@fungi.computer/inkcap 0.0.1 → 0.2.0

package/backend/methods.ts

@@ -1,3 +1,4 @@
+import { resultRows } from "@fungi.computer/agar/method-presentation";
 import { recentFilesGill } from "./gills.js";
 import {
   documentIdentitySchema,
@@ -11,6 +12,7 @@ import {
   type DocumentActivityStore,
 } from "./document-activity.js";
 import * as z from "zod";
+import { filesNavigateIntent } from "@fungi.computer/agar/roles/files";
 import type { AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
 import {
   defineAppBackend,
@@ -24,16 +26,16 @@ import {
   listOutputSchema,
   readBytesInputSchema,
   writeOutputSchema,
-} from "@fungi.computer/computer/operations";
+} from "@fungi.computer/computer-contract";
 export type InkcapBackendContext = {
   activity: DocumentActivityStore;
   documentsChanged(computerId: string, sequence: number): Promise<void>;
   env: {
     APP_STORAGE: Pick<AppStorageWire, "read" | "write">;
-    COMPUTER?: {
-      list?(input: z.output<typeof listInput>): Promise<WhistleJsonValue>;
-      read?(input: z.output<typeof readInput>): Promise<WhistleJsonValue>;
-      write?(input: z.output<typeof writeInput>): Promise<WhistleJsonValue>;
+    COMPUTER: {
+      list(input: z.output<typeof listInput>): Promise<WhistleJsonValue>;
+      read(input: z.output<typeof readInput>): Promise<WhistleJsonValue>;
+      write(input: z.output<typeof writeInput>): Promise<WhistleJsonValue>;
     };
   };
 };
@@ -101,6 +103,19 @@ const refusal = z.union([
 const listReply = z.union([listOutputSchema, refusal]);
 const readReply = z.union([readOutput, refusal]);
 const writeReply = z.union([writeOutputSchema, refusal]);
+// The host always supplies callable bindings; admission is checked on invocation.
+const bindingNotGranted = z.object({ code: z.literal("binding_not_granted") });
+async function computerCall(
+  call: () => Promise<WhistleJsonValue>,
+): Promise<WhistleJsonValue> {
+  try {
+    return await call();
+  } catch (cause) {
+    if (bindingNotGranted.safeParse(cause).success)
+      return { error: "not_granted" };
+    throw cause;
+  }
+}
 async function recordDocument(
   input: z.output<typeof documentIdentitySchema>,
   context: InkcapBackendContext,
@@ -162,9 +177,11 @@ export const appBackend = defineAppBackend({
       input: listInput,
       output: listReply,
       handler: async (input, context: InkcapBackendContext, caller) =>
-        caller.computerId === null || !context.env.COMPUTER?.list
+        caller.computerId === null
           ? refusal.parse({ error: "not_granted" })
-          : listReply.parse(await context.env.COMPUTER.list(input)),
+          : listReply.parse(
+              await computerCall(() => context.env.COMPUTER.list(input)),
+            ),
     }),
     readFile: defineAppMethod({
       description:
@@ -174,9 +191,11 @@ export const appBackend = defineAppBackend({
       input: readInput,
       output: readReply,
       handler: async (input, context: InkcapBackendContext, caller) =>
-        caller.computerId === null || !context.env.COMPUTER?.read
+        caller.computerId === null
           ? refusal.parse({ error: "not_granted" })
-          : readReply.parse(await context.env.COMPUTER.read(input)),
+          : readReply.parse(
+              await computerCall(() => context.env.COMPUTER.read(input)),
+            ),
     }),
     writeFile: defineAppMethod({
       description:
@@ -185,10 +204,32 @@ export const appBackend = defineAppBackend({
       requires: ["computer.writeFile"],
       input: writeInput,
       output: writeReply,
+      present: {
+        rows: resultRows,
+        verb: "wrote",
+        row: ({ output }) =>
+          "error" in output
+            ? {
+                id: "refused",
+                title: "Inkcap could not write the file",
+                detail: output.error,
+                tone: "error",
+              }
+            : {
+                id: output.path,
+                title: `Inkcap wrote ${output.path.split("/").at(-1) ?? output.path}`,
+                detail: `${output.path} · ${String(output.bytes)} bytes`,
+                open: {
+                  params: filesNavigateIntent({ path: output.path }).params,
+                },
+              },
+      },
       handler: async (input, context: InkcapBackendContext, caller) =>
-        caller.computerId === null || !context.env.COMPUTER?.write
+        caller.computerId === null
           ? refusal.parse({ error: "not_granted" })
-          : writeReply.parse(await context.env.COMPUTER.write(input)),
+          : writeReply.parse(
+              await computerCall(() => context.env.COMPUTER.write(input)),
+            ),
     }),
   },
 });

package/backend/test/gills.test.ts

@@ -27,7 +27,7 @@ it("projects the saved Recent Files source with stable identities and its own cu
     documentsChanged: () => Promise.resolve(),
     env: {
       APP_STORAGE: { read: unavailable, write: unavailable },
-      COMPUTER: { read: unavailable },
+      COMPUTER: { list: unavailable, read: unavailable, write: unavailable },
     },
   };
   const caller = {

package/backend/test/methods.test.ts

@@ -37,6 +37,7 @@ const unavailable = (): Promise<never> =>
   Promise.reject(new Error("Computer calls must not access repositories"));
 const unrelated = {
   APP_STORAGE: { read: unavailable, write: unavailable },
+  COMPUTER: { list: unavailable, read: unavailable, write: unavailable },
 };
 const emptyMarker = () =>
   Promise.resolve({
@@ -49,7 +50,7 @@ const emptyMarker = () =>
       canWriteTeam: false,
     },
   });
-type ComputerBinding = NonNullable<InkcapBackendContext["env"]["COMPUTER"]>;
+type ComputerBinding = InkcapBackendContext["env"]["COMPUTER"];
 
 const caller: Parameters<typeof appBackend.call>[3] = {
   actor: { kind: "agent", agentId: "agent-a" },
@@ -69,9 +70,8 @@ it("lists files only through the admitted pinned Computer binding", async () =>
         env: {
           ...unrelated,
           COMPUTER: {
-            list: (
-              input: Parameters<NonNullable<ComputerBinding["list"]>>[0],
-            ) => {
+            ...unrelated.COMPUTER,
+            list: (input: Parameters<ComputerBinding["list"]>[0]) => {
               calls.push(input);
               return Promise.resolve(reply);
             },
@@ -95,6 +95,7 @@ it("does not dispatch when the caller has no pinned Computer", async () => {
       env: {
         ...unrelated,
         COMPUTER: {
+          ...unrelated.COMPUTER,
           read: () => {
             calls++;
             return Promise.resolve({});
@@ -116,7 +117,8 @@ it("forwards bounded byte reads and compare-and-swap writes", async () => {
     env: {
       ...unrelated,
       COMPUTER: {
-        read: (input: Parameters<NonNullable<ComputerBinding["read"]>>[0]) => {
+        ...unrelated.COMPUTER,
+        read: (input: Parameters<ComputerBinding["read"]>[0]) => {
           calls.push(input);
           return Promise.resolve({
             path: "/notes",
@@ -126,9 +128,7 @@ it("forwards bounded byte reads and compare-and-swap writes", async () => {
             truncated: false,
           });
         },
-        write: (
-          input: Parameters<NonNullable<ComputerBinding["write"]>>[0],
-        ) => {
+        write: (input: Parameters<ComputerBinding["write"]>[0]) => {
           calls.push(input);
           return Promise.resolve({ path: "/notes", bytes: 2 });
         },
@@ -230,6 +230,7 @@ it("retains typed conflict and attachment budget refusals", async () => {
           env: {
             ...unrelated,
             COMPUTER: {
+              ...unrelated.COMPUTER,
               write: () => Promise.resolve(z.json().parse(response)),
             },
           },
@@ -239,16 +240,77 @@ it("retains typed conflict and attachment budget refusals", async () => {
     ).toEqual(response);
   }
 });
-it("refuses a missing Computer binding", async () => {
-  expect(
-    await appBackend.call(
-      "readFile",
-      { path: "/notes" },
-      { activity, documentsChanged, env: unrelated },
-      caller,
-    ),
-  ).toEqual({ error: "not_granted" });
-});
+it.each([
+  ["listFiles", {}],
+  ["readFile", { path: "/notes" }],
+  ["writeFile", { path: "/notes", content: "hi" }],
+] as const)(
+  "maps the host's missing-grant refusal for %s",
+  async (method, input) => {
+    const denied = (): Promise<never> =>
+      Promise.reject(
+        Object.assign(new Error("App binding refused: binding_not_granted"), {
+          name: "AppInstanceError",
+          code: "binding_not_granted",
+        }),
+      );
+    await expect(
+      appBackend.call(
+        method,
+        input,
+        {
+          activity,
+          documentsChanged,
+          env: {
+            ...unrelated,
+            COMPUTER: { list: denied, read: denied, write: denied },
+          },
+        },
+        caller,
+      ),
+    ).resolves.toEqual({ error: "not_granted" });
+  },
+);
+it.each([
+  ["listFiles", {}],
+  ["readFile", { path: "/notes" }],
+  ["writeFile", { path: "/notes", content: "hi" }],
+] as const)(
+  "preserves other binding failures for %s",
+  async (method, input) => {
+    for (const failure of [
+      Object.assign(new Error("App binding refused: binding_unavailable"), {
+        name: "AppInstanceError",
+        code: "binding_unavailable",
+      }),
+      Object.assign(
+        new Error("App binding refused: invalid_invocation_facts"),
+        {
+          name: "AppInstanceError",
+          code: "invalid_invocation_facts",
+        },
+      ),
+      new Error("binding_not_granted"),
+    ]) {
+      const failed = (): Promise<never> => Promise.reject(failure);
+      await expect(
+        appBackend.call(
+          method,
+          input,
+          {
+            activity,
+            documentsChanged,
+            env: {
+              ...unrelated,
+              COMPUTER: { list: failed, read: failed, write: failed },
+            },
+          },
+          caller,
+        ),
+      ).rejects.toBe(failure);
+    }
+  },
+);
 it("does not expose Computer methods through unauthenticated repository HTTP", async () => {
   expect(
     (await Inkcap.prototype.fetch(new Request("https://inkcap.test/"))).status,
@@ -274,6 +336,7 @@ it("persists admitted document activity and pages saved rows without provider ca
     activity,
     documentsChanged,
     env: {
+      ...unrelated,
       APP_STORAGE: {
         read: emptyMarker,
         write: (input) => {
@@ -311,6 +374,7 @@ it("keeps cursor pages and activity private to the actor and pinned Computer", a
     activity: createDocumentActivityStore(sql),
     documentsChanged,
     env: {
+      ...unrelated,
       APP_STORAGE: {
         read: emptyMarker,
         write: () =>
@@ -386,6 +450,7 @@ it("bounds retained documents and returns source continuation without trimming a
     activity,
     documentsChanged,
     env: {
+      ...unrelated,
       APP_STORAGE: {
         read: emptyMarker,
         write: () =>
@@ -440,6 +505,7 @@ it("preserves the original marker failure without any provider or retry", async
         activity,
         documentsChanged,
         env: {
+          ...unrelated,
           APP_STORAGE: {
             read: emptyMarker,
             write: () => {

package/backend/test/present.test.ts

@@ -0,0 +1,25 @@
+import { expect, it } from "vitest";
+import { appBackend } from "../methods.js";
+
+it("reads a written file as a row that opens it in Inkcap", () => {
+  expect(
+    appBackend.methods.writeFile?.present?.(
+      { path: "/storyboard/storyboard.md", content: "# Panels" },
+      { path: "/storyboard/storyboard.md", bytes: 8 },
+    ),
+  ).toEqual({
+    id: "/storyboard/storyboard.md",
+    title: "Inkcap wrote storyboard.md",
+    detail: "/storyboard/storyboard.md · 8 bytes",
+    open: { params: [{ key: "path", value: "/storyboard/storyboard.md" }] },
+  });
+});
+
+it("reads a refused write as an error row", () => {
+  expect(
+    appBackend.methods.writeFile?.present?.(
+      { path: "/a.md", content: "x" },
+      { error: "not_granted" },
+    ),
+  ).toMatchObject({ title: "Inkcap could not write the file", tone: "error" });
+});