conductor-board 1.2.0 → 1.3.0

package/bin/cli.js

@@ -2,6 +2,7 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import readline from "node:readline";
 import { startServer } from "../server/server.js";
 
 const argv = process.argv.slice(2);
@@ -117,6 +118,91 @@ const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
 const iris = (s) => `\x1b[38;5;141m${s}\x1b[0m`;
 const mint = (s) => `\x1b[38;5;78m${s}\x1b[0m`;
+const amber = (s) => `\x1b[38;5;214m${s}\x1b[0m`;
+
+function ago(iso) {
+  const t = new Date(iso).getTime();
+  if (Number.isNaN(t)) return "";
+  const s = Math.max(0, Math.floor((Date.now() - t) / 1000));
+  if (s < 60) return `${s}s ago`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m ago`;
+  const h = Math.floor(m / 60);
+  if (h < 24) return `${h}h ago`;
+  return `${Math.floor(h / 24)}d ago`;
+}
+
+function ask(question) {
+  return new Promise((resolve) => {
+    if (!process.stdin.isTTY) return resolve(false); // non-interactive — never block
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+
+// A pid is "alive" if signalling it doesn't throw ESRCH (EPERM = alive, not ours).
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+
+/**
+ * Before binding a port, look for a board that's already running here. A live
+ * one we offer to reclaim; a dead pid leaves a stale server.json we just clear.
+ */
+async function preflightStaleBoard(serverJsonPath) {
+  let info;
+  try {
+    info = JSON.parse(fs.readFileSync(serverJsonPath, "utf8"));
+  } catch {
+    return; // no (readable) server.json — nothing to do
+  }
+  const pid = info && info.pid;
+  const clear = () => {
+    try {
+      fs.unlinkSync(serverJsonPath);
+    } catch {
+      /* already gone */
+    }
+  };
+
+  if (!pid || !pidAlive(pid)) {
+    if (pid) {
+      clear();
+      console.log(dim(`\n  cleared a stale server.json (pid ${pid} is no longer running).`));
+    }
+    return;
+  }
+
+  const port = info.port ?? "?";
+  const when = info.started_at ? `, started ${ago(info.started_at)}` : "";
+  console.log("");
+  console.log(`  ${amber("⚠")}  A board is already running on port ${bold(port)} (pid ${pid}${when}).`);
+  const yes = await ask(`     Kill it and start fresh? ${dim("[y/N]")} `);
+  if (yes) {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+      /* it may have just exited */
+    }
+    await new Promise((r) => setTimeout(r, 600)); // let it release the port
+    clear();
+    console.log(dim(`     stopped pid ${pid}.`));
+  } else {
+    console.log(dim(`     leaving it running — starting on the next free port.`));
+  }
+}
+
+await preflightStaleBoard(
+  path.join(path.dirname(path.resolve(process.cwd(), statusPath)), "server.json"),
+);
 
 const { conductorPath: resolvedConductor, absStatus, server, serverJsonPath } =
   await listenWithFallback(wantedPort);

package/cli/setup.js

@@ -82,6 +82,9 @@ steps:
       At least once per minute, append a heartbeat {at, note} to the current
       step's heartbeat array (read prior entries first; orient against the gate
       AND the goal; use [text](url) links for any PRs or pages you produce).
+      Before marking each step done, append a finalBeat — {at, note, finalBeat:
+      true, handoff: {to, context, produced}} — summarizing the step and handing
+      off to the next; read the previous step's finalBeat before you start one.
       For loop steps, update "completed" and the "iterations" object as EACH
       iteration finishes — don't wait until the loop ends.
       Tag heartbeats with an "insight" object when you spot a way to improve the