@frockbot/plugin-fly-sprite 0.3.1 → 0.3.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frockbot/plugin-fly-sprite",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "private": false,
   "type": "module",
   "exports": {
@@ -25,16 +25,16 @@
   },
   "dependencies": {
     "@cordisjs/plugin-webui": "0.8.2",
-    "@frockbot/computer-core": "0.3.1",
-    "@frockbot/computer-host-protocol": "0.3.1",
-    "@frockbot/computer-host-runtime": "0.3.1",
-    "@frockbot/kernel-contracts": "0.3.1",
-    "@frockbot/plugin-computer": "0.3.1",
+    "@frockbot/computer-core": "0.3.2",
+    "@frockbot/computer-host-protocol": "0.3.2",
+    "@frockbot/computer-host-runtime": "0.3.2",
+    "@frockbot/kernel-contracts": "0.3.2",
+    "@frockbot/plugin-computer": "0.3.2",
     "cordis": "4.0.0-rc.8"
   },
   "devDependencies": {
-    "@frockbot/plugin-testkit": "0.3.1",
-    "@frockbot/workspace-store": "0.3.1",
+    "@frockbot/plugin-testkit": "0.3.2",
+    "@frockbot/workspace-store": "0.3.2",
     "@types/bun": "1.4.0",
     "@types/node": "26.2.0",
     "typescript": "5.9.3"

package/src/provider.ts

@@ -20,6 +20,10 @@ import {
   type ComputerTenantV1,
   type WorkspaceLayoutV1,
 } from "@frockbot/computer-core";
+import {
+  workspaceRootKeyV1,
+  type WorkspaceRootV1,
+} from "@frockbot/kernel-contracts";
 import type { Plugin } from "cordis";
 import {
   computerBotKey,
@@ -30,7 +34,11 @@ import {
   flySpriteNameForBot,
 } from "./computer.js";
 import { FlyComputerWorkspace } from "./workspace.js";
-import { createFlySpriteSyncV1, type WorkspaceSyncReportV1 } from "./sync.js";
+import {
+  createFlySpriteSyncV1,
+  declaredWorkspaceRootsV1,
+  type WorkspaceSyncReportV1,
+} from "./sync.js";
 
 const encoder = new TextEncoder();
 
@@ -181,6 +189,8 @@ function commandFor(
  */
 class FlySpriteComputerSync implements ComputerSyncV1 {
   private readonly sync: ReturnType<typeof createFlySpriteSyncV1>;
+  /** Every root this sync covers, so a per-root run can refuse a stranger. */
+  private readonly declared: readonly WorkspaceRootV1[];
 
   constructor(
     computer: FlySpriteAgentComputer,
@@ -188,12 +198,25 @@ class FlySpriteComputerSync implements ComputerSyncV1 {
     tenant: ComputerTenantV1,
     host: ComputerSyncHostV1,
   ) {
+    // The layout's own kinds, plus the `package-declared` roots the host said
+    // this User's enabled Packages declare. This provider knows where such a
+    // root is mounted and nothing about which ones exist, so without the
+    // host's list it reconciles none of them — which is what it did before
+    // any host supplied one.
+    this.declared = declaredWorkspaceRootsV1(FLY_WORKSPACE_LAYOUT, {
+      userId: identity.userId,
+      botIds: [tenant.botId],
+      ...(host.packageRoots ? { packageRoots: host.packageRoots } : {}),
+    });
     this.sync = createFlySpriteSyncV1({
       computer,
       layout: FLY_WORKSPACE_LAYOUT,
       userId: identity.userId,
       botDirectoryKey: computerBotKey,
       botIds: [tenant.botId],
+      // The same list, so "what the sync covers" and "what a per-root run will
+      // accept" cannot answer differently.
+      roots: [...this.declared],
       store: host.store,
       ...(host.effects ? { effects: host.effects } : {}),
       ...(host.generations ? { generations: host.generations } : {}),
@@ -219,6 +242,45 @@ class FlySpriteComputerSync implements ComputerSyncV1 {
     return summarize(report);
   }
 
+  /**
+   * One declared root, pulled and pushed. Never throws, exactly like
+   * `reconcile`: the caller records the outcome and carries on.
+   *
+   * A root this Computer does not cover is `refused` rather than reconciled.
+   * Silently syncing an undeclared root would mount a directory the layout
+   * never placed, and silently succeeding on nothing would tell a publish its
+   * artifact had reached the store when it had not.
+   */
+  async reconcileRoot(
+    root: WorkspaceRootV1,
+    _reason: ComputerSyncReasonV1,
+    options?: ComputerOperationOptions,
+  ): Promise<ComputerSyncSummaryV1> {
+    if (options?.signal?.aborted) {
+      return computerSyncSummaryV1("skipped", "the Turn was cancelled");
+    }
+    const key = workspaceRootKeyV1(root);
+    if (!this.declared.some((known) => workspaceRootKeyV1(known) === key)) {
+      return computerSyncSummaryV1(
+        "refused",
+        `this Computer syncs no durable root ${key}`,
+      );
+    }
+    try {
+      const report = await this.sync.syncRoot(root);
+      return summarize({
+        roots: [report],
+        conflicts: report.conflicts,
+        failures: report.failures,
+      });
+    } catch (error) {
+      return computerSyncSummaryV1(
+        "unavailable",
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
   async signal(
     options?: ComputerOperationOptions,
   ): Promise<string | undefined> {

package/src/sync.test.ts

@@ -264,6 +264,17 @@ const MOUNTS = {
   userSkills: "/home/box/agent-data/workflows",
   botMemory: `/home/box/agent-data/agents/${computerBotKey(BOT)}/memory`,
   userMemory: "/home/box/agent-data/user-memory",
+  // ADR 0022 decision 7's Applet source root, resolved from the layout's one
+  // `package-declared` template. Nothing about Applets is in this Package.
+  appletSource: "/home/box/agent-data/user-packages/applets/source",
+};
+
+/** The Applets Package's declared source root, as the host would supply it. */
+const APPLET_SOURCE_PACKAGE_ROOT = { packageId: "applets", rootId: "source" };
+const appletSourceRoot: WorkspaceRootV1 = {
+  kind: "package-declared",
+  userId: USER,
+  ...APPLET_SOURCE_PACKAGE_ROOT,
 };
 
 interface Harness {
@@ -280,6 +291,8 @@ interface Harness {
 function harness(
   options: {
     store?: (files: WorkspaceFilesV1) => WorkspaceFilesV1;
+    /** The `package-declared` roots a host says this User's Packages declare. */
+    packageRoots?: readonly { packageId: string; rootId: string }[];
   } = {},
 ): Harness {
   const bucket = createInMemoryObjectBucketV1();
@@ -302,6 +315,7 @@ function harness(
   const roots = declaredWorkspaceRootsV1(FLY_WORKSPACE_LAYOUT, {
     userId: USER,
     botIds: [BOT],
+    ...(options.packageRoots ? { packageRoots: options.packageRoots } : {}),
   });
   const agent = createFlySpriteSyncV1({
     computer,
@@ -616,6 +630,64 @@ describe("the durable-root sync, Computer to store", () => {
   });
 });
 
+describe("the durable-root sync, Package-declared roots", () => {
+  // Constitution — Computer and Workspace: "durable roots, declared by the
+  // Computer Package's Workspace layout **and by Package manifests**". The
+  // layout half was always here; a `package-declared` root reaches the sync
+  // only when a host supplies the Packages that declared it, which is what
+  // `declaredPackageRootsV1` in `plugin-shell/src/backend-computer.ts` now
+  // does. Without that list the root below is simply not synchronized.
+  test("a root nobody declared is not synchronized at all", () => {
+    const { roots } = harness();
+    expect(roots.some((root) => root.kind === "package-declared")).toBe(false);
+  });
+
+  test("a declared root round-trips: store to Computer, and a shell write back", async () => {
+    // ADR 0022 decision 7: this is the root Applet source lives in, and both
+    // directions matter — the Bot edits source the store holds, and `applet
+    // build` writes `dist/` with a shell that a publish then reads from the
+    // store.
+    const { sprite, store, sync, roots } = harness({
+      packageRoots: [APPLET_SOURCE_PACKAGE_ROOT],
+    });
+    expect(roots).toContainEqual(appletSourceRoot);
+
+    const appletId = "pub-user-1.0123456789abcdef0123456789abcdef";
+    await writeToStore(
+      store,
+      appletSourceRoot,
+      `${appletId}/server.ts`,
+      "export class TodoApplet {}",
+      BOT_WRITER,
+    );
+
+    await sync();
+
+    expect(sprite.text(`${MOUNTS.appletSource}/${appletId}/server.ts`)).toBe(
+      "export class TodoApplet {}",
+    );
+
+    // `applet build` is an ordinary shell write on the Computer.
+    sprite.shellWrite(
+      MOUNTS.appletSource,
+      `${appletId}/dist/server.js`,
+      "export class A{}",
+    );
+    const pushed = await sync();
+
+    const built = await store.read({
+      root: appletSourceRoot,
+      path: `${appletId}/dist/server.js`,
+    });
+    if (built.status !== "ok") throw new Error(built.reason);
+    expect(decoder.decode(built.file.bytes)).toBe("export class A{}");
+    // A shell wrote it, so nothing claims to know which Bot did: the artifact
+    // is data the publish reads, never provenance.
+    expect(built.file.generation.writer).toEqual({ kind: "unattributed" });
+    expect(pushed.failures).toEqual([]);
+  });
+});
+
 describe("the durable-root sync, conflicts", () => {
   // Constitution — Memory: "a write that would overwrite a generation its
   // writer has not seen is preserved as a conflicting generation and surfaced,
@@ -934,7 +1006,9 @@ describe("the durable-root sync on the Computer handle", () => {
     };
   }
 
-  function providerHarness() {
+  function providerHarness(
+    packageRoots?: readonly { packageId: string; rootId: string }[],
+  ) {
     const bucket = createInMemoryObjectBucketV1();
     const generations = createInMemoryWorkspaceGenerationsV1();
     const owner = { userId: USER };
@@ -966,6 +1040,7 @@ describe("the durable-root sync on the Computer handle", () => {
       },
       effects: effects.effects,
       generations,
+      ...(packageRoots ? { packageRoots } : {}),
     });
     const open = () =>
       provider.open(
@@ -1033,6 +1108,56 @@ describe("the durable-root sync on the Computer handle", () => {
     }
   });
 
+  // The sync-now seam of ADR 0022 decision 7, provider side: an Applet publish
+  // needs the bytes `applet build` left on the Computer to be in the store
+  // before it reads them, and it needs that for one root, not the Workspace.
+  test("reconciles one declared root on demand and refuses a root it does not sync", async () => {
+    const { sprite, store, open } = providerHarness([
+      APPLET_SOURCE_PACKAGE_ROOT,
+    ]);
+    const handle = await open();
+    const appletId = "pub-user-1.0123456789abcdef0123456789abcdef";
+    sprite.shellWrite(MOUNTS.skills, "unrelated.md", "not this root");
+    sprite.shellWrite(
+      MOUNTS.appletSource,
+      `${appletId}/dist/server.js`,
+      "export class A{}",
+    );
+
+    const summary = await handle.sync!.reconcileRoot!(
+      appletSourceRoot,
+      "publish",
+    );
+
+    expect(summary.status).toBe("ok");
+    expect(summary.pushed).toBe(1);
+    expect(
+      (
+        await store.read({
+          root: appletSourceRoot,
+          path: `${appletId}/dist/server.js`,
+        })
+      ).status,
+    ).toBe("ok");
+    // One root, not the Workspace: the instruction root's shell write is still
+    // waiting for the Turn's own `turn-end` push.
+    expect(
+      (await store.read({ root: skillsRoot, path: "unrelated.md" })).status,
+    ).toBe("not-found");
+
+    // A root no Package declared is refused rather than quietly reconciled.
+    const refused = await handle.sync!.reconcileRoot!(
+      {
+        kind: "package-declared",
+        userId: USER,
+        packageId: "image",
+        rootId: "generated",
+      },
+      "publish",
+    );
+    expect(refused.status).toBe("refused");
+  });
+
   test("answers unavailable rather than throwing when the Sprite is paused", async () => {
     const { sprite, open } = providerHarness();
     const handle = await open();

package/src/workspace.test.ts

@@ -10,6 +10,7 @@ import {
   type WorkspaceRootV1,
   type WorkspaceWriterV1,
 } from "@frockbot/kernel-contracts";
+import { workspaceMountPathV1 } from "@frockbot/computer-core";
 import { createObjectWorkspaceFilesV1 } from "@frockbot/workspace-store";
 import {
   createInMemoryObjectBucketV1,
@@ -322,6 +323,28 @@ describe("Fly Workspace layout", () => {
       ],
     });
   });
+
+  // ADR 0022 decision 7: Applet source lives at `applets/<appletId>/` under a
+  // `package-declared` root of the Applets Package. The ids are
+  // `APPLETS_PACKAGE_ID_V1` and `APPLETS_SOURCE_ROOT_ID_V1` in
+  // `@frockbot/plugin-applets/root`, written out here rather than imported so
+  // this provider Package keeps knowing nothing about Applets.
+  test("mounts the Applets source root with no layout change of its own", () => {
+    expect(
+      workspaceMountPathV1(FLY_WORKSPACE_LAYOUT, {
+        kind: "package-declared",
+        userId: USER,
+        packageId: "applets",
+        rootId: "source",
+      }),
+    ).toBe("/home/box/agent-data/user-packages/applets/source");
+    // Read-write, unlike Memory: writing source with a shell is the point.
+    expect(
+      FLY_WORKSPACE_LAYOUT.roots.find(
+        (root) => root.kind === "package-declared",
+      )?.access,
+    ).toBe("read-write");
+  });
 });
 
 describe("Fly Workspace files", () => {