@frockbot/plugin-shell 0.1.3 → 0.2.0

package/src/backend-contracts.test.ts

@@ -20,6 +20,34 @@ function storedRun(): StoredRun {
 }
 
 describe("StoredRun durable contract", () => {
+  test("migrates a historical configuration snapshot before strict decoding", () => {
+    // Literal Bot settings shape from eb0283edcce5daea976a21a9f6a6414bedc6e2bc.
+    const decoded = requireStoredRunV1({
+      ...storedRun(),
+      configurationSnapshot: {
+        schemaVersion: 1,
+        botId: "primary",
+        revision: 4,
+        profile: { name: "Primary" },
+        notifications: { enabled: true },
+        assignments: [],
+        assignmentOperations: [],
+        model: {
+          connectionId: "ollama-1",
+          providerModelId: "glm-5.3-flash:cloud",
+        },
+      },
+    });
+    expect(decoded.configurationSnapshot).toEqual({
+      schemaVersion: 1,
+      botId: "primary",
+      revision: 4,
+      profile: { name: "Primary", description: undefined },
+      notifications: { enabled: true },
+      packageValues: {},
+    });
+  });
+
   test("uses the public run identifier grammar", () => {
     expect(() =>
       requireStoredRunV1({ ...storedRun(), runId: "run:1" }),

package/src/backend-contracts.ts

@@ -8,6 +8,7 @@ import {
 import {
   decodeBotSettingsViewV1,
   isPublicIdentifier,
+  migrateStoredBotSettingsV1,
   type BotSettingsViewV1,
 } from "@frockbot/configuration-core";
 
@@ -36,7 +37,8 @@ export function decodeRunIdV1(value: unknown): string {
 export const storedRunCodecV1: StoredRunCodecV1<BotSettingsViewV1> =
   createStoredRunCodecV1<BotSettingsViewV1>({
     decodeRunId: decodeRunIdV1,
-    decodeConfigurationSnapshot: decodeBotSettingsViewV1,
+    decodeConfigurationSnapshot: (stored) =>
+      decodeBotSettingsViewV1(migrateStoredBotSettingsV1(stored)),
   });
 
 export function requireStoredRunV1(input: unknown): StoredRun {

package/src/backend-execution.ts

@@ -6,7 +6,6 @@ import type {
 import type {
   BotExecutionPlanV1,
   BotSettingsViewV1,
-  ConnectionView,
 } from "@frockbot/configuration-core";
 import type { BotTurnCommand, BotTurnCompletion } from "./backend-contracts.js";
 
@@ -17,9 +16,6 @@ export interface BotResidentProjection {
   settings: BotSettingsViewV1;
   executionPlan: BotExecutionPlanV1;
   systemPromptSection: string;
-  authorizeConnection(
-    assignment: BotSettingsViewV1["assignments"][number],
-  ): Promise<ConnectionView>;
 }
 
 export interface BotResidentTurnExecution {

package/src/backend-iframe-ui.test.ts

@@ -0,0 +1,131 @@
+import { describe, expect, test } from "bun:test";
+import type { PackageIframeCompositionV1 } from "@frockbot/kernel-contracts";
+import type { FrockBotManifest } from "@frockbot/kernel-composition";
+import type { CompositionGenerationV1 } from "@frockbot/kernel-composition/generation";
+import { requirePackageUiToolDeclarationV1 } from "./backend.js";
+import { projectPackageIframeCompositionV1 } from "./composition-views.js";
+
+describe("Package iframe server admission", () => {
+  const catalog: PackageIframeCompositionV1 = {
+    schemaVersion: 1,
+    botId: "bot",
+    generationId: "generation-1",
+    contributions: [
+      {
+        packageId: "weather-page",
+        displayName: "Weather page",
+        provenance: "Bot-authored",
+        artifact: {
+          contentHash: "a".repeat(64),
+          size: 123,
+          mediaType: "text/html",
+          bundlerVersion: "frockbot-inline-html@1",
+        },
+        mounts: [{ slot: "frockbot.tool-result:weather_lookup" }],
+        declaredTools: ["weather_lookup"],
+      },
+    ],
+  };
+
+  test("refuses an undeclared tool before admitting a durable Turn", () => {
+    expect(() =>
+      requirePackageUiToolDeclarationV1(catalog, {
+        generationId: "generation-1",
+        packageId: "weather-page",
+        name: "package_author",
+      }),
+    ).toThrow('did not declare tool "package_author"');
+  });
+
+  test("refuses a stale page after its Composition generation changed", () => {
+    expect(() =>
+      requirePackageUiToolDeclarationV1(catalog, {
+        generationId: "generation-old",
+        packageId: "weather-page",
+        name: "weather_lookup",
+      }),
+    ).toThrow('generation "generation-old"');
+  });
+
+  test("projects a Catalog member through the same manifest reader", async () => {
+    const manifestHash = "c".repeat(64);
+    const uiArtifact = {
+      contentHash: "d".repeat(64),
+      size: 42,
+      mediaType: "text/html" as const,
+      bundlerVersion: "frockbot-inline-html@1",
+    };
+    const manifest: FrockBotManifest = {
+      schemaVersion: 3,
+      id: "weather-page",
+      displayName: "Weather page",
+      version: "0.0.1",
+      compatibility: { frockbot: "*" },
+      dependencies: {},
+      contributions: {
+        runtime: { entry: "./package.js", host: "bot-isolate" },
+        client: {
+          kind: "iframe",
+          artifact: uiArtifact,
+          mounts: [{ slot: "frockbot.tool-result:weather_lookup" }],
+        },
+      },
+      tools: [
+        { name: "weather_lookup", description: "Looks up", inputSchema: {} },
+      ],
+      permissions: [],
+    };
+    const generation: CompositionGenerationV1 = {
+      schemaVersion: 1,
+      generationId: "generation-1",
+      artifactSetHash: "a".repeat(64),
+      createdAt: "2026-09-02T00:00:00.000Z",
+      origin: { kind: "bootstrap" },
+      members: [
+        {
+          packageId: "weather-page",
+          specifier: "catalog:weather-page",
+          version: "0.0.1",
+          manifestHash,
+          provenance: {
+            kind: "catalog",
+            packageId: "weather-page",
+            version: "0.0.1",
+            catalogId: "weather-page",
+            catalogGeneration: "catalog-1",
+            contentHash: "b".repeat(64),
+          },
+          artifact: {
+            contentHash: "b".repeat(64),
+            size: 512,
+            mediaType: "application/javascript",
+            bundlerVersion: "catalog-test@1",
+          },
+        },
+      ],
+      status: "active",
+    };
+    const requested: string[] = [];
+
+    const projected = await projectPackageIframeCompositionV1({
+      botId: "bot",
+      generation,
+      readMemberManifest: (member) => {
+        requested.push(member.manifestHash);
+        return Promise.resolve(manifest);
+      },
+    });
+
+    expect(requested).toEqual([manifestHash]);
+    expect(projected.contributions).toEqual([
+      {
+        packageId: "weather-page",
+        displayName: "Weather page",
+        provenance: "User-installed",
+        artifact: uiArtifact,
+        mounts: [{ slot: "frockbot.tool-result:weather_lookup" }],
+        declaredTools: ["weather_lookup"],
+      },
+    ]);
+  });
+});

package/src/backend-image.test.ts

@@ -5,8 +5,8 @@ import {
 } from "@frockbot/plugin-image/testing";
 import {
   createBotImageHost,
-  createWorkersAiImageModelV1,
-  decodeWorkersAiImageV1,
+  createNativeAiImageModelV1,
+  decodeNativeAiImageV1,
 } from "./backend-image.ts";
 
 const IDENTITY = { userId: "user-1", botId: "bot-1" };
@@ -56,7 +56,7 @@ describe("normalizing what Workers AI answered", () => {
   const png = fakePngBytesV1(64, 32);
 
   test("accepts the base64 envelope the FLUX models answer", async () => {
-    const buffer = await decodeWorkersAiImageV1({ image: base64(png) });
+    const buffer = await decodeNativeAiImageV1({ image: base64(png) });
     expect([...new Uint8Array(buffer)]).toEqual([...png]);
   });
 
@@ -68,23 +68,23 @@ describe("normalizing what Workers AI answered", () => {
         controller.close();
       },
     });
-    expect([...new Uint8Array(await decodeWorkersAiImageV1(stream))]).toEqual([
+    expect([...new Uint8Array(await decodeNativeAiImageV1(stream))]).toEqual([
       ...png,
     ]);
   });
 
   test("accepts a raw buffer or view", async () => {
     expect([
-      ...new Uint8Array(await decodeWorkersAiImageV1(png.slice().buffer)),
+      ...new Uint8Array(await decodeNativeAiImageV1(png.slice().buffer)),
     ]).toEqual([...png]);
-    expect([...new Uint8Array(await decodeWorkersAiImageV1(png))]).toEqual([
+    expect([...new Uint8Array(await decodeNativeAiImageV1(png))]).toEqual([
       ...png,
     ]);
   });
 
   test("refuses anything else rather than storing it", async () => {
     for (const answer of [undefined, null, 7, "hello", { image: 3 }, {}]) {
-      await expect(decodeWorkersAiImageV1(answer)).rejects.toThrow(
+      await expect(decodeNativeAiImageV1(answer)).rejects.toThrow(
         "not an image",
       );
     }
@@ -92,7 +92,7 @@ describe("normalizing what Workers AI answered", () => {
 
   test("passes the requested size through to the binding", async () => {
     const calls: Array<[string, Record<string, unknown>]> = [];
-    const model = createWorkersAiImageModelV1({
+    const model = createNativeAiImageModelV1({
       run: (name, input) => {
         calls.push([name, input]);
         return Promise.resolve({ image: base64(png) });

package/src/backend-image.ts

@@ -1,15 +1,15 @@
 // The Bot Durable Object's half of the image-generation seam.
 //
 // The Image Package consumes a narrow `ImageModelV1` — one method, answering
-// raw image bytes — and knows nothing about Workers AI. This module is the
+// raw image bytes — and knows nothing about Cloudflare's native AI binding. This module is the
 // adapter: it takes the `AI` binding off the Durable Object's environment,
-// normalizes the three shapes a Workers AI text-to-image model answers in, and
+// normalizes the three shapes a native text-to-image model answers in, and
 // hands the Package a seam with no platform vocabulary in it. "Electron,
 // Cloudflare, provider SDK, and Computer implementation types remain inside
 // their adapters."
 //
 // The binding is optional, exactly as `PACKAGE_BUNDLER` is. A deployment with
-// no Workers AI binding still mounts the Package, and `generate_image` then
+// no native AI binding still mounts the Package, and `generate_image` then
 // refuses visibly on the Turn that calls it — which is a better answer than a
 // tool that silently vanishes from the catalog, and a far better one than a
 // `TypeError` inside the Agent loop.
@@ -38,11 +38,11 @@ export interface BotImageTurn {
 }
 
 /**
- * The Workers AI binding, declared structurally so this module names no
+ * The native AI binding, declared structurally so this module names no
  * Cloudflare type it does not have to. `run` is the whole of what an image
  * model needs from it.
  */
-export interface WorkersAiBindingV1 {
+export interface NativeAiBindingV1 {
   run(model: string, input: Record<string, unknown>): Promise<unknown>;
 }
 
@@ -51,7 +51,7 @@ export interface WorkersAiBindingV1 {
  * as its own type so the binding's absence is a typed state, not a cast.
  */
 export interface BotImageEnv {
-  AI?: WorkersAiBindingV1;
+  AI?: NativeAiBindingV1;
   WORKSPACE_FILES?: WorkspaceFilesV1;
 }
 
@@ -88,7 +88,7 @@ async function readStream(
 }
 
 /**
- * The bytes inside whatever a Workers AI text-to-image model answered.
+ * The bytes inside whatever a native text-to-image model answered.
  *
  * The catalog does not agree with itself: `flux-1-schnell` and the FLUX.2
  * models answer `{ image: "<base64>" }`, the Stable Diffusion models answer a
@@ -96,7 +96,7 @@ async function readStream(
  * directly. Every one of those is an image; none of them is the Package's
  * problem.
  */
-export async function decodeWorkersAiImageV1(
+export async function decodeNativeAiImageV1(
   answer: unknown,
 ): Promise<ArrayBuffer> {
   if (answer instanceof ArrayBuffer) return answer;
@@ -123,15 +123,15 @@ export async function decodeWorkersAiImageV1(
 }
 
 /**
- * The Workers AI binding as an {@link ImageModelV1}.
+ * The native AI binding as an {@link ImageModelV1}.
  *
  * `width` and `height` are passed through: the Stable Diffusion models accept
  * them, and the FLUX models ignore unknown fields rather than refusing. The
  * Package never trusts them to have been honoured — it reads the dimensions
  * back out of the bytes.
  */
-export function createWorkersAiImageModelV1(
-  binding: WorkersAiBindingV1,
+export function createNativeAiImageModelV1(
+  binding: NativeAiBindingV1,
 ): ImageModelV1 {
   return {
     async run(model: string, input: ImageModelInputV1): Promise<ArrayBuffer> {
@@ -140,7 +140,7 @@ export function createWorkersAiImageModelV1(
         width: input.width,
         height: input.height,
       });
-      return await decodeWorkersAiImageV1(answer);
+      return await decodeNativeAiImageV1(answer);
     },
   };
 }
@@ -174,7 +174,7 @@ export function createBotImageHost(
       runId: turn.runId,
     },
     files,
-    ...(bindings.AI ? { model: createWorkersAiImageModelV1(bindings.AI) } : {}),
+    ...(bindings.AI ? { model: createNativeAiImageModelV1(bindings.AI) } : {}),
     ...(modelId ? { modelId } : {}),
   };
 }