@fungi.computer/shed 0.1.0 → 0.2.0

package/backend/test/methods.test.ts

@@ -4,18 +4,47 @@ import {
   maximumStreamBytes,
   mintComputerProcessId,
   processListOutputSchema,
-} from "@fungi.computer/computer/operations";
+} from "@fungi.computer/computer-contract";
 import { Shed } from "../index.js";
 import * as z from "zod";
 import { expect, it, onTestFinished } from "vitest";
 import { appBackend, type ShedMethodContext } from "../methods.js";
+
+function hostComputer(
+  overrides: Partial<ShedMethodContext["env"]["COMPUTER"]>,
+) {
+  const unexpected = () =>
+    Promise.reject(new Error("Unexpected host binding call"));
+  return {
+    ports: unexpected,
+    processes: unexpected,
+    exec: unexpected,
+    processStart: unexpected,
+    processKill: unexpected,
+    read: unexpected,
+    preview: unexpected,
+    ...overrides,
+  };
+}
+
+function bindingFailure(code = "binding_not_granted") {
+  return Object.assign(new Error("App binding refused"), {
+    name: "AppInstanceError",
+    code,
+  });
+}
+
 it("lists ports only through the admitted Computer binding", async () => {
   expect(
     await appBackend.call(
       "listPorts",
       {},
       {
-        env: { COMPUTER: { ports: () => Promise.resolve({ ports: [3000] }) } },
+        env: {
+          COMPUTER: hostComputer({
+            ports: () => Promise.resolve({ ports: [3000] }),
+          }),
+        },
       },
       {
         actor: { kind: "agent", agentId: "agent-a" },
@@ -32,12 +61,12 @@ it("forwards inventories without accepting selectors or starting commands", asyn
   };
   const context: ShedMethodContext = {
     env: {
-      COMPUTER: {
+      COMPUTER: hostComputer({
         processes: (input) => {
           calls.push(input);
           return Promise.resolve({ processes: [] });
         },
-      },
+      }),
     },
   };
   expect(await appBackend.call("listProcesses", {}, context, caller)).toEqual({
@@ -72,12 +101,12 @@ it("passes command and cwd unchanged with a host-owned request identity", async
       { command: "printf hi", cwd: "/work", timeoutMs: 45000 },
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             exec: (input) => {
               calls.push(input);
               return Promise.resolve(result);
             },
-          },
+          }),
         },
       },
       {
@@ -85,7 +114,13 @@ it("passes command and cwd unchanged with a host-owned request identity", async
         computerId: "computer-a",
       },
     ),
-  ).toEqual(result);
+  ).toEqual({
+    stdout: "hi",
+    stderr: "",
+    exitCode: 0,
+    stdoutTruncated: false,
+    stderrTruncated: false,
+  });
   expect(calls).toEqual([
     { command: "printf hi", cwd: "/work", timeoutMs: 45000 },
   ]);
@@ -107,12 +142,12 @@ it.each([
       z.json().parse(input),
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             exec: () => {
               calls++;
               return Promise.resolve({});
             },
-          },
+          }),
         },
       },
       {
@@ -123,7 +158,7 @@ it.each([
   ).rejects.toThrow();
   expect(calls).toBe(0);
 });
-it("retains typed execution budget and timeout refusals", async () => {
+it("keeps budget retry guidance and omits timeout host request identity", async () => {
   const budget = {
     error: "attachment_budget_exceeded",
     kind: "exec",
@@ -140,7 +175,9 @@ it("retains typed execution budget and timeout refusals", async () => {
         { command: "echo hi" },
         {
           env: {
-            COMPUTER: { exec: () => Promise.resolve(z.json().parse(reply)) },
+            COMPUTER: hostComputer({
+              exec: () => Promise.resolve(z.json().parse(reply)),
+            }),
           },
         },
         {
@@ -148,7 +185,7 @@ it("retains typed execution budget and timeout refusals", async () => {
           computerId: "computer-a",
         },
       ),
-    ).toEqual(reply);
+    ).toEqual(reply.error === "timeout" ? { error: reply.error } : reply);
 });
 it("refuses an absent pin and missing execution binding", async () => {
   let calls = 0;
@@ -158,12 +195,12 @@ it("refuses an absent pin and missing execution binding", async () => {
       { command: "echo hi" },
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             exec: () => {
               calls++;
               return Promise.resolve({});
             },
-          },
+          }),
         },
       },
       { actor: { kind: "agent", agentId: "agent-a" }, computerId: null },
@@ -173,7 +210,13 @@ it("refuses an absent pin and missing execution binding", async () => {
     await appBackend.call(
       "listPorts",
       {},
-      { env: {} },
+      {
+        env: {
+          COMPUTER: hostComputer({
+            ports: () => Promise.reject(bindingFailure()),
+          }),
+        },
+      },
       {
         actor: { kind: "agent", agentId: "agent-a" },
         computerId: "computer-a",
@@ -193,12 +236,12 @@ it("bounds inventory and command replies", async () => {
       {},
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             ports: () =>
               Promise.resolve({
                 ports: Array.from({ length: 65 }, () => 3000),
               }),
-          },
+          }),
         },
       },
       caller,
@@ -210,7 +253,7 @@ it("bounds inventory and command replies", async () => {
       { command: "echo hi" },
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             exec: () =>
               Promise.resolve({
                 requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
@@ -223,7 +266,7 @@ it("bounds inventory and command replies", async () => {
                   truncated: false,
                 },
               }),
-          },
+          }),
         },
       },
       caller,
@@ -251,7 +294,10 @@ it("returns exit status for both streams cut inside UTF-8 by the Computer", asyn
       exitCode: 0,
       stdout: stream,
       stderr: stream,
-      truncated: true,
+      truncated: [
+        { stream: "stdout", keptBytes: maximumStreamBytes, totalBytes: 66000 },
+        { stream: "stderr", keptBytes: maximumStreamBytes, totalBytes: 66000 },
+      ],
     },
   };
   let calls = 0;
@@ -261,12 +307,12 @@ it("returns exit status for both streams cut inside UTF-8 by the Computer", asyn
       { command: "emit multibyte streams" },
       {
         env: {
-          COMPUTER: {
+          COMPUTER: hostComputer({
             exec: () => {
               calls++;
               return Promise.resolve(reply);
             },
-          },
+          }),
         },
       },
       {
@@ -274,9 +320,66 @@ it("returns exit status for both streams cut inside UTF-8 by the Computer", asyn
         computerId: "computer-a",
       },
     ),
-  ).toEqual(reply);
+  ).toEqual({
+    stdout: stream,
+    stderr: stream,
+    exitCode: 0,
+    stdoutTruncated: true,
+    stderrTruncated: true,
+  });
   expect(calls).toBe(1);
 });
+it.each([
+  {
+    output: null,
+    expected: { error: "output_unavailable" },
+  },
+  {
+    output: {
+      status: "failed",
+      exitCode: 7,
+      stdout: "partial output",
+      stderr: "command failed",
+      truncated: [
+        { stream: "stderr", keptBytes: maximumStreamBytes, totalBytes: 70000 },
+      ],
+    },
+    expected: {
+      stdout: "partial output",
+      stderr: "command failed",
+      exitCode: 7,
+      stdoutTruncated: false,
+      stderrTruncated: true,
+    },
+  },
+])(
+  "projects the host outcome without fabricating success: $expected",
+  async ({ output, expected }) => {
+    expect(
+      await appBackend.call(
+        "runCommand",
+        { command: "exit 7" },
+        {
+          env: {
+            COMPUTER: hostComputer({
+              exec: () =>
+                Promise.resolve({
+                  requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
+                  status: "failed",
+                  output,
+                }),
+            }),
+          },
+        },
+        {
+          actor: { kind: "agent", agentId: "agent-a" },
+          computerId: "computer-a",
+        },
+      ),
+    ).toEqual(expected);
+  },
+);
+
 it("retains a process whose native cwd contains parent segments", async () => {
   const reply = {
     processes: [
@@ -297,7 +400,11 @@ it("retains a process whose native cwd contains parent segments", async () => {
     await appBackend.call(
       "listProcesses",
       {},
-      { env: { COMPUTER: { processes: () => Promise.resolve(reply) } } },
+      {
+        env: {
+          COMPUTER: hostComputer({ processes: () => Promise.resolve(reply) }),
+        },
+      },
       {
         actor: { kind: "agent", agentId: "agent-a" },
         computerId: "computer-a",
@@ -326,7 +433,7 @@ it("pages retained processes on the admitted Computer without starting work and
   };
   const context: ShedMethodContext = {
     env: {
-      COMPUTER: {
+      COMPUTER: hostComputer({
         processes: (input) => {
           expect(input).toEqual({});
           reads++;
@@ -334,7 +441,7 @@ it("pages retained processes on the admitted Computer without starting work and
         },
         processStart: notStarted,
         exec: notStarted,
-      },
+      }),
     },
   };
   const caller: Parameters<typeof appBackend.call>[3] = {
@@ -386,12 +493,12 @@ it("projects a process page through the declared read Gill with App-local naviga
   };
   const context: ShedMethodContext = {
     env: {
-      COMPUTER: {
+      COMPUTER: hostComputer({
         processes: () => {
           reads++;
           return Promise.resolve({ processes: [process] });
         },
-      },
+      }),
     },
   };
   const reply = await appBackend.gill(
@@ -417,7 +524,17 @@ it("keeps inventory refusals actionable and separate from empty without guessing
     computerId: "computer-a",
   };
   const request = { id: "processes", params: { computer: "computer-a" } };
-  const missing = await appBackend.gill(request, { env: {} }, caller);
+  const missing = await appBackend.gill(
+    request,
+    {
+      env: {
+        COMPUTER: hostComputer({
+          processes: () => Promise.reject(bindingFailure()),
+        }),
+      },
+    },
+    caller,
+  );
   expect(missing).toMatchObject({
     state: "error",
     rows: [],
@@ -427,9 +544,9 @@ it("keeps inventory refusals actionable and separate from empty without guessing
     request,
     {
       env: {
-        COMPUTER: {
+        COMPUTER: hostComputer({
           processes: () => Promise.resolve({ error: "unavailable" }),
-        },
+        }),
       },
     },
     caller,
@@ -443,7 +560,9 @@ it("keeps inventory refusals actionable and separate from empty without guessing
     request,
     {
       env: {
-        COMPUTER: { processes: () => Promise.resolve({ processes: [] }) },
+        COMPUTER: hostComputer({
+          processes: () => Promise.resolve({ processes: [] }),
+        }),
       },
     },
     caller,
@@ -467,9 +586,9 @@ it("shortens long display text without losing a retained process or changing its
     { id: "processes", params: { computer: "computer-a" } },
     {
       env: {
-        COMPUTER: {
+        COMPUTER: hostComputer({
           processes: () => Promise.resolve({ processes: [process] }),
-        },
+        }),
       },
     },
     {
@@ -516,14 +635,14 @@ it("stops the selected process through the pinned Computer without accepting ano
       },
     }),
     env: {
-      COMPUTER: {
+      COMPUTER: hostComputer({
         processStart: () => Promise.resolve(process),
         processes: () => Promise.resolve({ processes: [process] }),
         processKill: (input: { id: string }) => {
           calls.push(input);
           return Promise.resolve(reply);
         },
-      },
+      }),
     },
   };
   const caller = {
@@ -554,7 +673,7 @@ it("stops the selected process through the pinned Computer without accepting ano
   ).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 () => {
+it("sends a Workflow step's runCommand as ordinary exec input, with no credential transport", async () => {
   const gitAccess = {
     repository: {
       kind: "installation",
@@ -563,10 +682,7 @@ it("presents a Workflow step's read pass to runCommand only through a one-shot c
     },
     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 execs: unknown[] = [];
   const result = {
     requestId: "0199caff-aaaa-7000-8000-aaaaaaaaaaaa",
     status: "succeeded",
@@ -578,27 +694,15 @@ it("presents a Workflow step's read pass to runCommand only through a one-shot c
       truncated: false,
     },
   };
-  const context = (pass: unknown): ShedMethodContext => ({
+  const context: 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,
-          });
-        },
+      COMPUTER: hostComputer({
         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',
@@ -606,57 +710,146 @@ it("presents a Workflow step's read pass to runCommand only through a one-shot c
     gitAccess,
   });
   expect(
-    await appBackend.call(
-      "runCommand",
-      input,
-      context({
-        passId: "pass",
-        remote,
-        bearer,
-        expiresAt: Date.now() + 60_000,
+    await appBackend.call("runCommand", input, context, {
+      actor: { kind: "member", memberId: "member-a" },
+      computerId: "computer-a",
+    }),
+  ).toEqual({
+    stdout: "",
+    stderr: "",
+    exitCode: 0,
+    stdoutTruncated: false,
+    stderrTruncated: false,
+  });
+  // gitAccess is identity only: the host supplies $FUNGI_GIT_REMOTE and its
+  // credentials, so exactly the command and timeout cross the binding.
+  expect(execs).toEqual([
+    { command: 'git clone -- "$FUNGI_GIT_REMOTE" repo', timeoutMs: 45000 },
+  ]);
+});
+
+const directBindings = [
+  ["listPorts", "ports"],
+  ["listProcesses", "processes"],
+  ["runCommand", "exec"],
+] as const;
+const bindingCaller = {
+  actor: { kind: "member", memberId: "member-a" },
+  computerId: "computer-a",
+} satisfies Parameters<typeof appBackend.call>[3];
+
+it.each(directBindings)(
+  "maps a typed denied %s invocation",
+  async (method, binding) => {
+    let calls = 0;
+    const context = {
+      env: {
+        COMPUTER: hostComputer({
+          [binding]: () => {
+            calls++;
+            return Promise.reject(bindingFailure());
+          },
+        }),
+      },
+    };
+    expect(
+      await appBackend.call(
+        method,
+        method === "runCommand" ? { command: "printf hi" } : {},
+        context,
+        bindingCaller,
+      ),
+    ).toEqual({ error: "not_granted" });
+    expect(calls).toBe(1);
+    expect(
+      await appBackend.call(
+        method,
+        method === "runCommand" ? { command: "printf hi" } : {},
+        context,
+        { ...bindingCaller, computerId: null },
+      ),
+    ).toEqual({ error: "not_granted" });
+    expect(calls).toBe(1);
+  },
+);
+
+const workflowInput = {
+  command: 'git push "$FUNGI_GIT_REMOTE" HEAD:refs/heads/main',
+  gitAccess: {
+    repository: {
+      kind: "installation",
+      installationId: "installation_one",
+      repository: "app_source",
+    },
+    branches: ["refs/heads/main"],
+  },
+};
+
+function workflowBindingFixture(failure: Error) {
+  const calls: string[] = [];
+  return {
+    calls,
+    env: {
+      COMPUTER: hostComputer({
+        exec: () => {
+          calls.push("exec");
+          return Promise.reject(failure);
+        },
       }),
-      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;
+    },
+  };
+}
+
+it("maps a typed denied Workflow command exec", async () => {
+  const context = workflowBindingFixture(bindingFailure());
   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")),
+    await appBackend.call("runCommand", workflowInput, context, bindingCaller),
+  ).toEqual({ error: "not_granted" });
+  expect(context.calls).toEqual(["exec"]);
+  expect(
+    await appBackend.call("runCommand", workflowInput, context, {
+      ...bindingCaller,
+      computerId: null,
+    }),
+  ).toEqual({ error: "not_granted" });
+  expect(context.calls).toEqual(["exec"]);
+});
+
+function otherBindingFailures() {
+  return [
+    bindingFailure("binding_unavailable"),
+    bindingFailure("invalid_invocation_facts"),
+    new Error("binding_not_granted"),
+  ];
+}
+
+it.each(directBindings)(
+  "rethrows other %s binding failures unchanged",
+  async (method, binding) => {
+    for (const failure of otherBindingFailures())
+      await expect(
+        appBackend.call(
+          method,
+          method === "runCommand" ? { command: "printf hi" } : {},
+          {
+            env: {
+              COMPUTER: hostComputer({
+                [binding]: () => Promise.reject(failure),
+              }),
+            },
           },
-        },
-      },
-      caller,
-    ),
-  ).resolves.toEqual({ error: "not_granted" });
+          bindingCaller,
+        ),
+      ).rejects.toBe(failure);
+  },
+);
+
+it("rethrows other Workflow command exec failures unchanged", async () => {
+  for (const failure of otherBindingFailures()) {
+    const context = workflowBindingFixture(failure);
+    await expect(
+      appBackend.call("runCommand", workflowInput, context, bindingCaller),
+    ).rejects.toBe(failure);
+    expect(context.calls).toEqual(["exec"]);
+  }
 });