@fungi.computer/bonsai 0.0.0-stage → 0.0.1

package/test/seed-resume.test.mjs

@@ -0,0 +1,91 @@
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { seedDemo } from "../scripts/seed-demo.mjs";
+
+test("public seed requests identify the client honestly", async (t) => {
+  const work = await mkdtemp(join(tmpdir(), "koi-ua-"));
+  t.after(() => rm(work, { recursive: true, force: true }));
+  const agentKeysFile = join(work, "keys.json");
+  await writeFile(
+    agentKeysFile,
+    JSON.stringify({ morel: "test", chanterelle: "test", enoki: "test" }),
+    { mode: 0o600 },
+  );
+  let headers;
+  const stopped = new Error("request captured");
+  t.mock.method(globalThis, "fetch", async (_url, options) => {
+    headers = options.headers;
+    throw stopped;
+  });
+  await assert.rejects(
+    seedDemo({
+      origin: "https://oyster.test",
+      work,
+      agentKeysFile,
+      phase: "agents",
+    }),
+    stopped,
+  );
+  assert.equal(headers["User-Agent"], "oyster-koi-seed/1.0");
+});
+
+test("resume skips two pushed steps without consuming the staged third edit", async (t) => {
+  const { pushSeedStep } = await import("../scripts/seed-step.mjs");
+  const work = await mkdtemp(join(tmpdir(), "koi-resume-"));
+  t.after(() => rm(work, { recursive: true, force: true }));
+  const remote = join(work, ".git", "seed-remote.git");
+  const commands = [];
+  const git = async (args) => {
+    commands.push(args);
+    return execFileSync("git", args, {
+      cwd: work,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+  };
+  await git(["init", "-q", "-b", "main"]);
+  await git(["config", "user.name", "Morel"]);
+  await git(["config", "user.email", "morel@test.local"]);
+  await writeFile(join(work, "README.md"), "base\n");
+  await git(["add", "README.md"]);
+  await git(["commit", "-qm", "base"]);
+  const baseHead = await git(["rev-parse", "HEAD"]);
+  await git(["init", "--bare", "-q", remote]);
+  for (const message of ["palette", "ripples"]) {
+    await writeFile(join(work, "README.md"), message + "\n");
+    await git(["add", "README.md"]);
+    await git(["commit", "-qm", message]);
+  }
+  await git(["push", "-q", remote, "main"]);
+  const secondHead = await git(["rev-parse", "HEAD"]);
+  await writeFile(join(work, "README.md"), "third pending documentation\n");
+  await git(["add", "README.md"]);
+  commands.length = 0;
+  const options = {
+    git,
+    baseHead,
+    remote,
+    lastPushAt: Date.now(),
+    pushIntervalMinutes: 0.002,
+  };
+  assert.equal(await pushSeedStep({ ...options, message: "palette" }), null);
+  assert.equal(await pushSeedStep({ ...options, message: "ripples" }), null);
+  assert.equal(await git(["rev-parse", "HEAD"]), secondHead);
+  assert.equal(await git(["diff", "--cached", "--name-only"]), "README.md");
+  assert.equal(commands.filter(([cmd]) => cmd === "push").length, 0);
+  const third = await pushSeedStep({ ...options, message: "documentation" });
+  assert.ok(
+    third.at >= options.lastPushAt + 120,
+    "remaining real gap must elapse",
+  );
+  assert.equal(await git(["log", "-1", "--format=%s"]), "documentation");
+  assert.equal(
+    await pushSeedStep({ ...options, message: "documentation" }),
+    null,
+  );
+  assert.equal(commands.filter(([cmd]) => cmd === "push").length, 1);
+});

package/test/storyboard-save-https-git.fixture.mjs

@@ -0,0 +1,119 @@
+import { Buffer } from "node:buffer";
+import { execFileSync, spawn } from "node:child_process";
+import { once } from "node:events";
+import { createServer } from "node:https";
+import { mkdtemp, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { URL } from "node:url";
+
+/**
+ * A real git smart-HTTP server over real TLS (self-signed), proxying to the
+ * maintained `git http-backend` CGI program against a directory of real bare
+ * repositories. workflowGitPassResultSchema requires an `https:` remote
+ * (packages/agar/src/computer-contracts.ts); this gives Shed's real `run`
+ * handler and git's real client something genuine to fetch and push against,
+ * rather than a stand-in local path.
+ */
+export async function startHttpsGitServer(reposRoot) {
+  const certDir = await mkdtemp(join(tmpdir(), "storyboard-save-tls-"));
+  const keyPath = join(certDir, "key.pem");
+  const certPath = join(certDir, "cert.pem");
+  execFileSync(
+    "openssl",
+    [
+      "req",
+      "-x509",
+      "-newkey",
+      "rsa:2048",
+      "-keyout",
+      keyPath,
+      "-out",
+      certPath,
+      "-days",
+      "1",
+      "-nodes",
+      "-subj",
+      "/CN=127.0.0.1",
+    ],
+    { stdio: ["ignore", "pipe", "pipe"] },
+  );
+  const key = await readFile(keyPath);
+  const cert = await readFile(certPath);
+  function cgi(request, response) {
+    const url = new URL(request.url, "https://localhost");
+    const child = spawn("git", ["http-backend"], {
+      env: {
+        ...process.env,
+        GIT_PROJECT_ROOT: reposRoot,
+        GIT_HTTP_EXPORT_ALL: "1",
+        PATH_INFO: url.pathname,
+        QUERY_STRING: url.search.replace(/^\?/u, ""),
+        REQUEST_METHOD: request.method ?? "GET",
+        CONTENT_TYPE: request.headers["content-type"] ?? "",
+        CONTENT_LENGTH: request.headers["content-length"] ?? "0",
+        SERVER_PROTOCOL: "HTTP/1.1",
+        GATEWAY_INTERFACE: "CGI/1.1",
+        REMOTE_ADDR: "127.0.0.1",
+      },
+    });
+    request.pipe(child.stdin);
+    let headerBuffer = Buffer.alloc(0);
+    let headersSent = false;
+    child.stdout.on("data", (chunk) => {
+      if (headersSent) {
+        response.write(chunk);
+        return;
+      }
+      headerBuffer = Buffer.concat([headerBuffer, chunk]);
+      const crlf = headerBuffer.indexOf("\r\n\r\n");
+      const lf = headerBuffer.indexOf("\n\n");
+      const separatorAt = crlf !== -1 ? crlf : lf;
+      const separatorLength = crlf !== -1 ? 4 : 2;
+      if (separatorAt === -1) return;
+      const headerText = headerBuffer.slice(0, separatorAt).toString("utf8");
+      const body = headerBuffer.slice(separatorAt + separatorLength);
+      let status = 200;
+      const headers = {};
+      for (const line of headerText.split(/\r?\n/u)) {
+        const colon = line.indexOf(":");
+        if (colon === -1) continue;
+        const name = line.slice(0, colon).trim();
+        const value = line.slice(colon + 1).trim();
+        if (name.toLowerCase() === "status")
+          status = parseInt(value, 10) || 200;
+        else headers[name] = value;
+      }
+      response.writeHead(status, headers);
+      headersSent = true;
+      if (body.length > 0) response.write(body);
+    });
+    child.on("error", (cause) => {
+      response.destroy(cause);
+    });
+    child.on("close", () => {
+      if (!headersSent) response.writeHead(502);
+      response.end();
+    });
+  }
+  const server = createServer({ key, cert }, cgi);
+  server.listen(0, "127.0.0.1");
+  await once(server, "listening");
+  const { port } = server.address();
+  return {
+    origin: `https://127.0.0.1:${port}`,
+    close: () =>
+      new Promise((resolve) => {
+        server.closeAllConnections();
+        server.close(() => resolve());
+      }),
+  };
+}
+
+export function initBareRepo(reposRoot, name) {
+  const dir = join(reposRoot, `${name}.git`);
+  execFileSync("git", ["init", "--bare", "-q", dir]);
+  execFileSync("git", ["-C", dir, "config", "http.receivepack", "true"]);
+  return dir;
+}