Skip to content

Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.

Keep the playground's delete off a component the build ships (#109)

Hotragn Pettuganif14d5c715c9e
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d6bc8424..e4f8f949 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -180,6 +180,16 @@ Sessions survive and nobody signs in again.
access and refresh tokens use Better Auth's own encryption, keyed on `BETTER_AUTH_SECRET`.
- **A failed provider registration looked like a button that did not work.** The error was rendered
on the page behind the dialog, which was covering it.
+- **Deleting a component in the playground could release one the build ships.** `DELETE
+ /api/sandboxed/:name` deleted from the shared components table by name, without checking
+ which kind of component the name belonged to. Naming a compiled component removed its
+ governance row, and the foreign keys took that component's per-Bot withholdings and its
+ function grants with it. Withholding is the half that fails open: a published component is
+ available to every Bot unless a row says otherwise, so the next catalogue announcement brought
+ the component back published, and available to a Bot it had deliberately been kept from. The
+ audit row called it `kind: "sandboxed"`. The endpoint now refuses a name this surface does not
+ own and answers 404, the way publishing already did. A governance row whose source is already
+ gone is still this surface's to clear.
- **A write could follow a symlink out of the Bot's workspace.** The confinement resolved the
directory a write would land in but not the name it would land on, so a link left at `notes.txt`
pointing outside was followed by the write; a read through the identical link was already refused.
diff --git a/server/src/components/sandboxed-routes.ts b/server/src/components/sandboxed-routes.ts
index b297aad3..8e4ae226 100644
--- a/server/src/components/sandboxed-routes.ts
+++ b/server/src/components/sandboxed-routes.ts
@@ -110,8 +110,19 @@ export function createSandboxedRoutes(
const forbidden = requireAdmin(context);
if (forbidden) return forbidden;
- await store.remove(context.req.param("name"), actorEmail(context));
- return context.json({ ok: true });
+ // Answered like `publish`, because it is the same question: this surface owns the components it
+ // authored, and a name with no draft behind it is not one of them. Reporting that as "not found"
+ // rather than as success also stops a caller reading `{ ok: true }` as "the thing you named is
+ // gone", which it was not.
+ try {
+ await store.remove(context.req.param("name"), actorEmail(context));
+ return context.json({ ok: true });
+ } catch (error) {
+ if (error instanceof SandboxedNotFoundError) {
+ return context.json({ error: error.message }, 404);
+ }
+ throw error;
+ }
});
return routes;
diff --git a/server/src/components/sandboxed.ts b/server/src/components/sandboxed.ts
index 784426f1..c9d20656 100644
--- a/server/src/components/sandboxed.ts
+++ b/server/src/components/sandboxed.ts
@@ -277,6 +277,38 @@ export function createSandboxedStore(
},
async remove(name: string, by: string): Promise<void> {
+ /*
+ * Refuse a name this surface does not own.
+ *
+ * `components` is shared with the compiled catalogue and the delete below is by name, with
+ * nothing checking which kind of component the name belonged to. So a compiled component's
+ * governance row could be deleted through the playground's endpoint, and the foreign keys took
+ * its per-Bot withholdings and its function grants with it.
+ *
+ * The withholdings are the half that fails open. A published component is available to every
+ * Bot unless a `component_exclusions` row says otherwise, so losing that row does not hide the
+ * component, it releases it — and the next catalogue announcement rewrites the component with
+ * `published: true`, because that is how one the build ships arrives. A deliberate "not this
+ * Bot" comes back as "every Bot", under an audit row saying `kind: "sandboxed"`, which is the
+ * one thing it was not.
+ *
+ * Asked of the governance row's `kind` rather than of `sandboxed_components`, because ownership
+ * is the actual question and the two answers differ in one case worth keeping: these deletes
+ * are not in a transaction, so a failure between them leaves a governance row with no source.
+ * That orphan is the "catalogue disagrees with the build" state named below, it is this
+ * surface's to clean up, and requiring the source row would have made it undeletable here.
+ */
+ const [governance] = await database
+ .select({ kind: components.kind })
+ .from(components)
+ .where(eq(components.name, name))
+ .limit(1);
+ // "sandboxed" is the kind `save` writes above. A name with no row at all is refused for the
+ // same reason `publish` refuses one: this surface has nothing by that name to act on.
+ if (governance?.kind !== "sandboxed") {
+ throw new SandboxedNotFoundError(name);
+ }
+
// Delete both rows; a governance row pointing at a component with no source is the visible
// "catalogue disagrees with the build" state.
await database
diff --git a/server/tests/sandboxed-components.integration.test.ts b/server/tests/sandboxed-components.integration.test.ts
index 33da49fd..ed9b1445 100644
--- a/server/tests/sandboxed-components.integration.test.ts
+++ b/server/tests/sandboxed-components.integration.test.ts
@@ -1,11 +1,20 @@
-import { afterAll, describe, expect, test } from "bun:test";
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
import { randomUUID } from "node:crypto";
import { eq } from "drizzle-orm";
import { createAuditStore } from "../src/audit";
-import { createSandboxedStore } from "../src/components/sandboxed";
+import {
+ createSandboxedStore,
+ SandboxedNotFoundError,
+} from "../src/components/sandboxed";
import { createDatabase } from "../src/db/client";
import { TEST_POOL } from "./support/database";
-import { components, sandboxedComponents } from "../src/db/schema";
+import {
+ agents,
+ componentExclusions,
+ componentFunctions,
+ components,
+ sandboxedComponents,
+} from "../src/db/schema";
/**
* A component authored in a browser can be edited freely and still reach nobody until it is
@@ -146,3 +155,121 @@ describe("authoring a component without a rebuild", () => {
expect(governance).toBeUndefined();
});
});
+
+/**
+ * What this surface may delete.
+ *
+ * `components` is shared with the compiled catalogue, so a delete by name on this endpoint could
+ * reach a row the playground never authored. `save` refuses a name that is not a slug and `publish`
+ * refuses a name with no draft behind it; `remove` did neither, which is the asymmetry these pin.
+ */
+describe("deleting a name this surface does not own", () => {
+ const compiled = `chart_test_${suite}`;
+ const bot = `agent_test_${suite}`;
+
+ beforeAll(async () => {
+ await database
+ .insert(agents)
+ .values({ id: bot, name: bot, type: "remote_ag_ui", configuration: {} })
+ .onConflictDoNothing();
+ // A component the build ships, as `syncCatalogue` would have written it.
+ await database.insert(components).values({
+ name: compiled,
+ title: "A compiled chart",
+ kind: "chart",
+ draftDescription: "Drawn by the build.",
+ publishedDescription: "Drawn by the build.",
+ published: true,
+ publishedAt: new Date(),
+ updatedBy: "the build",
+ });
+ // One Bot held back from it. This row is the whole of the decision: a published component is
+ // available to every Bot unless it exists.
+ await database.insert(componentExclusions).values({
+ componentName: compiled,
+ agentId: bot,
+ withheldBy: "[email protected]",
+ });
+ await database.insert(componentFunctions).values({
+ componentName: compiled,
+ functionName: "listRecentOrders",
+ grantedBy: "[email protected]",
+ });
+ });
+
+ afterAll(async () => {
+ await database.delete(components).where(eq(components.name, compiled));
+ await database.delete(agents).where(eq(agents.id, bot));
+ });
+
+ test("refuses a compiled component's name instead of deleting its governance", async () => {
+ await expect(store.remove(compiled, "[email protected]")).rejects.toThrow(
+ SandboxedNotFoundError,
+ );
+
+ const [governance] = await database
+ .select()
+ .from(components)
+ .where(eq(components.name, compiled));
+ expect(governance).toBeDefined();
+ expect(governance?.published).toBe(true);
+ });
+
+ test("leaves the withholding that would otherwise have been released", async () => {
+ // The half that fails OPEN, and the reason this is worth a guard rather than a tidy-up. Losing
+ // this row does not hide the component from the Bot, it releases it to the Bot — and the next
+ // catalogue announcement rewrites the component as published, because that is how one the build
+ // ships arrives. A deliberate "not this Bot" would come back as "every Bot".
+ const withheld = await database
+ .select()
+ .from(componentExclusions)
+ .where(eq(componentExclusions.componentName, compiled));
+ expect(withheld).toHaveLength(1);
+ });
+
+ test("leaves the function grants, which the cascade would also have taken", async () => {
+ // This half fails closed, so it is a capability lost rather than one gained. Asserted anyway:
+ // a component that silently stops being able to read is still a component that stopped working.
+ const granted = await database
+ .select()
+ .from(componentFunctions)
+ .where(eq(componentFunctions.componentName, compiled));
+ expect(granted).toHaveLength(1);
+ });
+
+ test("refuses a name nothing was ever authored under", async () => {
+ // Answered rather than reported as success. `{ ok: true }` for a name that was never there reads
+ // as "the thing you named is gone", which is the one thing it does not establish.
+ await expect(
+ store.remove(`custom_never_${suite}`, "[email protected]"),
+ ).rejects.toThrow(SandboxedNotFoundError);
+ });
+
+ test("still deletes a governance row whose source is already gone", async () => {
+ /*
+ * The orphan, and the reason the guard asks about `kind` rather than about the source row.
+ *
+ * `remove` deletes from two tables and not in one transaction, so a failure between them leaves
+ * exactly this: a governance row of this surface's own kind with nothing behind it. It is the
+ * "catalogue disagrees with the build" state, it belongs to this surface, and gating on the
+ * source row instead would have left it with no way to be cleared.
+ */
+ const orphan = `custom_orphan_${suite}`;
+ await database.insert(components).values({
+ name: orphan,
+ title: "A draft whose source went",
+ kind: "sandboxed",
+ draftDescription: "Authored here.",
+ published: false,
+ updatedBy: "[email protected]",
+ });
+
+ await store.remove(orphan, "[email protected]");
+
+ const [gone] = await database
+ .select()
+ .from(components)
+ .where(eq(components.name, orphan));
+ expect(gone).toBeUndefined();
+ });
+});