@frockbot/plugin-shell 0.3.1 → 0.3.2

package/src/backend-isolate.ts

@@ -251,6 +251,16 @@ export function isolateModelEventStreamV1(
  * identity. User, Bot, the resolved model binding, and the pinned Composition
  * generation complete the digest. Package id is deliberately absent: two
  * Packages of one Bot receive the same authority projection.
+ *
+ * `runId` is here because `CAPABILITIES` is one of those bindings and it is
+ * scoped to one Turn: the stub carries that Turn's run, session, and turn id,
+ * and the Bot Durable Object refuses a capability call whose scope is not the
+ * Turn it is currently running. The loader hands back the *cached* worker for a
+ * repeated id, env and all, so leaving the Turn out of the digest gave a second
+ * Turn on one Composition generation an isolate holding the first Turn's stub —
+ * every `ctx.memory`, `ctx.workspace`, and `ctx.applets` call in it answered
+ * "the Package is not running in this Bot's active Composition". The digest is
+ * a statement about what is bound; a per-Turn binding belongs in it.
  */
 export async function isolateBindingDigestV1(input: {
   userId: string;
@@ -261,6 +271,8 @@ export async function isolateBindingDigestV1(input: {
   >[];
   model?: IsolateModelBindingV1;
   compositionGenerationId: string;
+  /** The Turn whose `CAPABILITIES` stub this isolate's env carries. */
+  runId?: string;
 }): Promise<string> {
   const connections = [...input.connections]
     .map(({ connectionId, generation }) => ({ connectionId, generation }))
@@ -270,6 +282,7 @@ export async function isolateBindingDigestV1(input: {
       userId: input.userId,
       botId: input.botId,
       compositionGenerationId: input.compositionGenerationId,
+      runId: input.runId ?? null,
       connections,
       model: input.model ?? null,
     }),
@@ -290,17 +303,30 @@ async function sha256Hex(value: string): Promise<string> {
  * Reads a Bot Package artifact from object storage and verifies its content
  * address before a byte of it becomes code. Artifacts are immutable content,
  * not state; the hash is the only thing that makes them safe to mount.
+ *
+ * `bundled` is a second *place* to find the same immutable bytes, not a second
+ * kind of thing. A first-party Package that ships as an artifact-backed member
+ * (ADR 0022 decision 8) is built at build time and travels inside this bundle,
+ * so its bytes are already here and object storage never has to be seeded for
+ * a deploy to be correct. Object storage still wins when it holds the object,
+ * the digest is still verified either way, and nothing is ever *built* here —
+ * which is what "Composition consumes immutable content-addressed artifacts and
+ * never builds them" asks of this seam.
  */
 export function createR2PackageArtifactStore(
   bucket: R2Bucket,
+  bundled?: ReadonlyMap<string, string>,
 ): BotIsolateArtifactStore {
   return {
     async loadPackageArtifact(contentHash: string): Promise<string> {
-      const object = await bucket.get(`packages/${contentHash}.mjs`);
-      if (!object) {
-        throw new Error(`package artifact "${contentHash}" is missing`);
-      }
-      const module = await object.text();
+      const key = `packages/${contentHash}.mjs`;
+      const object = await bucket.get(key);
+      const module = object
+        ? await object.text()
+        : (bundled?.get(key) ??
+          (() => {
+            throw new Error(`package artifact "${contentHash}" is missing`);
+          })());
       if ((await sha256Hex(module)) !== contentHash) {
         throw new Error(
           `package artifact "${contentHash}" failed hash verification`,

package/src/backend-package-catalog.test.ts

@@ -28,7 +28,7 @@ const UI_SIZE = 42;
 const CREATED_AT = "2026-09-02T00:00:00.000Z";
 
 const manifest = {
-  schemaVersion: 3 as const,
+  schemaVersion: 5 as const,
   id: "parcel-tracking",
   displayName: "Parcel tracking",
   version: "0.0.1",
@@ -38,13 +38,18 @@ const manifest = {
     runtime: { entry: "./package.js", host: "bot-isolate" as const },
     client: {
       kind: "iframe" as const,
-      artifact: {
-        contentHash: UI_CONTENT_HASH,
-        size: UI_SIZE,
-        mediaType: "text/html" as const,
-        bundlerVersion: "frockbot-inline-html@1",
-      },
-      mounts: [{ slot: "frockbot.tool-result:track_parcel" }],
+      pages: [
+        {
+          id: "main",
+          artifact: {
+            contentHash: UI_CONTENT_HASH,
+            size: UI_SIZE,
+            mediaType: "text/html" as const,
+            bundlerVersion: "frockbot-inline-html@1",
+          },
+          mounts: [{ slot: "frockbot.tool-result:track_parcel" }],
+        },
+      ],
     },
   },
   configuration: {

package/src/backend-package-catalog.ts

@@ -259,13 +259,15 @@ export function createPackageCatalogHost(
     }
     const client = entry.bundle.manifest.contributions.client;
     if (client && isClientIframeContribution(client)) {
-      const uiArtifact = await options.catalog.headUiArtifact(
-        client.artifact.contentHash,
-      );
-      if (!uiArtifact || uiArtifact.size !== client.artifact.size) {
-        throw new Error(
-          `Catalog iframe artifact "${client.artifact.contentHash}" is absent or has the wrong size`,
+      for (const page of client.pages) {
+        const uiArtifact = await options.catalog.headUiArtifact(
+          page.artifact.contentHash,
         );
+        if (!uiArtifact || uiArtifact.size !== page.artifact.size) {
+          throw new Error(
+            `Catalog iframe artifact "${page.artifact.contentHash}" is absent or has the wrong size`,
+          );
+        }
       }
     }
   }

package/src/backend-recovery-integration.test.ts

@@ -8,6 +8,7 @@ import {
   initializeBotSettingsV1,
   type UserSettingsViewV1,
 } from "@frockbot/configuration-core";
+import { compileFoundationApplication } from "@frockbot/application-foundation/runtime";
 import { createShellBotBackendContribution } from "./backend.js";
 import {
   botTurnCommandFingerprintV1,
@@ -85,6 +86,27 @@ class MemoryStorage {
   }
 }
 
+/*
+ * The application as a host with no Worker Loader can mount it.
+ *
+ * This suite runs under `bun test`, where there is no `BOT_PACKAGES` binding
+ * and no `BotCapabilities` loopback, so an artifact-backed member — the
+ * Applets Package, ADR 0022 decision 8 — has nowhere to load from and the
+ * Composition fails verification closed, which is correct and is not what
+ * these tests are about. Dropping those members is the honest way to say
+ * "this host cannot run isolate code"; it is not a switch over any Package's
+ * identity, and workerd's suites mount the real thing.
+ */
+async function compileWithoutIsolateMembers(): ReturnType<
+  typeof compileFoundationApplication
+> {
+  const application = await compileFoundationApplication();
+  return {
+    ...application,
+    packages: application.packages.filter((pkg) => pkg.artifact === undefined),
+  };
+}
+
 describe("Bot recovery", () => {
   test("executes and reconstructs an Ollama-bound Bot without Foundation fallback", async () => {
     const storage = new MemoryStorage();
@@ -216,6 +238,7 @@ describe("Bot recovery", () => {
           typeof createShellBotBackendContribution
         >[0]["env"],
         outboundFetch,
+        compileApplication: compileWithoutIsolateMembers,
       });
 
     const configured = host();