agent-relay 1.6.0 → 2.0.4

package/dist/wrapper/relay-pty-orchestrator.js

@@ -1,1088 +0,0 @@
-/**
- * RelayPtyOrchestrator - Orchestrates the relay-pty Rust binary
- *
- * This wrapper spawns the relay-pty binary and communicates via Unix socket.
- * It provides the same interface as PtyWrapper but with improved latency
- * (~550ms vs ~1700ms) by using direct PTY writes instead of tmux send-keys.
- *
- * Architecture:
- * 1. Spawn relay-pty --name {agentName} -- {command} as child process
- * 2. Connect to socket for injection:
- *    - With WORKSPACE_ID: /tmp/relay/{workspaceId}/sockets/{agentName}.sock
- *    - Without: /tmp/relay-pty-{agentName}.sock (legacy)
- * 3. Parse stdout for relay commands (relay-pty echoes all output)
- * 4. Translate SEND envelopes → inject messages via socket
- *
- * @see docs/RUST_WRAPPER_DESIGN.md for protocol details
- */
-import { spawn } from 'node:child_process';
-import { createConnection } from 'node:net';
-import { createHash } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import { existsSync, unlinkSync, mkdirSync } from 'node:fs';
-import { getProjectPaths } from '../utils/project-namespace.js';
-import { fileURLToPath } from 'node:url';
-// Get the directory where this module is located
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-import { BaseWrapper } from './base-wrapper.js';
-import { parseSummaryWithDetails, parseSessionEndFromOutput } from './parser.js';
-import { stripAnsi, sleep, buildInjectionString, INJECTION_CONSTANTS, } from './shared.js';
-// ============================================================================
-// Types for relay-pty socket protocol
-// ============================================================================
-const MAX_SOCKET_PATH_LENGTH = 107;
-function hashWorkspaceId(workspaceId) {
-    return createHash('sha256').update(workspaceId).digest('hex').slice(0, 12);
-}
-/**
- * Orchestrator for relay-pty Rust binary
- *
- * Extends BaseWrapper to provide the same interface as PtyWrapper
- * but uses the relay-pty binary for improved injection reliability.
- */
-export class RelayPtyOrchestrator extends BaseWrapper {
-    config;
-    // Process management
-    relayPtyProcess;
-    socketPath;
-    _logPath;
-    _outboxPath;
-    socket;
-    socketConnected = false;
-    // Output buffering
-    outputBuffer = '';
-    rawBuffer = '';
-    lastParsedLength = 0;
-    // Interactive mode (show output to terminal)
-    isInteractive = false;
-    // Injection state
-    pendingInjections = new Map();
-    backpressureActive = false;
-    readyForMessages = false;
-    // Unread message indicator state
-    lastUnreadIndicatorTime = 0;
-    UNREAD_INDICATOR_COOLDOWN_MS = 5000; // Don't spam indicators
-    // Track whether any output has been received from the CLI
-    hasReceivedOutput = false;
-    // Note: sessionEndProcessed and lastSummaryRawContent are inherited from BaseWrapper
-    constructor(config) {
-        super(config);
-        this.config = config;
-        // Check for workspace namespacing (for multi-tenant cloud deployment)
-        // WORKSPACE_ID can be in process.env or passed via config.env
-        const workspaceId = config.env?.WORKSPACE_ID || process.env.WORKSPACE_ID;
-        if (workspaceId) {
-            // Workspace-namespaced paths for cloud multi-tenant isolation
-            const getWorkspacePaths = (id) => {
-                const workspaceDir = `/tmp/relay/${id}`;
-                return {
-                    workspaceDir,
-                    socketPath: `${workspaceDir}/sockets/${config.name}.sock`,
-                    outboxPath: `${workspaceDir}/outbox/${config.name}`,
-                };
-            };
-            let paths = getWorkspacePaths(workspaceId);
-            if (paths.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-                const hashedWorkspaceId = hashWorkspaceId(workspaceId);
-                const hashedPaths = getWorkspacePaths(hashedWorkspaceId);
-                console.warn(`[relay-pty-orchestrator:${config.name}] Socket path too long (${paths.socketPath.length} chars); using hashed workspace id ${hashedWorkspaceId}`);
-                paths = hashedPaths;
-            }
-            if (paths.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-                throw new Error(`Socket path exceeds ${MAX_SOCKET_PATH_LENGTH} chars: ${paths.socketPath.length}`);
-            }
-            this.socketPath = paths.socketPath;
-            this._outboxPath = paths.outboxPath;
-        }
-        else {
-            // Legacy paths for local development
-            this.socketPath = `/tmp/relay-pty-${config.name}.sock`;
-            this._outboxPath = `/tmp/relay-outbox/${config.name}`;
-        }
-        if (this.socketPath.length > MAX_SOCKET_PATH_LENGTH) {
-            throw new Error(`Socket path exceeds ${MAX_SOCKET_PATH_LENGTH} chars: ${this.socketPath.length}`);
-        }
-        // Generate log path using same project paths as daemon
-        // Use cwd from config if specified, otherwise detect from current directory
-        const paths = getProjectPaths(config.cwd);
-        this._logPath = join(paths.teamDir, 'worker-logs', `${config.name}.log`);
-        // Check if we're running interactively (stdin is a TTY)
-        this.isInteractive = process.stdin.isTTY === true;
-    }
-    /**
-     * Debug log - only outputs when debug is enabled
-     */
-    log(message) {
-        if (this.config.debug) {
-            console.log(`[relay-pty-orchestrator:${this.config.name}] ${message}`);
-        }
-    }
-    /**
-     * Error log - always outputs (errors are important)
-     */
-    logError(message) {
-        console.error(`[relay-pty-orchestrator:${this.config.name}] ERROR: ${message}`);
-    }
-    /**
-     * Get the outbox path for this agent (for documentation purposes)
-     */
-    get outboxPath() {
-        return this._outboxPath;
-    }
-    // =========================================================================
-    // Abstract method implementations (required by BaseWrapper)
-    // =========================================================================
-    /**
-     * Start the relay-pty process and connect to socket
-     */
-    async start() {
-        if (this.running)
-            return;
-        this.log(` Starting...`);
-        // Ensure socket directory exists (for workspace-namespaced paths)
-        const socketDir = dirname(this.socketPath);
-        try {
-            if (!existsSync(socketDir)) {
-                mkdirSync(socketDir, { recursive: true });
-                this.log(` Created socket directory: ${socketDir}`);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to create socket directory: ${err.message}`);
-        }
-        // Clean up any stale socket from previous crashed process
-        try {
-            if (existsSync(this.socketPath)) {
-                this.log(` Removing stale socket: ${this.socketPath}`);
-                unlinkSync(this.socketPath);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to clean up socket: ${err.message}`);
-        }
-        // Find relay-pty binary
-        const binaryPath = this.findRelayPtyBinary();
-        if (!binaryPath) {
-            throw new Error('relay-pty binary not found. Build with: cd relay-pty && cargo build --release');
-        }
-        this.log(` Using binary: ${binaryPath}`);
-        // Connect to relay daemon first
-        try {
-            await this.client.connect();
-            this.log(` Relay daemon connected`);
-        }
-        catch (err) {
-            this.logError(` Relay connect failed: ${err.message}`);
-        }
-        // Spawn relay-pty process
-        await this.spawnRelayPty(binaryPath);
-        // Wait for socket to become available and connect
-        await this.connectToSocket();
-        this.running = true;
-        this.readyForMessages = true;
-        this.startStuckDetection();
-        this.log(` Ready for messages`);
-        this.log(` Socket connected: ${this.socketConnected}`);
-        this.log(` Relay client state: ${this.client.state}`);
-        // Process any queued messages
-        this.processMessageQueue();
-    }
-    /**
-     * Stop the relay-pty process gracefully
-     */
-    async stop() {
-        if (!this.running)
-            return;
-        this.running = false;
-        this.stopStuckDetection();
-        this.log(` Stopping...`);
-        // Send shutdown command via socket
-        if (this.socket && this.socketConnected) {
-            try {
-                await this.sendSocketRequest({ type: 'shutdown' });
-            }
-            catch {
-                // Ignore errors during shutdown
-            }
-        }
-        // Close socket
-        this.disconnectSocket();
-        // Kill process if still running
-        if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-            this.relayPtyProcess.kill('SIGTERM');
-            // Force kill after timeout
-            await Promise.race([
-                new Promise((resolve) => {
-                    this.relayPtyProcess?.on('exit', () => resolve());
-                }),
-                sleep(5000).then(() => {
-                    if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-                        this.relayPtyProcess.kill('SIGKILL');
-                    }
-                }),
-            ]);
-        }
-        // Cleanup relay client
-        this.destroyClient();
-        // Clean up socket file
-        try {
-            if (existsSync(this.socketPath)) {
-                unlinkSync(this.socketPath);
-                this.log(` Cleaned up socket: ${this.socketPath}`);
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to clean up socket: ${err.message}`);
-        }
-        this.log(` Stopped`);
-    }
-    /**
-     * Inject content into the agent via socket
-     */
-    async performInjection(content) {
-        // This is called by BaseWrapper but we handle injection differently
-        // via the socket protocol in processMessageQueue
-        throw new Error('Use injectMessage() instead of performInjection()');
-    }
-    /**
-     * Get cleaned output for parsing
-     */
-    getCleanOutput() {
-        return stripAnsi(this.rawBuffer);
-    }
-    // =========================================================================
-    // Process management
-    // =========================================================================
-    /**
-     * Find the relay-pty binary
-     */
-    findRelayPtyBinary() {
-        // Check config path first
-        if (this.config.relayPtyPath && existsSync(this.config.relayPtyPath)) {
-            return this.config.relayPtyPath;
-        }
-        // Get the package root (two levels up from dist/wrapper/)
-        const packageRoot = join(__dirname, '..', '..');
-        // Check common locations (ordered by priority)
-        const candidates = [
-            // Primary: installed by postinstall from platform-specific binary
-            join(packageRoot, 'bin', 'relay-pty'),
-            // Development: local Rust build
-            join(packageRoot, 'relay-pty', 'target', 'release', 'relay-pty'),
-            join(packageRoot, 'relay-pty', 'target', 'debug', 'relay-pty'),
-            // Local build in cwd (for development)
-            join(process.cwd(), 'relay-pty', 'target', 'release', 'relay-pty'),
-            join(process.cwd(), 'relay-pty', 'target', 'debug', 'relay-pty'),
-            // Installed globally
-            '/usr/local/bin/relay-pty',
-            // In node_modules (when installed as dependency)
-            join(process.cwd(), 'node_modules', 'agent-relay', 'bin', 'relay-pty'),
-            join(process.cwd(), 'node_modules', '.bin', 'relay-pty'),
-        ];
-        for (const candidate of candidates) {
-            if (existsSync(candidate)) {
-                return candidate;
-            }
-        }
-        return null;
-    }
-    /**
-     * Spawn the relay-pty process
-     */
-    async spawnRelayPty(binaryPath) {
-        // Get terminal dimensions for proper rendering
-        const rows = process.stdout.rows || 24;
-        const cols = process.stdout.columns || 80;
-        const args = [
-            '--name', this.config.name,
-            '--socket', this.socketPath,
-            '--idle-timeout', String(this.config.idleBeforeInjectMs ?? 500),
-            '--json-output', // Enable Rust parsing output
-            '--rows', String(rows),
-            '--cols', String(cols),
-            '--log-level', 'warn', // Only show warnings and errors
-            '--log-file', this._logPath, // Enable output logging
-            '--outbox', this._outboxPath, // Enable file-based relay messages
-            '--', this.config.command,
-            ...(this.config.args ?? []),
-        ];
-        this.log(` Spawning: ${binaryPath} ${args.join(' ')}`);
-        // For interactive mode, let Rust directly inherit stdin/stdout from the terminal
-        // This is more robust than manual forwarding through pipes
-        // We still pipe stderr to capture JSON parsed commands
-        const stdio = this.isInteractive
-            ? ['inherit', 'inherit', 'pipe'] // Rust handles terminal directly
-            : ['pipe', 'pipe', 'pipe']; // Headless mode - we handle I/O
-        const proc = spawn(binaryPath, args, {
-            cwd: this.config.cwd ?? process.cwd(),
-            env: {
-                ...process.env,
-                ...this.config.env,
-                AGENT_RELAY_NAME: this.config.name,
-                TERM: 'xterm-256color',
-            },
-            stdio,
-        });
-        this.relayPtyProcess = proc;
-        // Handle stdout (agent output) - only in headless mode
-        if (!this.isInteractive && proc.stdout) {
-            proc.stdout.on('data', (data) => {
-                const text = data.toString();
-                this.handleOutput(text);
-            });
-        }
-        // Handle stderr (relay-pty logs and JSON output) - always needed
-        if (proc.stderr) {
-            proc.stderr.on('data', (data) => {
-                const text = data.toString();
-                this.handleStderr(text);
-            });
-        }
-        // Handle exit
-        proc.on('exit', (code, signal) => {
-            const exitCode = code ?? (signal === 'SIGKILL' ? 137 : 1);
-            this.log(` Process exited: code=${exitCode} signal=${signal}`);
-            this.running = false;
-            this.emit('exit', exitCode);
-            this.config.onExit?.(exitCode);
-        });
-        // Handle error
-        proc.on('error', (err) => {
-            this.logError(` Process error: ${err.message}`);
-            this.emit('error', err);
-        });
-        // Wait for process to start
-        await sleep(500);
-        if (proc.exitCode !== null) {
-            throw new Error(`relay-pty exited immediately with code ${proc.exitCode}`);
-        }
-    }
-    /**
-     * Handle output from relay-pty stdout (headless mode only)
-     * In interactive mode, stdout goes directly to terminal via inherited stdio
-     */
-    handleOutput(data) {
-        this.rawBuffer += data;
-        this.outputBuffer += data;
-        this.hasReceivedOutput = true;
-        // Feed to idle detector
-        this.feedIdleDetectorOutput(data);
-        // Check for unread messages and append indicator if needed
-        const indicator = this.formatUnreadIndicator();
-        const outputWithIndicator = indicator ? data + indicator : data;
-        // Emit output event (with indicator if present)
-        this.emit('output', outputWithIndicator);
-        // Stream to daemon if configured
-        if (this.config.streamLogs !== false && this.client.state === 'READY') {
-            this.client.sendLog(outputWithIndicator);
-        }
-        // Parse for relay commands
-        this.parseRelayCommands();
-        // Check for summary and session end
-        const cleanContent = stripAnsi(this.rawBuffer);
-        this.checkForSummary(cleanContent);
-        this.checkForSessionEnd(cleanContent);
-    }
-    /**
-     * Format an unread message indicator if there are pending messages.
-     * Returns empty string if no pending messages or within cooldown period.
-     *
-     * Example output:
-     * ───────────────────────────
-     * 📬 2 unread messages (from: Alice, Bob)
-     */
-    formatUnreadIndicator() {
-        const queueLength = this.messageQueue.length;
-        if (queueLength === 0) {
-            return '';
-        }
-        // Check cooldown to avoid spamming
-        const now = Date.now();
-        if (now - this.lastUnreadIndicatorTime < this.UNREAD_INDICATOR_COOLDOWN_MS) {
-            return '';
-        }
-        this.lastUnreadIndicatorTime = now;
-        // Collect unique sender names
-        const senders = [...new Set(this.messageQueue.map(m => m.from))];
-        const senderList = senders.slice(0, 3).join(', ');
-        const moreCount = senders.length > 3 ? ` +${senders.length - 3} more` : '';
-        const line = '─'.repeat(27);
-        const messageWord = queueLength === 1 ? 'message' : 'messages';
-        return `\n${line}\n📬 ${queueLength} unread ${messageWord} (from: ${senderList}${moreCount})\n`;
-    }
-    /**
-     * Handle stderr from relay-pty (logs and JSON parsed commands)
-     */
-    handleStderr(data) {
-        // relay-pty outputs JSON parsed commands to stderr with --json-output
-        const lines = data.split('\n').filter(l => l.trim());
-        for (const line of lines) {
-            if (line.startsWith('{')) {
-                // JSON output - parsed relay command from Rust
-                try {
-                    const parsed = JSON.parse(line);
-                    if (parsed.type === 'relay_command' && parsed.kind) {
-                        this.log(`Rust parsed [${parsed.kind}]: ${parsed.from} -> ${parsed.to}`);
-                        this.handleRustParsedCommand(parsed);
-                    }
-                }
-                catch {
-                    // Not JSON, just log (only in debug mode)
-                    if (this.config.debug) {
-                        console.error(`[relay-pty:${this.config.name}] ${line}`);
-                    }
-                }
-            }
-            else {
-                // Non-JSON stderr - only show in debug mode (logs, info messages)
-                if (this.config.debug) {
-                    console.error(`[relay-pty:${this.config.name}] ${line}`);
-                }
-            }
-        }
-    }
-    /**
-     * Handle a parsed command from Rust relay-pty
-     * Rust outputs structured JSON with 'kind' field: "message", "spawn", "release"
-     */
-    handleRustParsedCommand(parsed) {
-        switch (parsed.kind) {
-            case 'spawn':
-                if (parsed.spawn_name && parsed.spawn_cli) {
-                    this.log(` Spawn detected: ${parsed.spawn_name} (${parsed.spawn_cli})`);
-                    this.handleSpawnCommand(parsed.spawn_name, parsed.spawn_cli, parsed.spawn_task || '');
-                }
-                break;
-            case 'release':
-                if (parsed.release_name) {
-                    this.log(`Release: ${parsed.release_name}`);
-                    this.handleReleaseCommand(parsed.release_name);
-                }
-                else {
-                    this.logError(`Missing release_name in parsed command: ${JSON.stringify(parsed)}`);
-                }
-                break;
-            case 'message':
-            default:
-                this.sendRelayCommand({
-                    to: parsed.to,
-                    kind: 'message',
-                    body: parsed.body,
-                    thread: parsed.thread,
-                    raw: parsed.raw,
-                });
-                break;
-        }
-    }
-    /**
-     * Handle spawn command (from Rust stderr JSON parsing)
-     *
-     * Note: We do NOT send the initial task message here because the spawner
-     * now handles it after waitUntilCliReady(). Sending it here would cause
-     * duplicate task delivery.
-     */
-    handleSpawnCommand(name, cli, task) {
-        const key = `spawn:${name}:${cli}`;
-        if (this.processedSpawnCommands.has(key)) {
-            this.log(` Spawn already processed: ${key}`);
-            return;
-        }
-        this.processedSpawnCommands.add(key);
-        this.log(` Spawn: ${name} (${cli})`);
-        this.log(` dashboardPort=${this.config.dashboardPort}, onSpawn=${!!this.config.onSpawn}`);
-        // Try dashboard API first, fall back to callback
-        // The spawner will send the task after waitUntilCliReady()
-        if (this.config.dashboardPort) {
-            this.log(` Calling dashboard API at port ${this.config.dashboardPort}`);
-            this.spawnViaDashboardApi(name, cli, task)
-                .then(() => {
-                this.log(` Dashboard spawn succeeded for ${name}`);
-            })
-                .catch(err => {
-                this.logError(` Dashboard spawn failed: ${err.message}`);
-                if (this.config.onSpawn) {
-                    this.log(` Falling back to onSpawn callback`);
-                    Promise.resolve(this.config.onSpawn(name, cli, task))
-                        .catch(e => this.logError(` onSpawn callback failed: ${e.message}`));
-                }
-            });
-        }
-        else if (this.config.onSpawn) {
-            this.log(` Using onSpawn callback directly`);
-            Promise.resolve(this.config.onSpawn(name, cli, task))
-                .catch(e => this.logError(` onSpawn callback failed: ${e.message}`));
-        }
-        else {
-            this.logError(` No spawn mechanism available!`);
-        }
-    }
-    /**
-     * Handle release command
-     */
-    handleReleaseCommand(name) {
-        const key = `release:${name}`;
-        if (this.processedReleaseCommands.has(key)) {
-            return;
-        }
-        this.processedReleaseCommands.add(key);
-        this.log(` Release: ${name}`);
-        // Try dashboard API first, fall back to callback
-        if (this.config.dashboardPort) {
-            this.releaseViaDashboardApi(name).catch(err => {
-                this.logError(` Dashboard release failed: ${err.message}`);
-                this.config.onRelease?.(name);
-            });
-        }
-        else if (this.config.onRelease) {
-            this.config.onRelease(name);
-        }
-    }
-    /**
-     * Spawn agent via dashboard API
-     */
-    async spawnViaDashboardApi(name, cli, task) {
-        const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawn`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                name,
-                cli,
-                task,
-                spawnerName: this.config.name, // Include spawner name so task appears from correct agent
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-    }
-    /**
-     * Release agent via dashboard API
-     */
-    async releaseViaDashboardApi(name) {
-        const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/spawned/${encodeURIComponent(name)}`, {
-            method: 'DELETE',
-        });
-        if (!response.ok) {
-            const body = await response.json().catch(() => ({ error: 'Unknown' }));
-            throw new Error(`HTTP ${response.status}: ${body.error || 'Unknown error'}`);
-        }
-        this.log(`Released ${name} via dashboard API`);
-    }
-    // =========================================================================
-    // Socket communication
-    // =========================================================================
-    /**
-     * Connect to the relay-pty socket
-     */
-    async connectToSocket() {
-        const timeout = this.config.socketConnectTimeoutMs ?? 5000;
-        const maxAttempts = this.config.socketReconnectAttempts ?? 3;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-            try {
-                await this.attemptSocketConnection(timeout);
-                this.log(` Socket connected`);
-                return;
-            }
-            catch (err) {
-                this.logError(` Socket connect attempt ${attempt}/${maxAttempts} failed: ${err.message}`);
-                if (attempt < maxAttempts) {
-                    await sleep(1000 * attempt); // Exponential backoff
-                }
-            }
-        }
-        throw new Error(`Failed to connect to socket after ${maxAttempts} attempts`);
-    }
-    /**
-     * Attempt a single socket connection
-     */
-    attemptSocketConnection(timeout) {
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                reject(new Error('Socket connection timeout'));
-            }, timeout);
-            this.socket = createConnection(this.socketPath, () => {
-                clearTimeout(timer);
-                this.socketConnected = true;
-                resolve();
-            });
-            this.socket.on('error', (err) => {
-                clearTimeout(timer);
-                this.socketConnected = false;
-                reject(err);
-            });
-            this.socket.on('close', () => {
-                this.socketConnected = false;
-                this.log(` Socket closed`);
-            });
-            // Handle incoming data (responses)
-            let buffer = '';
-            this.socket.on('data', (data) => {
-                buffer += data.toString();
-                // Process complete lines
-                const lines = buffer.split('\n');
-                buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
-                for (const line of lines) {
-                    if (line.trim()) {
-                        this.handleSocketResponse(line);
-                    }
-                }
-            });
-        });
-    }
-    /**
-     * Disconnect from socket
-     */
-    disconnectSocket() {
-        if (this.socket) {
-            this.socket.destroy();
-            this.socket = undefined;
-            this.socketConnected = false;
-        }
-        // Reject all pending injections
-        for (const [id, pending] of this.pendingInjections) {
-            clearTimeout(pending.timeout);
-            pending.reject(new Error('Socket disconnected'));
-        }
-        this.pendingInjections.clear();
-    }
-    /**
-     * Send a request to the socket and optionally wait for response
-     */
-    sendSocketRequest(request) {
-        return new Promise((resolve, reject) => {
-            if (!this.socket || !this.socketConnected) {
-                reject(new Error('Socket not connected'));
-                return;
-            }
-            const json = JSON.stringify(request) + '\n';
-            this.socket.write(json, (err) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * Handle a response from the socket
-     */
-    handleSocketResponse(line) {
-        try {
-            const response = JSON.parse(line);
-            switch (response.type) {
-                case 'inject_result':
-                    this.handleInjectResult(response);
-                    break;
-                case 'status':
-                    // Status responses are typically requested explicitly
-                    this.log(` Status: idle=${response.agent_idle} queue=${response.queue_length}`);
-                    break;
-                case 'backpressure':
-                    this.handleBackpressure(response);
-                    break;
-                case 'error':
-                    this.logError(` Socket error: ${response.message}`);
-                    break;
-                case 'shutdown_ack':
-                    this.log(` Shutdown acknowledged`);
-                    break;
-            }
-        }
-        catch (err) {
-            this.logError(` Failed to parse socket response: ${err.message}`);
-        }
-    }
-    /**
-     * Handle injection result response
-     */
-    handleInjectResult(response) {
-        this.log(` handleInjectResult: id=${response.id.substring(0, 8)} status=${response.status}`);
-        const pending = this.pendingInjections.get(response.id);
-        if (!pending) {
-            // Response for unknown message - might be from a previous session
-            this.log(` No pending injection found for ${response.id.substring(0, 8)}`);
-            return;
-        }
-        if (response.status === 'delivered') {
-            clearTimeout(pending.timeout);
-            this.pendingInjections.delete(response.id);
-            pending.resolve(true);
-            this.log(` Message ${response.id.substring(0, 8)} delivered`);
-        }
-        else if (response.status === 'failed') {
-            clearTimeout(pending.timeout);
-            this.pendingInjections.delete(response.id);
-            pending.resolve(false);
-            this.logError(` Message ${response.id.substring(0, 8)} failed: ${response.error}`);
-            this.emit('injection-failed', {
-                messageId: response.id,
-                from: 'unknown',
-                error: response.error ?? 'Unknown error',
-            });
-        }
-        // queued/injecting are intermediate states - wait for final status
-    }
-    /**
-     * Handle backpressure notification
-     */
-    handleBackpressure(response) {
-        const wasActive = this.backpressureActive;
-        this.backpressureActive = !response.accept;
-        if (this.backpressureActive !== wasActive) {
-            this.log(` Backpressure: ${this.backpressureActive ? 'ACTIVE' : 'cleared'} (queue=${response.queue_length})`);
-            this.emit('backpressure', { queueLength: response.queue_length, accept: response.accept });
-            // Resume processing if backpressure cleared
-            if (!this.backpressureActive) {
-                this.processMessageQueue();
-            }
-        }
-    }
-    // =========================================================================
-    // Message handling
-    // =========================================================================
-    /**
-     * Inject a message into the agent via socket
-     */
-    async injectMessage(msg) {
-        this.log(` === INJECT START: ${msg.messageId.substring(0, 8)} from ${msg.from} ===`);
-        if (!this.socket || !this.socketConnected) {
-            this.logError(` Cannot inject - socket not connected`);
-            return false;
-        }
-        // Build injection content
-        const content = buildInjectionString(msg);
-        this.log(` Injection content (${content.length} bytes): ${content.substring(0, 100)}...`);
-        // Create request
-        const request = {
-            type: 'inject',
-            id: msg.messageId,
-            from: msg.from,
-            body: content,
-            priority: msg.importance ?? 0,
-        };
-        this.log(` Sending inject request to socket...`);
-        // Create promise for result
-        return new Promise((resolve, reject) => {
-            const timeout = setTimeout(() => {
-                this.logError(` Inject timeout for ${msg.messageId.substring(0, 8)} after 30s`);
-                this.pendingInjections.delete(msg.messageId);
-                resolve(false); // Timeout = failure
-            }, 30000); // 30 second timeout for injection
-            this.pendingInjections.set(msg.messageId, { resolve, reject, timeout });
-            // Send request
-            this.sendSocketRequest(request)
-                .then(() => {
-                this.log(` Socket request sent for ${msg.messageId.substring(0, 8)}`);
-            })
-                .catch((err) => {
-                this.logError(` Socket request failed for ${msg.messageId.substring(0, 8)}: ${err.message}`);
-                clearTimeout(timeout);
-                this.pendingInjections.delete(msg.messageId);
-                resolve(false);
-            });
-        });
-    }
-    /**
-     * Process queued messages
-     */
-    async processMessageQueue() {
-        if (!this.readyForMessages || this.backpressureActive || this.isInjecting) {
-            return;
-        }
-        if (this.messageQueue.length === 0) {
-            return;
-        }
-        this.isInjecting = true;
-        const msg = this.messageQueue.shift();
-        const bodyPreview = msg.body.substring(0, 50).replace(/\n/g, '\\n');
-        this.log(` Processing message from ${msg.from}: "${bodyPreview}..." (remaining=${this.messageQueue.length})`);
-        try {
-            const success = await this.injectMessage(msg);
-            if (!success) {
-                this.logError(` Injection failed for message ${msg.messageId.substring(0, 8)}`);
-                this.injectionMetrics.failed++;
-                this.config.onInjectionFailed?.(msg.messageId, 'Injection failed');
-            }
-            else {
-                this.injectionMetrics.successFirstTry++;
-            }
-            this.injectionMetrics.total++;
-        }
-        catch (err) {
-            this.logError(` Injection error: ${err.message}`);
-            this.injectionMetrics.failed++;
-            this.injectionMetrics.total++;
-        }
-        finally {
-            this.isInjecting = false;
-            // Process next message after delay
-            if (this.messageQueue.length > 0 && !this.backpressureActive) {
-                setTimeout(() => this.processMessageQueue(), INJECTION_CONSTANTS.QUEUE_PROCESS_DELAY_MS);
-            }
-        }
-    }
-    /**
-     * Override handleIncomingMessage to trigger queue processing
-     */
-    handleIncomingMessage(from, payload, messageId, meta, originalTo) {
-        this.log(` === MESSAGE RECEIVED: ${messageId.substring(0, 8)} from ${from} ===`);
-        this.log(` Body preview: ${payload.body?.substring(0, 100) ?? '(no body)'}...`);
-        super.handleIncomingMessage(from, payload, messageId, meta, originalTo);
-        this.log(` Queue length after add: ${this.messageQueue.length}`);
-        this.processMessageQueue();
-    }
-    // =========================================================================
-    // Output parsing
-    // =========================================================================
-    /**
-     * Parse relay commands from output
-     */
-    parseRelayCommands() {
-        const cleanContent = stripAnsi(this.rawBuffer);
-        if (cleanContent.length <= this.lastParsedLength) {
-            return;
-        }
-        // Parse new content with lookback for fenced messages
-        const lookbackStart = Math.max(0, this.lastParsedLength - 500);
-        const contentToParse = cleanContent.substring(lookbackStart);
-        // Parse fenced messages
-        this.parseFencedMessages(contentToParse);
-        // Parse single-line messages
-        this.parseSingleLineMessages(contentToParse);
-        // Parse spawn/release commands
-        this.parseSpawnReleaseCommands(contentToParse);
-        this.lastParsedLength = cleanContent.length;
-    }
-    /**
-     * Parse fenced multi-line messages
-     */
-    parseFencedMessages(content) {
-        const escapedPrefix = this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const fencePattern = new RegExp(`${escapedPrefix}(\\S+)(?:\\s+\\[thread:([\\w-]+)\\])?\\s*<<<([\\s\\S]*?)>>>`, 'g');
-        let match;
-        while ((match = fencePattern.exec(content)) !== null) {
-            const target = match[1];
-            const thread = match[2];
-            const body = match[3].trim();
-            if (!body || target === 'spawn' || target === 'release') {
-                continue;
-            }
-            this.sendRelayCommand({
-                to: target,
-                kind: 'message',
-                body,
-                thread,
-                raw: match[0],
-            });
-        }
-    }
-    /**
-     * Parse single-line messages
-     */
-    parseSingleLineMessages(content) {
-        const lines = content.split('\n');
-        const escapedPrefix = this.relayPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const pattern = new RegExp(`${escapedPrefix}(\\S+)(?:\\s+\\[thread:([\\w-]+)\\])?\\s+(.+)$`);
-        for (const line of lines) {
-            // Skip fenced messages
-            if (line.includes('<<<') || line.includes('>>>')) {
-                continue;
-            }
-            const match = line.match(pattern);
-            if (!match) {
-                continue;
-            }
-            const target = match[1];
-            const thread = match[2];
-            const body = match[3].trim();
-            if (!body || target === 'spawn' || target === 'release') {
-                continue;
-            }
-            this.sendRelayCommand({
-                to: target,
-                kind: 'message',
-                body,
-                thread,
-                raw: line,
-            });
-        }
-    }
-    // =========================================================================
-    // Summary and session end detection
-    // =========================================================================
-    /**
-     * Check for [[SUMMARY]] blocks
-     */
-    checkForSummary(content) {
-        const result = parseSummaryWithDetails(content);
-        if (!result.found || !result.valid) {
-            return;
-        }
-        if (result.rawContent === this.lastSummaryRawContent) {
-            return;
-        }
-        this.lastSummaryRawContent = result.rawContent ?? '';
-        this.emit('summary', {
-            agentName: this.config.name,
-            summary: result.summary,
-        });
-    }
-    /**
-     * Check for [[SESSION_END]] blocks
-     */
-    checkForSessionEnd(content) {
-        if (this.sessionEndProcessed) {
-            return;
-        }
-        const sessionEnd = parseSessionEndFromOutput(content);
-        if (!sessionEnd) {
-            return;
-        }
-        this.sessionEndProcessed = true;
-        this.emit('session-end', {
-            agentName: this.config.name,
-            marker: sessionEnd,
-        });
-    }
-    // =========================================================================
-    // Public API
-    // =========================================================================
-    /**
-     * Query status from relay-pty
-     */
-    async queryStatus() {
-        if (!this.socket || !this.socketConnected) {
-            return null;
-        }
-        try {
-            await this.sendSocketRequest({ type: 'status' });
-            // Response will come asynchronously via handleSocketResponse
-            // For now, return null - could implement request/response matching
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Wait for the CLI to be ready to receive messages.
-     * This waits for:
-     * 1. The CLI to produce at least one output (it has started)
-     * 2. The CLI to become idle (it's ready for input)
-     *
-     * This is more reliable than a random sleep because it waits for
-     * actual signals from the CLI rather than guessing how long it takes to start.
-     *
-     * @param timeoutMs Maximum time to wait (default: 30s)
-     * @param pollMs Polling interval (default: 100ms)
-     * @returns true if CLI is ready, false if timeout
-     */
-    async waitUntilCliReady(timeoutMs = 30000, pollMs = 100) {
-        const startTime = Date.now();
-        this.log(` Waiting for CLI to be ready (timeout: ${timeoutMs}ms)`);
-        // Phase 1: Wait for first output (CLI has started)
-        while (Date.now() - startTime < timeoutMs) {
-            if (this.hasReceivedOutput) {
-                this.log(` CLI has started producing output`);
-                break;
-            }
-            await sleep(pollMs);
-        }
-        if (!this.hasReceivedOutput) {
-            this.log(` Timeout waiting for CLI to produce output`);
-            return false;
-        }
-        // Phase 2: Wait for idle state (CLI is ready for input)
-        const remainingTime = timeoutMs - (Date.now() - startTime);
-        if (remainingTime <= 0) {
-            return false;
-        }
-        const idleResult = await this.waitForIdleState(remainingTime, pollMs);
-        if (idleResult.isIdle) {
-            this.log(` CLI is idle and ready (confidence: ${idleResult.confidence.toFixed(2)})`);
-            return true;
-        }
-        this.log(` Timeout waiting for CLI to become idle`);
-        return false;
-    }
-    /**
-     * Check if the CLI has produced any output yet.
-     * Useful for checking if the CLI has started without blocking.
-     */
-    hasCliStarted() {
-        return this.hasReceivedOutput;
-    }
-    /**
-     * Get raw output buffer
-     */
-    getRawOutput() {
-        return this.rawBuffer;
-    }
-    /**
-     * Check if backpressure is active
-     */
-    isBackpressureActive() {
-        return this.backpressureActive;
-    }
-    /**
-     * Get the socket path
-     */
-    getSocketPath() {
-        return this.socketPath;
-    }
-    /**
-     * Get the relay-pty process PID
-     */
-    get pid() {
-        return this.relayPtyProcess?.pid;
-    }
-    /**
-     * Get the log file path (not used by relay-pty, returns undefined)
-     */
-    get logPath() {
-        return this._logPath;
-    }
-    /**
-     * Kill the process forcefully
-     */
-    async kill() {
-        if (this.relayPtyProcess && !this.relayPtyProcess.killed) {
-            this.relayPtyProcess.kill('SIGKILL');
-        }
-        this.running = false;
-        this.disconnectSocket();
-        this.destroyClient();
-    }
-    /**
-     * Get output lines (for compatibility with PtyWrapper)
-     * @param limit Maximum number of lines to return
-     */
-    getOutput(limit) {
-        const lines = this.rawBuffer.split('\n');
-        if (limit && limit > 0) {
-            return lines.slice(-limit);
-        }
-        return lines;
-    }
-    /**
-     * Write data directly to the process stdin
-     * @param data Data to write
-     */
-    async write(data) {
-        if (!this.relayPtyProcess || !this.relayPtyProcess.stdin) {
-            throw new Error('Process not running');
-        }
-        const buffer = typeof data === 'string' ? Buffer.from(data) : data;
-        this.relayPtyProcess.stdin.write(buffer);
-    }
-    /**
-     * Get the agent ID (from continuity if available)
-     */
-    getAgentId() {
-        return this.agentId;
-    }
-}
-//# sourceMappingURL=relay-pty-orchestrator.js.map