huddle-cli 0.0.0-stage → 0.1.1

package/dist/room/progress.js

@@ -0,0 +1,149 @@
+// The board as agents see it mid-task: for every task, who owns it, where it
+// is, the owner's last huddle_progress note and how old things are — so an
+// agent can tell a teammate that's nearly done from one that went quiet, and
+// see who took over whose work. Built from the task table plus Room events
+// (task.claimed / task.progress / task.takeover / task.split); no new tables.
+const ago = (s) => (s < 60 ? `${s}s` : s < 3600 ? `${Math.round(s / 60)}m` : `${Math.round(s / 360) / 10}h`);
+const parse = (s) => {
+    try {
+        return JSON.parse(s || "{}");
+    }
+    catch {
+        return {};
+    }
+};
+export function taskViews(db, now = Date.now()) {
+    const evs = db.eventsOfType(["task.claimed", "task.progress", "task.takeover", "task.split"], 0, 1000);
+    const claimed = new Map();
+    const note = new Map();
+    const touched = new Map();
+    const takeover = new Map();
+    const split = new Map();
+    const reported = new Set();
+    for (const e of evs) {
+        if (!e.task_id)
+            continue;
+        const p = parse(e.payload);
+        touched.set(e.task_id, e.ts);
+        if (e.type === "task.claimed")
+            claimed.set(e.task_id, e.ts);
+        if (e.type === "task.progress")
+            reported.add(e.task_id);
+        if (e.type === "task.progress" && p.note)
+            note.set(e.task_id, { text: String(p.note), ts: e.ts });
+        if (e.type === "task.takeover" && p.kind !== "split") {
+            takeover.set(e.task_id, { from: String(p.from ?? ""), reason: String(p.reason ?? "") });
+            claimed.set(e.task_id, e.ts); // the new owner's clock starts now
+        }
+        if (e.type === "task.split" && p.parent)
+            split.set(e.task_id, String(p.parent));
+    }
+    const secs = (ts) => Math.max(0, Math.round((now - ts) / 1000));
+    return db.listTasks().map((t) => {
+        const n = note.get(t.id);
+        const tk = takeover.get(t.id);
+        const c = claimed.get(t.id);
+        return {
+            id: t.id,
+            title: t.title,
+            status: t.status,
+            owner: t.claimed_by,
+            progress_pct: t.progress_pct,
+            reported: reported.has(t.id) || t.progress_pct > 0,
+            last_note: n?.text ?? null,
+            last_update_s: secs(Math.max(n?.ts ?? 0, touched.get(t.id) ?? 0, t.updated_at)),
+            age_s: t.status === "backlog" || c === undefined ? null : secs(c),
+            depends_on: JSON.parse(t.depends_on),
+            files: JSON.parse(t.files ?? "[]"),
+            ...(tk ? { taken_over_from: tk.from, takeover_reason: tk.reason } : {}),
+            ...(split.has(t.id) ? { split_from: split.get(t.id) } : {}),
+        };
+    });
+}
+/** One readable line per task: "codex · in_progress 40% · 3m · “wired the parser” (20s ago)". */
+export function progressLine(v) {
+    const who = v.owner ?? "unclaimed";
+    // An agent that never called huddle_progress shows "no report", not a made-up 0%.
+    const pct = v.status === "in_progress" || v.status === "claimed" ? (v.reported ? ` ${v.progress_pct}%` : " (no progress report)") : "";
+    const age = v.age_s !== null && v.status !== "merged" ? ` · ${ago(v.age_s)} on it` : "";
+    const last = v.last_note ? ` · “${v.last_note.slice(0, 120)}” (${ago(v.last_update_s)} ago)` : "";
+    const tk = v.taken_over_from ? ` · took over from ${v.taken_over_from}` : "";
+    const sp = v.split_from ? ` · split from ${v.split_from}` : "";
+    return `[${v.id}] ${v.title} — ${who} · ${v.status}${pct}${age}${last}${tk}${sp}`;
+}
+/** What huddle_progress hands back: everyone else's in-flight work, at a glance. */
+export function teamProgress(db, exceptTask) {
+    return taskViews(db)
+        .filter((v) => v.id !== exceptTask && ["claimed", "in_progress", "review"].includes(v.status))
+        .map(progressLine);
+}
+/**
+ * The launch prompt's "WORKING ALONGSIDE YOU" section: the other tasks in
+ * flight right now, who is on them, and their files, so an agent knows WHO
+ * to tell when it settles something they also rely on or expose. Found live
+ * (capstone round 2): 0 agent-to-agent messages in a 9-task run; the CLI and
+ * API were built side by side over the same service, and neither agent knew
+ * the other was mid-task without polling huddle_board. Empty when nobody else is working.
+ */
+export function alongsideBrief(db, taskId, agentId) {
+    const others = db
+        .listTasks()
+        .filter((t) => t.id !== taskId && t.claimed_by && t.claimed_by !== agentId && ["claimed", "in_progress"].includes(t.status))
+        .filter((t) => !/^QA round \d+:/.test(t.title));
+    if (!others.length)
+        return "";
+    const lines = others.map((t) => {
+        const files = JSON.parse(t.files ?? "[]").slice(0, 6);
+        return `- ${t.claimed_by}: “${t.title}” (task ${t.id}${files.length ? ` · ${files.join(", ")}` : ""})`;
+    });
+    return (`\n\nWORKING ALONGSIDE YOU right now, each in its own worktree:\n${lines.join("\n")}\n` +
+        `When you settle something one of them also relies on or exposes (a function or data shape, an error message, an output format, a test helper), ` +
+        `huddle_send(to="<agent>", message=…) as soon as you decide it, not at the end. Unsure what theirs does? huddle_ask(…, to="<agent>"). ` +
+        `Nothing they need? Don't send.`);
+}
+/** Was this message Huddle's automatic help offer (sent in a free agent's name), not words the agent wrote? */
+export function isHelpOffer(from, body) {
+    return body.startsWith(`${from} is free and can take part of your task `);
+}
+/** The note an idle agent (or the scheduler on its behalf) drops in a busy teammate's inbox. */
+export function helpOffer(from, taskId, title) {
+    return (`${from} is free and can take part of your task "${title}" (${taskId}). ` +
+        `If a piece of it is separable — ideally in files you won't keep editing — call ` +
+        `huddle_split(task_id="${taskId}", title=…, spec=…, files=[…]) and Huddle hands that part to a free agent; then don't do that part yourself. ` +
+        `If it isn't worth splitting, ignore this.`);
+}
+/** Parts one task may be split into (each huddle_split, or a Huddle pairing, hands one to the room). */
+export const MAX_SPLITS = 3;
+/**
+ * Put a part of `parent` on the board as its own task — huddle_split and
+ * Huddle's pairing both go through here. The part's files leave the parent's
+ * file list and the parent's leases on them are dropped: otherwise the part
+ * waits for the very task it was split off (busy files block a backlog task),
+ * and the two never run side by side.
+ */
+export function addSplitPart(db, parent, by, o) {
+    const parts = db.eventsOfType(["task.split"], 0, 1000).filter((e) => {
+        try {
+            return JSON.parse(e.payload || "{}").parent === parent.id;
+        }
+        catch {
+            return false;
+        }
+    }).length;
+    if (parts >= MAX_SPLITS)
+        return { error: `"${parent.title}" was already split ${parts} times — finish the rest yourself` };
+    const files = o.files.map(String).filter(Boolean).slice(0, 50);
+    const part = db.addTask({
+        title: o.title,
+        spec: `${o.spec.slice(0, 4000)}\n\n(Split off "${parent.title}" by ${by}, who keeps the rest of it — do only this part.)`,
+        files,
+        prefers: o.prefers ?? JSON.parse(parent.prefers),
+        depends_on: o.afterMine ? [parent.id] : [],
+    });
+    if (files.length)
+        db.handOverFiles(parent.id, files);
+    db.publish("task.split", { task_id: part.id, agent_id: by, payload: { parent: parent.id, parent_title: parent.title, from: by, title: o.title, files } });
+    db.remember({ kind: "fact", body: `${by} split "${o.title}" (${part.id}) off "${parent.title}" for a free agent`, author: by });
+    return { task: part };
+}
+//# sourceMappingURL=progress.js.map

package/dist/room/relaylink.js

@@ -0,0 +1,85 @@
+// The host's side of the relay: keeps one outbound WebSocket to the relay and
+// serves members through it with the exact same shared API as the direct door.
+import crypto from "node:crypto";
+import { WebSocket } from "ws";
+export function openRelayLink(room, relayUrl, log) {
+    const base = relayUrl.replace(/\/+$/, "").replace(/^http/, "ws");
+    const roomId = crypto.randomBytes(12).toString("base64url");
+    const key = crypto.randomBytes(24).toString("hex");
+    const subs = new Map(); // member connection → unsubscribe
+    let ws;
+    let closed = false;
+    let backoff = 1000;
+    const connect = (first) => {
+        ws = new WebSocket(`${base}/host/${roomId}?key=${key}`);
+        ws.on("open", () => {
+            backoff = 1000;
+            first(true);
+        });
+        ws.on("message", async (raw) => {
+            let m;
+            try {
+                m = JSON.parse(String(raw));
+            }
+            catch {
+                return;
+            }
+            const send = (f, close) => ws.readyState === WebSocket.OPEN && ws.send(JSON.stringify({ t: "to", cid: m.cid, f, ...(close ? { close } : {}) }));
+            if (m.t === "gone") {
+                subs.get(m.cid)?.();
+                subs.delete(m.cid);
+                return;
+            }
+            if (m.t !== "from")
+                return;
+            const f = m.f ?? {};
+            if (f.t === "req") {
+                const r = await room.handleShared({ method: String(f.method), path: String(f.path), token: f.token, body: f.body });
+                send({ t: "res", id: f.id, status: r.status, body: r.body });
+            }
+            else if (f.t === "sub") {
+                const stop = room.subscribe(String(f.token ?? ""), (e) => send({ t: "event", e }), () => send({ t: "closed", code: 4403 }, 4403));
+                if (!stop)
+                    send({ t: "closed", code: 4401 }, 4401);
+                else
+                    subs.set(m.cid, stop);
+            }
+        });
+        ws.on("close", () => {
+            for (const stop of subs.values())
+                stop();
+            subs.clear();
+            if (closed)
+                return;
+            setTimeout(() => connect(() => { }), backoff);
+            backoff = Math.min(backoff * 2, 30_000);
+        });
+        ws.on("error", () => first(false));
+    };
+    return new Promise((resolve) => {
+        let done = false;
+        const timer = setTimeout(() => {
+            if (!done)
+                (done = true), resolve(null);
+        }, 10_000);
+        connect((ok) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (!ok) {
+                closed = true;
+                log(`  couldn't reach the relay at ${relayUrl}`);
+                return resolve(null);
+            }
+            resolve({
+                address: `${base}/r/${roomId}`,
+                close: () => {
+                    closed = true;
+                    ws.close(1000);
+                },
+            });
+        });
+    });
+}
+//# sourceMappingURL=relaylink.js.map