@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/checks-workflow-template.test.mjs

@@ -0,0 +1,234 @@
+import assert from "node:assert/strict";
+import { execFileSync, spawnSync } from "node:child_process";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { env as processEnv } from "node:process";
+import { join } from "node:path";
+import { test } from "node:test";
+import { URL, pathToFileURL } 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";
+// Shed's source is pinned at runtime only; Bonsai's compiler options do not own it.
+import { activityEnvelope, hookEvent } from "../shared/hooks.ts";
+import { buildAppApi } from "@fungi.computer/agar/backend-declaration";
+import { appBackend as bonsaiBackend } from "../backend/methods.ts";
+import { appBackend as shedBackend } from "../../shed/backend/methods.ts";
+const bonsaiApi = buildAppApi(bonsaiBackend);
+const shedApi = buildAppApi(shedBackend);
+
+// The stock Workflows template that reports checks onto Bonsai Changes.
+async function checksTemplate() {
+  const template = z
+    .object({ definition: z.json() })
+    .parse(
+      JSON.parse(
+        await readFile(
+          new URL(
+            "../../trellis/templates/bonsai-checks.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,
+    },
+    app_shed: { methods: (await catalogMethods(shedApi.methods)).methods },
+  };
+}
+
+const change = {
+  repo: "pond",
+  number: 12,
+  sourceRepo: "pond--morel",
+  sourceRef: "main",
+  targetRef: "main",
+  head: "b".repeat(40),
+};
+
+test("pins the checks template to Bonsai's and Shed's maintained declarations", async () => {
+  const definition = await checksTemplate();
+  const catalog = await installedCatalog();
+  assert.deepEqual(validate(definition, catalog), []);
+  const compiled = await compile(definition, catalog, {
+    bonsai: { appId: "app_bonsai", installationId: "bonsai" },
+    shed: { appId: "app_shed", installationId: "shed" },
+  });
+  assert.ok(compiled.ok, JSON.stringify(compiled));
+});
+
+test("starts checks at the Change head from each emitted Bonsai Change event", async () => {
+  const definition = await checksTemplate();
+  for (const type of [
+    "change.opened",
+    "change.updated",
+    "change.checks_requested",
+  ]) {
+    const trigger = definition.triggers?.find(
+      (item) => item.on === "event" && item.event === type,
+    );
+    assert.ok(trigger, type);
+    // The payload is the envelope Bonsai's outbox emits for a stored activity.
+    const payload = activityEnvelope(
+      {
+        id: 12,
+        at: Date.UTC(2026, 9, 13, 8),
+        type,
+        repo: "pond",
+        actor: "morel",
+        data: { change },
+      },
+      {
+        name: "pond--morel",
+        canonical: "pond",
+        cloneUrl: "https://bonsai.example/git/pond--morel.git",
+      },
+    );
+    const outcome = triggerRun(definition, trigger.id, {
+      eventId: payload.data.eventId,
+      payload,
+    });
+    assert.equal(outcome.kind, "start", type);
+    assert.equal(outcome.input.testCommand, "npm test");
+    // The read pass is scoped to the source repository holding the head.
+    assert.equal(outcome.repository, "pond--morel", type);
+    const started = hookEvent.parse(outcome.input.payload);
+    assert.equal(started.data.eventId, "evt_12");
+    assert.deepEqual(started.data.change, change);
+  }
+  assert.ok(
+    !definition.triggers?.some(
+      (item) => item.on === "event" && item.event === "git.push",
+    ),
+    "checks report on Changes, not bare pushes",
+  );
+});
+
+test("clones only through the step's read-only pass for the event's repository", async () => {
+  const definition = await checksTemplate();
+  const tests = definition.nodes.find((node) => node.id === "tests");
+  assert.ok(tests?.kind === "app");
+  assert.equal(tests.app, "shed");
+  assert.equal(tests.method, "runCommand");
+  assert.deepEqual(tests.gitAccess, {
+    binding: "bonsai",
+    repository: "$trigger.repository",
+    access: "read",
+  });
+  const commandNode = definition.nodes.find((node) => node.id === "command");
+  assert.ok(commandNode?.kind === "code");
+  assert.match(commandNode.source, /"\$FUNGI_GIT_REMOTE"/);
+  assert.doesNotMatch(commandNode.source, /cloneUrl/);
+});
+
+test("runs tests on the pinned Change head even after the source branch moves", async (t) => {
+  const definition = await checksTemplate();
+  const commandNode = definition.nodes.find((node) => node.id === "command");
+  const resultNode = definition.nodes.find((node) => node.id === "result");
+  assert.ok(commandNode?.kind === "code" && resultNode?.kind === "code");
+  const work = await mkdtemp(join(tmpdir(), "bonsai-check-head-"));
+  t.after(() => rm(work, { recursive: true, force: true }));
+  const source = join(work, "source");
+  execFileSync("git", ["init", "--initial-branch=main", source]);
+  const git = (...args) =>
+    execFileSync("git", ["-C", source, ...args], { encoding: "utf8" }).trim();
+  git("config", "user.name", "Morel");
+  git("config", "user.email", "morel@test.invalid");
+  await writeFile(
+    join(source, "package.json"),
+    JSON.stringify({ scripts: { test: "node check.mjs" } }),
+  );
+  await writeFile(
+    join(source, "check.mjs"),
+    'console.log("PINNED HEAD PASSED");',
+  );
+  git("add", ".");
+  git("commit", "-m", "Passing Change head");
+  const head = git("rev-parse", "HEAD");
+  await writeFile(
+    join(source, "check.mjs"),
+    'console.error("MOVED HEAD FAILED"); process.exit(1);',
+  );
+  git("commit", "-am", "New failing head");
+  const movedHead = git("rev-parse", "HEAD");
+  // Only the external Code execution boundary is replaced by Node VM here.
+  // The generated command itself runs real Git and npm in an isolated directory.
+  const evaluate = async (code, input) =>
+    z.json().parse(
+      await new Script(`(async () => { ${code} })()`).runInNewContext({
+        env: { INPUT: { read: () => Promise.resolve(input) } },
+      }),
+    );
+  for (const [selected, expected] of [
+    [head, "passed"],
+    [movedHead, "failed"],
+  ]) {
+    const command = z.object({ command: z.string() }).parse(
+      await evaluate(commandNode.source, {
+        head: selected,
+        testCommand: "npm test",
+        report: { kind: "recorded" },
+      }),
+    );
+    // Shed hands the pass's remote to the command as $FUNGI_GIT_REMOTE.
+    const execution = spawnSync("sh", ["-c", command.command], {
+      env: { ...processEnv, FUNGI_GIT_REMOTE: pathToFileURL(source).href },
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (execution.error !== undefined) throw execution.error;
+    assert.notEqual(execution.status, null, execution.signal ?? "");
+    const result = z
+      .object({ status: z.enum(["passed", "failed"]), summary: z.string() })
+      .parse(
+        await evaluate(resultNode.source, {
+          status: execution.status === 0 ? "succeeded" : "failed",
+          output: {
+            status: execution.status === 0 ? "completed" : "failed",
+            exitCode: execution.status,
+            stdout: execution.stdout,
+            stderr: execution.stderr,
+            truncated: false,
+          },
+        }),
+      );
+    assert.equal(result.status, expected);
+    assert.match(
+      result.summary,
+      expected === "passed" ? /PINNED HEAD PASSED/ : /MOVED HEAD FAILED/,
+    );
+  }
+  await assert.rejects(
+    evaluate(commandNode.source, {
+      head,
+      testCommand: "npm test",
+      report: { kind: "moved", head: movedHead },
+    }),
+    /Check attempt is no longer current/,
+  );
+  for (const refusal of [
+    { error: "not_granted" },
+    { status: "running", output: null },
+  ]) {
+    const result = z
+      .object({ status: z.string() })
+      .parse(await evaluate(resultNode.source, refusal));
+    assert.equal(result.status, "failed");
+  }
+});

package/test/diff.test.ts

@@ -0,0 +1,70 @@
+import { bindingOf } from "./git-binding.fixture.js";
+import { describe, expect, it } from "vitest";
+import type { GitStore } from "../backend/git.js";
+import { decodeText, isBinary, treeDiff } from "../backend/diff.js";
+
+describe("git blob text decoding", () => {
+  it("distinguishes an empty text blob from invalid UTF-8", () => {
+    expect(decodeText(new Uint8Array())).toEqual({ kind: "text", text: "" });
+    expect(decodeText(new Uint8Array([0xff]))).toEqual({
+      kind: "invalid-utf8",
+    });
+  });
+
+  it("keeps valid multi-byte text and the bounded binary probe", () => {
+    const text = `${"a".repeat(7999)}é`;
+    expect(decodeText(new TextEncoder().encode(text))).toEqual({
+      kind: "text",
+      text,
+    });
+    expect(isBinary(new TextEncoder().encode(text))).toBe(false);
+    expect(isBinary(new Uint8Array([0, 65]))).toBe(true);
+    expect(isBinary(new Uint8Array([0xff]))).toBe(true);
+  });
+});
+
+it.each(["100644", "100755", "120000"])(
+  "marks invalid UTF-8 in a %s blob as binary, not an empty text diff",
+  async (mode) => {
+    const invalid = new Uint8Array(8001).fill(65);
+    invalid[8000] = 255;
+    const unused = () => Promise.reject(new Error("Unexpected Git operation"));
+    const store: GitStore = {
+      get binding() {
+        return bindingOf(this);
+      },
+      cloneUrl: unused,
+      create: unused,
+      fork: unused,
+      info: unused,
+      log: unused,
+      commit: unused,
+      refs: unused,
+      exchange: unused,
+      tree: (_repo, hash) =>
+        Promise.resolve([
+          {
+            name: "late.bin",
+            mode,
+            type: "blob",
+            hash: hash === "old" ? "a".repeat(40) : "b".repeat(40),
+          },
+        ]),
+      blob: (_repo, hash) =>
+        Promise.resolve(
+          hash === "a".repeat(40)
+            ? new TextEncoder().encode("old text")
+            : invalid,
+        ),
+    };
+    const result = await treeDiff(store, "pond", "old", "new");
+    expect(result.files).toHaveLength(1);
+    expect(result.files[0]).toMatchObject({
+      binary: true,
+      oldText: null,
+      newText: null,
+      additions: 0,
+      deletions: 0,
+    });
+  },
+);

package/test/edit-in-inkcap.test.ts

@@ -0,0 +1,227 @@
+// @vitest-environment jsdom
+import { afterEach, expect, it, vi } from "vitest";
+import { act, createElement } from "react";
+import { createRoot } from "react-dom/client";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { createCapabilityRegistry } from "@fungi.computer/agar";
+import {
+  appsOpen,
+  type AppOpenInput,
+  type AppRoleChoice,
+} from "@fungi.computer/agar/apps";
+import { appMethods } from "@fungi.computer/agar/backend";
+import { CodeTab } from "../web/code-tab.js";
+import { RouterProvider } from "../web/router.js";
+import { connect } from "../web/transport.js";
+const clean: (() => Promise<void> | void)[] = [];
+afterEach(async () => {
+  for (const dispose of clean.splice(0)) await dispose();
+  vi.unstubAllGlobals();
+  connect(null);
+});
+async function fixture(
+  granted: boolean,
+  binary = false,
+  pending?: { text: string; revision: number; state: "pending" | "failed" },
+  /** The Team's files-role choice as the shell's role routing reports it. */
+  filesRole: AppRoleChoice = { displayName: "Quill" },
+) {
+  vi.stubGlobal("matchMedia", () => ({
+    matches: false,
+    addEventListener() {
+      return undefined;
+    },
+    removeEventListener() {
+      return undefined;
+    },
+  }));
+  vi.stubGlobal(
+    "ResizeObserver",
+    class {
+      observe() {
+        return undefined;
+      }
+      disconnect() {
+        return undefined;
+      }
+      unobserve() {
+        return undefined;
+      }
+    },
+  );
+  Object.assign(globalThis, { IS_REACT_ACT_ENVIRONMENT: true });
+  const opened: AppOpenInput[] = [];
+  const asked: string[] = [];
+  const capabilities = createCapabilityRegistry();
+  if (granted)
+    capabilities.provide(appsOpen, {
+      open: (input) => {
+        opened.push(input);
+        return Promise.resolve();
+      },
+      role: (role) => {
+        asked.push(role);
+        return Promise.resolve(filesRole);
+      },
+    });
+  const called: string[] = [];
+  capabilities.provide(appMethods, {
+    call: (method) => {
+      called.push(method);
+      return Promise.resolve({ settled: [], more: true });
+    },
+  });
+  connect({ capabilities });
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, staleTime: Infinity } },
+  });
+  const commit = {
+    hash: "a".repeat(40),
+    treeHash: "b".repeat(40),
+    message: "Plant pond",
+    author: { name: "seed", email: "seed@test.invalid" },
+    committer: { name: "seed", email: "seed@test.invalid" },
+    parents: [],
+    authoredAt: 0,
+    committedAt: 0,
+  };
+  client.setQueryData(["files", "pond", "main"], {
+    ref: "main",
+    commit,
+    paths: ["README.md"],
+    truncated: false,
+  });
+  const read = {
+    ref: "main",
+    path: "README.md",
+    commit: commit.hash,
+    blob: "c".repeat(40),
+    size: 7,
+    binary,
+    text: binary ? null : "# Pond",
+    version: pending?.revision ?? null,
+  };
+  client.setQueryData(
+    ["blob", "pond", "main", "README.md"],
+    pending === undefined ? read : { ...read, pending },
+  );
+  const container = document.createElement("div");
+  document.body.appendChild(container);
+  const root = createRoot(container);
+  clean.push(async () => {
+    await act(() => {
+      root.unmount();
+      return Promise.resolve();
+    });
+    client.clear();
+    container.remove();
+  });
+  await act(() => {
+    root.render(
+      createElement(
+        QueryClientProvider,
+        { client },
+        createElement(
+          RouterProvider,
+          null,
+          createElement(CodeTab, {
+            route: {
+              page: "repo",
+              repo: "pond",
+              tab: "code",
+              ref: null,
+              file: "README.md",
+              path: "",
+            },
+            detail: {
+              repo: {
+                name: "pond",
+                description: null,
+                parent: null,
+                owner: null,
+                createdAt: 0,
+                lastPushAt: null,
+                forks: [],
+                openChanges: 0,
+                activity: [],
+              },
+              defaultBranch: "main",
+              refs: [],
+              cloneUrl: "https://example.test/pond.git",
+              empty: false,
+            },
+          }),
+        ),
+      ),
+    );
+    // Let the role lookup settle before reading the rendered entry.
+    return Promise.resolve();
+  });
+  await act(async () => {
+    await new Promise((resolve) => setTimeout(resolve, 0));
+  });
+  return { container, opened, called, asked };
+}
+const editButton = (container: HTMLElement) =>
+  Array.from(container.querySelectorAll("button")).find((button) =>
+    button.textContent.startsWith("Edit"),
+  );
+it("Edit opens the Team's files-role App, named by the shell, with the repository, branch and path", async () => {
+  const f = await fixture(true);
+  const button = editButton(f.container);
+  if (button === undefined) throw new Error("Missing edit button");
+  expect(button.textContent).toBe("Edit in Quill");
+  expect(f.asked).toEqual(["files"]);
+  await act(() => {
+    button.click();
+    return Promise.resolve();
+  });
+  expect(f.opened).toEqual([
+    {
+      role: "files",
+      intent: {
+        kind: "navigate",
+        params: [
+          { key: "repository", value: "pond" },
+          { key: "branch", value: "main" },
+          { key: "path", value: "README.md" },
+        ],
+      },
+    },
+  ]);
+});
+it("an unnamed files-role App gets a neutral Edit", async () => {
+  const f = await fixture(true, false, undefined, { displayName: null });
+  expect(editButton(f.container)?.textContent).toBe("Edit");
+});
+
+it.each([
+  ["without apps.open", false, false, { displayName: "Quill" }],
+  ["for a binary file", true, true, { displayName: "Quill" }],
+  ["when no App fills the files role", true, false, null],
+] as const)("hides Edit %s", async (_case, granted, binary, filesRole) => {
+  const f = await fixture(granted, binary, undefined, filesRole);
+  expect(editButton(f.container)).toBeUndefined();
+  expect(f.opened).toEqual([]);
+});
+
+it("a saved but unsynced edit shows its text and Sync asks Bonsai for this member's status", async () => {
+  const f = await fixture(true, false, {
+    text: "# Pond, edited",
+    revision: 2,
+    state: "failed",
+  });
+  expect(f.container.textContent).toContain(
+    "Sync failed · Saved text retained",
+  );
+  expect(f.container.textContent).toContain("Pond, edited");
+  const sync = Array.from(f.container.querySelectorAll("button")).find(
+    (button) => button.textContent === "Sync",
+  );
+  if (sync === undefined) throw new Error("Missing Sync button");
+  await act(async () => {
+    sync.click();
+    await Promise.resolve();
+  });
+  expect(f.called[0]).toBe("files.sync");
+});