@fungi.computer/bonsai 0.1.0 → 0.2.1

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

@@ -1,24 +1,34 @@
+import * as S from "effect/Schema";
+import { workflowDefinitionSchema } from "@fungi.computer/braid";
+import { repositoryWorkflowSourceSchema } from "@fungi.computer/workflows-wire";
+import { runReply, statusReply } from "@fungi.computer/workflows-wire";
+import type { BonsaiEnv } from "../backend/index.js";
+import type { GraphStartRequest } from "@fungi.computer/braid/runtime";
 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 { appBackend, type AppsBindingReply } 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 type { AppBuildInstallation } from "../shared/contract.js";
 import {
   appBackendBindingOperation,
   scopeOperationToMethod,
 } from "@fungi.computer/puffball/app";
 
 type Calls = {
+  register?: unknown;
   build?: unknown;
   buildStatus?: unknown;
   select?: unknown;
+  workflow?: GraphStartRequest;
+  workflowRuns?: { workflowId?: string };
 };
 
-/** apps.build/apps.buildStatus/apps.install never touch Git or Bonsai's own
+/** apps.register/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`. */
@@ -49,22 +59,29 @@ function bonsaiFixture(git: Partial<GitBinding> = {}): Bonsai {
   };
 }
 
-function fixture() {
+function fixture(
+  registrationReply?: AppsBindingReply,
+  buildReply?: AppsBindingReply,
+  installation?: AppBuildInstallation,
+  buildStatusReply?: AppsBindingReply,
+  selectReply?: AppsBindingReply,
+) {
   const calls: Calls = {};
   const build = {
     jobId: "build_test",
-    appId: "app_my-fork",
+    appId: "app_myfork",
     releaseId: "rel_test",
     sourceRevision: `git:${"a".repeat(40)}`,
     status: "running" as const,
     detail: null,
     release: null,
+    installation: null,
   };
   const release = {
-    appId: "app_my-fork",
+    appId: "app_myfork",
     releaseId: "rel_test",
     artifact: {
-      artifactRef: "artifact:root",
+      artifactRef: "artifact:sha256-" + "b".repeat(64),
       artifactDigest: `sha256:${"b".repeat(64)}`,
       provenance: {
         sourceRevision: build.sourceRevision,
@@ -73,29 +90,105 @@ function fixture() {
       },
     },
   };
-  const env = {
+  let workflowReply = runReply.parse({
+    kind: "started",
+    runId: "run_manual",
+    planDigest: "sha256:" + "d".repeat(64),
+  });
+  const env: Pick<BonsaiEnv, "APPS" | "WORKFLOWS"> = {
+    WORKFLOWS: {
+      runs: (input) => {
+        calls.workflowRuns = input;
+        return Promise.resolve({
+          runs: [
+            {
+              runId: "run_triggered",
+              workflowId: "bonsai-build-on-merge",
+              commit: "a".repeat(40),
+              source: "event" as const,
+              initiatedBy: { kind: "member" as const, memberId: "Levi" },
+              startedAt: 42,
+            },
+          ],
+        });
+      },
+      runGraph: (input) => {
+        calls.workflow = input;
+        return Promise.resolve(workflowReply);
+      },
+      graphStatus: () =>
+        Promise.resolve(
+          statusReply.parse({
+            runId: "run_manual",
+            planDigest: "sha256:" + "d".repeat(64),
+            outcome: "active",
+            title: "Build on merge",
+            status: "running",
+            events: [],
+            reviews: [],
+            output: null,
+            error: null,
+          }),
+        ),
+    },
     APPS: {
+      repository: () =>
+        Promise.resolve(
+          S.decodeUnknownSync(repositoryWorkflowSourceSchema)({
+            appId: "app_myfork",
+            installationId: "bonsai",
+            callerAppId: "app_bonsai",
+            callerSourceRevision: "git:" + "a".repeat(40),
+          }),
+        ),
+      register: (input: { repo: string }) => {
+        calls.register = input;
+        return Promise.resolve(
+          registrationReply ?? {
+            status: 200,
+            body: {
+              appId: "app_myfork",
+              sourceRevision: build.sourceRevision,
+            },
+          },
+        );
+      },
       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 });
+        return Promise.resolve(buildReply ?? { status: 202, body: build });
       },
-      buildStatus: (input: { jobId: string }) => {
+      buildStatus: (input: { jobId: string } | { repo: string }) => {
         calls.buildStatus = input;
-        return Promise.resolve({
-          status: 200,
-          body:
-            input.jobId === "build_running"
-              ? { ...build, jobId: input.jobId }
-              : { ...build, status: "succeeded" as const, release },
-        });
+        return Promise.resolve(
+          buildStatusReply ?? {
+            status: 200,
+            body:
+              "repo" in input && input.repo === "no-jobs"
+                ? null
+                : "jobId" in input && input.jobId === "build_running"
+                  ? { ...build, jobId: input.jobId }
+                  : {
+                      ...build,
+                      status: "succeeded" as const,
+                      release,
+                      installation: installation ?? null,
+                    },
+          },
+        );
       },
-      select: (input: { installationId: string; release: unknown }) => {
+      select: (input: {
+        jobId: string;
+        installationId: string;
+        release: unknown;
+      }) => {
         calls.select = input;
-        return Promise.resolve({
-          status: 200,
-          body: { installationId: input.installationId, status: "enabled" },
-        });
+        return Promise.resolve(
+          selectReply ?? {
+            status: 200,
+            body: { installationId: input.installationId, status: "enabled" },
+          },
+        );
       },
     },
   };
@@ -128,31 +221,251 @@ function fixture() {
         role: "member" as const,
       },
     );
-  return { owner, member, calls, build, release };
+  return {
+    owner,
+    member,
+    calls,
+    build,
+    release,
+    setWorkflowReply: (reply: ReturnType<typeof runReply.parse>) => {
+      workflowReply = reply;
+    },
+  };
 }
 
-describe("apps.build / apps.install", () => {
+describe("App authoring methods", () => {
+  it.each([
+    [409, "conflict", "Revision is not a seed of this App's template"],
+    [409, "conflict", "App has no build source"],
+    [400, "invalid", "Invalid source revision"],
+    [503, "unavailable", "Build is unavailable"],
+  ] as const)(
+    "preserves a build refusal (%s) through the App method",
+    async (status, code, message) => {
+      const f = fixture(undefined, { status, body: { error: message } });
+      await expect(
+        f.owner("apps.build", {
+          appId: "app_myfork",
+          sourceRevision: f.build.sourceRevision,
+        }),
+      ).rejects.toSatisfy(
+        (error) =>
+          error instanceof AppMethodRefusal &&
+          error.code === code &&
+          error.message === message,
+      );
+      expect(f.calls.select).toBeUndefined();
+    },
+  );
+
+  it("apps.register registers this repository through the host, not Bonsai's Files copy", async () => {
+    const f = fixture();
+    const result = await f.owner("apps.register", { repo: "my-fork" });
+    expect(result).toEqual({
+      appId: "app_myfork",
+      sourceRevision: "git:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+    });
+    expect(f.calls.register).toEqual({ repo: "my-fork" });
+    expect(f.calls.build).toBeUndefined();
+    expect(f.calls.select).toBeUndefined();
+  });
+
+  it("refuses registration for a non-owner before the host is called", async () => {
+    const f = fixture();
+    await expect(
+      f.member("apps.register", { repo: "my-fork" }),
+    ).rejects.toSatisfy(
+      (error) =>
+        error instanceof AppMethodRefusal && error.code === "forbidden",
+    );
+    expect(f.calls.register).toBeUndefined();
+  });
+
+  it.each([
+    { repo: "../other" },
+    { repo: "my-fork", recipe: {} },
+    { repo: "my-fork", installationId: "other-app" },
+  ])(
+    "refuses invalid or caller-chosen registration authority: %j",
+    async (input) => {
+      const f = fixture();
+      await expect(f.owner("apps.register", input)).rejects.toThrow();
+      expect(f.calls.register).toBeUndefined();
+    },
+  );
+
+  it.each([
+    [403, "forbidden"],
+    [404, "not_found"],
+    [409, "conflict"],
+    [400, "invalid"],
+    [503, "unavailable"],
+  ])("preserves the host's registration refusal (%s)", async (status, code) => {
+    const f = fixture({ status, body: { error: "Registration refused" } });
+    await expect(
+      f.owner("apps.register", { repo: "my-fork" }),
+    ).rejects.toSatisfy(
+      (error) =>
+        error instanceof AppMethodRefusal &&
+        error.code === code &&
+        error.message === "Registration refused",
+    );
+    expect(f.calls.build).toBeUndefined();
+    expect(f.calls.select).toBeUndefined();
+  });
+
+  it("the owner can discover automatic build Workflows without a browser run id or a second trigger ledger", async () => {
+    const f = fixture();
+    const reply = await f.owner("apps.buildWorkflowRuns", {});
+    expect(reply).toMatchObject({
+      runs: [{ runId: "run_triggered", source: "event" }],
+    });
+    expect(f.calls.workflowRuns).toEqual({
+      workflowId: "bonsai-build-on-merge",
+    });
+    expect(f.calls.workflow).toBeUndefined();
+    expect(f.calls.build).toBeUndefined();
+    expect(f.calls.select).toBeUndefined();
+    await expect(f.member("apps.buildWorkflowRuns", {})).rejects.toThrow(
+      "Owner only",
+    );
+  });
+
+  it("the owner action starts the retained build/verify/install Workflow with its edited target", async () => {
+    const f = fixture();
+    const input = {
+      repo: "my-fork",
+      sourceRevision: "git:" + "b".repeat(40),
+      installationId: "edited-target",
+      requestId: "manual-42",
+    };
+    expect(await f.owner("apps.startBuildWorkflow", input)).toMatchObject({
+      kind: "started",
+      runId: "run_manual",
+    });
+    expect(f.calls.workflow).toMatchObject({
+      requestId: "manual-42",
+      bindings: { bonsai: "bonsai" },
+      input: {
+        appId: "app_myfork",
+        sourceRevision: input.sourceRevision,
+        installationId: "edited-target",
+      },
+    });
+    const definition = S.decodeUnknownSync(workflowDefinitionSchema)(
+      f.calls.workflow?.definition,
+    );
+    expect(definition.nodes.map((node) => node.id)).toEqual([
+      "build",
+      "verify",
+      "install",
+    ]);
+    expect(f.calls.build).toBeUndefined();
+    expect(f.calls.select).toBeUndefined();
+  });
+  it("preserves a Workflow refusal instead of pretending the owner action started", async () => {
+    const f = fixture();
+    f.setWorkflowReply({ error: "not_granted" });
+    await expect(
+      f.owner("apps.startBuildWorkflow", {
+        repo: "my-fork",
+        sourceRevision: "git:" + "b".repeat(40),
+        installationId: "my-fork",
+        requestId: "manual-denied",
+      }),
+    ).rejects.toThrow("not_granted");
+    expect(f.calls.select).toBeUndefined();
+  });
+
   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",
+      appId: "app_myfork",
       sourceRevision: `git:${"a".repeat(40)}`,
     });
     expect(result).toMatchObject({ jobId: "build_test", status: "running" });
     expect(f.calls.build).toEqual({
-      appId: "app_my-fork",
+      appId: "app_myfork",
       sourceRevision: `git:${"a".repeat(40)}`,
     });
   });
 
+  it("apps.verifyBuild waits for a running build and returns only the matching succeeded Release", async () => {
+    const f = fixture();
+    expect(
+      await f.owner("apps.verifyBuild", {
+        jobId: "build_running",
+        sourceRevision: f.build.sourceRevision,
+      }),
+    ).toEqual({ kind: "pending", retryAfterMs: 5000 });
+    const verified = await f.owner("apps.verifyBuild", {
+      jobId: f.build.jobId,
+      sourceRevision: f.build.sourceRevision,
+    });
+    expect(verified).toMatchObject({ release: f.release });
+    expect(f.calls.select).toBeUndefined();
+    await expect(
+      f.owner("apps.verifyBuild", {
+        jobId: f.build.jobId,
+        sourceRevision: "git:" + "e".repeat(40),
+      }),
+    ).rejects.toThrow("not the requested commit");
+  });
+
+  it("apps.verifyBuild refuses a failed or missing build without installing", async () => {
+    const source = fixture();
+    const failed = fixture(undefined, undefined, undefined, {
+      status: 200,
+      body: {
+        ...source.build,
+        status: "failed",
+        detail: "Compiler refused the source",
+      },
+    });
+    await expect(
+      failed.owner("apps.verifyBuild", {
+        jobId: source.build.jobId,
+        sourceRevision: source.build.sourceRevision,
+      }),
+    ).rejects.toThrow("Compiler refused the source");
+    expect(failed.calls.select).toBeUndefined();
+    const missing = fixture(undefined, undefined, undefined, {
+      status: 200,
+      body: null,
+    });
+    await expect(
+      missing.owner("apps.verifyBuild", {
+        jobId: source.build.jobId,
+        sourceRevision: source.build.sourceRevision,
+      }),
+    ).rejects.toThrow("Build not found");
+    expect(missing.calls.select).toBeUndefined();
+  });
+
+  it("apps.install remains Pending while another Workflow installation is in flight", async () => {
+    const f = fixture(undefined, undefined, undefined, undefined, {
+      status: 202,
+      body: { pending: true },
+    });
+    expect(
+      await f.owner("apps.install", {
+        jobId: "build_test",
+        installationId: "my-fork",
+        release: f.release,
+      }),
+    ).toEqual({ kind: "pending", retryAfterMs: 5000 });
+  });
+
   it("apps.install switches the Release through the APPS binding", async () => {
     const f = fixture();
     const result = await f.owner("apps.install", {
+      jobId: "build_test",
       installationId: "my-fork",
       release: f.release,
     });
     expect(result).toEqual({ installationId: "my-fork", status: "enabled" });
     expect(f.calls.select).toEqual({
+      jobId: "build_test",
       installationId: "my-fork",
       release: f.release,
     });
@@ -165,6 +478,29 @@ describe("apps.build / apps.install", () => {
     expect(f.calls.buildStatus).toEqual({ jobId: "build_test" });
   });
 
+  it("apps.buildStatus discovers a repository's automatic consent outcome without a browser job id", async () => {
+    const f = fixture(undefined, undefined, {
+      kind: "needs_consent",
+      installationId: "my-fork",
+    });
+    expect(
+      await f.owner("apps.buildStatus", { repo: "my-fork" }),
+    ).toMatchObject({
+      jobId: "build_test",
+      status: "succeeded",
+      installation: { kind: "needs_consent", installationId: "my-fork" },
+    });
+    expect(f.calls.buildStatus).toEqual({ repo: "my-fork" });
+    expect(f.calls.select).toBeUndefined();
+  });
+
+  it("apps.buildStatus reports no job as null rather than an invented build or failure", async () => {
+    const f = fixture();
+    expect(await f.owner("apps.buildStatus", { repo: "no-jobs" })).toBeNull();
+    expect(f.calls.buildStatus).toEqual({ repo: "no-jobs" });
+    expect(f.calls.select).toBeUndefined();
+  });
+
   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);
@@ -174,6 +510,28 @@ describe("apps.build / apps.install", () => {
     expect(result).toMatchObject({ kind: "pending" });
   });
 
+  it.each(["installed", "needs_consent"] as const)(
+    "apps.buildStatus preserves the typed %s outcome for Settings",
+    async (kind) => {
+      const installation = { kind, installationId: "my-fork" };
+      const f = fixture(undefined, undefined, installation);
+      expect(
+        await f.owner("apps.buildStatus", { jobId: "build_test" }),
+      ).toMatchObject({ status: "succeeded", installation });
+      expect(f.calls.select).toBeUndefined();
+    },
+  );
+
+  it("apps.buildStatus stays Pending until automatic installation has an outcome", async () => {
+    const f = fixture(undefined, undefined, {
+      kind: "pending",
+      installationId: "my-fork",
+    });
+    expect(
+      await f.owner("apps.buildStatus", { jobId: "build_test" }),
+    ).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"],
@@ -193,11 +551,23 @@ describe("apps.build / apps.install", () => {
     }
   });
 
+  it("admits registration through the host's APPS operation without Computer access", () => {
+    const declared = appBackendBindingOperation("APPS", "register");
+    const policy = appBackend.methods["apps.register"]?.policy;
+    expect(declared).toMatchObject({
+      requires: ["git.repository"],
+      effect: "write",
+    });
+    expect(policy).toBeDefined();
+    if (declared === undefined || policy === undefined) return;
+    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",
+        appId: "app_myfork",
         sourceRevision: `git:${"a".repeat(40)}`,
       }),
     ).rejects.toSatisfy(
@@ -211,6 +581,7 @@ describe("apps.build / apps.install", () => {
     const f = fixture();
     await expect(
       f.member("apps.install", {
+        jobId: "build_test",
         installationId: "my-fork",
         release: f.release,
       }),
@@ -240,6 +611,8 @@ describe("apps.fork", () => {
     const refused = () => Promise.reject(new Error("Not part of a fork"));
     const env = {
       APPS: {
+        repository: refused,
+        register: refused,
         fork: (input: { platformAppId: string; name: string }) => {
           forks.push(input);
           return Promise.resolve({

package/test/browser/build-workflow.browser.mjs

@@ -0,0 +1,104 @@
+import {
+  repositoryBrowserFixture,
+  repositoryBrowserPage,
+  startManualBuildWorkflow,
+  assertNoDirectInstall,
+} from "./repository-browser.fixture.mjs";
+import assert from "node:assert/strict";
+import console from "node:console";
+import { fileURLToPath, URL } from "node:url";
+
+// Real Settings/button and Trellis cards, controlled App-method wire replies.
+// This UI law does not claim a real host, Computer or installed Release.
+const output = new URL(
+  "../../../../.botanical/honest-errors/manual-workflow-shots/",
+  import.meta.url,
+);
+const fixture = await repositoryBrowserFixture(output);
+const { browser, origin } = fixture;
+try {
+  for (const width of [1440, 390])
+    for (const theme of ["light", "dark"])
+      for (const refused of [false, true]) {
+        const { page, errors } = await repositoryBrowserPage(
+          browser,
+          width,
+          theme,
+        );
+        await page.goto(
+          origin +
+            "test/browser/repository-settings.html?scenario=" +
+            (refused ? "manual-workflow-refused" : "manual-workflow"),
+        );
+        await page.getByRole("link", { name: "Settings", exact: true }).click();
+        await page
+          .getByRole("button", { name: "Make this an App", exact: true })
+          .click();
+        await startManualBuildWorkflow(
+          page,
+          "git:" + "b".repeat(40),
+          "edited-installation",
+        );
+        await page
+          .getByText("Workflow run run_settings", { exact: true })
+          .waitFor();
+        if (refused) {
+          await page
+            .getByRole("alert")
+            .filter({
+              hasText: "No hosted build backend is attached to this Computer",
+            })
+            .waitFor();
+          assert.equal(
+            await page.getByText("Release installed", { exact: true }).count(),
+            0,
+          );
+          assert.equal(
+            await page.getByText("Release verified", { exact: true }).count(),
+            0,
+          );
+        } else {
+          await page.getByText("Build running", { exact: true }).waitFor();
+          await page.getByText("Release verified", { exact: true }).waitFor();
+          await page.getByText("Release installed", { exact: true }).waitFor();
+          assert.equal(
+            await page.locator(".wf-step").count(),
+            3,
+            "the retained Trellis step cards render the actual step rows",
+          );
+        }
+        const calls = JSON.parse(
+          await page.locator("#app-calls").textContent(),
+        );
+        assert.equal(
+          calls.filter((name) => name === "apps.startBuildWorkflow").length,
+          1,
+        );
+        assert.ok(calls.includes("apps.buildWorkflowRun"));
+        assert.ok(
+          !calls.includes("apps.build"),
+          "the button must start the Workflow, not a separate native build",
+        );
+        assert.ok(
+          !calls.includes("apps.install"),
+          "the panel must never select a Release as an App",
+        );
+        await assertNoDirectInstall(page);
+        assert.deepEqual(errors, []);
+        await page.screenshot({
+          path: fileURLToPath(
+            new URL(
+              width + "-" + theme + (refused ? "-refused" : "") + ".png",
+              output,
+            ),
+          ),
+          fullPage: true,
+        });
+        await page.close();
+      }
+  console.log(
+    "PASS manual Build & install starts one Workflow, renders Trellis cards and preserves refusal reasons in four views",
+  );
+} finally {
+  await fixture.close();
+}