kitty-hive 0.6.11 → 0.7.1

package/dist/index.js

@@ -10,8 +10,24 @@ import { join, dirname, basename, delimiter } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { homedir, hostname } from 'node:os';
 import { execSync } from 'node:child_process';
+import { buildPushMessage } from './preview.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
+// Build a properly-formatted push payload from operator-side CLI commands.
+// Operator has no agent identity, so `from` is empty (buildPushMessage drops
+// the "from X" suffix when empty). The push goes through the same code path
+// as MCP-side notifications, so receivers see consistent `[hive] xxx — call
+// hive-... for details.` hints regardless of whether the change came from
+// CLI or an agent calling an MCP tool.
+function operatorPush(opts) {
+    return buildPushMessage({
+        type: opts.type,
+        from: '',
+        from_agent_id: '',
+        event_id: opts.eventId,
+        team_id: opts.teamId,
+    });
+}
 const args = process.argv.slice(2);
 const command = args[0];
 function parseFlags(startIdx) {
@@ -70,6 +86,115 @@ async function cmdCodexChannel() {
     // Block until child exits (handled above)
     await new Promise(() => { });
 }
+// codex-pane <subcommand>: launcher-facing utilities for path B (visible codex
+// via `codex --remote`). Currently has one subcommand:
+//   ws --key <K> | --id <I>   Print the daemon's ws_url + thread_id as JSON,
+//                             so a launcher (kitty-kitty etc.) can spawn
+//                             `codex --remote <ws_url>` inside a pane. Polls
+//                             with exponential backoff until status='ready'
+//                             or hard timeout.
+async function cmdCodexPane() {
+    const sub = args[1];
+    if (sub !== 'ws') {
+        console.error('Usage: kitty-hive codex-pane ws --key <K> | --id <I> [--port 4123] [--timeout-ms 5000]');
+        process.exit(2);
+    }
+    const { port, dbPath } = parseFlags(1);
+    let agentKey = '';
+    let agentId = '';
+    let timeoutMs = 5000;
+    for (let i = 2; i < args.length; i++) {
+        if (args[i] === '--key' && args[i + 1]) {
+            agentKey = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--id' && args[i + 1]) {
+            agentId = args[i + 1];
+            i++;
+        }
+        else if (args[i] === '--timeout-ms' && args[i + 1]) {
+            timeoutMs = parseInt(args[i + 1], 10) || 5000;
+            i++;
+        }
+        else if (args[i] === '--port' || args[i] === '-p') {
+            i++;
+        }
+        else if (args[i] === '--db') {
+            i++;
+        }
+    }
+    if (!agentKey && !agentId) {
+        console.error('Usage: kitty-hive codex-pane ws --key <K> | --id <I>');
+        process.exit(2);
+    }
+    // Backoff: 200ms / 400 / 800 / 1600 / 3200 / cap at remaining time
+    const start = Date.now();
+    const delays = [200, 400, 800, 1600, 3200];
+    let attempt = 0;
+    let lastBody = null;
+    while (true) {
+        try {
+            const url = new URL(`http://127.0.0.1:${port}/admin/codex-daemons`);
+            const res = await fetch(url);
+            if (res.ok) {
+                const { daemons } = await res.json();
+                const match = daemons.find(d => (agentId && d.agent_id === agentId) ||
+                    // No external_key in admin snapshot, so we have to look up by id.
+                    // For agent_key path, resolve via DB locally.
+                    false);
+                let chosen = match;
+                if (!chosen && agentKey) {
+                    // Resolve key → id via DB (use the same dbPath as serve uses)
+                    const db = initDB(dbPath);
+                    const row = db.prepare('SELECT id FROM agents WHERE external_key = ?').get(agentKey);
+                    if (row)
+                        chosen = daemons.find(d => d.agent_id === row.id);
+                }
+                if (chosen) {
+                    if (chosen.ready && chosen.ws_url && chosen.thread_id) {
+                        console.log(JSON.stringify({
+                            status: 'ready',
+                            agent_id: chosen.agent_id,
+                            display_name: chosen.display_name,
+                            ws_url: chosen.ws_url,
+                            thread_id: chosen.thread_id,
+                            pid: chosen.pid,
+                        }));
+                        process.exit(0);
+                    }
+                    // daemon row exists but its codex app-server hasn't reported ready
+                    // back yet — wrap in the contract shape so callers can switch on
+                    // `status` consistently (no raw daemon snapshot leaking out).
+                    lastBody = {
+                        status: 'starting',
+                        agent_id: chosen.agent_id,
+                        display_name: chosen.display_name,
+                        pid: chosen.pid,
+                        uptime_ms: chosen.uptime_ms,
+                        restart_count: chosen.restart_count,
+                    };
+                }
+                else {
+                    lastBody = { status: 'not_supervised', error: 'no daemon for that agent_key/id (agent not registered with tool=codex, or supervisor not running)' };
+                }
+            }
+        }
+        catch (err) {
+            lastBody = { status: 'error', error: String(err?.message || err) };
+        }
+        if (Date.now() - start >= timeoutMs)
+            break;
+        const delay = delays[Math.min(attempt, delays.length - 1)];
+        attempt++;
+        await new Promise(r => setTimeout(r, Math.min(delay, Math.max(50, timeoutMs - (Date.now() - start)))));
+    }
+    // Timeout — emit what we last saw, exit non-zero
+    console.log(JSON.stringify(lastBody || {
+        status: 'timeout',
+        error: `daemon did not reach ready within ${timeoutMs}ms`,
+    }));
+    process.exit(1);
+}
 const INIT_TOOLS = ['claude', 'cursor', 'vscode'];
 // codex is config'd via its own CLI (`codex mcp add ... --url ...`) writing
 // to ~/.codex/config.toml — we shell out instead of editing toml ourselves.
@@ -381,6 +506,36 @@ async function cmdStatus() {
                 console.log(renderTable(['ID', 'NAME', 'PEER', 'STATUS', 'LAST SEEN'], rrows, '   '));
             }
         }
+        // Codex daemon supervisor snapshot — fetched live via admin endpoint
+        // so we get the actual running state, not just the DB intent.
+        try {
+            const daemonsRes = await fetch(`http://localhost:${port}/admin/codex-daemons`);
+            if (daemonsRes.ok) {
+                const { daemons } = await daemonsRes.json();
+                const codexAgents = agents.filter((a) => a.tool === 'codex');
+                if (codexAgents.length > 0 || daemons.length > 0) {
+                    console.log(`\n🤖 Codex daemons`);
+                    const liveByName = new Map(daemons.map(d => [d.display_name, d]));
+                    const rows = codexAgents.map((a) => {
+                        const live = liveByName.get(a.display_name);
+                        if (live) {
+                            const min = Math.floor(live.uptime_ms / 60000);
+                            const uptimeStr = min < 60 ? `${min}m` : `${Math.floor(min / 60)}h${min % 60}m`;
+                            return [a.display_name, `pid=${live.pid}`, `up ${uptimeStr}`, `restarts=${live.restart_count}`];
+                        }
+                        return [a.display_name, '(not running)', '', ''];
+                    });
+                    // Also surface zombie daemons (running but agent row deleted)
+                    for (const d of daemons) {
+                        if (!codexAgents.some((a) => a.display_name === d.display_name)) {
+                            rows.push([`${d.display_name} ⚠️ orphan`, `pid=${d.pid}`, '', `restarts=${d.restart_count}`]);
+                        }
+                    }
+                    console.log(renderTable(['NAME', 'PID', 'UPTIME', 'RESTARTS'], rows, '   '));
+                }
+            }
+        }
+        catch { /* serve might not expose admin yet — silently skip */ }
     }
     catch {
         console.log(`\n⚠️  Cannot read database`);
@@ -409,7 +564,7 @@ async function cmdDbClear() {
     console.log('✅ Database cleared.');
 }
 async function cmdAgentRemove() {
-    const { dbPath } = parseFlags(1);
+    const { dbPath, port } = parseFlags(1);
     // Flags: --key <K>            look up by external_key (idempotent: missing = exit 0)
     //        --yes                skip confirmation (scripts)
     //        --transfer-to <a>    transfer hosted teams to this agent before deleting
@@ -590,12 +745,10 @@ async function cmdAgentRemove() {
                 reason: 'agent-remove',
             });
             try {
-                await sessionsMod.notifyTeamMembers(r.team.id, undefined, JSON.stringify({
+                await sessionsMod.notifyTeamMembers(r.team.id, undefined, operatorPush({
                     type: 'team-host-transfer',
-                    team_id: r.team.id,
-                    team_name: r.team.name,
-                    from: name,
-                    to: transferAgent.display_name,
+                    teamId: r.team.id,
+                    eventId: `team:${r.team.id}:host-transfer:${Date.now()}`,
                 }));
             }
             catch { /* push best-effort */ }
@@ -621,6 +774,27 @@ async function cmdAgentRemove() {
     db.prepare('DELETE FROM teams WHERE host_agent_id = ?').run(agent.id);
     db.prepare('DELETE FROM agents WHERE id = ?').run(agent.id);
     console.log(`✅ Removed agent "${name}".`);
+    // Tell the live supervisor (if any) to kill the daemon for this agent.
+    // Without this, a deleted tool=codex agent's daemon keeps running on its
+    // old ws_url, causing routing schisms when another agent later self-
+    // registers with the same name. Mirrors the agent-register notify path.
+    // Best-effort: failures silently ignored — agent row is already gone.
+    try {
+        const notifyRes = await fetch(`http://127.0.0.1:${port}/admin/notify-agent-removed`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ agent_id: agent.id }),
+            signal: AbortSignal.timeout(2000),
+        });
+        if (notifyRes.ok) {
+            const { killed } = await notifyRes.json();
+            if (killed)
+                console.error(`   → supervisor killed codex daemon`);
+        }
+    }
+    catch {
+        // serve not running, or admin endpoint not reachable — fine, no daemon to kill anyway
+    }
 }
 async function cmdAgentRegister() {
     // Idempotent upsert by external_key. Designed for `spawn('kitty-hive',
@@ -633,6 +807,7 @@ async function cmdAgentRegister() {
     let roles = '';
     let tool = '';
     let agentIdOverride = '';
+    let projectDir = '';
     for (let i = 2; i < args.length; i++) {
         if (args[i] === '--key' && args[i + 1]) {
             externalKey = args[i + 1];
@@ -658,12 +833,18 @@ async function cmdAgentRegister() {
             agentIdOverride = args[i + 1];
             i++;
         }
+        else if (args[i] === '--project-dir' && args[i + 1]) {
+            projectDir = args[i + 1];
+            i++;
+        }
     }
     if (!externalKey && !agentIdOverride && !displayName) {
-        console.error('Usage: kitty-hive agent register --key <K> --display-name <N> [--roles R] [--tool T]');
+        console.error('Usage: kitty-hive agent register --key <K> --display-name <N> [--roles R] [--tool T] [--project-dir P]');
         console.error('  All three of --key/--id/--display-name optional, but at least one required.');
+        console.error('  --project-dir: working directory hint for codex agents (passed as cwd when supervisor spawns codex app-server).');
         process.exit(1);
     }
+    const { port } = parseFlags(1);
     initDB(dbPath);
     const { handleStart } = await import('./tools/start.js');
     try {
@@ -673,11 +854,37 @@ async function cmdAgentRegister() {
             name: displayName || undefined,
             roles: roles || undefined,
             tool: tool || undefined,
+            projectDir: projectDir || undefined,
         });
         // Stdout: one line, just the agent_id (script-friendly)
         console.log(result.agent_id);
         // Stderr: human context
-        console.error(`✅ ${result.display_name} (${result.agent_id})${externalKey ? ` key=${externalKey}` : ''}`);
+        console.error(`✅ ${result.display_name} (${result.agent_id})${externalKey ? ` key=${externalKey}` : ''}${projectDir ? ` cwd=${projectDir}` : ''}`);
+        // If serve is running and we registered a tool=codex agent, notify the
+        // supervisor so it can spawn a daemon for it on the fly (without this,
+        // dynamic spawn requires a serve restart because the in-process
+        // onAgentCreated hook lives in serve's process, not this CLI process).
+        // Best-effort: failures are silently ignored — agent row is already written.
+        if (tool === 'codex') {
+            try {
+                const notifyRes = await fetch(`http://127.0.0.1:${port}/admin/notify-agent-created`, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ agent_id: result.agent_id }),
+                    // Short timeout: register shouldn't block waiting for a dead serve
+                    signal: AbortSignal.timeout(2000),
+                });
+                if (notifyRes.ok) {
+                    const { spawned } = await notifyRes.json();
+                    if (spawned)
+                        console.error(`   → supervisor spawning codex daemon`);
+                }
+            }
+            catch {
+                // serve not running, or admin endpoint not reachable — that's fine,
+                // daemon will spawn at the next serve boot.
+            }
+        }
     }
     catch (err) {
         console.error(`Failed: ${err.message ?? err}`);
@@ -893,12 +1100,10 @@ async function cmdTeamTransfer() {
     });
     try {
         const sessionsMod = await import('./sessions.js');
-        await sessionsMod.notifyTeamMembers(team.id, undefined, JSON.stringify({
+        await sessionsMod.notifyTeamMembers(team.id, undefined, operatorPush({
             type: 'team-host-transfer',
-            team_id: team.id,
-            team_name: team.name,
-            from: currentHostName,
-            to: newHost.display_name,
+            teamId: team.id,
+            eventId: `team:${team.id}:host-transfer:${Date.now()}`,
         }));
     }
     catch { /* push best-effort */ }
@@ -1026,17 +1231,213 @@ async function cmdTeamKick() {
     });
     try {
         const sessionsMod = await import('./sessions.js');
-        await sessionsMod.notifyTeamMembers(team.id, undefined, JSON.stringify({
+        await sessionsMod.notifyTeamMembers(team.id, undefined, operatorPush({
             type: 'team-kick',
-            team_id: team.id,
-            team_name: team.name,
-            agent_id: target.id,
-            display_name: target.display_name,
+            teamId: team.id,
+            eventId: `team:${team.id}:kick:${Date.now()}`,
         }));
     }
     catch { /* push best-effort */ }
     console.log(`✅ Removed "${target.display_name}" from "${team.name}".`);
 }
+// Manage a team's rules (free-form markdown shown to all members on hive_start
+// and hive_team_info). Operator-side — no MCP tool exposes mutation, so rules
+// can't be hijacked by a member. Subcommands: show / edit / set / clear.
+async function cmdTeamRules() {
+    const { dbPath } = parseFlags(2);
+    let teamArg = args[2] && !args[2].startsWith('-') ? args[2] : '';
+    let action = args[3] && !args[3].startsWith('-') ? args[3] : '';
+    const db = initDB(dbPath);
+    const dbMod = await import('./db.js');
+    // --- Resolve team (interactive picker when omitted in a TTY) ---
+    if (!teamArg) {
+        if (!isInteractive()) {
+            console.log('Usage:');
+            console.log('  kitty-hive team rules <team>                show   (alias: omit subcommand)');
+            console.log('  kitty-hive team rules <team> show');
+            console.log('  kitty-hive team rules <team> edit                  Open $EDITOR for interactive edit');
+            console.log('  kitty-hive team rules <team> set --file <path>     Replace from file');
+            console.log('  kitty-hive team rules <team> set --text "..."      Replace from string');
+            console.log('  kitty-hive team rules <team> clear');
+            process.exit(1);
+        }
+        const teams = dbMod.listTeams(false);
+        if (teams.length === 0) {
+            console.log('No teams.');
+            process.exit(0);
+        }
+        teamArg = await askSelect({
+            message: 'Which team?',
+            options: teams.map(t => ({
+                value: t.id,
+                label: t.name,
+                hint: t.rules ? `${t.rules.length} chars of rules` : '(no rules)',
+            })),
+        });
+    }
+    const team = dbMod.getTeamById(teamArg) || dbMod.getTeamByName(teamArg);
+    if (!team) {
+        console.error(`Team "${teamArg}" not found.`);
+        process.exit(1);
+    }
+    // --- Resolve action (interactive picker when omitted in a TTY) ---
+    if (!action) {
+        if (!isInteractive()) {
+            action = 'show'; // default in scripts: just print
+        }
+        else {
+            action = await askSelect({
+                message: `Rules for "${team.name}" — what do you want to do?`,
+                options: [
+                    { value: 'show', label: 'Show current rules' },
+                    { value: 'edit', label: 'Edit in $EDITOR' },
+                    { value: 'set', label: 'Replace from file or text' },
+                    { value: 'clear', label: 'Clear rules' },
+                ],
+                initialValue: team.rules ? 'show' : 'edit',
+            });
+        }
+    }
+    if (action === 'show') {
+        if (!team.rules) {
+            console.log(`Team "${team.name}" has no rules set.`);
+            console.log(`Set them with: kitty-hive team rules ${team.name} edit`);
+            return;
+        }
+        console.log(`# Rules for team "${team.name}"\n`);
+        console.log(team.rules);
+        return;
+    }
+    if (action === 'clear') {
+        let assumeYes = false;
+        for (let i = 4; i < args.length; i++)
+            if (args[i] === '--yes' || args[i] === '-y')
+                assumeYes = true;
+        if (!assumeYes && isInteractive()) {
+            const ok = await askConfirm({ message: `Clear rules for team "${team.name}"?`, initialValue: false });
+            if (!ok) {
+                console.log('Cancelled.');
+                process.exit(0);
+            }
+        }
+        dbMod.setTeamRules(team.id, '');
+        try {
+            const sessionsMod = await import('./sessions.js');
+            await sessionsMod.notifyTeamMembers(team.id, undefined, operatorPush({
+                type: 'team-rules-update',
+                teamId: team.id,
+                eventId: `team:${team.id}:rules-update:${Date.now()}`,
+            }));
+        }
+        catch { /* best-effort */ }
+        console.log(`✅ Cleared rules for "${team.name}".`);
+        return;
+    }
+    // Helper: persist new rules + push notification (used by set + edit branches)
+    const applyRules = async (content, label) => {
+        dbMod.setTeamRules(team.id, content);
+        try {
+            const sessionsMod = await import('./sessions.js');
+            await sessionsMod.notifyTeamMembers(team.id, undefined, operatorPush({
+                type: 'team-rules-update',
+                teamId: team.id,
+                eventId: `team:${team.id}:rules-update:${Date.now()}`,
+            }));
+        }
+        catch { /* best-effort */ }
+        console.log(`✅ ${label === 'set' ? 'Set' : 'Updated'} rules for "${team.name}" (${content.length} chars).`);
+    };
+    if (action === 'set') {
+        let filePath = '';
+        let text = null;
+        for (let i = 4; i < args.length; i++) {
+            if (args[i] === '--file' && args[i + 1]) {
+                filePath = args[i + 1];
+                i++;
+            }
+            else if (args[i] === '--text' && args[i + 1]) {
+                text = args[i + 1];
+                i++;
+            }
+        }
+        if (filePath) {
+            if (!existsSync(filePath)) {
+                console.error(`File not found: ${filePath}`);
+                process.exit(1);
+            }
+            await applyRules(readFileSync(filePath, 'utf8'), 'set');
+            return;
+        }
+        if (text !== null) {
+            await applyRules(text, 'set');
+            return;
+        }
+        // No flags — interactive picker for source (editor / file / text)
+        if (!isInteractive()) {
+            console.error('Usage: kitty-hive team rules <team> set --file <path>  |  --text "..."');
+            process.exit(1);
+        }
+        const source = await askSelect({
+            message: 'Where should the new rules come from?',
+            options: [
+                { value: 'editor', label: 'Open $EDITOR (multi-line markdown)' },
+                { value: 'file', label: 'Load from file' },
+                { value: 'text', label: 'Type/paste a one-liner' },
+            ],
+            initialValue: 'editor',
+        });
+        if (source === 'editor') {
+            action = 'edit'; // promote — edit handler below picks it up
+        }
+        else if (source === 'file') {
+            const p = await askText({
+                message: 'Path to file?',
+                validate: (v) => ((v ?? '').trim().length === 0 ? 'Path required' : undefined),
+            });
+            if (!existsSync(p)) {
+                console.error(`File not found: ${p}`);
+                process.exit(1);
+            }
+            await applyRules(readFileSync(p, 'utf8'), 'set');
+            return;
+        }
+        else {
+            const oneliner = await askText({
+                message: 'New rules (single line):',
+                validate: (v) => ((v ?? '').trim().length === 0 ? 'Rules cannot be empty (use clear instead)' : undefined),
+            });
+            await applyRules(oneliner, 'set');
+            return;
+        }
+    }
+    if (action === 'edit') {
+        if (!isInteractive()) {
+            console.error('`team rules <team> edit` requires a TTY. Use --file or --text in non-interactive contexts.');
+            process.exit(1);
+        }
+        const editor = process.env.EDITOR || process.env.VISUAL || (process.platform === 'win32' ? 'notepad' : 'vi');
+        const tmpPath = join('/tmp', `kitty-hive-team-rules-${team.id.slice(-12)}-${Date.now()}.md`);
+        writeFileSync(tmpPath, team.rules || `# Rules for team "${team.name}"\n\n(Write the team's rules here. Save and exit to apply; quit without saving to abort.)\n`);
+        try {
+            execSync(`${editor} "${tmpPath}"`, { stdio: 'inherit' });
+            const newContent = readFileSync(tmpPath, 'utf8');
+            if (newContent === team.rules) {
+                console.log('No changes — rules unchanged.');
+                return;
+            }
+            await applyRules(newContent, 'updated');
+        }
+        finally {
+            try {
+                unlinkSync(tmpPath);
+            }
+            catch { /* ignore */ }
+        }
+        return;
+    }
+    console.error(`Unknown action: "${action}". Use show / edit / set / clear.`);
+    process.exit(1);
+}
 // --- Node config ---
 function getConfigPath() {
     return join(homedir(), '.kitty-hive', 'config.json');
@@ -1978,6 +2379,9 @@ Subcommands:
                                                     --add-member auto-joins target if not yet a member.
   kick [<team>] [<agent>] [--yes]                   Remove an agent from a team (operator-side).
                                                     Cannot kick the host — transfer first.
+  rules <team> [show|edit|set|clear]                Manage the team's rules / charter (free-form
+                                                    markdown; surfaced to all members on hive_start
+                                                    + hive_team_info). Default: show.
 
 Note: agents normally manage teams via the hive-team-* MCP tools.
 This group is for operator-level maintenance (e.g. before removing a host agent).`);
@@ -2067,6 +2471,9 @@ switch (command) {
     case 'codex-channel':
         run(cmdCodexChannel);
         break;
+    case 'codex-pane':
+        run(cmdCodexPane);
+        break;
     case 'status':
         run(cmdStatus);
         break;
@@ -2100,6 +2507,9 @@ switch (command) {
             case 'kick':
                 run(cmdTeamKick);
                 break;
+            case 'rules':
+                run(cmdTeamRules);
+                break;
             default:
                 showTeamHelp();
                 break;