@agent-relay/wrapper 2.0.18 → 2.0.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-relay/wrapper",
-  "version": "2.0.18",
+  "version": "2.0.20",
   "description": "CLI agent wrappers for Agent Relay - tmux, pty integration",
   "type": "module",
   "main": "dist/index.js",
@@ -30,11 +30,11 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@agent-relay/api-types": "2.0.18",
-    "@agent-relay/protocol": "2.0.18",
-    "@agent-relay/config": "2.0.18",
-    "@agent-relay/continuity": "2.0.18",
-    "@agent-relay/resiliency": "2.0.18"
+    "@agent-relay/api-types": "2.0.20",
+    "@agent-relay/protocol": "2.0.20",
+    "@agent-relay/config": "2.0.20",
+    "@agent-relay/continuity": "2.0.20",
+    "@agent-relay/resiliency": "2.0.20"
   },
   "devDependencies": {
     "typescript": "^5.9.3",
@@ -59,5 +59,5 @@
     "url": "git+https://github.com/AgentWorkforce/relay.git",
     "directory": "packages/wrapper"
   },
-  "license": "MIT"
+  "license": "Apache-2.0"
 }

package/src/base-wrapper.test.ts

@@ -17,11 +17,16 @@ vi.mock('./client.js', () => ({
     name,
     state: 'READY' as string,
     sentMessages: [] as Array<{ to: string; body: string; kind: string; meta?: unknown }>,
+    sentChannelMessages: [] as Array<{ channel: string; body: string; options?: unknown }>,
     onMessage: null as ((from: string, payload: any, messageId: string, meta?: any, originalTo?: string) => void) | null,
     sendMessage: vi.fn().mockImplementation(function(this: any, to: string, body: string, kind: string, meta?: unknown) {
       this.sentMessages.push({ to, body, kind, meta });
       return true;
     }),
+    sendChannelMessage: vi.fn().mockImplementation(function(this: any, channel: string, body: string, options?: unknown) {
+      this.sentChannelMessages.push({ channel, body, options });
+      return true;
+    }),
     destroy: vi.fn(),
   })),
 }));
@@ -462,6 +467,50 @@ describe('BaseWrapper', () => {
 
       expect(wrapper.testClient.sentMessages).toHaveLength(0);
     });
+
+    it('does not add hash when client not ready (allows retry)', () => {
+      // First attempt - client not ready
+      wrapper.testClient.state = 'CONNECTING';
+      wrapper.testSendRelayCommand({ to: 'ReceiverAgent', body: 'Hello' });
+      expect(wrapper.testClient.sentMessages).toHaveLength(0);
+      expect(wrapper.testSentMessageHashes.size).toBe(0);
+
+      // Client becomes ready - retry should work
+      wrapper.testClient.state = 'READY';
+      wrapper.testSendRelayCommand({ to: 'ReceiverAgent', body: 'Hello' });
+      expect(wrapper.testClient.sentMessages).toHaveLength(1);
+      expect(wrapper.testSentMessageHashes.size).toBe(1);
+    });
+
+    it('uses sendChannelMessage for channel targets (starting with #)', () => {
+      wrapper.testSendRelayCommand({
+        to: '#general',
+        body: 'Hello channel!',
+        thread: 'thread-1',
+      });
+
+      // Should use channel message, not regular message
+      expect(wrapper.testClient.sentChannelMessages).toHaveLength(1);
+      expect(wrapper.testClient.sentMessages).toHaveLength(0);
+      expect(wrapper.testClient.sentChannelMessages[0].channel).toBe('#general');
+      expect(wrapper.testClient.sentChannelMessages[0].body).toBe('Hello channel!');
+    });
+
+    it('sends to different channels correctly', () => {
+      wrapper.testSendRelayCommand({ to: '#general', body: 'Hello general!' });
+      wrapper.testSendRelayCommand({ to: '#team', body: 'Hello team!' });
+
+      expect(wrapper.testClient.sentChannelMessages).toHaveLength(2);
+      expect(wrapper.testClient.sentMessages).toHaveLength(0);
+    });
+
+    it('uses sendMessage for non-channel targets', () => {
+      wrapper.testSendRelayCommand({ to: 'Bob', body: 'Direct message' });
+      wrapper.testSendRelayCommand({ to: '*', body: 'Broadcast message' });
+
+      expect(wrapper.testClient.sentMessages).toHaveLength(2);
+      expect(wrapper.testClient.sentChannelMessages).toHaveLength(0);
+    });
   });
 
   describe('joinContinuationLines', () => {

package/src/base-wrapper.ts

@@ -456,15 +456,8 @@ export abstract class BaseWrapper extends EventEmitter {
       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
+    // Only send if client ready - check BEFORE adding hash to avoid blocking retries
     if (this.client.state !== 'READY') {
       console.error(`[base-wrapper] Client not ready (state=${this.client.state}), dropping message to ${cmd.to}`);
       return;
@@ -481,14 +474,29 @@ export abstract class BaseWrapper extends EventEmitter {
       };
     }
 
+    // Helper to mark message as sent (only after successful transmission)
+    const markSent = () => {
+      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);
+      }
+    };
+
     // 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, {
+      const success = this.client.sendChannelMessage(cmd.to, cmd.body, {
         thread: cmd.thread,
         data: cmd.data,
       });
+      if (success) {
+        markSent();
+      } else {
+        console.error(`[base-wrapper] sendChannelMessage failed for ${cmd.to}`);
+      }
     } else {
       // Use SEND protocol for direct messages and broadcasts
       if (cmd.sync?.blocking) {
@@ -497,11 +505,18 @@ export abstract class BaseWrapper extends EventEmitter {
           kind: cmd.kind,
           data: cmd.data,
           thread: cmd.thread,
+        }).then(() => {
+          markSent();
         }).catch((err) => {
           console.error(`[base-wrapper] sendAndWait failed for ${cmd.to}: ${err.message}`);
         });
       } else {
-        this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread, sendMeta);
+        const success = this.client.sendMessage(cmd.to, cmd.body, cmd.kind, cmd.data, cmd.thread, sendMeta);
+        if (success) {
+          markSent();
+        } else {
+          console.error(`[base-wrapper] sendMessage failed for ${cmd.to}`);
+        }
       }
     }
   }

package/src/idle-detector.test.ts

@@ -386,5 +386,33 @@ describe('UniversalIdleDetector', () => {
       const result = detector.checkIdle();
       expect(result.inEditorMode).toBe(false);
     });
+
+    it('returns false for Claude CLI status bar (not actual vim)', () => {
+      // Claude CLI shows "-- INSERT --" followed by permission indicators
+      // This is NOT vim editor mode - it's Claude's vim keybindings mode
+      detector.onOutput('> Try "how do I log an error?"\n-- INSERT -- ⏵⏵ bypass permissions on (shift+tab to cycle)');
+      expect(detector.isInEditorMode()).toBe(false);
+    });
+
+    it('returns false for Claude CLI NORMAL mode status bar', () => {
+      detector.onOutput('> Try "how do I log an error?"\n-- NORMAL -- ⏵⏵ bypass permissions on');
+      expect(detector.isInEditorMode()).toBe(false);
+    });
+
+    it('returns false for Claude CLI with ▶ symbol', () => {
+      detector.onOutput('Some prompt\n-- INSERT -- ▶ strict mode');
+      expect(detector.isInEditorMode()).toBe(false);
+    });
+
+    it('still detects actual vim INSERT mode at end of line', () => {
+      // Vim shows "-- INSERT --" alone at the end of the line
+      detector.onOutput('~\n~\n-- INSERT --\n');
+      expect(detector.isInEditorMode()).toBe(true);
+    });
+
+    it('still detects vim INSERT mode with trailing whitespace', () => {
+      detector.onOutput('~\n-- INSERT --   ');
+      expect(detector.isInEditorMode()).toBe(true);
+    });
   });
 });

package/src/idle-detector.ts

@@ -142,20 +142,34 @@ export class UniversalIdleDetector {
   /**
    * Check if the agent is in an editor mode (vim INSERT, REPLACE, etc.).
    * When in editor mode, message injection should be delayed.
+   *
+   * Note: Claude CLI shows "-- INSERT --" in its status bar (for vim keybindings mode)
+   * but this is NOT the same as being in vim. We exclude Claude CLI's status bar
+   * by checking for the "⏵" symbol that follows its mode indicator.
    */
   isInEditorMode(): boolean {
     // Check the last portion of output for editor mode indicators
     const lastOutput = this.outputBuffer.slice(-500);
 
-    // Vim/Neovim mode indicators
+    // Claude CLI status bar pattern - this is NOT vim editor mode
+    // Example: "-- INSERT -- ⏵⏵ bypass permissions on (shift+tab to cycle)"
+    // Also match: "-- NORMAL --", "-- VISUAL --" followed by Claude's UI elements
+    const claudeCliStatusBar = /-- (?:INSERT|NORMAL|VISUAL|REPLACE) --\s*[⏵⏴►▶]/;
+    if (claudeCliStatusBar.test(lastOutput)) {
+      return false;
+    }
+
+    // Vim/Neovim mode indicators (standalone, not part of Claude CLI status)
+    // These patterns require the mode indicator to be at the end of a line
+    // or followed only by whitespace, which matches vim's actual display
     const editorModePatterns = [
-      /-- INSERT --/i,
-      /-- REPLACE --/i,
-      /-- VISUAL --/i,
-      /-- VISUAL LINE --/i,
-      /-- VISUAL BLOCK --/i,
-      /-- SELECT --/i,
-      /-- TERMINAL --/i,
+      /-- INSERT --\s*$/m,
+      /-- REPLACE --\s*$/m,
+      /-- VISUAL --\s*$/m,
+      /-- VISUAL LINE --\s*$/m,
+      /-- VISUAL BLOCK --\s*$/m,
+      /-- SELECT --\s*$/m,
+      /-- TERMINAL --\s*$/m,
       // Emacs indicators
       /\*\*\* Emacs/,
       /M-x/,

package/src/relay-pty-orchestrator.test.ts

@@ -135,6 +135,10 @@ describe('RelayPtyOrchestrator', () => {
     // Mock waitUntilCliReady to resolve immediately in tests
     // This avoids waiting for CLI readiness checks which require complex simulation
     vi.spyOn(RelayPtyOrchestrator.prototype, 'waitUntilCliReady').mockResolvedValue(true);
+
+    // Mock isProcessAlive to return true - the real implementation uses process.kill(pid, 0)
+    // which fails for mock PIDs that don't correspond to real processes
+    vi.spyOn(RelayPtyOrchestrator.prototype as any, 'isProcessAlive').mockReturnValue(true);
   });
 
   afterEach(async () => {

package/src/relay-pty-orchestrator.ts

@@ -251,6 +251,9 @@ export class RelayPtyOrchestrator extends BaseWrapper {
   // Track if agent is being gracefully stopped (vs crashed)
   private isGracefulStop = false;
 
+  // Track early process exit for better error messages
+  private earlyExitInfo?: { code: number | null; signal: NodeJS.Signals | null; stderr: string };
+
   // Memory/CPU monitoring
   private memoryMonitor: AgentMemoryMonitor;
   private memoryAlertHandler: ((alert: MemoryAlert) => void) | null = null;
@@ -574,7 +577,15 @@ export class RelayPtyOrchestrator extends BaseWrapper {
 
     this.log(` Using binary: ${binaryPath}`);
 
-    // Connect to relay daemon first
+    // Spawn relay-pty process FIRST (before connecting to daemon)
+    // This ensures the CLI is actually running before we register with the daemon
+    await this.spawnRelayPty(binaryPath);
+
+    // Wait for socket to become available and connect
+    await this.connectToSocket();
+
+    // Connect to relay daemon AFTER CLI is spawned
+    // This prevents the spawner from seeing us as "registered" before the CLI runs
     try {
       await this.client.connect();
       this.log(` Relay daemon connected`);
@@ -582,12 +593,6 @@ export class RelayPtyOrchestrator extends BaseWrapper {
       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;
     // DON'T set readyForMessages yet - wait for CLI to be ready first
     // This prevents messages from being injected during CLI startup
@@ -754,6 +759,9 @@ export class RelayPtyOrchestrator extends BaseWrapper {
 
     this.log(` Spawning: ${binaryPath} ${args.join(' ')}`);
 
+    // Reset early exit info from any previous spawn attempt
+    this.earlyExitInfo = undefined;
+
     // 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
@@ -783,10 +791,15 @@ export class RelayPtyOrchestrator extends BaseWrapper {
       });
     }
 
+    // Capture stderr for early exit diagnosis
+    let stderrBuffer = '';
+
     // Handle stderr (relay-pty logs and JSON output) - always needed
+    // Also captures to buffer for error diagnostics if process dies early
     if (proc.stderr) {
       proc.stderr.on('data', (data: Buffer) => {
         const text = data.toString();
+        stderrBuffer += text;
         this.handleStderr(text);
       });
     }
@@ -795,6 +808,12 @@ export class RelayPtyOrchestrator extends BaseWrapper {
     proc.on('exit', (code, signal) => {
       const exitCode = code ?? (signal === 'SIGKILL' ? 137 : 1);
       this.log(` Process exited: code=${exitCode} signal=${signal}`);
+
+      // Capture early exit info for better error messages if socket not yet connected
+      if (!this.socketConnected) {
+        this.earlyExitInfo = { code, signal, stderr: stderrBuffer };
+      }
+
       this.running = false;
 
       // Get crash context before unregistering from memory monitor
@@ -1213,6 +1232,22 @@ export class RelayPtyOrchestrator extends BaseWrapper {
   // Socket communication
   // =========================================================================
 
+  /**
+   * Check if the relay-pty process is still alive
+   */
+  private isProcessAlive(): boolean {
+    if (!this.relayPtyProcess || this.relayPtyProcess.exitCode !== null) {
+      return false;
+    }
+    try {
+      // Signal 0 checks if process exists without killing it
+      process.kill(this.relayPtyProcess.pid!, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
   /**
    * Connect to the relay-pty socket
    */
@@ -1221,6 +1256,21 @@ export class RelayPtyOrchestrator extends BaseWrapper {
     const maxAttempts = this.config.socketReconnectAttempts ?? 3;
 
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      // Check if relay-pty process died before attempting connection
+      if (!this.isProcessAlive()) {
+        const exitInfo = this.earlyExitInfo;
+        if (exitInfo) {
+          const exitReason = exitInfo.signal
+            ? `signal ${exitInfo.signal}`
+            : `code ${exitInfo.code ?? 'unknown'}`;
+          const stderrHint = exitInfo.stderr
+            ? `\n  stderr: ${exitInfo.stderr.trim().slice(0, 500)}`
+            : '';
+          throw new Error(`relay-pty process died early (${exitReason}).${stderrHint}`);
+        }
+        throw new Error('relay-pty process died before socket could be created');
+      }
+
       try {
         await this.attemptSocketConnection(timeout);
         this.log(` Socket connected`);
@@ -1233,6 +1283,18 @@ export class RelayPtyOrchestrator extends BaseWrapper {
       }
     }
 
+    // Final check for process death after all attempts
+    if (!this.isProcessAlive() && this.earlyExitInfo) {
+      const exitInfo = this.earlyExitInfo;
+      const exitReason = exitInfo.signal
+        ? `signal ${exitInfo.signal}`
+        : `code ${exitInfo.code ?? 'unknown'}`;
+      const stderrHint = exitInfo.stderr
+        ? `\n  stderr: ${exitInfo.stderr.trim().slice(0, 500)}`
+        : '';
+      throw new Error(`relay-pty process died during socket connection (${exitReason}).${stderrHint}`);
+    }
+
     throw new Error(`Failed to connect to socket after ${maxAttempts} attempts`);
   }
 

package/src/tmux-wrapper.ts

@@ -969,6 +969,23 @@ export class TmuxWrapper extends BaseWrapper {
       };
     }
 
+    // Check if target is a channel (starts with #)
+    if (cmd.to.startsWith('#')) {
+      // Use CHANNEL_MESSAGE protocol for channel targets
+      this.logStderr(`→ [channel] ${cmd.to}: ${cmd.body.substring(0, Math.min(RELAY_LOG_TRUNCATE_LENGTH, cmd.body.length))}...`);
+      const success = this.client.sendChannelMessage(cmd.to, cmd.body, {
+        thread: cmd.thread,
+        data: cmd.data,
+      });
+      if (success) {
+        this.sentMessageHashes.add(msgHash);
+        this.queuedMessageHashes.delete(msgHash);
+        this.trajectory?.message('sent', this.config.name, cmd.to, cmd.body);
+      }
+      return;
+    }
+
+    // Use SEND protocol for direct messages and broadcasts
     if (cmd.sync?.blocking) {
       this.client.sendAndWait(cmd.to, cmd.body, {
         timeoutMs: cmd.sync.timeoutMs,