@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/merge-template-build.test.mjs

@@ -0,0 +1,234 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { test } from "node:test";
+import { URL } from "node:url";
+import { Script } from "node:vm";
+import * as S from "effect/Schema";
+import * as z from "zod";
+import {
+  catalogEvents,
+  catalogMethods,
+  compile,
+  triggerRun,
+  validate,
+  workflowDefinitionSchema,
+} from "@fungi.computer/braid";
+import { buildAppApi } from "@fungi.computer/agar/backend-declaration";
+import { activityEnvelope } from "../shared/hooks.ts";
+import { appBackend as bonsaiBackend } from "../backend/methods.ts";
+const bonsaiApi = buildAppApi(bonsaiBackend);
+
+// The stock Workflows template that builds and installs an App on merge.
+async function buildOnMergeTemplate() {
+  const template = z
+    .object({ definition: z.json() })
+    .parse(
+      JSON.parse(
+        await readFile(
+          new URL(
+            "../../trellis/templates/bonsai-build-on-merge.json",
+            import.meta.url,
+          ),
+          "utf8",
+        ),
+      ),
+    );
+  return S.decodeUnknownSync(workflowDefinitionSchema)(template.definition);
+}
+
+async function installedCatalog() {
+  return {
+    app_bonsai: {
+      methods: (await catalogMethods(bonsaiApi.methods)).methods,
+      events: (await catalogEvents(bonsaiApi.events)).events,
+    },
+  };
+}
+
+function findNode(definition, id) {
+  const node = definition.nodes.find((candidate) => candidate.id === id);
+  assert.ok(node, `missing node ${id}`);
+  return node;
+}
+
+// Only the external Code execution boundary is replaced by Node VM here.
+const evaluate = async (code, input) =>
+  z.json().parse(
+    await new Script(`(async () => { ${code} })()`).runInNewContext({
+      env: { INPUT: { read: () => Promise.resolve(input) } },
+    }),
+  );
+
+const after = "c".repeat(40);
+// The envelope Bonsai's outbox emits when a Change merges into `repo`.
+function mergedEnvelope({ repo = "my-app", ref = "main" } = {}) {
+  return activityEnvelope(
+    {
+      id: 41,
+      at: Date.UTC(2026, 9, 15, 4),
+      type: "merge",
+      repo,
+      actor: "morel",
+      data: {
+        change: {
+          repo,
+          number: 3,
+          sourceRepo: `${repo}--morel`,
+          sourceRef: "edit",
+          targetRef: ref,
+          head: "b".repeat(40),
+        },
+        from: `${repo}--morel`,
+        ref,
+        before: "a".repeat(40),
+        after,
+      },
+    },
+    {
+      name: `${repo}--morel`,
+      canonical: repo,
+      cloneUrl: `https://bonsai.example/git/${repo}--morel.git`,
+    },
+  );
+}
+
+test("pins the build-on-merge template to Bonsai's maintained declarations", async () => {
+  const definition = await buildOnMergeTemplate();
+  const catalog = await installedCatalog();
+  assert.deepEqual(validate(definition, catalog), []);
+  const compiled = await compile(definition, catalog, {
+    bonsai: { appId: "app_bonsai", installationId: "bonsai" },
+  });
+  assert.ok(compiled.ok, JSON.stringify(compiled));
+  // No key, token or Git pass rides in the definition: every step is an App
+  // method call made as the arming owner.
+  const text = JSON.stringify(definition);
+  assert.doesNotMatch(text, /gitAccess|OYSTER_OWNER_KEY|Authorization|token/iu);
+  // The run starts the build of the merged commit, then waits on that job.
+  const build = findNode(definition, "build");
+  assert.ok(build.kind === "app");
+  assert.equal(build.method, "apps.build");
+  assert.deepEqual(build.values.sourceRevision, {
+    from: { node: "merged", port: "sourceRevision" },
+  });
+  const status = findNode(definition, "build-status");
+  assert.ok(status.kind === "app");
+  assert.equal(status.method, "apps.buildStatus");
+  assert.deepEqual(status.values.jobId, {
+    from: { node: "build", port: "jobId" },
+  });
+  assert.equal(
+    catalog.app_bonsai.methods["apps.buildStatus"].pending,
+    true,
+    "the Workflow waits on the job through a pending method",
+  );
+});
+
+test("starts on a merge into the App's source main, at the merged commit", async () => {
+  const definition = await buildOnMergeTemplate();
+  const trigger = definition.triggers?.find(
+    (item) => item.on === "event" && item.event === "change.merged",
+  );
+  assert.ok(trigger);
+  const payload = mergedEnvelope();
+  const outcome = triggerRun(definition, trigger.id, {
+    eventId: payload.data.eventId,
+    payload,
+  });
+  assert.equal(outcome.kind, "start", JSON.stringify(outcome));
+  // The owner setting defaults to showing the Workflows review UI.
+  assert.equal(outcome.input.reviewBeforeInstall, true);
+  const merged = findNode(definition, "merged");
+  assert.ok(merged.kind === "code");
+  assert.deepEqual(
+    await evaluate(merged.source, {
+      payload: outcome.input.payload,
+      appId: outcome.input.appId,
+    }),
+    { appId: outcome.input.appId, sourceRevision: `git:${after}` },
+  );
+  for (const other of [{ repo: "elsewhere" }, { ref: "release" }]) {
+    const skipped = mergedEnvelope(other);
+    assert.deepEqual(
+      triggerRun(definition, trigger.id, {
+        eventId: skipped.data.eventId,
+        payload: skipped,
+      }),
+      { kind: "ignored" },
+      JSON.stringify(other),
+    );
+  }
+});
+
+test("installs only a passing build of the merged commit", async () => {
+  const definition = await buildOnMergeTemplate();
+  const built = findNode(definition, "built");
+  assert.ok(built.kind === "code");
+  const sourceRevision = `git:${after}`;
+  const release = {
+    appId: "app_myapp",
+    releaseId: "rel_built",
+    artifact: { provenance: { sourceRevision } },
+  };
+  assert.deepEqual(
+    await evaluate(built.source, {
+      status: "succeeded",
+      detail: null,
+      release,
+      sourceRevision,
+    }),
+    {
+      release,
+      summary: `Built rel_built of app_myapp from ${sourceRevision}`,
+    },
+  );
+  await assert.rejects(
+    evaluate(built.source, {
+      status: "failed",
+      detail: "tsc exited 2",
+      release: null,
+      sourceRevision,
+    }),
+    /The build did not pass: tsc exited 2/u,
+  );
+  await assert.rejects(
+    evaluate(built.source, {
+      status: "succeeded",
+      detail: null,
+      release,
+      sourceRevision: `git:${"d".repeat(40)}`,
+    }),
+    /not the merged commit/u,
+  );
+});
+
+test("routes the Release through review only when Review before install is on", async () => {
+  const definition = await buildOnMergeTemplate();
+  const gate = findNode(definition, "review-gate");
+  assert.ok(gate.kind === "condition");
+  assert.deepEqual(gate.test, {
+    op: "eq",
+    left: { from: { node: "$input", port: "reviewBeforeInstall" } },
+    right: { literal: true },
+  });
+  // The review is reached only from the gate's true outlet, automatic
+  // install only from its false one; install takes whichever ran.
+  const review = findNode(definition, "review");
+  assert.ok(review.kind === "review");
+  assert.deepEqual(review.show[0], { node: "to-review", port: "release" });
+  assert.deepEqual(findNode(definition, "to-review").fields.review, {
+    from: { node: "review-gate", port: "true" },
+  });
+  assert.deepEqual(findNode(definition, "automatic").fields.automatic, {
+    from: { node: "review-gate", port: "false" },
+  });
+  const install = findNode(definition, "install");
+  assert.ok(install.kind === "app");
+  assert.equal(install.method, "apps.install");
+  assert.deepEqual(install.values.release, {
+    coalesce: [
+      { from: { node: "review", port: "approved" } },
+      { from: { node: "automatic", port: "release" } },
+    ],
+  });
+});

package/test/network-layout.test.ts

@@ -0,0 +1,200 @@
+import { describe, expect, it } from "vitest";
+import type { Graph } from "../shared/contract.js";
+import { layoutGraph } from "../web/network-graph.js";
+
+const h = (n: number) => n.toString(16).padStart(40, "0");
+
+describe("network layout", () => {
+  it("puts shared history on the canonical lane and fork work on its own lane", () => {
+    const graph: Graph = {
+      lanes: [
+        {
+          id: "r:main",
+          repo: "r",
+          ref: "main",
+          owner: null,
+          head: h(1),
+          canonical: true,
+        },
+        {
+          id: "r--ada:main",
+          repo: "r--ada",
+          ref: "main",
+          owner: "ada",
+          head: h(3),
+          canonical: false,
+        },
+      ],
+      nodes: [
+        {
+          hash: h(3),
+          parents: [h(2)],
+          message: "c",
+          author: "ada",
+          agent: "ada",
+          origin: "r--ada",
+          committedAt: 3,
+          lanes: ["r--ada:main"],
+        },
+        {
+          hash: h(2),
+          parents: [h(1)],
+          message: "b",
+          author: "ada",
+          agent: "ada",
+          origin: "r--ada",
+          committedAt: 2,
+          lanes: ["r--ada:main"],
+        },
+        {
+          hash: h(1),
+          parents: [],
+          message: "a",
+          author: "levi",
+          agent: null,
+          origin: null,
+          committedAt: 1,
+          lanes: ["r:main", "r--ada:main"],
+        },
+      ],
+    };
+    const layout = layoutGraph(graph, 40);
+    expect(layout.placed.get(h(1))?.row).toBe(0);
+    expect(layout.placed.get(h(2))?.row).toBe(1);
+    const xs = [h(1), h(2), h(3)].map(
+      (hash) => layout.placed.get(hash)?.x ?? -1,
+    );
+    expect(xs).toEqual([...xs].sort((x, y) => x - y));
+  });
+
+  it("orders a parent before its child even when clocks disagree", () => {
+    const graph: Graph = {
+      lanes: [
+        {
+          id: "r:main",
+          repo: "r",
+          ref: "main",
+          owner: null,
+          head: h(2),
+          canonical: true,
+        },
+      ],
+      nodes: [
+        {
+          hash: h(2),
+          parents: [h(1)],
+          message: "child",
+          author: "x",
+          agent: null,
+          origin: null,
+          committedAt: 1,
+          lanes: ["r:main"],
+        },
+        {
+          hash: h(1),
+          parents: [],
+          message: "parent",
+          author: "x",
+          agent: null,
+          origin: null,
+          committedAt: 5,
+          lanes: ["r:main"],
+        },
+      ],
+    };
+    const layout = layoutGraph(graph, 40);
+    expect(layout.placed.get(h(1))?.x).toBeLessThan(
+      layout.placed.get(h(2))?.x ?? 0,
+    );
+  });
+
+  it("keeps a merged fork commit on its fork lane", () => {
+    const graph: Graph = {
+      lanes: [
+        {
+          id: "r:main",
+          repo: "r",
+          ref: "main",
+          owner: null,
+          head: h(3),
+          canonical: true,
+        },
+        {
+          id: "r--ada:main",
+          repo: "r--ada",
+          ref: "main",
+          owner: "ada",
+          head: h(2),
+          canonical: false,
+        },
+      ],
+      nodes: [
+        {
+          hash: h(3),
+          parents: [h(1), h(2)],
+          message: "merge",
+          author: "bonsai",
+          agent: "levi",
+          origin: "r",
+          committedAt: 3,
+          lanes: ["r:main"],
+        },
+        {
+          hash: h(2),
+          parents: [h(1)],
+          message: "work",
+          author: "ada",
+          agent: "ada",
+          origin: "r--ada",
+          committedAt: 2,
+          lanes: ["r:main", "r--ada:main"],
+        },
+        {
+          hash: h(1),
+          parents: [],
+          message: "start",
+          author: "levi",
+          agent: "levi",
+          origin: "r",
+          committedAt: 1,
+          lanes: ["r:main", "r--ada:main"],
+        },
+      ],
+    };
+    const layout = layoutGraph(graph, 40);
+    expect(layout.placed.get(h(2))?.row).toBe(1);
+    expect(layout.placed.get(h(3))?.row).toBe(0);
+  });
+});
+
+it("places every parent below its children in the vertical rail, despite clock skew", async () => {
+  const { verticalHistory } = await import("../web/commit-tree.js");
+  const lane = {
+    id: "r:main",
+    repo: "r",
+    ref: "main",
+    owner: null,
+    head: h(2),
+    canonical: true,
+  };
+  const base = {
+    message: "commit",
+    author: "x",
+    agent: null,
+    origin: null,
+    lanes: [lane.id],
+  };
+  const graph: Graph = {
+    lanes: [lane],
+    nodes: [
+      { ...base, hash: h(1), parents: [], committedAt: 50 },
+      { ...base, hash: h(2), parents: [h(1)], committedAt: 1 },
+    ],
+  };
+  const tree = verticalHistory(graph);
+  expect(tree.order.map((item) => item.node.hash)).toEqual([h(2), h(1)]);
+  expect(tree.byHash.get(h(1))?.y).toBeGreaterThan(
+    tree.byHash.get(h(2))?.y ?? 0,
+  );
+  expect(tree.width).toBeLessThan(150);
+});