agent-relay 1.3.1 → 1.3.3

package/dist/wrapper/pty-wrapper.js

@@ -184,6 +184,11 @@ export class PtyWrapper extends BaseWrapper {
         }
         this.running = true;
         this.sessionStartTime = Date.now();
+        // Set PID for idle detector (enables process state inspection on Linux)
+        if (this.ptyProcess.pid) {
+            this.setIdleDetectorPid(this.ptyProcess.pid);
+            console.log(`[pty:${this.config.name}] Idle detector initialized with PID ${this.ptyProcess.pid}`);
+        }
         // Skip hooks and continuity in interactive mode - user handles all prompts directly
         if (!this.config.interactive) {
             // Dispatch session start hook (handles trajectory initialization)
@@ -208,18 +213,40 @@ export class PtyWrapper extends BaseWrapper {
             this.config.onExit?.(exitCode);
             this.client.destroy();
         });
-        // Inject initial instructions after a delay, then mark ready for messages
-        // Skip in interactive mode - user handles all prompts directly
-        setTimeout(() => {
+        // Wait for agent to be idle before injecting instructions
+        // This replaces the fixed 2-second delay with actual readiness detection
+        this.waitForAgentReady().then(() => {
             if (!this.config.interactive) {
                 this.injectInstructions();
             }
             this.readyForMessages = true;
+            console.log(`[pty:${this.config.name}] Agent ready for messages (queueLen=${this.messageQueue.length}, interactive=${this.config.interactive})`);
             // Process any messages that arrived while waiting (skip in interactive mode)
             if (!this.config.interactive) {
                 this.processMessageQueue();
             }
-        }, 2000);
+        }).catch(err => {
+            console.error(`[pty:${this.config.name}] Failed to wait for agent ready:`, err);
+            // Fall back to marking ready anyway to avoid blocking forever
+            this.readyForMessages = true;
+            console.log(`[pty:${this.config.name}] Agent ready for messages (fallback, queueLen=${this.messageQueue.length})`);
+        });
+    }
+    /**
+     * Wait for the agent to be ready for input.
+     * Uses idle detection instead of a fixed delay.
+     */
+    async waitForAgentReady() {
+        // Minimum wait to ensure the CLI process has started
+        await sleep(500);
+        // Wait for agent to become idle (CLI fully initialized)
+        const result = await this.waitForIdleState(10000, 200);
+        if (result.isIdle) {
+            console.log(`[pty:${this.config.name}] Agent ready (confidence: ${(result.confidence * 100).toFixed(0)}%)`);
+        }
+        else {
+            console.warn(`[pty:${this.config.name}] Agent readiness timeout, proceeding anyway`);
+        }
     }
     // Note: initializeAgentId() and getAgentId() are inherited from BaseWrapper
     /**
@@ -322,6 +349,8 @@ export class PtyWrapper extends BaseWrapper {
     handleOutput(data) {
         // Track output timing for stability checks
         this.lastOutputTime = Date.now();
+        // Feed output to idle detector for robust idle detection
+        this.feedIdleDetectorOutput(data);
         // Append to raw buffer
         this.rawBuffer += data;
         // Write to log file if available
@@ -581,6 +610,14 @@ export class PtyWrapper extends BaseWrapper {
         // 500 chars is enough to capture most relay message headers
         const lookbackStart = Math.max(0, this.lastParsedLength - 500);
         const contentToParse = cleanContent.substring(lookbackStart);
+        // Debug: Check if content contains relay pattern
+        if (contentToParse.includes('->relay:')) {
+            const relayLines = contentToParse.split('\n').filter(l => l.includes('->relay:'));
+            console.log(`[pty:${this.config.name}] [RELAY-DEBUG] Found ${relayLines.length} lines with ->relay: pattern`);
+            relayLines.slice(0, 3).forEach((line, i) => {
+                console.log(`[pty:${this.config.name}] [RELAY-DEBUG] Line ${i}: "${line.substring(0, 80)}..."`);
+            });
+        }
         // First, try to find fenced multi-line messages: ->relay:Target <<<\n...\n>>>
         this.parseFencedMessages(contentToParse);
         // Then parse single-line messages
@@ -610,6 +647,7 @@ export class PtyWrapper extends BaseWrapper {
             }
             // Skip placeholder targets (documentation examples like "AgentName", "Lead", etc.)
             if (isPlaceholderTarget(target)) {
+                console.error(`[pty-wrapper] Filtered fenced message - placeholder target: ${target}`);
                 continue;
             }
             // Find the closing >>>
@@ -630,6 +668,7 @@ export class PtyWrapper extends BaseWrapper {
             }
             // Skip placeholder targets after parsing cross-project syntax
             if (isPlaceholderTarget(to)) {
+                console.error(`[pty-wrapper] Filtered fenced message - placeholder target after cross-project parse: ${to}`);
                 continue;
             }
             this.sendRelayCommand({
@@ -676,8 +715,10 @@ export class PtyWrapper extends BaseWrapper {
                 if (!body)
                     continue;
                 // Skip placeholder targets (documentation examples)
-                if (isPlaceholderTarget(target))
+                if (isPlaceholderTarget(target)) {
+                    console.error(`[pty-wrapper] Filtered single-line message - placeholder target: ${target}`);
                     continue;
+                }
                 // Parse target for cross-project syntax
                 const colonIdx = target.indexOf(':');
                 let to = target;
@@ -687,8 +728,10 @@ export class PtyWrapper extends BaseWrapper {
                     to = target.substring(colonIdx + 1);
                 }
                 // Skip placeholder targets after parsing cross-project syntax
-                if (isPlaceholderTarget(to))
+                if (isPlaceholderTarget(to)) {
+                    console.error(`[pty-wrapper] Filtered single-line message - placeholder target after cross-project parse: ${to}`);
                     continue;
+                }
                 this.sendRelayCommand({
                     to,
                     kind: 'message',
@@ -702,8 +745,10 @@ export class PtyWrapper extends BaseWrapper {
             if (!body)
                 continue;
             // Skip placeholder targets (documentation examples)
-            if (isPlaceholderTarget(target))
+            if (isPlaceholderTarget(target)) {
+                console.error(`[pty-wrapper] Filtered single-line message - placeholder target: ${target}`);
                 continue;
+            }
             // Parse target for cross-project syntax
             const colonIdx = target.indexOf(':');
             let to = target;
@@ -713,8 +758,10 @@ export class PtyWrapper extends BaseWrapper {
                 to = target.substring(colonIdx + 1);
             }
             // Skip placeholder targets after parsing cross-project syntax
-            if (isPlaceholderTarget(to))
+            if (isPlaceholderTarget(to)) {
+                console.error(`[pty-wrapper] Filtered single-line message - placeholder target after cross-project parse: ${to}`);
                 continue;
+            }
             this.sendRelayCommand({
                 to,
                 kind: 'message',
@@ -948,22 +995,24 @@ export class PtyWrapper extends BaseWrapper {
     }
     /**
      * Execute spawn via API or callback.
-     * Overrides BaseWrapper to add PTY-specific logging and API path.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     async executeSpawn(name, cli, task) {
         console.log(`[pty:${this.config.name}] [SPAWN-DEBUG] executeSpawn called: name=${name}, cli=${cli}, task="${task.substring(0, 50)}..."`);
         console.log(`[pty:${this.config.name}] [SPAWN-DEBUG] dashboardPort=${this.config.dashboardPort}, hasOnSpawn=${!!this.config.onSpawn}`);
+        let spawned = false;
         if (this.config.dashboardPort) {
             // Use dashboard API for spawning (works from spawned agents)
             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 }),
+                    body: JSON.stringify({ name, cli }), // No task - we send it after agent is online
                 });
                 const result = await response.json();
                 if (result.success) {
                     console.log(`[pty:${this.config.name}] Spawned ${name} via API`);
+                    spawned = true;
                 }
                 else {
                     console.error(`[pty:${this.config.name}] Spawn failed: ${result.error}`);
@@ -977,11 +1026,57 @@ export class PtyWrapper extends BaseWrapper {
             // Fall back to callback
             try {
                 await this.config.onSpawn(name, cli, task);
+                spawned = true;
             }
             catch (err) {
                 console.error(`[pty:${this.config.name}] Spawn failed: ${err.message}`);
             }
         }
+        // If spawn succeeded and we have a task, wait for agent to come online and send it
+        if (spawned && task && task.trim() && this.config.dashboardPort) {
+            await this.waitAndSendTask(name, task);
+        }
+    }
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    async waitAndSendTask(agentName, task) {
+        const maxWaitMs = 30000;
+        const pollIntervalMs = 500;
+        const startTime = Date.now();
+        console.log(`[pty:${this.config.name}] Waiting for ${agentName} to come online...`);
+        // Poll for agent to be online using dedicated status endpoint
+        while (Date.now() - startTime < maxWaitMs) {
+            try {
+                const response = await fetch(`http://localhost:${this.config.dashboardPort}/api/agents/${encodeURIComponent(agentName)}/online`);
+                const data = await response.json();
+                if (data.online) {
+                    console.log(`[pty:${this.config.name}] ${agentName} is online, sending task...`);
+                    // Send task directly via our relay client (not dashboard API)
+                    // This ensures the message comes "from" this agent, not from _DashboardUI
+                    if (this.client.state === 'READY') {
+                        const sent = this.client.sendMessage(agentName, task, 'message');
+                        if (sent) {
+                            console.log(`[pty:${this.config.name}] Task sent to ${agentName}`);
+                        }
+                        else {
+                            console.error(`[pty:${this.config.name}] Failed to send task to ${agentName}: sendMessage returned false`);
+                        }
+                    }
+                    else {
+                        console.error(`[pty:${this.config.name}] Failed to send task to ${agentName}: relay client not ready (state: ${this.client.state})`);
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                // Ignore poll errors, keep trying
+            }
+            await sleep(pollIntervalMs);
+        }
+        console.error(`[pty:${this.config.name}] Timeout waiting for ${agentName} to come online`);
     }
     /**
      * Execute release via API or callback.
@@ -1021,6 +1116,8 @@ export class PtyWrapper extends BaseWrapper {
      * Extends BaseWrapper to add PTY-specific behavior.
      */
     handleIncomingMessage(from, payload, messageId, meta, originalTo) {
+        const bodyPreview = payload.body.substring(0, 50).replace(/\n/g, '\\n');
+        console.log(`[pty:${this.config.name}] Message received from ${from}: "${bodyPreview}..." (readyForMessages=${this.readyForMessages}, queueLen=${this.messageQueue.length})`);
         // Call base class to handle deduplication and queuing
         super.handleIncomingMessage(from, payload, messageId, meta, originalTo);
         // PTY-specific: Process the message queue immediately
@@ -1032,27 +1129,14 @@ export class PtyWrapper extends BaseWrapper {
     }
     /**
      * Wait for output to stabilize before injection.
-     * Returns true if output has been stable for the required duration.
+     * Uses UniversalIdleDetector (from BaseWrapper) for robust cross-CLI idle detection.
+     * Returns true if agent is idle and ready for input.
      */
     async waitForOutputStable() {
-        const startTime = Date.now();
-        let stablePolls = 0;
-        let lastBufferLength = this.rawBuffer.length;
-        while (Date.now() - startTime < INJECTION_CONSTANTS.STABILITY_TIMEOUT_MS) {
-            await sleep(INJECTION_CONSTANTS.STABILITY_POLL_MS);
-            const timeSinceOutput = Date.now() - this.lastOutputTime;
-            const bufferUnchanged = this.rawBuffer.length === lastBufferLength;
-            // Consider stable if no output for at least one poll interval
-            if (timeSinceOutput >= INJECTION_CONSTANTS.STABILITY_POLL_MS && bufferUnchanged) {
-                stablePolls++;
-                if (stablePolls >= INJECTION_CONSTANTS.REQUIRED_STABLE_POLLS) {
-                    return true;
-                }
-            }
-            else {
-                stablePolls = 0;
-                lastBufferLength = this.rawBuffer.length;
-            }
+        const result = await this.waitForIdleState(INJECTION_CONSTANTS.STABILITY_TIMEOUT_MS, INJECTION_CONSTANTS.STABILITY_POLL_MS);
+        if (result.isIdle) {
+            console.log(`[pty:${this.config.name}] Idle detected (confidence: ${(result.confidence * 100).toFixed(0)}%)`);
+            return true;
         }
         // Timeout - return true anyway to avoid blocking forever
         console.warn(`[pty:${this.config.name}] Stability timeout, proceeding with injection`);
@@ -1090,6 +1174,8 @@ export class PtyWrapper extends BaseWrapper {
             this.isInjecting = false;
             return;
         }
+        const bodyPreview = msg.body.substring(0, 50).replace(/\n/g, '\\n');
+        console.log(`[pty:${this.config.name}] Processing message from ${msg.from}: "${bodyPreview}..." (remaining=${this.messageQueue.length})`);
         try {
             // Wait for output to stabilize before injecting
             await this.waitForOutputStable();
@@ -1128,9 +1214,21 @@ export class PtyWrapper extends BaseWrapper {
                     if (!this.ptyProcess || !this.running) {
                         throw new Error('PTY process not running');
                     }
-                    // Write message to PTY, then send Enter separately after a small delay
-                    this.ptyProcess.write(inj);
-                    await sleep(INJECTION_CONSTANTS.ENTER_DELAY_MS);
+                    // Use bracketed paste mode for CLIs that support it (claude, codex, gemini)
+                    // This prevents interleaving with CLI output and ensures clean input
+                    const useBracketedPaste = this.cliType === 'claude' || this.cliType === 'codex' || this.cliType === 'gemini';
+                    if (useBracketedPaste) {
+                        // Bracketed paste: \x1b[200~ starts paste, \x1b[201~ ends paste
+                        this.ptyProcess.write('\x1b[200~' + inj + '\x1b[201~');
+                    }
+                    else {
+                        this.ptyProcess.write(inj);
+                    }
+                    // Wait longer for CLI to process the pasted content before sending Enter.
+                    // The standard 50ms delay is too short for CLIs like Claude that need time
+                    // to process bracketed paste content before accepting Enter.
+                    await sleep(200);
+                    // Send Enter key - use \r for PTY (carriage return)
                     this.ptyProcess.write('\r');
                 },
                 log: (message) => console.log(`[pty:${this.config.name}] ${message}`),
@@ -1175,6 +1273,8 @@ export class PtyWrapper extends BaseWrapper {
     injectInstructions() {
         if (!this.running)
             return;
+        if (this.config.skipInstructions)
+            return;
         // Guard: Only inject once per session
         if (this.instructionsInjected) {
             console.log(`[pty:${this.config.name}] Init instructions already injected, skipping`);

package/dist/wrapper/shared.d.ts

@@ -53,7 +53,7 @@ export declare const INJECTION_CONSTANTS: {
     /** Timeout for injection verification (ms) */
     readonly VERIFICATION_TIMEOUT_MS: 2000;
     /** Delay between message and Enter key (ms) */
-    readonly ENTER_DELAY_MS: 50;
+    readonly ENTER_DELAY_MS: 100;
     /** Backoff multiplier for retries (ms per attempt) */
     readonly RETRY_BACKOFF_MS: 300;
     /** Delay between processing queued messages (ms) */

package/dist/wrapper/shared.js

@@ -19,7 +19,7 @@ export const INJECTION_CONSTANTS = {
     /** Timeout for injection verification (ms) */
     VERIFICATION_TIMEOUT_MS: 2000,
     /** Delay between message and Enter key (ms) */
-    ENTER_DELAY_MS: 50,
+    ENTER_DELAY_MS: 100,
     /** Backoff multiplier for retries (ms per attempt) */
     RETRY_BACKOFF_MS: 300,
     /** Delay between processing queued messages (ms) */

package/dist/wrapper/tmux-wrapper.d.ts

@@ -127,6 +127,16 @@ export declare class TmuxWrapper extends BaseWrapper {
      * Initialize agent ID for continuity/resume functionality (uses logStderr for tmux)
      */
     protected initializeAgentId(): Promise<void>;
+    /**
+     * Initialize the idle detector with the tmux pane PID.
+     * This enables process state inspection on Linux for more reliable idle detection.
+     */
+    private initializeIdleDetectorPid;
+    /**
+     * Wait for the agent to be ready for input.
+     * Uses idle detection instead of a fixed delay.
+     */
+    private waitForAgentReady;
     /**
      * Inject usage instructions for the agent including persistence protocol
      */
@@ -222,9 +232,16 @@ export declare class TmuxWrapper extends BaseWrapper {
      */
     private parseSessionEndAndClose;
     /**
-     * Execute spawn via API (if dashboardPort set) or callback
+     * Execute spawn via API (if dashboardPort set) or callback.
+     * After spawning, waits for the agent to come online and sends the task via relay.
      */
     protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
+    /**
+     * Wait for a spawned agent to come online, then send the task via relay.
+     * Uses the wrapper's own relay client so the message comes "from" this agent,
+     * not from the dashboard's relay client.
+     */
+    private waitAndSendTask;
     /**
      * Execute release via API (if dashboardPort set) or callback
      */
@@ -246,7 +263,8 @@ export declare class TmuxWrapper extends BaseWrapper {
      */
     protected handleIncomingMessage(from: string, payload: SendPayload, messageId: string, meta?: SendMeta, originalTo?: string): void;
     /**
-     * Check if we should inject a message
+     * Check if we should inject a message.
+     * Uses UniversalIdleDetector (from BaseWrapper) for robust cross-CLI idle detection.
      */
     private checkForInjectionOpportunity;
     /**