@fungi.computer/bonsai 0.0.1 → 0.2.0

package/shared/contract.ts

@@ -12,6 +12,15 @@ import { commit } from "@fungi.computer/agar/roles/files";
 
 export const productName = "Bonsai";
 
+/** An explicit owner action starts the same published build/install Workflow. */
+export const appBuildWorkflowInput = z.strictObject({
+  repo: repoName,
+  sourceRevision: z.string().min(1).max(256),
+  installationId: z.string().min(1).max(256),
+  requestId: z.string().min(1).max(256),
+});
+export type AppBuildWorkflowInput = z.infer<typeof appBuildWorkflowInput>;
+
 /** Any JSON value: App method inputs and results travel as JSON. */
 export const jsonValue = z.json();
 export type JsonValue = z.infer<typeof jsonValue>;
@@ -389,6 +398,22 @@ export const issueFiles = z.strictObject({
 export type IssueFiles = z.infer<typeof issueFiles>;
 export const repoPage = z.strictObject({ repos: z.array(repoSummary) });
 
+/** The host's install decision on this build, not a consent request. */
+const appBuildInstallation = z.discriminatedUnion("kind", [
+  z.strictObject({ kind: z.literal("pending"), installationId: z.string() }),
+  z.strictObject({ kind: z.literal("installed"), installationId: z.string() }),
+  z.strictObject({
+    kind: z.literal("needs_consent"),
+    installationId: z.string(),
+  }),
+  z.strictObject({
+    kind: z.literal("failed"),
+    installationId: z.string(),
+    detail: z.string(),
+  }),
+]);
+export type AppBuildInstallation = z.infer<typeof appBuildInstallation>;
+
 /** One App build job as its owner sees it; a settled success carries its Release. */
 export const appBuildView = z.strictObject({
   jobId: z.string().min(1).max(256),
@@ -399,6 +424,22 @@ export const appBuildView = z.strictObject({
   detail: z.string().max(65_536).nullable(),
   /** The recorded Release, parsed by its owner where it is installed. */
   release: z.unknown(),
+  installation: appBuildInstallation.nullable(),
+});
+
+/** Register the calling installation's repository, never a caller-supplied recipe. */
+export const appRegistrationInput = z.strictObject({ repo: repoName });
+
+/** Workflows wait for one job; Settings discovers its repository's latest job. */
+export const appBuildStatusInput = z.union([
+  z.strictObject({ jobId: z.string().min(1).max(256) }),
+  appRegistrationInput,
+]);
+
+/** The host's App identity and exact main commit whose metadata it registered. */
+export const appRegistration = appBuildView.pick({
+  appId: true,
+  sourceRevision: true,
 });
 
 export const errorBody = z.strictObject({ error: z.string() });

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({