@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/outbox.test.ts

@@ -0,0 +1,424 @@
+import type { EventSink } from "@fungi.computer/oyster/git";
+import { createRecipientDeliveries } from "@fungi.computer/oyster/event-recipients";
+import { bindingOf } from "./git-binding.fixture.js";
+import { appGitPushFactSchema } from "@fungi.computer/agar/git";
+import { DatabaseSync } from "node:sqlite";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { describe, expect, it, vi } from "vitest";
+import * as z from "zod";
+import {
+  drainOutbox,
+  ensureBonsaiTables,
+  BonsaiState,
+} from "../backend/state.js";
+import { appBackend } from "../backend/methods.js";
+import type { GitStore } from "../backend/git.js";
+import { observePush } from "../backend/service.js";
+import { hookEvent, hookSpec, type HookEvent } from "../shared/hooks.js";
+
+const resultSchema = z.strictObject({ kind: z.literal("recorded") });
+
+function fixture() {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const reopen = () => new BonsaiState(owner.sql, owner.transactionSync);
+  const state = reopen();
+  const build = () => {
+    const activity = state.record({
+      at: 1000,
+      type: "repo.created",
+      repo: "notes",
+      actor: "Levi",
+      data: {},
+    });
+    const event = hookEvent.parse({
+      type: "repo.created",
+      timestamp: new Date(activity.at).toISOString(),
+      data: {
+        spec: hookSpec,
+        eventId: `evt_${String(activity.id)}`,
+        repository: {
+          name: "notes",
+          canonical: "notes",
+          cloneUrl: "https://git.test/notes.git",
+        },
+        actor: "Levi",
+        activity,
+      },
+    });
+    return {
+      result: resultSchema.parse({ kind: "recorded" }),
+      events: [event],
+    };
+  };
+  return { state, database, reopen, build };
+}
+
+const unused = () => Promise.reject(new Error("Unexpected Git operation"));
+const repositoryInfo = (name: string) =>
+  Promise.resolve({
+    name,
+    defaultBranch: "main",
+    lastPushAt: null,
+    source: null,
+  });
+const store: GitStore = {
+  get binding() {
+    return bindingOf(this);
+  },
+  cloneUrl: (repo) => Promise.resolve(`https://git.test/${repo}.git`),
+  create: unused,
+  fork: unused,
+  info: repositoryInfo,
+  log: () => Promise.resolve([]),
+  commit: unused,
+  tree: unused,
+  blob: unused,
+  refs: () => Promise.resolve([]),
+  exchange: unused,
+};
+
+describe("Bonsai transactional receipts and outbox", () => {
+  it("reads committed activity without emitting or acknowledging pending events", async () => {
+    const { state, database, build } = fixture();
+    try {
+      state.transition("create:one", "request-one", resultSchema, build);
+      const emit = vi.fn(() => Promise.resolve());
+      database.exec(
+        "CREATE TRIGGER refuse_read_ack BEFORE UPDATE ON outbox BEGIN SELECT RAISE(ABORT,'read wrote outbox'); END",
+      );
+      await appBackend.call(
+        "activity.list",
+        {},
+        { bonsai: { state, store, events: { emit } } },
+        { computerId: null, actor: { kind: "member", memberId: "Levi" } },
+      );
+      expect(emit).not.toHaveBeenCalled();
+      expect(state.pendingEvents()).toHaveLength(1);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("keeps a committed write successful when delivery fails and retries on the next write", async () => {
+    const { state, database } = fixture();
+    try {
+      const delivered: string[] = [];
+      const failure = new Error("Event sink unavailable");
+      const emit = vi.fn<EventSink["emit"]>((_type, _payload, eventId) => {
+        expect(state.repo("notes")).not.toBeNull();
+        delivered.push(eventId);
+        return delivered.length === 1
+          ? Promise.reject(failure)
+          : Promise.resolve();
+      });
+      const bonsai = {
+        state,
+        store: { ...store, create: repositoryInfo },
+        events: { emit },
+      };
+      const caller = {
+        computerId: null,
+        actor: { kind: "member", memberId: "Levi" },
+      } as const;
+      await expect(
+        appBackend.call("repos.create", { name: "notes" }, { bonsai }, caller),
+      ).resolves.toMatchObject({ name: "notes" });
+      expect(emit).toHaveBeenCalledTimes(1);
+      expect(state.pendingEvents()).toHaveLength(1);
+      await appBackend.call("repos.list", {}, { bonsai }, caller);
+      expect(emit).toHaveBeenCalledTimes(1);
+      const tiles = { view: "overview", placements: [] };
+      await expect(
+        appBackend.call(
+          "insights.layout.save",
+          { repo: "notes", tiles },
+          { bonsai },
+          caller,
+        ),
+      ).resolves.toEqual({ tiles });
+      expect(delivered).toHaveLength(2);
+      expect(delivered[1]).toBe(delivered[0]);
+      expect(state.pendingEvents()).toHaveLength(0);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("commits a write when the subscribing Workflows instance is down, and the host retries that delivery", async () => {
+    const { state, database } = fixture();
+    const host = new DatabaseSync(":memory:");
+    try {
+      let clock = 1_000;
+      let workflowsDown = true;
+      const attempts: string[] = [];
+      const deliveries = createRecipientDeliveries({
+        sql: fromNodeSqlite(host).sql,
+        now: () => clock,
+        wake: () => Promise.resolve(),
+        deliver: (recipient, event) => {
+          attempts.push(`${recipient}:${event.type}`);
+          return workflowsDown
+            ? Promise.reject(new Error("App instance returned 502"))
+            : Promise.resolve();
+        },
+      });
+      // The host's EVENTS.emit: accept durably for each subscriber, deliver later.
+      const emit: EventSink["emit"] = (type, payload, eventId) => {
+        deliveries.enqueue(
+          {
+            source: {
+              installationId: "bonsai",
+              appId: "app_bonsai",
+              releaseId: "rel_bonsai",
+            },
+            type,
+            eventId,
+            payload,
+          },
+          ["workflows-library"],
+        );
+        return Promise.resolve();
+      };
+      const bonsai = {
+        state,
+        store: { ...store, create: repositoryInfo },
+        events: { emit },
+      };
+      await expect(
+        appBackend.call(
+          "repos.create",
+          { name: "reed-pond" },
+          { bonsai },
+          { computerId: null, actor: { kind: "member", memberId: "Levi" } },
+        ),
+      ).resolves.toMatchObject({ name: "reed-pond" });
+      expect(state.repo("reed-pond")).not.toBeNull();
+      expect(state.pendingEvents()).toHaveLength(0);
+      expect(attempts).toEqual([]);
+
+      await deliveries.drain();
+      expect(deliveries.deliveries("workflows-library")).toMatchObject([
+        {
+          type: "repo.created",
+          state: "pending",
+          attempts: 1,
+          lastError: "Error: App instance returned 502",
+        },
+      ]);
+
+      workflowsDown = false;
+      clock = deliveries.nextDue() ?? clock;
+      await deliveries.drain();
+      expect(deliveries.deliveries("workflows-library")).toMatchObject([
+        {
+          type: "repo.created",
+          state: "delivered",
+          attempts: 2,
+          lastError: null,
+        },
+      ]);
+      expect(attempts).toEqual([
+        "workflows-library:repo.created",
+        "workflows-library:repo.created",
+      ]);
+    } finally {
+      host.close();
+      database.close();
+    }
+  });
+
+  it("recovers a committed event after restart and lost acknowledgement without repeating activity", async () => {
+    const { state, database, reopen, build } = fixture();
+    try {
+      expect(
+        state.transition("create:one", "request-one", resultSchema, build),
+      ).toEqual({ kind: "recorded" });
+      const delivered: HookEvent[] = [];
+      await expect(
+        drainOutbox({
+          state,
+          events: {
+            emit: (_type, payload) => {
+              delivered.push(hookEvent.parse(payload));
+              return Promise.reject(new Error("Acknowledgement lost"));
+            },
+          },
+        }),
+      ).resolves.toMatchObject({ kind: "deferred", delivered: 0 });
+      const reopened = reopen();
+      expect(
+        reopened.transition("create:one", "request-one", resultSchema, () => {
+          throw new Error("Replay must not rebuild");
+        }),
+      ).toEqual({ kind: "recorded" });
+      await drainOutbox({
+        state: reopened,
+        events: {
+          emit: (_type, payload) => {
+            delivered.push(hookEvent.parse(payload));
+            return Promise.resolve();
+          },
+        },
+      });
+      expect(delivered).toHaveLength(2);
+      expect(delivered[1]).toEqual(delivered[0]);
+      expect(reopened.events(null, 20)).toHaveLength(1);
+      await expect(
+        drainOutbox({
+          state: reopened,
+          events: {
+            emit: () => Promise.reject(new Error("Already acknowledged")),
+          },
+        }),
+      ).resolves.toEqual({ kind: "delivered", delivered: 0 });
+    } finally {
+      database.close();
+    }
+  });
+
+  it("retries a failed host push on the next write without repeating Git preparation", async () => {
+    const { state, database } = fixture();
+    try {
+      state.registerRepo({
+        name: "notes",
+        description: null,
+        parent: null,
+        owner: null,
+      });
+      const delivered: HookEvent[] = [];
+      let failed = false;
+      const bonsai = {
+        state,
+        store,
+        events: {
+          emit: (_type: string, payload: unknown) => {
+            delivered.push(hookEvent.parse(payload));
+            if (!failed) {
+              failed = true;
+              return Promise.reject(new Error("Sink unavailable"));
+            }
+            return Promise.resolve();
+          },
+        },
+      };
+      const fact = appGitPushFactSchema.parse({
+        repository: "notes",
+        writer: { kind: "actor", actor: { kind: "member", memberId: "Levi" } },
+        eventId: "push_one",
+        updates: [
+          {
+            ref: "refs/heads/main",
+            before: "a".repeat(40),
+            after: "0".repeat(40),
+          },
+        ],
+      });
+      await expect(observePush(bonsai, fact)).resolves.toBeUndefined();
+      await appBackend.call(
+        "activity.list",
+        {},
+        { bonsai },
+        { computerId: null, actor: { kind: "member", memberId: "Levi" } },
+      );
+      expect(delivered).toHaveLength(1);
+      await appBackend.call(
+        "insights.layout.save",
+        { repo: "notes", tiles: { view: "overview", placements: [] } },
+        { bonsai },
+        { computerId: null, actor: { kind: "member", memberId: "Levi" } },
+      );
+      expect(delivered).toHaveLength(2);
+      expect(delivered[1]).toEqual(delivered[0]);
+      expect(state.events(null, 20)).toHaveLength(1);
+      await observePush(
+        { ...bonsai, store: { ...store, cloneUrl: unused } },
+        fact,
+      );
+      expect(delivered).toHaveLength(2);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("refuses a reused key with different input without writing another activity", () => {
+    const { state, database, build } = fixture();
+    try {
+      state.transition("create:one", "request-one", resultSchema, build);
+      expect(() =>
+        state.transition("create:one", "request-two", resultSchema, build),
+      ).toThrow("different");
+      expect(state.events(null, 20)).toHaveLength(1);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("rolls back domain activity and receipt if its outbox insert cannot commit", () => {
+    const { state, database, build } = fixture();
+    try {
+      database.exec(
+        "CREATE TRIGGER refuse_outbox BEFORE INSERT ON outbox BEGIN SELECT RAISE(ABORT,'outbox unavailable'); END",
+      );
+      expect(() =>
+        state.transition("create:one", "request-one", resultSchema, build),
+      ).toThrow("outbox unavailable");
+      expect(state.events(null, 20)).toEqual([]);
+      database.exec("DROP TRIGGER refuse_outbox");
+      expect(
+        state.transition("create:one", "request-one", resultSchema, build),
+      ).toEqual({ kind: "recorded" });
+      expect(state.events(null, 20)).toHaveLength(1);
+    } finally {
+      database.close();
+    }
+  });
+
+  it("keeps a committed write bounded to 32 emits without capping event acceptance", async () => {
+    const { state, database, build } = fixture();
+    try {
+      state.transition("push:many", "request-many", resultSchema, () => ({
+        result: resultSchema.parse({ kind: "recorded" }),
+        events: Array.from({ length: 65 }, () => build().events[0]).map(
+          (event) => hookEvent.parse(event),
+        ),
+      }));
+      const ids: string[] = [];
+      const emit: EventSink["emit"] = (_type, _payload, eventId) => {
+        ids.push(eventId);
+        return Promise.resolve();
+      };
+      const bonsai = {
+        state,
+        store: { ...store, create: repositoryInfo },
+        events: { emit },
+      };
+      const caller = {
+        computerId: null,
+        actor: { kind: "member", memberId: "Levi" },
+      } as const;
+      await appBackend.call(
+        "repos.create",
+        { name: "notes" },
+        { bonsai },
+        caller,
+      );
+      expect(ids).toHaveLength(32);
+      expect(state.events(null, 100)).toHaveLength(66);
+      const input = {
+        repo: "notes",
+        tiles: { view: "overview", placements: [] },
+      };
+      await appBackend.call("insights.layout.save", input, { bonsai }, caller);
+      expect(ids).toHaveLength(64);
+      await appBackend.call("insights.layout.save", input, { bonsai }, caller);
+      expect(ids).toHaveLength(66);
+      expect(new Set(ids).size).toBe(66);
+      await appBackend.call("insights.layout.save", input, { bonsai }, caller);
+      expect(ids).toHaveLength(66);
+    } finally {
+      database.close();
+    }
+  });
+});

package/test/parts.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { createElement } from "react";
+import { renderToStaticMarkup } from "react-dom/server";
+import type { Agent } from "../shared/contract.js";
+import {
+  AgentName,
+  Sparkline,
+  actorLabel,
+  agentColors,
+  type AgentColors,
+} from "../web/parts.js";
+import { shortActor } from "../web/format.js";
+
+const agent = (overrides: Partial<Agent>): Agent => ({
+  id: "morel",
+  name: "morel",
+  color: "c0",
+  kind: "agent",
+  createdAt: 1,
+  ...overrides,
+});
+
+describe("actorLabel", () => {
+  it("keeps a resolved agent's recorded name", () => {
+    const colors: AgentColors = agentColors([agent({})]);
+    expect(actorLabel("morel", colors)).toBe("morel");
+  });
+
+  it("replaces a resolved human member's raw host id with a short label", () => {
+    const id = "tenant_member_5mirwh5a0r0p7v793qxhy";
+    const colors: AgentColors = agentColors([
+      agent({ id, name: id, kind: "human" }),
+    ]);
+    const label = actorLabel(id, colors);
+    expect(label).toBe(shortActor(id));
+    expect(label).not.toContain(id);
+    expect(label).not.toBe(id);
+  });
+
+  it("leaves an unresolved actor's string untouched rather than guessing", () => {
+    expect(actorLabel("unresolved-actor", new Map())).toBe("unresolved-actor");
+  });
+});
+
+describe("AgentName", () => {
+  it("never renders a human actor's raw member id", () => {
+    const id = "tenant_member_5mirwh5a0r0p7v793qxhy";
+    const colors: AgentColors = agentColors([
+      agent({ id, name: id, kind: "human" }),
+    ]);
+    const html = renderToStaticMarkup(
+      createElement(AgentName, { name: id, colors }),
+    );
+    expect(html).not.toContain(id);
+    expect(html).toContain("Member");
+  });
+
+  it("still renders a bot agent's readable name", () => {
+    const colors: AgentColors = agentColors([agent({})]);
+    const html = renderToStaticMarkup(
+      createElement(AgentName, { name: "morel", colors }),
+    );
+    expect(html).toContain("morel");
+  });
+});
+
+describe("Sparkline", () => {
+  it("renders nothing when there is no activity", () => {
+    const values = Array.from({ length: 24 }, () => 0);
+    expect(renderToStaticMarkup(createElement(Sparkline, { values }))).toBe("");
+  });
+
+  it("renders nothing for a single stray data point", () => {
+    const values = Array.from({ length: 24 }, () => 0);
+    values[20] = 1;
+    expect(renderToStaticMarkup(createElement(Sparkline, { values }))).toBe("");
+  });
+
+  it("renders a sparkline once there is a real multi-point trend", () => {
+    const values = Array.from({ length: 24 }, () => 0);
+    values[2] = 1;
+    values[10] = 3;
+    const html = renderToStaticMarkup(createElement(Sparkline, { values }));
+    expect(html).toContain("bonsai-spark");
+  });
+});

package/test/pkt-line.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from "vitest";
+import { acceptedRefs, parseReceivePack } from "@fungi.computer/agar/git-wire";
+
+const encoder = new TextEncoder();
+
+function pkt(text: string): string {
+  return (text.length + 4).toString(16).padStart(4, "0") + text;
+}
+
+function bytes(...parts: string[]): Uint8Array {
+  return encoder.encode(parts.join(""));
+}
+
+const a = "a".repeat(40);
+const b = "b".repeat(40);
+const zero = "0".repeat(40);
+
+describe("push observation", () => {
+  it("reads ref commands and capabilities before the pack", () => {
+    const body = bytes(
+      pkt(`${zero} ${a} refs/heads/main\0report-status side-band-64k\n`),
+      pkt(`${a} ${b} refs/heads/feature\n`),
+      "0000",
+      "PACK....",
+    );
+    expect(parseReceivePack(body)).toEqual({
+      kind: "ok",
+      updates: [
+        { before: zero, after: a, ref: "refs/heads/main" },
+        { before: a, after: b, ref: "refs/heads/feature" },
+      ],
+      capabilities: ["report-status", "side-band-64k"],
+    });
+  });
+
+  it("reads accepted refs from side-band report-status", () => {
+    const inner =
+      pkt("unpack ok\n") +
+      pkt("ok refs/heads/main\n") +
+      pkt("ng refs/heads/x denied\n") +
+      "0000";
+    const response = bytes(pkt(`\u0001${inner}`), "0000");
+    expect([...acceptedRefs(response, true)]).toEqual(["refs/heads/main"]);
+  });
+
+  it("reads accepted refs without side-band", () => {
+    const response = bytes(
+      pkt("unpack ok\n"),
+      pkt("ok refs/heads/main\n"),
+      "0000",
+    );
+    expect([...acceptedRefs(response, false)]).toEqual(["refs/heads/main"]);
+  });
+});