@frockbot/plugin-package-publisher 0.0.0 → 0.1.1

package/frockbot.json

@@ -0,0 +1,25 @@
+{
+  "schemaVersion": 3,
+  "id": "package-publisher",
+  "displayName": "Package Publisher",
+  "version": "0.0.1",
+  "compatibility": { "frockbot": ">=0.0.1" },
+  "dependencies": {
+    "computer": ">=0.0.1",
+    "shell": ">=0.0.1",
+    "ui-theme": ">=0.0.1"
+  },
+  "contributions": {
+    "backend": [
+      { "entry": "./backend", "host": "gateway" },
+      { "entry": "./user", "host": "user" }
+    ],
+    "runtime": { "entry": "./agent" },
+    "client": {
+      "entry": "./client",
+      "mounts": [{ "slot": "frockbot.user-settings-sections", "order": 20 }],
+      "outlets": []
+    }
+  },
+  "permissions": ["package:publish"]
+}

package/package.json

@@ -1,14 +1,52 @@
 {
   "name": "@frockbot/plugin-package-publisher",
-  "version": "0.0.0",
-  "description": "Placeholder reserving this name for trusted publishing. Superseded by the first release.",
-  "license": "UNLICENSED",
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./agent": "./src/agent.ts",
+    "./backend": "./src/backend.ts",
+    "./user": "./src/user.ts",
+    "./client": "./src/client/index.ts",
+    "./manifest": "./src/manifest.ts",
+    "./shared": "./src/shared.ts",
+    "./frockbot.json": "./frockbot.json",
+    "./package.json": "./package.json"
+  },
+  "frockbot": {
+    "manifest": "./frockbot.json"
+  },
+  "scripts": {
+    "test": "bun test src",
+    "build": "vite build",
+    "typecheck": "vue-tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@frockbot/kernel-contracts": "0.1.1",
+    "@frockbot/plugin-prompt": "0.1.1",
+    "@frockbot/plugin-tools": "0.1.1",
+    "@frockbot/client-core": "0.1.1",
+    "@frockbot/client-ui": "0.1.1",
+    "@frockbot/plugin-shell": "0.1.1",
+    "cordis": "4.0.0-rc.8",
+    "vue": "3.5.41"
+  },
+  "devDependencies": {
+    "@frockbot/computer-core": "0.1.1",
+    "@frockbot/plugin-testkit": "0.1.1",
+    "@types/bun": "1.4.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-package-publisher"
-  },
-  "publishConfig": {
-    "access": "public"
   }
 }

package/src/agent.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, test } from "bun:test";
+import { SystemPromptRegistry } from "@frockbot/plugin-prompt";
+import { ToolRegistry } from "@frockbot/plugin-tools";
+import {
+  ComputerRegistry,
+  type ComputerProvider,
+} from "@frockbot/computer-core";
+import {
+  createPluginHarness,
+  verifyPluginPackage,
+} from "@frockbot/plugin-testkit";
+import manifest from "../frockbot.json" with { type: "json" };
+import packageJson from "../package.json" with { type: "json" };
+import { createPackagePublisherAgentPlugin } from "./agent.js";
+import type {
+  PackagePublicationReceiptV1,
+  PackageRevisionHistoryV1,
+} from "./shared.js";
+
+const history: PackageRevisionHistoryV1 = {
+  schemaVersion: 1,
+  revision: 1,
+  activePackageRevision: 1,
+  revisions: [
+    {
+      packageRevision: 1,
+      applicationHash: "sha256:one",
+      publishedAt: "2026-09-01T00:00:00.000Z",
+      checks: [{ name: "test", status: "passed" }],
+    },
+  ],
+};
+
+async function execute(
+  tools: Pick<ToolRegistry, "prepare" | "executePrepared">,
+  name: string,
+  input: unknown,
+): Promise<{ content: string; isError: boolean }> {
+  const context = {
+    botId: "bot-1",
+    agentId: "bot-1",
+    compositionGenerationId: "bootstrap",
+    turnType: "chat" as const,
+    effectId: "tool:1:1:0",
+    sessionId: "session-1",
+    signal: new AbortController().signal,
+  };
+  const prepared = await tools.prepare(
+    { id: crypto.randomUUID(), name, input },
+    context,
+  );
+  if (prepared.kind !== "ready") throw new Error("tool was denied");
+  return tools.executePrepared(prepared, context);
+}
+
+describe("Package Publisher Agent contribution", () => {
+  test("lets any Bot list, publish, and roll back its User's shared setup", async () => {
+    const commands: unknown[] = [];
+    const executedCommands: string[] = [];
+    const active = (commandId: string): PackagePublicationReceiptV1 => ({
+      schemaVersion: 1,
+      commandId,
+      status: "active",
+      revision: 2,
+      packageRevision: 1,
+      applicationHash: "sha256:one",
+    });
+    const harness = await createPluginHarness([
+      ComputerRegistry,
+      SystemPromptRegistry,
+      ToolRegistry,
+    ]);
+    const provider: ComputerProvider = {
+      id: "fixture",
+      open: (identity, tenant, assignment) =>
+        Promise.resolve({
+          assignment,
+          identity,
+          tenant,
+          exec: {
+            execute: (request) => {
+              const command = (request.args ?? []).join(" ");
+              executedCommands.push(command);
+              const content = command.includes("archive --format=tar")
+                ? "source snapshot"
+                : "application artifact";
+              return Promise.resolve({
+                exitCode: 0,
+                stdout: new TextEncoder().encode(content),
+                stderr: new Uint8Array(),
+                outputTruncated: false,
+              });
+            },
+          },
+          close: () => Promise.resolve(),
+        }),
+    };
+    harness.root.computers.register(provider);
+    const fiber = await harness.mount(
+      createPackagePublisherAgentPlugin(
+        {
+          read: () => Promise.resolve(history),
+          publish: (command) => {
+            commands.push(command);
+            return Promise.resolve(active(command.commandId));
+          },
+          rollback: (command) => {
+            commands.push(command);
+            return Promise.resolve(active(command.commandId));
+          },
+        },
+        {
+          userId: "user-1",
+          defaultProviderId: "fixture",
+        },
+      ),
+    );
+
+    expect(
+      harness.root.tools.schemas({ turnType: "chat" }).map((tool) => tool.name),
+    ).toEqual(["list_setup_revisions", "publish_setup", "rollback_setup"]);
+    expect(
+      JSON.parse(
+        (await execute(harness.root.tools, "list_setup_revisions", {})).content,
+      ),
+    ).toEqual(history);
+    await execute(harness.root.tools, "publish_setup", {
+      checks: [{ name: "test", status: "passed" }],
+    });
+    await execute(harness.root.tools, "rollback_setup", {
+      packageRevision: 1,
+    });
+    expect(commands).toHaveLength(2);
+    expect(executedCommands[0]).toContain("git -C /home/box/setup init");
+    expect(executedCommands.slice(1)).toHaveLength(2);
+    expect(commands[0]).toMatchObject({
+      expectedRevision: 1,
+      candidate: {
+        source: "source snapshot",
+        applicationArtifact: "application artifact",
+      },
+    });
+    expect(commands[1]).toMatchObject({
+      expectedRevision: 1,
+      packageRevision: 1,
+    });
+
+    await fiber.dispose();
+    expect(harness.root.tools.schemas({ turnType: "chat" })).toEqual([]);
+    await harness.dispose();
+  });
+
+  test("satisfies built-in Package conventions", () => {
+    expect(verifyPluginPackage({ packageJson, manifest })).toMatchObject({
+      name: "@frockbot/plugin-package-publisher",
+      contributionKinds: ["backend", "runtime", "client"],
+    });
+  });
+});

package/src/agent.ts

@@ -0,0 +1,266 @@
+import type { ToolDefinition } from "@frockbot/kernel-contracts";
+import type { ComputerHandle } from "@frockbot/computer-core";
+import type { Plugin } from "cordis";
+import {
+  decodePublishPackageCommandV1,
+  decodeRollbackPackageCommandV1,
+  type PackageCandidateV1,
+  type PackagePublicationReceiptV1,
+  type PackageRevisionHistoryV1,
+  type PublishPackageCommandV1,
+  type RollbackPackageCommandV1,
+} from "./shared.js";
+
+export const SETUP_DIRECTORY = "/home/box/setup";
+export const SETUP_APPLICATION_FILE = "dist/application.mjs";
+
+export interface PackagePublisherAgentHost {
+  read(): Promise<PackageRevisionHistoryV1>;
+  publish(
+    command: PublishPackageCommandV1,
+  ): Promise<PackagePublicationReceiptV1>;
+  rollback(
+    command: RollbackPackageCommandV1,
+  ): Promise<PackagePublicationReceiptV1>;
+}
+
+export interface PackagePublisherAgentConfig {
+  userId: string;
+  defaultProviderId: string;
+}
+
+async function executeText(
+  computer: ComputerHandle,
+  command: string,
+  maxOutputBytes: number,
+  signal: AbortSignal,
+): Promise<string> {
+  if (!computer.exec) {
+    throw new Error("The selected Computer cannot run setup commands");
+  }
+  const result = await computer.exec.execute(
+    {
+      executable: "/bin/bash",
+      args: ["-lc", command],
+      timeoutMs: 120_000,
+      maxOutputBytes,
+    },
+    { signal },
+  );
+  if (result.exitCode !== 0) {
+    const stderr = new TextDecoder().decode(result.stderr).trim();
+    throw new Error(stderr || `setup command exited ${result.exitCode}`);
+  }
+  if (result.outputTruncated)
+    throw new Error("setup output exceeded its limit");
+  return new TextDecoder("utf-8", { fatal: true }).decode(result.stdout);
+}
+
+function publishCommand(
+  input: unknown,
+  commandId: string,
+  expectedRevision: number,
+): PublishPackageCommandV1 {
+  return decodePublishPackageCommandV1({
+    schemaVersion: 1,
+    commandId,
+    expectedRevision,
+    candidate: input,
+  });
+}
+
+function rollbackCommand(
+  input: unknown,
+  commandId: string,
+  expectedRevision: number,
+): RollbackPackageCommandV1 {
+  const value =
+    input && typeof input === "object" && !Array.isArray(input)
+      ? (input as Record<string, unknown>)
+      : {};
+  return decodeRollbackPackageCommandV1({
+    schemaVersion: 1,
+    commandId,
+    expectedRevision,
+    packageRevision: value.packageRevision,
+  });
+}
+
+export function createPackagePublisherAgentPlugin(
+  host: PackagePublisherAgentHost,
+  config: PackagePublisherAgentConfig,
+): Plugin.Function {
+  const userId = config.userId.trim();
+  const defaultProviderId = config.defaultProviderId.trim();
+  if (!userId) throw new Error("Package Publisher user id must be non-empty");
+  if (!defaultProviderId) {
+    throw new Error("Package Publisher provider id must be non-empty");
+  }
+  const plugin: Plugin.Function = (ctx) => {
+    const list: ToolDefinition = {
+      name: "list_setup_revisions",
+      // A general work tool: `executor` reach only.
+      admission: { subagentRoles: ["executor"] },
+      description:
+        "List the immutable setup revisions published for this User and identify the active revision.",
+      inputSchema: {
+        type: "object",
+        properties: {},
+        additionalProperties: false,
+      },
+      idempotent: true,
+      validate: (input) =>
+        Boolean(
+          input &&
+          typeof input === "object" &&
+          !Array.isArray(input) &&
+          Object.keys(input).length === 0,
+        ),
+      execute: async () => ({
+        content: JSON.stringify(await host.read()),
+        isError: false,
+      }),
+    };
+    const publish: ToolDefinition = {
+      name: "publish_setup",
+      // A general work tool: `executor` reach only.
+      admission: { subagentRoles: ["executor"] },
+      description: `Publish and activate the tested Git setup in ${SETUP_DIRECTORY}. The committed source is archived from HEAD, the built application is read from ${SETUP_APPLICATION_FILE}, and all required check results must be provided. This affects all Bots owned by the User.`,
+      inputSchema: {
+        type: "object",
+        properties: {
+          checks: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string" },
+                status: { type: "string", enum: ["passed", "failed"] },
+              },
+              required: ["name", "status"],
+              additionalProperties: false,
+            },
+          },
+        },
+        required: ["checks"],
+        additionalProperties: false,
+      },
+      idempotent: false,
+      validate: (input) => {
+        try {
+          const value = input as { checks?: unknown };
+          publishCommand(
+            {
+              source: "pending",
+              applicationArtifact: "pending",
+              checks: value?.checks,
+            },
+            "validate",
+            0,
+          );
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      execute: async (input, context) => {
+        // One Computer per User (ADR 0012): the assignment is keyed by the
+        // User, and the Bot attaches to it as a tenant.
+        const identity = { userId };
+        if (!ctx.computers.assignment(identity)) {
+          ctx.computers.assign(identity, defaultProviderId);
+        }
+        const computer = await ctx.computers.open(
+          identity,
+          { botId: context.botId },
+          { signal: context.signal },
+        );
+        let candidate: PackageCandidateV1;
+        try {
+          await executeText(
+            computer,
+            `mkdir -p ${SETUP_DIRECTORY} && (git -C ${SETUP_DIRECTORY} rev-parse --git-dir >/dev/null 2>&1 || git -C ${SETUP_DIRECTORY} init)`,
+            10_000,
+            context.signal,
+          );
+          const [source, applicationArtifact] = await Promise.all([
+            executeText(
+              computer,
+              `git -C ${SETUP_DIRECTORY} archive --format=tar HEAD | base64 -w0`,
+              5_000_000,
+              context.signal,
+            ),
+            executeText(
+              computer,
+              `cat ${SETUP_DIRECTORY}/${SETUP_APPLICATION_FILE}`,
+              10_000_000,
+              context.signal,
+            ),
+          ]);
+          candidate = {
+            source,
+            applicationArtifact,
+            checks: (input as { checks: PackageCandidateV1["checks"] }).checks,
+          };
+        } finally {
+          await computer.close();
+        }
+        const current = await host.read();
+        const receipt = await host.publish(
+          publishCommand(candidate, crypto.randomUUID(), current.revision),
+        );
+        return {
+          content: JSON.stringify(receipt),
+          isError: receipt.status === "failed",
+        };
+      },
+    };
+    const rollback: ToolDefinition = {
+      name: "rollback_setup",
+      // A general work tool: `executor` reach only.
+      admission: { subagentRoles: ["executor"] },
+      description:
+        "Activate an earlier immutable setup revision for all Bots owned by the User.",
+      inputSchema: {
+        type: "object",
+        properties: { packageRevision: { type: "integer", minimum: 1 } },
+        required: ["packageRevision"],
+        additionalProperties: false,
+      },
+      idempotent: false,
+      validate: (input) => {
+        try {
+          rollbackCommand(input, "validate", 0);
+          return true;
+        } catch {
+          return false;
+        }
+      },
+      execute: async (input) => {
+        const current = await host.read();
+        const receipt = await host.rollback(
+          rollbackCommand(input, crypto.randomUUID(), current.revision),
+        );
+        return { content: JSON.stringify(receipt), isError: false };
+      },
+    };
+    return [
+      ctx.tools.register(list),
+      ctx.tools.register(publish),
+      ctx.tools.register(rollback),
+      ctx.systemPrompt.register({
+        id: "package-publisher-workspace",
+        order: 90,
+        render: () =>
+          [
+            "## Editable setup",
+            `Edit and test the User's shared setup in ${SETUP_DIRECTORY} using the Computer.`,
+            `Publishing archives the current Git HEAD and reads ${SETUP_APPLICATION_FILE} from that fixed folder; file editing itself is not owned by the Package Publisher.`,
+            "Commit the intended source, run the setup's required checks, and call publish_setup only after they pass.",
+          ].join("\n"),
+      }),
+    ];
+  };
+  plugin.inject = ["computers", "tools", "systemPrompt"];
+  return plugin;
+}

package/src/backend.test.ts

@@ -0,0 +1,129 @@
+import { describe, expect, test } from "bun:test";
+import {
+  createPackagePublisherBackendContribution,
+  type PackagePublisherGatewayHost,
+} from "./backend.js";
+import type {
+  PackagePublicationReceiptV1,
+  PackageRevisionHistoryV1,
+} from "./shared.js";
+
+const history: PackageRevisionHistoryV1 = {
+  schemaVersion: 1,
+  revision: 2,
+  activePackageRevision: 2,
+  revisions: [
+    {
+      packageRevision: 1,
+      applicationHash: "sha256:one",
+      publishedAt: "2026-09-01T00:00:00.000Z",
+      checks: [{ name: "test", status: "passed" }],
+    },
+    {
+      packageRevision: 2,
+      applicationHash: "sha256:two",
+      publishedAt: "2026-09-02T00:00:00.000Z",
+      checks: [{ name: "test", status: "passed" }],
+    },
+  ],
+};
+
+function receipt(commandId: string): PackagePublicationReceiptV1 {
+  return {
+    schemaVersion: 1,
+    commandId,
+    status: "active",
+    revision: 3,
+    packageRevision: 1,
+    applicationHash: "sha256:one",
+  };
+}
+
+describe("Package Publisher gateway contribution", () => {
+  test("exposes authenticated history and rollback without direct publication", async () => {
+    const calls: unknown[] = [];
+    const host: PackagePublisherGatewayHost = {
+      read: (userId) => {
+        calls.push(["read", userId]);
+        return Promise.resolve(history);
+      },
+      rollback: (userId, command) => {
+        calls.push(["rollback", userId, command]);
+        return Promise.resolve(receipt(command.commandId));
+      },
+    };
+    const contribution = createPackagePublisherBackendContribution(host);
+    const context = { userId: "user-1", client: "browser" as const };
+
+    const listed = await contribution.route(
+      new Request("https://bot.test/api/package-revisions"),
+      new URL("https://bot.test/api/package-revisions"),
+      context,
+    );
+    const published = await contribution.route(
+      new Request("https://bot.test/api/package-revisions", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          schemaVersion: 1,
+          commandId: "publish-1",
+          expectedRevision: 2,
+          candidate: {
+            source: "source",
+            applicationArtifact: "artifact",
+            checks: [{ name: "test", status: "passed" }],
+          },
+        }),
+      }),
+      new URL("https://bot.test/api/package-revisions"),
+      context,
+    );
+    const rolledBack = await contribution.route(
+      new Request("https://bot.test/api/package-revisions/rollback", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          schemaVersion: 1,
+          commandId: "rollback-1",
+          expectedRevision: 2,
+          packageRevision: 1,
+        }),
+      }),
+      new URL("https://bot.test/api/package-revisions/rollback"),
+      context,
+    );
+
+    expect(await listed?.json()).toEqual(history);
+    expect(published?.status).toBe(405);
+    expect(await rolledBack?.json()).toEqual(receipt("rollback-1"));
+    expect(calls.map((call) => (call as unknown[])[0])).toEqual([
+      "read",
+      "rollback",
+    ]);
+  });
+
+  test("rejects unauthenticated and malformed publication requests", async () => {
+    const unexpected = () => Promise.reject(new Error("unexpected host call"));
+    const contribution = createPackagePublisherBackendContribution({
+      read: unexpected,
+      rollback: unexpected,
+    });
+    const url = new URL("https://bot.test/api/package-revisions");
+
+    expect(
+      await contribution.route(new Request(url), url, {
+        client: "browser",
+      }),
+    ).toBeUndefined();
+    const response = await contribution.route(
+      new Request(url, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ schemaVersion: 1 }),
+      }),
+      url,
+      { userId: "user-1", client: "browser" },
+    );
+    expect(response?.status).toBe(405);
+  });
+});