huddle-cli 0.1.0 → 0.1.3

package/dist/app/live.js

@@ -0,0 +1,142 @@
+// The bridge between a run and the dashboard (`huddle app`), which may be
+// another process: the run can start in a terminal and be watched, answered
+// and stopped from the browser, or start from the browser itself.
+//
+//   .huddle/live.json   the run's live state, rewritten every second: phase,
+//                       narrator, each agent's task / % / tokens, the
+//                       council so far, a question waiting on you
+//   .huddle/inbox/      what the dashboard sends the run: your answer to a
+//                       question, a line for the agents, stop. One JSON file
+//                       each; the run takes them within a second
+//   .huddle/app.json    the dashboard is open (pid, url): a run with no
+//                       terminal still asks you its questions there
+//
+// Files, not a socket: the council runs before the Room exists, and either
+// side may start first. Everything here is local to the repo's .huddle/.
+import fs from "node:fs";
+import path from "node:path";
+const dir = (root) => path.join(root, ".huddle");
+export const livePath = (root) => path.join(dir(root), "live.json");
+export const inboxDir = (root) => path.join(dir(root), "inbox");
+export const appFile = (root) => path.join(dir(root), "app.json");
+/** Is `pid` a process on this machine? */
+export function alive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === "EPERM"; // exists, owned by someone else
+    }
+}
+/** Write atomically: a reader never sees half a file. */
+function writeJson(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(value));
+    fs.renameSync(tmp, file);
+}
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function writeLive(root, s) {
+    try {
+        writeJson(livePath(root), s);
+    }
+    catch {
+        /* a read-only or vanished .huddle: the dashboard just won't see this run */
+    }
+}
+/** The run in progress, or null: none, finished, or its process is gone (a crash, a kill -9). */
+export function readLive(root) {
+    const s = readJson(livePath(root));
+    if (!s || s.done || !alive(s.pid))
+        return null;
+    return s;
+}
+let seq = 0;
+/** The dashboard's side: queue a command for the run. */
+export function postCommand(root, c) {
+    const d = inboxDir(root);
+    fs.mkdirSync(d, { recursive: true });
+    // Sorted by name = oldest first: two commands in one millisecond keep their order (seen on Linux).
+    const name = `${String(Date.now()).padStart(15, "0")}-${String(seq++).padStart(6, "0")}-${process.pid}.json`;
+    writeJson(path.join(d, name), c);
+}
+/** The run's side: every queued command, oldest first, each taken once. */
+export function takeCommands(root) {
+    const d = inboxDir(root);
+    let names = [];
+    try {
+        names = fs.readdirSync(d).filter((n) => n.endsWith(".json")).sort();
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const n of names) {
+        const f = path.join(d, n);
+        const c = readJson(f);
+        try {
+            fs.unlinkSync(f);
+        }
+        catch {
+            continue; // another taker got it
+        }
+        if (c && typeof c === "object" && ["answer", "say", "stop"].includes(c.type))
+            out.push(c);
+    }
+    return out;
+}
+/** Commands left from an earlier run must not steer this one. */
+export function clearCommands(root) {
+    try {
+        for (const n of fs.readdirSync(inboxDir(root)))
+            fs.rmSync(path.join(inboxDir(root), n), { force: true });
+    }
+    catch {
+        /* no inbox yet */
+    }
+}
+export function writeAppInfo(root, info) {
+    writeJson(appFile(root), info);
+}
+export function clearAppInfo(root) {
+    const cur = readJson(appFile(root));
+    if (cur?.pid === process.pid)
+        fs.rmSync(appFile(root), { force: true });
+}
+/** The dashboard that's open on this repo, if any. */
+export function openApp(root) {
+    const a = readJson(appFile(root));
+    return a && alive(a.pid) ? a : null;
+}
+/** The run's WHAT YOU GOT write-up, kept for the dashboard: .huddle/reports/<session>.md */
+const reportFile = (root, session) => path.join(dir(root), "reports", `${session.replace(/[^\w-]/g, "_")}.md`);
+export function saveReport(root, session, text) {
+    try {
+        fs.mkdirSync(path.dirname(reportFile(root, session)), { recursive: true });
+        fs.writeFileSync(reportFile(root, session), text);
+    }
+    catch {
+        /* the terminal had it; the dashboard just won't */
+    }
+}
+export function readReport(root, session) {
+    if (!session)
+        return null;
+    try {
+        return fs.readFileSync(reportFile(root, session), "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=live.js.map