@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/read-copy-rpc.worker.ts

@@ -0,0 +1,92 @@
+/** A native service binding retains the same RPC method semantics as the host's GIT slot. */
+import { WorkerEntrypoint } from "cloudflare:workers";
+import {
+  countingGit,
+  ReadCopyBudgetExceeded,
+} from "@fungi.computer/agar/read-copy";
+import type { GitBinding } from "@fungi.computer/agar/git";
+
+export class GitRpc extends WorkerEntrypoint implements GitBinding {
+  create(name: string) {
+    return this.info(name);
+  }
+  fork(_source: string, name: string) {
+    return this.info(name);
+  }
+  cloneUrl() {
+    return Promise.resolve("https://git.test/pond.git");
+  }
+  info(name: string) {
+    return Promise.resolve({
+      name,
+      defaultBranch: "main",
+      lastPushAt: null,
+      source: null,
+    });
+  }
+  delete() {
+    return Promise.resolve(true);
+  }
+  log() {
+    return Promise.resolve([]);
+  }
+  readCommit() {
+    return Promise.resolve(null);
+  }
+  readTree() {
+    return Promise.resolve(null);
+  }
+  readBlob() {
+    return Promise.resolve(null);
+  }
+  refs() {
+    return Promise.resolve([]);
+  }
+  exchange() {
+    return Promise.resolve({
+      status: 200,
+      headers: {},
+      body: new Uint8Array(),
+    });
+  }
+}
+
+export default {
+  async fetch(_request, env) {
+    const direct = await env.GIT.info("pond");
+    const lifetime = new AbortController();
+    try {
+      const counted = countingGit(env.GIT, {
+        limit: 1,
+        signal: lifetime.signal,
+      });
+      const wrapped = await counted.git.info("pond");
+      let exhausted = false;
+      try {
+        await counted.git.info("pond");
+      } catch (error) {
+        if (!(error instanceof ReadCopyBudgetExceeded)) throw error;
+        exhausted = true;
+      }
+      lifetime.abort();
+      let aborted = false;
+      try {
+        await counted.git.info("pond");
+      } catch (error) {
+        if (!(error instanceof DOMException) || error.name !== "AbortError")
+          throw error;
+        aborted = true;
+      }
+      return Response.json({
+        direct,
+        wrapped,
+        total: counted.total(),
+        counts: counted.counts(),
+        exhausted,
+        aborted,
+      });
+    } finally {
+      lifetime.abort();
+    }
+  },
+} satisfies ExportedHandler<{ GIT: Service<GitRpc> }>;

package/test/recent-activity.test.ts

@@ -0,0 +1,62 @@
+// @vitest-environment jsdom
+import { afterEach, beforeEach, expect, it, vi } from "vitest";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import type { Activity } from "../shared/contract.js";
+import { WorkingNow } from "../web/working-now.js";
+
+let container: HTMLDivElement;
+let root: ReturnType<typeof createRoot>;
+
+beforeEach(() => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date("2026-10-13T12:00:00Z"));
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+  container = document.createElement("div");
+  document.body.appendChild(container);
+  root = createRoot(container);
+});
+
+afterEach(() => {
+  act(() => {
+    root.unmount();
+  });
+  container.remove();
+  vi.useRealTimers();
+});
+
+it("expires recent push activity without another event or page reload", async () => {
+  const events: Activity[] = [
+    {
+      id: 1,
+      at: Date.now() - 8 * 60_000,
+      type: "push",
+      repo: "koi-pond--enoki",
+      actor: "enoki",
+      data: {
+        updates: [
+          {
+            ref: "refs/heads/main",
+            before: "0".repeat(40),
+            after: "a".repeat(40),
+          },
+        ],
+        commits: [],
+        paths: ["src/pond.ts"],
+      },
+    },
+  ];
+  act(() => {
+    root.render(
+      createElement(WorkingNow, {
+        events,
+        colors: new Map([["enoki", { color: "c1", kind: "agent" as const }]]),
+      }),
+    );
+  });
+  expect(container.querySelectorAll("li")).toHaveLength(1);
+  await act(async () => {
+    await vi.advanceTimersByTimeAsync(7 * 60_000 + 1);
+  });
+  expect(container.querySelectorAll("li")).toHaveLength(0);
+});

package/test/repository-deletion.test.ts

@@ -0,0 +1,500 @@
+import { DatabaseSync } from "node:sqlite";
+import { rmSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { createAdmittedGit, createGitDoor } from "@fungi.computer/oyster/git";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import type { AppMethodCallContext } from "@fungi.computer/puffball/app-method-runtime";
+import { expect, it, vi } from "vitest";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { BonsaiState, ensureBonsaiTables } from "../backend/state.js";
+import type { Bonsai } from "../backend/service.js";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  const sql = fromNodeSqlite(database);
+  ensureBonsaiTables(sql.sql);
+  const state = new BonsaiState(sql.sql, sql.transactionSync);
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const unavailable = () =>
+    Promise.reject(new Error("Unexpected provider operation"));
+  const deletion = vi.fn<GitBinding["delete"]>(() => Promise.resolve(true));
+  const binding: GitBinding = {
+    create: unavailable,
+    fork: unavailable,
+    cloneUrl: unavailable,
+    info: unavailable,
+    delete: deletion,
+    log: unavailable,
+    readCommit: unavailable,
+    readTree: unavailable,
+    readBlob: unavailable,
+    refs: unavailable,
+    exchange: unavailable,
+  };
+  const emit = vi.fn(() => Promise.resolve());
+  const bonsai: Bonsai = { state, store: gitStore(binding), events: { emit } };
+  return { database, sql, state, binding, deletion, emit, bonsai };
+}
+
+it("refuses repository deletion before state or provider writes for every non-owner caller", async () => {
+  const callers: readonly AppMethodCallContext[] = [
+    { computerId: null, actor: { kind: "member", memberId: "Owner" } },
+    {
+      computerId: null,
+      actor: { kind: "member", memberId: "member" },
+      role: "member",
+    },
+    {
+      computerId: null,
+      actor: { kind: "agent", agentId: "agent" },
+      role: "owner",
+    },
+    {
+      computerId: null,
+      actor: { kind: "team-key", keyId: "key" },
+      role: "owner",
+    },
+  ];
+  for (const caller of callers) {
+    const f = fixture();
+    try {
+      const before = f.state.repo("pond");
+      await expect(
+        appBackend.call(
+          "repos.delete",
+          { repo: "pond" },
+          { bonsai: f.bonsai },
+          caller,
+        ),
+      ).rejects.toMatchObject({ code: "forbidden" });
+      expect(f.state.repo("pond")).toEqual(before);
+      expect(f.deletion).not.toHaveBeenCalled();
+      expect(f.emit).not.toHaveBeenCalled();
+    } finally {
+      f.database.close();
+    }
+  }
+});
+
+it("withdraws the public listing and anonymous clone after owner deletion", async () => {
+  const f = fixture();
+  const provider = realGit();
+  try {
+    await provider.git.create("pond");
+    const binding: GitBinding = {
+      ...provider.git,
+      delete: async (name) => {
+        const listing = await appBackend.call(
+          "repos.list",
+          {},
+          { bonsai: f.bonsai },
+          owner,
+        );
+        expect(listing).toEqual({ repos: [] });
+        if ((await provider.git.info(name)) === null) return false;
+        rmSync(fileURLToPath(await provider.git.cloneUrl(name)), {
+          recursive: true,
+        });
+        return true;
+      },
+    };
+    const bonsai = { ...f.bonsai, store: gitStore(binding) };
+    const git = createAdmittedGit({
+      installationId: "bonsai",
+      store: binding,
+      grants: { admits: () => Promise.resolve(true) },
+      policy: {
+        authorize: () =>
+          Promise.reject(new Error("Anonymous clone never authorizes a push")),
+      },
+      journal: {
+        tip: () => Promise.reject(new Error("Clone has no write journal")),
+        record: () => Promise.reject(new Error("Clone never records a push")),
+      },
+    });
+    const door = createGitDoor({
+      authenticate: () => Promise.resolve(null),
+      isPublic: () => Promise.resolve(true),
+      git: () => Promise.resolve(git),
+    });
+    const path = "/git/bonsai/pond.git/info/refs?service=git-upload-pack";
+    expect((await door.request(path)).status).toBe(200);
+    await expect(
+      appBackend.call("repos.list", {}, { bonsai }, owner),
+    ).resolves.toMatchObject({ repos: [{ name: "pond" }] });
+    await expect(
+      appBackend.call("repos.delete", { repo: "pond" }, { bonsai }, owner),
+    ).resolves.toEqual({ deleted: true });
+    await expect(
+      appBackend.call("repos.list", {}, { bonsai }, owner),
+    ).resolves.toEqual({ repos: [] });
+    expect((await door.request(path)).status).toBe(404);
+    await expect(
+      appBackend.call("repos.delete", { repo: "pond" }, { bonsai }, owner),
+    ).resolves.toEqual({ deleted: true });
+    expect((await door.request(path)).status).toBe(404);
+  } finally {
+    provider.close();
+    f.database.close();
+  }
+});
+
+it("shares one same-name provider cleanup so a concurrent retry cannot outlive marker completion", async () => {
+  const f = fixture();
+  const entered = Promise.withResolvers<undefined>();
+  const provider = Promise.withResolvers<boolean>();
+  try {
+    f.deletion.mockImplementation(() => {
+      entered.resolve(undefined);
+      return provider.promise;
+    });
+    const first = appBackend.call(
+      "repos.delete",
+      { repo: "pond" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    await entered.promise;
+    const second = appBackend.call(
+      "repos.delete",
+      { repo: "pond" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    await expect(
+      appBackend.call(
+        "repos.create",
+        { name: "pond" },
+        { bonsai: f.bonsai },
+        owner,
+      ),
+    ).rejects.toMatchObject({ code: "conflict" });
+    provider.resolve(true);
+    await expect(Promise.all([first, second])).resolves.toEqual([
+      { deleted: true },
+      { deleted: true },
+    ]);
+    expect(f.deletion).toHaveBeenCalledTimes(1);
+  } finally {
+    provider.resolve(true);
+    f.database.close();
+  }
+});
+
+it.each(["create", "fork"] as const)(
+  "fences an older %s publication even after deletion cleanup completed",
+  async (kind) => {
+    const f = fixture();
+    const entered = Promise.withResolvers<undefined>();
+    const resume = Promise.withResolvers<string>();
+    const name = kind === "create" ? "pond" : "pond--Levi";
+    try {
+      let cloneCalls = 0;
+      const info = (name: string) =>
+        Promise.resolve({
+          name,
+          defaultBranch: "main",
+          lastPushAt: null,
+          source: null,
+        });
+      const binding: GitBinding = {
+        ...f.binding,
+        create: info,
+        fork: async (source, name) => ({ ...(await info(name)), source }),
+        refs: () => Promise.resolve([]),
+        cloneUrl: (repo) => {
+          cloneCalls += 1;
+          if (cloneCalls === 2) {
+            entered.resolve(undefined);
+            return resume.promise;
+          }
+          return Promise.resolve(`https://git.test/${repo}.git`);
+        },
+      };
+      const bonsai = { ...f.bonsai, store: gitStore(binding) };
+      const pending = appBackend.call(
+        kind === "create" ? "repos.create" : "repos.fork",
+        kind === "create" ? { name } : { repo: "pond" },
+        { bonsai },
+        owner,
+      );
+      const refused = expect(pending).rejects.toMatchObject({
+        code: "conflict",
+      });
+      await entered.promise;
+      await appBackend.call("repos.delete", { repo: name }, { bonsai }, owner);
+      resume.resolve(`https://git.test/${name}.git`);
+      await refused;
+      expect(f.state.repo(name)).toBeNull();
+    } finally {
+      resume.resolve(`https://git.test/${name}.git`);
+      f.database.close();
+    }
+  },
+);
+
+it("refuses a canonical repository with forks without modifying either repository", async () => {
+  const f = fixture();
+  try {
+    f.state.registerRepo({
+      name: "pond--Luna",
+      description: null,
+      parent: "pond",
+      owner: "Luna",
+    });
+    await expect(
+      appBackend.call(
+        "repos.delete",
+        { repo: "pond" },
+        { bonsai: f.bonsai },
+        owner,
+      ),
+    ).rejects.toMatchObject({ code: "conflict" });
+    expect(f.deletion).not.toHaveBeenCalled();
+    expect(f.state.repo("pond")?.forks).toEqual(["pond--Luna"]);
+    await appBackend.call(
+      "repos.delete",
+      { repo: "pond--Luna" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    expect(f.state.repo("pond")?.forks).toEqual([]);
+    await appBackend.call(
+      "repos.delete",
+      { repo: "pond" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    expect(f.state.repos()).toEqual([]);
+  } finally {
+    f.database.close();
+  }
+});
+
+it("keeps provider and catalog intact when the local withdrawal transaction fails", async () => {
+  const f = fixture();
+  try {
+    f.database.exec(
+      "CREATE TRIGGER refuse_deletion BEFORE DELETE ON repos BEGIN SELECT RAISE(ABORT, 'Local withdrawal failed'); END",
+    );
+    await expect(
+      appBackend.call(
+        "repos.delete",
+        { repo: "pond" },
+        { bonsai: f.bonsai },
+        owner,
+      ),
+    ).rejects.toThrow("Local withdrawal failed");
+    await expect(
+      appBackend.call("repos.list", {}, { bonsai: f.bonsai }, owner),
+    ).resolves.toMatchObject({ repos: [{ name: "pond" }] });
+    expect(f.deletion).not.toHaveBeenCalled();
+  } finally {
+    f.database.close();
+  }
+});
+
+it("preserves the readiness generation so an in-flight refresh cannot republish deleted refs", async () => {
+  const f = fixture();
+  try {
+    const revision = f.state.repositoryRefStatus("pond").revision;
+    await appBackend.call(
+      "repos.delete",
+      { repo: "pond" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    expect(
+      f.state.publishRepositoryRefs("pond", revision, null, {
+        defaultBranch: "main",
+        refs: [],
+        cloneUrl: "https://git.test/pond.git",
+        empty: true,
+      }),
+    ).toBe(false);
+    await expect(
+      appBackend.call(
+        "repos.get",
+        { repo: "pond" },
+        { bonsai: f.bonsai },
+        owner,
+      ),
+    ).rejects.toMatchObject({ code: "not_found" });
+  } finally {
+    f.database.close();
+  }
+});
+
+const owner: AppMethodCallContext = {
+  computerId: null,
+  actor: { kind: "member", memberId: "Levi" },
+  role: "owner",
+};
+
+it("keeps failed cleanup hidden and blocks name reuse across owner reopen until a retry succeeds", async () => {
+  const f = fixture();
+  try {
+    const failure = new Error("Provider temporarily unavailable");
+    f.deletion.mockRejectedValueOnce(failure);
+    await expect(
+      appBackend.call(
+        "repos.delete",
+        { repo: "pond" },
+        { bonsai: f.bonsai },
+        owner,
+      ),
+    ).rejects.toBe(failure);
+    await expect(
+      appBackend.call("repos.list", {}, { bonsai: f.bonsai }, owner),
+    ).resolves.toEqual({ repos: [] });
+    const reopened = {
+      ...f.bonsai,
+      state: new BonsaiState(f.sql.sql, f.sql.transactionSync),
+    };
+    await expect(
+      appBackend.call(
+        "repos.create",
+        { name: "pond" },
+        { bonsai: reopened },
+        owner,
+      ),
+    ).rejects.toMatchObject({ code: "conflict" });
+    await expect(
+      appBackend.call(
+        "repos.delete",
+        { repo: "pond" },
+        { bonsai: reopened },
+        owner,
+      ),
+    ).resolves.toEqual({ deleted: true });
+    expect(f.deletion).toHaveBeenCalledTimes(2);
+    const create = vi.fn((name: string) =>
+      Promise.resolve({
+        name,
+        defaultBranch: "main",
+        lastPushAt: null,
+        source: null,
+      }),
+    );
+    reopened.store = gitStore({
+      ...f.binding,
+      create,
+      refs: () => Promise.resolve([]),
+      cloneUrl: (name) => Promise.resolve(`https://git.test/${name}.git`),
+    });
+    await expect(
+      appBackend.call(
+        "repos.create",
+        { name: "pond" },
+        { bonsai: reopened },
+        owner,
+      ),
+    ).resolves.toMatchObject({ name: "pond" });
+    expect(create).toHaveBeenCalledTimes(1);
+  } finally {
+    f.database.close();
+  }
+});
+
+it.each(["create", "fork"] as const)(
+  "recreated %s metadata is ready without any warm provider reads",
+  async (kind) => {
+    const f = fixture();
+    try {
+      const name = kind === "create" ? "pond" : "pond--Levi";
+      if (kind === "fork")
+        f.state.registerRepo({
+          name,
+          description: null,
+          parent: "pond",
+          owner: "Levi",
+        });
+      await appBackend.call(
+        "repos.delete",
+        { repo: name },
+        { bonsai: f.bonsai },
+        owner,
+      );
+      const info = (name: string) =>
+        Promise.resolve({
+          name,
+          defaultBranch: "main",
+          lastPushAt: null,
+          source: null,
+        });
+      const readInfo = vi.fn(info);
+      const refs = vi.fn(() => Promise.resolve([]));
+      const cloneUrl = vi.fn((name: string) =>
+        Promise.resolve(`https://git.test/${name}.git`),
+      );
+      const bonsai = {
+        ...f.bonsai,
+        store: gitStore({
+          ...f.binding,
+          create: info,
+          fork: async (source, name) => ({ ...(await info(name)), source }),
+          info: readInfo,
+          refs,
+          cloneUrl,
+        }),
+      };
+      await appBackend.call(
+        kind === "create" ? "repos.create" : "repos.fork",
+        kind === "create" ? { name } : { repo: "pond" },
+        { bonsai },
+        owner,
+      );
+      readInfo.mockClear();
+      refs.mockClear();
+      cloneUrl.mockClear();
+      await expect(
+        appBackend.call("repos.get", { repo: name }, { bonsai }, owner),
+      ).resolves.toMatchObject({ repo: { name } });
+      expect(readInfo).not.toHaveBeenCalled();
+      expect(refs).not.toHaveBeenCalled();
+      expect(cloneUrl).not.toHaveBeenCalled();
+    } finally {
+      f.database.close();
+    }
+  },
+);
+
+it("advances the durable repository lifetime only on registration after absence", async () => {
+  const f = fixture();
+  try {
+    expect(f.state.repositoryGeneration("pond")).toBe(1);
+    f.state.registerRepo({
+      name: "pond",
+      description: null,
+      parent: null,
+      owner: null,
+    });
+    f.state.invalidateRepositoryRefs("pond");
+    expect(f.state.repositoryGeneration("pond")).toBe(1);
+    await appBackend.call(
+      "repos.delete",
+      { repo: "pond" },
+      { bonsai: f.bonsai },
+      owner,
+    );
+    const reopened = new BonsaiState(f.sql.sql, f.sql.transactionSync);
+    expect(reopened.repositoryGeneration("pond")).toBe(1);
+    reopened.registerRepo({
+      name: "pond",
+      description: null,
+      parent: null,
+      owner: null,
+    });
+    expect(reopened.repositoryGeneration("pond")).toBe(2);
+  } finally {
+    f.database.close();
+  }
+});