@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/backend/graph-commit-copies.ts

@@ -0,0 +1,321 @@
+/** Graph and Commit screen projections in the facet's bounded read copies. */
+import * as z from "zod";
+import {
+  readCopyPageInput,
+  type ReadCopyPageInput,
+} from "../shared/contract.js";
+import { readCopyPageOffset, sliceReadCopyPage } from "./read-copy-page.js";
+import { ReadCopyBudgetExceeded } from "@fungi.computer/agar/read-copy";
+import {
+  commitDetail,
+  graph,
+  type CommitDetail,
+  type Graph,
+  type GraphLane,
+  type GraphNode,
+} from "../shared/contract.js";
+import { commitPage, type CommitPage } from "@fungi.computer/agar/roles/files";
+import { treeDiff } from "./diff.js";
+import { AppMethodRefusal } from "@fungi.computer/agar/backend";
+import { projectionStore } from "./history.js";
+import { readRepositoryRefs } from "./repository-copy.js";
+import type { Bonsai } from "./service.js";
+
+const oid = /^[0-9a-f]{40}$/u;
+const pageKey = (bonsai: Bonsai, repo: string, ref: string) =>
+  JSON.stringify([repo, bonsai.state.repositoryGeneration(repo), ref]);
+const graphKey = (bonsai: Bonsai, repo: string) =>
+  JSON.stringify([repo, bonsai.state.repositoryGeneration(repo)]);
+const graphCopies = (bonsai: Bonsai) =>
+  bonsai.state.copies.open("bonsai-graph", graph);
+const pages = (bonsai: Bonsai) =>
+  bonsai.state.copies.open("bonsai-commit-page", commitPage);
+const details = (bonsai: Bonsai) =>
+  bonsai.state.copies.open("bonsai-commit-detail", commitDetail);
+
+function known(bonsai: Bonsai, repo: string) {
+  const summary = bonsai.state.repo(repo);
+  if (summary === null)
+    throw new AppMethodRefusal("not_found", `No repository ${repo}`);
+  return summary;
+}
+function localRefs(bonsai: Bonsai, repo: string) {
+  known(bonsai, repo);
+  return readRepositoryRefs(bonsai, repo).refs;
+}
+function refHead(bonsai: Bonsai, repo: string, ref: string) {
+  if (oid.test(ref)) return ref;
+  const found = localRefs(bonsai, repo).find(
+    (item) =>
+      item.name === ref ||
+      item.name === `refs/heads/${ref}` ||
+      item.name === `refs/tags/${ref}`,
+  );
+  return found?.hash ?? null;
+}
+function localLanes(bonsai: Bonsai, repo: string): GraphLane[] {
+  const summary = known(bonsai, repo);
+  if (summary.parent !== null)
+    throw new AppMethodRefusal("invalid", "Graph the canonical repository");
+  return [repo, ...summary.forks].flatMap((member) => {
+    const owner = known(bonsai, member).owner;
+    return localRefs(bonsai, member)
+      .filter((ref) => ref.name.startsWith("refs/heads/"))
+      .sort((a, b) =>
+        a.name === "refs/heads/main"
+          ? -1
+          : b.name === "refs/heads/main"
+            ? 1
+            : a.name.localeCompare(b.name),
+      )
+      .map((ref) => ({
+        id: `${member}:${ref.name.slice(11)}`,
+        repo: member,
+        ref: ref.name.slice(11),
+        owner: member === repo ? null : owner,
+        head: ref.hash,
+        canonical: member === repo,
+      }));
+  });
+}
+function origins(bonsai: Bonsai, value: Graph): Graph {
+  const recorded = bonsai.state.origins(value.nodes.map((node) => node.hash));
+  return {
+    lanes: value.lanes,
+    nodes: value.nodes.map((node) => ({
+      ...node,
+      agent: recorded.get(node.hash)?.agent ?? null,
+      origin: recorded.get(node.hash)?.repo ?? null,
+    })),
+  };
+}
+
+/** Caller supplies the existing bounded frame; this module never resets its budget. */
+export async function readGraph(bonsai: Bonsai, repo: string): Promise<Graph> {
+  const lanes = localLanes(bonsai, repo);
+  const copy = graphCopies(bonsai);
+  const key = graphKey(bonsai, repo);
+  const saved = copy.read(key);
+  if (
+    saved.kind === "ready" &&
+    JSON.stringify(saved.value.lanes) === JSON.stringify(lanes)
+  )
+    return origins(bonsai, saved.value);
+  // A changed family must never retain its old ready projection if rebuilding fails.
+  copy.stale(key);
+  const store = projectionStore(bonsai);
+  const nodes = new Map<string, GraphNode>();
+  for (const lane of lanes) {
+    for (const commit of await store.log(lane.repo, lane.head, 60)) {
+      const existing = nodes.get(commit.hash);
+      if (existing) {
+        existing.lanes.push(lane.id);
+        continue;
+      }
+      nodes.set(commit.hash, {
+        hash: commit.hash,
+        parents: commit.parents,
+        message: commit.message.split("\n")[0] ?? "",
+        author: commit.author.name,
+        committedAt: commit.committedAt,
+        agent: null,
+        origin: null,
+        lanes: [lane.id],
+      });
+    }
+  }
+  const value = {
+    lanes,
+    nodes: [...nodes.values()].sort((a, b) => b.committedAt - a.committedAt),
+  };
+  copy.write(key, null, value);
+  return origins(bonsai, value);
+}
+
+/** Mutable branch/tag pages chain on local refs; OID pages retain immutable history. */
+export async function readCommits(
+  bonsai: Bonsai,
+  input: { repo: string; ref: string } & ReadCopyPageInput,
+): Promise<CommitPage> {
+  known(bonsai, input.repo);
+  const options = readCopyPageInput.parse({
+    limit: input.limit,
+    after: input.after,
+  });
+  const head = refHead(bonsai, input.repo, input.ref);
+  const scope = JSON.stringify(["commits", input.repo, input.ref]);
+  const offset = readCopyPageOffset(options.after, scope, head);
+  const copy = pages(bonsai),
+    key = pageKey(bonsai, input.repo, input.ref);
+  const saved = copy.read(key);
+  if (
+    options.after !== undefined &&
+    (saved.kind !== "ready" || saved.head !== head)
+  )
+    throw new AppMethodRefusal(
+      "conflict",
+      "Saved Commit page is unavailable; restart from the first page.",
+    );
+  let value: CommitPage;
+  if (saved.kind === "ready" && saved.head === head) value = saved.value;
+  else {
+    copy.stale(key);
+    const commits =
+      head === null
+        ? []
+        : await projectionStore(bonsai).log(input.repo, head, 100);
+    value = {
+      ref: input.ref,
+      commits: commits.map((commit) => ({ commit, agent: null })),
+    };
+    if (!oid.test(input.ref) && refHead(bonsai, input.repo, input.ref) !== head)
+      throw new AppMethodRefusal(
+        "unavailable",
+        "Commit refs changed during rebuild.",
+      );
+    copy.write(key, head, value);
+  }
+  const selected = sliceReadCopyPage(
+    value.commits,
+    options.limit,
+    offset,
+    scope,
+    head,
+  );
+  const recorded = bonsai.state.origins(
+    selected.items.map((item) => item.commit.hash),
+  );
+  const result: CommitPage = {
+    ref: value.ref,
+    commits: selected.items.map((item) => ({
+      ...item,
+      agent: recorded.get(item.commit.hash)?.agent ?? null,
+    })),
+  };
+  if (selected.next !== null) result.next = selected.next;
+  return result;
+}
+
+/** Immutable OID detail and its first-parent diff survive ref changes and restarts. */
+export async function readCommitDetail(
+  bonsai: Bonsai,
+  input: { repo: string; hash: string },
+): Promise<CommitDetail> {
+  known(bonsai, input.repo);
+  if (!oid.test(input.hash))
+    throw new AppMethodRefusal("invalid", "Expected a commit hash");
+  const copy = details(bonsai),
+    key = pageKey(bonsai, input.repo, input.hash);
+  const saved = copy.read(key);
+  let value: CommitDetail;
+  if (saved.kind === "ready") value = saved.value;
+  else {
+    const store = projectionStore(bonsai);
+    const commit = await store.commit(input.repo, input.hash);
+    if (commit === null)
+      throw new AppMethodRefusal("not_found", "No such commit");
+    const parent =
+      commit.parents[0] === undefined
+        ? null
+        : await store.commit(input.repo, commit.parents[0]);
+    value = {
+      commit,
+      agent: null,
+      diff: await treeDiff(
+        store,
+        input.repo,
+        parent?.treeHash ?? null,
+        commit.treeHash,
+      ),
+    };
+    copy.write(key, input.hash, value);
+  }
+  return {
+    ...value,
+    agent: bonsai.state.origins([input.hash]).get(input.hash)?.agent ?? null,
+  };
+}
+
+/** Composer calls synchronously after receipt check and BEFORE any provider await. */
+export function invalidateGraphCommitCopies(
+  bonsai: Bonsai,
+  repo: string,
+): void {
+  known(bonsai, repo);
+  const canonical = bonsai.state.canonicalOf(repo);
+  graphCopies(bonsai).stale(graphKey(bonsai, canonical));
+  const saved = bonsai.state.repositoryCopies.read(repo);
+  if (saved.kind === "ready")
+    for (const ref of saved.value.refs) {
+      const copy = pages(bonsai);
+      copy.stale(pageKey(bonsai, repo, ref.name));
+      copy.stale(
+        pageKey(bonsai, repo, ref.name.replace(/^refs\/(heads|tags)\//u, "")),
+      );
+    }
+}
+
+const rebuildItem = z.discriminatedUnion("kind", [
+  z.object({ kind: z.literal("graph"), repo: z.string() }),
+  z.object({ kind: z.literal("commits"), repo: z.string(), ref: z.string() }),
+  z.object({
+    kind: z.literal("commit"),
+    repo: z.string(),
+    hash: z.string().regex(oid),
+  }),
+]);
+/** Opaque cursor keys are App-owned values, not a second shared rebuild protocol. */
+export function graphCommitCopyKeys(bonsai: Bonsai, repo: string): string[] {
+  const canonical = bonsai.state.canonicalOf(repo);
+  const family = known(bonsai, canonical);
+  return [
+    JSON.stringify({ kind: "graph", repo: canonical }),
+    ...[canonical, ...family.forks].flatMap((member) =>
+      localRefs(bonsai, member).flatMap((ref) => [
+        JSON.stringify({
+          kind: "commits",
+          repo: member,
+          ref: ref.name.replace(/^refs\/(heads|tags)\//u, ""),
+        }),
+        JSON.stringify({ kind: "commit", repo: member, hash: ref.hash }),
+      ]),
+    ),
+  ];
+}
+/** One selected foreground key in the caller's frame; unfinished keys retain their cursor. */
+export async function rebuildGraphCommitCopy(
+  bonsai: Bonsai,
+  key: string,
+): Promise<boolean> {
+  const item = rebuildItem.parse(JSON.parse(key));
+  try {
+    switch (item.kind) {
+      case "graph":
+        await readGraph(bonsai, item.repo);
+        break;
+      case "commits":
+        await readCommits(bonsai, item);
+        break;
+      case "commit":
+        await readCommitDetail(bonsai, item);
+        break;
+    }
+    return true;
+  } catch (error) {
+    if (
+      error instanceof ReadCopyBudgetExceeded ||
+      (error instanceof AppMethodRefusal && error.code === "unavailable")
+    )
+      return false;
+    throw error;
+  }
+}
+/** Push composer runs this after Changed-Change refresh, before Files, on the same store. */
+export async function refreshGraphCommitCopies(
+  bonsai: Bonsai,
+  repo: string,
+): Promise<boolean> {
+  for (const key of graphCommitCopyKeys(bonsai, repo))
+    if (!(await rebuildGraphCommitCopy(bonsai, key))) return false;
+  return true;
+}

package/backend/history.ts

@@ -0,0 +1,178 @@
+/** Bounded Git ancestry and host-recorded commit origins for proposals. */
+import type { ChangeRecord } from "../shared/contract.js";
+import type { Commit } from "@fungi.computer/agar/roles/files";
+import type { GitStore } from "./git.js";
+import type { Bonsai } from "./service.js";
+import { AppMethodRefusal } from "@fungi.computer/agar/backend";
+import * as z from "zod";
+import {
+  commit as commitSchema,
+  treeEntry,
+} from "@fungi.computer/agar/roles/files";
+
+const HISTORY = 300;
+const MAX_SIDE_BRANCHES = 24;
+
+/** Immutable Git objects survive frame boundaries while a bounded rebuild advances. */
+export function projectionStore(bonsai: Bonsai): GitStore {
+  const store = bonsai.store;
+  const commits = bonsai.state.copies.open("bonsai-commit", commitSchema);
+  const trees = bonsai.state.copies.open("bonsai-tree", z.array(treeEntry));
+  const logs = bonsai.state.copies.open(
+    "bonsai-history",
+    z.array(commitSchema),
+  );
+  return {
+    ...store,
+    async commit(repo, hash) {
+      const key = JSON.stringify([
+        repo,
+        bonsai.state.repositoryGeneration(repo),
+        hash,
+      ]);
+      const saved = commits.read(key);
+      if (saved.kind === "ready") return saved.value;
+      const value = await store.commit(repo, hash);
+      if (value !== null) commits.write(key, hash, value);
+      return value;
+    },
+    async tree(repo, hash) {
+      const key = JSON.stringify([
+        repo,
+        bonsai.state.repositoryGeneration(repo),
+        hash,
+      ]);
+      const saved = trees.read(key);
+      if (saved.kind === "ready") return saved.value;
+      const value = await store.tree(repo, hash);
+      if (value !== null) trees.write(key, hash, [...value]);
+      return value;
+    },
+    async blob(repo, hash) {
+      const saved = bonsai.state.copies.readBlob(hash);
+      if (saved !== null) return saved;
+      const value = await store.blob(repo, hash);
+      if (value !== null && value.byteLength <= 512_000)
+        bonsai.state.copies.putBlob(hash, value);
+      return value;
+    },
+    async log(repo, ref, limit, offset = 0) {
+      if (!/^[0-9a-f]{40}$/u.test(ref))
+        return store.log(repo, ref, limit, offset);
+      const key = JSON.stringify([
+        repo,
+        bonsai.state.repositoryGeneration(repo),
+        ref,
+        limit,
+        offset,
+      ]);
+      const saved = logs.read(key);
+      if (saved.kind === "ready") return saved.value;
+      const value = await store.log(repo, ref, limit, offset);
+      logs.write(key, ref, [...value]);
+      return value;
+    },
+  };
+}
+
+/**
+ * Commits reachable from `ref`: the first-parent history plus the histories
+ * merged into it, bounded so a listing stays a handful of reads.
+ */
+async function ancestry(
+  store: GitStore,
+  repo: string,
+  ref: string,
+): Promise<{ firstParent: readonly Commit[]; all: ReadonlySet<string> }> {
+  const firstParent = await store.log(repo, ref, HISTORY);
+  const all = new Set(firstParent.map((commit) => commit.hash));
+  const pending = firstParent.flatMap((commit) => commit.parents.slice(1));
+  let reads = 0;
+  while (pending.length > 0 && reads < MAX_SIDE_BRANCHES) {
+    const next = pending.shift();
+    if (next === undefined || all.has(next)) continue;
+    reads += 1;
+    for (const commit of await store.log(repo, next, HISTORY)) {
+      if (all.has(commit.hash)) break;
+      all.add(commit.hash);
+      pending.push(...commit.parents.slice(1));
+    }
+  }
+  return { firstParent, all };
+}
+
+export type ChangeHistory = Readonly<{
+  /** Fork commits the canonical repository does not contain, newest first. */
+  ahead: readonly Commit[];
+  aheadHashes: readonly string[];
+  base: string | null;
+  behind: number;
+  head: string;
+}>;
+
+export async function compareChange(
+  store: GitStore,
+  canonical: string,
+  fork: string,
+  head: string,
+  target: string,
+): Promise<ChangeHistory | null> {
+  const [main, branch] = await Promise.all([
+    ancestry(store, canonical, target),
+    ancestry(store, fork, head),
+  ]);
+  const tip = branch.firstParent[0];
+  if (tip === undefined) return null;
+  const ahead: Commit[] = [];
+  let base: string | null = null;
+  for (const commit of branch.firstParent) {
+    if (main.all.has(commit.hash)) {
+      base = commit.hash;
+      break;
+    }
+    ahead.push(commit);
+  }
+  let behind = 0;
+  for (const commit of main.firstParent) {
+    if (branch.all.has(commit.hash)) break;
+    behind += 1;
+  }
+  return {
+    ahead,
+    aheadHashes: [...branch.all].filter((hash) => !main.all.has(hash)),
+    base,
+    behind,
+    head: tip.hash,
+  };
+}
+
+/** Bounded target reachability, prepared once per accepted target update. */
+export async function reachableCommits(
+  store: GitStore,
+  repo: string,
+  target: string,
+): Promise<ReadonlySet<string>> {
+  return (await ancestry(store, repo, target)).all;
+}
+
+export async function authorsAtHead(
+  bonsai: Bonsai,
+  row: ChangeRecord,
+): Promise<readonly string[]> {
+  const history = await compareChange(
+    bonsai.store,
+    row.repo,
+    row.sourceRepo,
+    row.head,
+    row.target,
+  );
+  if (history === null)
+    throw new AppMethodRefusal("not_found", "The proposed head is missing");
+  return [
+    ...new Set(
+      [...bonsai.state.origins(history.aheadHashes).values()].map(
+        (origin) => origin.agent,
+      ),
+    ),
+  ];
+}

package/backend/index.ts

@@ -0,0 +1,144 @@
+/**
+ * The Bonsai App facet: a Durable Object whose generated RPC methods are
+ * Bonsai's App methods. `fetch` serves the App's own UI (a JSON PUT naming a
+ * method, as agar's appBackend.request sends it). Native onGitPush receives
+ * accepted push facts from the host.
+ */
+import {
+  AppMethodRefusal,
+  appBackendActorHeader,
+  appBackendComputerHeader,
+  appMethodRefusalStatus,
+} from "@fungi.computer/agar/backend";
+import {
+  gitPushQuestionSchema,
+  type GitPushQuestion,
+  type GitPushVerdict,
+  type AppGitPushFact,
+} from "@fungi.computer/agar/git";
+import { DurableObject } from "cloudflare:workers";
+import * as z from "zod";
+import { gitStore, type GitBinding } from "./git.js";
+import { appBackend, type BonsaiAppsBinding } from "./methods.js";
+import {
+  observePush,
+  type EventSink,
+  type Bonsai as BonsaiRuntime,
+} from "./service.js";
+import { ensureBonsaiTables, BonsaiState } from "./state.js";
+import { mayPush } from "./policy.js";
+import type {
+  BackgroundSyncRefusal,
+  BackgroundBinding,
+} from "@fungi.computer/puffball/background-replay";
+import { refuseBackground } from "./background.js";
+
+/** The bindings the host grants Bonsai (see the Oyster binding proposal). */
+export type BonsaiEnv = Readonly<{
+  GIT: GitBinding;
+  EVENTS: EventSink;
+  BACKGROUND?: BackgroundBinding;
+  /** Fork, build and install Apps; present only on a host that supplies it. */
+  APPS?: BonsaiAppsBinding;
+}>;
+
+const uiRequest = z.strictObject({
+  method: z.string().min(1).max(80),
+  input: z.json(),
+});
+
+function declared(method: string): boolean {
+  return Object.hasOwn(appBackend.methods, method);
+}
+
+function failure(error: Error): Response {
+  if (error instanceof AppMethodRefusal)
+    return Response.json(
+      { error: error.code, message: error.message },
+      { status: appMethodRefusalStatus[error.code] },
+    );
+  if (error instanceof z.ZodError)
+    return Response.json({ error: "Invalid request" }, { status: 400 });
+  console.error("bonsai backend error", error);
+  return Response.json(
+    { error: "Bonsai could not finish that request" },
+    { status: 500 },
+  );
+}
+
+class BonsaiFacet extends DurableObject<BonsaiEnv> {
+  declare public readonly env: BonsaiEnv;
+  readonly bonsai: BonsaiRuntime;
+
+  constructor(ctx: DurableObjectState, env: BonsaiEnv) {
+    super(ctx, env);
+    ensureBonsaiTables(ctx.storage.sql);
+    this.bonsai = {
+      store: gitStore(env.GIT),
+      state: new BonsaiState(ctx.storage.sql, (body) =>
+        ctx.storage.transactionSync(body),
+      ),
+      events: env.EVENTS,
+    };
+  }
+
+  syncRefused(refusal: BackgroundSyncRefusal): Promise<void> {
+    return refuseBackground(this.bonsai, refusal);
+  }
+
+  async onGitPush(fact: AppGitPushFact): Promise<void> {
+    await observePush(this.bonsai, fact);
+  }
+
+  authorizeGitPush(raw: GitPushQuestion): Promise<GitPushVerdict> {
+    return Promise.resolve().then(() => {
+      const question = gitPushQuestionSchema.parse(raw);
+      const actor = question.writer.actor;
+      const allowed = mayPush(
+        actor.kind === "member"
+          ? { name: actor.memberId, kind: "human" }
+          : {
+              name: actor.kind === "team-key" ? actor.keyId : actor.agentId,
+              kind: "agent",
+            },
+        this.bonsai.state.repo(question.repository),
+      );
+      return allowed
+        ? { allowed: true }
+        : {
+            allowed: false,
+            refused: question.updates.map((update) => ({
+              ref: update.ref,
+              message: "Writer cannot push to this repository",
+            })),
+          };
+    });
+  }
+
+  override async fetch(request: Request): Promise<Response> {
+    try {
+      if (request.method !== "PUT")
+        return new Response(null, { status: 405, headers: { Allow: "PUT" } });
+      const body = uiRequest.parse(await request.json());
+      if (!declared(body.method))
+        return Response.json({ error: "No such method" }, { status: 404 });
+      const memberId = request.headers.get(appBackendActorHeader);
+      if (memberId === null)
+        return Response.json(
+          { error: "App actor unavailable" },
+          { status: 403 },
+        );
+      const result = await appBackend.call(body.method, body.input, this, {
+        computerId: request.headers.get(appBackendComputerHeader),
+        actor: { kind: "member", memberId },
+      });
+      return Response.json(result);
+    } catch (error) {
+      return failure(
+        error instanceof Error ? error : new Error("Non-error thrown"),
+      );
+    }
+  }
+}
+
+export const BonsaiApp = appBackend.implement(BonsaiFacet);