@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/shared/picker-options.ts

@@ -0,0 +1,23 @@
+/** Bonsai picker methods share Gills' maintained placement and choice grammar. */
+import * as Schema from "effect/Schema";
+import * as z from "zod";
+import {
+  gillParamsSchema,
+  gillOptionsResponseSchema,
+} from "@fungi.computer/gills";
+
+const decodeParams = Schema.decodeUnknownSync(gillParamsSchema, {
+  onExcessProperty: "error",
+});
+const params = z
+  .fromJSONSchema(Schema.toJsonSchemaDocument(gillParamsSchema).schema)
+  .transform((value) => decodeParams(value));
+export const pickerOptionsInput = z.strictObject({
+  params,
+  limit: z.number().int().min(1).max(200),
+  after: z.string().max(1024).optional(),
+});
+export type PickerOptionsInput = z.output<typeof pickerOptionsInput>;
+export const pickerOptionsPage = z.fromJSONSchema(
+  Schema.toJsonSchemaDocument(gillOptionsResponseSchema).schema,
+);

package/shared/presentation.ts

@@ -0,0 +1,21 @@
+import type { StatusTone } from "@fungi.computer/caps/components/status";
+import type { Change } from "./contract.js";
+
+/** The same App-owned status labels and tones serve lists and Gills. */
+export function changeStatusLabel(status: Change["status"]): string {
+  const label = status.replaceAll("-", " ");
+  return label.charAt(0).toUpperCase() + label.slice(1);
+}
+
+export const changeStatusTone = {
+  conflict: "warning",
+  "checks-failed": "error",
+  "checks-running": "info",
+  "needs-approval": "warning",
+  ready: "success",
+  merging: "info",
+  merged: "success",
+  closed: "neutral",
+} as const satisfies Record<Change["status"], StatusTone>;
+
+export { relativeTime } from "@fungi.computer/gills/presentation";

package/shared/repository-deletion.ts

@@ -0,0 +1,4 @@
+import * as z from "zod";
+
+/** Successful deletion confirms both catalog withdrawal and provider cleanup. */
+export const repositoryDeletion = z.strictObject({ deleted: z.literal(true) });

package/test/apps-build-install.test.ts

@@ -0,0 +1,302 @@
+import { DatabaseSync } from "node:sqlite";
+import { describe, expect, it } from "vitest";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import { AppMethodRefusal } from "@fungi.computer/agar/backend";
+import type { GitBinding } from "@fungi.computer/agar/git";
+import { appBackend } from "../backend/methods.js";
+import { gitStore } from "../backend/git.js";
+import { ensureBonsaiTables, BonsaiState } from "../backend/state.js";
+import type { Bonsai } from "../backend/service.js";
+import {
+  appBackendBindingOperation,
+  scopeOperationToMethod,
+} from "@fungi.computer/puffball/app";
+
+type Calls = {
+  build?: unknown;
+  buildStatus?: unknown;
+  select?: unknown;
+};
+
+/** apps.build/apps.buildStatus/apps.install never touch Git or Bonsai's own
+ * repository state; a real (empty) BonsaiState plus an always-unavailable
+ * GitBinding give a fully typed Bonsai without faking its shape. apps.fork
+ * reads the one repository the host forked, through `git`. */
+function bonsaiFixture(git: Partial<GitBinding> = {}): Bonsai {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const unavailable = () =>
+    Promise.reject(new Error("Unexpected provider operation"));
+  const binding: GitBinding = {
+    create: unavailable,
+    fork: unavailable,
+    cloneUrl: unavailable,
+    info: unavailable,
+    delete: unavailable,
+    log: unavailable,
+    readCommit: unavailable,
+    readTree: unavailable,
+    readBlob: unavailable,
+    refs: unavailable,
+    exchange: unavailable,
+    ...git,
+  };
+  return {
+    state: new BonsaiState(owner.sql, owner.transactionSync),
+    store: gitStore(binding),
+    events: { emit: () => Promise.resolve() },
+  };
+}
+
+function fixture() {
+  const calls: Calls = {};
+  const build = {
+    jobId: "build_test",
+    appId: "app_my-fork",
+    releaseId: "rel_test",
+    sourceRevision: `git:${"a".repeat(40)}`,
+    status: "running" as const,
+    detail: null,
+    release: null,
+  };
+  const release = {
+    appId: "app_my-fork",
+    releaseId: "rel_test",
+    artifact: {
+      artifactRef: "artifact:root",
+      artifactDigest: `sha256:${"b".repeat(64)}`,
+      provenance: {
+        sourceRevision: build.sourceRevision,
+        sourceTreeDigest: `sha256:${"c".repeat(64)}`,
+        buildRecipeDigest: `sha256:${"d".repeat(64)}`,
+      },
+    },
+  };
+  const env = {
+    APPS: {
+      fork: () => Promise.reject(new Error("This proof never forks")),
+      build: (input: { appId: string; sourceRevision: string }) => {
+        calls.build = input;
+        return Promise.resolve({ status: 202, body: build });
+      },
+      buildStatus: (input: { jobId: string }) => {
+        calls.buildStatus = input;
+        return Promise.resolve({
+          status: 200,
+          body:
+            input.jobId === "build_running"
+              ? { ...build, jobId: input.jobId }
+              : { ...build, status: "succeeded" as const, release },
+        });
+      },
+      select: (input: { installationId: string; release: unknown }) => {
+        calls.select = input;
+        return Promise.resolve({
+          status: 200,
+          body: { installationId: input.installationId, status: "enabled" },
+        });
+      },
+    },
+  };
+  const bonsai = bonsaiFixture();
+  const owner = (
+    method: string,
+    input: import("../shared/contract.js").JsonValue,
+  ) =>
+    appBackend.call(
+      method,
+      input,
+      { bonsai, env },
+      {
+        actor: { kind: "member", memberId: "Levi" },
+        computerId: null,
+        role: "owner" as const,
+      },
+    );
+  const member = (
+    method: string,
+    input: import("../shared/contract.js").JsonValue,
+  ) =>
+    appBackend.call(
+      method,
+      input,
+      { bonsai, env },
+      {
+        actor: { kind: "member", memberId: "Ren" },
+        computerId: null,
+        role: "member" as const,
+      },
+    );
+  return { owner, member, calls, build, release };
+}
+
+describe("apps.build / apps.install", () => {
+  it("apps.build starts a job on the APPS binding and returns its id", async () => {
+    const f = fixture();
+    const result = await f.owner("apps.build", {
+      appId: "app_my-fork",
+      sourceRevision: `git:${"a".repeat(40)}`,
+    });
+    expect(result).toMatchObject({ jobId: "build_test", status: "running" });
+    expect(f.calls.build).toEqual({
+      appId: "app_my-fork",
+      sourceRevision: `git:${"a".repeat(40)}`,
+    });
+  });
+
+  it("apps.install switches the Release through the APPS binding", async () => {
+    const f = fixture();
+    const result = await f.owner("apps.install", {
+      installationId: "my-fork",
+      release: f.release,
+    });
+    expect(result).toEqual({ installationId: "my-fork", status: "enabled" });
+    expect(f.calls.select).toEqual({
+      installationId: "my-fork",
+      release: f.release,
+    });
+  });
+
+  it("apps.buildStatus reads a job's current status through the APPS binding", async () => {
+    const f = fixture();
+    const result = await f.owner("apps.buildStatus", { jobId: "build_test" });
+    expect(result).toMatchObject({ status: "succeeded", release: f.release });
+    expect(f.calls.buildStatus).toEqual({ jobId: "build_test" });
+  });
+
+  it("apps.buildStatus answers Pending while the job runs, so a Workflow step waits on it", async () => {
+    const f = fixture();
+    expect(appBackend.methods["apps.buildStatus"]?.policy.pending).toBe(true);
+    const result = await f.owner("apps.buildStatus", {
+      jobId: "build_running",
+    });
+    expect(result).toMatchObject({ kind: "pending" });
+  });
+
+  it("declares what the host's APPS operations require, so their grants reach the call", () => {
+    for (const [method, operation] of [
+      ["apps.build", "build"],
+      ["apps.buildStatus", "buildStatus"],
+      ["apps.install", "select"],
+      ["apps.fork", "fork"],
+    ] as const) {
+      const declared = appBackendBindingOperation("APPS", operation);
+      const policy = appBackend.methods[method]?.policy;
+      expect(declared).toBeDefined();
+      expect(policy).toBeDefined();
+      if (declared === undefined || policy === undefined) return;
+      // The host grants an operation only through approved capabilities;
+      // one that requires none is never granted at all.
+      expect(declared.requires.length).toBeGreaterThan(0);
+      expect(scopeOperationToMethod(declared, policy, "write")).toBe(true);
+    }
+  });
+
+  it("refuses apps.build for a non-owner member, typed", async () => {
+    const f = fixture();
+    await expect(
+      f.member("apps.build", {
+        appId: "app_my-fork",
+        sourceRevision: `git:${"a".repeat(40)}`,
+      }),
+    ).rejects.toSatisfy(
+      (error) =>
+        error instanceof AppMethodRefusal && error.code === "forbidden",
+    );
+    expect(f.calls.build).toBeUndefined();
+  });
+
+  it("refuses apps.install for a non-owner member, typed", async () => {
+    const f = fixture();
+    await expect(
+      f.member("apps.install", {
+        installationId: "my-fork",
+        release: f.release,
+      }),
+    ).rejects.toSatisfy(
+      (error) =>
+        error instanceof AppMethodRefusal && error.code === "forbidden",
+    );
+    expect(f.calls.select).toBeUndefined();
+  });
+});
+
+describe("apps.fork", () => {
+  const head = "c".repeat(40);
+  function forkFixture() {
+    const bonsai = bonsaiFixture({
+      info: (name) =>
+        Promise.resolve(
+          name === "my-app"
+            ? { name, defaultBranch: "main", lastPushAt: null, source: null }
+            : null,
+        ),
+      refs: () => Promise.resolve([{ name: "refs/heads/main", hash: head }]),
+      cloneUrl: (name) =>
+        Promise.resolve(`https://oyster.test/git/bonsai/${name}.git`),
+    });
+    const forks: unknown[] = [];
+    const refused = () => Promise.reject(new Error("Not part of a fork"));
+    const env = {
+      APPS: {
+        fork: (input: { platformAppId: string; name: string }) => {
+          forks.push(input);
+          return Promise.resolve({
+            kind: "forked" as const,
+            appId: "app_myapp",
+            repository: "my-app",
+          });
+        },
+        build: refused,
+        buildStatus: refused,
+        select: refused,
+      },
+    };
+    const call = (
+      role: "owner" | "member",
+      input: import("../shared/contract.js").JsonValue,
+    ) =>
+      appBackend.call(
+        "apps.fork",
+        input,
+        { bonsai, env },
+        {
+          actor: { kind: "member", memberId: "Levi" },
+          computerId: null,
+          role,
+        },
+      );
+    return { bonsai, forks, call };
+  }
+
+  it("records the host's fork as a Bonsai repository the owner merges in", async () => {
+    const f = forkFixture();
+    const result = await f.call("owner", {
+      appId: "app_bonsai",
+      name: "my-app",
+    });
+    expect(result).toEqual({ appId: "app_myapp", repository: "my-app" });
+    expect(f.forks).toEqual([{ platformAppId: "app_bonsai", name: "my-app" }]);
+    expect(f.bonsai.state.repo("my-app")).toMatchObject({
+      name: "my-app",
+      parent: null,
+    });
+  });
+
+  it("refuses a non-owner and an invalid name before any fork, typed", async () => {
+    const f = forkFixture();
+    await expect(
+      f.call("member", { appId: "app_bonsai", name: "my-app" }),
+    ).rejects.toSatisfy(
+      (error) =>
+        error instanceof AppMethodRefusal && error.code === "forbidden",
+    );
+    await expect(
+      f.call("owner", { appId: "app_bonsai", name: "my--app" }),
+    ).rejects.toSatisfy(
+      (error) => error instanceof AppMethodRefusal && error.code === "invalid",
+    );
+    expect(f.forks).toEqual([]);
+  });
+});

package/test/background-runtime.test.ts

@@ -0,0 +1,206 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { countingGit } from "@fungi.computer/agar/read-copy";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import {
+  backgroundContext,
+  backgroundOriginKey,
+  sealBackgroundOrigin,
+  admitClaimedOrigin,
+} from "@fungi.computer/puffball/background-replay";
+import { realGit } from "@fungi.computer/agar/test-kit/git";
+import {
+  backgroundRuntime,
+  registerBackgroundProjector,
+} from "../backend/background.js";
+import type { WatchdogQueueTransition } from "@fungi.computer/watchdog";
+import { saveFileEdit, projectQueuedFileEdit } from "../backend/file-edits.js";
+import { gitStore } from "../backend/git.js";
+import { BonsaiState, ensureBonsaiTables } from "../backend/state.js";
+
+it("shares the actor runner and completes discarded file jobs without touching another member's lane or Git", async () => {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const provider = realGit();
+  const controller = new AbortController();
+  const counted = countingGit(provider.git, {
+    limit: 100,
+    signal: controller.signal,
+  });
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  state.registerRepo({
+    name: "pond",
+    description: null,
+    parent: null,
+    owner: null,
+  });
+  const bonsai = {
+    state,
+    store: gitStore(counted.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  const key = await backgroundOriginKey("background-runtime-test-key");
+  const caller = async (memberId: string) =>
+    backgroundContext(
+      { actor: { kind: "member", memberId }, computerId: null },
+      [],
+      { name: "files.save", effect: "write" },
+      await sealBackgroundOrigin(key, {
+        instanceId: "runner-test",
+        lane: `member:${memberId}`,
+        method: "files.save",
+      }),
+    );
+  const member = await caller("owner");
+  const other = await caller("other");
+  const input = {
+    repo: "pond",
+    branch: "main",
+    path: "README.md",
+    text: "Saved\n",
+    baseCommit: "a".repeat(40),
+    baseBlob: null,
+    revision: null,
+  };
+  try {
+    const background = {
+      admit: (origin: NonNullable<typeof member.backgroundOrigin>) =>
+        admitClaimedOrigin(
+          key,
+          {
+            instanceId: "runner-test",
+            lane: "member:owner",
+            admitted: ["files.save"],
+          },
+          origin,
+        ),
+    };
+    const runtime = await backgroundRuntime(
+      bonsai,
+      member,
+      controller.signal,
+      background,
+    );
+    expect(
+      await backgroundRuntime(bonsai, member, controller.signal, background),
+    ).toBe(runtime);
+    const otherRuntime = await backgroundRuntime(bonsai, other);
+    const saved = await saveFileEdit(bonsai, member, input, runtime);
+    const otherSaved = await saveFileEdit(bonsai, other, input, otherRuntime);
+    expect(saved).toMatchObject({ kind: "saved", state: "pending" });
+    expect(otherSaved).toMatchObject({ kind: "saved", state: "pending" });
+    if (saved.kind !== "saved" || otherSaved.kind !== "saved")
+      throw new Error("Fixture rows not saved");
+    state.fileEdits.discard("member:owner", {
+      ...input,
+      revision: saved.revision,
+    });
+    expect(await runtime.tickConcurrent()).toMatchObject({
+      status: "settled",
+      job: { lane: "member:owner", outcome: "completed" },
+    });
+    expect(await runtime.tickConcurrent()).toEqual({ status: "no_ready" });
+    expect(state.fileEdits.pending("member:other", input)).toMatchObject({
+      revision: otherSaved.revision,
+      state: "pending",
+    });
+    expect(counted.total()).toBe(0);
+  } finally {
+    controller.abort();
+    database.close();
+    provider.close();
+  }
+});
+
+it("projects a retained missing-branch failure through the completed job receipt on an existing runner", async () => {
+  const database = new DatabaseSync(":memory:");
+  const owner = fromNodeSqlite(database);
+  ensureBonsaiTables(owner.sql);
+  const provider = realGit();
+  const state = new BonsaiState(owner.sql, owner.transactionSync);
+  const bonsai = {
+    state,
+    store: gitStore(provider.git),
+    events: { emit: () => Promise.resolve() },
+  };
+  const caller = backgroundContext(
+    { actor: { kind: "member", memberId: "owner" }, computerId: null },
+    [],
+    { name: "files.save", effect: "write" },
+    await sealBackgroundOrigin(
+      await backgroundOriginKey("background-runtime-test-key"),
+      { instanceId: "runner-test", lane: "member:owner", method: "files.save" },
+    ),
+  );
+  try {
+    const key = await backgroundOriginKey("background-runtime-test-key");
+    const background = {
+      admit: (origin: NonNullable<typeof caller.backgroundOrigin>) =>
+        admitClaimedOrigin(
+          key,
+          {
+            instanceId: "runner-test",
+            lane: "member:owner",
+            admitted: ["files.save"],
+          },
+          origin,
+        ),
+    };
+    const runtime = await backgroundRuntime(
+      bonsai,
+      caller,
+      new AbortController().signal,
+      background,
+    );
+    const transitions: WatchdogQueueTransition[] = [];
+    registerBackgroundProjector(bonsai, "file-edit", (transition) => {
+      projectQueuedFileEdit(bonsai, transition);
+      transitions.push(transition);
+    });
+    await provider.git.create("pond");
+    state.registerRepo({
+      name: "pond",
+      description: null,
+      parent: null,
+      owner: null,
+    });
+    await saveFileEdit(
+      bonsai,
+      caller,
+      {
+        repo: "pond",
+        branch: "removed",
+        path: "README.md",
+        text: "Retained\n",
+        baseCommit: "a".repeat(40),
+        baseBlob: null,
+        revision: null,
+      },
+      runtime,
+    );
+    expect(await runtime.tickConcurrent()).toMatchObject({
+      status: "settled",
+      job: { outcome: "completed" },
+    });
+    expect(
+      transitions.find(
+        (transition) => transition.settled?.outcome === "completed",
+      )?.settled,
+    ).toMatchObject({ outcome: "completed" });
+    expect(
+      state.fileEdits.pending("member:owner", {
+        repo: "pond",
+        branch: "removed",
+        path: "README.md",
+      }),
+    ).toMatchObject({
+      state: "failed",
+      failure: "branch_missing",
+      text: "Retained\n",
+    });
+  } finally {
+    database.close();
+    provider.close();
+  }
+});

package/test/browser/board.browser.mjs

@@ -0,0 +1,52 @@
+import assert from "node:assert/strict";
+import console from "node:console";
+import { chromium } from "playwright";
+const browser = await chromium.launch({ headless: true });
+try {
+  const page = await browser.newPage({
+    viewport: { width: 1440, height: 1000 },
+  });
+  await page.goto("http://127.0.0.1:5188/test/browser/visual.html?board");
+  const below = page.locator('[data-tile="below"]');
+  await below.waitFor();
+  const initial = await below.boundingBox();
+  await page.getByRole("button", { name: "Expand document" }).click();
+  await page.waitForFunction(
+    (y) =>
+      globalThis.document
+        .querySelector('[data-tile="below"]')
+        .getBoundingClientRect().y >
+      y + 300,
+    initial.y,
+  );
+  const document = await page.locator('[data-tile="document"]').boundingBox();
+  assert.ok(
+    (await below.boundingBox()).y >= document.y + document.height,
+    "measured content pushes later rows without overlap",
+  );
+  await page.getByRole("button", { name: "Expand document" }).click();
+  await page.waitForFunction(
+    (y) =>
+      Math.abs(
+        globalThis.document
+          .querySelector('[data-tile="below"]')
+          .getBoundingClientRect().y - y,
+      ) < 1,
+    initial.y,
+  );
+  await page.setViewportSize({ width: 390, height: 1000 });
+  await page.waitForFunction(
+    () =>
+      globalThis.document
+        .querySelector('[data-tile="facts"]')
+        .getBoundingClientRect().y <
+      globalThis.document
+        .querySelector('[data-tile="document"]')
+        .getBoundingClientRect().y,
+  );
+  console.log(
+    "PASS board: measured rows grow and shrink; no overlap; explicit phone priority",
+  );
+} finally {
+  await browser.close();
+}