@fungi.computer/shed 0.0.0-stage → 0.1.0

package/backend/test/methods.test.ts

@@ -0,0 +1,662 @@
+import { DatabaseSync } from "node:sqlite";
+import { createShedRuns } from "../runs.js";
+import {
+  maximumStreamBytes,
+  mintComputerProcessId,
+  processListOutputSchema,
+} from "@fungi.computer/computer/operations";
+import { Shed } from "../index.js";
+import * as z from "zod";
+import { expect, it, onTestFinished } from "vitest";
+import { appBackend, type ShedMethodContext } from "../methods.js";
+it("lists ports only through the admitted Computer binding", async () => {
+  expect(
+    await appBackend.call(
+      "listPorts",
+      {},
+      {
+        env: { COMPUTER: { ports: () => Promise.resolve({ ports: [3000] }) } },
+      },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).toEqual({ ports: [3000] });
+});
+it("forwards inventories without accepting selectors or starting commands", async () => {
+  const calls: unknown[] = [];
+  const caller: Parameters<typeof appBackend.call>[3] = {
+    actor: { kind: "member", memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  const context: ShedMethodContext = {
+    env: {
+      COMPUTER: {
+        processes: (input) => {
+          calls.push(input);
+          return Promise.resolve({ processes: [] });
+        },
+      },
+    },
+  };
+  expect(await appBackend.call("listProcesses", {}, context, caller)).toEqual({
+    processes: [],
+  });
+  for (const input of [
+    { computerId: "other" },
+    { agentId: "other" },
+    { command: "rm -rf /" },
+  ])
+    await expect(
+      appBackend.call("listProcesses", z.json().parse(input), context, caller),
+    ).rejects.toThrow();
+  expect(calls).toEqual([{}]);
+});
+it("passes command and cwd unchanged with a host-owned request identity", async () => {
+  const calls: unknown[] = [];
+  const result = {
+    requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+    status: "succeeded",
+    output: {
+      status: "completed",
+      exitCode: 0,
+      stdout: "hi",
+      stderr: "",
+      truncated: false,
+    },
+  };
+  expect(
+    await appBackend.call(
+      "runCommand",
+      { command: "printf hi", cwd: "/work", timeoutMs: 45000 },
+      {
+        env: {
+          COMPUTER: {
+            exec: (input) => {
+              calls.push(input);
+              return Promise.resolve(result);
+            },
+          },
+        },
+      },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).toEqual(result);
+  expect(calls).toEqual([
+    { command: "printf hi", cwd: "/work", timeoutMs: 45000 },
+  ]);
+});
+it.each([
+  { command: "" },
+  { command: "a".repeat(16385) },
+  { command: "echo hi", timeoutMs: 45001 },
+  { command: "echo hi", cwd: "/a/../b" },
+  { command: "echo hi", computerId: "other" },
+  { command: "echo hi", memberId: "other" },
+  { command: "echo hi", requestId: "chosen" },
+  { command: "echo hi", backend: "container" },
+])("refuses invalid command input before dispatch: %j", async (input) => {
+  let calls = 0;
+  await expect(
+    appBackend.call(
+      "runCommand",
+      z.json().parse(input),
+      {
+        env: {
+          COMPUTER: {
+            exec: () => {
+              calls++;
+              return Promise.resolve({});
+            },
+          },
+        },
+      },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).rejects.toThrow();
+  expect(calls).toBe(0);
+});
+it("retains typed execution budget and timeout refusals", async () => {
+  const budget = {
+    error: "attachment_budget_exceeded",
+    kind: "exec",
+    retryAfterMs: 1000,
+  };
+  const timeout = {
+    error: "timeout",
+    requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+  };
+  for (const reply of [budget, timeout])
+    expect(
+      await appBackend.call(
+        "runCommand",
+        { command: "echo hi" },
+        {
+          env: {
+            COMPUTER: { exec: () => Promise.resolve(z.json().parse(reply)) },
+          },
+        },
+        {
+          actor: { kind: "agent", agentId: "agent-a" },
+          computerId: "computer-a",
+        },
+      ),
+    ).toEqual(reply);
+});
+it("refuses an absent pin and missing execution binding", async () => {
+  let calls = 0;
+  expect(
+    await appBackend.call(
+      "runCommand",
+      { command: "echo hi" },
+      {
+        env: {
+          COMPUTER: {
+            exec: () => {
+              calls++;
+              return Promise.resolve({});
+            },
+          },
+        },
+      },
+      { actor: { kind: "agent", agentId: "agent-a" }, computerId: null },
+    ),
+  ).toEqual({ error: "not_granted" });
+  expect(
+    await appBackend.call(
+      "listPorts",
+      {},
+      { env: {} },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).toEqual({ error: "not_granted" });
+  expect(calls).toBe(0);
+});
+it("bounds inventory and command replies", async () => {
+  const caller: Parameters<typeof appBackend.call>[3] = {
+    actor: { kind: "agent", agentId: "agent-a" },
+    computerId: "computer-a",
+  };
+  await expect(
+    appBackend.call(
+      "listPorts",
+      {},
+      {
+        env: {
+          COMPUTER: {
+            ports: () =>
+              Promise.resolve({
+                ports: Array.from({ length: 65 }, () => 3000),
+              }),
+          },
+        },
+      },
+      caller,
+    ),
+  ).rejects.toThrow();
+  await expect(
+    appBackend.call(
+      "runCommand",
+      { command: "echo hi" },
+      {
+        env: {
+          COMPUTER: {
+            exec: () =>
+              Promise.resolve({
+                requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+                status: "succeeded",
+                output: {
+                  status: "completed",
+                  exitCode: 0,
+                  stdout: "é".repeat(65537),
+                  stderr: "",
+                  truncated: false,
+                },
+              }),
+          },
+        },
+      },
+      caller,
+    ),
+  ).rejects.toThrow();
+});
+
+it("the named-method Worker exposes no unauthenticated HTTP execution interface", async () => {
+  expect((await Shed.prototype.fetch()).status).toBe(405);
+});
+
+it("returns exit status for both streams cut inside UTF-8 by the Computer", async () => {
+  // Same byte slice and nonfatal UTF-8 decode as the native Computer producer.
+  const stream = new TextDecoder().decode(
+    new TextEncoder().encode("€".repeat(22000)).slice(0, maximumStreamBytes),
+  );
+  expect(new TextEncoder().encode(stream).byteLength).toBe(
+    maximumStreamBytes + 2,
+  );
+  const reply = {
+    requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+    status: "succeeded",
+    output: {
+      status: "completed",
+      exitCode: 0,
+      stdout: stream,
+      stderr: stream,
+      truncated: true,
+    },
+  };
+  let calls = 0;
+  expect(
+    await appBackend.call(
+      "runCommand",
+      { command: "emit multibyte streams" },
+      {
+        env: {
+          COMPUTER: {
+            exec: () => {
+              calls++;
+              return Promise.resolve(reply);
+            },
+          },
+        },
+      },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).toEqual(reply);
+  expect(calls).toBe(1);
+});
+it("retains a process whose native cwd contains parent segments", async () => {
+  const reply = {
+    processes: [
+      {
+        id: mintComputerProcessId(),
+        port: null,
+        command: "sleep 1",
+        cwd: "/a/../b",
+        state: "running",
+        exitCode: null,
+        sync: "unknown",
+        startedAt: 1,
+        endedAt: null,
+      },
+    ],
+  };
+  expect(
+    await appBackend.call(
+      "listProcesses",
+      {},
+      { env: { COMPUTER: { processes: () => Promise.resolve(reply) } } },
+      {
+        actor: { kind: "agent", agentId: "agent-a" },
+        computerId: "computer-a",
+      },
+    ),
+  ).toEqual(reply);
+});
+
+it("pages retained processes on the admitted Computer without starting work and refuses another Computer's cursor", async () => {
+  const processes = Array.from({ length: 21 }, (_, index) => ({
+    id: mintComputerProcessId(),
+    port: null,
+    command: `node worker-${String(index)}.mjs`,
+    cwd: "/workspace",
+    state: "running" as const,
+    exitCode: null,
+    sync: "unknown",
+    startedAt: index + 1,
+    endedAt: null,
+  })).reverse();
+  let reads = 0;
+  let starts = 0;
+  const notStarted = (): Promise<never> => {
+    starts++;
+    return Promise.reject(new Error("Reading must not start a command"));
+  };
+  const context: ShedMethodContext = {
+    env: {
+      COMPUTER: {
+        processes: (input) => {
+          expect(input).toEqual({});
+          reads++;
+          return Promise.resolve({ processes });
+        },
+        processStart: notStarted,
+        exec: notStarted,
+      },
+    },
+  };
+  const caller: Parameters<typeof appBackend.call>[3] = {
+    actor: { kind: "member", memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  const page = processListOutputSchema.extend({ next: z.json().optional() });
+  const first = page.parse(
+    await appBackend.call("listProcesses", { limit: 20 }, context, caller),
+  );
+  expect(first.processes).toHaveLength(20);
+  expect(first.processes[0]?.id).toBe(processes[0]?.id);
+  if (first.next === undefined) throw new Error("Expected the source cursor");
+  const next = page.parse(
+    await appBackend.call(
+      "listProcesses",
+      { limit: 20, after: first.next },
+      context,
+      caller,
+    ),
+  );
+  expect(next.processes).toEqual([processes[20]]);
+  expect(next.next).toBeUndefined();
+  expect(reads).toBe(2);
+  expect(
+    await appBackend.call(
+      "listProcesses",
+      { limit: 20, after: first.next },
+      context,
+      { ...caller, computerId: "computer-b" },
+    ),
+  ).toEqual({ error: "invalid" });
+  expect(reads).toBe(2);
+  expect(starts).toBe(0);
+});
+
+it("projects a process page through the declared read Gill with App-local navigation", async () => {
+  let reads = 0;
+  const process = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "node server.js",
+    cwd: "/workspace",
+    state: "running",
+    exitCode: null,
+    sync: "unknown",
+    startedAt: Date.now() - 480000,
+    endedAt: null,
+  };
+  const context: ShedMethodContext = {
+    env: {
+      COMPUTER: {
+        processes: () => {
+          reads++;
+          return Promise.resolve({ processes: [process] });
+        },
+      },
+    },
+  };
+  const reply = await appBackend.gill(
+    { id: "processes", params: { computer: "computer-a" } },
+    context,
+    {
+      actor: { kind: "member", memberId: "member-a" },
+      computerId: "computer-a",
+    },
+  );
+  if (!("rows" in reply)) throw new Error("Expected process rows");
+  expect(reply.rows).toHaveLength(1);
+  expect(reply.rows[0]?.open).toEqual({
+    params: [{ key: "process", value: process.id }],
+  });
+  expect(reply.rows[0]?.status).toEqual({ label: "running", tone: "success" });
+  expect(reads).toBe(1);
+});
+
+it("keeps inventory refusals actionable and separate from empty without guessing container state", async () => {
+  const caller: Parameters<typeof appBackend.call>[3] = {
+    actor: { kind: "member", memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  const request = { id: "processes", params: { computer: "computer-a" } };
+  const missing = await appBackend.gill(request, { env: {} }, caller);
+  expect(missing).toMatchObject({
+    state: "error",
+    rows: [],
+    recovery: { kind: "configure", param: "computer" },
+  });
+  const unavailable = await appBackend.gill(
+    request,
+    {
+      env: {
+        COMPUTER: {
+          processes: () => Promise.resolve({ error: "unavailable" }),
+        },
+      },
+    },
+    caller,
+  );
+  expect(unavailable).toMatchObject({
+    state: "error",
+    rows: [],
+    recovery: { kind: "open" },
+  });
+  const empty = await appBackend.gill(
+    request,
+    {
+      env: {
+        COMPUTER: { processes: () => Promise.resolve({ processes: [] }) },
+      },
+    },
+    caller,
+  );
+  expect(empty).toMatchObject({ state: "empty", rows: [] });
+});
+
+it("shortens long display text without losing a retained process or changing its navigation identity", async () => {
+  const process = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "x".repeat(16384),
+    cwd: "/" + "x".repeat(4095),
+    state: "uncertain",
+    exitCode: null,
+    sync: "unknown",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const reply = await appBackend.gill(
+    { id: "processes", params: { computer: "computer-a" } },
+    {
+      env: {
+        COMPUTER: {
+          processes: () => Promise.resolve({ processes: [process] }),
+        },
+      },
+    },
+    {
+      actor: { kind: "member", memberId: "member-a" },
+      computerId: "computer-a",
+    },
+  );
+  if (!("rows" in reply)) throw new Error("Expected retained process rows");
+  expect(reply.rows).toHaveLength(1);
+  expect(reply.rows[0]?.title).toHaveLength(4096);
+  expect(reply.rows[0]?.detail).toHaveLength(1024);
+  expect(reply.rows[0]?.status).toEqual({
+    label: "uncertain",
+    tone: "warning",
+  });
+  expect(reply.rows[0]?.open).toEqual({
+    params: [{ key: "process", value: process.id }],
+  });
+});
+
+it("stops the selected process through the pinned Computer without accepting another selector", async () => {
+  const process = {
+    id: mintComputerProcessId(),
+    port: null,
+    command: "sleep 120",
+    cwd: null,
+    state: "running",
+    exitCode: null,
+    sync: "unknown",
+    startedAt: 1,
+    endedAt: null,
+  };
+  const reply = { process, signalled: true };
+  const calls: unknown[] = [];
+  const database = new DatabaseSync(":memory:");
+  onTestFinished(() => {
+    database.close();
+  });
+  const context = {
+    runs: createShedRuns({
+      exec(query, ...values) {
+        const rows = database.prepare(query).all(...values);
+        return { toArray: () => rows };
+      },
+    }),
+    env: {
+      COMPUTER: {
+        processStart: () => Promise.resolve(process),
+        processes: () => Promise.resolve({ processes: [process] }),
+        processKill: (input: { id: string }) => {
+          calls.push(input);
+          return Promise.resolve(reply);
+        },
+      },
+    },
+  };
+  const caller = {
+    actor: { kind: "member", memberId: "member-one" },
+    idempotencyKey: "stop-test",
+    computerId: "computer-one",
+  } satisfies Parameters<typeof appBackend.call>[3];
+  await appBackend.call("start", { command: "sleep 120" }, context, caller);
+  expect(
+    await appBackend.call("stop", { id: process.id }, context, caller),
+  ).toEqual(reply);
+  await expect(
+    appBackend.call(
+      "stop",
+      { id: process.id, computerId: "other" },
+      context,
+      caller,
+    ),
+  ).rejects.toThrow();
+  await expect(
+    appBackend.call("stop", { id: "not-a-process-id" }, context, caller),
+  ).rejects.toThrow();
+  await expect(
+    appBackend.call("stop", { id: process.id }, context, {
+      ...caller,
+      computerId: null,
+    }),
+  ).rejects.toThrow();
+  expect(calls).toEqual([{ id: process.id }]);
+});
+it("presents a Workflow step's read pass to runCommand only through a one-shot credential file", async () => {
+  const gitAccess = {
+    repository: {
+      kind: "installation",
+      installationId: "bonsai-a",
+      repository: "pond",
+    },
+    access: "read",
+  } as const;
+  const bearer = "wgp.library.secret-pass";
+  const remote = "https://oyster.test/git/bonsai-a/pond.git";
+  const writes: { path: string; content: string }[] = [];
+  const execs: { command: string; timeoutMs?: number }[] = [];
+  const result = {
+    requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+    status: "succeeded",
+    output: {
+      status: "completed",
+      exitCode: 0,
+      stdout: "",
+      stderr: "",
+      truncated: false,
+    },
+  };
+  const context = (pass: unknown): ShedMethodContext => ({
+    env: {
+      COMPUTER: {
+        workflowGitPass: () => Promise.resolve(z.json().parse(pass)),
+        write: (input) => {
+          writes.push(input);
+          return Promise.resolve({
+            path: input.path,
+            bytes: new TextEncoder().encode(input.content).byteLength,
+          });
+        },
+        exec: (input) => {
+          execs.push(input);
+          return Promise.resolve(result);
+        },
+      },
+    },
+  });
+  const caller: Parameters<typeof appBackend.call>[3] = {
+    actor: { kind: "member", memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  const input = z.json().parse({
+    command: 'git clone -- "$FUNGI_GIT_REMOTE" repo',
+    timeoutMs: 45000,
+    gitAccess,
+  });
+  expect(
+    await appBackend.call(
+      "runCommand",
+      input,
+      context({
+        passId: "pass",
+        remote,
+        bearer,
+        expiresAt: Date.now() + 60_000,
+      }),
+      caller,
+    ),
+  ).toEqual(result);
+  expect(writes).toHaveLength(1);
+  const [file] = writes;
+  expect(file?.content).toBe(`${remote}\n${bearer}\n`);
+  expect(file?.path).toMatch(/^\/workspace\/\.fungi-git-[0-9a-f]{32}\.remote$/);
+  const [exec] = execs;
+  expect(exec?.timeoutMs).toBe(45000);
+  // The pass travels only as command-local Git config read from the file.
+  expect(exec?.command).not.toContain(bearer);
+  expect(exec?.command).toContain(`rm -f -- '${file?.path ?? ""}'`);
+  expect(exec?.command).toContain(
+    'GIT_CONFIG_KEY_0="http.$_fungi_git_remote.extraHeader"',
+  );
+  // A refused pass runs nothing and reports the refusal as the step result.
+  execs.length = 0;
+  writes.length = 0;
+  expect(
+    await appBackend.call(
+      "runCommand",
+      input,
+      context({ error: "revoked" }),
+      caller,
+    ),
+  ).toEqual({ error: "revoked" });
+  expect(execs).toEqual([]);
+  expect(writes).toEqual([]);
+  // Without a write binding there is no credential path, so nothing runs.
+  await expect(
+    appBackend.call(
+      "runCommand",
+      input,
+      {
+        env: {
+          COMPUTER: {
+            exec: () => Promise.reject(new Error("must not exec")),
+            workflowGitPass: () => Promise.reject(new Error("must not mint")),
+          },
+        },
+      },
+      caller,
+    ),
+  ).resolves.toEqual({ error: "not_granted" });
+});

package/backend/test/present.test.ts

@@ -0,0 +1,40 @@
+import { expect, it } from "vitest";
+import { appBackend } from "../methods.js";
+
+const present = (command: string, exitCode: number) =>
+  appBackend.methods.run?.present?.(
+    { command },
+    { exitCode, logPath: "/logs/1" },
+  );
+
+it("reads a finished command as a settled row and a failed one as an error row", () => {
+  expect(present("git push origin main", 0)).toEqual({
+    id: "/logs/1",
+    title: "Shed ran git push origin main",
+    detail: "Finished",
+    tone: "settled",
+  });
+  expect(present("git push origin main", 2)).toMatchObject({
+    detail: "Exited with code 2",
+    tone: "error",
+  });
+});
+
+it("names a script by its last command, so two scripts with the same setup read apart", () => {
+  const clone = present(
+    "set -eu\ngit init -q '/work/repo'\n\n# fetch the branch\ngit checkout -q main",
+    0,
+  );
+  const push = present(
+    "set -eu\ncd '/work/repo'\ngit add 'board'\ngit push origin 'HEAD:refs/heads/main'",
+    0,
+  );
+  expect(clone).toMatchObject({
+    title: "Shed ran git checkout -q main",
+    detail: "Finished · 3 commands",
+  });
+  expect(push).toMatchObject({
+    title: "Shed ran git push origin 'HEAD:refs/heads/main'",
+    detail: "Finished · 4 commands",
+  });
+});