@fungi.computer/bonsai 0.0.0-stage → 0.1.0

package/test/storyboard-save-template.test.mjs

@@ -0,0 +1,545 @@
+import assert from "node:assert/strict";
+import { Buffer } from "node:buffer";
+import { spawn } from "node:child_process";
+import { execFile } from "node:child_process";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import process from "node:process";
+import { test } from "node:test";
+import { setTimeout as delay } from "node:timers/promises";
+import { URL } from "node:url";
+import { promisify } from "node:util";
+import { Script } from "node:vm";
+import * as S from "effect/Schema";
+import * as z from "zod";
+import {
+  catalogEvents,
+  catalogMethods,
+  compile,
+  validate,
+  workflowDefinitionSchema,
+} from "@fungi.computer/braid";
+// Shed's, Prints', Inkcap's and Bonsai's sources are pinned at runtime only;
+// Bonsai's compiler options do not own them.
+import { buildAppApi } from "@fungi.computer/agar/backend-declaration";
+import { mintComputerProcessId } from "@fungi.computer/computer/operations";
+import { appBackend as bonsaiBackend } from "../backend/methods.ts";
+import { appBackend as shedBackend } from "../../shed/backend/methods.ts";
+import { createShedRuns } from "../../shed/backend/runs.ts";
+import { appBackend as printsBackend } from "../../prints/backend/methods.ts";
+import { appBackend as inkcapBackend } from "../../inkcap/backend/methods.ts";
+import {
+  startHttpsGitServer,
+  initBareRepo,
+} from "./storyboard-save-https-git.fixture.mjs";
+
+const execFileAsync = promisify(execFile);
+
+async function readTemplate(name) {
+  const template = z
+    .object({ definition: z.json() })
+    .parse(
+      JSON.parse(
+        await readFile(
+          new URL(`../../trellis/templates/${name}.json`, import.meta.url),
+          "utf8",
+        ),
+      ),
+    );
+  return S.decodeUnknownSync(workflowDefinitionSchema)(template.definition);
+}
+
+function findNode(definition, id) {
+  const node = definition.nodes.find((candidate) => candidate.id === id);
+  assert.ok(node, `missing node ${id}`);
+  return node;
+}
+
+// Only the external Code execution boundary is replaced by Node VM here,
+// exactly as checks-workflow-template.test.mjs proves bonsai-checks.json's
+// command. The commands this produces then run through Shed's and Inkcap's
+// real App method handlers below, not through a hand-run shell.
+async function evaluate(code, input) {
+  return z.json().parse(
+    await new Script(`(async () => { ${code} })()`).runInNewContext({
+      env: { INPUT: { read: () => Promise.resolve(input) } },
+      crypto: globalThis.crypto,
+      TextEncoder: globalThis.TextEncoder,
+    }),
+  );
+}
+
+test("pins the Storyboard + Save to git template's Save step to Bonsai's, Shed's and Inkcap's maintained declarations, and keeps the stock Storyboard template Save-free", async () => {
+  const bonsaiApi = buildAppApi(bonsaiBackend);
+  const shedApi = buildAppApi(shedBackend);
+  const printsApi = buildAppApi(printsBackend);
+  const inkcapApi = buildAppApi(inkcapBackend);
+  const catalog = {
+    app_bonsai: {
+      methods: (await catalogMethods(bonsaiApi.methods)).methods,
+      events: (await catalogEvents(bonsaiApi.events)).events,
+    },
+    app_shed: { methods: (await catalogMethods(shedApi.methods)).methods },
+    app_prints: { methods: (await catalogMethods(printsApi.methods)).methods },
+    app_inkcap: { methods: (await catalogMethods(inkcapApi.methods)).methods },
+  };
+
+  // The stock Storyboard template is unchanged: it declares only Prints, has
+  // no Git step, and compiles as an ordinary run with only Prints bound.
+  const stock = await readTemplate("storyboard");
+  assert.deepEqual(Object.keys(stock.apps), ["prints"]);
+  assert.ok(
+    !stock.nodes.some((node) => node.kind === "app" && "gitAccess" in node),
+    "the stock Storyboard template must declare no Git step",
+  );
+  assert.deepEqual(validate(stock, { app_prints: catalog.app_prints }), []);
+  const stockCompiled = await compile(
+    stock,
+    { app_prints: catalog.app_prints },
+    { prints: { appId: "app_prints", installationId: "prints" } },
+  );
+  assert.ok(stockCompiled.ok, JSON.stringify(stockCompiled));
+
+  // The separate, opt-in "Storyboard + Save to git" template carries the Git
+  // step and needs Bonsai, Shed and Inkcap in addition to Prints.
+  const withSave = await readTemplate("storyboard-save");
+  assert.deepEqual(Object.keys(withSave.apps).sort(), [
+    "bonsai",
+    "inkcap",
+    "prints",
+    "shed",
+  ]);
+  assert.deepEqual(validate(withSave, catalog), []);
+  const compiled = await compile(withSave, catalog, {
+    prints: { appId: "app_prints", installationId: "prints" },
+    bonsai: { appId: "app_bonsai", installationId: "bonsai" },
+    shed: { appId: "app_shed", installationId: "shed" },
+    inkcap: { appId: "app_inkcap", installationId: "inkcap" },
+  });
+  assert.ok(compiled.ok, JSON.stringify(compiled));
+  const clone = findNode(withSave, "clone");
+  const commitPush = findNode(withSave, "commitPush");
+  const writeSheet = findNode(withSave, "writeSheet");
+  assert.equal(clone.app, "shed");
+  assert.equal(clone.method, "run");
+  assert.deepEqual(clone.gitAccess, {
+    binding: "bonsai",
+    repository: "storyboard",
+    branches: ["refs/heads/main", "refs/heads/storyboard-drafts"],
+  });
+  assert.deepEqual(commitPush.gitAccess, clone.gitAccess);
+  assert.equal(writeSheet.app, "inkcap");
+  assert.equal(writeSheet.method, "writeFile");
+  assert.equal(
+    "gitAccess" in writeSheet,
+    false,
+    "the write step needs no Git access of its own",
+  );
+  const branchInput = withSave.input.properties.branch;
+  assert.deepEqual(
+    branchInput.enum.map((branch) => `refs/heads/${branch}`),
+    clone.gitAccess.branches,
+  );
+  assert.equal(
+    withSave.input.properties.repository.default,
+    clone.gitAccess.repository,
+  );
+});
+
+test("the Save to git flow runs through Shed's real run handler and Inkcap's real writeFile handler, and lands exact bytes", async (t) => {
+  const definition = await readTemplate("storyboard-save");
+  const saveSetup = findNode(definition, "saveSetup");
+  const cloneCommand = findNode(definition, "cloneCommand");
+  const commitCommand = findNode(definition, "commitCommand");
+
+  const work = await mkdtemp(join(tmpdir(), "storyboard-save-"));
+  t.after(() => rm(work, { recursive: true, force: true }));
+  const reposRoot = join(work, "repos");
+  await mkdir(reposRoot);
+  initBareRepo(reposRoot, "storyboard");
+  const server = await startHttpsGitServer(reposRoot);
+  t.after(() => server.close());
+  const remote = `${server.origin}/storyboard.git`;
+
+  // Production runs this inside the Computer sandbox, where /workspace is
+  // real; locally, a real (non-sync, so the in-process HTTPS server above
+  // can still answer requests concurrently) exec backend redirects the same
+  // absolute paths under a writable root instead of touching /workspace.
+  const sandboxRoot = join(work, "sandbox");
+  await mkdir(sandboxRoot);
+  const localize = (absolute) => absolute.replace("/workspace", sandboxRoot);
+
+  function createRealComputer() {
+    const procs = new Map();
+    return {
+      async processStart({ command, cwd }) {
+        const id = mintComputerProcessId();
+        const localCommand = command.replaceAll("/workspace", sandboxRoot);
+        const startedAt = Date.now();
+        const record = {
+          id,
+          port: null,
+          command,
+          cwd: cwd ?? null,
+          state: "running",
+          exitCode: null,
+          sync: "unknown",
+          startedAt,
+          endedAt: null,
+        };
+        procs.set(id, record);
+        const child = spawn("bash", ["-c", localCommand], {
+          cwd: cwd ? localize(cwd) : undefined,
+          env: { ...process.env, GIT_SSL_NO_VERIFY: "true" },
+        });
+        let stderr = "";
+        child.stderr.on("data", (chunk) => {
+          stderr += chunk;
+        });
+        child.on("exit", (code) => {
+          record.state = "exited";
+          record.exitCode = code;
+          record.endedAt = Date.now();
+          if (code !== 0) record.stderr = stderr.slice(-4000);
+        });
+        return record;
+      },
+      processes() {
+        return Promise.resolve({ processes: [...procs.values()] });
+      },
+      workflowGitPass() {
+        return Promise.resolve({
+          passId: "pass_test",
+          remote,
+          expiresAt: Date.now() + 300000,
+        });
+      },
+      async write({ path, content }) {
+        const target = localize(path);
+        await mkdir(dirname(target), { recursive: true });
+        await writeFile(target, content, "utf8");
+        return { path, bytes: Buffer.byteLength(content, "utf8") };
+      },
+    };
+  }
+
+  const database = new DatabaseSync(":memory:");
+  t.after(() => database.close());
+  const sql = {
+    exec(query, ...values) {
+      const rows = database.prepare(query).all(...values);
+      return { toArray: () => rows };
+    },
+  };
+  const computer = createRealComputer();
+  const shedContext = {
+    runs: createShedRuns(sql),
+    env: { COMPUTER: computer },
+  };
+  const inkcapContext = { env: { COMPUTER: computer } };
+  const actor = { kind: "member", memberId: "member_one" };
+  const computerId = "computer_one";
+  const gitAccess = {
+    repository: {
+      kind: "installation",
+      installationId: "bonsai",
+      repository: "storyboard",
+    },
+    branches: ["refs/heads/main", "refs/heads/storyboard-drafts"],
+  };
+
+  const shedRunReplySchema = z.union([
+    z.strictObject({ kind: z.literal("pending"), retryAfterMs: z.number() }),
+    z.strictObject({ exitCode: z.number(), logPath: z.string() }),
+    z.looseObject({ error: z.string() }),
+  ]);
+  const writeReplySchema = z.union([
+    z.strictObject({ path: z.string(), bytes: z.number() }),
+    z.looseObject({ error: z.string() }),
+  ]);
+
+  async function runShed(command, idempotencyKey) {
+    const caller = { actor, computerId, idempotencyKey };
+    const input = { command, gitAccess };
+    const deadline = Date.now() + 20000;
+    for (;;) {
+      const result = shedRunReplySchema.parse(
+        await shedBackend.call("run", input, shedContext, caller),
+      );
+      if ("kind" in result && result.kind === "pending") {
+        if (Date.now() > deadline)
+          throw new Error(`${idempotencyKey} timed out`);
+        await delay(25);
+        continue;
+      }
+      assert.ok(
+        !("error" in result),
+        `${idempotencyKey} refused: ${JSON.stringify(result)}`,
+      );
+      assert.equal(
+        result.exitCode,
+        0,
+        `${idempotencyKey}: ${JSON.stringify(result)}`,
+      );
+      return result;
+    }
+  }
+
+  async function save(contactSheet, branch, saveIndex) {
+    const setup = await evaluate(saveSetup.source, {
+      contactSheet,
+      repository: "storyboard",
+      branch,
+    });
+    const clone = await evaluate(cloneCommand.source, {
+      base: setup.base,
+      repoDir: setup.repoDir,
+      dir: setup.dir,
+      branch: setup.branch,
+    });
+    await runShed(clone.command, `clone-${saveIndex}`);
+    const written = writeReplySchema.parse(
+      await inkcapBackend.call(
+        "writeFile",
+        { path: setup.filePath, content: contactSheet },
+        inkcapContext,
+        { actor, computerId },
+      ),
+    );
+    assert.ok(
+      !("error" in written),
+      `write refused: ${JSON.stringify(written)}`,
+    );
+    const commit = await evaluate(commitCommand.source, {
+      repoDir: setup.repoDir,
+      dir: setup.dir,
+      saveId: setup.saveId,
+      branch: setup.branch,
+    });
+    await runShed(commit.command, `commit-${saveIndex}`);
+    return setup;
+  }
+
+  // A sheet with apostrophes and a long line: nothing here goes through a
+  // shell, since the write step is Inkcap's structured writeFile, not a
+  // heredoc, but this proves the whole path keeps bytes exact regardless.
+  const longLine = "L".repeat(5000) + " end-of-long-line";
+  const sheet = [
+    "# Storyboard contact sheet and shot list",
+    "",
+    "## 1. The fox's den at dawn",
+    "",
+    "Decision: keep",
+    "",
+    "Review note: don't regenerate; it's perfect. \"Quotes\" and 'apostrophes' too.",
+    "",
+    longLine,
+    "",
+  ].join("\n");
+
+  const first = await save(sheet, "storyboard-drafts", 1);
+  const checkout = join(work, "checkout-1");
+  await execFileAsync(
+    "git",
+    ["clone", "-q", "--branch", "storyboard-drafts", remote, checkout],
+    { env: { ...process.env, GIT_SSL_NO_VERIFY: "true" } },
+  );
+  const saved = await readFile(join(checkout, first.fileRel), "utf8");
+  assert.equal(
+    saved,
+    sheet,
+    "the saved bytes must exactly match the sheet, with no trimming",
+  );
+
+  // A second save to the same branch fetches the existing branch rather than
+  // starting an orphan, and keeps the first save's directory.
+  const secondSheet =
+    "# Storyboard contact sheet and shot list\n\nSecond run, with an apostrophe: it's done.\n";
+  const second = await save(secondSheet, "storyboard-drafts", 2);
+  const checkout2 = join(work, "checkout-2");
+  await execFileAsync(
+    "git",
+    ["clone", "-q", "--branch", "storyboard-drafts", remote, checkout2],
+    { env: { ...process.env, GIT_SSL_NO_VERIFY: "true" } },
+  );
+  assert.equal(
+    await readFile(join(checkout2, first.fileRel), "utf8"),
+    sheet,
+    "the first save's directory must survive a later save",
+  );
+  assert.equal(
+    await readFile(join(checkout2, second.fileRel), "utf8"),
+    secondSheet,
+  );
+});
+
+test("refuses a repository input that does not match the Save step's Git access", async () => {
+  const definition = await readTemplate("storyboard-save");
+  const saveSetup = findNode(definition, "saveSetup");
+  await assert.rejects(
+    evaluate(saveSetup.source, {
+      contactSheet: "x",
+      repository: "some-other-repo",
+      branch: "main",
+    }),
+    /authorized for repository 'storyboard'/,
+  );
+});
+
+test("caps the contact sheet by UTF-8 bytes, not characters, to match Inkcap's real writeFile limit", async () => {
+  const definition = await readTemplate("storyboard-save");
+  const saveSetup = findNode(definition, "saveSetup");
+  const writeSheet = findNode(definition, "writeSheet");
+  // Inkcap's own 48 KiB bound (apps/inkcap/backend/methods.ts:60,67-72).
+  const inkcapByteLimit = 48 * 1024;
+
+  // A non-ASCII sheet whose character count is far under the schema's old
+  // 49,152-character bound, but whose UTF-8 byte count is over Inkcap's
+  // real 48 KiB limit: "中" is 1 UTF-16 code unit and 3 UTF-8 bytes, so
+  // 20,000 of them are 20,000 characters but 60,000 bytes.
+  const nonAsciiSheet = "中".repeat(20000);
+  assert.ok(nonAsciiSheet.length < 49152);
+  assert.ok(
+    new globalThis.TextEncoder().encode(nonAsciiSheet).byteLength >
+      inkcapByteLimit,
+  );
+  await assert.rejects(
+    evaluate(saveSetup.source, {
+      contactSheet: nonAsciiSheet,
+      repository: "storyboard",
+      branch: "main",
+    }),
+    /UTF-8 bytes, over Inkcap's/,
+  );
+
+  // A sheet right at the byte boundary is accepted by saveSetup and would
+  // be accepted by Inkcap's own input schema too, so the two bounds agree.
+  const atLimitSheet = "a".repeat(inkcapByteLimit);
+  const setup = await evaluate(saveSetup.source, {
+    contactSheet: atLimitSheet,
+    repository: "storyboard",
+    branch: "main",
+  });
+  assert.ok(setup.saveId);
+  const inkcapApi = buildAppApi(inkcapBackend);
+  const inkcapCatalog = (await catalogMethods(inkcapApi.methods)).methods;
+  assert.equal(writeSheet.methodDigest, inkcapCatalog.writeFile.digest);
+  const writeInputSchema = z.looseObject({
+    path: z.string(),
+    content: z
+      .string()
+      .refine(
+        (value) =>
+          new globalThis.TextEncoder().encode(value).byteLength <=
+          inkcapByteLimit,
+        "exceeds Inkcap's byte limit",
+      ),
+  });
+  assert.doesNotThrow(() =>
+    writeInputSchema.parse({ path: "/workspace/x.md", content: atLimitSheet }),
+  );
+
+  // One byte over the limit is refused by saveSetup before ever reaching
+  // Inkcap, where it would have been refused anyway (spending no credit).
+  await assert.rejects(
+    evaluate(saveSetup.source, {
+      contactSheet: "a".repeat(inkcapByteLimit + 1),
+      repository: "storyboard",
+      branch: "main",
+    }),
+    /UTF-8 bytes, over Inkcap's/,
+  );
+});
+
+test("keeps storyboard-save.json's copied Storyboard graph identical to storyboard.json, so they can't drift", async () => {
+  const stock = await readTemplate("storyboard");
+  const withSave = await readTemplate("storyboard-save");
+
+  // The shared run-form input (beats/aspect/style) is untouched; only the
+  // Save-specific repository/branch fields are added on top.
+  assert.deepEqual(
+    withSave.input.properties.beats,
+    stock.input.properties.beats,
+  );
+  assert.deepEqual(
+    withSave.input.properties.aspect,
+    stock.input.properties.aspect,
+  );
+  assert.deepEqual(
+    withSave.input.properties.style,
+    stock.input.properties.style,
+  );
+  assert.deepEqual(withSave.input.required, stock.input.required);
+
+  // The beat-generation graph (fan-out, map, review, animate, retry) is
+  // copied byte-for-byte: a full deep-equal on both subgraphs.
+  assert.deepEqual(withSave.subgraphs.beat, stock.subgraphs.beat);
+  assert.deepEqual(withSave.subgraphs.attempt, stock.subgraphs.attempt);
+
+  // beatInputs and beats are copied byte-for-byte too.
+  assert.deepEqual(
+    findNode(withSave, "beatInputs"),
+    findNode(stock, "beatInputs"),
+  );
+  assert.deepEqual(findNode(withSave, "beats"), findNode(stock, "beats"));
+
+  // contactSheet is identical except its output bound, deliberately lowered
+  // in the Save template to fit Inkcap's 48 KiB writeFile limit (see the
+  // byte-cap test above); the stock template keeps its original 64 KiB bound.
+  const stockContactSheet = findNode(stock, "contactSheet");
+  const saveContactSheet = findNode(withSave, "contactSheet");
+  assert.deepEqual(
+    { ...saveContactSheet, output: undefined },
+    { ...stockContactSheet, output: undefined },
+  );
+  assert.equal(stockContactSheet.output.maxLength, 65536);
+  assert.equal(saveContactSheet.output.maxLength, 49152);
+});
+
+test("stops the run with Inkcap's refusal reason instead of falling through to commitPush's 'nothing to commit'", async () => {
+  const definition = await readTemplate("storyboard-save");
+  const writeFailure = findNode(definition, "writeFailure");
+
+  // Structural wiring: commitPush is gated on writeSheet's own `ok` port
+  // (not a plain completion-ordering edge), and a refusal is routed to a
+  // node that always throws, carrying the refusal through.
+  assert.deepEqual(definition.edges, [
+    {
+      from: { node: "clone", port: "after" },
+      to: { node: "writeSheet", port: "after" },
+    },
+    {
+      from: { node: "writeOk", port: "true" },
+      to: { node: "commitPush", port: "after" },
+    },
+    {
+      from: { node: "writeFailed", port: "true" },
+      to: { node: "writeFailure", port: "after" },
+    },
+  ]);
+  const writeOk = findNode(definition, "writeOk");
+  const writeFailed = findNode(definition, "writeFailed");
+  assert.deepEqual(writeOk.test, {
+    op: "exists",
+    value: { from: { node: "writeSheet", port: "ok" } },
+  });
+  assert.deepEqual(writeFailed.test, {
+    op: "exists",
+    value: { from: { node: "writeSheet", port: "refused" } },
+  });
+
+  // The failure node's own behavior: given Inkcap's refusal shape, it
+  // always throws with that reason, instead of silently completing.
+  const refusal = {
+    error: "attachment_budget_exceeded",
+    kind: "write",
+    retryAfterMs: 1000,
+  };
+  await assert.rejects(evaluate(writeFailure.source, { refusal }), (cause) => {
+    assert.match(cause.message, /could not write the contact sheet/);
+    assert.match(cause.message, /attachment_budget_exceeded/);
+    return true;
+  });
+});