@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/workflow-store.test.ts

@@ -0,0 +1,115 @@
+import { DatabaseSync } from "node:sqlite";
+import { expect, it } from "vitest";
+import { fromNodeSqlite } from "@fungi.computer/watchdog/node-sqlite";
+import {
+  createGraphWorkflowRuns,
+  createWorkflowCeilingCapture,
+} from "@fungi.computer/braid/runtime";
+
+it("refuses execution facts for an unknown run", () => {
+  const database = new DatabaseSync(":memory:");
+  try {
+    const store = createGraphWorkflowRuns(fromNodeSqlite(database));
+    expect(() => {
+      store.recordEvent({
+        runId: "missing",
+        nodeId: "node",
+        iteration: "0",
+        state: "running",
+        attempt: 0,
+      });
+    }).toThrow("not active");
+    expect(() => store.events("missing")).toThrow("Unknown graph run");
+  } finally {
+    database.close();
+  }
+});
+
+it("retains distinct Pending polls across reopen and excludes cancelled-run facts", async () => {
+  const { compile } = await import("@fungi.computer/braid");
+  const result = await compile(
+    {
+      format: "fungi.workflow/v1",
+      title: "Store law",
+      apps: {},
+      input: { type: "object", properties: {}, additionalProperties: false },
+      nodes: [
+        {
+          id: "done",
+          kind: "transform",
+          fields: { value: { literal: "done" } },
+        },
+      ],
+      edges: [],
+      output: { value: { node: "done", port: "value" } },
+    },
+    {},
+    {},
+  );
+  if (!result.ok) throw new Error(JSON.stringify(result.issues));
+  const database = new DatabaseSync(":memory:");
+  try {
+    const owner = fromNodeSqlite(database);
+    const store = createGraphWorkflowRuns(owner);
+    const unused = (): never => {
+      throw new Error("Transform store fixture has no App or Git node");
+    };
+    const ceiling = await createWorkflowCeilingCapture({
+      node: unused,
+      git: unused,
+    })(
+      {
+        plan: result.plan,
+        computerId: null,
+        initiatedBy: { kind: "member", memberId: "owner" },
+        source: "manual",
+      },
+      { kind: "member", memberId: "owner" },
+      { membershipVersion: 1 },
+    );
+    if (ceiling === null) throw new Error("Transform ceiling refused");
+    const run = {
+      runId: "run_one",
+      teamId: "library",
+      requestId: "request",
+      actorId: "owner",
+      computerId: null,
+      plan: result.plan,
+      input: {},
+      ceiling,
+      source: "manual" as const,
+      initiatedBy: { kind: "member" as const, memberId: "owner" },
+    };
+    expect(store.startCompiled(run)).toBe("started");
+    expect(store.startCompiled(run)).toBe("replay");
+    expect(store.startCompiled({ ...run, requestId: "changed" })).toBe(
+      "conflict",
+    );
+    const base = {
+      runId: run.runId,
+      nodeId: "done",
+      iteration: "0",
+      attempt: 0,
+    };
+    store.recordEvent({ ...base, state: "running", poll: 0 });
+    store.recordEvent({ ...base, state: "waiting", poll: 0 });
+    const reopened = createGraphWorkflowRuns(owner);
+    reopened.recordEvent({ ...base, state: "running", poll: 1 });
+    reopened.recordEvent({
+      ...base,
+      graphId: "body",
+      state: "running",
+      poll: 1,
+    });
+    expect(reopened.events(run.runId)).toHaveLength(4);
+    reopened.markTerminal(run.runId, "cancelled");
+    expect(() => {
+      reopened.recordEvent({ ...base, state: "complete", poll: 1 });
+    }).toThrow("not active");
+    reopened.markTerminal(run.runId, "terminal");
+    expect(reopened.outcome(run.runId)).toBe("cancelled");
+    expect(reopened.events(run.runId)).toHaveLength(4);
+  } finally {
+    database.close();
+  }
+});

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "jsx": "react-jsx",
+    "noEmit": true,
+    "allowJs": false,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "exactOptionalPropertyTypes": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
+    "module": "NodeNext",
+    "moduleDetection": "force",
+    "moduleResolution": "NodeNext",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022",
+    "types": ["@cloudflare/workers-types", "vitest/globals", "vite/client"],
+    "verbatimModuleSyntax": true
+  },
+  "include": [
+    "backend",
+    "web",
+    "shared",
+    "test",
+    "vite.config.ts",
+    "vitest.config.ts"
+  ]
+}

package/turbo.jsonc

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://turborepo.com/schema.json",
+  "extends": ["//"],
+  "tasks": {
+    // The checks template test reads Shed's backend declaration and the
+    // Trellis App's templates; the storyboard template test builds Prints'
+    // and Inkcap's method catalogs from their sources; the merge test loads
+    // the celld runtime adapters.
+    "test:unit": {
+      "dependsOn": [
+        "build",
+        "@fungi.computer/shed#build",
+        "@fungi.computer/inkcap#build",
+        "@fungi.computer/prints#build",
+      ],
+      "inputs": [
+        "$TURBO_DEFAULT$",
+        "$TURBO_ROOT$/tooling/repository/scripts/{test-file-pool,proof-budget}.{mjs,d.mts}",
+        "$TURBO_ROOT$/.agents/skills/orchestrate-multi-lane-work/scripts/proof-time-bound.sh",
+        "$TURBO_ROOT$/tooling/celld-platform/runtime/**",
+        "$TURBO_ROOT$/apps/trellis/templates/**",
+      ],
+    },
+  },
+}

package/vite.config.ts

@@ -0,0 +1,19 @@
+import { fileURLToPath } from "node:url";
+import tailwindcss from "@tailwindcss/vite";
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  envDir: false,
+  base: "./",
+  root: fileURLToPath(new URL("./web", import.meta.url)),
+  plugins: [react(), tailwindcss()],
+  build: {
+    target: "es2022",
+    outDir: fileURLToPath(new URL("./.botanical/web", import.meta.url)),
+    emptyOutDir: true,
+  },
+  server: {
+    proxy: { "/api": "http://127.0.0.1:8797", "/git": "http://127.0.0.1:8797" },
+  },
+});

package/vitest.config.ts

@@ -0,0 +1,47 @@
+import { defineConfig } from "vitest/config";
+
+/**
+ * These files drive real `git` subprocesses (init, http-backend pushes, clones,
+ * plumbing reads) through Agar's real-Git test kit. Each Git spawn costs a few
+ * milliseconds idle and tens under CI load, so a test that is about 1 s on an
+ * idle box crosses the 5 s default when the gate runs at several times
+ * oversubscription. They get their own project and timeout; the fast unit
+ * tests keep Vitest's default.
+ */
+const realGit = [
+  "test/background-runtime.test.ts",
+  "test/changes.test.ts",
+  "test/file-edits.test.ts",
+  "test/files-read-copy-calls.test.ts",
+  "test/graph-commit-read-copy-calls.test.ts",
+  "test/merge-background.test.ts",
+  "test/merge-conflict.test.ts",
+  "test/merge-repro.test.ts",
+  "test/read-copy-composer.test.ts",
+  "test/read-copy-lifetimes.test.ts",
+  "test/repository-deletion.test.ts",
+];
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: "unit",
+          include: ["test/**/*.test.ts"],
+          exclude: realGit,
+          environment: "node",
+        },
+      },
+      {
+        test: {
+          name: "real-git",
+          include: realGit,
+          environment: "node",
+          testTimeout: 30_000,
+          hookTimeout: 30_000,
+        },
+      },
+    ],
+  },
+});

package/web/api.ts

@@ -0,0 +1,224 @@
+/** Bonsai's data hooks: every call is an App method, parsed at this boundary. */
+import { useQuery, useQueryClient } from "@tanstack/react-query";
+import { useEffect, useRef, useState } from "react";
+import {
+  activityPage,
+  approvalResult,
+  policyDecision,
+  agentPage,
+  changeDetail,
+  changePage,
+  commitDetail,
+  graph,
+  issueFiles,
+  mergeResult,
+  repoDetail,
+  repoPage,
+  type Activity,
+} from "../shared/contract.js";
+import { fileContent, fileList } from "@fungi.computer/agar/roles/files";
+import { ApiError, callMethod, filesEditor } from "./transport.js";
+
+export { ApiError };
+
+/** The Team's files-role App, re-asked as the shell's role choice may change. */
+export const useFilesEditor = () =>
+  useQuery({ queryKey: ["role", "files"], queryFn: filesEditor });
+
+export const useRepos = () =>
+  useQuery({
+    queryKey: ["repos"],
+    queryFn: () => callMethod("repos.list", {}, repoPage),
+  });
+
+export const useAgents = () =>
+  useQuery({
+    queryKey: ["agents"],
+    queryFn: () => callMethod("actors.list", {}, agentPage),
+  });
+
+export const useRepo = (name: string) =>
+  useQuery({
+    queryKey: ["repo", name],
+    queryFn: () => callMethod("repos.get", { repo: name }, repoDetail),
+  });
+
+export const useFile = (name: string, ref: string, path: string | null) =>
+  useQuery({
+    queryKey: ["blob", name, ref, path],
+    queryFn: () =>
+      callMethod(
+        "files.read",
+        { repo: name, ref, path: path ?? "" },
+        fileContent,
+      ),
+    enabled: path !== null,
+  });
+
+export const useFiles = (name: string, ref: string, enabled = true) =>
+  useQuery({
+    queryKey: ["files", name, ref],
+    queryFn: () => callMethod("files.list", { repo: name, ref }, fileList),
+    enabled,
+  });
+
+export const useIssueFiles = (name: string, ref: string) =>
+  useQuery({
+    queryKey: ["issues", name, ref],
+    queryFn: () => callMethod("issues.read", { repo: name, ref }, issueFiles),
+  });
+
+export const useChanges = (name: string) =>
+  useQuery({
+    queryKey: ["changes", name],
+    queryFn: () => callMethod("changes.list", { repo: name }, changePage),
+  });
+
+export const useChange = (repo: string, number: number) =>
+  useQuery({
+    queryKey: ["change", repo, number],
+    queryFn: () => callMethod("changes.get", { repo, number }, changeDetail),
+  });
+
+export function mergeChange(repo: string, number: number, head: string) {
+  return callMethod("changes.merge", { repo, number, head }, mergeResult);
+}
+
+export function approveChange(repo: string, number: number, head: string) {
+  return callMethod("changes.approve", { repo, number, head }, approvalResult);
+}
+
+export function closeChange(repo: string, number: number) {
+  return callMethod("changes.close", { repo, number }, policyDecision);
+}
+
+export const useCommit = (name: string, hash: string) =>
+  useQuery({
+    queryKey: ["commit", name, hash],
+    queryFn: () =>
+      callMethod("commits.get", { repo: name, hash }, commitDetail),
+    staleTime: Number.POSITIVE_INFINITY,
+  });
+
+export const useGraph = (name: string, enabled = true) =>
+  useQuery({
+    queryKey: ["graph", name],
+    queryFn: () => callMethod("graph.get", { repo: name }, graph),
+    enabled,
+  });
+
+export const useEvents = (repo: string | null) =>
+  useQuery({
+    queryKey: ["events", repo],
+    queryFn: () =>
+      callMethod("activity.list", { repo, limit: 60 }, activityPage),
+  });
+
+export type LiveState = Readonly<{
+  connected: boolean;
+  error: string | null;
+  /** Event ids that arrived while this page was open, for entrance motion. */
+  fresh: ReadonlySet<number>;
+}>;
+
+const POLL_MS = 2500;
+const IDLE_POLL_MS = 5000;
+
+function touches(event: Activity, key: readonly unknown[]): boolean {
+  const [kind, repo, number] = key;
+  const family = event.repo.split("--")[0] ?? event.repo;
+  if (kind === "events")
+    return repo === null || repo === family || repo === event.repo;
+  if (kind === "repos") return true;
+  if (kind === "agents")
+    return (
+      event.type === "push" ||
+      event.type === "fork" ||
+      event.type === "repo.created"
+    );
+  if ("change" in event.data) {
+    const change = event.data.change;
+    if (kind === "change")
+      return repo === change.repo && number === change.number;
+    if (kind === "changes") return repo === change.repo;
+  }
+  if (event.type === "push" || event.type === "merge") {
+    if (kind === "change") return repo === event.repo;
+    if (kind === "graph" || kind === "changes") return repo === family;
+    if (
+      kind === "repo" ||
+      kind === "files" ||
+      kind === "blob" ||
+      kind === "issues"
+    )
+      return repo === event.repo;
+  }
+  if (event.type === "fork") {
+    if (kind === "graph" || kind === "repo")
+      return repo === family || repo === event.data.fork;
+  }
+  return false;
+}
+
+/** Follow new activity and refresh whatever it touches. */
+export function useLive(): LiveState {
+  const client = useQueryClient();
+  const [connected, setConnected] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [fresh, setFresh] = useState<ReadonlySet<number>>(new Set());
+  const cursor = useRef<number | null>(null);
+  useEffect(() => {
+    let stopped = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let inFlight = false;
+    const canPoll = () => !stopped && !document.hidden;
+    const tick = async () => {
+      if (!canPoll() || inFlight) return;
+      inFlight = true;
+      let delay = POLL_MS;
+      try {
+        const page = await callMethod(
+          "activity.list",
+          { repo: null, limit: 50, after: cursor.current ?? 0 },
+          activityPage,
+        );
+        if (stopped) return;
+        setConnected(true);
+        setError(null);
+        const newest = page.events[0]?.id;
+        if (newest === undefined) delay = IDLE_POLL_MS;
+        if (cursor.current === null) cursor.current = newest ?? 0;
+        else if (newest !== undefined) {
+          cursor.current = newest;
+          const arrived: Activity[] = page.events;
+          setFresh(
+            (current) =>
+              new Set([...current, ...arrived.map((event) => event.id)]),
+          );
+          void client.invalidateQueries({
+            predicate: (query) =>
+              arrived.some((event) => touches(event, query.queryKey)),
+          });
+        }
+      } catch {
+        if (stopped) return;
+        setConnected(false);
+        setError("Live updates are unavailable. Retrying…");
+      }
+      inFlight = false;
+      if (canPoll()) timer = setTimeout(() => void tick(), delay);
+    };
+    const onVisibilityChange = () => {
+      if (timer !== undefined) clearTimeout(timer);
+      if (!document.hidden) void tick();
+    };
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    void tick();
+    return () => {
+      stopped = true;
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+      if (timer !== undefined) clearTimeout(timer);
+    };
+  }, [client]);
+  return { connected, error, fresh };
+}

package/web/app-build-panel.tsx

@@ -0,0 +1,171 @@
+import { useState } from "react";
+import { useMutation, useQuery } from "@tanstack/react-query";
+import { z } from "zod";
+import { Button } from "@fungi.computer/caps/components/button";
+import {
+  Card,
+  CardContent,
+  CardHeader,
+  CardTitle,
+} from "@fungi.computer/caps/components/card";
+import { Input } from "@fungi.computer/caps/components/input";
+import { pendingSchema } from "@fungi.computer/agar";
+import { appBuildView, jsonValue } from "../shared/contract.js";
+import { callMethod } from "./transport.js";
+
+// The panel sends the Release back to apps.install as JSON.
+const buildView = appBuildView.extend({ release: jsonValue.nullable() });
+// While the job runs, apps.buildStatus answers Agar Pending.
+const buildStatus = z.union([pendingSchema, buildView]);
+
+/** Start a build of a registered App's source, then install or switch its
+ * Release once it finishes. Owner only; the host re-checks that on every call. */
+export function AppBuildPanel() {
+  const [appId, setAppId] = useState("");
+  const [sourceRevision, setSourceRevision] = useState("");
+  const [installationId, setInstallationId] = useState("");
+  const [jobId, setJobId] = useState<string | null>(null);
+
+  const build = useMutation({
+    mutationFn: () =>
+      callMethod("apps.build", { appId, sourceRevision }, buildView),
+    onSuccess: (job) => {
+      setJobId(job.jobId);
+    },
+  });
+  const status = useQuery({
+    queryKey: ["apps.buildStatus", jobId],
+    queryFn: () => {
+      if (jobId === null) throw new Error("No build job to check yet");
+      return callMethod("apps.buildStatus", { jobId }, buildStatus);
+    },
+    enabled: jobId !== null,
+    refetchInterval: (query) =>
+      query.state.data === undefined || "kind" in query.state.data
+        ? 3_000
+        : false,
+  });
+  const settled =
+    status.data === undefined || "kind" in status.data ? null : status.data;
+  const install = useMutation({
+    mutationFn: () => {
+      const release = settled?.release;
+      if (release === null || release === undefined)
+        throw new Error("This build has no Release yet");
+      return callMethod(
+        "apps.install",
+        { installationId, release },
+        z.unknown(),
+      );
+    },
+  });
+
+  const release = settled?.release ?? null;
+  return (
+    <Card className="w-full max-w-2xl" variant="outline">
+      <CardHeader>
+        <CardTitle level={2}>Build &amp; install</CardTitle>
+      </CardHeader>
+      <CardContent className="flex flex-col gap-4">
+        <p className="text-sm text-[var(--stipe-fg-muted)]">
+          Build a registered App&rsquo;s source at one exact commit on this
+          Oyster&rsquo;s Computer, then install the Release, or switch an
+          already-live installation onto it. Only the owner may do this.
+        </p>
+        <form
+          className="flex flex-col gap-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            if (appId && sourceRevision && !build.isPending) build.mutate();
+          }}
+        >
+          <label className="flex flex-col gap-2" htmlFor="app-build-app-id">
+            <span>App id</span>
+            <Input
+              id="app-build-app-id"
+              value={appId}
+              onChange={(event) => {
+                setAppId(event.target.value);
+              }}
+              placeholder="app_my-fork"
+              disabled={build.isPending}
+            />
+          </label>
+          <label
+            className="flex flex-col gap-2"
+            htmlFor="app-build-source-revision"
+          >
+            <span>Source revision</span>
+            <Input
+              id="app-build-source-revision"
+              value={sourceRevision}
+              onChange={(event) => {
+                setSourceRevision(event.target.value);
+              }}
+              placeholder={`git:${"a".repeat(40)}`}
+              disabled={build.isPending}
+            />
+          </label>
+          {build.isError ? (
+            <div role="alert" className="text-sm text-error">
+              <p>{build.error.message}</p>
+            </div>
+          ) : null}
+          <div>
+            <Button
+              type="submit"
+              disabled={!appId || !sourceRevision || build.isPending}
+            >
+              {build.isPending ? "Starting build…" : "Build"}
+            </Button>
+          </div>
+        </form>
+        {jobId !== null ? (
+          <p className="text-sm" role="status">
+            Job {jobId}: {settled?.status ?? "running…"}
+            {/* A succeeded build's detail is its phase timings, not a message. */}
+            {settled?.status !== "succeeded" && settled?.detail
+              ? ` — ${settled.detail}`
+              : ""}
+          </p>
+        ) : null}
+        <form
+          className="flex flex-col gap-4"
+          onSubmit={(event) => {
+            event.preventDefault();
+            if (installationId && release !== null && !install.isPending)
+              install.mutate();
+          }}
+        >
+          <label className="flex flex-col gap-2" htmlFor="app-install-id">
+            <span>Install at</span>
+            <Input
+              id="app-install-id"
+              value={installationId}
+              onChange={(event) => {
+                setInstallationId(event.target.value);
+              }}
+              placeholder="my-fork"
+              disabled={install.isPending}
+            />
+          </label>
+          {install.isError ? (
+            <div role="alert" className="text-sm text-error">
+              <p>{install.error.message}</p>
+            </div>
+          ) : null}
+          <div>
+            <Button
+              type="submit"
+              disabled={
+                !installationId || release === null || install.isPending
+              }
+            >
+              {install.isPending ? "Installing…" : "Install this Release"}
+            </Button>
+          </div>
+        </form>
+      </CardContent>
+    </Card>
+  );
+}