conductor-board 1.0.0 → 1.3.0

package/README.md

@@ -42,7 +42,7 @@ npx conductor-board --help                  # all commands + options
 | `--path`, `-p` | `.conductor/status.json` | Path to the status file |
 | `--conductor`, `-c` | auto-discovered | Path to the conductor `.yaml` |
 | `--port` | `3042` | Port to serve on (walks forward if taken) |
-| `--no-open` | — | Don't open the browser |
+| `--no-open` | — | Don't open the browser — CI / headless only (it opens by default) |
 | `--help`, `-h` | — | Show help |
 
 ```bash

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);
@@ -35,7 +36,8 @@ const HELP = `
     --path, -p <file>        Path to status.json   (default: .conductor/status.json)
     --conductor, -c <file>   Path to the conductor  (default: auto-discovered)
     --port <n>               Port to serve on        (default: 3042)
-    --no-open                Don't open the browser
+    --no-open                Don't open the browser  (CI / headless only;
+                             the board opens your browser by default)
 
   init options
     --name, -n <name>        Workflow name (skips the prompts)
@@ -116,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

@@ -27,8 +27,9 @@ steps:
 
   - id: start-board
     instruction: |
-      Start the board server in the background:
-        npx conductor-board &
+      Start the board server in the background. It opens the browser
+      automatically — do NOT pass --no-open here, that defeats the live view.
+        npx conductor-board >/tmp/conductor-board.log 2>&1 &
       Wait ~3 seconds for it to initialize. It auto-detects a free port if 3042
       is taken and records the chosen port in .conductor/server.json.
     requires: [preflight]
@@ -74,9 +75,22 @@ steps:
     instruction: |
       Execute the generated conductor workflow.
       Create .conductor/status.json with all steps pending and a timestamp run_id.
+      Set the top-level "goal" from the conductor's description, and refresh
+      "current_step_goal" each time current_step changes.
       Walk each step in order, updating status.json after every step and gate
-      change. Retry on gate failure — never skip. Set the top-level status to
-      "done" when the last step completes.
+      change. Retry on gate failure — never skip.
+      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
+      workflow. Before setting status to "done", review your insight-tagged
+      heartbeats and write 3-5 optimization "suggestions" to status.json.
+      Set the top-level status to "done" when the last step completes.
     requires: [convert-to-conductor]
     gate:
       - name: "Status file exists"