aegis-bridge 2.2.2

package/dist/swarm-monitor.js

@@ -0,0 +1,267 @@
+/**
+ * swarm-monitor.ts — Monitors Claude Code swarm sockets for teammate sessions.
+ *
+ * Issue #81: Agent Swarm Awareness.
+ *
+ * When CC spawns teammates/subagents, it creates them in tmux with:
+ *   - Socket: -L claude-swarm-{pid} (isolated from main session)
+ *   - Window naming: teammate-{name}
+ *   - Env vars: CLAUDE_PARENT_SESSION_ID, --agent-id, --agent-name
+ *
+ * This module discovers those swarm sockets, lists their windows,
+ * cross-references with parent sessions, and tracks teammate status.
+ */
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { readdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+const execFileAsync = promisify(execFile);
+const TMUX_TIMEOUT_MS = 5_000;
+export const DEFAULT_SWARM_CONFIG = {
+    scanIntervalMs: 10_000,
+    socketGlobPattern: 'tmux-claude-swarm-*',
+};
+export class SwarmMonitor {
+    sessions;
+    config;
+    running = false;
+    lastResult = null;
+    timer = null;
+    eventHandlers = [];
+    constructor(sessions, config = DEFAULT_SWARM_CONFIG) {
+        this.sessions = sessions;
+        this.config = config;
+    }
+    /** Register an event handler for teammate lifecycle events. */
+    onEvent(handler) {
+        this.eventHandlers.push(handler);
+    }
+    emitEvent(event) {
+        for (const handler of this.eventHandlers) {
+            try {
+                handler(event);
+            }
+            catch (e) {
+                console.error('SwarmMonitor event handler error:', e);
+            }
+        }
+    }
+    /** Start the periodic scan loop. */
+    start() {
+        if (this.running)
+            return;
+        this.running = true;
+        void this.scan();
+        this.timer = setInterval(() => {
+            void this.scan();
+        }, this.config.scanIntervalMs);
+    }
+    /** Stop the periodic scan loop. */
+    stop() {
+        this.running = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    /** Get the most recent scan result. */
+    getLastResult() {
+        return this.lastResult;
+    }
+    /** Run a single scan and return the result. */
+    async scan() {
+        try {
+            const sockets = await this.discoverSwarmSockets();
+            // Issue #353: Inspect sockets in parallel to avoid N×timeout accumulation.
+            const results = await Promise.allSettled(sockets.map(socketName => this.inspectSwarmSocket(socketName)));
+            const swarms = [];
+            for (const result of results) {
+                if (result.status === 'fulfilled') {
+                    swarms.push(result.value);
+                }
+            }
+            this.lastResult = {
+                swarms,
+                totalSockets: sockets.length,
+                totalTeammates: swarms.reduce((sum, s) => sum + s.teammates.length, 0),
+                scannedAt: Date.now(),
+            };
+            this.detectChanges();
+            return this.lastResult;
+        }
+        catch (e) {
+            // Issue #353: Prevent unhandled rejection from setInterval fire-and-forget.
+            console.error('SwarmMonitor scan error:', e);
+            return this.lastResult ?? {
+                swarms: [],
+                totalSockets: 0,
+                totalTeammates: 0,
+                scannedAt: Date.now(),
+            };
+        }
+    }
+    /** Compare current scan result against previous to detect teammate changes. */
+    detectChanges() {
+        if (!this.lastResult)
+            return;
+        for (const swarm of this.lastResult.swarms) {
+            // Issue #353: Always update previous snapshot, even without a parent session,
+            // to prevent repeated spawn events on every scan cycle.
+            const prevSwarm = this.previousTeammates.get(swarm.socketName);
+            this.previousTeammates.set(swarm.socketName, swarm.teammates.map(t => ({ ...t })));
+            if (!swarm.parentSession)
+                continue;
+            const prevNames = new Set(prevSwarm?.map(t => t.windowName) ?? []);
+            // New teammates
+            for (const teammate of swarm.teammates) {
+                if (!prevNames.has(teammate.windowName) && teammate.status !== 'dead') {
+                    this.emitEvent({ type: 'teammate_spawned', swarm, teammate });
+                }
+            }
+            // Finished teammates (previously seen, now dead)
+            if (prevSwarm) {
+                for (const prev of prevSwarm) {
+                    const current = swarm.teammates.find(t => t.windowName === prev.windowName);
+                    if (!current) {
+                        // Teammate window gone entirely
+                        this.emitEvent({ type: 'teammate_finished', swarm, teammate: { ...prev, status: 'dead', alive: false } });
+                    }
+                    else if (prev.status === 'running' && current.status === 'dead') {
+                        this.emitEvent({ type: 'teammate_finished', swarm, teammate: current });
+                    }
+                }
+            }
+        }
+        // Clean up stale socket tracking
+        for (const socketName of this.previousTeammates.keys()) {
+            if (!this.lastResult.swarms.find(s => s.socketName === socketName)) {
+                this.previousTeammates.delete(socketName);
+            }
+        }
+    }
+    /** Snapshot of teammates from previous scan for diffing. */
+    previousTeammates = new Map();
+    /** Cached /tmp listing to avoid redundant I/O on every scan. */
+    cachedSocketNames = [];
+    cachedSocketAt = 0;
+    static SOCKET_CACHE_TTL_MS = 5_000;
+    /** Discover swarm socket directories in /tmp. */
+    async discoverSwarmSockets() {
+        try {
+            // Issue #353: Cache /tmp listing for 5s to avoid redundant I/O.
+            const now = Date.now();
+            if (this.cachedSocketNames.length > 0 && now - this.cachedSocketAt < SwarmMonitor.SOCKET_CACHE_TTL_MS) {
+                return this.cachedSocketNames;
+            }
+            const entries = await readdir(tmpdir());
+            const pattern = this.config.socketGlobPattern.replace('tmux-', '');
+            // Match "tmux-<socketName>" directories (tmux socket dirs start with "tmux-")
+            const socketNames = [];
+            for (const entry of entries) {
+                if (entry.startsWith('tmux-') && entry.includes(pattern)) {
+                    // Extract socket name: tmux-<socketName> → <socketName>
+                    const socketName = entry.slice(5); // remove "tmux-"
+                    // Verify it's a claude-swarm-* socket
+                    if (socketName.startsWith('claude-swarm-')) {
+                        socketNames.push(socketName);
+                    }
+                }
+            }
+            this.cachedSocketNames = socketNames;
+            this.cachedSocketAt = now;
+            return socketNames;
+        }
+        catch { /* tmux list-sockets failed — no swarm sockets visible */
+            return [];
+        }
+    }
+    /** Inspect a single swarm socket and return swarm info. */
+    async inspectSwarmSocket(socketName) {
+        const pid = this.extractPid(socketName);
+        const teammates = await this.listSwarmWindows(socketName);
+        const parentSession = this.findParentSession(pid, teammates);
+        const aggregatedStatus = this.computeAggregatedStatus(teammates);
+        return {
+            socketName,
+            pid,
+            parentSession,
+            teammates,
+            aggregatedStatus,
+            lastScannedAt: Date.now(),
+        };
+    }
+    /** Extract PID from socket name "claude-swarm-{pid}". */
+    extractPid(socketName) {
+        const match = socketName.match(/^claude-swarm-(\d+)$/);
+        return match ? parseInt(match[1], 10) : 0;
+    }
+    /** List all windows in a swarm socket. */
+    async listSwarmWindows(socketName) {
+        try {
+            const { stdout } = await execFileAsync('tmux', ['-L', socketName, 'list-windows', '-F', '#{window_id}\t#{window_name}\t#{pane_current_path}\t#{pane_current_command}'], { timeout: TMUX_TIMEOUT_MS });
+            const raw = stdout.trim();
+            if (!raw)
+                return [];
+            return raw.split('\n').filter(Boolean).map(line => {
+                const [windowId, windowName, cwd, paneCommand] = line.split('\t');
+                const cmd = (paneCommand || '').toLowerCase();
+                const alive = cmd === 'claude' || cmd === 'node';
+                const status = alive
+                    ? 'running'
+                    : (paneCommand === '' || paneCommand === 'bash' || paneCommand === 'zsh')
+                        ? 'idle'
+                        : 'dead';
+                return {
+                    windowId: windowId || '',
+                    windowName: windowName || '',
+                    cwd: cwd || '',
+                    paneCommand: paneCommand || '',
+                    alive,
+                    status,
+                };
+            });
+        }
+        catch {
+            // Socket may be stale (parent process died)
+            return [];
+        }
+    }
+    /** Find the parent Aegis session for a swarm by matching the CC process PID. */
+    findParentSession(pid, _teammates) {
+        if (pid === 0)
+            return null;
+        // Issue #353: Match swarm socket PID against session.ccPid.
+        // The swarm socket name (claude-swarm-{pid}) contains the PID of the parent CC process.
+        for (const session of this.sessions.listSessions()) {
+            if (session.ccPid === pid) {
+                return session;
+            }
+        }
+        return null;
+    }
+    /** Compute aggregated status for a swarm. */
+    computeAggregatedStatus(teammates) {
+        if (teammates.length === 0)
+            return 'no_teammates';
+        const allDead = teammates.every(t => t.status === 'dead');
+        if (allDead)
+            return 'all_dead';
+        const anyWorking = teammates.some(t => t.status === 'running');
+        if (anyWorking)
+            return 'some_working';
+        return 'all_idle';
+    }
+    /** Find a specific swarm by parent session ID. */
+    findSwarmByParentSessionId(sessionId) {
+        if (!this.lastResult)
+            return null;
+        return this.lastResult.swarms.find(s => s.parentSession?.id === sessionId) ?? null;
+    }
+    /** Find all swarms associated with any active session. */
+    findActiveSwarms() {
+        if (!this.lastResult)
+            return [];
+        return this.lastResult.swarms.filter(s => s.parentSession !== null && s.teammates.length > 0);
+    }
+}
+//# sourceMappingURL=swarm-monitor.js.map

package/dist/terminal-parser.d.ts

@@ -0,0 +1,16 @@
+/**
+ * terminal-parser.ts — Detects Claude Code UI state from tmux pane content.
+ *
+ * Port of CCBot's terminal_parser.py.
+ * Detects: permission prompts, plan mode, ask questions, status line.
+ */
+export type UIState = 'idle' | 'working' | 'compacting' | 'context_warning' | 'waiting_for_input' | 'permission_prompt' | 'plan_mode' | 'ask_question' | 'bash_approval' | 'settings' | 'error' | 'unknown';
+/** Detect the UI state from captured pane text. */
+export declare function detectUIState(paneText: string): UIState;
+/** Extract the interactive UI content if present. */
+export declare function extractInteractiveContent(paneText: string): {
+    content: string;
+    name: UIState;
+} | null;
+/** Parse the status line text (what CC is doing). */
+export declare function parseStatusLine(paneText: string): string | null;

package/dist/terminal-parser.js

@@ -0,0 +1,343 @@
+/**
+ * terminal-parser.ts — Detects Claude Code UI state from tmux pane content.
+ *
+ * Port of CCBot's terminal_parser.py.
+ * Detects: permission prompts, plan mode, ask questions, status line.
+ */
+const UI_PATTERNS = [
+    {
+        name: 'plan_mode',
+        top: [
+            /^\s*Would you like to proceed\?/,
+            /^\s*Claude has written up a plan/,
+        ],
+        bottom: [
+            /^\s*ctrl-g to edit in /,
+            /^\s*Esc to (cancel|exit)/,
+        ],
+        minGap: 2,
+    },
+    {
+        name: 'ask_question',
+        top: [/^\s*[☐✔☒]/],
+        bottom: [/^\s*Enter to select/],
+        minGap: 1,
+    },
+    {
+        name: 'permission_prompt',
+        top: [
+            /^\s*Do you want to proceed\?/,
+            /^\s*Do you want to make this edit/,
+            /^\s*Do you want to create \S/,
+            /^\s*Do you want to delete \S/,
+            /^\s*Do you want to allow Claude to make these changes/, // batch edit
+            /^\s*Do you want to allow Claude to use/, // MCP tool
+            /^\s*Do you want to trust this (project|workspace)/, // workspace trust
+            /^\s*Do you want to allow (reading|writing)/, // file scope
+            /^\s*Do you want to run this command/, // alt bash approval
+            /^\s*Do you want to allow writing to/, // file write scope
+            /^\s*Continue\?/, // continuation
+        ],
+        bottom: [/^\s*Esc to cancel/],
+        minGap: 2,
+    },
+    {
+        name: 'permission_prompt',
+        top: [/^\s*❯\s*1\.\s*Yes/],
+        bottom: [],
+        minGap: 2,
+    },
+    {
+        name: 'bash_approval',
+        top: [
+            /^\s*Bash command\s*$/,
+            /^\s*This command requires approval/,
+        ],
+        bottom: [/^\s*Esc to cancel/],
+        minGap: 2,
+    },
+    {
+        name: 'settings',
+        top: [
+            /^\s*Settings:.*tab to cycle/,
+            /^\s*Select model/,
+        ],
+        bottom: [
+            /^\s*Esc to cancel/,
+            /^\s*Esc to exit/,
+            /^\s*Enter to confirm/,
+            /^\s*Type to filter/,
+        ],
+        minGap: 2,
+    },
+    {
+        name: 'error',
+        top: [
+            /^Error:/,
+            /Rate limit/,
+            /Authentication failed/,
+            /overloaded/i,
+            /API error/,
+            /^429\b/,
+        ],
+        bottom: [/^\s*❯\s*$/],
+        minGap: 1,
+    },
+];
+// Spinner characters Claude Code uses (including braille spinners with TERM=xterm-256color)
+// Issue #102: CC also uses * (asterisk) and ● (bullet) for status lines like "* Perambulating…"
+const STATUS_SPINNERS = new Set([
+    '·', '✻', '✽', '✶', '✳', '✢', '*', '●',
+    '⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏',
+    '⣾', '⣽', '⣻', '⢿', '⡿', '⣟', '⣯', '⣷',
+]);
+/** Detect the UI state from captured pane text. */
+export function detectUIState(paneText) {
+    if (!paneText)
+        return 'unknown';
+    const lines = paneText.trim().split('\n');
+    // Check for interactive UI patterns first (highest priority)
+    for (const pattern of UI_PATTERNS) {
+        if (tryMatchPattern(lines, pattern)) {
+            return pattern.name;
+        }
+    }
+    // Check for working status — scan entire pane for active spinners
+    const statusText = parseStatusLine(paneText);
+    const hasActiveSpinner = hasSpinnerAnywhere(lines);
+    // Check for the prompt (❯) near the bottom
+    const hasPrompt = hasIdlePrompt(lines);
+    const hasChrome = hasChromeSeparator(lines);
+    if (statusText) {
+        // "Worked for Xs" = finished, not working; "Aborted" = CC was interrupted
+        if (/^Worked for/i.test(statusText) || /^Compacted/i.test(statusText) || /aborted/i.test(statusText)) {
+            return hasPrompt ? 'idle' : 'unknown';
+        }
+        // Active spinner text = working regardless of prompt
+        return 'working';
+    }
+    // Even without parseStatusLine match, if we see active spinners → working
+    if (hasActiveSpinner) {
+        return 'working';
+    }
+    // L30: Check for compacting state — CC shows "Compacting..." when compacting context
+    // Checked after working so active spinners take priority over compacting text
+    const compactingState = detectCompacting(lines);
+    if (compactingState)
+        return 'compacting';
+    // L31: Check for context window warning — CC shows "Context window X% full"
+    const contextWarning = detectContextWarning(lines);
+    if (contextWarning)
+        return 'context_warning';
+    if (hasPrompt) {
+        // L32: Differentiate idle (chrome separator present) vs waiting_for_input (no chrome)
+        return hasChrome ? 'idle' : 'waiting_for_input';
+    }
+    // Check for chrome separator (─────) near bottom = CC is loaded
+    if (hasChrome) {
+        return 'idle';
+    }
+    // L32: Check for waiting-for-input patterns without the idle separator
+    if (detectWaitingForInput(lines))
+        return 'waiting_for_input';
+    return 'unknown';
+}
+/** Check if any line in the pane has an active spinner character followed by working text. */
+function hasSpinnerAnywhere(lines) {
+    // Only check lines in the content area (not the very bottom few which are prompt/footer)
+    const searchEnd = Math.max(0, lines.length - 3);
+    for (let i = Math.max(0, lines.length - 20); i < searchEnd; i++) {
+        const stripped = lines[i].trim();
+        if (!stripped)
+            continue;
+        // Check for spinner characters at start of line, followed by text containing "…" or "..."
+        const firstChar = stripped[0];
+        if (STATUS_SPINNERS.has(firstChar) && stripped.length > 1) {
+            // For `*` (also a markdown bullet), require `* ` + ellipsis/dots to avoid false positives
+            if (firstChar === '*') {
+                if (stripped[1] !== ' ' || !(stripped.includes('…') || stripped.includes('...')))
+                    continue;
+            }
+            else if (!(stripped.includes('…') || stripped.includes('...') || /[^\s\u00a0]/.test(stripped.slice(1)))) {
+                continue;
+            }
+            // Exclude "Worked for" which is a completion indicator, and "Aborted" which means CC stopped
+            if (/^.Worked for/i.test(stripped) || /^.Compacted/i.test(stripped) || /aborted/i.test(stripped))
+                continue;
+            return true;
+        }
+    }
+    return false;
+}
+/** Check if the prompt ❯ is visible between chrome separators. */
+function hasIdlePrompt(lines) {
+    // Look for ❯ on its own line near the bottom, between two ─── separators
+    for (let i = Math.max(0, lines.length - 8); i < lines.length; i++) {
+        const stripped = lines[i].trim();
+        if (stripped === '❯' || stripped === '❯\u00a0' || stripped.startsWith('❯ ') || stripped.startsWith('❯\u00a0')) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Check if a chrome separator (─────) is present near the bottom of the pane. */
+function hasChromeSeparator(lines) {
+    for (let i = Math.max(0, lines.length - 10); i < lines.length; i++) {
+        const stripped = lines[i].trim();
+        if (stripped.length >= 20 && /^─+$/.test(stripped)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** L30: Detect compacting state — CC shows "Compacting..." when compacting context. */
+function detectCompacting(lines) {
+    // Check last 15 lines for compacting indicators
+    const searchStart = Math.max(0, lines.length - 15);
+    for (let i = searchStart; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (/compacting/i.test(line) && !/compacted/i.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** L31: Detect context window warning — CC shows "Context window X% full". */
+function detectContextWarning(lines) {
+    // Check last 15 lines for context window warnings
+    const searchStart = Math.max(0, lines.length - 15);
+    for (let i = searchStart; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (/context\s+window/i.test(line) && /(\d+)%/.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** L32: Detect waiting-for-input state — CC prompt without chrome separator. */
+function detectWaitingForInput(lines) {
+    // Look for prompt-like text near the bottom without the chrome separator
+    const searchStart = Math.max(0, lines.length - 8);
+    for (let i = searchStart; i < lines.length; i++) {
+        const stripped = lines[i].trim();
+        // ❯ with text (but not bare ❯ which is idle)
+        if ((stripped.startsWith('❯ ') || stripped.startsWith('❯\u00a0')) && stripped.length > 2) {
+            return true;
+        }
+        // CC asking questions like "What would you like to do?" near bottom
+        if (/^(What would you like|What do you want|How would you like|How should I)/i.test(stripped)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** Extract the interactive UI content if present. */
+export function extractInteractiveContent(paneText) {
+    if (!paneText)
+        return null;
+    const lines = paneText.trim().split('\n');
+    for (const pattern of UI_PATTERNS) {
+        const result = extractPattern(lines, pattern);
+        if (result)
+            return { content: result, name: pattern.name };
+    }
+    return null;
+}
+/** Parse the status line text (what CC is doing). */
+export function parseStatusLine(paneText) {
+    if (!paneText)
+        return null;
+    const lines = paneText.split('\n');
+    // Find chrome separator
+    let chromeIdx = null;
+    const searchStart = Math.max(0, lines.length - 10);
+    for (let i = searchStart; i < lines.length; i++) {
+        const stripped = lines[i].trim();
+        if (stripped.length >= 20 && /^─+$/.test(stripped)) {
+            chromeIdx = i;
+            break;
+        }
+    }
+    if (chromeIdx === null)
+        return null;
+    // Check lines above separator for spinner
+    for (let i = chromeIdx - 1; i > Math.max(chromeIdx - 10, -1); i--) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        if (STATUS_SPINNERS.has(line[0])) {
+            // For `*`, require `* ` + ellipsis/dots to avoid matching markdown bullets
+            if (line[0] === '*' && (line[1] !== ' ' || !(line.includes('…') || line.includes('...')))) {
+                // Not a real spinner line — skip
+                continue;
+            }
+            return line.slice(1).trim();
+        }
+        // Skip non-spinner lines (tool output between spinner and separator) and keep scanning
+    }
+    return null;
+}
+function tryMatchPattern(lines, pattern) {
+    // Only search the last 30 lines to avoid matching scrollback text
+    const searchStart = Math.max(0, lines.length - 30);
+    // Try each top match — don't give up after the first one fails to find a bottom
+    for (let t = searchStart; t < lines.length; t++) {
+        if (!pattern.top.some(re => re.test(lines[t])))
+            continue;
+        if (pattern.bottom.length === 0) {
+            const lastNonEmpty = findLastNonEmpty(lines, t + 1);
+            if (lastNonEmpty !== null && lastNonEmpty - t >= pattern.minGap) {
+                return true;
+            }
+            continue;
+        }
+        // Search for a matching bottom after this top
+        for (let b = t + 1; b < lines.length; b++) {
+            if (pattern.bottom.some(re => re.test(lines[b]))) {
+                if (b - t >= pattern.minGap) {
+                    return true;
+                }
+            }
+        }
+        // No matching bottom for this top — try next top match
+    }
+    return false;
+}
+function extractPattern(lines, pattern) {
+    let topIdx = null;
+    let bottomIdx = null;
+    // Only search the last 30 lines to avoid matching scrollback text
+    const searchStart = Math.max(0, lines.length - 30);
+    for (let i = searchStart; i < lines.length; i++) {
+        if (topIdx === null) {
+            if (pattern.top.some(re => re.test(lines[i]))) {
+                topIdx = i;
+            }
+        }
+        else if (pattern.bottom.length > 0 && pattern.bottom.some(re => re.test(lines[i]))) {
+            bottomIdx = i;
+            break;
+        }
+    }
+    if (topIdx === null)
+        return null;
+    if (pattern.bottom.length === 0) {
+        bottomIdx = findLastNonEmpty(lines, topIdx + 1);
+    }
+    if (bottomIdx === null || bottomIdx - topIdx < pattern.minGap)
+        return null;
+    return lines.slice(topIdx, bottomIdx + 1).join('\n').trimEnd();
+}
+function findLastNonEmpty(lines, from = 0) {
+    let last = null;
+    for (let i = from; i < lines.length; i++) {
+        if (lines[i].trim())
+            last = i;
+    }
+    return last;
+}
+//# sourceMappingURL=terminal-parser.js.map