@frockbot/plugin-shell 0.1.3 → 0.2.0

package/src/client/model-presentation.ts

@@ -1,19 +1,26 @@
 /**
- * The model line the shell shows above the composer. It names the model the
- * Bot actually runs on, whether that model is the Bot's own override or the
- * User's default: a Bot that "just works" does not advertise where its
- * settings came from.
+ * The model line the shell shows above the composer. Platform choices read as
+ * the model itself; opting into an account choice or Bot override makes that
+ * distinction visible. A resolver failure is already the backend's complete,
+ * repairable explanation, so the client presents it verbatim.
  */
 export function modelRuntimeLabel(input: {
+  source: "bot" | "account" | "platform" | "none";
   modelDisplayName?: string;
   providerModelId?: string;
   packageDisplayName?: string;
   connectionDisplayName?: string;
-  hasModel: boolean;
+  failure?: string;
 }): string {
-  if (!input.hasModel) return "No default model";
+  if (input.failure) return input.failure;
+  if (input.source === "none" || !input.providerModelId) {
+    return "Model unavailable";
+  }
   const model =
     input.modelDisplayName ?? input.providerModelId ?? "Connected model";
   const provider = input.packageDisplayName ?? input.connectionDisplayName;
-  return provider ? `${model} · ${provider}` : model;
+  const runtime = provider ? `${model} · ${provider}` : model;
+  if (input.source === "bot") return `${runtime} · Bot override`;
+  if (input.source === "account") return `${runtime} · Account model`;
+  return runtime;
 }

package/src/client/package-iframe-host-message.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from "bun:test";
+import type { PackageIframeHostMessageV1 } from "@frockbot/kernel-contracts";
+import { postPackageIframeHostMessage } from "./package-iframe-host-message.js";
+
+describe("Package iframe host messages", () => {
+  test("posts unchanged state once and posts changed state again", () => {
+    const posted: PackageIframeHostMessageV1[] = [];
+    const target = {
+      postMessage(message: PackageIframeHostMessageV1): void {
+        posted.push(message);
+      },
+    } as Pick<Window, "postMessage">;
+    const lastStateWireByName = new Map<string, string>();
+
+    const postSettings = (value: unknown): void =>
+      postPackageIframeHostMessage(
+        target,
+        { schemaVersion: 1, type: "state", name: "settings", value },
+        lastStateWireByName,
+      );
+
+    postSettings({ temperatureUnit: "celsius" });
+    postSettings({ temperatureUnit: "celsius" });
+    postSettings({ temperatureUnit: "fahrenheit" });
+
+    expect(posted).toEqual([
+      {
+        schemaVersion: 1,
+        type: "state",
+        name: "settings",
+        value: { temperatureUnit: "celsius" },
+      },
+      {
+        schemaVersion: 1,
+        type: "state",
+        name: "settings",
+        value: { temperatureUnit: "fahrenheit" },
+      },
+    ]);
+  });
+});

package/src/client/package-iframe-host-message.ts

@@ -0,0 +1,27 @@
+import type { PackageIframeHostMessageV1 } from "@frockbot/kernel-contracts";
+
+type MessageTarget = Pick<Window, "postMessage">;
+
+export function postPackageIframeHostMessage(
+  target: MessageTarget,
+  message: PackageIframeHostMessageV1,
+  lastStateWireByName: Map<string, string>,
+): void {
+  const wire = JSON.stringify(message);
+  if (new TextEncoder().encode(wire).byteLength > 64 * 1024) {
+    throw new Error("Package page state exceeds the bridge limit");
+  }
+  if (
+    message.type === "state" &&
+    lastStateWireByName.get(message.name) === wire
+  ) {
+    return;
+  }
+
+  // Vue settings values may be reactive proxies, which structured clone
+  // rejects. JSON is also the bridge's declared value domain.
+  target.postMessage(JSON.parse(wire) as PackageIframeHostMessageV1, "*");
+  if (message.type === "state") {
+    lastStateWireByName.set(message.name, wire);
+  }
+}

package/src/client/styles.css

@@ -175,27 +175,6 @@
   text-overflow: ellipsis;
 }
 
-.model-setup-link {
-  width: max-content;
-  max-width: 100%;
-  margin-top: 3px;
-  overflow: hidden;
-  border: 0;
-  padding: 0;
-  color: var(--frock-action-primary);
-  background: transparent;
-  font: inherit;
-  font-size: var(--frock-text-sm);
-  text-align: left;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  cursor: pointer;
-}
-
-.model-setup-link:hover {
-  color: var(--frock-action-primary-hover);
-}
-
 /*
  * The panel collapse control is pinned to the window's trailing edge. Feature
  * actions live in the panel's own header.
@@ -570,12 +549,6 @@
     0 0 0 3px var(--frock-focus-ring);
 }
 
-.composer-model-setup {
-  min-width: 0;
-  flex: 1;
-  align-self: center;
-}
-
 .composer textarea {
   box-sizing: border-box;
   width: 100%;

package/src/composition-views.ts

@@ -9,6 +9,11 @@ import {
   type CompositionMemberViewV1,
   type CompositionProvenanceViewV1,
 } from "@frockbot/configuration-core";
+import type { PackageIframeCompositionV1 } from "@frockbot/kernel-contracts";
+import {
+  isClientIframeContribution,
+  type FrockBotManifest,
+} from "@frockbot/kernel-composition";
 import type {
   CompositionFailureV1,
   CompositionQuarantineV1,
@@ -29,11 +34,57 @@ export type CompositionMemberSourceReaderV1 = (
   member: CompositionMemberV1,
 ) => Promise<string | undefined>;
 
+/** One decoded manifest lookup shared by isolate mount and hosted UI views. */
+export type CompositionMemberManifestReaderV1 = (
+  member: CompositionMemberV1,
+) => Promise<FrockBotManifest | undefined>;
+
+/** Project iframe Contributions from either Bot or Catalog provenance. */
+export async function projectPackageIframeCompositionV1(input: {
+  botId: string;
+  generation: CompositionGenerationV1;
+  readMemberManifest: CompositionMemberManifestReaderV1;
+}): Promise<PackageIframeCompositionV1> {
+  const contributions: PackageIframeCompositionV1["contributions"] = [];
+  for (const member of input.generation.members) {
+    if (member.provenance.kind === "first-party") continue;
+    const manifest = await input.readMemberManifest(member);
+    if (!manifest) continue;
+    const client = manifest.contributions.client;
+    if (!client || !isClientIframeContribution(client)) continue;
+    contributions.push({
+      packageId: member.packageId,
+      displayName: manifest.displayName,
+      provenance:
+        member.provenance.kind === "bot" ? "Bot-authored" : "User-installed",
+      artifact: { ...client.artifact },
+      mounts: client.mounts.map((mount) => ({ ...mount })),
+      declaredTools: (manifest.tools ?? []).map((tool) => tool.name),
+    });
+  }
+  contributions.sort((left, right) =>
+    left.packageId.localeCompare(right.packageId),
+  );
+  return {
+    schemaVersion: 1,
+    botId: input.botId,
+    generationId: input.generation.generationId,
+    contributions,
+  };
+}
+
 function provenanceView(
   member: CompositionMemberV1,
 ): CompositionProvenanceViewV1 {
   const provenance = member.provenance;
   if (provenance.kind === "first-party") return { kind: "first-party" };
+  if (provenance.kind === "catalog") {
+    return {
+      kind: "catalog",
+      catalogId: provenance.catalogId,
+      catalogGeneration: provenance.catalogGeneration,
+    };
+  }
   if (provenance.kind === "user") {
     return {
       kind: "user",
@@ -102,6 +153,9 @@ export async function projectCompositionGenerationV1(
     isCurrent: input.generation.generationId === input.currentGenerationId,
     members,
     failures,
+    ...(input.generation.summary === undefined
+      ? {}
+      : { summary: input.generation.summary }),
     ...(input.quarantine === undefined
       ? {}
       : {

package/src/settings-links.test.ts

@@ -23,11 +23,11 @@ describe("settings link scheme", () => {
   test("renders against an origin when one is supplied", () => {
     expect(
       settingsLinkV1({
-        anchor: "bot-model",
+        anchor: "bot-name",
         botId: "alpha",
         origin: "https://app.example/",
       }),
-    ).toBe("https://app.example/?bot=alpha&settings=bot-settings#bot-model");
+    ).toBe("https://app.example/?bot=alpha&settings=bot-settings#bot-name");
   });
 
   test("refuses an anchor this build does not ship", () => {
@@ -36,14 +36,6 @@ describe("settings link scheme", () => {
     );
   });
 
-  test("renders a Markdown citation a payload can carry verbatim", () => {
-    expect(
-      renderSettingsLinkV1({ anchor: "bot-capabilities", botId: "alpha" }),
-    ).toBe(
-      "[Capability Assignments](/?bot=alpha&settings=bot-settings#bot-capabilities)",
-    );
-  });
-
   test("decodes an absolute link back to its surface, anchor and Bot", () => {
     expect(
       decodeSettingsLinkV1(

package/src/settings-links.ts

@@ -108,18 +108,6 @@ export const SETTINGS_ANCHORS_V1: readonly SettingsAnchorV1[] = [
     label: "Waiting on you",
     scope: "bot",
   },
-  {
-    anchor: "bot-model",
-    surface: "bot-settings",
-    label: "Model",
-    scope: "bot",
-  },
-  {
-    anchor: "bot-capabilities",
-    surface: "bot-settings",
-    label: "Capability Assignments",
-    scope: "bot",
-  },
   {
     anchor: "bot-routines",
     surface: "bot-settings",
@@ -194,7 +182,7 @@ export const SETTINGS_ANCHORS_V1: readonly SettingsAnchorV1[] = [
   {
     anchor: "user-connections",
     surface: "connections",
-    label: "Connections",
+    label: "Connectors",
     scope: "user",
   },
   {

package/src/shared.ts

@@ -7,8 +7,6 @@ import type {
   BotProfile,
   BotProfilePatchV1,
   BotSettingsViewV1,
-  CapabilityAssignmentView,
-  ModelAssignment,
   UserSettingsViewV1,
 } from "@frockbot/configuration-core";
 import type {
@@ -16,6 +14,8 @@ import type {
   CatalogIndexEntryV1,
 } from "@frockbot/catalog-core";
 import type {
+  PackageIframeCatalogV1,
+  PackageIframeContributionViewV1,
   SendToUserPayloadV1,
   SkillRefV1,
 } from "@frockbot/kernel-contracts";
@@ -189,6 +189,8 @@ export interface FrockBotWebData {
    * without the run's own events being rewritten.
    */
   tasks: TaskViewV1[];
+  /** Sandboxed pages in the selected Bot's active fail-closed Composition. */
+  packageUi?: PackageIframeCatalogV1;
   /**
    * The User's MCP servers: state, tool count, last handshake, instructions,
    * failure, and the durable refusal ledger. Absent until it is loaded, and
@@ -206,19 +208,8 @@ export interface FrockBotWebData {
     namedBy?: BotNameProvenanceV1,
   ): Promise<void>;
   saveBotNotifications(notifications: BotNotificationPolicy): Promise<void>;
-  assignCapability(
-    assignment: Omit<CapabilityAssignmentView, "state">,
-  ): Promise<void>;
-  replaceCapability(
-    assignment: Omit<CapabilityAssignmentView, "state">,
-  ): Promise<void>;
-  unassignCapability(assignmentId: string): Promise<void>;
-  saveBotModel(model: ModelAssignment): Promise<void>;
-  clearBotModel(): Promise<void>;
   loadUserSettings(): Promise<void>;
   saveUserProfile(profile: { name: string; email?: string }): Promise<void>;
-  /** The model every Bot uses unless it overrides it. */
-  saveDefaultModel(model: ModelAssignment | undefined): Promise<void>;
   loadPluginCatalog(): Promise<void>;
   /** Refreshes {@link FrockBotWebData.mcpServers}. */
   loadMcpServers(): Promise<void>;
@@ -253,6 +244,12 @@ export interface FrockBotWebData {
   loadApprovals(): Promise<void>;
   /** Refreshes {@link FrockBotWebData.tasks} for the active Bot. */
   loadTasks(): Promise<void>;
+  loadPackageUi(): Promise<void>;
+  callPackageUiTool(
+    contribution: PackageIframeContributionViewV1,
+    name: string,
+    input: unknown,
+  ): Promise<unknown>;
   /**
    * Cancels one subagent, explicitly and with the User's authentication. The
    * backend is the authority: the task this replaces in the list is the record

package/src/backend-assignment.test.ts

@@ -1,161 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import {
-  nextAssignmentPhase,
-  requireStoredAssignmentSaga,
-  settleAssignmentSaga,
-  type AssignmentSagaEffects,
-  type StoredAssignmentSaga,
-} from "./backend-assignment.js";
-
-function saga(
-  phase: StoredAssignmentSaga["phase"],
-  input: Partial<StoredAssignmentSaga> = {},
-): StoredAssignmentSaga {
-  return {
-    schemaVersion: 1,
-    commandId: "command-1",
-    commandFingerprint: "configuration-command-v1:test",
-    userId: "user-1",
-    botId: "bot-1",
-    operation: "replacing",
-    assignmentId: "mail",
-    generation: "generation-1",
-    phase,
-    target: {
-      assignmentId: "mail",
-      packageId: "mail",
-      capabilityId: "send",
-      connectionId: "new-connection",
-    },
-    previous: {
-      assignmentId: "mail",
-      packageId: "mail",
-      capabilityId: "send",
-      connectionId: "old-connection",
-      state: "enabled",
-    },
-    previousGeneration: "old-generation",
-    deadlineAt: Date.now() + 60_000,
-    ...input,
-    acceptedReceipt: input.acceptedReceipt ?? {
-      schemaVersion: 1,
-      commandId: "command-1",
-      revision: 0,
-      status: "pending",
-    },
-  };
-}
-
-function effects(log: string[], acknowledge = true): AssignmentSagaEffects {
-  return {
-    acknowledge: () => {
-      log.push("acknowledge");
-      return Promise.resolve(acknowledge);
-    },
-    compensate: () => {
-      log.push("compensate");
-      return Promise.resolve();
-    },
-    release: () => {
-      log.push("release");
-      return Promise.resolve(true);
-    },
-    rejectCommitted: () => {
-      log.push("reject-committed");
-      return Promise.resolve();
-    },
-  };
-}
-
-describe("Assignment saga transitions", () => {
-  test("orders Replace as claim, commit, acknowledge, release", () => {
-    const committed = nextAssignmentPhase(saga("claiming"), "claimed")!;
-    const acknowledged = nextAssignmentPhase(committed, "committed")!;
-    const releasing = nextAssignmentPhase(acknowledged, "acknowledged")!;
-    expect([committed.phase, acknowledged.phase, releasing.phase]).toEqual([
-      "committing",
-      "acknowledging",
-      "releasing",
-    ]);
-    expect(nextAssignmentPhase(releasing, "released")).toBeUndefined();
-  });
-
-  test("finishes a connection-free Assign after commit", () => {
-    expect(
-      nextAssignmentPhase(
-        saga("committing", {
-          operation: "assigning",
-          target: {
-            assignmentId: "clock",
-            packageId: "clock",
-            capabilityId: "time",
-          },
-          previous: undefined,
-          previousGeneration: undefined,
-        }),
-        "committed",
-      ),
-    ).toBeUndefined();
-  });
-
-  test("strictly decodes durable saga state", () => {
-    expect(requireStoredAssignmentSaga(saga("claiming"))).toMatchObject({
-      operation: "replacing",
-      phase: "claiming",
-    });
-    expect(() =>
-      requireStoredAssignmentSaga({ ...saga("claiming"), extra: true }),
-    ).toThrow("invalid fields");
-    const hidden = saga("claiming") as StoredAssignmentSaga & { hidden?: true };
-    Object.defineProperty(hidden, "hidden", { value: true });
-    expect(() => requireStoredAssignmentSaga(hidden)).toThrow("invalid fields");
-    expect(() =>
-      requireStoredAssignmentSaga({
-        ...saga("claiming"),
-        [Symbol("extra")]: true,
-      }),
-    ).toThrow("invalid fields");
-    expect(() =>
-      requireStoredAssignmentSaga({
-        ...saga("claiming"),
-        acceptedReceipt: {
-          schemaVersion: 1,
-          commandId: "command-1",
-          revision: 0,
-          status: "applied",
-        },
-      }),
-    ).toThrow("accepted receipt is invalid");
-  });
-
-  test("rejects out-of-order advancement", () => {
-    expect(() => nextAssignmentPhase(saga("claiming"), "released")).toThrow(
-      "cannot apply released while claiming",
-    );
-  });
-
-  test("compensates a claiming saga and rejects an unacknowledged commit", async () => {
-    const compensated: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("claiming"), effects(compensated)),
-    ).resolves.toBe("compensated");
-    expect(compensated).toEqual(["compensate"]);
-
-    const acknowledged: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("acknowledging"), effects(acknowledged)),
-    ).resolves.toBe("acknowledged");
-    expect(acknowledged).toEqual(["acknowledge"]);
-
-    const log: string[] = [];
-    await expect(
-      settleAssignmentSaga(saga("acknowledging"), effects(log, false)),
-    ).resolves.toBe("rejected");
-    expect(log).toEqual([
-      "acknowledge",
-      "compensate",
-      "release",
-      "reject-committed",
-    ]);
-  });
-});