Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
JavaScript
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653import assert from "node:assert/strict";import { randomBytes } from "node:crypto";import { mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";import { createServer } from "node:net";import { tmpdir } from "node:os";import { join, resolve } from "node:path";import { test } from "node:test";import { unstable_dev } from "wrangler";import { parse } from "jsonc-parser";import { oauthBindings, oauthConfig } from "./fixtures/oauth-config.mjs";import { parseInstallation } from "../control-plane/installation-metadata.ts";import "./fixtures/config.mjs";
const A = "a".repeat(32), B = "b".repeat(32);const id = () => randomBytes(16).toString("hex");const release = (digit = "1") => ({ version: `0.1.0-dev.${digit}`, sourceRevision: digit.repeat(40), artifactDigest: digit.repeat(64),});const setCookie = (response, name) => response.headers .getSetCookie() .find((v) => v.startsWith(`${name}=`)) ?.split(";")[0];async function freePort() { const server = createServer(); await new Promise((done) => server.listen(0, "127.0.0.1", done)); const { port } = server.address(); await new Promise((done) => server.close(done)); return port;}
test( "native ownership registry isolates owners and preserves atomic metadata across replay and restart", { timeout: 120_000 }, async (t) => { const temporary = await mkdtemp(join(tmpdir(), "flarebot-ownership-")); const port = await freePort(); const origin = `http://127.0.0.1:${port}`; const configPath = join(temporary, "wrangler.json"); // Production routes rewrite the request host in Miniflare. These direct // localhost requests must retain the fixture's configured origin instead. const { routes: _productionRoutes, workers_dev: _productionWorkersDev, ...base } = parse(await readFile("wrangler.control-plane.jsonc", "utf8")); await writeFile( configPath, JSON.stringify({ ...base, name: "flarebot-ownership-test", main: resolve("tests/fixtures/ownership-worker.ts"), assets: { directory: resolve("dist/control-plane/client"), binding: "ASSETS", }, }), ); let bindings = oauthBindings(origin); const start = () => unstable_dev("tests/fixtures/ownership-worker.ts", { config: configPath, vars: bindings, local: true, ip: "127.0.0.1", port, inspectorPort: 0, persist: true, persistTo: temporary, logLevel: "error", experimental: { disableExperimentalWarning: true, watch: false }, }); let worker; t.after(async () => { await worker?.stop(); await rm(temporary, { recursive: true, force: true }); }); const logs = []; for (const method of ["log", "warn", "error"]) { const original = console[method]; t.mock.method(console, method, (...args) => { logs.push(args.map(String).join(" ")); original(...args); }); } const call = (path, options = {}) => fetch(`${origin}${path}`, { redirect: "manual", ...options, headers: { Origin: origin, ...options.headers }, }); const admin = async (path, body = {}, cookie = "") => ( await call(`/__test__/${path}`, { method: "POST", headers: { Cookie: cookie, "Content-Type": "application/json" }, body: JSON.stringify(body), }) ).json(); const form = (path, cookie, values, headers = {}) => call(path, { method: "POST", headers: { Cookie: cookie, "Content-Type": "application/x-www-form-urlencoded", ...headers, }, body: new URLSearchParams(values).toString(), }); async function login(mode = "normal") { const start = await form("/auth/start", "", {}); const location = new URL(start.headers.get("Location")); const code = id(); await admin("code", { code, challenge: location.searchParams.get("code_challenge"), mode, }); const callback = await call( `/auth/callback?state=${location.searchParams.get("state")}&code=${code}`, { headers: { Cookie: setCookie(start, "__Host-flarebot-oauth") } }, ); assert.equal(callback.headers.get("Location"), "/connect"); return setCookie(callback, "__Host-flarebot-control-session"); } const select = (cookie, accountId) => form("/api/account", cookie, { accountId }); const reserve = (cookie, requestId = id()) => form("/api/installations", cookie, { requestId }); const get = (cookie, installationId) => call(`/api/installations/${installationId}`, { headers: { Cookie: cookie }, }); const list = (cookie, query = "") => call(`/api/installations${query}`, { headers: { Cookie: cookie } }); const update = (cookie, record, changes, revision = record.revision) => admin( "metadata/update", { id: record.installationId, revision, changes }, cookie, ); const inspect = (cookie) => admin("metadata/inspect", {}, cookie); worker = await start(); const first = await login(); const second = await login("second-owner"); let record; const requestId = id();
await t.test( "real verified identity/account and strict browser mutation boundary", async () => { assert.equal((await reserve("")).status, 401); assert.equal((await list("")).status, 401); assert.equal((await reserve(first)).status, 400); // no selected account assert.equal((await select(first, A)).status, 200); assert.equal((await select(second, B)).status, 200); for (const field of [ "ownerSubject", "accountId", "desiredRelease", "accessToken", "messages", "runtimeOrigin", "installedRelease", "grantRef", ]) { const response = await form("/api/installations", first, { requestId, [field]: "private-content-sentinel", }); assert.equal(response.status, 400, field); } for (const values of [ [ ["requestId", requestId], ["requestId", id()], ], { requestId: "private-content-sentinel" }, { requestId: "a".repeat(3000) }, ]) assert.equal( (await form("/api/installations", first, values)).status, 400, ); for (const Origin of ["", "null", "https://evil.example"]) assert.equal( (await form("/api/installations", first, { requestId }, { Origin })) .status, 403, ); assert.equal( ( await call("/api/installations", { method: "POST", headers: { Cookie: first, "Content-Type": "application/json" }, body: JSON.stringify({ requestId }), }) ).status, 400, ); assert.deepEqual(await inspect(first), {}); const response = await reserve(first, requestId); assert.equal(response.status, 200); assert.equal(response.headers.get("Cache-Control"), "no-store"); assert.equal(response.headers.get("Referrer-Policy"), "no-referrer"); record = (await response.json()).installation; assert.match(record.installationId, /^[a-f0-9]{32}$/); assert.equal(record.ownerSubject, "verified-userinfo-subject"); assert.equal(record.accountId, A); assert.equal(record.status, "reserved"); assert.equal(record.desiredRelease, null); assert.equal(record.installedRelease, null); assert.equal(record.resources.runtimeOrigin, null); assert.equal( record.resources.workerName, `flarebot-${record.installationId}`, ); assert.equal( record.resources.sandboxApplicationName, `flarebot-shell-${record.installationId}`, ); assert.deepEqual(parseInstallation(record), record); }, );
await t.test( "concurrent duplicate and lost reply replay, account conflict and owner isolation", async () => { const responses = await Promise.all( Array.from({ length: 12 }, () => reserve(first, requestId)), ); for (const response of responses) assert.deepEqual((await response.json()).installation, record); const ignored = id(); await reserve(first, ignored); // caller lost/ignored successful reply const retried = (await (await reserve(first, ignored)).json()) .installation; assert.notEqual(retried.installationId, record.installationId); assert.equal( (await (await list(first)).json()).installations.length, 2, ); assert.equal((await select(first, B)).status, 200); assert.equal((await reserve(first, requestId)).status, 409); const otherAccount = (await (await reserve(first)).json()).installation; assert.equal(otherAccount.accountId, B); assert.equal((await select(first, A)).status, 200); const otherOwner = (await (await reserve(second, requestId)).json()) .installation; assert.notEqual(otherOwner.installationId, record.installationId); assert.equal((await get(second, record.installationId)).status, 404); assert.deepEqual( await (await get(second, record.installationId)).json(), await (await get(second, id())).json(), ); assert.deepEqual((await (await list(second)).json()).installations, [ otherOwner, ]); assert.equal( ( await update(second, record, { status: "installing", desiredRelease: release(), operationId: id(), }) ).error, "installation_not_found", ); assert.deepEqual( await admin( "metadata/wrong-owner", { subject: otherOwner.ownerSubject, id: record.installationId }, first, ), { ok: false, error: "installation_not_found" }, ); assert.deepEqual(await admin("metadata/private-rpc", {}, first), { exposed: false, }); assert.equal( ( await call(`/api/installations/${record.installationId}`, { method: "PATCH", headers: { Cookie: first }, body: "{}", }) ).status, 404, ); assert.equal( ( await call("/agents/installation-registry/personal", { headers: { Cookie: first }, }) ).status, 404, ); }, );
await t.test( "withdrawn account access blocks reservation but preserves identity reads", async () => { const before = await inspect(first); for (const mode of ["denied", "empty"]) { await admin("accounts", { mode }); const response = await reserve(first); assert.equal(response.status, 400); assert.equal((await response.json()).error, "account_denied"); assert.deepEqual(await inspect(first), before); assert.equal((await get(first, record.installationId)).status, 200); assert.equal((await list(first)).status, 200); } await admin("accounts", { mode: "normal" }); }, );
await t.test( "private CAS pins desired release, assigns resource identity and preserves verified installed release", async () => { const start = { status: "installing", operationId: id(), desiredRelease: release(), }; for (const changes of [ { ...start, ownerSubject: "forged" }, { ...start, accountId: B }, { ...start, resources: { workerName: "another-worker" } }, { ...start, desiredRelease: { ...release(), accessToken: "oauth-secret-sentinel", }, }, { ...start, resources: { sandboxNamespaceId: A, memories: "private-content-sentinel", }, }, { ...start, installedRelease: { ...release(), installedAt: Date.now() }, }, { ...start, errorCode: "private-provider-error" }, { ...start, grantRef: id() }, { ...start, progress: "provider-private-error" }, { ...start, progress: { accessToken: "secret" } }, { ...start, progress: "complete" }, ]) assert.equal( (await update(first, record, changes)).error, "invalid_metadata", ); assert.deepEqual( (await (await get(first, record.installationId)).json()).installation, record, ); const racers = await Promise.all([ update(first, record, start), update(first, record, start), ]); assert.equal(racers.filter((r) => r.ok).length, 1); assert.equal(racers.find((r) => !r.ok).error, "installation_conflict"); const original = record; record = racers.find((r) => r.ok).value; assert.equal(record.revision, original.revision + 1); assert.equal(record.installedRelease, null); assert.equal( (await update(first, original, start)).error, "installation_conflict", ); assert.equal( (await update(first, record, { desiredRelease: release("2") })).error, "installation_conflict", ); assert.equal( (await update(first, record, { operationId: id() })).error, "installation_conflict", ); assert.equal( (await update(first, record, { status: "ready" })).error, "invalid_metadata", ); assert.equal( ( await update(first, record, { resources: { runtimeOrigin: "https://evil.example" }, }) ).error, "invalid_metadata", ); record = ( await update(first, record, { resources: { personalAgentNamespaceId: A, sandboxNamespaceId: B, sandboxApplicationId: "01234567-89ab-cdef-0123-456789abcdef", runtimeOrigin: `https://flarebot-${record.installationId}.customer.workers.dev`, }, }) ).value; for (const [key, value] of Object.entries(record.resources).filter( ([key]) => !key.endsWith("Name"), )) { assert.equal( (await update(first, record, { resources: { [key]: null } })).error, "installation_conflict", ); assert.equal( ( await update(first, record, { resources: { [key]: key === "runtimeOrigin" ? `https://flarebot-${record.installationId}.other.workers.dev` : "c".repeat(32), }, }) ).error, "installation_conflict", ); } record = (await update(first, record, { status: "ready" })).value; assert.equal(record.status, "ready"); assert.equal(record.progress, "complete"); assert.deepEqual(record.installedRelease, { ...release(), installedAt: record.updatedAt, }); const installed = record.installedRelease; record = ( await update(first, record, { status: "updating", operationId: id(), desiredRelease: release("2"), }) ).value; assert.deepEqual(record.installedRelease, installed); assert.equal(record.progress, "preparing"); record = ( await update(first, record, { status: "failed", errorCode: "health_failed", }) ).value; assert.deepEqual(record.installedRelease, installed); assert.equal(record.desiredRelease.version, "0.1.0-dev.2"); assert.equal(record.progress, "preparing"); record = ( await update(first, record, { status: "updating", operationId: id(), desiredRelease: release("2"), }) ).value; assert.equal(record.errorCode, null); record = (await update(first, record, { status: "ready" })).value; assert.equal(record.installedRelease.version, "0.1.0-dev.2"); assert.deepEqual( (await (await reserve(first, requestId)).json()).installation, record, ); }, );
await t.test( "recursive storage/export allowlist rejects corrupted fields without disclosing content", async () => { for (const invalid of [ { ...record, conversations: "private-content-sentinel" }, { ...record, resources: { ...record.resources, accessToken: "oauth-secret-sentinel", }, }, { ...record, desiredRelease: { ...record.desiredRelease, rawError: "private-provider-error", }, }, { ...record, installedRelease: { ...record.installedRelease, modelKey: "private-model-key-sentinel", }, }, ]) { assert.throws(() => parseInstallation(invalid), /invalid_metadata/); await admin( "metadata/put", { id: record.installationId, value: invalid }, first, ); for (const response of [ await get(first, record.installationId), await list(first), ]) { assert.equal(response.status, 400); const body = await response.text(); assert.ok(!body.includes("sentinel")); assert.ok(!body.includes("private-provider-error")); } await admin( "metadata/put", { id: record.installationId, value: record }, first, ); } const snapshot = JSON.stringify(await inspect(first)); for (const marker of [ "oauth-secret-sentinel", "private-content-sentinel", "private-model-key-sentinel", "private-provider-error", "grantRef", "accessToken", "messages", "modelKey", ]) assert.ok(!snapshot.includes(marker), marker); assert.ok( Object.keys(await inspect(first)).every((key) => /^(installation|request):[a-f0-9]{32}$/.test(key), ), ); }, );
await t.test( "plural owner listing is bounded and uses validated exclusive cursors", async () => { await Promise.all(Array.from({ length: 49 }, () => reserve(first))); const one = await (await list(first)).json(); assert.equal(one.installations.length, 50); assert.match(one.nextCursor, /^[a-f0-9]{32}$/); const two = await ( await list(first, `?cursor=${one.nextCursor}`) ).json(); assert.equal(two.installations.length, 2); assert.equal(two.nextCursor, null); assert.equal( new Set( [...one.installations, ...two.installations].map( (r) => r.installationId, ), ).size, 52, ); for (const query of [ "?subject=forged", "?cursor=bad", `?cursor=${id()}&cursor=${id()}`, ]) assert.equal((await list(first, query)).status, 400); }, );
await t.test( "identity reads outlive deployment grant; real restart retains ownership and replay", async () => { const { principal } = await admin("inspect", {}, first); await admin("expire", { kind: "grant", ref: principal.grantRef }); assert.equal((await reserve(first)).status, 401); assert.equal((await get(first, record.installationId)).status, 200); assert.equal((await list(first)).status, 200); const calls = await admin("metadata/network", {}, first); assert.ok(calls.length > 0); assert.ok( calls.every( (path) => path === "https://api.cloudflare.com/client/v4/accounts", ), ); await worker.stop(); const configuration = oauthConfig(origin); delete configuration.oauthCapabilities; bindings = { ...oauthBindings(origin), FLAREBOT_CONTROL_PLANE: JSON.stringify(configuration), }; worker = await start(); assert.deepEqual( (await (await get(first, record.installationId)).json()).installation, record, ); assert.equal((await list(first)).status, 200); assert.equal((await reserve(first)).status, 401); await worker.stop(); bindings = oauthBindings(origin); worker = await start(); const reconnected = await login(); assert.equal((await select(reconnected, A)).status, 200); assert.deepEqual( (await (await reserve(reconnected, requestId)).json()).installation, record, ); assert.equal((await get(second, record.installationId)).status, 404); await admin("expire", { kind: "session", ref: reconnected.split("=")[1], }); assert.equal( (await get(reconnected, record.installationId)).status, 401, ); for (const marker of [ "oauth-secret-sentinel", "private-content-sentinel", "private-model-key-sentinel", "private-provider-error", ]) assert.ok(!logs.join("\n").includes(marker), marker); }, ); },);
test("production exports private native registry only in publisher bundle", async () => { const control = await readFile("dist/control-plane/worker/index.js", "utf8"); assert.match(control, /InstallationRegistry/); assert.ok(!control.includes("/__test__/")); assert.ok(!control.includes("fixtureInspect")); const customer = await readFile("dist/release/worker/index.js", "utf8"); assert.ok(!customer.includes("InstallationRegistry")); for (const entry of await readdir("dist/control-plane/client/assets")) { const source = await readFile( `dist/control-plane/client/assets/${entry}`, "utf8", ); assert.ok(!source.includes("InstallationRegistry")); // The owner-scoped status UI consumes public metadata, including its owner // identity. Authority resolution and credential storage remain server-only. for (const privateName of [ "authenticatedPrincipal", "selectedDeploymentGrant", "AuthVault", "FLAREBOT_CREDENTIAL_ENCRYPTION_KEY", ]) assert.ok(!source.includes(privateName), privateName); }});