@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/git-push.native.mjs

@@ -0,0 +1,413 @@
+import assert from "node:assert/strict";
+import { URL } from "node:url";
+import { log } from "node:console";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { unstable_dev } from "wrangler";
+import * as z from "zod";
+import { appBackendActorHeader } from "@fungi.computer/agar/backend";
+import { codeInsights, savedLayout } from "../shared/insights.ts";
+import { buildAppDeclaration } from "@fungi.computer/agar/backend-declaration";
+import { appBackend as bonsaiBackend } from "../backend/methods.ts";
+import bonsaiMetadata from "../package.json" with { type: "json" };
+const appDeclaration = buildAppDeclaration(
+  bonsaiBackend,
+  bonsaiMetadata.fungi.app,
+);
+
+const fact = {
+  repository: "pond--ada",
+  writer: { kind: "actor", actor: { kind: "agent", agentId: "agent_ada" } },
+  updates: [
+    { ref: "refs/heads/main", before: "0".repeat(40), after: "b".repeat(40) },
+  ],
+  eventId: "push_1",
+};
+const state = await mkdtemp(join(tmpdir(), "bonsai-push-"));
+const start = () =>
+  unstable_dev(new URL("./git-push.worker.ts", import.meta.url).pathname, {
+    config: new URL("./git-push.config.jsonc", import.meta.url).pathname,
+    local: true,
+    ip: "127.0.0.1",
+    port: 0,
+    persist: true,
+    persistTo: state,
+    logLevel: "none",
+    experimental: {
+      disableExperimentalWarning: true,
+      disableDevRegistry: true,
+    },
+  });
+let worker;
+try {
+  worker = await start();
+  let origin = `http://127.0.0.1:${String(worker.port)}`;
+  const seeded = await globalThis.fetch(`${origin}/seed`, {
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(seeded.status, 204, await seeded.text());
+  const authorize = (question) =>
+    globalThis.fetch(`${origin}/authorize`, {
+      method: "POST",
+      body: JSON.stringify(question),
+      signal: globalThis.AbortSignal.timeout(10_000),
+    });
+  const update = {
+    ref: "refs/heads/main",
+    before: "a".repeat(40),
+    after: "b".repeat(40),
+  };
+  const agentQuestion = {
+    repository: "pond--ada",
+    writer: { kind: "actor", actor: { kind: "agent", agentId: "ada" } },
+    updates: [update],
+  };
+  const allowed = await authorize(agentQuestion);
+  assert.equal(allowed.status, 200);
+  assert.deepEqual(await allowed.json(), { allowed: true });
+  const denied = await authorize({
+    ...agentQuestion,
+    repository: "pond",
+    updates: [update, { ...update, ref: "refs/heads/topic" }],
+  });
+  assert.equal(denied.status, 200);
+  assert.deepEqual(await denied.json(), {
+    allowed: false,
+    refused: [
+      {
+        ref: "refs/heads/main",
+        message: "Writer cannot push to this repository",
+      },
+      {
+        ref: "refs/heads/topic",
+        message: "Writer cannot push to this repository",
+      },
+    ],
+  });
+  for (const question of [
+    { repo: "pond", actor: { name: "levi", kind: "human" } },
+    {
+      ...agentQuestion,
+      writer: {
+        kind: "actor",
+        actor: { kind: "human", name: "levi" },
+      },
+    },
+    { ...agentQuestion, updates: Array.from({ length: 257 }, () => update) },
+  ])
+    assert.equal((await authorize(question)).status, 400);
+  const response = await globalThis.fetch(origin, {
+    method: "POST",
+    body: JSON.stringify(fact),
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(response.status, 200, await response.clone().text());
+  const result = await response.json();
+  assert.deepEqual(appDeclaration.receives, ["git.push"]);
+  assert.deepEqual(
+    result.emitted.map((event) => event.type),
+    ["git.push", "change.opened"],
+  );
+  for (const event of result.emitted) {
+    const declaration = appDeclaration.api.events[event.type];
+    assert.ok(declaration, `${event.type} must be declared`);
+    assert.deepEqual(
+      z.fromJSONSchema(declaration.payload).parse(event.payload),
+      event.payload,
+    );
+    assert.equal(event.payload.data.eventId, event.eventId);
+    assert.equal(event.payload.data.actor, "agent_ada");
+    assert.deepEqual(event.payload.data.repository, {
+      name: "pond--ada",
+      canonical: "pond",
+      cloneUrl: "https://git.example.test/repos/pond--ada",
+    });
+    if (event.type === "git.push") {
+      assert.deepEqual(event.payload.data.activity.data, {
+        updates: fact.updates,
+        commits: [{ hash: "b".repeat(40), message: "Add food" }],
+        paths: ["food.txt"],
+      });
+    } else
+      assert.deepEqual(event.payload.data.change, {
+        repo: "pond",
+        number: 1,
+        sourceRepo: "pond--ada",
+        sourceRef: "main",
+        targetRef: "main",
+        head: "b".repeat(40),
+      });
+  }
+  assert.equal(
+    result.activity.filter((event) => event.type === "push").length,
+    1,
+  );
+  const tiles = {
+    view: "overview",
+    placements: [{ id: "network", col: 0, row: 0, w: 2, h: 1 }],
+  };
+  const method = async (name, input, actor = "levi", probe = "push") => {
+    const response = await globalThis.fetch(
+      `${origin}/methods?probe=${probe}`,
+      {
+        method: "PUT",
+        headers: { [appBackendActorHeader]: actor },
+        body: JSON.stringify({ method: name, input }),
+        signal: globalThis.AbortSignal.timeout(10_000),
+      },
+    );
+    assert.equal(response.status, 200, await response.clone().text());
+    return response.json();
+  };
+  assert.deepEqual(
+    savedLayout.parse(
+      await method("insights.layout.save", { repo: "pond", tiles }),
+    ),
+    { tiles },
+  );
+  assert.deepEqual(
+    savedLayout.parse(
+      await method("insights.layout.get", { repo: "pond" }, "ada"),
+    ),
+    { tiles: null },
+  );
+  // Warm projections exercise the real App method and native SQLite blob representation.
+  await method("repos.get", { repo: "pond--ada" });
+  const callsBefore = await (await globalThis.fetch(`${origin}/calls`)).json();
+  await method("repos.get", { repo: "pond--ada" });
+  await method("changes.list", { repo: "pond" });
+  await method("changes.get", { repo: "pond", number: 1 });
+  const callsAfter = await (await globalThis.fetch(`${origin}/calls`)).json();
+  assert.equal(
+    callsAfter.calls - callsBefore.calls,
+    0,
+    "warm repository and Change screens never call Git",
+  );
+  const insights = codeInsights.parse(
+    await method("insights.code", { repo: "pond", ref: "main" }),
+  );
+  assert.deepEqual(insights.files, [
+    { path: "food.txt", lines: 2, changes: 1 },
+  ]);
+  assert.equal(insights.partial, false);
+  await worker.stop();
+  worker = await start();
+  origin = `http://127.0.0.1:${String(worker.port)}`;
+  assert.deepEqual(
+    savedLayout.parse(await method("insights.layout.get", { repo: "pond" })),
+    { tiles },
+  );
+  const retry = await globalThis.fetch(origin, {
+    method: "POST",
+    body: JSON.stringify(fact),
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(retry.status, 200, await retry.clone().text());
+  const replayed = await retry.json();
+  assert.deepEqual(
+    replayed.activity,
+    result.activity,
+    "retry must not duplicate activity or lose commit attribution",
+  );
+  assert.deepEqual(
+    replayed.emitted,
+    [],
+    "acknowledged outbox envelopes must stay acknowledged across owner recreation",
+  );
+  const changed = await globalThis.fetch(origin, {
+    method: "POST",
+    body: JSON.stringify({
+      ...fact,
+      writer: { kind: "actor", actor: { kind: "agent", agentId: "mallory" } },
+    }),
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(
+    changed.status,
+    500,
+    "changed contents under the same canonical event ID must refuse",
+  );
+  const legacy = await globalThis.fetch(`${origin}/legacy`, {
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(
+    legacy.status,
+    405,
+    "the retired push POST must not remain a second router",
+  );
+
+  const seededFailure = await globalThis.fetch(`${origin}/seed?probe=failure`, {
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(seededFailure.status, 204, await seededFailure.text());
+  const failed = await globalThis.fetch(`${origin}/?probe=failure&fail`, {
+    method: "POST",
+    body: JSON.stringify(fact),
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(
+    failed.status,
+    200,
+    "best-effort delivery failure must preserve the committed push",
+  );
+  const committed = await failed.json();
+  assert.deepEqual(
+    committed.emitted,
+    [],
+    "failed delivery is not acknowledged",
+  );
+  assert.equal(
+    committed.activity.filter((event) => event.type === "push").length,
+    1,
+    "delivery failure does not roll back the committed activity",
+  );
+  await worker.stop();
+  worker = await start();
+  origin = `http://127.0.0.1:${String(worker.port)}`;
+  const recovered = await globalThis.fetch(`${origin}/?probe=failure`, {
+    method: "POST",
+    body: JSON.stringify(fact),
+    signal: globalThis.AbortSignal.timeout(10_000),
+  });
+  assert.equal(recovered.status, 200, await recovered.clone().text());
+  const retried = await recovered.json();
+  assert.equal(
+    retried.activity.filter((event) => event.type === "push").length,
+    1,
+  );
+  assert.deepEqual(
+    retried.emitted.map((event) => event.type),
+    ["git.push", "change.opened"],
+    "unacknowledged outbox envelopes survive owner restart and are retried",
+  );
+  assert.deepEqual(
+    retried.emitted.map((event) => event.payload.data.activity.data),
+    result.emitted.map((event) => event.payload.data.activity.data),
+  );
+  // Public native methods share the real push frame and durable pending gate.
+  assert.equal(
+    (await globalThis.fetch(`${origin}/seed?probe=budget`)).status,
+    204,
+  );
+  const views = [
+    ["files.list", { repo: "pond", ref: "main" }],
+    ["files.tree", { repo: "pond", ref: "main", path: "" }],
+    ["files.read", { repo: "pond", ref: "main", path: "food.txt" }],
+    ["graph.get", { repo: "pond" }],
+    ["commits.list", { repo: "pond", ref: "main" }],
+  ];
+  for (const [name, input] of views)
+    await method(name, input, "levi", "budget");
+  await method(
+    "commits.get",
+    { repo: "pond", hash: "b".repeat(40) },
+    "levi",
+    "budget",
+  );
+  const counts = async () =>
+    (await (await globalThis.fetch(`${origin}/calls?probe=budget`)).json())
+      .calls;
+  let beforeBudget = await counts();
+  for (const [name, input] of views)
+    await method(name, input, "levi", "budget");
+  assert.equal(
+    (await counts()) - beforeBudget,
+    0,
+    "warm native T2 methods never read Git",
+  );
+  const grown = await globalThis.fetch(`${origin}/grow?probe=budget`);
+  assert.equal(grown.status, 200, await grown.clone().text());
+  assert.deepEqual(await grown.json(), { exhausted: true, pending: true });
+  assert.ok(
+    (await counts()) - beforeBudget <= 40,
+    "native push shares one40 operation ceiling",
+  );
+  await worker.stop();
+  worker = await start();
+  origin = `http://127.0.0.1:${String(worker.port)}`;
+  beforeBudget = await counts();
+  for (const [name, input] of views)
+    assert.deepEqual(await method(name, input, "levi", "budget"), {
+      kind: "rebuilding",
+    });
+  assert.equal(
+    (await counts()) - beforeBudget,
+    0,
+    "native pending gate survives reconstruction",
+  );
+  assert.equal(
+    (
+      await method(
+        "commits.get",
+        { repo: "pond", hash: "b".repeat(40) },
+        "levi",
+        "budget",
+      )
+    ).commit.hash,
+    "b".repeat(40),
+  );
+  let page = { done: false, cursor: null },
+    pages = 0;
+  while (!page.done && pages < 30) {
+    const beforePage = await counts();
+    page = await method(
+      "rebuildCopies",
+      { cursor: page.cursor },
+      "levi",
+      "budget",
+    );
+    assert.ok(
+      (await counts()) - beforePage <= 40,
+      "native foreground page shares one40 operation ceiling",
+    );
+    pages++;
+  }
+  assert.equal(page.done, true, "native foreground backfill finishes");
+  beforeBudget = await counts();
+  for (const [name, input] of views) {
+    const ready = await method(name, input, "levi", "budget");
+    assert.notEqual(ready.kind, "rebuilding");
+  }
+  assert.equal(
+    (
+      await method(
+        "commits.get",
+        { repo: "pond", hash: "e".repeat(40) },
+        "levi",
+        "budget",
+      )
+    ).commit.hash,
+    "e".repeat(40),
+  );
+  assert.equal(
+    (await counts()) - beforeBudget,
+    0,
+    "backfilled native T2 methods stay warm0",
+  );
+  // Retry the original failed fact after foreground recovery: native transaction
+  // publication must clear the newer pending revision and retain warm views.
+  const acceptedGrowth = await globalThis.fetch(`${origin}/grow?probe=budget`);
+  assert.equal(acceptedGrowth.status, 200, await acceptedGrowth.clone().text());
+  assert.deepEqual(await acceptedGrowth.json(), {
+    exhausted: false,
+    pending: false,
+  });
+  beforeBudget = await counts();
+  for (const [name, input] of views)
+    assert.notEqual(
+      (await method(name, input, "levi", "budget")).kind,
+      "rebuilding",
+    );
+  assert.equal(
+    (await counts()) - beforeBudget,
+    0,
+    "accepted native retry publishes refs and all warm views",
+  );
+  log(
+    "PASS: Bonsai warm read-copy Git calls=0, T2 pending/exhaustion/foreground pages PASS, native push events, parsed Git insights, caller-isolated layouts persisted across restart",
+  );
+} finally {
+  await worker?.stop();
+  await rm(state, { recursive: true, force: true });
+}

package/test/git-push.worker.ts

@@ -0,0 +1,280 @@
+import {
+  ReadCopyBudgetExceeded,
+  countingGit,
+} from "@fungi.computer/agar/read-copy";
+import { appBackendActorHeader } from "@fungi.computer/agar/backend";
+import {
+  gitPushQuestionSchema,
+  type AppGitPushFact,
+} from "@fungi.computer/agar/git";
+import type { StandardWebhookPayload } from "@fungi.computer/oyster/git";
+import { BonsaiApp } from "../backend/index.js";
+import type { GitBinding } from "../backend/git.js";
+import type { HookEvent } from "../shared/hooks.js";
+
+const after = "b".repeat(40);
+const tree = "c".repeat(40);
+const unused = () => Promise.reject(new Error("Unexpected Git operation"));
+const git: GitBinding = {
+  cloneUrl: (repo) => Promise.resolve(`https://git.example.test/repos/${repo}`),
+  create: (name) =>
+    Promise.resolve({
+      name,
+      defaultBranch: "main",
+      lastPushAt: null,
+      source: null,
+    }),
+  fork: (source, name) =>
+    Promise.resolve({ name, defaultBranch: "main", lastPushAt: null, source }),
+  info: (name) =>
+    Promise.resolve({
+      name,
+      defaultBranch: "main",
+      lastPushAt: null,
+      source: null,
+    }),
+  delete: unused,
+  log: () =>
+    Promise.resolve([
+      {
+        hash: after,
+        treeHash: tree,
+        message: "Add food",
+        parents: [],
+        author: { name: "ada", email: "ada@example.test" },
+        committer: { name: "ada", email: "ada@example.test" },
+        authoredAt: 1,
+        committedAt: 1,
+      },
+    ]),
+  readCommit: (_repo, hash) =>
+    hash === after
+      ? Promise.resolve({
+          hash: after,
+          treeHash: tree,
+          message: "Add food",
+          parents: [],
+          author: { name: "ada", email: "ada@example.test" },
+          committer: { name: "ada", email: "ada@example.test" },
+          authoredAt: 1,
+          committedAt: 1,
+        })
+      : Promise.resolve(null),
+  readTree: () =>
+    Promise.resolve([
+      { name: "food.txt", mode: "100644", hash: "d".repeat(40), type: "blob" },
+    ]),
+  readBlob: () => Promise.resolve(new TextEncoder().encode("food\nwater\n")),
+  refs: () =>
+    Promise.resolve([{ name: "refs/heads/main", hash: "a".repeat(40) }]),
+  exchange: unused,
+};
+
+/** A native fixture with enough distinct directories to exhaust real tree reads. */
+function growingGit(large: () => boolean): GitBinding {
+  const grown = "e".repeat(40),
+    root = "f".repeat(40);
+  const commit = (hash: string) => ({
+    hash,
+    treeHash: hash === grown ? root : tree,
+    message: hash === grown ? "Grow native pond" : "Add food",
+    parents: hash === grown ? [after] : [],
+    author: { name: "ada", email: "ada@example.test" },
+    committer: { name: "ada", email: "ada@example.test" },
+    authoredAt: 1,
+    committedAt: 1,
+  });
+  return {
+    ...git,
+    refs: (repo) =>
+      Promise.resolve([
+        {
+          name: "refs/heads/main",
+          hash: large() && repo === "pond" ? grown : after,
+        },
+      ]),
+    log: (repo, options) => {
+      const hash = /^[0-9a-f]{40}$/u.test(options.ref)
+        ? options.ref
+        : large() && repo === "pond"
+          ? grown
+          : after;
+      return Promise.resolve(
+        hash === grown ? [commit(grown), commit(after)] : [commit(after)],
+      );
+    },
+    readCommit: (_repo, hash) =>
+      Promise.resolve(hash === grown || hash === after ? commit(hash) : null),
+    readTree: (_repo, hash) => {
+      const food = {
+        name: "food.txt",
+        mode: "100644" as const,
+        hash: "d".repeat(40),
+        type: "blob" as const,
+      };
+      if (hash === root)
+        return Promise.resolve([
+          food,
+          ...Array.from({ length: 60 }, (_, i) => ({
+            name: `dir${String(i)}`,
+            mode: "040000" as const,
+            type: "tree" as const,
+            hash: String(i + 1).padStart(40, "0"),
+          })),
+        ]);
+      return Promise.resolve([food]);
+    },
+  };
+}
+
+export class BonsaiPushProbe extends BonsaiApp {
+  private readonly providerCalls: () => number;
+  private readonly delivery: { failNext: boolean };
+  private readonly emitted: {
+    type: string;
+    payload: StandardWebhookPayload;
+    eventId: string;
+  }[];
+  constructor(ctx: DurableObjectState) {
+    const emitted: {
+      type: string;
+      payload: StandardWebhookPayload;
+      eventId: string;
+    }[] = [];
+    const delivery = { failNext: false };
+    ctx.storage.sql.exec(
+      "CREATE TABLE IF NOT EXISTS native_git_fixture (id INTEGER PRIMARY KEY, large INTEGER NOT NULL)",
+    );
+    ctx.storage.sql.exec(
+      "INSERT OR IGNORE INTO native_git_fixture VALUES(1,0)",
+    );
+    const provider =
+      ctx.id.name === "budget"
+        ? growingGit(
+            () =>
+              ctx.storage.sql
+                .exec("SELECT large FROM native_git_fixture WHERE id=1")
+                .one().large === 1,
+          )
+        : git;
+    const lifetime = new AbortController();
+    const counted = countingGit(provider, {
+      limit: 10_000,
+      signal: lifetime.signal,
+    });
+    super(ctx, {
+      GIT: counted.git,
+      EVENTS: {
+        emit: (type, payload, eventId) => {
+          if (delivery.failNext) {
+            delivery.failNext = false;
+            return Promise.reject(new Error("EVENTS temporarily unavailable"));
+          }
+          emitted.push({ type, payload, eventId });
+          return Promise.resolve();
+        },
+      },
+    });
+    this.providerCalls = counted.total;
+    this.emitted = emitted;
+    this.delivery = delivery;
+  }
+  async seed(): Promise<void> {
+    for (const [method, input, actor] of [
+      ["repos.create", { name: "pond" }, "levi"],
+      ["repos.fork", { repo: "pond" }, "ada"],
+    ] as const) {
+      const response = await this.fetch(
+        new Request("https://app.internal/", {
+          method: "PUT",
+          headers: {
+            "Content-Type": "application/json",
+            [appBackendActorHeader]: actor,
+          },
+          body: JSON.stringify({ method, input }),
+        }),
+      );
+      if (!response.ok)
+        throw new Error(`Seed failed: ${await response.text()}`);
+    }
+    this.emitted.length = 0;
+  }
+  async grow(): Promise<{ exhausted: boolean; pending: boolean }> {
+    this.ctx.storage.sql.exec(
+      "UPDATE native_git_fixture SET large=1 WHERE id=1",
+    );
+    try {
+      await this.onGitPush({
+        repository: "pond",
+        eventId: "native-grow",
+        writer: { kind: "actor", actor: { kind: "member", memberId: "levi" } },
+        updates: [
+          { ref: "refs/heads/main", before: after, after: "e".repeat(40) },
+        ],
+      });
+      return {
+        exhausted: false,
+        pending: this.bonsai.state.repositoryRefStatus("pond").pending,
+      };
+    } catch (error) {
+      if (!(error instanceof ReadCopyBudgetExceeded)) throw error;
+      return {
+        exhausted: true,
+        pending: this.bonsai.state.repositoryRefStatus("pond").pending,
+      };
+    }
+  }
+  calls(): Promise<number> {
+    return Promise.resolve(this.providerCalls());
+  }
+  failNextEmit(): void {
+    this.delivery.failNext = true;
+  }
+  snapshot(): Promise<{
+    emitted: {
+      type: string;
+      payload: StandardWebhookPayload;
+      eventId: string;
+    }[];
+    activity: HookEvent["data"]["activity"][];
+  }> {
+    return Promise.resolve({
+      emitted: this.emitted,
+      activity: this.bonsai.state.events("pond", 20),
+    });
+  }
+}
+
+export default {
+  async fetch(
+    request: Request,
+    env: { PROBE: DurableObjectNamespace<BonsaiPushProbe> },
+  ): Promise<Response> {
+    const url = new URL(request.url);
+    const probe = env.PROBE.getByName(url.searchParams.get("probe") ?? "push");
+    if (url.pathname === "/grow") return Response.json(await probe.grow());
+    if (url.pathname === "/calls")
+      return Response.json({ calls: await probe.calls() });
+    if (url.pathname === "/methods") return probe.fetch(request);
+    if (url.pathname === "/authorize") {
+      const question = gitPushQuestionSchema.safeParse(await request.json());
+      if (!question.success) return new Response(null, { status: 400 });
+      return Response.json(await probe.authorizeGitPush(question.data));
+    }
+    if (url.pathname === "/legacy")
+      return probe.fetch(
+        new Request("https://app.internal/host/git-push", {
+          method: "POST",
+          body: "{}",
+        }),
+      );
+    if (url.pathname === "/seed") {
+      await probe.seed();
+      return new Response(null, { status: 204 });
+    }
+    if (url.searchParams.has("fail")) await probe.failNextEmit();
+    const fact = await request.json<AppGitPushFact>();
+    await probe.onGitPush(fact);
+    return Response.json(await probe.snapshot());
+  },
+};