ai-agent-session-center 2.0.2 → 2.0.3

package/server/sshManager.js

@@ -53,6 +53,103 @@ function shellEscapeSingleQuote(str) {
   return str.replace(/'/g, "'\\''");
 }
 
+// ---- Shell Ready Detection ----
+
+// Match ANSI escape sequences (CSI + OSC + DEC private modes) for stripping from PTY output
+const ANSI_ESC_RE = /\x1b\[[\x20-\x3f]*[0-9;]*[a-zA-Z@]|\x1b\].*?(?:\x07|\x1b\\)/g;
+
+// Common shell prompt endings: $ (bash/zsh), % (zsh), # (root), > (fish/powershell),
+// ❯ (starship), ➜ (oh-my-zsh robbyrussell), → » λ (other popular themes)
+const SHELL_PROMPT_RE = /[#$%>❯➜→»λ]\s*$/;
+
+/**
+ * Watch PTY output to detect when the shell is ready (prompt visible).
+ * Resolves `true` when a prompt is detected, `false` on timeout or PTY exit.
+ *
+ * Strategy:
+ * 1. Watch for prompt patterns in PTY output (50ms settle timer to avoid MOTD false matches)
+ * 2. After `probeDelayMs`, send a bare Enter to the PTY — if the shell is ready, this
+ *    triggers a fresh prompt that gets detected immediately; if still loading, the Enter
+ *    is harmlessly buffered by the TTY driver
+ * 3. Hard timeout as final fallback (command will still work — PTY input is buffered)
+ *
+ * @param {import('node-pty').IPty} ptyProcess
+ * @param {string} terminalId - For logging
+ * @param {number} timeoutMs - Max wait time before fallback
+ * @param {number} probeDelayMs - Delay before sending Enter probe (0 to disable)
+ * @returns {Promise<boolean>}
+ */
+function detectShellReady(ptyProcess, terminalId, timeoutMs, probeDelayMs = 0) {
+  let resolveFn;
+  const promise = new Promise(r => { resolveFn = r; });
+  let buffer = '';
+  let done = false;
+  let settleTimer = null;
+  let probeTimer = null;
+
+  function finish(detected) {
+    if (done) return;
+    done = true;
+    clearTimeout(fallbackTimer);
+    clearTimeout(settleTimer);
+    clearTimeout(probeTimer);
+    dataDisp.dispose();
+    exitDisp.dispose();
+    resolveFn(detected);
+  }
+
+  function checkPrompt() {
+    const stripped = buffer.replace(ANSI_ESC_RE, '');
+    const lines = stripped.split(/[\r\n]+/);
+    // Find the last non-empty line
+    let lastLine = '';
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (lines[i].trim()) { lastLine = lines[i].trim(); break; }
+    }
+    // Shell prompts are short and end with $ % # >
+    if (lastLine && lastLine.length < 200 && SHELL_PROMPT_RE.test(lastLine)) {
+      log.debug('pty', `Shell prompt detected for ${terminalId}: "${lastLine.slice(-60)}"`);
+      finish(true);
+    }
+  }
+
+  const dataDisp = ptyProcess.onData((data) => {
+    if (done) return;
+    buffer += data;
+    // Cap buffer to avoid memory issues with large MOTD output
+    if (buffer.length > 4096) buffer = buffer.slice(-4096);
+    // Wait for output to settle (30ms of silence) before checking —
+    // MOTD lines arrive in bursts, but the final prompt is followed by silence
+    clearTimeout(settleTimer);
+    settleTimer = setTimeout(checkPrompt, 30);
+  });
+
+  const exitDisp = ptyProcess.onExit(() => {
+    log.debug('pty', `PTY ${terminalId} exited before shell ready detected`);
+    finish(false);
+  });
+
+  // Active probe: send Enter after delay to force a fresh prompt.
+  // This handles shells whose prompts don't match SHELL_PROMPT_RE
+  // (e.g., powerlevel10k, custom themes) — the new prompt after Enter
+  // gives another chance for detection, and even if detection still fails,
+  // the shorter hard timeout kicks in quickly.
+  if (probeDelayMs > 0) {
+    probeTimer = setTimeout(() => {
+      if (done) return;
+      log.debug('pty', `Sending Enter probe to ${terminalId} (no prompt detected after ${probeDelayMs}ms)`);
+      try { ptyProcess.write('\r'); } catch { /* pty may have exited */ }
+    }, probeDelayMs);
+  }
+
+  const fallbackTimer = setTimeout(() => {
+    log.warn('pty', `Shell ready detection timed out for ${terminalId} after ${timeoutMs}ms — sending command as fallback`);
+    finish(false);
+  }, timeoutMs);
+
+  return promise;
+}
+
 // List available SSH keys from ~/.ssh/
 export function listSshKeys() {
   const sshDir = join(homedir(), '.ssh');
@@ -207,6 +304,15 @@ export function createTerminal(config, wsClient) {
 
       log.info('pty', `Spawned ${local ? 'local' : `remote (${config.host})`} terminal ${terminalId} (pid: ${ptyProcess.pid})`);
 
+      // Detect when the shell is ready (prompt visible) before sending commands.
+      // Local shells init in ~100-300ms; remote SSH can take seconds for key exchange.
+      // Probe sends an Enter after delay to force a prompt for shells with unrecognized prompts.
+      const shellReady = detectShellReady(
+        ptyProcess, terminalId,
+        local ? 1200 : 3000,   // hard timeout
+        local ? 300 : 1000,    // Enter probe delay
+      );
+
       terminals.set(terminalId, {
         pty: ptyProcess,
         sessionId: null,
@@ -214,6 +320,7 @@ export function createTerminal(config, wsClient) {
         wsClient,
         createdAt: Date.now(),
         outputBuffer: Buffer.alloc(0),
+        shellReady,
       });
 
       // Register pending link for session matching
@@ -250,47 +357,64 @@ export function createTerminal(config, wsClient) {
         cleanup(terminalId);
       });
 
-      // Send the launch command after shell/SSH init
+      // Send the launch command once the shell is ready (prompt detected).
       // API keys are passed via env object to pty.spawn (above), not via shell commands.
       // For remote SSH sessions, we export the env var in the shell since env doesn't
       // propagate across SSH.
       // When skipAutoLaunch is true, the caller will write the command itself
       // (e.g., resume with || fallback that contains shell metacharacters).
       if (!skipAutoLaunch) {
-        setTimeout(() => {
-          let launchCmd;
-
-          if (config.tmuxSession) {
-            // Attach to existing tmux session (validated above as alphanumeric+dash+underscore+dot)
-            launchCmd = `tmux attach -t '${shellEscapeSingleQuote(config.tmuxSession)}'`;
-          } else if (config.useTmux) {
-            // Wrap command in a new tmux session
-            const tmuxName = `claude-${Date.now().toString(36)}`;
-            let innerCmd = local ? '' : `cd '${shellEscapeSingleQuote(workDir)}' && `;
-            if (!local && config.apiKey) {
+        // Build the launch command eagerly — only the write is deferred
+        let launchCmd;
+
+        if (config.tmuxSession) {
+          // Attach to existing tmux session (validated above as alphanumeric+dash+underscore+dot)
+          launchCmd = `tmux attach -t '${shellEscapeSingleQuote(config.tmuxSession)}'`;
+        } else if (config.useTmux) {
+          // Wrap command in a new tmux session
+          const tmuxName = `claude-${Date.now().toString(36)}`;
+          let innerCmd = local ? '' : `cd '${shellEscapeSingleQuote(workDir)}' && `;
+          if (!local) {
+            // Export terminal ID for hook matching over SSH
+            innerCmd += `export AGENT_MANAGER_TERMINAL_ID='${shellEscapeSingleQuote(terminalId)}' && `;
+            if (config.apiKey) {
               const envVar = command.startsWith('codex') ? 'OPENAI_API_KEY'
                 : command.startsWith('gemini') ? 'GEMINI_API_KEY'
                 : 'ANTHROPIC_API_KEY';
               innerCmd += `export ${envVar}='${shellEscapeSingleQuote(config.apiKey)}' && `;
             }
-            innerCmd += command;
-            launchCmd = `tmux new-session -s '${tmuxName}' '${shellEscapeSingleQuote(innerCmd)}'`;
-          } else {
-            // Direct launch
-            launchCmd = local ? '' : `cd '${shellEscapeSingleQuote(workDir)}'`;
-            if (!local && config.apiKey) {
-              if (launchCmd) launchCmd += ' && ';
+          }
+          innerCmd += command;
+          launchCmd = `tmux new-session -s '${tmuxName}' '${shellEscapeSingleQuote(innerCmd)}'`;
+        } else {
+          // Direct launch
+          launchCmd = local ? '' : `cd '${shellEscapeSingleQuote(workDir)}'`;
+          if (!local) {
+            // Export AGENT_MANAGER_TERMINAL_ID on the remote side so hooks
+            // can include it for Priority 0/1 session matching (SSH doesn't
+            // forward env vars from the local PTY).
+            if (launchCmd) launchCmd += ' && ';
+            launchCmd += `export AGENT_MANAGER_TERMINAL_ID='${shellEscapeSingleQuote(terminalId)}'`;
+            if (config.apiKey) {
               const envVar = command.startsWith('codex') ? 'OPENAI_API_KEY'
                 : command.startsWith('gemini') ? 'GEMINI_API_KEY'
                 : 'ANTHROPIC_API_KEY';
-              launchCmd += `export ${envVar}='${shellEscapeSingleQuote(config.apiKey)}'`;
+              launchCmd += ` && export ${envVar}='${shellEscapeSingleQuote(config.apiKey)}'`;
             }
-            if (launchCmd) launchCmd += ' && ';
-            launchCmd += command;
           }
+          if (launchCmd) launchCmd += ' && ';
+          launchCmd += command;
+        }
 
-          ptyProcess.write(launchCmd + '\r');
-        }, local ? 100 : 500);
+        // Wait for shell prompt before writing — replaces the old blind setTimeout
+        shellReady.then((detected) => {
+          const term = terminals.get(terminalId);
+          if (!term || !term.pty) return;
+          if (!detected) {
+            log.warn('pty', `Sending launch command to ${terminalId} despite no prompt detected`);
+          }
+          term.pty.write(launchCmd + '\r');
+        });
       }
 
       // Notify client terminal is ready
@@ -408,6 +532,25 @@ export function writeToTerminal(terminalId, data) {
   }
 }
 
+/**
+ * Write data to a terminal after its shell is ready.
+ * Awaits the shell prompt detection before writing, so commands aren't lost
+ * if SSH hasn't finished connecting yet.
+ * @param {string} terminalId
+ * @param {string} data
+ * @returns {Promise<boolean>} true if written, false if terminal was gone
+ */
+export async function writeWhenReady(terminalId, data) {
+  const term = terminals.get(terminalId);
+  if (!term) return false;
+  if (term.shellReady) await term.shellReady;
+  // Terminal might have been cleaned up while waiting
+  const termNow = terminals.get(terminalId);
+  if (!termNow || !termNow.pty) return false;
+  termNow.pty.write(data);
+  return true;
+}
+
 export function resizeTerminal(terminalId, cols, rows) {
   const term = terminals.get(terminalId);
   if (term && term.pty) {