Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530import { cleanupProbe, runCleanupTimeout, registerCleanupProbe,} from "./fixtures/native-cleanup-probe.mjs";import { NativeFixtureLifetime } from "./fixtures/native-fixture-lifetime.mjs";import { BridgeHttpDiagnostics } from "./fixtures/bridge-http-diagnostics.mjs";import * as Effect from "effect/Effect";import assert from "node:assert/strict";import { randomBytes, generateKeyPairSync, sign, createHash,} from "node:crypto";import { mkdtemp, readFile, writeFile, rm } from "node:fs/promises";import { createServer as netServer } from "node:net";import { createServer as httpsServer } from "node:https";import { request as httpRequest } from "node:http";import { execFileSync } from "node:child_process";import { tmpdir } from "node:os";import { join, resolve } from "node:path";import { test } from "node:test";import { unstable_dev } from "wrangler";import { chromium } from "playwright";import { parse } from "jsonc-parser";import { oauthBindings, oauthConfig } from "./fixtures/oauth-config.mjs";import { customerBindings } from "./fixtures/config.mjs";import { parseInstallationConfig } from "../configuration/customer.ts";import { parseControlPlaneConfig } from "../configuration/control-plane.ts";import { LOGIN_PURPOSE, HEALTH_PURPOSE, PROVIDER_PURPOSE, DOMAIN_CONFIGURATION_PURPOSE, DOMAIN_HEALTH_PURPOSE,} from "../shared/bridge.ts";import { verifyAssertion } from "../server/bridge.ts";
const id = () => randomBytes(32).toString("base64url");const pair = generateKeyPairSync("ed25519");const bridgeKey = { keyId: "fixture-key", publicKey: pair.publicKey.export({ format: "jwk" }).x,};const privateKey = pair.privateKey .export({ type: "pkcs8", format: "der" }) .toString("base64url");const I = "0123456789abcdef0123456789abcdef";const CP = "https://publisher.test";const CUSTOMER = `https://flarebot-${I}.bridgefixture.workers.dev`;const OWNER = "verified-userinfo-subject";const release = { version: "0.1.0-dev.1", artifactDigest: "d".repeat(64), operationId: "e".repeat(32),};const claims = { iss: CP, aud: CUSTOMER, sub: OWNER, installationId: I, purpose: LOGIN_PURPOSE, state: id(), challenge: id(),};function token( value, header = { alg: "EdDSA", kid: bridgeKey.keyId, typ: "JWT" }, key = pair.privateKey,) { const payload = [header, value] .map((v) => Buffer.from(JSON.stringify(v)).toString("base64url")) .join("."); return `${payload}.${sign(null, Buffer.from(payload), key).toString("base64url")}`;}test("pinned bridge assertion validates every exact claim and separates purposes", async () => { const now = Math.floor(Date.now() / 1000); const value = { ...claims, iat: now, exp: now + 60, jti: id() }; assert.deepEqual( await Effect.runPromise(verifyAssertion(token(value), bridgeKey, claims)), value, ); for (const field of [ "iss", "aud", "sub", "installationId", "purpose", "state", "challenge", ]) { await assert.rejects( Effect.runPromise( verifyAssertion( token({ ...value, [field]: "wrong" }), bridgeKey, claims, ), ), ); } // A future `iat` must be rejected, but `now` is recomputed inside // verifyAssertion. A one-second offset can be swallowed when the wall clock // advances between capture and verification, so use a margin that cannot. for (const change of [ { iat: now + 30 }, { exp: now }, { exp: now + 61 }, { jti: "short" }, { extra: "hidden" }, { iat: 1.1 }, { purpose: HEALTH_PURPOSE }, ]) await assert.rejects( Effect.runPromise( verifyAssertion(token({ ...value, ...change }), bridgeKey, claims), ), ); for (const header of [ { alg: "HS256", kid: bridgeKey.keyId, typ: "JWT" }, { alg: "EdDSA", kid: "rotated", typ: "JWT" }, { alg: "EdDSA", kid: bridgeKey.keyId, typ: "JWT", jwk: pair.publicKey.export({ format: "jwk" }), }, ]) await assert.rejects( Effect.runPromise( verifyAssertion(token(value, header), bridgeKey, claims), ), ); await assert.rejects( Effect.runPromise( verifyAssertion( token(value, undefined, generateKeyPairSync("ed25519").privateKey), bridgeKey, claims, ), ), );});test("bridge pins and deployment markers preserve strict secret-free configuration", () => { const installation = { schemaVersion: 1, installationId: I, ownerSubject: OWNER, runtimeOrigin: CUSTOMER, controlPlaneOrigin: CP, bridge: bridgeKey, release, }; assert.deepEqual(parseInstallationConfig(installation), installation); assert.deepEqual( parseControlPlaneConfig({ ...oauthConfig(CP), bridge: bridgeKey }).bridge, bridgeKey, ); for (const change of [ { bridge: { ...bridgeKey, privateKey } }, { bridge: { ...bridgeKey, keyId: "../key" } }, { bridge: { ...bridgeKey, publicKey: "short" } }, { release: { ...release, sessionSecret: "secret" } }, { release: { ...release, operationId: "not-an-operation" } }, { release: { ...release, artifactDigest: "bad" } }, ]) assert.throws(() => parseInstallationConfig({ ...installation, ...change }), ); assert.throws(() => parseControlPlaneConfig({ ...oauthConfig(CP), bridge: { ...bridgeKey, privateKey }, }), );});
async function freePort(lifetime) { const server = lifetime.own( "port reservation", netServer(), (server) => new Promise((resolve) => server.close(() => resolve())), ); await new Promise((done) => server.listen(0, "127.0.0.1", done)); const port = server.address().port; await new Promise((done) => server.close(done)); return port;}const cookie = (response, name) => response.headers .getSetCookie() .find((value) => value.startsWith(`${name}=`)) ?.split(";")[0];
test( "native two-site HTTPS owner login, atomic replay retention, encrypted operation and native health", { timeout: 360_000 }, async (t) => { const lifetime = new NativeFixtureLifetime(t, "bridge"); const temporary = await lifetime.start( "directory", () => mkdtemp(join(tmpdir(), "flarebot-bridge-")), (path) => rm(path, { recursive: true, force: true }), true, ); const cpPort = await freePort(lifetime), customerPort = await freePort(lifetime); const installation = { schemaVersion: 1, installationId: I, ownerSubject: OWNER, runtimeOrigin: CUSTOMER, controlPlaneOrigin: CP, bridge: bridgeKey, release, }; const config = oauthConfig(CP); config.bridge = bridgeKey; const cpBindings = { ...oauthBindings(CP), FLAREBOT_CONTROL_PLANE: JSON.stringify(config), FLAREBOT_BRIDGE_SIGNING_KEY: privateKey, TEST_CUSTOMER_PORT: String(customerPort), }; const baseCP = parse( await readFile("wrangler.control-plane.jsonc", "utf8"), ); const baseCustomer = parse(await readFile("wrangler.jsonc", "utf8")); const cpPath = join(temporary, "cp.json"), customerPath = join(temporary, "customer.json"); await writeFile( cpPath, JSON.stringify({ ...baseCP, name: "flarebot-bridge-cp", main: resolve("tests/fixtures/bridge-control-worker.ts"), assets: { directory: resolve("dist/control-plane/client"), binding: "ASSETS", }, }), ); await writeFile( customerPath, JSON.stringify({ ...baseCustomer, name: "flarebot-bridge-customer", main: resolve("tests/fixtures/bridge-customer-worker.ts"), assets: { directory: resolve("dist/client"), binding: "ASSETS" }, }), ); const options = (config, port, vars, containers = false) => ({ config, vars, local: true, ip: "127.0.0.1", port, inspectorPort: 0, persist: true, persistTo: join(temporary, String(port)), logLevel: "error", experimental: { disableExperimentalWarning: true, watch: false, enableContainers: containers, }, }); const startCP = () => lifetime.start( "control Worker", () => unstable_dev( "tests/fixtures/bridge-control-worker.ts", options(cpPath, cpPort, cpBindings), ), (worker) => worker.stop(), ); const startCustomer = () => lifetime.start( "customer Worker", () => unstable_dev( "tests/fixtures/bridge-customer-worker.ts", options( customerPath, customerPort, { ...customerBindings, FLAREBOT_INSTALLATION: JSON.stringify(installation), TEST_CP_PORT: String(cpPort), }, true, ), ), (worker) => worker.stop(), ); let cp, customer, browser, proxy; let mode = "normal", oauthVisits = 0; const visited = []; let holdHTTP = false; const responseHeld = Promise.withResolvers(); const httpDiagnostics = new BridgeHttpDiagnostics((facts) => t.diagnostic(`Native bridge HTTP failed: ${JSON.stringify(facts)}`), ); const nativeCall = (port, path, init = {}) => lifetime.wait( "native HTTP", new Promise((resolve, reject) => { lifetime.signal.throwIfAborted(); const body = init.body === undefined ? undefined : String(init.body); const req = httpRequest( { hostname: "127.0.0.1", port, path, method: init.method ?? "GET", signal: lifetime.signal, headers: { "Sec-Fetch-Mode": "navigate", ...init.headers }, }, (incoming) => { if (holdHTTP) { incoming.pause(); responseHeld.resolve(); return; } const chunks = []; incoming.on("data", (chunk) => chunks.push(chunk)); incoming.on("end", () => { const headers = new Headers(); for (let i = 0; i < incoming.rawHeaders.length; i += 2) headers.append( incoming.rawHeaders[i], incoming.rawHeaders[i + 1], ); resolve( new Response(Buffer.concat(chunks), { status: incoming.statusCode, headers, }), ); }); }, ); lifetime.own("HTTP request", req, (request) => request.destroy()); httpDiagnostics.watch( req, { role: port === cpPort ? "publisher" : "customer", path, method: init.method ?? "GET", }, reject, ); req.end(body); }), ); const callCP = (path, init = {}) => nativeCall(cpPort, path, init); const callCustomer = (path, init = {}) => nativeCall(customerPort, path, init); const post = (call, path, body, headers = {}) => call(path, { method: "POST", headers: { "Content-Type": "application/json", ...headers }, body: JSON.stringify(body), }); const now = Date.now(); const record = { schemaVersion: 1, installationId: I, ownerSubject: OWNER, accountId: "a".repeat(32), createdAt: now, updatedAt: now, revision: 3, resources: { workerName: `flarebot-${I}`, sandboxApplicationName: `flarebot-shell-${I}`, runtimeOrigin: CUSTOMER, personalAgentNamespaceId: "1".repeat(32), sandboxNamespaceId: "2".repeat(32), sandboxApplicationId: "3".repeat(32), }, desiredRelease: { version: release.version, artifactDigest: release.artifactDigest, sourceRevision: "4".repeat(40), }, installedRelease: { version: release.version, artifactDigest: release.artifactDigest, sourceRevision: "4".repeat(40), installedAt: now, }, status: "ready", errorCode: null, operationId: release.operationId, }; try { cp = await startCP(); customer = await startCustomer(); assert.equal( (await post(callCP, "/__bridge__/seed", record)).status, 200, ); // A real TLS reverse proxy preserves browser-origin, Cookie and WebSocket headers. execFileSync( "openssl", [ "req", "-x509", "-newkey", "rsa:2048", "-nodes", "-keyout", join(temporary, "key.pem"), "-out", join(temporary, "cert.pem"), "-days", "1", "-subj", "/CN=publisher.test", "-addext", `subjectAltName=DNS:publisher.test,DNS:${new URL(CUSTOMER).hostname}`, ], { stdio: "ignore" }, ); const target = (req) => req.headers.host === "publisher.test" ? cpPort : customerPort; const tls = { key: await readFile(join(temporary, "key.pem")), cert: await readFile(join(temporary, "cert.pem")), }; lifetime.signal.throwIfAborted(); proxy = httpsServer(tls, async (req, res) => { if (lifetime.signal.aborted) { res.destroy(); return; } if (req.headers.host === "dash.cloudflare.com") { const url = new URL(req.url, "https://dash.cloudflare.com"); if (url.pathname !== "/oauth2/auth") { res.writeHead(404); res.end(); return; } oauthVisits++; const code = id(); assert.equal(url.searchParams.get("code_challenge_method"), "S256"); await post(callCP, "/__test__/code", { code, challenge: url.searchParams.get("code_challenge"), mode, }); const callback = new URL(url.searchParams.get("redirect_uri")); callback.search = new URLSearchParams({ code, state: url.searchParams.get("state"), }); res.writeHead(303, { location: callback.href, "cache-control": "no-store", "referrer-policy": "no-referrer", }); res.end(); return; } const headers = { ...req.headers, "x-fixture-origin": `https://${req.headers.host}`, }; delete headers.host; const outgoing = httpRequest( { host: "127.0.0.1", port: target(req), path: req.url, method: req.method, signal: lifetime.signal, headers, }, (incoming) => { res.writeHead(incoming.statusCode, incoming.headers); incoming.pipe(res); }, ); lifetime.own("proxy HTTP request", outgoing, (request) => request.destroy(), ); outgoing.on("error", () => { if (!res.destroyed) { if (!res.headersSent) res.writeHead(502); res.end(); } }); req.pipe(outgoing); }); lifetime.own("HTTPS proxy", proxy, (server) => { server.closeAllConnections(); return new Promise((resolve) => server.close(() => resolve())); }); proxy.on("connection", (socket) => { if (lifetime.signal.aborted) socket.destroy(); else lifetime.own("proxy socket", socket, (socket) => socket.destroy()); }); proxy.on("upgrade", (req, socket, head) => { if (lifetime.signal.aborted) { socket.destroy(); return; } const headers = { ...req.headers, "x-fixture-origin": `https://${req.headers.host}`, }; delete headers.host; const outgoing = httpRequest({ host: "127.0.0.1", port: target(req), path: req.url, method: "GET", signal: lifetime.signal, headers, }); lifetime.own("proxy upgrade request", outgoing, (request) => request.destroy(), ); outgoing.on("upgrade", (incoming, upstream, upgradeHead) => { if (lifetime.signal.aborted) { upstream.destroy(); socket.destroy(); return; } lifetime.own("upgraded socket", upstream, (socket) => socket.destroy(), ); socket.write( `HTTP/1.1 101 Switching Protocols\r\n${incoming.rawHeaders.reduce((s, v, i) => s + (i % 2 ? `${v}\r\n` : `${v}: `), "")}\r\n`, ); if (head.length) upstream.write(head); if (upgradeHead.length) socket.write(upgradeHead); upstream.pipe(socket); socket.pipe(upstream); upstream.on("error", () => socket.destroy()); socket.on("error", () => upstream.destroy()); }); outgoing.on("response", (incoming) => { socket.end( `HTTP/1.1 ${incoming.statusCode} Denied\r\nConnection: close\r\n\r\n`, ); }); outgoing.on("error", () => socket.destroy()); outgoing.end(); }); await new Promise((done) => proxy.listen(0, "127.0.0.1", done)); const tlsPort = proxy.address().port; browser = await lifetime.start( "browser", () => chromium.launch({ headless: true, args: [ "--no-proxy-server", `--host-resolver-rules=MAP dash.cloudflare.com 127.0.0.1:${tlsPort}, MAP publisher.test 127.0.0.1:${tlsPort}, MAP ${new URL(CUSTOMER).hostname} 127.0.0.1:${tlsPort}`, ], }), (browser) => browser.close(), ); const context = await browser.newContext({ ignoreHTTPSErrors: true }); if (cleanupProbe === "bridge") { holdHTTP = true; const pending = callCustomer("/agents/personal-agent/personal"); void pending.catch(() => {}); await responseHeld.promise; await runCleanupTimeout(t, lifetime, pending); return; } context.on("request", (request) => { if (request.isNavigationRequest()) visited.push(request.url()); }); const page = await context.newPage(); page.on("response", (r) => { if (new URL(r.url()).pathname.startsWith("/auth/")) console.log( "Bridge navigation", new URL(r.url()).host, new URL(r.url()).pathname, r.status(), ); }); await page.goto(`${CUSTOMER}/auth/login`); assert.equal(new URL(page.url()).pathname, "/"); assert.equal( oauthVisits, 1, "fresh OAuth continuation completed on a distinct site", ); const cookies = await context.cookies(); const ownerCookie = cookies.find( (c) => c.name === "__Host-flarebot-session", ); assert.ok( ownerCookie?.httpOnly && ownerCookie.secure && ownerCookie.sameSite === "Lax", ); assert.ok( cookies.find((c) => c.name === "__Host-flarebot-control-session") ?.httpOnly, ); assert.ok(!cookies.some((c) => c.name === "__Host-flarebot-login")); assert.ok( !visited.some( (url) => url.includes("assertion") || url.includes("oauth-secret") || url.includes("verifier"), ), ); const callback = visited.find((url) => url.startsWith(`${CUSTOMER}/auth/callback`), ); assert.ok(callback); assert.equal( ( await callCustomer( new URL(callback).pathname + new URL(callback).search, ) ).status, 403, ); assert.equal( await page.evaluate( async () => (await fetch("/agents/personal-agent/personal")).status, ), 200, ); const cpCookie = cookies.find( (c) => c.name === "__Host-flarebot-control-session", ); const inspected = await ( await callCP("/__test__/inspect", { headers: { Cookie: `${cpCookie.name}=${cpCookie.value}` }, }) ).json(); await post(callCP, "/__test__/expire", { kind: "grant", ref: inspected.principal.grantRef, }); await context.clearCookies({ name: "__Host-flarebot-session" }); await page.goto(`${CUSTOMER}/auth/login`); assert.equal(new URL(page.url()).pathname, "/"); assert.equal( oauthVisits, 1, "identity-only login succeeds after deployment grant expires", ); // Native owner socket works; server-only methods remain inaccessible to browser RPC. const rpc = await page.evaluate(async () => { const ws = new WebSocket( `${location.origin.replace("https:", "wss:")}/agents/personal-agent/personal`, ); const replies = {}; return new Promise((resolve, reject) => { const timeout = setTimeout(() => { ws.close(); reject(new Error("Socket timeout")); }, 15000); ws.onopen = () => { for (const [id, method] of [ ["public", "getRuntimeInfo"], ["private", "createLoginChallenge"], ["health", "bootstrapHealth"], ["save", "setProviderKey"], ["enable", "enableOpenRouter"], ["disabled", "updateModelSettings"], ]) ws.send( JSON.stringify({ type: "rpc", id, method, args: id === "save" ? ["anthropic", "sk-ant-fixture-preserved-key-sentinel"] : id === "disabled" ? [ { provider: "openrouter", model: "openai/gpt-5.6-luna", }, ] : [], }), ); }; ws.onmessage = (event) => { const frame = JSON.parse(event.data); if ( [ "public", "private", "health", "save", "enable", "disabled", ].includes(frame.id) ) { replies[frame.id] = frame; if (Object.keys(replies).length === 6) { clearTimeout(timeout); ws.close(); resolve(replies); } } }; ws.onerror = () => reject(new Error("Socket denied")); }); }); assert.ok(rpc.public.success); assert.equal(rpc.private.success, false); assert.equal(rpc.health.success, false); assert.ok(rpc.save.success); assert.equal( rpc.enable.success, false, "browser RPC cannot enable a provider", ); assert.equal( rpc.disabled.success, false, "model selection requires enablement", ); const providerEndpoint = `/api/installations/${I}/providers/openrouter`; assert.equal((await callCP(providerEndpoint)).status, 401); assert.equal( (await callCP(providerEndpoint, { method: "POST" })).status, 403, ); assert.equal( ( await callCP(providerEndpoint, { method: "POST", headers: { Origin: CP, Cookie: `${cpCookie.name}=${cpCookie.value}`, "Content-Type": "application/x-www-form-urlencoded", }, body: "", }) ).status, 401, "expired deployment grants require reconnect", ); const enabled = async () => (await (await callCustomer("/__bridge__/inspect")).json()).models .providers["openrouter"]; assert.equal(await enabled(), false); const receiptTime = Math.floor(Date.now() / 1000); const receipt = { ...claims, purpose: PROVIDER_PURPOSE, state: "openrouter", challenge: "enabled", iat: receiptTime, exp: receiptTime + 60, jti: id(), }; for (const change of [ { sub: "wrong-owner" }, { aud: "https://other.example" }, { purpose: LOGIN_PURPOSE }, { state: "opencode-go" }, { exp: receiptTime - 1 }, ]) { assert.equal( ( await callCustomer("/auth/provider-enabled", { method: "POST", headers: { Authorization: `Bearer ${token({ ...receipt, ...change })}`, }, }) ).status, 403, ); } assert.equal( await enabled(), false, "invalid receipts never enable a provider", ); const setupContext = await browser.newContext({ ignoreHTTPSErrors: true, }); await setupContext.addCookies( (await context.cookies()).filter( (c) => c.name === "__Host-flarebot-session", ), ); const setupPage = await setupContext.newPage(); const setupErrors = []; setupPage.on("pageerror", (error) => setupErrors.push(error.message)); await setupPage.goto(`${CUSTOMER}/settings`); const chooseOpenRouter = async () => { await setupPage .getByRole("combobox", { name: "Provider", exact: true }) .click(); await setupPage .getByRole("option", { name: "OpenRouter", exact: true }) .click(); }; await chooseOpenRouter(); await setupPage .getByRole("link", { name: "Enable OpenRouter", exact: true }) .click(); await setupPage .getByRole("button", { name: "Reconnect Cloudflare" }) .click(); await setupPage .getByRole("button", { name: "Enable OpenRouter", exact: true }) .waitFor() .catch(async (error) => { throw new Error( `${error.message}\nPage errors: ${JSON.stringify(setupErrors)}\nProvider setup: ${await setupPage.locator("body").innerText()}`, ); }); assert.equal( new URL(setupPage.url()).searchParams.get("installationId"), I, ); assert.equal(await enabled(), false, "GET and reconnect do not enable"); let providerCommands = 0; setupPage.on("request", (request) => { if ( request.url() === CP + providerEndpoint && request.method() === "POST" ) providerCommands++; }); await setupPage.route(CP + providerEndpoint, (route) => route.request().method() === "GET" ? route.abort("failed") : route.continue(), ); try { await setupPage.clock.setFixedTime(Date.now() + 31_000); await setupPage.evaluate(() => window.dispatchEvent(new Event("focus")), ); await setupPage .getByRole("alert") .filter({ hasText: "temporarily unavailable" }) .waitFor(); assert.equal( await setupPage .getByRole("button", { name: "Enable OpenRouter", exact: true }) .isVisible(), true, "A failed background read retains the verified installation", ); } finally { await setupPage.unrouteAll({ behavior: "wait" }); } await setupPage .getByRole("button", { name: "Retry", exact: true }) .click(); await setupPage .getByRole("alert") .filter({ hasText: "temporarily unavailable" }) .waitFor({ state: "hidden" }); assert.equal(providerCommands, 0, "Read retries never enable providers"); assert.equal(await enabled(), false); await setupPage.screenshot({ path: "/tmp/flarebot-openrouter-setup.png", fullPage: true, }); await post(callCP, "/__bridge__/provider", { failNotification: true }); await setupPage .getByRole("button", { name: "Enable OpenRouter", exact: true }) .click(); await setupPage .getByRole("alert") .filter({ hasText: "temporarily unavailable" }) .waitFor(); assert.equal( await enabled(), false, "runtime acknowledgment is required", ); await setupPage.screenshot({ path: "/tmp/flarebot-openrouter-setup-error.png", fullPage: true, }); await post(callCP, "/__bridge__/provider", { failNotification: false }); await setupPage .getByRole("button", { name: "Retry", exact: true }) .click(); await setupPage.waitForURL(`${CUSTOMER}/settings`); assert.equal(await enabled(), true); await chooseOpenRouter(); await setupPage .getByText("OpenRouter is enabled for this installation.", { exact: true, }) .waitFor(); assert.equal( await setupPage .getByRole("link", { name: "Enable OpenRouter", exact: true }) .count(), 0, ); assert.equal( await setupPage.getByLabel("API key", { exact: true }).isEnabled(), true, ); await setupPage.setViewportSize({ width: 1280, height: 1600 }); await setupPage .locator("section[aria-labelledby='model-heading']") .screenshot({ path: "/tmp/flarebot-openrouter-enabled.png" }); await setupPage .locator("section[aria-labelledby='domain-heading']") .screenshot({ path: "/tmp/flarebot-domain-settings.png" }); assert.ok( !visited.some( (url) => url.includes("assertion") || url.includes("oauth-secret"), ), ); await setupContext.close(); const cpIdentity = { Cookie: `${cpCookie.name}=${cpCookie.value}` }; // The custom hostname is a separate browser origin, not a cookie alias. { const customOrigin = "https://bot.example.com"; const domain = await ( await post(callCP, "/__bridge__/domain", { owner: OWNER, id: I }) ).json(); const domainToken = (revision, origin, changes = {}) => token({ ...claims, purpose: DOMAIN_CONFIGURATION_PURPOSE, state: String(revision), challenge: origin ?? "", iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 60, jti: id(), ...changes, }); const configure = (signed) => callCustomer("/auth/domain-configuration", { method: "POST", headers: { Authorization: `Bearer ${signed}` }, }); for (const changes of [ { sub: "not-owner" }, { aud: customOrigin }, { purpose: LOGIN_PURPOSE }, ]) assert.equal( ( await configure( domainToken(domain.revision, customOrigin, changes), ) ).status, 403, ); const configured = domainToken(domain.revision, customOrigin); assert.deepEqual(await (await configure(configured)).json(), { revision: domain.revision, origin: customOrigin, }); assert.equal( (await configure(configured)).status, 200, "same signed revision is idempotent", ); assert.equal( ( await configure( domainToken(domain.revision, "https://other.example.com"), ) ).status, 403, ); const customHeaders = { "x-fixture-origin": customOrigin }; const customBegin = await callCustomer("/auth/login", { headers: customHeaders, }); assert.equal(customBegin.status, 303); const customDestination = new URL(customBegin.headers.get("location")); assert.equal( customDestination.searchParams.get("audience"), customOrigin, ); const customCode = await callCP( customDestination.pathname + customDestination.search, { headers: cpIdentity }, ); assert.equal(customCode.status, 303); const customCallback = new URL(customCode.headers.get("location")); assert.equal(customCallback.origin, customOrigin); const loginCookie = cookie(customBegin, "__Host-flarebot-login"); assert.equal( ( await callCustomer( customCallback.pathname + customCallback.search, { headers: { Cookie: loginCookie }, }, ) ).status, 403, "challenge cannot be consumed on workers.dev", ); const customSession = await callCustomer( customCallback.pathname + customCallback.search, { headers: { ...customHeaders, Cookie: loginCookie } }, ); assert.equal(customSession.status, 303); const ownerCookie = cookie(customSession, "__Host-flarebot-session"); assert.ok(ownerCookie); assert.equal( ( await callCustomer("/api/domain", { headers: { ...customHeaders, Cookie: ownerCookie }, }) ).status, 200, ); assert.equal( ( await callCustomer("/api/domain", { headers: { Cookie: ownerCookie }, }) ).status, 401, "sessions cannot cross approved origins", ); assert.equal( ( await callCustomer("/api/domain", { headers: { ...customHeaders, Cookie: ownerCookie, Origin: CUSTOMER, }, }) ).status, 403, ); const forgedDestination = new URL(customDestination); forgedDestination.searchParams.set( "audience", "https://attacker.example", ); assert.equal( ( await callCP( forgedDestination.pathname + forgedDestination.search, { headers: cpIdentity, }, ) ).status, 403, ); const probeClaims = { ...claims, purpose: DOMAIN_HEALTH_PURPOSE, aud: customOrigin, iat: Math.floor(Date.now() / 1000), exp: Math.floor(Date.now() / 1000) + 60, jti: id(), }; const health = await callCustomer("/auth/domain-health", { method: "POST", headers: { ...customHeaders, Authorization: `Bearer ${token(probeClaims)}`, }, }); assert.deepEqual(await health.json(), { installationId: I, origin: customOrigin, state: claims.state, challenge: claims.challenge, }); await lifetime.release(customer); customer = await startCustomer(); assert.equal( ( await callCustomer("/api/domain", { headers: { ...customHeaders, Cookie: ownerCookie }, }) ).status, 200, "custom domain survives native restart", ); const removedDomain = await ( await post(callCP, "/__bridge__/domain", { owner: OWNER, id: I, remove: true, }) ).json(); assert.equal( (await configure(domainToken(removedDomain.revision, null))).status, 200, ); assert.equal( (await configure(configured)).status, 403, "stale receipt cannot resurrect removed domain", ); assert.equal( ( await callCustomer("/api/domain", { headers: { ...customHeaders, Cookie: ownerCookie }, }) ).status, 403, ); assert.equal( ( await callCP( customDestination.pathname + customDestination.search, { headers: cpIdentity, }, ) ).status, 403, "removed origin cannot receive login codes", ); } async function pendingLogin() { const begin = await callCustomer("/auth/login"); assert.equal(begin.status, 303); assert.equal(begin.headers.get("referrer-policy"), "no-referrer"); assert.equal(begin.headers.get("cache-control"), "no-store"); const destination = new URL(begin.headers.get("location")); const issued = await callCP(destination.pathname + destination.search, { headers: cpIdentity, }); assert.equal(issued.status, 303); assert.match( issued.headers.get("content-security-policy"), /form-action 'self' https:\/\/dash.cloudflare.com/, ); const callback = new URL(issued.headers.get("location")); const saved = ( await (await callCustomer("/__bridge__/inspect")).json() ).challenges.find( (row) => row.state === callback.searchParams.get("state"), ); return { callback, saved, binding: cookie(begin, "__Host-flarebot-login"), }; } const first = await pendingLogin(); const callbackPath = (item) => item.callback.pathname + item.callback.search; assert.equal( ( await callCustomer(callbackPath(first), { headers: { Cookie: "__Host-flarebot-login=" + id() }, }) ).status, 403, ); assert.equal( ( await callCustomer(callbackPath(first) + "&state=" + id(), { headers: { Cookie: first.binding }, }) ).status, 403, ); const callbackRace = await Promise.all( Array.from({ length: 8 }, () => callCustomer(callbackPath(first), { headers: { Cookie: first.binding }, }), ), ); assert.equal( callbackRace.filter((r) => r.status === 303).length, 1, "one concurrent callback issues a cookie", ); const expired = await pendingLogin(); await post(callCustomer, "/__bridge__/expire", {}); assert.equal( ( await callCustomer(callbackPath(expired), { headers: { Cookie: expired.binding }, }) ).status, 403, ); const lost = await pendingLogin(); await post(callCustomer, "/__bridge__/exchange-mode", { mode: "lost" }); assert.equal( ( await callCustomer(callbackPath(lost), { headers: { Cookie: lost.binding }, }) ).status, 403, ); assert.equal( ( await callCustomer(callbackPath(lost), { headers: { Cookie: lost.binding }, }) ).status, 403, "lost exchange never reopens local challenge", ); const direct = await pendingLogin(); const exchangeBody = { code: direct.callback.searchParams.get("code"), verifier: direct.saved.verifier, installationId: I, audience: CUSTOMER, state: direct.saved.state, }; const exchange = (body) => callCP("/auth/bridge/exchange", { method: "POST", headers: { "Content-Type": "application/x-www-form-urlencoded" }, body: new URLSearchParams(body), }); for (const change of [ { verifier: id() }, { audience: "https://other.example" }, { installationId: "f".repeat(32) }, { state: id() }, ]) assert.equal( (await exchange({ ...exchangeBody, ...change })).status, 403, ); const codeRace = await Promise.all( Array.from({ length: 8 }, () => exchange(exchangeBody)), ); assert.equal( codeRace.filter((r) => r.status === 200).length, 1, "one concurrent PKCE exchange consumes a code", ); assert.equal((await exchange(exchangeBody)).status, 403); const expiredCode = await pendingLogin(); await post(callCP, "/__test__/expire", { kind: "code", ref: createHash("sha256") .update(expiredCode.callback.searchParams.get("code")) .digest("base64url"), }); assert.equal( ( await callCustomer(callbackPath(expiredCode), { headers: { Cookie: expiredCode.binding }, }) ).status, 403, ); const wrong = await browser.newContext({ ignoreHTTPSErrors: true }); mode = "second-owner"; const wrongPage = await wrong.newPage(); await wrongPage.goto(`${CUSTOMER}/auth/login`); await wrongPage.waitForURL(`${CP}/connect?error=forbidden`); assert.ok( !(await wrong.cookies()).some( (c) => c.name === "__Host-flarebot-session", ), ); await wrong.close(); // Parallel native SQLite claims have one winner and survive a Worker restart. const challenge = { state: id(), bindingHash: id(), verifier: id(), challenge: id(), expiresAt: Date.now() + 600_000, }; assert.equal( (await post(callCustomer, "/__bridge__/create", challenge)).status, 200, ); const claimed = await Promise.all( Array.from({ length: 8 }, () => post(callCustomer, "/__bridge__/claim", challenge).then((r) => r.json(), ), ), ); assert.equal(claimed.filter(Boolean).length, 1); await lifetime.release(customer); customer = await startCustomer(); assert.equal( await enabled(), true, "provider enablement survives native restart", ); assert.equal( await (await post(callCustomer, "/__bridge__/claim", challenge)).json(), null, ); assert.equal( await (await callCustomer("/__bridge__/key-survived")).json(), true, "encrypted provider key survives unchanged session secret and native restart", ); await post(callCustomer, "/__bridge__/expire", {}); for (let i = 0; i < 128; i++) assert.equal( ( await post(callCustomer, "/__bridge__/create", { ...challenge, state: id(), }) ).status, 200, ); assert.equal( ( await post(callCustomer, "/__bridge__/create", { ...challenge, state: id(), }) ).status, 429, ); await post(callCustomer, "/__bridge__/expire", {}); assert.equal( ( await post(callCustomer, "/__bridge__/create", { ...challenge, state: id(), }) ).status, 200, ); assert.equal( (await (await callCustomer("/__bridge__/inspect")).json()).challenges .length, 1, ); // Encrypted bootstrap create/replay preserves the original secret across restart. const operation = { subject: OWNER, accountId: "a".repeat(32), installationId: I, operationId: "9".repeat(32), grantRef: id(), expiresAt: Date.now() + 120000, bootstrapSecret: id(), }; const expected = Object.fromEntries( ["subject", "accountId", "installationId", "operationId"].map((k) => [ k, operation[k], ]), ); await post(callCP, "/__bridge__/operation", { action: "grant", value: operation, grantExpiresAt: operation.expiresAt + 1000, }); assert.deepEqual( await ( await post(callCP, "/__bridge__/operation", { action: "create", value: operation, }) ).json(), operation, ); await lifetime.release(cp); cp = await startCP(); assert.deepEqual( await ( await post(callCP, "/__bridge__/operation", { action: "create", value: { ...operation, bootstrapSecret: id() }, }) ).json(), operation, ); assert.equal( (await exchange(exchangeBody)).status, 403, "consumed code survives native CP restart", ); assert.equal( ( await post(callCP, "/__bridge__/operation", { action: "create", value: { ...operation, accountId: "b".repeat(32) }, }) ).status, 409, ); assert.equal( await ( await post(callCP, "/__bridge__/operation", { action: "get", expected: { ...expected, subject: "other" }, }) ).json(), null, ); assert.equal( await ( await post(callCP, "/__bridge__/operation", { action: "retire", expected, }) ).json(), true, ); assert.equal( ( await ( await post(callCP, "/__bridge__/operation", { action: "get", expected, }) ).json() ).bootstrapSecret, null, ); // Signed metadata-only health exercises actual native Sandbox launch and destroy. const healthClaims = { aud: CUSTOMER, sub: OWNER, installationId: I, purpose: HEALTH_PURPOSE, state: id(), challenge: id(), ...release, }; const signHealth = async () => ( await ( await post(callCP, "/__bridge__/sign", { ...healthClaims, state: id(), challenge: id(), }) ).json() ).assertion; const assertion = await signHealth(); const health = await callCustomer("/auth/bootstrap-health", { method: "POST", headers: { Authorization: `Bearer ${assertion}` }, }); assert.equal(health.status, 200, await health.clone().text()); assert.equal( (await post(callCP, "/__bridge__/health", record)).status, 200, "production CP helper verifies native runtime health", ); assert.equal( ( await post(callCP, "/__bridge__/health", { ...record, operationId: "f".repeat(32), }) ).status, 403, ); const ready = await health.json(); assert.equal(ready.sandbox, "booted-and-destroyed"); assert.equal(ready.nativeParent, "ready"); assert.ok(!JSON.stringify(ready).includes("stdout")); assert.equal( ( await callCustomer("/auth/bootstrap-health", { method: "POST", headers: { Authorization: `Bearer ${assertion}` }, }) ).status, 403, ); const state = await (await callCustomer("/__bridge__/inspect")).json(); assert.equal(state.probes.length, 1); assert.equal(state.probes[0].status, "complete"); assert.equal(state.conversations.length, 0); await lifetime.release(customer); customer = await startCustomer(); assert.equal( ( await callCustomer("/auth/bootstrap-health", { method: "POST", headers: { Authorization: `Bearer ${assertion}` }, }) ).status, 403, ); assert.equal( ( await callCustomer("/auth/bootstrap-health", { method: "POST", headers: { Authorization: `Bearer ${await signHealth()}` }, }) ).status, 200, ); assert.equal( (await (await callCustomer("/__bridge__/inspect")).json()).probes .length, 1, "lost health reply reconciles completed probe", ); assert.equal( (await callCustomer("/agents/personal-agent/personal")).status, 401, ); lifetime.complete(); } finally { await lifetime.cleanup(); } },);
registerCleanupProbe(import.meta.url, "bridge");