huddle-cli 0.0.0-stage → 0.1.0

package/dist/orchestrator/takeover.js

@@ -0,0 +1,85 @@
+// Takeovers: agents take on other agents' tasks.
+//
+// Rescue (scheduler-driven): a task whose agent crashed, stayed red after its
+// fix round, or went silent is re-offered to a DIFFERENT agent, which continues
+// in the original worktree — the first agent's edits are already there — with
+// a brief: why it stopped, the test output, and what the first agent posted.
+// One takeover per task; if the rescuer can't land it either, it's parked for
+// you with the branch kept.
+//
+// Split (agent-driven): a busy agent hands a part of its task to the room
+// (huddle_split); a free agent picks it up like any backlog task. The
+// scheduler nudges busy agents when a teammate is free (huddle_offer_help).
+import fs from "node:fs";
+const cap = (s, n) => (s.length > n ? s.slice(0, n) + "…" : s);
+const parse = (s) => {
+    try {
+        return JSON.parse(s || "{}");
+    }
+    catch {
+        return {};
+    }
+};
+/** Minutes without output or a huddle_* call before an agent counts as silent. HUDDLE_SILENCE_MIN overrides. */
+export const DEFAULT_SILENCE_MS = 10 * 60_000;
+/** How long a task runs before a free agent offers to take part of it. HUDDLE_HELP_AFTER_SEC overrides; 0 = at once, "off" = never. */
+export const DEFAULT_HELP_AFTER_MS = 60_000;
+export function silenceMsFromEnv() {
+    const v = Number(process.env.HUDDLE_SILENCE_MIN);
+    return v > 0 ? v * 60_000 : DEFAULT_SILENCE_MS;
+}
+export function helpAfterMsFromEnv() {
+    const raw = process.env.HUDDLE_HELP_AFTER_SEC;
+    if (raw === undefined || raw === "")
+        return DEFAULT_HELP_AFTER_MS;
+    if (/^(off|no|never|-)/i.test(raw))
+        return null;
+    const v = Number(raw);
+    return Number.isFinite(v) && v >= 0 ? v * 1000 : DEFAULT_HELP_AFTER_MS;
+}
+function tail(file, bytes) {
+    try {
+        const st = fs.statSync(file);
+        const fd = fs.openSync(file, "r");
+        const n = Math.min(bytes, st.size);
+        const buf = Buffer.alloc(n);
+        fs.readSync(fd, buf, 0, n, st.size - n);
+        fs.closeSync(fd);
+        return buf.toString("utf8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+/** What the rescuer is told: why the first agent stopped, and everything it left behind. */
+export function takeoverBrief(db, o) {
+    const evs = db.eventsOfType(["plan.announced", "task.progress"], o.since - 1, 400).filter((e) => e.task_id === o.taskId);
+    const posted = [];
+    for (const e of evs) {
+        const p = parse(e.payload);
+        if (e.type === "plan.announced" && e.agent_id === o.from)
+            posted.push(`  plan: ${cap(String(p.intent ?? ""), 300)}${Array.isArray(p.touches) && p.touches.length ? ` — touches ${p.touches.slice(0, 12).join(", ")}` : ""}`);
+        if (e.type === "task.progress" && p.note)
+            posted.push(`  progress ${p.pct}%: ${cap(String(p.note), 300)}`);
+    }
+    const notes = db
+        .recall()
+        .filter((m) => m.author === o.from && m.created_at >= o.since)
+        .reverse()
+        .slice(-6)
+        .map((m) => `  ${m.kind}: ${cap(m.body, 300)}${m.why ? ` (why: ${cap(m.why, 160)})` : ""}`);
+    const summary = db.getHandoff(o.taskId)?.summary;
+    const left = [...posted.slice(-10), ...notes, ...(summary ? [`  done summary: ${cap(summary, 400)}`] : [])];
+    const log = o.testOutput === undefined && o.logPath ? tail(o.logPath, 1200) : "";
+    return `
+
+TAKEOVER — ${o.from} started this task and couldn't finish it: ${o.reason}.
+You are taking it over. ${o.from}'s work is ALREADY in your current directory (branch ${o.branch}, uncommitted edits included):
+continue from it — don't start over. Look first (git status, git diff), keep what's right, fix what's wrong, finish the task,
+and make the whole test suite pass. There is one takeover per task: if this doesn't land, it goes to the user.
+
+WHAT ${o.from} POSTED:
+${left.length ? left.join("\n") : "  (nothing — it never called huddle_progress / huddle_remember)"}
+${o.testOutput !== undefined ? `\nLAST TEST OUTPUT (tail):\n${cap(o.testOutput || "(no output)", 3000)}\n` : ""}${log ? `\nEND OF ${o.from}'S LOG (tail):\n${log}\n` : ""}`;
+}
+//# sourceMappingURL=takeover.js.map

package/dist/preflight.js

@@ -0,0 +1,31 @@
+// Runs before anything else in cli.ts (it's the first import, and ES modules
+// evaluate in import order): refuse old Node with a plain sentence instead of
+// a crash deep inside a dependency. No imports beyond node: builtins, so this
+// file works on any Node that can parse the CLI at all.
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export const MIN_NODE = 20;
+const major = Number(process.versions.node.split(".")[0]);
+if (major < MIN_NODE) {
+    console.error(`huddle needs Node.js ${MIN_NODE} or newer — this is ${process.version}.\n` +
+        `  Update Node (https://nodejs.org, or \`nvm install ${MIN_NODE}\`), then: npm install -g huddle-cli`);
+    process.exit(1);
+}
+/** Our own package.json — found by walking up, so it works from dist/ and from the test build. */
+export function packageInfo() {
+    let dir = path.dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+        try {
+            const pkg = JSON.parse(fs.readFileSync(path.join(dir, "package.json"), "utf8"));
+            if (pkg.name === "huddle-cli")
+                return { name: pkg.name, version: pkg.version };
+        }
+        catch {
+            /* not here — keep walking */
+        }
+        dir = path.dirname(dir);
+    }
+    return { name: "huddle-cli", version: "unknown" };
+}
+//# sourceMappingURL=preflight.js.map

package/dist/relay/server.js

@@ -0,0 +1,113 @@
+// The relay: a tiny, stateless switchboard so rooms work across any networks.
+//
+// Both sides dial OUT to it (which works through NAT, campus Wi-Fi, anything):
+//   host    wss://relay/host/<room>?key=<secret>   — one per room
+//   member  wss://relay/join/<room>                — anyone with the address
+// The relay only forwards frames between a room's members and its host. It
+// can't let anyone in: every request is checked by the host's Room (invite
+// codes, GitHub proofs, member tokens). Nothing is stored; when the host
+// disconnects, the room is gone.
+//
+// Run it anywhere Node runs:  huddle relay --port 8080
+import http from "node:http";
+import crypto from "node:crypto";
+import { WebSocketServer, WebSocket } from "ws";
+const MAX_FRAME = 512 * 1024;
+const MAX_MEMBERS = 64;
+const sha = (s) => crypto.createHash("sha256").update(s).digest("hex");
+export function startRelay(port, log = console.log) {
+    const rooms = new Map();
+    const server = http.createServer((req, res) => {
+        res.writeHead(200, { "content-type": "application/json" });
+        res.end(JSON.stringify({ huddle: "relay", rooms: rooms.size }));
+    });
+    const wss = new WebSocketServer({ server, maxPayload: MAX_FRAME });
+    wss.on("connection", (ws, req) => {
+        const url = new URL(req.url ?? "/", "http://relay");
+        const [, kind, roomId] = url.pathname.split("/");
+        if (!roomId || !/^[\w-]{8,64}$/.test(roomId))
+            return ws.close(4400, "bad room id");
+        if (kind === "host") {
+            const key = url.searchParams.get("key") ?? "";
+            const existing = rooms.get(roomId);
+            if (existing && existing.keyHash !== sha(key))
+                return ws.close(4403, "room id taken");
+            if (existing)
+                existing.host.close(4409, "replaced by a new host connection");
+            const link = { host: ws, keyHash: sha(key), members: existing?.members ?? new Map() };
+            rooms.set(roomId, link);
+            log(`room ${roomId.slice(0, 6)}… host connected`);
+            ws.on("message", (raw) => {
+                let f;
+                try {
+                    f = JSON.parse(String(raw));
+                }
+                catch {
+                    return;
+                }
+                // host → one member
+                if (f.t === "to" && typeof f.cid === "string") {
+                    const m = link.members.get(f.cid);
+                    if (m?.readyState === WebSocket.OPEN)
+                        m.send(JSON.stringify(f.f));
+                    if (f.close)
+                        m?.close(f.close, "closed by room");
+                }
+            });
+            ws.on("close", () => {
+                if (rooms.get(roomId)?.host !== ws)
+                    return;
+                rooms.delete(roomId);
+                for (const m of link.members.values()) {
+                    if (m.readyState === WebSocket.OPEN)
+                        m.send(JSON.stringify({ t: "closed", code: 1001 }));
+                    m.close(1001, "room closed");
+                }
+                log(`room ${roomId.slice(0, 6)}… closed`);
+            });
+            return;
+        }
+        if (kind === "join") {
+            const link = rooms.get(roomId);
+            if (!link)
+                return ws.close(4404, "no such room (is the host's Huddle open?)");
+            if (link.members.size >= MAX_MEMBERS)
+                return ws.close(4429, "room is full");
+            const cid = crypto.randomBytes(8).toString("hex");
+            link.members.set(cid, ws);
+            ws.on("message", (raw) => {
+                let f;
+                try {
+                    f = JSON.parse(String(raw));
+                }
+                catch {
+                    return;
+                }
+                if (link.host.readyState === WebSocket.OPEN)
+                    link.host.send(JSON.stringify({ t: "from", cid, f }));
+            });
+            ws.on("close", () => {
+                link.members.delete(cid);
+                if (link.host.readyState === WebSocket.OPEN)
+                    link.host.send(JSON.stringify({ t: "gone", cid }));
+            });
+            return;
+        }
+        ws.close(4400, "unknown path");
+    });
+    wss.on("error", () => { }); // listen errors are reported below
+    return new Promise((resolve, reject) => {
+        server.once("error", (e) => reject(new Error(e?.code === "EADDRINUSE" ? `port ${port} is already in use — try --port <another>` : String(e?.message ?? e))));
+        server.listen(port, "0.0.0.0", () => {
+            const actual = server.address().port;
+            resolve({
+                port: actual,
+                close: () => {
+                    wss.close();
+                    server.close();
+                },
+            });
+        });
+    });
+}
+//# sourceMappingURL=server.js.map