agent-relay 1.6.0 → 2.0.4

package/dist/wrapper/base-wrapper.js

@@ -1,538 +0,0 @@
-/**
- * BaseWrapper - Abstract base class for agent wrappers
- *
- * Provides shared functionality between TmuxWrapper and PtyWrapper:
- * - Message queue management and deduplication
- * - Spawn/release command parsing and execution
- * - Continuity integration (agent ID, summary saving)
- * - Relay command handling
- * - Line joining for multi-line commands
- *
- * Subclasses implement:
- * - start() - Initialize and start the agent process
- * - stop() - Stop the agent process
- * - performInjection() - Inject content into the agent
- * - getCleanOutput() - Get cleaned output for parsing
- */
-import { EventEmitter } from 'node:events';
-import { RelayClient } from './client.js';
-import { isPlaceholderTarget } from './parser.js';
-import { getDefaultRelayPrefix, detectCliType, createInjectionMetrics, } from './shared.js';
-import { DEFAULT_IDLE_BEFORE_INJECT_MS, DEFAULT_IDLE_CONFIDENCE_THRESHOLD, } from '../config/relay-config.js';
-import { getContinuityManager, parseContinuityCommand, hasContinuityCommand, } from '../continuity/index.js';
-import { UniversalIdleDetector } from './idle-detector.js';
-import { StuckDetector } from './stuck-detector.js';
-/**
- * Abstract base class for agent wrappers
- */
-export class BaseWrapper extends EventEmitter {
-    config;
-    client;
-    relayPrefix;
-    cliType;
-    running = false;
-    // Message queue state
-    messageQueue = [];
-    sentMessageHashes = new Set();
-    isInjecting = false;
-    receivedMessageIds = new Set();
-    injectionMetrics = createInjectionMetrics();
-    // Spawn/release state
-    processedSpawnCommands = new Set();
-    processedReleaseCommands = new Set();
-    pendingFencedSpawn = null;
-    // Continuity state
-    continuity;
-    agentId;
-    processedContinuityCommands = new Set();
-    sessionEndProcessed = false;
-    sessionEndData;
-    lastSummaryRawContent = '';
-    // Universal idle detection (shared across all wrapper types)
-    idleDetector;
-    // Stuck detection (extended idle, error loops, output loops)
-    stuckDetector;
-    constructor(config) {
-        super();
-        this.config = config;
-        this.relayPrefix = config.relayPrefix ?? getDefaultRelayPrefix();
-        this.cliType = config.cliType ?? detectCliType(config.command);
-        // Initialize relay client with full config
-        this.client = new RelayClient({
-            agentName: config.name,
-            socketPath: config.socketPath,
-            cli: this.cliType,
-            task: config.task,
-            workingDirectory: config.cwd,
-            quiet: true,
-        });
-        // Initialize continuity manager (skip for spawned agents that don't need session recovery)
-        if (!config.skipContinuity) {
-            this.continuity = getContinuityManager({ defaultCli: this.cliType });
-        }
-        // Initialize universal idle detector for robust injection timing
-        this.idleDetector = new UniversalIdleDetector({
-            minSilenceMs: config.idleBeforeInjectMs ?? DEFAULT_IDLE_BEFORE_INJECT_MS,
-            confidenceThreshold: config.idleConfidenceThreshold ?? DEFAULT_IDLE_CONFIDENCE_THRESHOLD,
-        });
-        // Initialize stuck detector for extended idle and loop detection
-        this.stuckDetector = new StuckDetector();
-        this.stuckDetector.on('stuck', (event) => {
-            console.warn(`[${config.name}] Agent stuck: ${event.reason} - ${event.details}`);
-            this.emit('stuck', event);
-        });
-        this.stuckDetector.on('unstuck', () => {
-            console.log(`[${config.name}] Agent unstuck`);
-            this.emit('unstuck');
-        });
-        // Set up message handler for direct messages
-        this.client.onMessage = (from, payload, messageId, meta, originalTo) => {
-            this.handleIncomingMessage(from, payload, messageId, meta, originalTo);
-        };
-        // Set up channel message handler
-        this.client.onChannelMessage = (from, channel, body, envelope) => {
-            this.handleIncomingChannelMessage(from, channel, body, envelope);
-        };
-    }
-    // =========================================================================
-    // Common getters
-    // =========================================================================
-    get isRunning() {
-        return this.running;
-    }
-    get name() {
-        return this.config.name;
-    }
-    getAgentId() {
-        return this.agentId;
-    }
-    getInjectionMetrics() {
-        const total = this.injectionMetrics.total;
-        const successes = this.injectionMetrics.successFirstTry + this.injectionMetrics.successWithRetry;
-        const successRate = total > 0
-            ? (successes / total) * 100
-            : 100;
-        return {
-            ...this.injectionMetrics,
-            successRate,
-        };
-    }
-    get pendingMessageCount() {
-        return this.messageQueue.length;
-    }
-    // =========================================================================
-    // Idle detection (shared across all wrapper types)
-    // =========================================================================
-    /**
-     * Set the PID for process state inspection (Linux only).
-     * Call this after the agent process is started.
-     */
-    setIdleDetectorPid(pid) {
-        this.idleDetector.setPid(pid);
-    }
-    /**
-     * Start stuck detection. Call after the agent process starts.
-     */
-    startStuckDetection() {
-        this.stuckDetector.start();
-    }
-    /**
-     * Stop stuck detection. Call when the agent process stops.
-     */
-    stopStuckDetection() {
-        this.stuckDetector.stop();
-    }
-    /**
-     * Check if the agent is currently stuck.
-     */
-    isStuck() {
-        return this.stuckDetector.getIsStuck();
-    }
-    /**
-     * Get the reason for being stuck (if stuck).
-     */
-    getStuckReason() {
-        return this.stuckDetector.getStuckReason();
-    }
-    /**
-     * Feed output to the idle and stuck detectors.
-     * Call this whenever new output is received from the agent.
-     */
-    feedIdleDetectorOutput(output) {
-        this.idleDetector.onOutput(output);
-        this.stuckDetector.onOutput(output);
-    }
-    /**
-     * Check if the agent is idle and ready for injection.
-     * Returns idle state with confidence signals.
-     */
-    checkIdleForInjection() {
-        return this.idleDetector.checkIdle({
-            minSilenceMs: this.config.idleBeforeInjectMs ?? 1500,
-        });
-    }
-    /**
-     * Wait for the agent to become idle.
-     * Returns when idle or after timeout.
-     */
-    async waitForIdleState(timeoutMs = 30000, pollMs = 200) {
-        return this.idleDetector.waitForIdle(timeoutMs, pollMs);
-    }
-    // =========================================================================
-    // Message handling
-    // =========================================================================
-    /**
-     * Handle incoming message from relay
-     */
-    handleIncomingMessage(from, payload, messageId, meta, originalTo) {
-        // Deduplicate by message ID
-        if (this.receivedMessageIds.has(messageId))
-            return;
-        this.receivedMessageIds.add(messageId);
-        // Limit dedup set size
-        if (this.receivedMessageIds.size > 1000) {
-            const oldest = this.receivedMessageIds.values().next().value;
-            if (oldest)
-                this.receivedMessageIds.delete(oldest);
-        }
-        // Queue the message
-        const queuedMsg = {
-            from,
-            body: payload.body,
-            messageId,
-            thread: payload.thread,
-            importance: meta?.importance,
-            data: payload.data,
-            originalTo,
-        };
-        this.messageQueue.push(queuedMsg);
-    }
-    /**
-     * Handle incoming channel message from relay.
-     * Channel messages include a channel indicator so the agent knows to reply to the channel.
-     */
-    handleIncomingChannelMessage(from, channel, body, envelope) {
-        const messageId = envelope.id;
-        // Deduplicate by message ID
-        if (this.receivedMessageIds.has(messageId))
-            return;
-        this.receivedMessageIds.add(messageId);
-        // Limit dedup set size
-        if (this.receivedMessageIds.size > 1000) {
-            const oldest = this.receivedMessageIds.values().next().value;
-            if (oldest)
-                this.receivedMessageIds.delete(oldest);
-        }
-        // Queue the message with channel indicator in the body
-        // Format: "Relay message from Alice [abc123] [#general]: message body"
-        // This lets the agent know to reply to the channel, not the sender
-        const queuedMsg = {
-            from,
-            body,
-            messageId,
-            thread: envelope.payload.thread,
-            data: {
-                _isChannelMessage: true,
-                _channel: channel,
-                _mentions: envelope.payload.mentions,
-            },
-            originalTo: channel, // Set channel as the reply target
-        };
-        console.error(`[base-wrapper] Received channel message: from=${from} channel=${channel} id=${messageId.substring(0, 8)}`);
-        this.messageQueue.push(queuedMsg);
-    }
-    /**
-     * Send a relay command via the client
-     */
-    sendRelayCommand(cmd) {
-        // Validate target
-        if (isPlaceholderTarget(cmd.to)) {
-            console.error(`[base-wrapper] Skipped message - placeholder target: ${cmd.to}`);
-            return;
-        }
-        // Create hash for deduplication (use first 100 chars of body)
-        const hash = `${cmd.to}:${cmd.body.substring(0, 100)}`;
-        if (this.sentMessageHashes.has(hash)) {
-            console.error(`[base-wrapper] Skipped duplicate message to ${cmd.to}`);
-            return;
-        }
-        this.sentMessageHashes.add(hash);
-        // Limit hash set size
-        if (this.sentMessageHashes.size > 500) {
-            const oldest = this.sentMessageHashes.values().next().value;
-            if (oldest)
-                this.sentMessageHashes.delete(oldest);
-        }
-        // Only send if client ready
-        if (this.client.state !== 'READY') {
-            console.error(`[base-wrapper] Client not ready (state=${this.client.state}), dropping message to ${cmd.to}`);
-            return;
-        }
-        console.error(`[base-wrapper] sendRelayCommand: to=${cmd.to}, body=${cmd.body.substring(0, 50)}...`);
-        // Check if target is a channel (starts with #)
-        if (cmd.to.startsWith('#')) {
-            // Use CHANNEL_MESSAGE protocol for channel targets
-            console.error(`[base-wrapper] Sending CHANNEL_MESSAGE to ${cmd.to}`);
-            this.client.sendChannelMessage(cmd.to, cmd.body, {
-                thread: cmd.thread,
-                data: cmd.data,
-            });
-        }
-        else {
-            // Use SEND protocol for direct messages and broadcasts
-            this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread);
-        }
-    }
-    // =========================================================================
-    // Spawn/release handling
-    // =========================================================================
-    /**
-     * Parse spawn and release commands from output
-     */
-    parseSpawnReleaseCommands(content) {
-        // Debug: check for spawn keyword
-        if (content.includes('->relay:spawn')) {
-            console.log(`[base-wrapper:${this.config.name}] Found spawn keyword in content`);
-        }
-        // Single-line spawn: ->relay:spawn Name cli "task"
-        const spawnPattern = new RegExp(`${this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}spawn\\s+(\\w+)\\s+(\\w+)\\s+"([^"]+)"`);
-        const spawnMatch = content.match(spawnPattern);
-        if (spawnMatch) {
-            const [, name, cli, task] = spawnMatch;
-            console.log(`[base-wrapper:${this.config.name}] Single-line spawn match: ${name} ${cli}`);
-            const cmdHash = `spawn:${name}:${cli}:${task}`;
-            if (!this.processedSpawnCommands.has(cmdHash)) {
-                this.processedSpawnCommands.add(cmdHash);
-                this.executeSpawn(name, cli, task);
-            }
-        }
-        // Fenced spawn: ->relay:spawn Name cli <<<\ntask\n>>>
-        const fencedSpawnPattern = new RegExp(`${this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}spawn\\s+(\\w+)\\s+(\\w+)\\s*<<<[\\s]*([\\s\\S]*?)>>>`);
-        const fencedSpawnMatch = content.match(fencedSpawnPattern);
-        if (fencedSpawnMatch) {
-            const [, name, cli, task] = fencedSpawnMatch;
-            console.log(`[base-wrapper:${this.config.name}] Fenced spawn match: ${name} ${cli}`);
-            const cmdHash = `spawn:${name}:${cli}:${task.trim()}`;
-            if (!this.processedSpawnCommands.has(cmdHash)) {
-                this.processedSpawnCommands.add(cmdHash);
-                this.executeSpawn(name, cli, task.trim());
-            }
-        }
-        // Release: ->relay:release Name
-        const releasePattern = new RegExp(`${this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}release\\s+(\\w+)`);
-        const releaseMatch = content.match(releasePattern);
-        if (releaseMatch) {
-            const name = releaseMatch[1];
-            const cmdHash = `release:${name}`;
-            if (!this.processedReleaseCommands.has(cmdHash)) {
-                this.processedReleaseCommands.add(cmdHash);
-                this.executeRelease(name);
-            }
-        }
-    }
-    /**
-     * Execute a spawn command
-     */
-    async executeSpawn(name, cli, task) {
-        // Try dashboard API first
-        if (this.config.dashboardPort) {
-            try {
-                const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawn`, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({ name, cli, task }),
-                });
-                if (response.ok)
-                    return;
-            }
-            catch {
-                // Fall through to callback
-            }
-        }
-        // Use callback
-        if (this.config.onSpawn) {
-            await this.config.onSpawn(name, cli, task);
-        }
-    }
-    /**
-     * Execute a release command
-     */
-    async executeRelease(name) {
-        // Try dashboard API first
-        if (this.config.dashboardPort) {
-            try {
-                const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/agents/${name}`, { method: 'DELETE' });
-                if (response.ok)
-                    return;
-            }
-            catch {
-                // Fall through to callback
-            }
-        }
-        // Use callback
-        if (this.config.onRelease) {
-            await this.config.onRelease(name);
-        }
-    }
-    // =========================================================================
-    // Continuity handling
-    // =========================================================================
-    /**
-     * Initialize agent ID for continuity/resume
-     */
-    async initializeAgentId() {
-        if (!this.continuity)
-            return;
-        try {
-            let ledger;
-            // If resuming, try to find previous ledger
-            if (this.config.resumeAgentId) {
-                ledger = await this.continuity.findLedgerByAgentId(this.config.resumeAgentId);
-                if (ledger) {
-                    console.log(`[${this.config.name}] Resuming agent ID: ${ledger.agentId}`);
-                }
-            }
-            // Otherwise get or create
-            if (!ledger) {
-                ledger = await this.continuity.getOrCreateLedger(this.config.name, this.cliType);
-                console.log(`[${this.config.name}] Agent ID: ${ledger.agentId}`);
-            }
-            this.agentId = ledger.agentId;
-        }
-        catch (err) {
-            console.error(`[${this.config.name}] Failed to initialize agent ID: ${err.message}`);
-        }
-    }
-    /**
-     * Parse continuity commands from output
-     */
-    async parseContinuityCommands(content) {
-        if (!this.continuity)
-            return;
-        if (!hasContinuityCommand(content))
-            return;
-        const command = parseContinuityCommand(content);
-        if (!command)
-            return;
-        // Deduplication
-        const cmdHash = `${command.type}:${command.content || command.query || command.item || 'no-content'}`;
-        if (command.content && this.processedContinuityCommands.has(cmdHash))
-            return;
-        this.processedContinuityCommands.add(cmdHash);
-        // Limit dedup set size
-        if (this.processedContinuityCommands.size > 100) {
-            const oldest = this.processedContinuityCommands.values().next().value;
-            if (oldest)
-                this.processedContinuityCommands.delete(oldest);
-        }
-        try {
-            const response = await this.continuity.handleCommand(this.config.name, command);
-            if (response) {
-                // Queue response for injection
-                this.messageQueue.push({
-                    from: 'system',
-                    body: response,
-                    messageId: `continuity-${Date.now()}`,
-                    thread: 'continuity-response',
-                });
-            }
-        }
-        catch (err) {
-            console.error(`[${this.config.name}] Continuity command error: ${err.message}`);
-        }
-    }
-    /**
-     * Save a parsed summary to the continuity ledger
-     */
-    async saveSummaryToLedger(summary) {
-        if (!this.continuity)
-            return;
-        const updates = {};
-        if (summary.currentTask) {
-            updates.currentTask = summary.currentTask;
-        }
-        if (summary.completedTasks && summary.completedTasks.length > 0) {
-            updates.completed = summary.completedTasks;
-        }
-        if (summary.context) {
-            updates.inProgress = [summary.context];
-        }
-        if (summary.files && summary.files.length > 0) {
-            updates.fileContext = summary.files.map((f) => ({ path: f }));
-        }
-        if (Object.keys(updates).length > 0) {
-            await this.continuity.saveLedger(this.config.name, updates);
-            console.log(`[${this.config.name}] Saved summary to continuity ledger`);
-        }
-    }
-    /**
-     * Reset session-specific state for wrapper reuse
-     */
-    resetSessionState() {
-        this.sessionEndProcessed = false;
-        this.lastSummaryRawContent = '';
-        this.sessionEndData = undefined;
-    }
-    // =========================================================================
-    // Utility methods
-    // =========================================================================
-    /**
-     * Join continuation lines for multi-line relay/continuity commands.
-     * TUIs like Claude Code insert real newlines in output, causing
-     * messages to span multiple lines. This joins indented
-     * continuation lines back to the command line.
-     */
-    joinContinuationLines(content) {
-        const lines = content.split('\n');
-        const result = [];
-        // Pattern to detect relay OR continuity command line (with optional bullet prefix)
-        const escapedPrefix = this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const commandPattern = new RegExp(`^(?:\\s*(?:[>$%#→➜›»●•◦‣⁃\\-*⏺◆◇○□■]\\s*)*)?(?:${escapedPrefix}|->continuity:)`);
-        // Pattern to detect a continuation line (starts with spaces, no bullet/command)
-        const continuationPattern = /^[ \t]+[^>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■\s]/;
-        // Pattern to detect a new block/bullet (stops continuation)
-        const newBlockPattern = /^(?:\s*)?[>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■]/;
-        let i = 0;
-        while (i < lines.length) {
-            const line = lines[i];
-            // Check if this is a command line
-            if (commandPattern.test(line)) {
-                let joined = line;
-                let j = i + 1;
-                // Look ahead for continuation lines
-                while (j < lines.length) {
-                    const nextLine = lines[j];
-                    // Empty line stops continuation
-                    if (nextLine.trim() === '')
-                        break;
-                    // New bullet/block stops continuation
-                    if (newBlockPattern.test(nextLine))
-                        break;
-                    // Check if it looks like a continuation (indented text)
-                    if (continuationPattern.test(nextLine)) {
-                        // Join with newline to preserve multi-line message content
-                        joined += '\n' + nextLine.trim();
-                        j++;
-                    }
-                    else {
-                        break;
-                    }
-                }
-                result.push(joined);
-                i = j; // Skip the lines we joined
-            }
-            else {
-                result.push(line);
-                i++;
-            }
-        }
-        return result.join('\n');
-    }
-    /**
-     * Clean up resources
-     */
-    destroyClient() {
-        this.client.destroy();
-    }
-}
-//# sourceMappingURL=base-wrapper.js.map