huddle-cli 0.0.0-stage → 0.1.0

package/dist/attach/live.js

@@ -0,0 +1,222 @@
+// Attach mode, the daemon: one long-lived Room per repo for the sessions you
+// run yourself. `huddle up` starts it in the background (or finds the one
+// already running), `huddle down` stops it. Everything it needs is under
+// .huddle/ (never committed):
+//
+//   .huddle/live.json   pid · port · secret (0600) — how Plugs and hooks find it
+//   .huddle/live.db     its board: leases, notes, shared memory
+//   .huddle/logs/live.log
+//
+// The Plug reads live.json on every connect, so a restarted room (new port,
+// new secret) is picked up without rewriting anyone's MCP config.
+import { execFileSync, spawn } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { RoomDB } from "../room/db.js";
+import { liveRoom } from "../room/live.js";
+import { startRoom } from "../room/server.js";
+// dist/attach/live.js -> dist/cli.js
+export const CLI_PATH = fileURLToPath(new URL("../cli.js", import.meta.url));
+/**
+ * The main checkout's root for wherever we are — also from inside a worktree
+ * (git-common-dir is the main repo's .git). null outside git.
+ */
+export function mainRoot(cwd = process.cwd()) {
+    try {
+        const common = execFileSync("git", ["rev-parse", "--path-format=absolute", "--git-common-dir"], {
+            cwd,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return fs.realpathSync(path.dirname(common));
+    }
+    catch {
+        return null;
+    }
+}
+/** This checkout's root (a worktree's own root when inside one). */
+export function checkoutRoot(cwd = process.cwd()) {
+    try {
+        return fs.realpathSync(execFileSync("git", ["rev-parse", "--show-toplevel"], { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim());
+    }
+    catch {
+        return null;
+    }
+}
+export const liveFiles = (root) => {
+    const dir = path.join(root, ".huddle");
+    return {
+        dir,
+        state: path.join(dir, "live.json"),
+        db: path.join(dir, "live.db"),
+        lock: path.join(dir, "live.lock"),
+        log: path.join(dir, "logs", "live.log"),
+    };
+};
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === "EPERM";
+    }
+}
+/** The running room's state, if its process is still alive. */
+export function readLive(root) {
+    try {
+        const st = JSON.parse(fs.readFileSync(liveFiles(root).state, "utf8"));
+        return st.pid && alive(st.pid) ? st : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Call the live room as `as` (a session id; "" for anonymous verbs). */
+export async function liveCall(st, verb, body = {}, as = "", timeoutMs = 4000) {
+    const res = await fetch(`${st.url}/live/${verb}`, {
+        method: "POST",
+        headers: { "content-type": "application/json", "x-huddle-secret": st.secret, "x-huddle-agent": as },
+        body: JSON.stringify(body ?? {}),
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    return { status: res.status, body: await res.json().catch(() => ({})) };
+}
+/** Same as liveCall, for the Room's ordinary agent verbs (/recall, /remember, …). */
+export async function roomCall(st, method, p, body, as) {
+    const res = await fetch(`${st.url}${p}`, {
+        method,
+        headers: { "content-type": "application/json", "x-huddle-secret": st.secret, "x-huddle-agent": as },
+        body: method === "POST" ? JSON.stringify({ agent_id: as, ...body }) : undefined,
+        signal: AbortSignal.timeout(8000),
+    });
+    return res.json();
+}
+export async function pingLive(st) {
+    if (!st)
+        return false;
+    try {
+        return (await liveCall(st, "ping", {}, "", 1500)).status === 200;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureHuddleDir(root) {
+    const f = liveFiles(root);
+    fs.mkdirSync(path.dirname(f.log), { recursive: true });
+    const gi = path.join(f.dir, ".gitignore");
+    if (!fs.existsSync(gi))
+        fs.writeFileSync(gi, "*\n"); // keep .huddle/ out of commits
+}
+/**
+ * Find the repo's live room, or start it in the background. Safe to call from
+ * several Plugs at once: a lock file makes sure only one daemon starts.
+ */
+export async function ensureLive(root, timeoutMs = 8000) {
+    const st = readLive(root);
+    if (st && (await pingLive(st)))
+        return { state: st, started: false };
+    ensureHuddleDir(root);
+    const f = liveFiles(root);
+    let mine = false;
+    try {
+        fs.writeFileSync(f.lock, String(process.pid), { flag: "wx" });
+        mine = true;
+    }
+    catch {
+        // Someone else is starting it — unless their lock is stale.
+        try {
+            if (Date.now() - fs.statSync(f.lock).mtimeMs > 10_000) {
+                fs.writeFileSync(f.lock, String(process.pid));
+                mine = true;
+            }
+        }
+        catch {
+            /* lock vanished: they finished */
+        }
+    }
+    if (mine) {
+        const out = fs.openSync(f.log, "a");
+        const child = spawn(process.execPath, [CLI_PATH, "up", "--serve"], {
+            cwd: root,
+            detached: true,
+            stdio: ["ignore", out, out],
+            env: { ...process.env, HUDDLE_LIVE_ROOT: root },
+        });
+        child.unref();
+        fs.closeSync(out);
+    }
+    const deadline = Date.now() + timeoutMs;
+    try {
+        while (Date.now() < deadline) {
+            const s = readLive(root);
+            if (s && (await pingLive(s)))
+                return { state: s, started: mine };
+            await new Promise((r) => setTimeout(r, 100));
+        }
+    }
+    finally {
+        if (mine)
+            fs.rmSync(f.lock, { force: true });
+    }
+    throw new Error(`the live room didn't start — see ${path.relative(root, f.log)}`);
+}
+/** The daemon itself (`huddle up --serve`). Runs until `huddle down` or idle. */
+export async function serveLive(root) {
+    ensureHuddleDir(root);
+    const f = liveFiles(root);
+    const other = readLive(root);
+    if (other && other.pid !== process.pid && (await pingLive(other))) {
+        console.log(`live room already running (pid ${other.pid})`);
+        return;
+    }
+    const db = new RoomDB(f.db);
+    const room = await startRoom(db, Number(process.env.HUDDLE_LIVE_PORT ?? 0), { host: "live" });
+    room.live = liveRoom(db, { repoRoot: root, staleMs: Number(process.env.HUDDLE_LIVE_STALE_MS ?? 60_000) });
+    const st = { pid: process.pid, port: room.port, url: room.url, secret: room.secret, root, started_at: Date.now() };
+    const tmp = `${f.state}.${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(st, null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, f.state);
+    console.log(`${new Date().toISOString()} live room up on ${room.url} (pid ${process.pid})`);
+    let lastBusy = Date.now();
+    const IDLE_MS = Number(process.env.HUDDLE_LIVE_IDLE_MS ?? 6 * 3600_000);
+    const stop = (why) => {
+        console.log(`${new Date().toISOString()} live room stopping: ${why}`);
+        try {
+            const cur = JSON.parse(fs.readFileSync(f.state, "utf8"));
+            if (cur.pid === process.pid)
+                fs.rmSync(f.state, { force: true });
+        }
+        catch {
+            /* already gone */
+        }
+        room.live?.close();
+        room.close();
+        db.close();
+        process.exit(0);
+    };
+    process.on("SIGTERM", () => stop("huddle down"));
+    process.on("SIGINT", () => stop("interrupted"));
+    // No live sessions for IDLE_MS (default 6h) = nobody needs it; leave quietly.
+    setInterval(() => {
+        if (room.live.sessions().length)
+            lastBusy = Date.now();
+        else if (Date.now() - lastBusy > IDLE_MS)
+            stop("idle");
+    }, Math.min(IDLE_MS, 60_000));
+}
+/** `huddle down`. True if a room was running. */
+export async function stopLive(root) {
+    const st = readLive(root);
+    if (!st) {
+        fs.rmSync(liveFiles(root).state, { force: true });
+        return false;
+    }
+    process.kill(st.pid, "SIGTERM");
+    for (let i = 0; i < 50 && alive(st.pid); i++)
+        await new Promise((r) => setTimeout(r, 100));
+    return true;
+}
+//# sourceMappingURL=live.js.map

package/dist/attach/plug.js

@@ -0,0 +1,174 @@
+// Attach mode, the agent side: the Plug as seen by a session YOU started
+// (claude / codex / cursor in your own terminal). `huddle connect` puts this in
+// each agent's project MCP config with HUDDLE_LIVE=1. There's no scheduler and
+// no task id: the session says hello to the repo's live room (starting it if
+// needed), and its tools are about sharing the repo safely with the others.
+import { execFileSync } from "node:child_process";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { checkoutRoot, ensureLive, liveCall, mainRoot, roomCall } from "./live.js";
+/** What every attached agent is told, via the MCP `instructions` field. */
+export const LIVE_INSTRUCTIONS = `
+You are one of several AI coding sessions (e.g. claude, codex, cursor) working in this same repo at the same time, coordinated by Huddle.
+Before you edit ANY file:
+1. huddle_peers — see who else is live, what they're doing, which files they hold.
+2. huddle_announce_plan(intent, touches) with every file (or "dir/") you'll change. If it returns conflicts, DO NOT edit those files: huddle_note the holder or pick other work, and tell your user.
+3. When you finish a change, huddle_release so the others can proceed.
+Notes from other sessions arrive in "notes_for_you" on any huddle_* reply — read them and answer with huddle_note. Record lasting decisions with huddle_remember.
+`.trim();
+const tools = [
+    {
+        name: "huddle_peers",
+        description: "See every OTHER live AI session in this repo right now (claude, codex, cursor…): what each is doing, which files it holds, recent notes. Call this before you start editing.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "huddle_announce_plan",
+        description: "BEFORE editing: say what you're about to do and every file you'll touch ('path', 'dir/' or 'path::symbol'). Leases the free ones to you; returns conflicts for any another live session holds — don't edit those.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                intent: { type: "string", description: "one line: what you're changing and why" },
+                touches: { type: "array", items: { type: "string" } },
+            },
+            required: ["intent", "touches"],
+        },
+    },
+    {
+        name: "huddle_check_overlap",
+        description: "Is anyone else holding these files? ('path', 'dir/', 'path::symbol'). Read-only — takes no lease.",
+        inputSchema: { type: "object", properties: { touches: { type: "array", items: { type: "string" } } }, required: ["touches"] },
+    },
+    {
+        name: "huddle_release",
+        description: "You're done with these files (omit `touches` = all of yours). Others waiting on them can go ahead.",
+        inputSchema: { type: "object", properties: { touches: { type: "array", items: { type: "string" } } } },
+    },
+    {
+        name: "huddle_note",
+        description: "Leave a note for the other sessions — everyone, or one by id/agent ('codex', 'claude#2'). E.g. 'I renamed User.email to User.mail, update your callers'. They see it on their next huddle_* call.",
+        inputSchema: {
+            type: "object",
+            properties: { body: { type: "string" }, to: { type: "string", description: "optional: a session id or agent name; default everyone" } },
+            required: ["body"],
+        },
+    },
+    {
+        name: "huddle_remember",
+        description: "Write to the repo's SHARED MEMORY (kind = decision | fact | gotcha) so every session, now and later, inherits it. Include 'why'.",
+        inputSchema: {
+            type: "object",
+            properties: { kind: { type: "string", enum: ["decision", "fact", "gotcha"] }, body: { type: "string" }, why: { type: "string" } },
+            required: ["kind", "body"],
+        },
+    },
+    {
+        name: "huddle_recall",
+        description: "Read shared memory: decisions, facts and gotchas other sessions recorded. Optional text filter.",
+        inputSchema: { type: "object", properties: { query: { type: "string" } } },
+    },
+];
+function branchOf(dir) {
+    try {
+        return execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+    }
+    catch {
+        return "";
+    }
+}
+export async function runLivePlug() {
+    const agent = process.env.HUDDLE_AGENT_ID ?? "agent";
+    // Claude sets CLAUDE_PROJECT_DIR for its MCP servers; others start us in the project.
+    const here = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    const sessionRoot = checkoutRoot(here) ?? here;
+    const repo = process.env.HUDDLE_REPO || mainRoot(here) || sessionRoot;
+    let st = null;
+    let sid = "";
+    let hello = null;
+    const sayHello = () => (hello ??= (async () => {
+        st = (await ensureLive(repo)).state;
+        const r = await liveCall(st, "hello", { agent, pid: process.ppid, root: sessionRoot, branch: branchOf(sessionRoot) });
+        if (r.status !== 200)
+            throw new Error(r.body?.error ?? "hello failed");
+        sid = r.body.id;
+    })().finally(() => (hello = null)));
+    /** One live verb, re-saying hello if the room restarted or forgot us. */
+    const live = async (verb, body) => {
+        for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+                if (!sid || !st)
+                    await sayHello();
+                const r = await liveCall(st, verb, body, sid);
+                if (r.status === 409 && r.body?.rehello) {
+                    sid = "";
+                    continue;
+                }
+                return r.body;
+            }
+            catch (e) {
+                st = null;
+                sid = "";
+                if (attempt)
+                    throw e;
+            }
+        }
+    };
+    const plain = async (method, p, body) => {
+        if (!sid || !st)
+            await sayHello();
+        return roomCall(st, method, p, body, sid);
+    };
+    const call = (name, a) => {
+        switch (name) {
+            case "huddle_peers":
+                return live("peers", {});
+            case "huddle_announce_plan":
+                return live("announce", { intent: a.intent, touches: a.touches ?? [] });
+            case "huddle_check_overlap":
+                return live("check", { touches: a.touches ?? [] });
+            case "huddle_release":
+                return live("release", { touches: a.touches });
+            case "huddle_note":
+                // Models sometimes name it message/text (seen live with claude -p): accept those.
+                return live("note", { body: a.body ?? a.message ?? a.text ?? a.note, to: a.to });
+            case "huddle_remember":
+                return plain("POST", "/remember", { kind: a.kind, body: a.body, why: a.why ?? "" });
+            case "huddle_recall":
+                return plain("GET", `/recall${a.query ? `?q=${encodeURIComponent(a.query)}` : ""}`, {});
+        }
+        throw new Error(`unknown tool: ${name}`);
+    };
+    const server = new Server({ name: "huddle", version: "0.1.0" }, { capabilities: { tools: {} }, instructions: LIVE_INSTRUCTIONS });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools.map((t) => ({ ...t })) }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        try {
+            const result = await call(req.params.name, req.params.arguments ?? {});
+            return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+        }
+        catch (e) {
+            // Never wedge the agent: say what's wrong and let it carry on.
+            return { isError: true, content: [{ type: "text", text: `Huddle live room unavailable (${e?.message ?? e}). Tell your user to run \`huddle up\`.` }] };
+        }
+    });
+    // Be visible to the other sessions from the moment this one opens.
+    sayHello().catch(() => { });
+    const beat = setInterval(() => void live("heartbeat", {}).catch(() => { }), Number(process.env.HUDDLE_LIVE_BEAT_MS ?? 15_000));
+    beat.unref();
+    let closing = false;
+    const goodbye = async () => {
+        if (closing)
+            return;
+        closing = true;
+        clearInterval(beat);
+        if (st && sid)
+            await liveCall(st, "bye", {}, sid, 1500).catch(() => { });
+        process.exit(0);
+    };
+    process.stdin.on("end", goodbye);
+    process.stdin.on("close", goodbye);
+    process.on("SIGTERM", goodbye);
+    process.on("SIGINT", goodbye);
+    await server.connect(new StdioServerTransport());
+}
+//# sourceMappingURL=plug.js.map

package/dist/attach/session.js

@@ -0,0 +1,172 @@
+// Attach mode, isolation: `huddle attach <agent>` opens the agent's normal
+// interactive CLI in its OWN worktree branch (huddle/<agent>-live-N), already
+// connected to the live room. Two sessions can then never overwrite each
+// other's files mid-edit; `huddle land` brings a session's branch home through
+// the merge engine (commit → tests → rebase → fast-forward), after you say so.
+//
+// Plus `huddle up` / `huddle down` / `huddle peers`, the human's view of the room.
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { getAdapter } from "../adapters/index.js";
+import { createWorktree, landMerge, prepareMerge, removeWorktree } from "../sandbox/worktree.js";
+import { C, dot } from "../ui/term.js";
+import { detectTestCmd } from "../ui/app.js";
+import { applyConnect, confirm, disconnect, livePlug, planConnect } from "./connect.js";
+import { ensureLive, liveCall, liveFiles, mainRoot, readLive, serveLive, stopLive, pingLive, checkoutRoot } from "./live.js";
+const attachFile = (repo) => path.join(liveFiles(repo).dir, "attach.json");
+export function readAttached(repo) {
+    try {
+        return JSON.parse(fs.readFileSync(attachFile(repo), "utf8"));
+    }
+    catch {
+        return [];
+    }
+}
+function writeAttached(repo, list) {
+    fs.mkdirSync(path.dirname(attachFile(repo)), { recursive: true });
+    fs.writeFileSync(attachFile(repo), JSON.stringify(list, null, 2));
+}
+function needRepo() {
+    const root = mainRoot();
+    if (!root) {
+        console.log(C.red("✗ Not a git repo.") + " Run this inside the repo your agents work in.");
+        process.exit(1);
+    }
+    return root;
+}
+/**
+ * Make a session worktree for `agent`, wired to the live room. Returns the
+ * worktree and the interactive command to run in it.
+ */
+export function prepareAttach(repo, agentId) {
+    const adapter = getAdapter(agentId);
+    if (!adapter)
+        throw new Error(`unknown agent "${agentId}"`);
+    const taken = new Set(readAttached(repo).map((e) => e.branch));
+    let n = 1;
+    while (taken.has(`huddle/${agentId}-live-${n}`) || fs.existsSync(path.join(repo, ".huddle", "worktrees", `${agentId}-live-${n}`)))
+        n++;
+    const wt = createWorktree(repo, agentId, `live-${n}`);
+    // The same project files `huddle connect` writes, inside the session's own worktree.
+    const plan = planConnect(wt.path, { agents: [agentId], repo, adapters: [adapter] });
+    applyConnect(wt.path, plan, repo);
+    const excludes = plan.filter((w) => w.action !== "skip").map((w) => w.file);
+    const cmd = [adapter.bin];
+    if (adapter.id === "codex") {
+        // A new worktree isn't a trusted project yet, and Codex ignores .codex/ in
+        // untrusted ones — so hand the Plug over with -c too (verified: `codex --help`).
+        const plug = livePlug(repo, "codex");
+        const env = `{${Object.entries(plug.env).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(",")}}`;
+        cmd.push("-c", `mcp_servers.huddle.command=${JSON.stringify(plug.command)}`, "-c", `mcp_servers.huddle.args=${JSON.stringify(plug.args)}`, "-c", `mcp_servers.huddle.env=${env}`);
+    }
+    writeAttached(repo, [...readAttached(repo), { agent: agentId, branch: wt.branch, path: wt.path, excludes, started_at: Date.now() }]);
+    return { wt, cmd, excludes };
+}
+export async function runAttach(args) {
+    const repo = needRepo();
+    const agentId = args.find((a) => !a.startsWith("-"));
+    if (!agentId) {
+        console.log(C.red("✗ Which agent?") + " huddle attach claude   (or codex, cursor, …)");
+        process.exit(1);
+    }
+    const passthrough = args.includes("--") ? args.slice(args.indexOf("--") + 1) : [];
+    const dirty = spawnSync("git", ["status", "--porcelain", "--untracked-files=no"], { cwd: repo, encoding: "utf8" }).stdout.trim();
+    if (dirty)
+        console.log(C.yellow("! You have uncommitted changes in the main checkout — the session starts from the last commit, without them."));
+    const { state } = await ensureLive(repo);
+    const { wt, cmd } = prepareAttach(repo, agentId);
+    console.log(`${dot(agentId)} ${C.bold(agentId)} in its own worktree ${C.faint(path.relative(repo, wt.path))} on ${C.bold(wt.branch)}`);
+    console.log(C.faint(`  live room ${state.url} · the others see it in huddle_peers · when it's done: huddle land ${wt.branch}\n`));
+    const r = spawnSync(cmd[0], [...cmd.slice(1), ...passthrough], { cwd: wt.path, stdio: "inherit" });
+    if (r.error)
+        console.log(C.red(`✗ couldn't start ${cmd[0]}: ${r.error.message}`));
+    const changed = spawnSync("git", ["status", "--porcelain"], { cwd: wt.path, encoding: "utf8" }).stdout.trim();
+    const ahead = spawnSync("git", ["rev-list", "--count", `HEAD..${wt.branch}`], { cwd: repo, encoding: "utf8" }).stdout.trim();
+    console.log(`\n${agentId} session ended. ${changed || (ahead && ahead !== "0") ? `Its work is on ${C.bold(wt.branch)} — ${C.bold(`huddle land ${wt.branch}`)} tests it and merges it.` : "No changes."}`);
+}
+/** `huddle land [branch|agent]`: the merge engine for one attach session. */
+export async function landSession(repo, e, opts = {}) {
+    const wt = { branch: e.branch, path: e.path };
+    const testCmd = opts.testCmd !== undefined ? opts.testCmd : detectTestCmd(e.path);
+    const prep = prepareMerge(repo, wt, testCmd, e.excludes, `huddle: ${e.agent} session (${e.branch})`);
+    // Attach mode has no scheduler to hand a conflict to a resolver agent: the
+    // session's own agent (or you) merges main in, then lands again.
+    if (prep.conflict)
+        return { merged: false, reason: `main changed the same lines — in ${e.path} run \`git merge main\`, resolve, then \`huddle land\` again` };
+    if (!prep.ok)
+        return { merged: false, reason: prep.reason };
+    if (!prep.diffstat.trim())
+        return { merged: false, reason: "nothing to land — the branch matches main" };
+    if (!opts.yes) {
+        console.log(prep.diffstat + "\n" + C.faint(prep.reason));
+        if (!(await confirm(`Merge ${e.branch} into your current branch?`)))
+            return { merged: false, reason: "not now", diffstat: prep.diffstat };
+    }
+    const land = landMerge(repo, wt);
+    if (land.merged && !opts.keep) {
+        disconnect(e.path, repo);
+        removeWorktree(repo, e.path);
+        spawnSync("git", ["branch", "-d", e.branch], { cwd: repo, stdio: "ignore" });
+        writeAttached(repo, readAttached(repo).filter((x) => x.branch !== e.branch));
+    }
+    return { merged: land.merged, reason: land.reason, diffstat: prep.diffstat };
+}
+export async function runLand(args) {
+    const repo = needRepo();
+    const list = readAttached(repo);
+    const want = args.find((a) => !a.startsWith("-"));
+    const here = checkoutRoot();
+    const pick = want
+        ? list.filter((e) => e.branch === want || e.agent === want || path.basename(e.path) === want)
+        : list.filter((e) => e.path === here).length
+            ? list.filter((e) => e.path === here)
+            : list;
+    if (!pick.length)
+        return void console.log(want ? C.red(`✗ no attach session "${want}"`) : "No attach sessions. Start one with huddle attach <agent>.");
+    if (pick.length > 1) {
+        console.log("Which one?\n" + pick.map((e) => `  huddle land ${e.branch}   ${C.faint(e.agent)}`).join("\n"));
+        return;
+    }
+    const r = await landSession(repo, pick[0], { yes: args.includes("--yes") || args.includes("-y"), keep: args.includes("--keep") });
+    console.log(r.merged ? `${C.green("✓")} landed ${pick[0].branch}` : `${C.yellow("·")} not landed: ${r.reason}`);
+    if (!r.merged)
+        process.exitCode = 1;
+}
+// ---- up / down / peers ---------------------------------------------------------
+export async function runUp(args) {
+    if (args.includes("--serve"))
+        return serveLive(process.env.HUDDLE_LIVE_ROOT || needRepo());
+    const repo = needRepo();
+    const { state, started } = await ensureLive(repo);
+    console.log(`${C.green("✓")} live room ${started ? "started" : "already running"} for ${C.bold(path.basename(repo))} ${C.faint(`(${state.url}, pid ${state.pid})`)}`);
+    const connected = fs.existsSync(path.join(liveFiles(repo).dir, "connect.json"));
+    if (!connected)
+        console.log(`  next: ${C.bold("huddle connect")} so your claude / codex / cursor sessions join it`);
+    console.log(C.faint("  huddle peers — who's in · huddle down — stop it"));
+}
+export async function runDown() {
+    const repo = needRepo();
+    console.log((await stopLive(repo)) ? `${C.green("✓")} live room stopped` : "No live room running for this repo.");
+}
+export async function runPeers() {
+    const repo = needRepo();
+    const st = readLive(repo);
+    if (!st || !(await pingLive(st)))
+        return void console.log(`No live room. ${C.bold("huddle up")} starts one.`);
+    // Anonymous: a person looking in isn't a session.
+    const r = await liveCall(st, "peers", {}, "");
+    const sessions = (r.body.sessions ?? []).filter((s) => !s.you);
+    console.log(`${C.violet("huddle")} live room · ${path.basename(repo)} · ${sessions.length} session${sessions.length === 1 ? "" : "s"}\n`);
+    for (const s of sessions) {
+        console.log(`  ${dot(s.agent)} ${C.bold(s.id.padEnd(12))} ${s.doing}`);
+        console.log(C.faint(`      ${s.branch || "?"} · ${s.worktree} · holds ${s.holds.length ? s.holds.join(", ") : "nothing"} · seen ${s.seen_s_ago}s ago`));
+    }
+    const notes = r.body.notes ?? [];
+    if (notes.length) {
+        console.log(`\n  ${C.bold("notes")}`);
+        for (const n of notes)
+            console.log(`  ${C.faint(`${n.ago} ago`.padStart(8))} ${n.from}${n.from_live ? "" : C.faint(" (gone)")} → ${n.to}: ${n.body}`);
+    }
+}
+//# sourceMappingURL=session.js.map