ai-agent-session-center 1.0.0

package/server/sshManager.js

@@ -0,0 +1,339 @@
+// sshManager.js — PTY-based terminal multiplexer using node-pty
+// Manages terminal lifecycle for local and remote (via native ssh) sessions.
+// Terminal I/O is relayed through WebSocket to xterm.js in the browser.
+
+import pty from 'node-pty';
+import { execFile, execSync } from 'child_process';
+import { readdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import log from './logger.js';
+
+// List available SSH keys from ~/.ssh/
+export function listSshKeys() {
+  const sshDir = join(homedir(), '.ssh');
+  try {
+    return readdirSync(sshDir)
+      .filter(f => !f.endsWith('.pub') && !f.startsWith('known_hosts') && !f.startsWith('config') && !f.startsWith('authorized_keys') && !f.startsWith('.'))
+      .map(f => ({ name: f, path: join('~', '.ssh', f) }));
+  } catch {
+    return [];
+  }
+}
+
+// Active terminals: terminalId -> { pty, sessionId, config, wsClient, createdAt }
+const terminals = new Map();
+
+// Pending links: workingDir -> { terminalId, host, createdAt }
+// Used to match incoming SessionStart hooks to the terminal that launched Claude
+const pendingLinks = new Map();
+
+// Clean up stale pending links every 30s
+setInterval(() => {
+  const now = Date.now();
+  for (const [key, link] of pendingLinks) {
+    if (now - link.createdAt > 60000) {
+      log.debug('pty', `Expired pending link for ${key}`);
+      pendingLinks.delete(key);
+    }
+  }
+}, 30000);
+
+function resolveWorkDir(dir) {
+  if (!dir || dir === '~') return homedir();
+  return dir.replace(/^~/, homedir());
+}
+
+function isLocal(host) {
+  return !host || host === 'localhost' || host === '127.0.0.1' || host === '::1';
+}
+
+function getDefaultShell() {
+  return process.env.SHELL || '/bin/bash';
+}
+
+// Build SSH command args for remote connections (without -t for non-interactive)
+function buildSshArgs(config, { allocatePty = false } = {}) {
+  const args = [];
+  if (allocatePty) args.push('-t');
+  if (config.port && config.port !== 22) {
+    args.push('-p', String(config.port));
+  }
+  if (config.privateKeyPath) {
+    const keyPath = config.privateKeyPath.replace(/^~/, homedir());
+    args.push('-i', keyPath);
+  }
+  args.push('-o', 'StrictHostKeyChecking=accept-new');
+  args.push(`${config.username}@${config.host}`);
+  return args;
+}
+
+// List tmux sessions on local or remote host
+export function listTmuxSessions(config) {
+  return new Promise((resolve, reject) => {
+    const tmuxFmt = 'tmux list-sessions -F "#{session_name}||#{session_attached}||#{session_created}||#{session_windows}" 2>/dev/null || echo "__no_tmux__"';
+
+    let cmd, args;
+    if (isLocal(config.host)) {
+      cmd = 'bash';
+      args = ['-c', tmuxFmt];
+    } else {
+      cmd = 'ssh';
+      args = [...buildSshArgs(config), tmuxFmt];
+    }
+
+    execFile(cmd, args, { timeout: 10000 }, (err, stdout) => {
+      if (err) {
+        if (err.killed) {
+          reject(new Error('Connection timed out'));
+        } else {
+          // tmux not installed or no sessions — not an error
+          resolve([]);
+        }
+        return;
+      }
+      const output = stdout.toString();
+      if (output.includes('__no_tmux__') || !output.trim()) {
+        resolve([]);
+        return;
+      }
+      const sessions = output.trim().split('\n').map(line => {
+        const [name, attached, created, windows] = line.split('||');
+        return {
+          name,
+          attached: attached === '1',
+          created: parseInt(created) * 1000,
+          windows: parseInt(windows) || 1,
+        };
+      }).filter(s => s.name);
+      resolve(sessions);
+    });
+  });
+}
+
+export function createTerminal(config, wsClient) {
+  return new Promise((resolve, reject) => {
+    const terminalId = `term-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const workDir = resolveWorkDir(config.workingDir);
+    const command = config.command || 'claude';
+    const local = isLocal(config.host);
+
+    try {
+      let shell, args, cwd;
+
+      if (local) {
+        shell = getDefaultShell();
+        args = [];
+        cwd = workDir;
+      } else {
+        // Spawn native ssh — uses system SSH config, agent, keys automatically
+        shell = 'ssh';
+        args = buildSshArgs(config, { allocatePty: true });
+        cwd = homedir();
+      }
+
+      const ptyProcess = pty.spawn(shell, args, {
+        name: 'xterm-256color',
+        cols: 120,
+        rows: 40,
+        cwd,
+        env: { ...process.env, AGENT_MANAGER_TERMINAL_ID: terminalId },
+      });
+
+      log.info('pty', `Spawned ${local ? 'local' : `remote (${config.host})`} terminal ${terminalId} (pid: ${ptyProcess.pid})`);
+
+      terminals.set(terminalId, {
+        pty: ptyProcess,
+        sessionId: null,
+        config: { ...config, workingDir: workDir },
+        wsClient,
+        createdAt: Date.now(),
+      });
+
+      // Register pending link for session matching
+      pendingLinks.set(workDir, { terminalId, host: config.host || 'localhost', createdAt: Date.now() });
+
+      // Stream output to WebSocket client
+      ptyProcess.onData((data) => {
+        const term = terminals.get(terminalId);
+        if (term && term.wsClient && term.wsClient.readyState === 1) {
+          term.wsClient.send(JSON.stringify({
+            type: 'terminal_output',
+            terminalId,
+            data: Buffer.from(data).toString('base64'),
+          }));
+        }
+      });
+
+      ptyProcess.onExit(({ exitCode, signal }) => {
+        log.info('pty', `Terminal ${terminalId} exited (code: ${exitCode}, signal: ${signal})`);
+        broadcastToClient(terminalId, {
+          type: 'terminal_closed',
+          terminalId,
+          reason: signal ? `signal ${signal}` : 'exited',
+        });
+        cleanup(terminalId);
+      });
+
+      // Send the launch command after shell/SSH init
+      setTimeout(() => {
+        let launchCmd;
+
+        if (config.tmuxSession) {
+          // Attach to existing tmux session
+          launchCmd = `tmux attach -t "${config.tmuxSession}"`;
+        } else if (config.useTmux) {
+          // Wrap command in a new tmux session
+          const tmuxName = `claude-${Date.now().toString(36)}`;
+          let innerCmd = local ? '' : `cd "${workDir}" && `;
+          if (config.apiKey) {
+            const envVar = command.startsWith('codex') ? 'OPENAI_API_KEY'
+              : command.startsWith('gemini') ? 'GEMINI_API_KEY'
+              : 'ANTHROPIC_API_KEY';
+            innerCmd += `export ${envVar}='${config.apiKey.replace(/'/g, "'\\''")}' && `;
+          }
+          innerCmd += command;
+          launchCmd = `tmux new-session -s "${tmuxName}" '${innerCmd.replace(/'/g, "'\\''")}'`;
+        } else {
+          // Direct launch
+          launchCmd = local ? '' : `cd "${workDir}"`;
+          if (config.apiKey) {
+            if (launchCmd) launchCmd += ' && ';
+            const envVar = command.startsWith('codex') ? 'OPENAI_API_KEY'
+              : command.startsWith('gemini') ? 'GEMINI_API_KEY'
+              : 'ANTHROPIC_API_KEY';
+            launchCmd += `export ${envVar}="${config.apiKey}"`;
+          }
+          if (launchCmd) launchCmd += ' && ';
+          launchCmd += command;
+        }
+
+        ptyProcess.write(launchCmd + '\r');
+      }, local ? 100 : 500);
+
+      // Notify client terminal is ready
+      if (wsClient && wsClient.readyState === 1) {
+        wsClient.send(JSON.stringify({ type: 'terminal_ready', terminalId }));
+      }
+
+      resolve(terminalId);
+    } catch (err) {
+      log.error('pty', `Failed to create terminal: ${err.message}`);
+      reject(err);
+    }
+  });
+}
+
+export function writeToTerminal(terminalId, data) {
+  const term = terminals.get(terminalId);
+  if (term && term.pty) {
+    term.pty.write(data);
+  }
+}
+
+export function resizeTerminal(terminalId, cols, rows) {
+  const term = terminals.get(terminalId);
+  if (term && term.pty) {
+    try {
+      term.pty.resize(cols, rows);
+    } catch {
+      // Process may already be dead
+    }
+  }
+}
+
+export function closeTerminal(terminalId) {
+  const term = terminals.get(terminalId);
+  if (term) {
+    if (term.pty) {
+      try { term.pty.kill(); } catch {}
+    }
+    cleanup(terminalId);
+  }
+}
+
+export function linkSession(terminalId, sessionId) {
+  const term = terminals.get(terminalId);
+  if (term) {
+    term.sessionId = sessionId;
+    log.info('pty', `Linked terminal ${terminalId} to session ${sessionId}`);
+  }
+}
+
+export function tryLinkByWorkDir(workDir, sessionId) {
+  const link = pendingLinks.get(workDir);
+  if (link) {
+    linkSession(link.terminalId, sessionId);
+    pendingLinks.delete(workDir);
+    return link.terminalId;
+  }
+  // Also try matching with trailing slash variants
+  const normalized = workDir.replace(/\/$/, '');
+  for (const [dir, link] of pendingLinks) {
+    if (dir.replace(/\/$/, '') === normalized) {
+      linkSession(link.terminalId, sessionId);
+      pendingLinks.delete(dir);
+      return link.terminalId;
+    }
+  }
+  return null;
+}
+
+export function getTerminalForSession(sessionId) {
+  for (const [terminalId, term] of terminals) {
+    if (term.sessionId === sessionId) return terminalId;
+  }
+  return null;
+}
+
+// Find terminal whose pty is the parent of the given child PID
+export function getTerminalByPtyChild(childPid) {
+  if (!childPid || childPid <= 0) return null;
+  try {
+    const ppid = parseInt(execSync(`ps -o ppid= -p ${childPid} 2>/dev/null`, { encoding: 'utf-8' }).trim(), 10);
+    if (!ppid || ppid <= 0) return null;
+    for (const [terminalId, term] of terminals) {
+      if (term.pty && term.pty.pid === ppid) return terminalId;
+    }
+  } catch {}
+  return null;
+}
+
+export function setWsClient(terminalId, wsClient) {
+  const term = terminals.get(terminalId);
+  if (term) {
+    term.wsClient = wsClient;
+  }
+}
+
+export function getTerminals() {
+  const result = [];
+  for (const [terminalId, term] of terminals) {
+    result.push({
+      terminalId,
+      sessionId: term.sessionId,
+      host: term.config.host,
+      workingDir: term.config.workingDir,
+      command: term.config.command,
+      createdAt: term.createdAt,
+    });
+  }
+  return result;
+}
+
+function broadcastToClient(terminalId, message) {
+  const term = terminals.get(terminalId);
+  if (term && term.wsClient && term.wsClient.readyState === 1) {
+    term.wsClient.send(JSON.stringify(message));
+  }
+}
+
+function cleanup(terminalId) {
+  const term = terminals.get(terminalId);
+  if (term) {
+    for (const [key, link] of pendingLinks) {
+      if (link.terminalId === terminalId) pendingLinks.delete(key);
+    }
+    terminals.delete(terminalId);
+  }
+}

package/server/wsManager.js

@@ -0,0 +1,83 @@
+// wsManager.js — WebSocket broadcast manager with bidirectional terminal support
+import { getAllSessions, getAllTeams, getEventSeq, getEventsSince } from './sessionStore.js';
+import { writeToTerminal, resizeTerminal, closeTerminal, setWsClient } from './sshManager.js';
+import log from './logger.js';
+
+const clients = new Set();
+
+export function handleConnection(ws) {
+  clients.add(ws);
+  ws._terminalIds = new Set(); // Track subscribed terminals
+  log.info('ws', `Client connected (total: ${clients.size})`);
+
+  // Send full snapshot on connect (includes teams + event sequence for replay)
+  const sessions = getAllSessions();
+  const teams = getAllTeams();
+  const seq = getEventSeq();
+  log.debug('ws', `Sending snapshot: ${Object.keys(sessions).length} sessions, ${Object.keys(teams).length} teams, seq=${seq}`);
+  ws.send(JSON.stringify({ type: 'snapshot', sessions, teams, seq }));
+
+  // Handle incoming messages (terminal input, resize, etc.)
+  ws.on('message', (raw) => {
+    try {
+      const msg = JSON.parse(raw.toString());
+      switch (msg.type) {
+        case 'terminal_input':
+          if (msg.terminalId && msg.data) {
+            writeToTerminal(msg.terminalId, msg.data);
+          }
+          break;
+        case 'terminal_resize':
+          if (msg.terminalId && msg.cols && msg.rows) {
+            resizeTerminal(msg.terminalId, msg.cols, msg.rows);
+          }
+          break;
+        case 'terminal_disconnect':
+          if (msg.terminalId) {
+            closeTerminal(msg.terminalId);
+            ws._terminalIds.delete(msg.terminalId);
+          }
+          break;
+        case 'terminal_subscribe':
+          if (msg.terminalId) {
+            ws._terminalIds.add(msg.terminalId);
+            setWsClient(msg.terminalId, ws);
+          }
+          break;
+        case 'replay':
+          // Client reconnected and wants events since a certain sequence number
+          if (typeof msg.sinceSeq === 'number') {
+            const missed = getEventsSince(msg.sinceSeq);
+            log.debug('ws', `Replaying ${missed.length} events since seq=${msg.sinceSeq}`);
+            for (const evt of missed) {
+              ws.send(JSON.stringify(evt.data));
+            }
+          }
+          break;
+        default:
+          log.debug('ws', `Unknown message type: ${msg.type}`);
+      }
+    } catch (e) {
+      log.debug('ws', `Invalid WS message: ${e.message}`);
+    }
+  });
+
+  ws.on('close', () => {
+    clients.delete(ws);
+    log.info('ws', `Client disconnected (total: ${clients.size})`);
+  });
+  ws.on('error', (err) => {
+    clients.delete(ws);
+    log.error('ws', 'Client error:', err.message);
+  });
+}
+
+export function broadcast(data) {
+  const msg = JSON.stringify(data);
+  log.debug('ws', `Broadcasting ${data.type} to ${clients.size} clients`);
+  for (const client of clients) {
+    if (client.readyState === 1) {
+      client.send(msg);
+    }
+  }
+}