@fungi.computer/inkcap 0.0.0-stage → 0.0.1

package/backend/test/gills.test.ts

@@ -0,0 +1,156 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { appBackend, type InkcapBackendContext } from "../methods.js";
+import { createDocumentActivityStore } from "../document-activity.js";
+import { documentsRecentSchema } from "../../src/document-activity-contract.js";
+
+it("projects the saved Recent Files source with stable identities and its own cursor without providers", async () => {
+  const db = new DatabaseSync(":memory:");
+  let providerCalls = 0;
+  const unavailable = (): Promise<never> => {
+    providerCalls++;
+    return Promise.reject(new Error("Recent Files must not call a provider"));
+  };
+  const context: InkcapBackendContext = {
+    activity: createDocumentActivityStore({
+      exec(query, ...bindings) {
+        const rows = db
+          .prepare(query)
+          .all(
+            ...bindings.map((value) =>
+              value instanceof ArrayBuffer ? new Uint8Array(value) : value,
+            ),
+          );
+        return { toArray: () => rows };
+      },
+    }),
+    documentsChanged: () => Promise.resolve(),
+    env: {
+      APP_STORAGE: { read: unavailable, write: unavailable },
+      COMPUTER: { read: unavailable },
+    },
+  };
+  const caller = {
+    actor: { kind: "member" as const, memberId: "member-a" },
+    computerId: "computer-a",
+  };
+  try {
+    for (let i = 0; i < 11; i++)
+      await appBackend.call(
+        "documents.opened",
+        { computerId: "computer-a", path: `/notes/file-${String(i)}.md` },
+        context,
+        caller,
+      );
+    const source = documentsRecentSchema.parse(
+      await appBackend.call("documents.recent", { limit: 10 }, context, caller),
+    );
+    const first = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in first) || first.state !== "full")
+      throw new Error("Expected recorded files");
+    expect(first.rows).toHaveLength(10);
+    expect(first.rows.map((row) => row.id)).toEqual(
+      source.rows.map((row) => row.id),
+    );
+    expect(first.rows[0]?.open?.params).toEqual([
+      { key: "path", value: "/notes/file-10.md" },
+    ]);
+    expect(first.next).toBe(JSON.stringify(source.next));
+    const second = await appBackend.gill(
+      {
+        id: "recent-files",
+        params: { computer: "computer-a" },
+        after: first.next,
+      },
+      context,
+      caller,
+    );
+    if (!("rows" in second) || second.state !== "full")
+      throw new Error("Expected the final recorded file");
+    expect(second.rows).toHaveLength(1);
+    expect(second.rows[0]?.open?.params).toEqual([
+      { key: "path", value: "/notes/file-0.md" },
+    ]);
+    expect(second.next).toBeUndefined();
+    const identity = first.rows[0]?.id;
+    await appBackend.call(
+      "documents.edited",
+      { computerId: "computer-a", path: "/notes/file-10.md" },
+      context,
+      caller,
+    );
+    const updated = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in updated) || updated.state !== "full")
+      throw new Error("Expected edited files");
+    expect(updated.rows[0]?.id).toBe(identity);
+    expect(updated.rows[0]?.detail).toContain("Edited");
+    // These paths are accepted metadata from the public recording method, not a filesystem-open proof.
+    for (let i = 0; i < 10; i++)
+      await appBackend.call(
+        "documents.opened",
+        {
+          computerId: "computer-a",
+          path: `/${"界".repeat(4094)}${String(i)}`,
+        },
+        context,
+        caller,
+      );
+    const longPage = await appBackend.gill(
+      { id: "recent-files", params: { computer: "computer-a" } },
+      context,
+      caller,
+    );
+    if (!("rows" in longPage) || longPage.state !== "full")
+      throw new Error("Expected all saved long-path records");
+    expect(longPage.rows).toHaveLength(10);
+    expect(longPage.rows[0]?.open?.params).toEqual([
+      { key: "path", value: `/${"界".repeat(4094)}9` },
+    ]);
+    expect(longPage.rows[9]?.open?.params).toEqual([
+      { key: "path", value: `/${"界".repeat(4094)}0` },
+    ]);
+    expect(longPage.rows[0]?.title.length).toBeLessThan(4095);
+    expect(
+      new TextEncoder().encode(JSON.stringify(longPage)).byteLength,
+    ).toBeLessThanOrEqual(240 * 1024);
+    expect(providerCalls).toBe(0);
+  } finally {
+    db.close();
+  }
+});
+
+it("keeps missing Computer access distinct from an empty activity page and rejects malformed source cursors", async () => {
+  const { recentFilesGill } = await import("../gills.js");
+  expect(
+    recentFilesGill.rows({ error: "not_granted" }, { params: {} }),
+  ).toMatchObject({
+    state: "error",
+    rows: [],
+    error: "Choose a Computer and allow Inkcap to read its files.",
+    recovery: { kind: "configure", param: "computer" },
+  });
+  expect(
+    recentFilesGill.rows({ rows: [], next: null }, { params: {} }),
+  ).toMatchObject({ state: "empty", rows: [] });
+  expect(recentFilesGill.declaration.watch).toEqual({
+    storage: "documents-recent",
+  });
+  expect(() =>
+    recentFilesGill.input({ params: {}, limit: 10, after: '{"before":0}' }),
+  ).toThrow();
+  expect(() =>
+    recentFilesGill.input({
+      params: {},
+      limit: 10,
+      after: '{"before":1,"computerId":"other"}',
+    }),
+  ).toThrow();
+});

package/backend/test/methods.test.ts

@@ -0,0 +1,456 @@
+import { markDocumentsChanged } from "../documents-changed.js";
+import { documentsRecentSchema } from "../../src/document-activity-contract.js";
+import { afterAll, expect, it } from "vitest";
+import * as z from "zod";
+import { DatabaseSync } from "node:sqlite";
+import { createDocumentActivityStore } from "../document-activity.js";
+import type { ReadCopySql } from "@fungi.computer/agar/read-copy";
+import { Inkcap } from "../index.js";
+import { buildAppApi } from "@fungi.computer/agar/backend-declaration";
+import { appBackend, type InkcapBackendContext } from "../methods.js";
+
+const db = new DatabaseSync(":memory:");
+afterAll(() => {
+  db.close();
+});
+const sql: ReadCopySql = {
+  exec(query, ...bindings) {
+    const rows = db
+      .prepare(query)
+      .all(
+        ...bindings.map((value) =>
+          value instanceof ArrayBuffer ? new Uint8Array(value) : value,
+        ),
+      );
+    return { toArray: () => rows };
+  },
+};
+const activity = createDocumentActivityStore(sql);
+function documentsChanged(
+  this: Pick<InkcapBackendContext, "env">,
+  computerId: string,
+  sequence: number,
+): Promise<void> {
+  return markDocumentsChanged(this.env.APP_STORAGE, computerId, sequence);
+}
+const unavailable = (): Promise<never> =>
+  Promise.reject(new Error("Computer calls must not access repositories"));
+const unrelated = {
+  APP_STORAGE: { read: unavailable, write: unavailable },
+};
+const emptyMarker = () =>
+  Promise.resolve({
+    kind: "accepted" as const,
+    value: {
+      value: null,
+      source: "none" as const,
+      team: null,
+      member: null,
+      canWriteTeam: false,
+    },
+  });
+type ComputerBinding = NonNullable<InkcapBackendContext["env"]["COMPUTER"]>;
+
+const caller: Parameters<typeof appBackend.call>[3] = {
+  actor: { kind: "agent", agentId: "agent-a" },
+  computerId: "computer-a",
+};
+
+it("lists files only through the admitted pinned Computer binding", async () => {
+  const calls: unknown[] = [];
+  const reply = { path: "/", entries: [], nextOffset: null };
+  await expect(
+    appBackend.call(
+      "listFiles",
+      {},
+      {
+        activity,
+        documentsChanged,
+        env: {
+          ...unrelated,
+          COMPUTER: {
+            list: (
+              input: Parameters<NonNullable<ComputerBinding["list"]>>[0],
+            ) => {
+              calls.push(input);
+              return Promise.resolve(reply);
+            },
+          },
+        },
+      },
+      caller,
+    ),
+  ).resolves.toEqual(reply);
+  expect(calls).toEqual([{ path: "/", limit: 100, offset: 0 }]);
+});
+
+it("does not dispatch when the caller has no pinned Computer", async () => {
+  let calls = 0;
+  const result = await appBackend.call(
+    "readFile",
+    { path: "/notes" },
+    {
+      activity,
+      documentsChanged,
+      env: {
+        ...unrelated,
+        COMPUTER: {
+          read: () => {
+            calls++;
+            return Promise.resolve({});
+          },
+        },
+      },
+    },
+    { ...caller, computerId: null },
+  );
+  expect(result).toEqual({ error: "not_granted" });
+  expect(calls).toBe(0);
+});
+
+it("forwards bounded byte reads and compare-and-swap writes", async () => {
+  const calls: unknown[] = [];
+  const context = {
+    activity,
+    documentsChanged,
+    env: {
+      ...unrelated,
+      COMPUTER: {
+        read: (input: Parameters<NonNullable<ComputerBinding["read"]>>[0]) => {
+          calls.push(input);
+          return Promise.resolve({
+            path: "/notes",
+            byteOffset: 5,
+            content: "aGk=",
+            encoding: "base64",
+            truncated: false,
+          });
+        },
+        write: (
+          input: Parameters<NonNullable<ComputerBinding["write"]>>[0],
+        ) => {
+          calls.push(input);
+          return Promise.resolve({ path: "/notes", bytes: 2 });
+        },
+      },
+    },
+  };
+  await expect(
+    appBackend.call(
+      "readFile",
+      { path: "/notes", byteOffset: 5, byteLength: 2 },
+      context,
+      caller,
+    ),
+  ).resolves.toMatchObject({ content: "aGk=", byteOffset: 5 });
+  await expect(
+    appBackend.call(
+      "writeFile",
+      { path: "/notes", content: "hi", expectedContent: "old" },
+      context,
+      caller,
+    ),
+  ).resolves.toEqual({ path: "/notes", bytes: 2 });
+  expect(calls).toEqual([
+    { path: "/notes", byteOffset: 5, byteLength: 2 },
+    { path: "/notes", content: "hi", expectedContent: "old" },
+  ]);
+});
+
+it.each([
+  ["listFiles", { computerId: "other" }],
+  ["listFiles", { limit: 257 }],
+  ["readFile", { path: "relative" }],
+  ["readFile", { path: "/a/../b" }],
+  ["readFile", { path: "/a\0b" }],
+  ["readFile", { path: "/a", byteLength: 131073 }],
+  ["writeFile", { path: "/a", content: "a".repeat(49153) }],
+  ["writeFile", { path: "/a", content: "é".repeat(24577) }],
+  [
+    "writeFile",
+    {
+      path: "/a",
+      content: "a".repeat(30000),
+      expectedContent: "b".repeat(30000),
+    },
+  ],
+])("rejects invalid %s input before dispatch", async (method, input) => {
+  let calls = 0;
+  const invoke = () => {
+    calls++;
+    return Promise.resolve({});
+  };
+  await expect(
+    appBackend.call(
+      method,
+      input,
+      {
+        activity,
+        documentsChanged,
+        env: {
+          ...unrelated,
+          COMPUTER: { list: invoke, read: invoke, write: invoke },
+        },
+      },
+      caller,
+    ),
+  ).rejects.toThrow();
+  expect(calls).toBe(0);
+});
+
+it("edits repositories only through Bonsai, never through its own Git methods", () => {
+  const methods = Object.keys(buildAppApi(appBackend).methods);
+  expect(methods).toEqual(
+    expect.arrayContaining(["listFiles", "readFile", "writeFile"]),
+  );
+  for (const retired of [
+    "snapshot",
+    "read",
+    "commit",
+    "history.recent",
+    "rebuildCopies",
+    "discard",
+    "sync",
+  ])
+    expect(methods).not.toContain(retired);
+});
+
+it("retains typed conflict and attachment budget refusals", async () => {
+  for (const response of [
+    { error: "conflict" },
+    { error: "attachment_budget_exceeded", kind: "write", retryAfterMs: 1000 },
+  ]) {
+    expect(
+      await appBackend.call(
+        "writeFile",
+        { path: "/a", content: "hi" },
+        {
+          activity,
+          documentsChanged,
+          env: {
+            ...unrelated,
+            COMPUTER: {
+              write: () => Promise.resolve(z.json().parse(response)),
+            },
+          },
+        },
+        caller,
+      ),
+    ).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("does not expose Computer methods through unauthenticated repository HTTP", async () => {
+  expect(
+    (await Inkcap.prototype.fetch(new Request("https://inkcap.test/"))).status,
+  ).toBe(405);
+  expect(
+    (
+      await Inkcap.prototype.fetch(
+        new Request("https://inkcap.test/", {
+          method: "PUT",
+          body: JSON.stringify({
+            method: "writeFile",
+            input: { path: "/notes", content: "hi" },
+          }),
+        }),
+      )
+    ).status,
+  ).toBe(403);
+});
+
+it("persists admitted document activity and pages saved rows without provider calls", async () => {
+  const markers: unknown[] = [];
+  const context: InkcapBackendContext = {
+    activity,
+    documentsChanged,
+    env: {
+      APP_STORAGE: {
+        read: emptyMarker,
+        write: (input) => {
+          markers.push(input);
+          return Promise.resolve({
+            kind: "accepted",
+            value: { revision: markers.length },
+          });
+        },
+      },
+    },
+  };
+  for (const path of ["/first.txt", "/second.txt", "/third.txt"])
+    await appBackend.call(
+      "documents.opened",
+      { computerId: "computer-a", path },
+      context,
+      caller,
+    );
+  const page = await appBackend.call(
+    "documents.recent",
+    { limit: 2 },
+    context,
+    caller,
+  );
+  expect(page).toMatchObject({
+    rows: [{ path: "/third.txt" }, { path: "/second.txt" }],
+    next: { before: 2 },
+  });
+  expect(markers).toHaveLength(3);
+});
+
+it("keeps cursor pages and activity private to the actor and pinned Computer", async () => {
+  const context = {
+    activity: createDocumentActivityStore(sql),
+    documentsChanged,
+    env: {
+      APP_STORAGE: {
+        read: emptyMarker,
+        write: () =>
+          Promise.resolve({
+            kind: "accepted" as const,
+            value: { revision: 1 },
+          }),
+      },
+    },
+  };
+  expect(
+    await appBackend.call(
+      "documents.recent",
+      { limit: 2, after: { before: 2 } },
+      context,
+      caller,
+    ),
+  ).toMatchObject({
+    rows: [{ path: "/first.txt", activity: "opened" }],
+    next: null,
+  });
+  for (const other of [
+    { ...caller, computerId: "computer-b" },
+    { ...caller, actor: { kind: "member" as const, memberId: "member-b" } },
+  ])
+    expect(
+      await appBackend.call("documents.recent", {}, context, other),
+    ).toEqual({ rows: [], next: null });
+  expect(
+    await appBackend.call(
+      "documents.opened",
+      { computerId: "computer-b", path: "/private" },
+      context,
+      caller,
+    ),
+  ).toEqual({ error: "not_granted" });
+  expect(
+    await appBackend.call("documents.recent", {}, context, {
+      ...caller,
+      computerId: null,
+    }),
+  ).toEqual({ error: "not_granted" });
+  const earlier = documentsRecentSchema.parse(
+    await appBackend.call(
+      "documents.recent",
+      { limit: 2, after: { before: 2 } },
+      context,
+      caller,
+    ),
+  );
+  await appBackend.call(
+    "documents.edited",
+    { computerId: "computer-a", path: "/first.txt" },
+    context,
+    caller,
+  );
+  const edited = documentsRecentSchema.parse(
+    await appBackend.call("documents.recent", { limit: 1 }, context, caller),
+  );
+  expect(edited.rows[0]?.id).toBe(earlier.rows[0]?.id);
+  expect(edited).toMatchObject({
+    rows: [{ path: "/first.txt", activity: "edited", sequence: 4 }],
+    next: { before: 4 },
+  });
+});
+
+it("bounds retained documents and returns source continuation without trimming a supplied page", async () => {
+  const retained = {
+    ...caller,
+    actor: { kind: "member" as const, memberId: "retention-member" },
+  };
+  const context = {
+    activity,
+    documentsChanged,
+    env: {
+      APP_STORAGE: {
+        read: emptyMarker,
+        write: () =>
+          Promise.resolve({
+            kind: "accepted" as const,
+            value: { revision: 1 },
+          }),
+      },
+    },
+  };
+  for (let i = 0; i < 110; i++)
+    await appBackend.call(
+      "documents.opened",
+      { computerId: "computer-a", path: `/file-${String(i)}` },
+      context,
+      retained,
+    );
+  const first = await appBackend.call(
+    "documents.recent",
+    { limit: 50 },
+    context,
+    retained,
+  );
+  const firstPage = documentsRecentSchema.parse(first);
+  expect(firstPage.rows).toHaveLength(50);
+  expect(firstPage.rows[0]?.path).toBe("/file-109");
+  expect(firstPage.next).toEqual({ before: 61 });
+  const last = documentsRecentSchema.parse(
+    await appBackend.call(
+      "documents.recent",
+      { limit: 50, after: { before: 61 } },
+      context,
+      retained,
+    ),
+  );
+  expect(last.rows).toHaveLength(50);
+  expect(last.rows.at(-1)?.path).toBe("/file-10");
+  expect(last.next).toBeNull();
+  await expect(
+    appBackend.call("documents.recent", { limit: 51 }, context, retained),
+  ).rejects.toThrow();
+});
+
+it("preserves the original marker failure without any provider or retry", async () => {
+  const failure = new Error("private marker failure");
+  let writes = 0;
+  await expect(
+    appBackend.call(
+      "documents.opened",
+      { computerId: "computer-a", path: "/accepted-open" },
+      {
+        activity,
+        documentsChanged,
+        env: {
+          APP_STORAGE: {
+            read: emptyMarker,
+            write: () => {
+              writes++;
+              return Promise.reject(failure);
+            },
+          },
+        },
+      },
+      caller,
+    ),
+  ).rejects.toBe(failure);
+  expect(writes).toBe(1);
+});

package/backend/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "types": ["@cloudflare/workers-types"],
+    "lib": ["ES2022"],
+    "noEmit": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["*.ts", "test/**/*.ts"]
+}

package/backend/vitest.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+  resolve: {
+    alias: {
+      "cloudflare:workers": new URL(
+        "./test/cloudflare-workers.fixture.ts",
+        import.meta.url,
+      ).pathname,
+    },
+  },
+  test: { environment: "node", include: ["backend/test/*.test.{ts,mjs}"] },
+});