npm - conductor-board - Versions diffs - 1.0.0 → 1.2.0 - Mend

conductor-board 1.0.0 → 1.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/README.md +1 -1
package/bin/cli.js +2 -1
package/cli/setup.js +15 -4
package/dist/assets/index-C0erDplC.css +1 -0
package/dist/assets/index-D02IYg9C.js +34 -0
package/dist/index.html +2 -2
package/package.json +3 -2
package/server/server.js +313 -61
package/dist/assets/index--J1uxrSo.js +0 -34
package/dist/assets/index-DMqA9hDY.css +0 -1

package/dist/index.html CHANGED Viewed

@@ -6,10 +6,10 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="theme-color" content="#0a0a0f" />
     <title>Agent Conductor — Board</title>
-    <script type="module" crossorigin src="./assets/index--J1uxrSo.js"></script>
+    <script type="module" crossorigin src="./assets/index-D02IYg9C.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/motion-Dmvx5jlk.js">
     <link rel="modulepreload" crossorigin href="./assets/yaml-NA7d4LV6.js">
-    <link rel="stylesheet" crossorigin href="./assets/index-DMqA9hDY.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-C0erDplC.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,12 +1,13 @@
 {
   "name": "conductor-board",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Gated workflows for AI agents — live Kanban board included",
   "license": "MIT",
   "author": "mettafive",
   "type": "module",
   "bin": {
-    "conductor-board": "bin/cli.js"
+    "conductor-board": "bin/cli.js",
+    "3042": "bin/cli.js"
   },
   "files": [
     "bin",

package/server/server.js CHANGED Viewed

@@ -13,6 +13,60 @@ import http from "node:http";
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
+import { validateConductor } from "../cli/validate.js";
+const readBody = (req) =>
+  new Promise((resolve) => {
+    let data = "";
+    req.on("data", (c) => (data += c));
+    req.on("end", () => resolve(data));
+  });
+/** Apply optimization suggestions to a parsed conductor doc (in place). */
+function applyMutations(doc, suggestions) {
+  doc.steps = Array.isArray(doc.steps) ? doc.steps : [];
+  const byId = new Map(doc.steps.map((s) => [s.id, s]));
+  for (const sug of suggestions) {
+    const step = sug.step ? byId.get(sug.step) : null;
+    switch (sug.type) {
+      case "instruction":
+        if (step) {
+          if (sug.current && typeof step.instruction === "string" && step.instruction.includes(sug.current)) {
+            step.instruction = step.instruction.replace(sug.current, sug.proposed ?? "");
+          } else if (sug.proposed) {
+            step.instruction = sug.proposed;
+          }
+        }
+        break;
+      case "gate":
+        if (step && Array.isArray(step.gate)) {
+          const i = step.gate.findIndex((g) => g === sug.current);
+          if (i >= 0 && sug.proposed != null) step.gate[i] = sug.proposed;
+          else if (sug.proposed != null) step.gate.push(sug.proposed);
+        }
+        break;
+      case "new_gate":
+        if (step && sug.proposed != null) {
+          step.gate = Array.isArray(step.gate) ? step.gate : [];
+          step.gate.push(sug.proposed);
+        }
+        break;
+      case "new_step":
+        doc.steps.push({
+          id: sug.step || `step-${doc.steps.length + 1}`,
+          instruction: sug.proposed || "TODO",
+          gate: ["TODO: add a gate criterion"],
+        });
+        break;
+      case "remove_step":
+        if (sug.step) doc.steps = doc.steps.filter((s) => s.id !== sug.step);
+        break;
+      // `reorder` is not auto-applied in v1
+    }
+  }
+  return doc;
+}
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const DIST = path.resolve(__dirname, "..", "dist");
@@ -207,89 +261,279 @@ function serveStatic(req, res) {
   fs.createReadStream(filePath).pipe(res);
 }
+/** Best-effort workflow name without parsing YAML (keeps the server dep-free). */
+function workflowName(statusPath, conductorPath, dir) {
+  try {
+    if (fs.existsSync(statusPath)) {
+      const s = JSON.parse(fs.readFileSync(statusPath, "utf8"));
+      if (s && typeof s.workflow === "string") return s.workflow;
+    }
+  } catch {
+    /* ignore */
+  }
+  try {
+    if (conductorPath && fs.existsSync(conductorPath)) {
+      const m = fs.readFileSync(conductorPath, "utf8").match(/^name:\s*(.+)$/m);
+      if (m) return m[1].trim();
+    }
+  } catch {
+    /* ignore */
+  }
+  return path.basename(dir);
+}
+/**
+ * Discover workflows under the .conductor root. Supports both the flat layout
+ * (.conductor/status.json — a single workflow, for v1 backwards compatibility)
+ * and the subdirectory layout (.conductor/<name>/status.json — many workflows).
+ */
+function discoverWorkflows(conductorDir, explicitStatus, explicitConductor) {
+  const found = [];
+  const seen = new Set();
+  const add = (name, dir, statusPath, conductorPath) => {
+    if (seen.has(name)) return;
+    seen.add(name);
+    found.push({
+      name,
+      dir,
+      statusPath,
+      conductorPath,
+      historyDir: path.join(dir, "history"),
+    });
+  };
+  // flat / explicit --path
+  const flatStatus = explicitStatus || path.join(conductorDir, "status.json");
+  const flatConductor = discoverConductor(flatStatus, explicitConductor);
+  if (fs.existsSync(flatStatus) || (flatConductor && fs.existsSync(flatConductor))) {
+    add(workflowName(flatStatus, flatConductor, conductorDir), conductorDir, flatStatus, flatConductor);
+  }
+  // subdirectories
+  if (fs.existsSync(conductorDir)) {
+    for (const entry of fs.readdirSync(conductorDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name === "history") continue;
+      const dir = path.join(conductorDir, entry.name);
+      const sp = path.join(dir, "status.json");
+      const cp = fs.existsSync(path.join(dir, "conductor.yaml"))
+        ? path.join(dir, "conductor.yaml")
+        : discoverConductor(sp, null);
+      if (fs.existsSync(sp) || (cp && fs.existsSync(cp))) {
+        add(workflowName(sp, cp, dir), dir, sp, cp);
+      }
+    }
+  }
+  return found;
+}
 export function startServer({ statusPath, conductorPath: explicitConductor, port }) {
   const absStatus = path.resolve(process.cwd(), statusPath);
-  let conductorPath = discoverConductor(absStatus, explicitConductor);
-  const watchDir = path.dirname(absStatus);
-  const historyDir = path.join(watchDir, "history");
+  const conductorDir = path.dirname(absStatus);
   /** @type {Set<http.ServerResponse>} */
   const clients = new Set();
+  /** @type {Map<string, Set<string>>} per-workflow archived run ids */
+  const archivedByWf = new Map();
+  const archivedSetFor = (wf) => {
+    let set = archivedByWf.get(wf.name);
+    if (!set) {
+      set = new Set();
+      for (const r of listHistory(wf.historyDir)) if (r.run_id) set.add(r.run_id);
+      archivedByWf.set(wf.name, set);
+    }
+    return set;
+  };
+  const snapshotFor = (wf) => {
+    const snap = readSnapshot(wf.statusPath, wf.conductorPath);
+    snap.workflow = wf.name;
+    return snap;
+  };
-  // Seed the archived set from disk so a restart doesn't re-archive past runs.
-  const archivedRunIds = new Set();
-  for (const r of listHistory(historyDir)) if (r.run_id) archivedRunIds.add(r.run_id);
+  const findWf = (name) =>
+    discoverWorkflows(conductorDir, absStatus, explicitConductor).find((w) => w.name === name);
-  const broadcastHistory = () => {
-    const list = JSON.stringify(listHistory(historyDir));
-    for (const res of clients) res.write(`event: history\ndata: ${list}\n\n`);
+  const sendAll = (event, data) => {
+    const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+    for (const res of clients) res.write(payload);
   };
   const broadcast = () => {
-    // conductor may appear after the server starts — re-discover if missing
-    if (!conductorPath) conductorPath = discoverConductor(absStatus, explicitConductor);
-    const snapshot = readSnapshot(absStatus, conductorPath);
-    const payload = JSON.stringify(snapshot);
-    for (const res of clients) {
-      res.write(`event: update\ndata: ${payload}\n\n`);
+    for (const wf of discoverWorkflows(conductorDir, absStatus, explicitConductor)) {
+      const snap = snapshotFor(wf);
+      sendAll("update", snap);
+      if (archiveIfDone(wf.historyDir, snap, archivedSetFor(wf))) {
+        sendAll("history", { workflow: wf.name, runs: listHistory(wf.historyDir) });
+      }
     }
-    if (archiveIfDone(historyDir, snapshot, archivedRunIds)) broadcastHistory();
   };
-  // Watch the directory that holds the status file (more reliable than
-  // watching a single file that gets atomically replaced). Debounced.
+  // Recursively watch the .conductor root so subdirectory status files are seen.
   let timer = null;
   const schedule = () => {
     clearTimeout(timer);
     timer = setTimeout(broadcast, 80);
   };
   try {
-    fs.mkdirSync(watchDir, { recursive: true });
-    fs.watch(watchDir, schedule);
+    fs.mkdirSync(conductorDir, { recursive: true });
+    try {
+      fs.watch(conductorDir, { recursive: true }, schedule);
+    } catch {
+      fs.watch(conductorDir, schedule); // platforms without recursive watch
+    }
   } catch (e) {
-    console.warn(`[agent-conductor] watch failed: ${e.message}`);
+    console.warn(`[conductor-board] watch failed: ${e.message}`);
   }
+  const sendSnapshotsTo = (res) => {
+    for (const wf of discoverWorkflows(conductorDir, absStatus, explicitConductor)) {
+      res.write(`event: update\ndata: ${JSON.stringify(snapshotFor(wf))}\n\n`);
+      res.write(
+        `event: history\ndata: ${JSON.stringify({
+          workflow: wf.name,
+          runs: listHistory(wf.historyDir),
+        })}\n\n`,
+      );
+    }
+  };
+  const json = (res, code, body) => {
+    res.writeHead(code, { "content-type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify(body));
+  };
   const server = http.createServer((req, res) => {
     const url = (req.url || "/").split("?")[0];
+    const wfs = () => discoverWorkflows(conductorDir, absStatus, explicitConductor);
     if (url === "/health") {
-      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-      res.end(
-        JSON.stringify({
-          status: "ok",
-          version: VERSION,
-          watching: path.relative(process.cwd(), absStatus) || absStatus,
-          port: server.address()?.port ?? null,
+      return json(res, 200, {
+        status: "ok",
+        version: VERSION,
+        watching: path.relative(process.cwd(), conductorDir) || conductorDir,
+        port: server.address()?.port ?? null,
+        workflows: wfs().map((w) => w.name),
+      });
+    }
+    // ---- multi-workflow API ----
+    if (url === "/api/workflows") {
+      return json(
+        res,
+        200,
+        wfs().map((wf) => {
+          const snap = snapshotFor(wf);
+          const st = snap.status?.status;
+          return {
+            name: wf.name,
+            status: st ?? "idle",
+            active: st === "running",
+            done: snap.status?.steps
+              ? Object.values(snap.status.steps).filter((s) => s && s.status === "done").length
+              : 0,
+            total: snap.status?.steps ? Object.keys(snap.status.steps).length : 0,
+            started_at: snap.status?.started_at ?? null,
+            runs: listHistory(wf.historyDir).length,
+            hasConductor: !!snap.conductorYaml,
+          };
         }),
       );
-      return;
     }
-    if (url === "/api/state") {
-      if (!conductorPath) conductorPath = discoverConductor(absStatus, explicitConductor);
-      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-      res.end(JSON.stringify(readSnapshot(absStatus, conductorPath)));
+    let m;
+    // apply optimization suggestions back to the conductor (mutate + backup + re-validate)
+    if (req.method === "POST" && (m = url.match(/^\/api\/workflow\/([^/]+)\/apply-suggestion$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      if (!wf) return json(res, 404, { error: "workflow not found" });
+      readBody(req).then((bodyStr) => {
+        let ids;
+        try {
+          ids = JSON.parse(bodyStr || "{}").suggestions;
+        } catch {
+          return json(res, 400, { error: "invalid request body" });
+        }
+        if (!Array.isArray(ids)) return json(res, 400, { error: "suggestions must be an array" });
+        if (!wf.conductorPath || !fs.existsSync(wf.conductorPath))
+          return json(res, 400, { error: "no conductor file for this workflow" });
+        let status;
+        try {
+          status = JSON.parse(fs.readFileSync(wf.statusPath, "utf8"));
+        } catch {
+          return json(res, 500, { error: "could not read status.json" });
+        }
+        const chosen = (status.suggestions || []).filter((s) => ids.includes(s.id));
+        if (chosen.length === 0) return json(res, 400, { error: "no matching suggestions" });
+        const original = fs.readFileSync(wf.conductorPath, "utf8");
+        const backup = `${wf.conductorPath}.bak.${new Date().toISOString().replace(/[:.]/g, "-")}`;
+        try {
+          fs.writeFileSync(backup, original);
+        } catch {
+          /* backup best-effort */
+        }
+        let doc;
+        try {
+          doc = yaml.load(original);
+        } catch (e) {
+          return json(res, 500, { error: `conductor parse error: ${e.message}` });
+        }
+        applyMutations(doc, chosen);
+        const errors = validateConductor(doc);
+        if (errors.length) {
+          // leave the original conductor untouched (we never wrote it)
+          return json(res, 422, { error: `would be invalid: ${errors[0]}`, errors });
+        }
+        try {
+          fs.writeFileSync(wf.conductorPath, yaml.dump(doc, { lineWidth: 100 }));
+        } catch (e) {
+          try {
+            fs.writeFileSync(wf.conductorPath, original); // rollback
+          } catch {
+            /* ignore */
+          }
+          return json(res, 500, { error: `write failed, rolled back: ${e.message}` });
+        }
+        return json(res, 200, {
+          ok: true,
+          applied: chosen.map((s) => s.id),
+          backup: path.basename(backup),
+        });
+      });
       return;
     }
-    if (url === "/history") {
-      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-      res.end(JSON.stringify(listHistory(historyDir)));
-      return;
+    if ((m = url.match(/^\/api\/workflow\/([^/]+)\/state$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      return wf ? json(res, 200, snapshotFor(wf)) : json(res, 404, { error: "not found" });
+    }
+    if ((m = url.match(/^\/api\/workflow\/([^/]+)\/history$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      return wf ? json(res, 200, listHistory(wf.historyDir)) : json(res, 404, { error: "not found" });
+    }
+    if ((m = url.match(/^\/api\/workflow\/([^/]+)\/history\/(.+)$/))) {
+      const wf = findWf(decodeURIComponent(m[1]));
+      if (!wf) return json(res, 404, { error: "not found" });
+      const rec = getHistory(wf.historyDir, decodeURIComponent(m[2]));
+      return rec ? json(res, 200, rec) : json(res, 404, { error: "not found" });
     }
+    // ---- backwards-compatible single-workflow API (primary = first found) ----
+    const primary = wfs()[0];
+    if (url === "/api/state") {
+      return json(res, 200, primary ? snapshotFor(primary) : { status: null, conductorYaml: null });
+    }
+    if (url === "/history") {
+      return json(res, 200, primary ? listHistory(primary.historyDir) : []);
+    }
     if (url.startsWith("/history/")) {
       const id = decodeURIComponent(url.slice("/history/".length));
-      const rec = getHistory(historyDir, id);
-      if (!rec) {
-        res.writeHead(404, { "content-type": "application/json" }).end('{"error":"not found"}');
-        return;
-      }
-      res.writeHead(200, { "content-type": "application/json; charset=utf-8" });
-      res.end(JSON.stringify(rec));
-      return;
+      const rec = primary ? getHistory(primary.historyDir, id) : null;
+      return rec ? json(res, 200, rec) : json(res, 404, { error: "not found" });
     }
     if (url === "/events") {
@@ -299,17 +543,11 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
         connection: "keep-alive",
       });
       res.write("retry: 2000\n\n");
-      // send an immediate snapshot + history so the board paints on connect
-      res.write(
-        `event: update\ndata: ${JSON.stringify(
-          readSnapshot(absStatus, conductorPath),
-        )}\n\n`,
-      );
-      res.write(`event: history\ndata: ${JSON.stringify(listHistory(historyDir))}\n\n`);
+      sendSnapshotsTo(res);
       clients.add(res);
-      const heartbeat = setInterval(() => res.write(": ping\n\n"), 25000);
+      const hb = setInterval(() => res.write(": ping\n\n"), 25000);
       req.on("close", () => {
-        clearInterval(heartbeat);
+        clearInterval(hb);
         clients.delete(res);
       });
       return;
@@ -318,15 +556,22 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
     serveStatic(req, res);
   });
-  // .conductor/server.json — the source of truth for which port we landed on,
-  // so a setup conductor's health check never has to hardcode a port.
-  const serverJsonPath = path.join(watchDir, "server.json");
+  const serverJsonPath = path.join(conductorDir, "server.json");
-  return new Promise((resolve) => {
+  return new Promise((resolve, reject) => {
+    // Reject on listen errors (e.g. EADDRINUSE) so the CLI can walk to the next
+    // port instead of crashing on an unhandled 'error' event.
+    const onError = (e) => {
+      server.off("error", onError);
+      reject(e);
+    };
+    server.once("error", onError);
     server.listen(port, () => {
+      server.off("error", onError);
       const actualPort = server.address().port;
+      const discovered = discoverWorkflows(conductorDir, absStatus, explicitConductor);
       try {
-        fs.mkdirSync(watchDir, { recursive: true });
+        fs.mkdirSync(conductorDir, { recursive: true });
         fs.writeFileSync(
           serverJsonPath,
           JSON.stringify(
@@ -335,6 +580,7 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
               url: `http://localhost:${actualPort}`,
               pid: process.pid,
               started_at: new Date().toISOString(),
+              workflows: discovered.map((w) => w.name),
             },
             null,
             2,
@@ -343,7 +589,13 @@ export function startServer({ statusPath, conductorPath: explicitConductor, port
       } catch (e) {
         console.warn(`[conductor-board] could not write server.json: ${e.message}`);
       }
-      resolve({ server, conductorPath, absStatus, serverJsonPath });
+      resolve({
+        server,
+        serverJsonPath,
+        absStatus,
+        conductorPath: discovered[0]?.conductorPath ?? null,
+        workflows: discovered.map((w) => w.name),
+      });
     });
   });
 }