@mmerterden/multi-agent-pipeline 20.29.0 → 20.33.0

package/pipeline/scripts/launch-request.mjs

@@ -99,6 +99,7 @@ import {
   writeFileSync,
 } from "node:fs";
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join } from "node:path";
 import { catalog, commandsDir } from "./commands.mjs";
@@ -108,6 +109,7 @@ import { autopilotRoot, unattendedLogsRoot } from "../lib/pr-request-location.mj
 import { lockTimeoutFrom, updateJsonFileSync } from "../lib/json-file-lock.mjs";
 import { unattendedSettingsPath } from "../lib/unattended-settings-location.mjs";
 import { isUnattended } from "../lib/unattended.mjs";
+import { listRuns, logsRoot } from "./_run-paths.mjs";
 
 export const CONTRACT_VERSION = "1.1.0";
 export const MODES = ["interactive", "autopilot", "background"];
@@ -548,6 +550,84 @@ export function launchRepos(env = process.env) {
   return out;
 }
 
+/** A stable, path-free handle for a repository path, as a client names one. */
+export const repoId = (p) => createHash("sha256").update(String(p)).digest("hex").slice(0, 16);
+
+const isCheckout = (real) => existsSync(join(real, ".git"));
+
+/**
+ * Checkouts earlier runs worked in that a launch does not accept yet: each
+ * run's projectRoot (and every projects[].projectRoot) under both log roots,
+ * by real path, kept when it is a git checkout and neither the home directory
+ * nor the root. A client offers them for registration; nothing is accepted
+ * until registerRepo stores one.
+ *
+ * @returns {{id: string, path: string, name: string}[]}
+ */
+export function suggestedRepos(env = process.env) {
+  const allowed = allowedLaunchRepos(env);
+  const home = realDir(homedir());
+  const out = new Map();
+  for (const root of new Set([logsRoot(), unattendedLogsRoot()])) {
+    for (const run of listRuns(root)) {
+      const state = readJsonOr(join(run.dir, "agent-state.json"), null);
+      if (!state || typeof state !== "object") continue;
+      const roots = [
+        state.projectRoot,
+        ...(Array.isArray(state.projects) ? state.projects.map((x) => x?.projectRoot) : []),
+      ];
+      for (const raw of roots) {
+        if (typeof raw !== "string" || !isAbsolute(raw)) continue;
+        const real = realDir(raw);
+        if (!real || real === "/" || real === home || allowed.has(real) || out.has(real)) continue;
+        if (!isCheckout(real)) continue;
+        out.set(real, { id: repoId(real), path: real, name: basename(real) });
+      }
+    }
+  }
+  return [...out.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Registered entries that are no longer a directory, as a client lists them
+ * for removal: launchRepos leaves them out, so nothing else would show them.
+ *
+ * @returns {{id: string, path: string, name: string}[]}
+ */
+export function missingRepos(env = process.env) {
+  const registered = readJsonOr(launchReposPath(env), {});
+  return (Array.isArray(registered?.repos) ? registered.repos : [])
+    .filter((p) => typeof p === "string" && p && !realDir(expandHome(p)))
+    .map((p) => ({ id: repoId(p), path: p, name: basename(p) }));
+}
+
+/**
+ * Remove one registered entry, named by repoId of its stored path. Configured
+ * autopilot repos are not touched: they belong to the autopilot config.
+ * Returns the removed path, or null when no entry has that id.
+ */
+export function unregisterRepo(id, env = process.env) {
+  let removed = null;
+  updateJsonFileSync(
+    launchReposPath(env),
+    (current) => {
+      const repos = Array.isArray(current?.repos) ? current.repos : [];
+      const keep = repos.filter((p) => {
+        // The list shows entries by their real path, so match that form too.
+        const real = typeof p === "string" ? realDir(expandHome(p)) : null;
+        if (removed === null && (repoId(p) === id || (real && repoId(real) === id))) {
+          removed = p;
+          return false;
+        }
+        return true;
+      });
+      return { ...current, repos: keep };
+    },
+    { fallback: {}, mode: 0o600, timeoutMs: lockTimeoutFrom(env) },
+  );
+  return removed;
+}
+
 /** Is `repoPath` a directory a launch may start in? Compared by real path. */
 export function launchRepoAllowed(repoPath, env = process.env) {
   const real = typeof repoPath === "string" && isAbsolute(repoPath) ? realDir(repoPath) : null;
@@ -560,7 +640,7 @@ export function launchRepoAllowed(repoPath, env = process.env) {
  * The read-modify-write holds the file's lock and replaces it atomically, so
  * two registrations at once both land. Returns the stored path.
  */
-export function registerRepo(repoPath, env = process.env) {
+export function registerRepo(repoPath, env = process.env, { requireCheckout = false } = {}) {
   if (typeof repoPath !== "string" || !isAbsolute(repoPath))
     throw new Error("the path must be absolute");
   const real = realDir(repoPath);
@@ -568,6 +648,7 @@ export function registerRepo(repoPath, env = process.env) {
   if (real === "/" || real === realDir(homedir())) {
     throw new Error("the home directory or the root is not a repository");
   }
+  if (requireCheckout && !isCheckout(real)) throw new Error("the path is not a git checkout");
   const file = launchReposPath(env);
   mkdirSync(autopilotRoot(env), { recursive: true, mode: 0o700 });
   updateJsonFileSync(
@@ -798,12 +879,15 @@ function planMain(rest) {
 }
 
 /** The `repos` document: launchRepos() with contractVersion; paths dropped under redact. */
-export function reposDocument({ redact = false, env = process.env } = {}) {
+export function reposDocument({ redact = false, env = process.env, extras = false } = {}) {
   const repos = launchRepos(env);
-  return {
-    contractVersion: CONTRACT_VERSION,
-    repos: redact ? repos.map(({ path: _p, ...r }) => r) : repos,
-  };
+  const strip = (list) => (redact ? list.map(({ path: _p, ...r }) => r) : list);
+  const doc = { contractVersion: CONTRACT_VERSION, repos: strip(repos) };
+  if (extras) {
+    doc.suggested = strip(suggestedRepos(env));
+    doc.missing = strip(missingRepos(env));
+  }
+  return doc;
 }
 
 function resumeMain(rest) {
@@ -857,11 +941,12 @@ function main(argv) {
   const [cmd, ...rest] = argv;
   if (cmd === "repos") {
     const redact = rest.includes("--redact");
-    if (rest.some((a) => a !== "--redact")) {
-      process.stderr.write("launch-request: repos takes only --redact\n");
+    const extras = rest.includes("--all");
+    if (rest.some((a) => a !== "--redact" && a !== "--all")) {
+      process.stderr.write("launch-request: repos takes only --redact and --all\n");
       return 2;
     }
-    process.stdout.write(JSON.stringify(reposDocument({ redact }), null, 2) + "\n");
+    process.stdout.write(JSON.stringify(reposDocument({ redact, extras }), null, 2) + "\n");
     return 0;
   }
   if (cmd === "questions" || cmd === "spec") {

package/pipeline/scripts/office-build.mjs

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+/**
+ * office-build.mjs - assemble the office panel page from pipeline/office-src.
+ *
+ * The server's CSP allows one nonce'd inline script, one nonce'd inline style
+ * and data: images, so the page has to be a single file. The sources stay
+ * readable as separate files (shell.html, style.css, world.js, app.js,
+ * strings.json) and this script inlines them into
+ * pipeline/office/index.html: the list of sprite names in pipeline/office/assets
+ * (served by contract-server.mjs at /office/assets/), the strings as a JSON
+ * literal, the two code files in order inside one IIFE. It also renders the
+ * pixel grids in pipeline/office-art into PNG sprites in pipeline/office/assets
+ * and writes pipeline/office/toolkit.json, the toolkit version shipped with
+ * the page; --check holds all three to their sources.
+ *
+ *   node pipeline/scripts/office-build.mjs          write the page
+ *   node pipeline/scripts/office-build.mjs --check  exit 1 when the page on
+ *                                                   disk is not what the
+ *                                                   sources build to
+ */
+
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { deflateSync } from "node:zlib";
+import { basename, join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+const ROOT = join(import.meta.dirname, "..");
+const SRC = join(ROOT, "office-src");
+const OUT = join(ROOT, "office", "index.html");
+const ASSETS = join(ROOT, "office", "assets");
+const TOOLKIT = join(ROOT, "office", "toolkit.json");
+const ART = join(ROOT, "office-art");
+const FACTS = join(ROOT, "..", "docs", "facts.json");
+const PNG_SIGNATURE = "89504e470d0a1a0a";
+
+// --- the project's own sprites -----------------------------------------------
+// Each office-art/<NAME>.txt is a "size WxH" line and H rows of W letters, one
+// letter per pixel from office-art/palette.json, "." transparent. They are
+// encoded here into office/assets/<NAME>.png byte for byte the same each time
+// (no timestamp, fixed compression), so --check can hold the PNGs to their
+// text and a review reads the drawing as a diff.
+
+const CRC_TABLE = Array.from({ length: 256 }, (_, n) => {
+  let c = n;
+  for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+  return c >>> 0;
+});
+function crc32(buf) {
+  let c = 0xffffffff;
+  for (const b of buf) c = CRC_TABLE[(c ^ b) & 0xff] ^ (c >>> 8);
+  return (c ^ 0xffffffff) >>> 0;
+}
+function chunk(type, data) {
+  const len = Buffer.alloc(4);
+  len.writeUInt32BE(data.length);
+  const body = Buffer.concat([Buffer.from(type, "ascii"), data]);
+  const crc = Buffer.alloc(4);
+  crc.writeUInt32BE(crc32(body));
+  return Buffer.concat([len, body, crc]);
+}
+/** An RGBA PNG, unfiltered rows, zlib level 9. */
+export function encodePng(width, height, rgba) {
+  const header = Buffer.alloc(13);
+  header.writeUInt32BE(width, 0);
+  header.writeUInt32BE(height, 4);
+  header[8] = 8;
+  header[9] = 6;
+  const raw = Buffer.alloc((width * 4 + 1) * height);
+  for (let y = 0; y < height; y++) {
+    rgba.copy(raw, y * (width * 4 + 1) + 1, y * width * 4, (y + 1) * width * 4);
+  }
+  return Buffer.concat([
+    Buffer.from(PNG_SIGNATURE, "hex"),
+    chunk("IHDR", header),
+    chunk("IDAT", deflateSync(raw, { level: 9 })),
+    chunk("IEND", Buffer.alloc(0)),
+  ]);
+}
+
+/** One art file as a PNG; throws on a size line, row length or letter that does not fit. */
+export function renderArt(text, colors, name = "sprite") {
+  const lines = text.replace(/\r/g, "").trimEnd().split("\n");
+  const m = /^size (\d{1,3})x(\d{1,3})$/.exec(lines[0] ?? "");
+  if (!m) throw new Error(`${name}: the first line is "size WxH"`);
+  const [w, h] = [Number(m[1]), Number(m[2])];
+  const rows = lines.slice(1);
+  if (rows.length !== h) throw new Error(`${name}: ${rows.length} rows, expected ${h}`);
+  const rgba = Buffer.alloc(w * h * 4);
+  rows.forEach((row, y) => {
+    if (row.length !== w)
+      throw new Error(`${name}: row ${y + 1} is ${row.length} wide, expected ${w}`);
+    [...row].forEach((ch, x) => {
+      if (ch === ".") return;
+      const hex = colors[ch];
+      if (!hex) throw new Error(`${name}: "${ch}" is not in the palette`);
+      const o = (y * w + x) * 4;
+      rgba[o] = parseInt(hex.slice(0, 2), 16);
+      rgba[o + 1] = parseInt(hex.slice(2, 4), 16);
+      rgba[o + 2] = parseInt(hex.slice(4, 6), 16);
+      rgba[o + 3] = 255;
+    });
+  });
+  return encodePng(w, h, rgba);
+}
+
+/** Every art sprite, name -> PNG bytes. */
+export function artSprites() {
+  const { colors } = JSON.parse(readFileSync(join(ART, "palette.json"), "utf8"));
+  const out = new Map();
+  for (const f of readdirSync(ART).sort()) {
+    if (!f.endsWith(".txt")) continue;
+    const name = basename(f, ".txt");
+    if (!/^[A-Z0-9_]{1,48}$/.test(name)) throw new Error(`${f}: sprite names are A-Z, 0-9 and _`);
+    out.set(name, renderArt(readFileSync(join(ART, f), "utf8"), colors, name));
+  }
+  return out;
+}
+
+// The sprite names the page may load from /office/assets/: every PNG beside
+// the page, checked to be one.
+function atlas() {
+  const out = [];
+  for (const name of readdirSync(ASSETS).sort()) {
+    if (!name.endsWith(".png")) continue;
+    const buf = readFileSync(join(ASSETS, name));
+    if (buf.subarray(0, 8).toString("hex") !== PNG_SIGNATURE) {
+      throw new Error(`${name} is not a PNG file`);
+    }
+    out.push(basename(name, ".png"));
+  }
+  return out;
+}
+
+/**
+ * The toolkit version the office's Tools window starts, shipped beside the
+ * page: the version this release was checked against, from docs/facts.json.
+ * The host runs the toolkit as @latest; the panel only runs an exact version,
+ * and every pipeline update brings the newer one with it.
+ */
+export function toolkitDoc() {
+  const v = JSON.parse(readFileSync(FACTS, "utf8")).toolkitVersion;
+  if (typeof v !== "string" || !/^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?$/.test(v)) {
+    throw new Error("docs/facts.json carries no exact toolkitVersion");
+  }
+  return JSON.stringify({ toolkitVersion: v }, null, 2) + "\n";
+}
+
+export function build() {
+  const read = (f) => readFileSync(join(SRC, f), "utf8");
+  const strings = JSON.parse(read("strings.json"));
+  const sprites = atlas();
+  const script = [
+    '"use strict";',
+    "(() => {",
+    `const ATLAS = ${JSON.stringify(sprites)};`,
+    `const STRINGS = ${JSON.stringify(strings)};`,
+    'const spriteUrl = (name) => "/office/assets/" + name + ".png";',
+    read("world.js").trim(),
+    read("app.js").trim(),
+    "})();",
+  ].join("\n");
+  const style = read("style.css").trim();
+  // The build id the server reads back from the installed page: the page
+  // compares it with its own to tell that a newer one has been installed.
+  const hash = createHash("sha256").update(script).update(style).update(read("shell.html"));
+  // Redrawn sprites change the page too, though no source text did.
+  for (const [name, png] of artSprites()) hash.update(name).update(png);
+  const build = hash.digest("hex").slice(0, 12);
+  // Text that would close the inline element early, or open an HTML comment
+  // inside it, turns source into markup.
+  if (/<\/script|<!--/i.test(script)) throw new Error("the script contains </script or <!--");
+  if (/<\/style/i.test(style)) throw new Error("style.css contains </style");
+  const shell = read("shell.html");
+  for (const marker of ["/*STYLE*/", "/*SCRIPT*/"]) {
+    if (shell.split(marker).length !== 2) throw new Error(`shell.html needs exactly one ${marker}`);
+  }
+  const stamped = script.replace('"use strict";', () => `"use strict";\nconst BUILD = "${build}";`);
+  return shell.replace("/*STYLE*/", () => style).replace("/*SCRIPT*/", () => stamped);
+}
+
+const isMain = process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href;
+if (isMain) {
+  const art = artSprites();
+  const check = process.argv.includes("--check");
+  if (!check) for (const [name, png] of art) writeFileSync(join(ASSETS, `${name}.png`), png);
+  const html = build();
+  const toolkit = toolkitDoc();
+  if (check) {
+    for (const [name, png] of art) {
+      let on = null;
+      try {
+        on = readFileSync(join(ASSETS, `${name}.png`));
+      } catch {
+        // Missing is stale.
+      }
+      if (!on || !on.equals(png)) {
+        console.error(
+          `office/assets/${name}.png is stale: run node pipeline/scripts/office-build.mjs`,
+        );
+        process.exit(1);
+      }
+    }
+    const read = (f) => {
+      try {
+        return readFileSync(f, "utf8");
+      } catch {
+        // A missing file is stale by definition.
+        return "";
+      }
+    };
+    if (read(OUT) !== html) {
+      console.error("office/index.html is stale: run node pipeline/scripts/office-build.mjs");
+      process.exit(1);
+    }
+    if (read(TOOLKIT) !== toolkit) {
+      console.error("office/toolkit.json is stale: run node pipeline/scripts/office-build.mjs");
+      process.exit(1);
+    }
+    console.log("office/index.html and office/toolkit.json match their sources");
+  } else {
+    writeFileSync(OUT, html);
+    writeFileSync(TOOLKIT, toolkit);
+    console.log(`wrote ${OUT} (${Buffer.byteLength(html)} bytes) and ${TOOLKIT}`);
+  }
+}