agent-relay 1.3.2 → 1.3.3

package/dist/wrapper/tmux-wrapper.js

@@ -218,11 +218,18 @@ export class TmuxWrapper extends BaseWrapper {
         if (!this.config.args || this.config.args.length === 0) {
             return this.config.command;
         }
-        // Quote any argument that contains spaces, quotes, or special chars
+        // Quote any argument that contains spaces, quotes, or shell special chars
+        // Must handle: spaces, quotes, $, <, >, |, &, ;, (, ), `, etc.
         const quotedArgs = this.config.args.map(arg => {
-            if (arg.includes(' ') || arg.includes('"') || arg.includes("'") || arg.includes('$')) {
-                // Use double quotes and escape internal quotes
-                return `"${arg.replace(/"/g, '\\"')}"`;
+            if (/[\s"'$<>|&;()`,!\\]/.test(arg)) {
+                // Use double quotes and escape internal quotes and special chars
+                const escaped = arg
+                    .replace(/\\/g, '\\\\')
+                    .replace(/"/g, '\\"')
+                    .replace(/\$/g, '\\$')
+                    .replace(/`/g, '\\`')
+                    .replace(/!/g, '\\!');
+                return `"${escaped}"`;
             }
             return arg;
         });
@@ -330,9 +337,13 @@ export class TmuxWrapper extends BaseWrapper {
             // Wait for shell to be ready (look for prompt)
             await this.waitForShellReady();
             // Send the command to run
+            this.logStderr('Sending command to tmux...');
             await this.sendKeysLiteral(fullCommand);
-            await sleep(100);
+            await sleep(300); // Give shell time to process the command literal
+            this.logStderr('Sending Enter...');
             await this.sendKeys('Enter');
+            await sleep(500); // Ensure Enter is processed and command starts before we continue
+            this.logStderr('Command sent');
         }
         catch (err) {
             throw new Error(`Failed to create tmux session: ${err.message}`);
@@ -452,6 +463,8 @@ export class TmuxWrapper extends BaseWrapper {
     async injectInstructions() {
         if (!this.running)
             return;
+        if (this.config.skipInstructions)
+            return;
         // Use escaped prefix (\->relay:) in examples to prevent parser from treating them as real commands
         const escapedPrefix = '\\' + this.relayPrefix;
         // Build instructions including relay and trail
@@ -991,20 +1004,23 @@ export class TmuxWrapper extends BaseWrapper {
         });
     }
     /**
-     * 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.
      */
     async executeSpawn(name, cli, task) {
+        let spawned = false;
         if (this.config.dashboardPort) {
             // Use dashboard API for spawning (works from any context, no terminal required)
             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) {
                     this.logStderr(`Spawned ${name} via API`);
+                    spawned = true;
                 }
                 else {
                     this.logStderr(`Spawn failed: ${result.error}`, true);
@@ -1018,11 +1034,57 @@ export class TmuxWrapper extends BaseWrapper {
             // Fall back to callback
             try {
                 await this.config.onSpawn(name, cli, task);
+                spawned = true;
             }
             catch (err) {
                 this.logStderr(`Spawn failed: ${err.message}`, true);
             }
         }
+        // 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();
+        this.logStderr(`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) {
+                    this.logStderr(`${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) {
+                            this.logStderr(`Task sent to ${agentName}`);
+                        }
+                        else {
+                            this.logStderr(`Failed to send task to ${agentName}: sendMessage returned false`, true);
+                        }
+                    }
+                    else {
+                        this.logStderr(`Failed to send task to ${agentName}: relay client not ready (state: ${this.client.state})`, true);
+                    }
+                    return;
+                }
+            }
+            catch (err) {
+                // Ignore poll errors, keep trying
+            }
+            await sleep(pollIntervalMs);
+        }
+        this.logStderr(`Timeout waiting for ${agentName} to come online`, true);
     }
     /**
      * Execute release via API (if dashboardPort set) or callback
@@ -1069,6 +1131,10 @@ export class TmuxWrapper extends BaseWrapper {
         // Only process if we have API or callbacks configured
         const canSpawn = this.config.dashboardPort || this.config.onSpawn;
         const canRelease = this.config.dashboardPort || this.config.onRelease;
+        // Debug: Log spawn capability status
+        if (content.includes('->relay:spawn')) {
+            this.logStderr(`[spawn-debug] canSpawn=${!!canSpawn} dashboardPort=${this.config.dashboardPort} hasOnSpawn=${!!this.config.onSpawn}`);
+        }
         if (!canSpawn && !canRelease)
             return;
         const lines = content.split('\n');
@@ -1079,6 +1145,12 @@ export class TmuxWrapper extends BaseWrapper {
             let trimmed = line.trim();
             // Strip common line prefixes (bullets, prompts) before checking for commands
             trimmed = trimmed.replace(linePrefixPattern, '');
+            // Fix for over-stripping: the linePrefixPattern includes - and > characters,
+            // which can accidentally strip the -> from ->relay:spawn, leaving just relay:spawn.
+            // If we detect this happened, restore the -> prefix.
+            if (/^(relay|thinking|continuity):/.test(trimmed)) {
+                trimmed = '->' + trimmed;
+            }
             // If we're in fenced spawn mode, accumulate lines until we see >>>
             if (this.pendingFencedSpawn) {
                 // Check for fence close (>>> at end of line or on its own line)
@@ -1236,11 +1308,6 @@ export class TmuxWrapper extends BaseWrapper {
             setTimeout(() => this.checkForInjectionOpportunity(), retryMs);
             return;
         }
-        // Log detection method in debug mode
-        if (this.config.debug && idleResult.signals.length > 0) {
-            const signalInfo = idleResult.signals.map(s => `${s.source}:${(s.confidence * 100).toFixed(0)}%`).join(', ');
-            this.logStderr(`Idle detected (${signalInfo})`);
-        }
         this.injectNextMessage();
     }
     /**
@@ -1252,19 +1319,16 @@ export class TmuxWrapper extends BaseWrapper {
         if (!msg)
             return;
         this.isInjecting = true;
-        this.logStderr(`Injecting message from ${msg.from} (cli: ${this.cliType})`);
         try {
             const shortId = msg.messageId.substring(0, 8);
             // Wait for input to be clear before injecting
             // If input is not clear (human typing), re-queue and try later - never clear forcefully!
-            // Fix for agent-relay-j9z: forceful clearing destroys human input in progress
             const waitTimeoutMs = this.config.inputWaitTimeoutMs ?? 5000;
             const waitPollMs = this.config.inputWaitPollMs ?? 200;
             const inputClear = await this.waitForClearInput(waitTimeoutMs, waitPollMs);
             if (!inputClear) {
                 // Input still has text after timeout - DON'T clear forcefully, re-queue instead
-                // This preserves any human input in progress
-                this.logStderr('Input not clear after waiting, re-queuing injection to preserve human input');
+                this.logStderr('Input not clear, re-queuing injection');
                 this.messageQueue.unshift(msg);
                 this.isInjecting = false;
                 setTimeout(() => this.checkForInjectionOpportunity(), this.config.injectRetryMs ?? 1000);
@@ -1316,7 +1380,9 @@ export class TmuxWrapper extends BaseWrapper {
                     }
                 },
                 performInjection: async (inj) => {
-                    await this.pasteLiteral(inj);
+                    // Use send-keys -l (literal) instead of paste-buffer
+                    // paste-buffer causes issues where Claude shows "[Pasted text]" but content doesn't appear
+                    await this.sendKeysLiteral(inj);
                     await sleep(INJECTION_CONSTANTS.ENTER_DELAY_MS);
                     await this.sendKeys('Enter');
                 },
@@ -1367,7 +1433,15 @@ export class TmuxWrapper extends BaseWrapper {
      * Send special keys to tmux
      */
     async sendKeys(keys) {
-        await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} ${keys}`);
+        const cmd = `"${this.tmuxPath}" send-keys -t ${this.sessionName} ${keys}`;
+        try {
+            await execAsync(cmd);
+            this.logStderr(`[sendKeys] Sent: ${keys}`);
+        }
+        catch (err) {
+            this.logStderr(`[sendKeys] Failed to send ${keys}: ${err.message}`, true);
+            throw err;
+        }
     }
     /**
      * Send literal text to tmux
@@ -1382,7 +1456,14 @@ export class TmuxWrapper extends BaseWrapper {
             .replace(/\$/g, '\\$')
             .replace(/`/g, '\\`')
             .replace(/!/g, '\\!');
-        await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} -l "${escaped}"`);
+        try {
+            await execAsync(`"${this.tmuxPath}" send-keys -t ${this.sessionName} -l "${escaped}"`);
+            this.logStderr(`[sendKeysLiteral] Sent ${text.length} chars`);
+        }
+        catch (err) {
+            this.logStderr(`[sendKeysLiteral] Failed: ${err.message}`, true);
+            throw err;
+        }
     }
     /**
      * Paste text using tmux buffer with optional bracketed paste to avoid interleaving with ongoing output.
@@ -1398,15 +1479,9 @@ export class TmuxWrapper extends BaseWrapper {
             .replace(/`/g, '\\`')
             .replace(/!/g, '\\!');
         // Set tmux buffer then paste
-        // Skip bracketed paste (-p) for CLIs that don't handle it properly (droid, other)
-        await execAsync(`"${this.tmuxPath}" set-buffer -- "${escaped}"`);
-        const useBracketedPaste = this.cliType === 'claude' || this.cliType === 'codex' || this.cliType === 'gemini' || this.cliType === 'opencode';
-        if (useBracketedPaste) {
-            await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName} -p`);
-        }
-        else {
-            await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName}`);
-        }
+        const setBufferCmd = `"${this.tmuxPath}" set-buffer -- "${escaped}"`;
+        await execAsync(setBufferCmd);
+        await execAsync(`"${this.tmuxPath}" paste-buffer -t ${this.sessionName}`);
     }
     /**
      * Reset session-specific state for wrapper reuse.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.js",
@@ -13,8 +13,9 @@
   },
   "scripts": {
     "postinstall": "npm rebuild better-sqlite3 && node scripts/postinstall.js",
-    "build": "npm run clean && tsc",
-    "postbuild": "chmod +x dist/cli/index.js",
+    "build": "npm run clean && tsc && npm run build:dashboard",
+    "build:dashboard": "cd src/dashboard && npm run build",
+    "postbuild": "chmod +x dist/cli/index.js && mkdir -p dist/dashboard && cp -r src/dashboard/out dist/dashboard/",
     "dev:watch": "tsc -w",
     "predev": "npm run clean && tsc && chmod +x dist/cli/index.js",
     "dev": "concurrently -n daemon,next -c blue,magenta \"npm run dev:daemon\" \"npm run dev:next\"",
@@ -26,6 +27,7 @@
     "dev:rebuild": "npm run build && echo '✓ Rebuilt (linked version updated)'",
     "start": "node dist/cli/index.js",
     "daemon": "node dist/daemon/server.js",
+    "dashboard": "node dist/dashboard-server/start.js",
     "pretest": "npm run build",
     "test": "vitest run",
     "test:integration": "vitest run test/cloud/*.integration.test.ts",