aegis-bridge 0.1.0

package/dist/swarm-monitor.js

@@ -0,0 +1,300 @@
+/**
+ * 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 = [];
+    windowsDisabledLogged = false;
+    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);
+            }
+        }
+    }
+    isWindowsPlatform() {
+        return process.platform === 'win32';
+    }
+    logWindowsDisabled() {
+        if (this.windowsDisabledLogged)
+            return;
+        console.info('SwarmMonitor disabled on Windows: tmux swarm sockets are not supported on this platform.');
+        this.windowsDisabledLogged = true;
+    }
+    /** Start the periodic scan loop. */
+    start() {
+        if (this.isWindowsPlatform()) {
+            this.logWindowsDisabled();
+            return;
+        }
+        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() {
+        if (this.isWindowsPlatform()) {
+            this.logWindowsDisabled();
+            this.lastResult = {
+                swarms: [],
+                totalSockets: 0,
+                totalTeammates: 0,
+                scannedAt: Date.now(),
+            };
+            return this.lastResult;
+        }
+        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());
+            // Match "tmux-<socketName>" directories (tmux socket dirs start with "tmux-")
+            const socketNames = [];
+            for (const entry of entries) {
+                if (entry.startsWith('tmux-')) {
+                    // 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) {
+        if (this.isWindowsPlatform()) {
+            const pid = this.extractPid(socketName);
+            return {
+                socketName,
+                pid,
+                parentSession: null,
+                teammates: [],
+                aggregatedStatus: 'no_teammates',
+                lastScannedAt: Date.now(),
+            };
+        }
+        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);
+    }
+}

package/dist/template-store.d.ts

@@ -0,0 +1,45 @@
+/**
+ * template-store.ts — Session template persistence.
+ *
+ * Manages saving, loading, and listing session templates.
+ * Templates are stored in ~/.config/aegis/templates.json
+ */
+export interface SessionTemplate {
+    id: string;
+    name: string;
+    description?: string;
+    workDir: string;
+    prompt?: string;
+    claudeCommand?: string;
+    env?: Record<string, string>;
+    stallThresholdMs?: number;
+    permissionMode?: 'default' | 'bypassPermissions' | 'plan' | 'acceptEdits' | 'dontAsk' | 'auto';
+    autoApprove?: boolean;
+    parentId?: string;
+    memoryKeys?: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface TemplateStore {
+    templates: Record<string, SessionTemplate>;
+}
+/**
+ * Create a new template from session parameters.
+ */
+export declare function createTemplate(input: Omit<SessionTemplate, 'id' | 'createdAt' | 'updatedAt'>): Promise<SessionTemplate>;
+/**
+ * Get a template by ID.
+ */
+export declare function getTemplate(id: string): Promise<SessionTemplate | null>;
+/**
+ * List all templates.
+ */
+export declare function listTemplates(): Promise<SessionTemplate[]>;
+/**
+ * Update a template.
+ */
+export declare function updateTemplate(id: string, updates: Partial<Omit<SessionTemplate, 'id' | 'createdAt'>>): Promise<SessionTemplate | null>;
+/**
+ * Delete a template.
+ */
+export declare function deleteTemplate(id: string): Promise<boolean>;

package/dist/template-store.js

@@ -0,0 +1,142 @@
+/**
+ * template-store.ts — Session template persistence.
+ *
+ * Manages saving, loading, and listing session templates.
+ * Templates are stored in ~/.config/aegis/templates.json
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+import { safeJsonParse } from './safe-json.js';
+function isSessionTemplate(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const t = value;
+    return (typeof t.id === 'string' &&
+        typeof t.name === 'string' &&
+        typeof t.workDir === 'string' &&
+        typeof t.createdAt === 'number' &&
+        typeof t.updatedAt === 'number');
+}
+function isTemplateStore(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    if (!record.templates || typeof record.templates !== 'object' || Array.isArray(record.templates))
+        return false;
+    for (const tmpl of Object.values(record.templates)) {
+        if (!isSessionTemplate(tmpl))
+            return false;
+    }
+    return true;
+}
+const CONFIG_DIR = join(homedir(), '.config', 'aegis');
+const TEMPLATES_FILE = join(CONFIG_DIR, 'templates.json');
+let cachedTemplates = {};
+let loaded = false;
+/**
+ * Load templates from disk, or initialize empty store.
+ */
+async function loadTemplates() {
+    if (loaded)
+        return cachedTemplates;
+    try {
+        if (existsSync(TEMPLATES_FILE)) {
+            const content = await readFile(TEMPLATES_FILE, 'utf-8');
+            const parsed = safeJsonParse(content, 'templates.json');
+            if (!parsed.ok || !isTemplateStore(parsed.data)) {
+                console.warn(`Failed to parse templates store: ${parsed.ok ? 'invalid structure' : parsed.error}`);
+                cachedTemplates = {};
+            }
+            else {
+                cachedTemplates = parsed.data.templates || {};
+            }
+        }
+        else {
+            cachedTemplates = {};
+        }
+    }
+    catch (err) {
+        console.error(`Failed to load templates from ${TEMPLATES_FILE}:`, err);
+        cachedTemplates = {};
+    }
+    loaded = true;
+    return cachedTemplates;
+}
+/**
+ * Persist templates to disk.
+ */
+async function saveTemplates() {
+    try {
+        if (!existsSync(CONFIG_DIR)) {
+            await mkdir(CONFIG_DIR, { recursive: true });
+        }
+        const store = { templates: cachedTemplates };
+        await writeFile(TEMPLATES_FILE, JSON.stringify(store, null, 2));
+    }
+    catch (err) {
+        console.error(`Failed to save templates to ${TEMPLATES_FILE}:`, err);
+        throw err;
+    }
+}
+/**
+ * Create a new template from session parameters.
+ */
+export async function createTemplate(input) {
+    await loadTemplates();
+    const template = {
+        ...input,
+        id: randomUUID(),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    };
+    cachedTemplates[template.id] = template;
+    await saveTemplates();
+    return template;
+}
+/**
+ * Get a template by ID.
+ */
+export async function getTemplate(id) {
+    await loadTemplates();
+    return cachedTemplates[id] ?? null;
+}
+/**
+ * List all templates.
+ */
+export async function listTemplates() {
+    await loadTemplates();
+    return Object.values(cachedTemplates).sort((a, b) => b.updatedAt - a.updatedAt);
+}
+/**
+ * Update a template.
+ */
+export async function updateTemplate(id, updates) {
+    await loadTemplates();
+    const template = cachedTemplates[id];
+    if (!template)
+        return null;
+    const updated = {
+        ...template,
+        ...updates,
+        id: template.id,
+        createdAt: template.createdAt,
+        updatedAt: Date.now(),
+    };
+    cachedTemplates[id] = updated;
+    await saveTemplates();
+    return updated;
+}
+/**
+ * Delete a template.
+ */
+export async function deleteTemplate(id) {
+    await loadTemplates();
+    if (!cachedTemplates[id])
+        return false;
+    delete cachedTemplates[id];
+    await saveTemplates();
+    return true;
+}

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;