agent-relay 1.3.1 → 1.3.3

package/dist/wrapper/tmux-wrapper.js

@@ -26,6 +26,8 @@ import { getTrajectoryIntegration, detectPhaseFromContent, detectToolCalls, dete
 import { escapeForShell } from '../bridge/utils.js';
 import { detectProviderAuthRevocation } from './auth-detection.js';
 import { stripAnsi, sleep, getDefaultRelayPrefix, buildInjectionString, injectWithRetry as sharedInjectWithRetry, INJECTION_CONSTANTS, CLI_QUIRKS, } from './shared.js';
+import { getTmuxPanePid } from './idle-detector.js';
+import { DEFAULT_TMUX_WRAPPER_CONFIG } from '../config/relay-config.js';
 const execAsync = promisify(exec);
 // Constants for cursor stability detection in waitForClearInput
 /** Number of consecutive polls with stable cursor before assuming input is clear */
@@ -82,16 +84,7 @@ export class TmuxWrapper extends BaseWrapper {
         const mergedConfig = {
             cols: process.stdout.columns || 120,
             rows: process.stdout.rows || 40,
-            pollInterval: 200, // Slightly slower polling since we're not displaying
-            idleBeforeInjectMs: 1500,
-            injectRetryMs: 500,
-            debug: false,
-            debugLogIntervalMs: 0,
-            mouseMode: true, // Enable mouse scroll passthrough by default
-            activityIdleThresholdMs: 30_000, // Consider idle after 30s with no output
-            outputStabilityTimeoutMs: 2000,
-            outputStabilityPollMs: 200,
-            streamLogs: true, // Stream output to daemon for dashboard
+            ...DEFAULT_TMUX_WRAPPER_CONFIG,
             ...config,
         };
         // Call parent constructor (initializes client, cliType, relayPrefix, continuity)
@@ -225,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;
         });
@@ -337,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}`);
@@ -353,10 +357,19 @@ export class TmuxWrapper extends BaseWrapper {
         this.initializeTrajectory();
         // Initialize continuity and get/create agentId
         this.initializeAgentId();
-        // Inject instructions for the agent (after a delay to let CLI initialize)
-        setTimeout(() => this.injectInstructions(), 3000);
         // Start background polling (silent - no stdout writes)
         this.startSilentPolling();
+        // Initialize idle detector with the tmux pane PID for process state inspection
+        this.initializeIdleDetectorPid();
+        // Wait for agent to be ready, then inject instructions
+        // This replaces the fixed 3-second delay with actual readiness detection
+        this.waitForAgentReady().then(() => {
+            this.injectInstructions();
+        }).catch(err => {
+            this.logStderr(`Failed to wait for agent ready: ${err.message}`, true);
+            // Fall back to injecting after a delay
+            setTimeout(() => this.injectInstructions(), 3000);
+        });
         // Attach user to tmux session
         // This takes over stdin/stdout - user sees the real terminal
         this.attachToSession();
@@ -409,12 +422,49 @@ export class TmuxWrapper extends BaseWrapper {
             this.logStderr(`Failed to initialize agent ID: ${err.message}`, true);
         }
     }
+    /**
+     * Initialize the idle detector with the tmux pane PID.
+     * This enables process state inspection on Linux for more reliable idle detection.
+     */
+    async initializeIdleDetectorPid() {
+        try {
+            const pid = await getTmuxPanePid(this.tmuxPath, this.sessionName);
+            if (pid) {
+                this.setIdleDetectorPid(pid);
+                this.logStderr(`Idle detector initialized with PID ${pid}`);
+            }
+            else {
+                this.logStderr('Could not get pane PID for idle detection (will use output analysis)');
+            }
+        }
+        catch (err) {
+            this.logStderr(`Failed to initialize idle detector PID: ${err.message}`);
+        }
+    }
+    /**
+     * 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) {
+            this.logStderr(`Agent ready (confidence: ${(result.confidence * 100).toFixed(0)}%)`);
+        }
+        else {
+            this.logStderr('Agent readiness timeout, proceeding anyway');
+        }
+    }
     /**
      * Inject usage instructions for the agent including persistence protocol
      */
     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
@@ -586,6 +636,9 @@ export class TmuxWrapper extends BaseWrapper {
             if (stdout.length !== this.processedOutputLength) {
                 this.lastOutputTime = Date.now();
                 this.markActivity();
+                // Feed new output to idle detector for more robust idle detection
+                const newOutput = stdout.substring(this.processedOutputLength);
+                this.feedIdleDetectorOutput(newOutput);
                 this.processedOutputLength = stdout.length;
                 // Stream new output to daemon for dashboard log viewing
                 // Use filtered output to exclude thinking blocks and relay commands
@@ -713,8 +766,9 @@ export class TmuxWrapper extends BaseWrapper {
      */
     sendRelayCommand(cmd) {
         const msgHash = `${cmd.to}:${cmd.body}`;
-        // Permanent dedup - never send the same message twice (silent)
+        // Permanent dedup - never send the same message twice
         if (this.sentMessageHashes.has(msgHash)) {
+            this.logStderr(`[DEDUP] Skipped duplicate message to ${cmd.to} (hash already sent)`);
             return;
         }
         // If client not ready, queue for later and return
@@ -950,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);
@@ -977,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
@@ -1028,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');
@@ -1038,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)
@@ -1177,7 +1290,8 @@ export class TmuxWrapper extends BaseWrapper {
         this.checkForInjectionOpportunity();
     }
     /**
-     * Check if we should inject a message
+     * Check if we should inject a message.
+     * Uses UniversalIdleDetector (from BaseWrapper) for robust cross-CLI idle detection.
      */
     checkForInjectionOpportunity() {
         if (this.messageQueue.length === 0)
@@ -1186,9 +1300,10 @@ export class TmuxWrapper extends BaseWrapper {
             return;
         if (!this.running)
             return;
-        // Wait for output to settle (agent might be busy)
-        const timeSinceOutput = Date.now() - this.lastOutputTime;
-        if (timeSinceOutput < (this.config.idleBeforeInjectMs ?? 1500)) {
+        // Use universal idle detector for more reliable detection (inherited from BaseWrapper)
+        const idleResult = this.checkIdleForInjection();
+        if (!idleResult.isIdle) {
+            // Not idle yet, retry later
             const retryMs = this.config.injectRetryMs ?? 500;
             setTimeout(() => this.checkForInjectionOpportunity(), retryMs);
             return;
@@ -1204,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);
@@ -1268,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');
                 },
@@ -1319,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
@@ -1334,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.
@@ -1350,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.1",
+  "version": "1.3.3",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.js",
@@ -41,6 +41,8 @@
     "clean": "rm -rf dist",
     "db:generate": "drizzle-kit generate",
     "db:migrate": "drizzle-kit migrate",
+    "db:migrate:run": "node scripts/run-migrations.js",
+    "db:migrate:verify": "node scripts/verify-schema.js",
     "db:push": "drizzle-kit push",
     "db:studio": "drizzle-kit studio",
     "services:up": "docker compose -f docker-compose.dev.yml up -d postgres redis && echo '✓ Postgres and Redis running'",

package/scripts/run-migrations.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+/**
+ * Run database migrations (standalone)
+ *
+ * This script is used in CI to verify migrations run successfully.
+ * It connects to the database and runs all pending migrations.
+ *
+ * This is a standalone script that doesn't depend on the cloud config,
+ * so it only requires DATABASE_URL to run.
+ *
+ * Usage: DATABASE_URL=postgres://... node scripts/run-migrations.js
+ */
+
+import pg from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { migrate } from 'drizzle-orm/node-postgres/migrator';
+
+const { Pool } = pg;
+
+async function main() {
+  console.log('Starting database migrations...');
+  console.log(`Database URL: ${process.env.DATABASE_URL?.replace(/:[^:@]+@/, ':***@') || 'not set'}`);
+
+  if (!process.env.DATABASE_URL) {
+    console.error('ERROR: DATABASE_URL environment variable is required');
+    process.exit(1);
+  }
+
+  const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+  const db = drizzle(pool);
+
+  try {
+    await migrate(db, { migrationsFolder: './src/cloud/db/migrations' });
+    console.log('All migrations completed successfully');
+  } catch (error) {
+    console.error('Migration failed:', error);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main();

package/scripts/verify-schema.js

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+/**
+ * Verify database schema after migrations
+ *
+ * This script verifies that all expected tables exist after migrations.
+ * It dynamically reads table definitions from the schema to avoid hardcoding.
+ *
+ * Usage: DATABASE_URL=postgres://... node scripts/verify-schema.js
+ */
+
+import pg from 'pg';
+import * as schema from '../dist/cloud/db/schema.js';
+
+const { Pool } = pg;
+
+/**
+ * Extract table names from the schema module.
+ * Drizzle pgTable objects store their name in Symbol.for('drizzle:Name').
+ */
+function getTablesFromSchema() {
+  const tables = [];
+  const drizzleNameSymbol = Symbol.for('drizzle:Name');
+
+  for (const [key, value] of Object.entries(schema)) {
+    // Skip relation definitions (they end with 'Relations')
+    if (key.endsWith('Relations')) continue;
+
+    // Drizzle tables have the table name in a Symbol
+    if (value && typeof value === 'object' && value[drizzleNameSymbol]) {
+      tables.push(value[drizzleNameSymbol]);
+    }
+  }
+  return tables;
+}
+
+// Dynamically get tables from schema
+const SCHEMA_TABLES = getTablesFromSchema();
+const EXPECTED_TABLES = [...SCHEMA_TABLES];
+
+// Key columns to spot-check (subset of critical columns)
+const EXPECTED_COLUMNS = {
+  users: ['id', 'email', 'created_at'],
+  workspaces: ['id', 'user_id', 'name', 'status'],
+  linked_daemons: ['id', 'user_id', 'workspace_id', 'status'],
+};
+
+async function main() {
+  console.log('Verifying database schema...\n');
+
+  if (!process.env.DATABASE_URL) {
+    console.error('ERROR: DATABASE_URL environment variable is required');
+    process.exit(1);
+  }
+
+  console.log(`Found ${SCHEMA_TABLES.length} tables in schema.ts:`);
+  console.log(`  ${SCHEMA_TABLES.join(', ')}\n`);
+
+  const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+
+  try {
+    // Get all tables in the public schema
+    const tablesResult = await pool.query(`
+      SELECT table_name
+      FROM information_schema.tables
+      WHERE table_schema = 'public'
+      ORDER BY table_name
+    `);
+
+    const existingTables = tablesResult.rows.map((r) => r.table_name);
+    console.log('Existing tables:', existingTables.join(', '));
+    console.log('');
+
+    // Check for missing tables
+    const missingTables = EXPECTED_TABLES.filter((t) => !existingTables.includes(t));
+    if (missingTables.length > 0) {
+      console.error('MISSING TABLES:', missingTables.join(', '));
+      process.exit(1);
+    }
+    console.log(`All ${EXPECTED_TABLES.length} expected tables exist`);
+
+    // Verify key columns
+    console.log('\nVerifying key columns...');
+    for (const [table, columns] of Object.entries(EXPECTED_COLUMNS)) {
+      const columnsResult = await pool.query(
+        `
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_schema = 'public' AND table_name = $1
+      `,
+        [table]
+      );
+
+      const existingColumns = columnsResult.rows.map((r) => r.column_name);
+      const missingColumns = columns.filter((c) => !existingColumns.includes(c));
+
+      if (missingColumns.length > 0) {
+        console.error(`Table '${table}' missing columns: ${missingColumns.join(', ')}`);
+        console.error(`Existing columns: ${existingColumns.join(', ')}`);
+        process.exit(1);
+      }
+      console.log(`  ${table}: OK (${columns.length} key columns verified)`);
+    }
+
+    // Check migration history (table may be in public or drizzle schema)
+    try {
+      // Try public schema first, then drizzle schema
+      let migrationsResult;
+      try {
+        migrationsResult = await pool.query(`
+          SELECT id, hash, created_at FROM public.__drizzle_migrations ORDER BY created_at
+        `);
+      } catch {
+        migrationsResult = await pool.query(`
+          SELECT id, hash, created_at FROM drizzle.__drizzle_migrations ORDER BY created_at
+        `);
+      }
+      console.log(`\nMigration history: ${migrationsResult.rows.length} migrations applied`);
+      for (const row of migrationsResult.rows) {
+        console.log(`  - ${row.id} (${new Date(Number(row.created_at)).toISOString()})`);
+      }
+    } catch {
+      console.log('\nMigration history: (table not found, but migrations ran successfully)');
+    }
+
+    console.log('\nSchema verification passed!');
+  } catch (error) {
+    console.error('Schema verification failed:', error);
+    process.exit(1);
+  } finally {
+    await pool.end();
+  }
+}
+
+main();