@fungi.computer/bonsai 0.1.0 → 0.2.1

package/test/browser/repository-browser.fixture.mjs

@@ -0,0 +1,84 @@
+import assert from "node:assert/strict";
+import { mkdir } from "node:fs/promises";
+import { createServer } from "vite";
+import { chromium } from "playwright";
+import viteConfig from "./vite.config.mjs";
+
+/** Serve the real Settings view and its controlled App-method transport. */
+export async function repositoryBrowserFixture(output) {
+  await mkdir(output, { recursive: true });
+  const server = await createServer({
+    ...viteConfig,
+    configFile: false,
+    server: { ...viteConfig.server, port: 0 },
+  });
+  await server.listen();
+  try {
+    const browser = await chromium.launch({ headless: true });
+    return {
+      browser,
+      origin: server.resolvedUrls.local[0],
+      async close() {
+        try {
+          await browser.close();
+        } finally {
+          await server.close();
+        }
+      },
+    };
+  } catch (cause) {
+    await server.close();
+    throw cause;
+  }
+}
+
+export async function repositoryBrowserPage(browser, width, theme) {
+  const page = await browser.newPage({
+    viewport: { width, height: 1000 },
+    colorScheme: theme,
+  });
+  page.setDefaultTimeout(10000);
+  const errors = [];
+  page.on("pageerror", (cause) => errors.push(cause.message));
+  return { page, errors };
+}
+
+/** Expected identity stays with each scenario; inspect the same visible fields. */
+export async function assertAuthoringFields(page, expected) {
+  for (const [name, value] of [
+    ["App id", expected.appId],
+    ["Source revision", expected.sourceRevision],
+    ["Install at", expected.installationId],
+  ]) {
+    assert.equal(
+      await page.getByRole("textbox", { name, exact: true }).inputValue(),
+      value,
+    );
+  }
+}
+
+export async function startManualBuildWorkflow(
+  page,
+  sourceRevision,
+  installationId,
+) {
+  await page
+    .getByRole("textbox", { name: "Source revision", exact: true })
+    .fill(sourceRevision);
+  await page
+    .getByRole("textbox", { name: "Install at", exact: true })
+    .fill(installationId);
+  await page
+    .getByRole("button", { name: "Build & install", exact: true })
+    .click();
+}
+
+export async function assertNoDirectInstall(page) {
+  assert.equal(
+    await page
+      .getByRole("button", { name: "Install this Release", exact: true })
+      .count(),
+    0,
+    "Only the Workflow may install; no direct install action remains",
+  );
+}

package/test/browser/repository-settings-fixture.tsx

@@ -2,10 +2,10 @@
 import { useEffect, useRef } from "react";
 import { createRoot } from "react-dom/client";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
-import { createCapabilityRegistry } from "@fungi.computer/agar";
+import { createCapabilityRegistry, pending } from "@fungi.computer/agar";
 import { appMethods } from "@fungi.computer/agar/backend";
 import * as z from "zod";
-import { repoDetail } from "../../shared/contract.js";
+import { appBuildStatusInput, repoDetail } from "../../shared/contract.js";
 import { connect } from "../../web/transport.js";
 import { RouterProvider, useRouter } from "../../web/router.js";
 import { RepoPage } from "../../web/pages.js";
@@ -39,10 +39,203 @@ client.setQueryData(["events", name], { events: [] });
 client.setQueryData(["changes", name], { changes: [] });
 client.setQueryData(["agents"], { agents: [] });
 let attempts = 0;
+let registrations = 0;
 let withdrawn = false;
+const appCalls: string[] = [];
+const build = {
+  jobId: "build_settings",
+  appId: "app_settingstest",
+  releaseId: "rel_settings",
+  sourceRevision: "git:" + "a".repeat(40),
+  status: "running",
+  detail: null,
+  release: null,
+  installation: { kind: "pending", installationId: name },
+};
 const capabilities = createCapabilityRegistry();
 capabilities.provide(appMethods, {
   call: (method, inputJson) => {
+    if (method.startsWith("apps.")) {
+      appCalls.push(method);
+      const counter = document.getElementById("app-calls");
+      if (counter) counter.textContent = JSON.stringify(appCalls);
+    }
+    if (method === "apps.register") {
+      z.strictObject({ repo: z.literal(name) }).parse(JSON.parse(inputJson));
+      registrations += 1;
+      const scenario = new URLSearchParams(location.search).get("scenario");
+      if (scenario === "registration-refused")
+        return Promise.resolve({ error: "Owner only" });
+      if (scenario === "registration-invalid")
+        return Promise.resolve({
+          error: "Repository main must declare a valid fungi.build recipe",
+        });
+      if (scenario === "registration-unavailable" && registrations === 1)
+        return Promise.resolve({ error: "App registration is unavailable" });
+      return Promise.resolve({
+        appId: "app_settingstest",
+        sourceRevision: "git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      });
+    }
+    if (method === "apps.startBuildWorkflow") {
+      z.strictObject({
+        repo: z.literal(name),
+        sourceRevision: z.literal("git:" + "b".repeat(40)),
+        installationId: z.literal("edited-installation"),
+        requestId: z.string().min(1).max(256),
+      }).parse(JSON.parse(inputJson));
+      return Promise.resolve({
+        kind: "started",
+        runId: "run_settings",
+        planDigest: "sha256:" + "d".repeat(64),
+      });
+    }
+    if (method === "apps.buildWorkflowRun") {
+      z.strictObject({ runId: z.literal("run_settings") }).parse(
+        JSON.parse(inputJson),
+      );
+      if (
+        new URLSearchParams(location.search).get("scenario") ===
+        "manual-workflow-refused"
+      )
+        return Promise.resolve({
+          runId: "run_settings",
+          planDigest: "sha256:" + "d".repeat(64),
+          outcome: "terminal",
+          title: "Build on merge",
+          status: "errored",
+          output: null,
+          error: {
+            name: "Error",
+            message:
+              "App method refused (unavailable): No hosted build backend is attached to this Computer",
+          },
+          reviews: [],
+          events: [
+            {
+              nodeId: "build",
+              iteration: "0",
+              poll: 0,
+              state: "failed",
+              attempt: 1,
+              refusal: "dispatch_failed",
+            },
+          ],
+        });
+      const release = {
+        appId: "app_settingstest",
+        releaseId: "rel_settings",
+        artifact: {
+          artifactRef: "artifact:sha256-" + "b".repeat(64),
+          artifactDigest: "sha256:" + "b".repeat(64),
+          provenance: {
+            sourceRevision: "git:" + "b".repeat(40),
+            sourceTreeDigest: "sha256:" + "c".repeat(64),
+            buildRecipeDigest: "sha256:" + "d".repeat(64),
+          },
+        },
+      };
+      return Promise.resolve({
+        runId: "run_settings",
+        planDigest: "sha256:" + "d".repeat(64),
+        outcome: "terminal",
+        title: "Build on merge",
+        status: "complete",
+        output: {
+          installation: {
+            installationId: "edited-installation",
+            status: "enabled",
+          },
+        },
+        error: null,
+        reviews: [],
+        events: [
+          {
+            nodeId: "build",
+            iteration: "0",
+            state: "complete",
+            attempt: 0,
+            output: {
+              ...build,
+              sourceRevision: "git:" + "b".repeat(40),
+              installation: {
+                kind: "pending",
+                installationId: "edited-installation",
+              },
+            },
+            row: {
+              id: "build_settings",
+              title: "Build running",
+              detail: "git:" + "b".repeat(40),
+            },
+          },
+          {
+            nodeId: "verify",
+            iteration: "0",
+            state: "complete",
+            attempt: 0,
+            output: {
+              release,
+              summary:
+                "Built rel_settings of app_settingstest from git:" +
+                "b".repeat(40),
+            },
+            row: {
+              id: "rel_settings",
+              title: "Release verified",
+              detail: "Exact source verified",
+            },
+          },
+          {
+            nodeId: "install",
+            iteration: "0",
+            state: "complete",
+            attempt: 0,
+            output: {
+              installationId: "edited-installation",
+              status: "enabled",
+            },
+            row: {
+              id: "apps.install",
+              title: "Release installed",
+              detail: "edited-installation",
+            },
+          },
+        ],
+      });
+    }
+    if (method === "apps.buildStatus") {
+      const input = appBuildStatusInput.parse(JSON.parse(inputJson));
+      if (
+        new URLSearchParams(location.search).get("scenario") ===
+        "automatic-pending"
+      )
+        return Promise.resolve(pending(5000));
+      if (
+        "repo" in input &&
+        new URLSearchParams(location.search).get("scenario") !==
+          "automatic-needs-consent"
+      )
+        return Promise.resolve(null);
+      return Promise.resolve({
+        ...build,
+        status: "succeeded",
+        installation: { kind: "needs_consent", installationId: name },
+        release: {
+          appId: build.appId,
+          releaseId: build.releaseId,
+          artifact: {
+            artifactRef: "artifact:sha256-" + "b".repeat(64),
+            artifactDigest: "sha256:" + "b".repeat(64),
+            provenance: {
+              sourceRevision: build.sourceRevision,
+              sourceTreeDigest: "sha256:" + "c".repeat(64),
+              buildRecipeDigest: "sha256:" + "d".repeat(64),
+            },
+          },
+        },
+      });
+    }
     if (method === "repos.delete") {
       z.strictObject({ repo: z.literal(name) }).parse(JSON.parse(inputJson));
       attempts += 1;
@@ -91,6 +284,9 @@ function Shell() {
           <h1>Repositories</h1>
         )}
       </main>
+      <output id="app-calls" hidden>
+        {JSON.stringify([])}
+      </output>
       <output id="attempts" hidden>
         0
       </output>

package/test/browser/repository-settings.browser.mjs

@@ -1,39 +1,93 @@
+import {
+  repositoryBrowserFixture,
+  repositoryBrowserPage,
+  startManualBuildWorkflow,
+  assertNoDirectInstall,
+  assertAuthoringFields,
+} from "./repository-browser.fixture.mjs";
 import assert from "node:assert/strict";
 import console from "node:console";
 import process from "node:process";
-import { mkdir } from "node:fs/promises";
 import { fileURLToPath, URL } from "node:url";
-import { createServer } from "vite";
-import { chromium } from "playwright";
-import viteConfig from "./vite.config.mjs";
 
 const output = new URL(
   "../../../../.botanical/repos-delete/shots/",
   import.meta.url,
 );
-await mkdir(output, { recursive: true });
-const server = await createServer({
-  ...viteConfig,
-  configFile: false,
-  server: { ...viteConfig.server, port: 0 },
-});
-await server.listen();
-const origin = server.resolvedUrls.local[0];
-let browser;
+const fixture = await repositoryBrowserFixture(output);
+const { browser, origin } = fixture;
 const name = "disposable-merge-1791840651624";
 const before = process.argv.includes("--before");
+const appWrites = async (page) =>
+  JSON.parse(await page.locator("#app-calls").textContent()).filter(
+    (method) =>
+      method !== "apps.buildStatus" && method !== "apps.buildWorkflowRun",
+  );
 try {
-  browser = await chromium.launch({ headless: true });
   for (const width of [1440, 390])
     for (const theme of ["light", "dark"]) {
-      const page = await browser.newPage({
-        viewport: { width, height: 1000 },
-        colorScheme: theme,
-      });
-      page.setDefaultTimeout(10000);
-      const errors = [];
-      page.on("pageerror", (cause) => errors.push(cause.message));
-      await page.goto(`${origin}test/browser/repository-settings.html`);
+      const { page, errors } = await repositoryBrowserPage(
+        browser,
+        width,
+        theme,
+      );
+      if (!before) {
+        await page.goto(
+          origin +
+            "test/browser/repository-settings.html?scenario=automatic-needs-consent",
+        );
+        for (let visit = 0; visit < 2; visit++) {
+          if (visit > 0) await page.reload();
+          await page
+            .getByRole("link", { name: "Settings", exact: true })
+            .click();
+          await page
+            .getByRole("status")
+            .filter({ hasText: "Needs owner consent" })
+            .waitFor();
+          await assertAuthoringFields(page, {
+            appId: "app_settingstest",
+            sourceRevision: "git:" + "a".repeat(40),
+            installationId: name,
+          });
+          await assertNoDirectInstall(page);
+          assert.equal(
+            await page
+              .getByRole("button", { name: "Build & install", exact: true })
+              .isEnabled(),
+            true,
+          );
+          assert.deepEqual(
+            await appWrites(page),
+            [],
+            "Status discovery and reload must not register, build or install",
+          );
+        }
+        await page.screenshot({
+          path: fileURLToPath(
+            new URL(width + "-" + theme + "-automatic-reload.png", output),
+          ),
+          fullPage: true,
+        });
+      }
+      if (!before) {
+        await page.goto(
+          origin +
+            "test/browser/repository-settings.html?scenario=automatic-pending",
+        );
+        await page.getByRole("link", { name: "Settings", exact: true }).click();
+        await page
+          .getByRole("status")
+          .filter({
+            hasText: "Build or automatic installation is still running",
+          })
+          .waitFor();
+        assert.deepEqual(await appWrites(page), []);
+      }
+      await page.goto(
+        origin +
+          "test/browser/repository-settings.html?scenario=manual-workflow-refused",
+      );
       await page.evaluate(
         (value) =>
           globalThis.document.documentElement.setAttribute("data-theme", value),
@@ -56,10 +110,65 @@ try {
       await page
         .getByRole("heading", { name: "Repository settings", exact: true })
         .waitFor();
+      await page
+        .getByRole("button", { name: "Make this an App", exact: true })
+        .click();
+      await page
+        .locator('#app-build-app-id[value="app_settingstest"]')
+        .waitFor();
+      await assertAuthoringFields(page, {
+        appId: "app_settingstest",
+        sourceRevision: "git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+        installationId: name,
+      });
+      await page
+        .getByRole("button", { name: "Build & install", exact: true })
+        .and(page.locator(":enabled"))
+        .waitFor();
+      assert.equal(
+        await page
+          .getByRole("button", { name: "Build & install", exact: true })
+          .isEnabled(),
+        true,
+      );
+      await assertNoDirectInstall(page);
+      assert.deepEqual(await appWrites(page), ["apps.register"]);
       assert.equal(await page.locator("#attempts").textContent(), "0");
       await page.screenshot({
         path: fileURLToPath(new URL(`${width}-${theme}-settings.png`, output)),
       });
+      assert.equal(
+        await page
+          .getByRole("textbox", { name: "App id", exact: true })
+          .isEditable(),
+        false,
+      );
+      await startManualBuildWorkflow(
+        page,
+        "git:" + "b".repeat(40),
+        "edited-installation",
+      );
+      await page
+        .getByRole("alert")
+        .filter({
+          hasText: "No hosted build backend is attached to this Computer",
+        })
+        .waitFor();
+      await assertAuthoringFields(page, {
+        appId: "app_settingstest",
+        sourceRevision: "git:" + "b".repeat(40),
+        installationId: "edited-installation",
+      });
+      assert.deepEqual(await appWrites(page), [
+        "apps.register",
+        "apps.startBuildWorkflow",
+      ]);
+      await assertNoDirectInstall(page);
+      await page.screenshot({
+        path: fileURLToPath(
+          new URL(`${width}-${theme}-build-refusal.png`, output),
+        ),
+      });
       await page
         .getByRole("button", { name: "Delete repository", exact: true })
         .click();
@@ -88,7 +197,16 @@ try {
           hasText: "Deletion didn't finish because storage was unavailable.",
         })
         .waitFor();
-      assert.equal(await page.getByRole("alert").locator("p").count(), 1);
+      assert.equal(
+        await page
+          .getByRole("alert")
+          .filter({
+            hasText: "Deletion didn't finish because storage was unavailable.",
+          })
+          .locator("p")
+          .count(),
+        1,
+      );
       assert.equal(await page.locator("#attempts").textContent(), "1");
       await page.screenshot({
         path: fileURLToPath(new URL(`${width}-${theme}-retry.png`, output)),
@@ -111,6 +229,51 @@ try {
         .getByRole("alert")
         .filter({ hasText: "Only the owner" })
         .waitFor();
+      for (const [scenario, message] of [
+        ["registration-refused", "Owner only"],
+        [
+          "registration-invalid",
+          "Repository main must declare a valid fungi.build recipe",
+        ],
+        ["registration-unavailable", "App registration is unavailable"],
+      ]) {
+        await page.goto(
+          origin + "test/browser/repository-settings.html?scenario=" + scenario,
+        );
+        await page.getByRole("link", { name: "Settings", exact: true }).click();
+        await page
+          .getByRole("button", { name: "Make this an App", exact: true })
+          .click();
+        await page.getByRole("alert").filter({ hasText: message }).waitFor();
+
+        await assertAuthoringFields(page, {
+          appId: "",
+          sourceRevision: "",
+          installationId: name,
+        });
+        assert.equal(
+          await page
+            .getByRole("button", { name: "Build & install", exact: true })
+            .isDisabled(),
+          true,
+        );
+        await assertNoDirectInstall(page);
+        assert.deepEqual(await appWrites(page), ["apps.register"]);
+        await page.screenshot({
+          path: fileURLToPath(
+            new URL([width, theme, scenario].join("-") + ".png", output),
+          ),
+        });
+        if (scenario === "registration-unavailable") {
+          await page
+            .getByRole("button", { name: "Make this an App", exact: true })
+            .click();
+          await page
+            .locator('#app-build-app-id[value="app_settingstest"]')
+            .waitFor();
+          assert.equal(await page.getByRole("alert").count(), 0);
+        }
+      }
       assert.deepEqual(errors, []);
       assert.equal(
         await page.evaluate(
@@ -126,11 +289,10 @@ try {
   console.log(
     before
       ? "PASS baseline 1440/390 light/dark: repository view before Settings"
-      : "PASS Settings 1440/390 light/dark: launcher entry, explicit confirmation, cancel, owner refusal, failed provider retry and home navigation",
+      : "PASS Settings 1440/390 light/dark: App registration/prefill, readonly identity, editable head/name and honest build refusal; typed needs-consent status without installing; denied/invalid/unavailable registration and retry; deletion confirmation/cancel/refusal/provider retry/navigation",
   );
 } finally {
-  await browser?.close();
-  await server.close();
+  await fixture.close();
   console.log("CLOSED browser and Vite server");
 }
 process.exitCode = 0;

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

@@ -198,14 +198,11 @@ test("runs tests on the pinned Change head even after the source branch moves",
       .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,
-          },
+          exitCode: execution.status,
+          stdout: execution.stdout,
+          stderr: execution.stderr,
+          stdoutTruncated: false,
+          stderrTruncated: false,
         }),
       );
     assert.equal(result.status, expected);
@@ -224,11 +221,16 @@ test("runs tests on the pinned Change head even after the source branch moves",
   );
   for (const refusal of [
     { error: "not_granted" },
-    { status: "running", output: null },
+    { error: "output_unavailable" },
+    { error: "attachment_budget_exceeded", kind: "exec", retryAfterMs: 1500 },
   ]) {
     const result = z
-      .object({ status: z.string() })
+      .object({
+        status: z.enum(["passed", "failed"]),
+        summary: z.string(),
+      })
       .parse(await evaluate(resultNode.source, refusal));
     assert.equal(result.status, "failed");
+    assert.equal(result.summary, refusal.error);
   }
 });

package/test/favicon.test.mjs

@@ -0,0 +1,25 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { URL, fileURLToPath } from "node:url";
+import { test } from "node:test";
+import { build } from "vite";
+import { fungiFaviconHref } from "@fungi.computer/sigils/favicon";
+
+test("the built Bonsai page carries the Fungi sigil as its tab icon", async (t) => {
+  const directory = await mkdtemp(join(tmpdir(), "bonsai-favicon-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  await build({
+    configFile: fileURLToPath(new URL("../vite.config.ts", import.meta.url)),
+    build: { outDir: directory, emptyOutDir: true },
+    logLevel: "silent",
+  });
+  const html = await readFile(join(directory, "index.html"), "utf8");
+  assert.ok(
+    html.includes(
+      `<link rel="icon" type="image/svg+xml" href="${fungiFaviconHref}">`,
+    ),
+  );
+  assert.doesNotMatch(html, /href="[^"]*favicon\.svg"/u);
+});

package/test/git-push.native.mjs

@@ -404,6 +404,36 @@ try {
     0,
     "accepted native retry publishes refs and all warm views",
   );
+  // The actual App lifecycle method, not a helper invocation or an App event
+  // invented by a guest, must hand the accepted main head to Workflows.
+  const workflowSeed = await globalThis.fetch(origin + "/seed?probe=workflow");
+  assert.equal(workflowSeed.status, 204, await workflowSeed.text());
+  const workflowPush = await globalThis.fetch(origin + "/?probe=workflow", {
+    method: "POST",
+    body: JSON.stringify({
+      ...fact,
+      repository: "pond",
+      eventId: "registered-main-push",
+      writer: { kind: "actor", actor: { kind: "member", memberId: "levi" } },
+    }),
+  });
+  assert.equal(workflowPush.status, 200, await workflowPush.text());
+  const workflowStarts = await globalThis
+    .fetch(origin + "/workflow-starts?probe=workflow")
+    .then((response) => response.json());
+  assert.equal(
+    workflowStarts.length,
+    1,
+    "accepted main must start the build Workflow, not native installation",
+  );
+  assert.equal(workflowStarts[0].definition.title, "Build on merge");
+  const steps = workflowStarts[0].definition.nodes.map((node) => node.id);
+  assert.ok(steps.indexOf("build") >= 0);
+  assert.ok(steps.indexOf("verify") > steps.indexOf("build"));
+  assert.ok(steps.indexOf("install") > steps.indexOf("verify"));
+  assert.equal(workflowStarts[0].input.sourceRevision, "git:" + "b".repeat(40));
+  assert.equal(workflowStarts[0].input.appId, "app_pond");
+  assert.equal(workflowStarts[0].bindings.bonsai, "bonsai");
   log(
     "PASS: Bonsai warm read-copy Git calls=0, T2 pending/exhaustion/foreground pages PASS, native push events, parsed Git insights, caller-isolated layouts persisted across restart",
   );