@frockbot/plugin-computer 0.0.0 → 0.1.0

package/frockbot.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 3,
+  "id": "computer",
+  "displayName": "Computer",
+  "version": "0.0.1",
+  "compatibility": { "frockbot": ">=0.0.1" },
+  "dependencies": { "shell": ">=0.0.1", "ui-theme": ">=0.0.1" },
+  "contributions": {
+    "backend": [
+      { "entry": "./backend", "host": "gateway" },
+      { "entry": "./bot", "host": "bot" }
+    ],
+    "runtime": { "entry": "./agent" },
+    "client": {
+      "entry": "./client",
+      "mounts": [
+        { "slot": "frockbot.computer" },
+        { "slot": "frockbot.sidebar-computer" },
+        { "slot": "frockbot.overlays" }
+      ],
+      "outlets": []
+    }
+  },
+  "permissions": ["computer:execute", "computer:browser", "webui:remote-frame"]
+}

package/package.json

@@ -1,14 +1,62 @@
 {
   "name": "@frockbot/plugin-computer",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./agent": "./src/agent.ts",
+    "./backend": "./src/backend.ts",
+    "./bot": "./src/bot.ts",
+    "./client": "./src/client/application.ts",
+    "./client-state-machine": "./src/client/state-machine.ts",
+    "./protocol": "./src/protocol.ts",
+    "./roots": "./src/roots.ts",
+    "./src/client/index.ts": "./src/client/index.ts",
+    "./shared": "./src/shared.ts",
+    "./shared-provider": "./src/shared-provider.ts",
+    "./manifest": "./src/manifest.ts",
+    "./frockbot.json": "./frockbot.json",
+    "./package.json": "./package.json"
+  },
+  "frockbot": {
+    "manifest": "./frockbot.json"
+  },
+  "scripts": {
+    "build": "vite build",
+    "test": "bun test src",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@cordisjs/client": "0.8.2",
+    "@frockbot/client-core": "0.1.0",
+    "@frockbot/client-ui": "0.1.0",
+    "@frockbot/computer-core": "0.1.0",
+    "@frockbot/computer-host-runtime": "0.1.0",
+    "@frockbot/kernel-agent-loop": "0.1.0",
+    "@frockbot/kernel-contracts": "0.1.0",
+    "@frockbot/plugin-prompt": "0.1.0",
+    "@frockbot/plugin-shell": "0.1.0",
+    "@frockbot/plugin-tools": "0.1.0",
+    "cordis": "4.0.0-rc.8",
+    "vue": "3.5.41"
+  },
+  "devDependencies": {
+    "@frockbot/plugin-models": "0.1.0",
+    "@frockbot/plugin-testkit": "0.1.0",
+    "@types/bun": "1.4.0",
+    "@types/node": "26.2.0",
+    "@vitejs/plugin-vue": "6.0.8",
+    "typescript": "5.9.3",
+    "vite": "8.2.2",
+    "vue-tsc": "3.3.10"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/timoconnellaus/frockbot.git",
     "directory": "packages/plugin-computer"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/agent.test.ts

@@ -0,0 +1,271 @@
+import { describe, expect, test } from "bun:test";
+import { SystemPromptRegistry } from "@frockbot/plugin-prompt";
+import { ToolRegistry } from "@frockbot/plugin-tools";
+import {
+  ComputerError,
+  ComputerRegistry,
+  type ComputerProvider,
+} from "@frockbot/computer-core";
+import {
+  createPluginHarness,
+  verifyPluginPackage,
+} from "@frockbot/plugin-testkit";
+import { SessionStore } from "@frockbot/kernel-contracts";
+import manifest from "../frockbot.json" with { type: "json" };
+import packageJson from "../package.json" with { type: "json" };
+import {
+  createComputerAgentPlugin,
+  HUMAN_CONTROL_PROMPT_LINE,
+} from "./agent.js";
+import { COMPUTER_CONTROL_RECORD_KEY } from "./control-record.js";
+
+async function execute(
+  harness: Awaited<ReturnType<typeof createPluginHarness>>,
+  name: string,
+  input: unknown,
+) {
+  const context = {
+    botId: "bot-1",
+    agentId: "run-9",
+    compositionGenerationId: "bootstrap",
+    turnType: "chat" as const,
+    sessionId: "session-1",
+    effectId: "tool:1:1:0",
+    signal: new AbortController().signal,
+  };
+  const prepared = await harness.root.tools.prepare(
+    { id: crypto.randomUUID(), name, input },
+    context,
+  );
+  if (prepared.kind !== "ready") throw new Error(prepared.result.content);
+  return harness.root.tools.executePrepared(prepared, context);
+}
+
+describe("computer agent contribution", () => {
+  test("routes generic tools through the Bot's selected Computer provider", async () => {
+    const calls: string[] = [];
+    const provider: ComputerProvider = {
+      id: "fixture",
+      open: async (identity, tenant, assignment) => {
+        calls.push(`open:${identity.userId}:${tenant.botId}`);
+        return {
+          assignment,
+          identity,
+          tenant,
+          exec: {
+            execute: async (request) => {
+              calls.push(
+                `exec:${request.executable}:${request.args?.join(" ")}`,
+              );
+              return {
+                exitCode: 0,
+                stdout: new TextEncoder().encode("/workspace/bot-1"),
+                stderr: new Uint8Array(),
+                outputTruncated: false,
+              };
+            },
+          },
+          browser: {
+            perform: async (action) => {
+              calls.push(`browser:${action.type}`);
+              return { accessibilitySnapshot: "button: Continue" };
+            },
+          },
+          close: () => Promise.resolve(),
+        };
+      },
+    };
+    const harness = await createPluginHarness([
+      ComputerRegistry,
+      ToolRegistry,
+      SystemPromptRegistry,
+      SessionStore,
+    ]);
+    harness.root.computers.register(provider);
+    await harness.mount(
+      createComputerAgentPlugin({
+        userId: "user-1",
+        defaultProviderId: "fixture",
+      }),
+    );
+
+    const exec = await execute(harness, "computer_exec", { command: "pwd" });
+    const browser = await execute(harness, "computer_browser", {
+      action: "snapshot",
+    });
+
+    expect(exec).toMatchObject({ content: "/workspace/bot-1", isError: false });
+    expect(browser).toMatchObject({
+      content: "button: Continue",
+      isError: false,
+    });
+    expect(calls).toEqual([
+      "open:user-1:bot-1",
+      "exec:/bin/bash:-lc pwd",
+      "open:user-1:bot-1",
+      "browser:snapshot",
+    ]);
+    await harness.dispose();
+  });
+
+  test("computer_exec during an update returns an actionable tool failure", async () => {
+    const provider: ComputerProvider = {
+      id: "fixture",
+      open: async (identity, tenant, assignment) => ({
+        assignment,
+        identity,
+        tenant,
+        exec: {
+          execute: async () => {
+            throw new ComputerError(
+              "updating",
+              "Updating the Computer runtime",
+              true,
+            );
+          },
+        },
+        close: () => Promise.resolve(),
+      }),
+    };
+    const harness = await createPluginHarness([
+      ComputerRegistry,
+      ToolRegistry,
+      SystemPromptRegistry,
+      SessionStore,
+    ]);
+    harness.root.computers.register(provider);
+    await harness.mount(
+      createComputerAgentPlugin({
+        userId: "user-1",
+        defaultProviderId: "fixture",
+      }),
+    );
+
+    const result = await execute(harness, "computer_exec", { command: "pwd" });
+
+    expect(result).toEqual({
+      content:
+        "The Computer is updating (Updating the Computer runtime); try again shortly",
+      isError: true,
+    });
+    await harness.dispose();
+  });
+
+  test("injects and records the human-control line only while the durable lease is fresh", async () => {
+    const records = new Map<string, unknown>([
+      [
+        COMPUTER_CONTROL_RECORD_KEY,
+        {
+          version: 1,
+          ownerId: "human:session-1",
+          acquiredAt: "2026-09-02T00:00:00.000Z",
+          expiresAt: "2026-09-02T00:01:30.000Z",
+        },
+      ],
+    ]);
+    let now = new Date("2026-09-02T00:00:30.000Z");
+    const harness = await createPluginHarness([
+      ComputerRegistry,
+      ToolRegistry,
+      SystemPromptRegistry,
+      SessionStore,
+    ]);
+    await harness.mount(
+      createComputerAgentPlugin({
+        userId: "user-1",
+        defaultProviderId: "fixture",
+        controlRecords: {
+          get: <T>(key: string) =>
+            Promise.resolve(records.get(key) as T | undefined),
+          now: () => now,
+        },
+      }),
+    );
+    const session = harness.root.sessions.create("session-1");
+    const preStep = (turn: number) =>
+      harness.root.waterfall(
+        "agent/pre-step",
+        { session } as never,
+        [],
+        turn,
+        1,
+        () => Promise.resolve({ kind: "enter" as const, inputs: [] }),
+      );
+    const assemble = () =>
+      harness.root.systemPrompt.assemble({
+        sessionId: "session-1",
+        provider: "fixture",
+        model: "fixture",
+        turnType: "chat",
+      });
+
+    await preStep(1);
+    expect((await assemble()).text).toContain(HUMAN_CONTROL_PROMPT_LINE);
+    now = new Date("2026-09-02T00:02:00.000Z");
+    await preStep(2);
+    expect((await assemble()).text).not.toContain(HUMAN_CONTROL_PROMPT_LINE);
+
+    const injected = session.events.filter(
+      (event) => event.type === "computer/injected",
+    );
+    expect(injected).toMatchObject([
+      {
+        type: "computer/injected",
+        turn: 1,
+        text: HUMAN_CONTROL_PROMPT_LINE,
+        ownerId: "human:session-1",
+        expiresAt: "2026-09-02T00:01:30.000Z",
+      },
+      { type: "computer/injected", turn: 2, text: "" },
+    ]);
+    await harness.dispose();
+  });
+
+  test("human-control-active is a non-throwing actionable tool result", async () => {
+    const provider: ComputerProvider = {
+      id: "fixture",
+      open: async (identity, tenant, assignment) => ({
+        assignment,
+        identity,
+        tenant,
+        exec: {
+          execute: async () => {
+            throw new ComputerError(
+              "human-control-active",
+              "held by human:session-1",
+            );
+          },
+        },
+        close: () => Promise.resolve(),
+      }),
+    };
+    const harness = await createPluginHarness([
+      ComputerRegistry,
+      ToolRegistry,
+      SystemPromptRegistry,
+      SessionStore,
+    ]);
+    harness.root.computers.register(provider);
+    await harness.mount(
+      createComputerAgentPlugin({
+        userId: "user-1",
+        defaultProviderId: "fixture",
+      }),
+    );
+
+    await expect(
+      execute(harness, "computer_exec", { command: "pwd" }),
+    ).resolves.toEqual({
+      content: "The user is controlling this Computer; do not retry this Turn",
+      isError: true,
+    });
+    await harness.dispose();
+  });
+
+  test("satisfies plugin package conventions", () => {
+    expect(verifyPluginPackage({ packageJson, manifest })).toMatchObject({
+      name: "@frockbot/plugin-computer",
+      contributionKinds: ["backend", "runtime", "client"],
+    });
+  });
+});