upfynai-code 2.7.4 → 2.8.0

package/src/connect.js

@@ -1,14 +1,22 @@
 import WebSocket from 'ws';
 import os from 'os';
 import { spawn } from 'child_process';
-import { promises as fsPromises } from 'fs';
-import path from 'path';
+import { promises as fsPromises, existsSync } from 'fs';
+import path, { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
 import chalk from 'chalk';
 import { readConfig, writeConfig, displayUrl } from './config.js';
 import { getToken, validateToken } from './auth.js';
 import { getPersistentShell } from './persistent-shell.js';
 import { needsPermission, requestPermission, handlePermissionResponse } from './permissions.js';
 
+// Resolve agents: dist/agents/ (npm package) or ../../shared/agents/ (monorepo)
+const __connectDir = dirname(fileURLToPath(import.meta.url));
+const _agentsPath = existsSync(join(__connectDir, '../dist/agents/index.js'))
+  ? '../dist/agents/index.js'
+  : '../../shared/agents/index.js';
+const { executeAction, isStreamingAction } = await import(_agentsPath);
+
 // Active process tracking (opencode pattern: activeRequests sync.Map)
 const activeProcesses = new Map(); // requestId → { proc, action }
 
@@ -23,42 +31,26 @@ function handleShellSessionStart(data, ws) {
   const shellSessionId = data.requestId;
   const projectPath = data.projectPath || process.cwd();
   const isWin = process.platform === 'win32';
-  const isMac = process.platform === 'darwin';
-  const shellType = data.shellType; // 'cmd', 'powershell', 'bash', 'zsh', etc.
+  const shellType = data.shellType;
 
   console.log(chalk.cyan(`  [relay] Starting shell session in ${projectPath}`));
 
-  // Build the shell command
   let shellCmd, shellArgs;
   const provider = data.provider || 'claude';
   const isPlainShell = data.isPlainShell || (!!data.initialCommand && !data.hasSession) || provider === 'plain-shell';
 
-  /**
-   * Helper: get the right shell command + args for interactive shell based on platform + shellType.
-   * Returns { cmd, args } that cd into projectPath.
-   */
   function getInteractiveShell(projectDir) {
     if (isWin) {
-      if (shellType === 'cmd') {
-        return { cmd: 'cmd.exe', args: ['/K', `cd /d "${projectDir}"`] };
-      }
-      // Default to PowerShell on Windows
+      if (shellType === 'cmd') return { cmd: 'cmd.exe', args: ['/K', `cd /d "${projectDir}"`] };
       return { cmd: 'powershell.exe', args: ['-NoExit', '-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'`] };
     }
-    // Unix: use shellType if specified, else $SHELL or bash
     const sh = shellType || process.env.SHELL || 'bash';
     return { cmd: sh, args: ['--login'] };
   }
 
-  /**
-   * Helper: wrap a command to execute in the right shell for the platform + shellType.
-   * Returns { cmd, args }.
-   */
   function wrapCommand(command, projectDir) {
     if (isWin) {
-      if (shellType === 'cmd') {
-        return { cmd: 'cmd.exe', args: ['/C', `cd /d "${projectDir}" && ${command}`] };
-      }
+      if (shellType === 'cmd') return { cmd: 'cmd.exe', args: ['/C', `cd /d "${projectDir}" && ${command}`] };
       return { cmd: 'powershell.exe', args: ['-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'; ${command}`] };
     }
     const sh = shellType || 'bash';
@@ -66,11 +58,9 @@ function handleShellSessionStart(data, ws) {
   }
 
   if (isPlainShell && data.initialCommand) {
-    // Run a specific command
     const s = wrapCommand(data.initialCommand, projectPath);
     shellCmd = s.cmd; shellArgs = s.args;
   } else if (isPlainShell) {
-    // Interactive shell
     const s = getInteractiveShell(projectPath);
     shellCmd = s.cmd; shellArgs = s.args;
   } else if (provider === 'cursor') {
@@ -80,7 +70,6 @@ function handleShellSessionStart(data, ws) {
     const s = wrapCommand(cursorCmd, projectPath);
     shellCmd = s.cmd; shellArgs = s.args;
   } else {
-    // Claude (default)
     const command = data.initialCommand || 'claude';
     let claudeCmd;
     if (isWin) {
@@ -96,56 +85,32 @@ function handleShellSessionStart(data, ws) {
     shellCmd = s.cmd; shellArgs = s.args;
   }
 
-  // Send ack so browser knows spawn is starting
-  ws.send(JSON.stringify({
-    type: 'relay-shell-output',
-    shellSessionId,
-    data: '',
-  }));
+  ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: '' }));
 
   const proc = spawn(shellCmd, shellArgs, {
     cwd: isPlainShell && !data.initialCommand ? projectPath : undefined,
-    env: {
-      ...process.env,
-      TERM: 'xterm-256color',
-      COLORTERM: 'truecolor',
-      FORCE_COLOR: '3',
-    },
+    env: { ...process.env, TERM: 'xterm-256color', COLORTERM: 'truecolor', FORCE_COLOR: '3' },
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 
   activeShellSessions.set(shellSessionId, { proc, projectPath });
 
-  // Stream stdout → browser via relay
   proc.stdout.on('data', (chunk) => {
     if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'relay-shell-output',
-        shellSessionId,
-        data: chunk.toString(),
-      }));
+      ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
     }
   });
 
-  // Stream stderr → browser via relay
   proc.stderr.on('data', (chunk) => {
     if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'relay-shell-output',
-        shellSessionId,
-        data: chunk.toString(),
-      }));
+      ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: chunk.toString() }));
     }
   });
 
   proc.on('close', (code) => {
     activeShellSessions.delete(shellSessionId);
     if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'relay-shell-exited',
-        shellSessionId,
-        exitCode: code,
-      }));
+      ws.send(JSON.stringify({ type: 'relay-shell-exited', shellSessionId, exitCode: code }));
     }
     console.log(chalk.dim(`  [relay] Shell session ended (code ${code})`));
   });
@@ -153,88 +118,33 @@ function handleShellSessionStart(data, ws) {
   proc.on('error', (err) => {
     activeShellSessions.delete(shellSessionId);
     if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'relay-shell-output',
-        shellSessionId,
-        data: `\r\n\x1b[31mError: ${err.message}\x1b[0m\r\n`,
-      }));
+      ws.send(JSON.stringify({ type: 'relay-shell-output', shellSessionId, data: `\r\n\x1b[31mError: ${err.message}\x1b[0m\r\n` }));
     }
   });
 }
 
 /**
- * Execute a shell command and return stdout
- */
-function execCommand(cmd, args, options = {}) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(cmd, args, {
-      shell: true,
-      cwd: options.cwd || os.homedir(),
-      env: { ...process.env, ...options.env },
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    let stdout = '';
-    let stderr = '';
-    proc.stdout.on('data', (d) => { stdout += d; });
-    proc.stderr.on('data', (d) => { stderr += d; });
-
-    const timeout = setTimeout(() => {
-      proc.kill();
-      reject(new Error('Command timed out'));
-    }, options.timeout || 30000);
-
-    proc.on('close', (code) => {
-      clearTimeout(timeout);
-      if (code === 0) resolve(stdout);
-      else reject(new Error(stderr || `Exit code ${code}`));
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-  });
-}
-
-/**
- * Build a file tree for a directory
+ * Build execution context for shared agents.
+ * Provides CLI-specific capabilities (persistent shell, process tracking, streaming).
  */
-async function buildFileTree(dirPath, maxDepth, currentDepth = 0) {
-  if (currentDepth >= maxDepth) return [];
-  try {
-    const entries = await fsPromises.readdir(dirPath, { withFileTypes: true });
-    const items = [];
-    for (const entry of entries.slice(0, 200)) {
-      // Skip heavy/hidden directories
-      if (entry.name === 'node_modules' || entry.name === '.git' ||
-          entry.name === 'dist' || entry.name === 'build' ||
-          entry.name === '.svn' || entry.name === '.hg') continue;
-      if (entry.name.startsWith('.') && currentDepth === 0) continue; // hide dotfiles at root only
-
-      const itemPath = path.join(dirPath, entry.name);
-      const item = { name: entry.name, path: itemPath, type: entry.isDirectory() ? 'directory' : 'file' };
-
-      // Get file stats for metadata (size, modified)
-      try {
-        const stats = await fsPromises.stat(itemPath);
-        item.size = stats.size;
-        item.modified = stats.mtime.toISOString();
-      } catch { /* ignore stat errors */ }
-
-      if (entry.isDirectory() && currentDepth < maxDepth - 1) {
-        item.children = await buildFileTree(itemPath, maxDepth, currentDepth + 1);
+function buildAgentContext(requestId, ws) {
+  return {
+    requestId,
+    streamMode: 'structured',
+    getPersistentShell,
+    trackProcess: (id, entry) => activeProcesses.set(id, entry),
+    untrackProcess: (id) => activeProcesses.delete(id),
+    stream: (data) => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify({ type: 'relay-stream', requestId, data }));
       }
-      items.push(item);
-    }
-    return items;
-  } catch {
-    return [];
-  }
+    },
+  };
 }
 
 /**
- * Handle incoming relay commands from the server
+ * Handle incoming relay commands from the server.
+ * Delegates to shared agent modules for action execution.
  */
 async function handleRelayCommand(data, ws) {
   const { requestId, action } = data;
@@ -244,369 +154,29 @@ async function handleRelayCommand(data, ws) {
     if (needsPermission(action, data)) {
       const approved = await requestPermission(ws, requestId, action, data);
       if (!approved) {
-        ws.send(JSON.stringify({
-          type: 'relay-response', requestId,
-          error: 'Permission denied by user',
-        }));
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, error: 'Permission denied by user' }));
         return;
       }
     }
 
-    switch (action) {
-      case 'claude-query': {
-        const { command, options } = data;
-        console.log(chalk.cyan('  [relay] Processing Claude query...'));
-
-        // Stream-JSON mode for real-time token streaming (opencode pattern)
-        const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
-        if (options?.sessionId) args.push('--continue', options.sessionId);
-
-        const proc = spawn('claude', [...args, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || os.homedir(),
-          env: process.env,
-        });
-
-        // Track for abort support (opencode pattern: activeRequests)
-        activeProcesses.set(requestId, { proc, action: 'claude-query' });
-
-        let stdoutBuffer = '';
-        let capturedSessionId = null;
-        // Track previous text length per content block to compute deltas
-        // (--include-partial-messages sends FULL accumulated text each update, not just the delta)
-        let lastTextLength = 0;
-
-        // Parse NDJSON line-by-line (same pattern as cursor-cli.js)
-        proc.stdout.on('data', (chunk) => {
-          stdoutBuffer += chunk.toString();
-          const lines = stdoutBuffer.split('\n');
-          stdoutBuffer = lines.pop(); // keep incomplete last line in buffer
-
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            try {
-              const evt = JSON.parse(line);
-
-              if (evt.type === 'system' && evt.subtype === 'init') {
-                // Capture session ID for resume support
-                if (evt.session_id) capturedSessionId = evt.session_id;
-                // Reset delta tracking for new session
-                lastTextLength = 0;
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-system', sessionId: evt.session_id, model: evt.model, cwd: evt.cwd },
-                }));
-              } else if (evt.type === 'assistant' && evt.message?.content?.length) {
-                // --include-partial-messages sends FULL text each time; compute the new delta only
-                const fullText = evt.message.content[0].text || '';
-                const delta = fullText.slice(lastTextLength);
-                lastTextLength = fullText.length;
-                if (delta) {
-                  ws.send(JSON.stringify({
-                    type: 'relay-stream', requestId,
-                    data: { type: 'claude-response', content: delta },
-                  }));
-                }
-              } else if (evt.type === 'result') {
-                // Session complete — reset delta tracking, capture session ID
-                lastTextLength = 0;
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-result', sessionId: capturedSessionId, subtype: evt.subtype },
-                }));
-              }
-            } catch {
-              // Non-JSON line — send as raw text only if it looks meaningful
-              if (line.trim() && !line.startsWith('%') && !line.includes('claude query')) {
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-response', content: line },
-                }));
-              }
-            }
-          }
-        });
-
-        proc.stderr.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream', requestId,
-            data: { type: 'claude-error', content: chunk.toString() },
-          }));
-        });
-
-        proc.on('close', (code) => {
-          activeProcesses.delete(requestId);
-          ws.send(JSON.stringify({
-            type: 'relay-complete', requestId,
-            exitCode: code,
-            sessionId: capturedSessionId,
-          }));
-        });
-
-        proc.on('error', () => {
-          activeProcesses.delete(requestId);
-        });
-        break;
-      }
-
-      case 'shell-command': {
-        const { command: cmd, cwd } = data;
-        if (!cmd || typeof cmd !== 'string') throw new Error('Invalid command');
-        const cmdLower = cmd.toLowerCase();
-        const dangerous = [
-          'rm -rf /', 'mkfs', 'dd if=', ':(){', 'fork bomb', '> /dev/sd',
-          'format c:', 'format d:', 'format e:', 'del /s /q c:\\',
-          'rd /s /q c:\\', 'reg delete', 'bcdedit',
-        ];
-        if (dangerous.some(d => cmdLower.includes(d.toLowerCase()))) throw new Error('Command blocked for safety');
-        console.log(chalk.dim('  [relay] Executing shell command...'));
-        // Persistent shell singleton (opencode pattern: commands share one shell process)
-        const shell = getPersistentShell(cwd || process.cwd());
-        const result = await shell.exec(cmd, { timeoutMs: 60000 });
-        ws.send(JSON.stringify({
-          type: 'relay-response', requestId,
-          data: { stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode, cwd: result.cwd },
-        }));
-        break;
-      }
-
-      case 'file-read': {
-        let { filePath, encoding } = data;
-        if (!filePath || typeof filePath !== 'string') throw new Error('Invalid file path');
-        // Resolve ~ to home directory (routes send paths like ~/.cursor/config.json)
-        if (filePath === '~') filePath = os.homedir();
-        else if (filePath.startsWith('~/') || filePath.startsWith('~\\')) filePath = path.join(os.homedir(), filePath.slice(2));
-        const normalizedPath = path.resolve(filePath);
-        const normLower = normalizedPath.toLowerCase().replace(/\\/g, '/');
-        const blockedRead = ['/etc/shadow', '/etc/passwd', '.ssh/id_rsa', '.ssh/id_ed25519', '/.env'];
-        if (blockedRead.some(b => normLower.includes(b))) throw new Error('Access denied');
-        const content = await fsPromises.readFile(normalizedPath, encoding === 'base64' ? null : 'utf8');
-        const result = encoding === 'base64' ? content.toString('base64') : content;
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content: result } }));
-        break;
-      }
-
-      case 'file-write': {
-        let fp2 = data.filePath;
-        const fileContent = data.content;
-        if (!fp2 || typeof fp2 !== 'string') throw new Error('Invalid file path');
-        // Resolve ~ to home directory
-        if (fp2 === '~') fp2 = os.homedir();
-        else if (fp2.startsWith('~/') || fp2.startsWith('~\\')) fp2 = path.join(os.homedir(), fp2.slice(2));
-        const normalizedFp = path.resolve(fp2);
-        const fpLower = normalizedFp.toLowerCase().replace(/\\/g, '/');
-        const blockedWrite = [
-          '/etc/', '/usr/bin/', '/usr/sbin/',
-          '/windows/system32', '/windows/syswow64', '/program files',
-          '.ssh/', '/.env',
-        ];
-        if (blockedWrite.some(d => fpLower.includes(d))) throw new Error('Access denied');
-        const parentDir = path.dirname(normalizedFp);
-        await fsPromises.mkdir(parentDir, { recursive: true }).catch(() => {});
-        await fsPromises.writeFile(normalizedFp, fileContent, 'utf8');
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { success: true } }));
-        break;
-      }
-
-      case 'file-tree': {
-        const { dirPath, depth, maxDepth } = data;
-        const treeDepth = depth || maxDepth || 3;
-        const resolvedDir = dirPath ? path.resolve(dirPath) : process.cwd();
-        const tree = await buildFileTree(resolvedDir, treeDepth);
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { files: tree } }));
-        break;
-      }
-
-      case 'browse-dirs': {
-        // Browse directories on user's local machine
-        const { dirPath: browsePath } = data;
-        const os = await import('os');
-        let targetDir = browsePath || os.default.homedir();
-        if (targetDir === '~') targetDir = os.default.homedir();
-        else if (targetDir.startsWith('~/') || targetDir.startsWith('~\\')) targetDir = path.join(os.default.homedir(), targetDir.slice(2));
-        targetDir = path.resolve(targetDir);
-
-        let dirs = [];
-        // On Windows, detect available drives to show alongside directory listing
-        let drives = [];
-        if (process.platform === 'win32') {
-          try {
-            const { execSync } = await import('child_process');
-            const wmicOut = execSync('wmic logicaldisk get name', { encoding: 'utf8', timeout: 5000 });
-            drives = wmicOut.split('\n')
-              .map(l => l.trim())
-              .filter(l => /^[A-Z]:$/.test(l))
-              .map(d => ({ name: d + '\\', path: d + '\\', type: 'drive' }));
-          } catch { /* ignore — wmic not available */ }
-        }
-
-        const entries = await fsPromises.readdir(targetDir, { withFileTypes: true });
-        dirs = entries
-          .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-          .map(e => ({ name: e.name, path: path.join(targetDir, e.name), type: 'directory' }))
-          .sort((a, b) => a.name.localeCompare(b.name));
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { path: targetDir, suggestions: dirs, drives, homedir: os.default.homedir() } }));
-        break;
-      }
-
-      case 'validate-path': {
-        // Check if a path exists on user's machine
-        const { targetPath } = data;
-        const os2 = await import('os');
-        let checkPath = targetPath || '';
-        if (checkPath === '~') checkPath = os2.default.homedir();
-        else if (checkPath.startsWith('~/') || checkPath.startsWith('~\\')) checkPath = path.join(os2.default.homedir(), checkPath.slice(2));
-        checkPath = path.resolve(checkPath);
-
-        try {
-          const stats = await fsPromises.stat(checkPath);
-          ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { exists: true, isDirectory: stats.isDirectory(), resolvedPath: checkPath } }));
-        } catch {
-          ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { exists: false, resolvedPath: checkPath } }));
-        }
-        break;
-      }
-
-      case 'create-folder': {
-        // Create a directory on user's machine
-        const { folderPath } = data;
-        const os3 = await import('os');
-        let mkPath = folderPath || '';
-        if (mkPath === '~') mkPath = os3.default.homedir();
-        else if (mkPath.startsWith('~/') || mkPath.startsWith('~\\')) mkPath = path.join(os3.default.homedir(), mkPath.slice(2));
-        mkPath = path.resolve(mkPath);
-
-        await fsPromises.mkdir(mkPath, { recursive: true });
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { success: true, path: mkPath } }));
-        break;
-      }
-
-      case 'git-operation': {
-        const { gitCommand, cwd: gitCwd } = data;
-        console.log(chalk.dim('  [relay] Running git operation...'));
-        const resolvedGitCwd = gitCwd ? path.resolve(gitCwd) : process.cwd();
-        const result = await execCommand('git', [gitCommand], { cwd: resolvedGitCwd });
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { stdout: result } }));
-        break;
-      }
-
-      // Sub-agent: read-only research agent (opencode pattern: AgentTask)
-      // Spawns a separate claude process with --allowedTools limited to read-only
-      case 'claude-task-query': {
-        const { command: taskCmd, options: taskOpts } = data;
-        console.log(chalk.cyan('  [relay] Spawning sub-agent for research...'));
-
-        const taskArgs = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
-        // Sub-agents are read-only: use --allowedTools to restrict
-        taskArgs.push('--allowedTools', 'View,Glob,Grep,LS,Read');
-        // Sub-agents always start fresh (no --continue)
-
-        const taskProc = spawn('claude', [...taskArgs, taskCmd || ''], {
-          shell: true,
-          cwd: taskOpts?.projectPath || os.homedir(),
-          env: process.env,
-        });
-
-        activeProcesses.set(requestId, { proc: taskProc, action: 'claude-task-query' });
-        let taskBuffer = '';
-
-        taskProc.stdout.on('data', (chunk) => {
-          taskBuffer += chunk.toString();
-          const lines = taskBuffer.split('\n');
-          taskBuffer = lines.pop();
-          for (const line of lines) {
-            if (!line.trim()) continue;
-            try {
-              const evt = JSON.parse(line);
-              if (evt.type === 'assistant' && evt.message?.content?.length) {
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-response', content: evt.message.content[0].text || '' },
-                }));
-              }
-            } catch {
-              if (line.trim()) {
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-response', content: line },
-                }));
-              }
-            }
-          }
-        });
-
-        taskProc.stderr.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream', requestId,
-            data: { type: 'claude-error', content: chunk.toString() },
-          }));
-        });
-
-        taskProc.on('close', (code) => {
-          activeProcesses.delete(requestId);
-          ws.send(JSON.stringify({ type: 'relay-complete', requestId, exitCode: code }));
-        });
-
-        taskProc.on('error', () => { activeProcesses.delete(requestId); });
-        break;
-      }
-
-      case 'detect-agents': {
-        // Detect installed AI CLI agents on user's machine
-        const agents = {};
-        const checkCmd = process.platform === 'win32' ? 'where' : 'which';
-        const agentBins = { claude: 'claude', cursor: 'cursor-agent', codex: 'codex' };
-        for (const [name, bin] of Object.entries(agentBins)) {
-          try {
-            const { execSync } = await import('child_process');
-            execSync(`${checkCmd} ${bin}`, { encoding: 'utf8', timeout: 5000, stdio: 'pipe' });
-            agents[name] = true;
-          } catch {
-            agents[name] = false;
-          }
-        }
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { agents } }));
-        break;
-      }
+    const ctx = buildAgentContext(requestId, ws);
 
-      case 'exec': {
-        // Execute an arbitrary command on the user's machine (used for updates, etc.)
-        const { command, timeout: cmdTimeout = 60000 } = options;
-        if (!command) {
-          ws.send(JSON.stringify({ type: 'relay-response', requestId, error: 'No command provided' }));
-          break;
-        }
-        const { execSync } = await import('child_process');
-        try {
-          const output = execSync(command, {
-            encoding: 'utf8',
-            timeout: cmdTimeout,
-            cwd: options.cwd || process.cwd(),
-            stdio: ['pipe', 'pipe', 'pipe']
-          });
-          ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { output, exitCode: 0 } }));
-        } catch (execErr) {
-          ws.send(JSON.stringify({
-            type: 'relay-response', requestId,
-            data: { output: execErr.stdout || '', stderr: execErr.stderr || '', exitCode: execErr.status || 1 }
-          }));
-        }
-        break;
-      }
+    // For the exec action, params come from data.options in the old format
+    const params = action === 'exec'
+      ? { command: data.options?.command || data.command, timeout: data.options?.timeout || data.timeout, cwd: data.options?.cwd || data.cwd }
+      : data;
 
-      default:
-        ws.send(JSON.stringify({
-          type: 'relay-response',
-          requestId,
-          error: `Unknown action: ${action}`,
-        }));
+    if (isStreamingAction(action)) {
+      // Streaming actions: agent calls ctx.stream() for chunks, returns on completion
+      const result = await executeAction(action, params, ctx);
+      ws.send(JSON.stringify({ type: 'relay-complete', requestId, exitCode: result.exitCode, sessionId: result.sessionId }));
+    } else {
+      // Sync actions: agent returns data directly
+      const result = await executeAction(action, params, ctx);
+      ws.send(JSON.stringify({ type: 'relay-response', requestId, data: result }));
     }
   } catch (err) {
-    ws.send(JSON.stringify({
-      type: 'relay-response',
-      requestId,
-      error: err.message,
-    }));
+    ws.send(JSON.stringify({ type: 'relay-response', requestId, error: err.message }));
   }
 }
 
@@ -619,7 +189,6 @@ export async function connect(options = {}) {
   const serverUrl = options.server || config.serverUrl;
   let relayKey = options.key;
 
-  // If no key provided, fetch one using the auth token
   if (!relayKey) {
     const token = getToken();
     if (!token) {
@@ -634,7 +203,6 @@ export async function connect(options = {}) {
       process.exit(1);
     }
 
-    // Fetch a relay token from the API
     try {
       const res = await fetch(`${serverUrl}/api/auth/connect-token`, {
         headers: { Authorization: `Bearer ${token}` },
@@ -648,7 +216,6 @@ export async function connect(options = {}) {
     }
   }
 
-  // Save for future use
   writeConfig({ relayKey });
 
   const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
@@ -669,25 +236,17 @@ export async function connect(options = {}) {
       console.log(chalk.green('  Connected! Your local machine is now bridged to the server.'));
       console.log(chalk.dim('  Claude Code is the AI brain. Press Ctrl+C to disconnect.\n'));
 
-      // Send initial working directory so it becomes the default project
       const cwd = process.cwd();
       const dirName = path.basename(cwd);
       ws.send(JSON.stringify({
-        type: 'relay-init',
-        cwd,
-        dirName,
-        homedir: os.homedir(),
-        platform: process.platform,
-        hostname: os.hostname(),
+        type: 'relay-init', cwd, dirName,
+        homedir: os.homedir(), platform: process.platform, hostname: os.hostname(),
       }));
       console.log(chalk.dim(`  Default project: ${cwd}\n`));
 
       const heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: 'ping' }));
-        }
+        if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'ping' }));
       }, 30000);
-
       ws.on('close', () => clearInterval(heartbeat));
     });
 
@@ -700,44 +259,33 @@ export async function connect(options = {}) {
           return;
         }
         if (data.type === 'relay-command') {
-          handleRelayCommand(data, ws);
+          if (data.action === 'shell-session-start') {
+            handleShellSessionStart(data, ws);
+          } else {
+            handleRelayCommand(data, ws);
+          }
           return;
         }
-        // Abort handler (opencode pattern: cancel via context propagation)
         if (data.type === 'relay-abort') {
           const entry = activeProcesses.get(data.requestId);
           if (entry?.proc) {
             entry.proc.kill('SIGTERM');
             activeProcesses.delete(data.requestId);
-            ws.send(JSON.stringify({
-              type: 'relay-complete', requestId: data.requestId,
-              exitCode: -1, aborted: true,
-            }));
+            ws.send(JSON.stringify({ type: 'relay-complete', requestId: data.requestId, exitCode: -1, aborted: true }));
             console.log(chalk.yellow('  [relay] Process aborted by user'));
           }
           return;
         }
-        // Permission response from browser (opencode pattern: grant/deny flow)
         if (data.type === 'relay-permission-response') {
           handlePermissionResponse(data);
           return;
         }
-        // ── Relay Shell: interactive terminal on local machine ──────────
-        if (data.type === 'relay-command' && data.action === 'shell-session-start') {
-          handleShellSessionStart(data, ws);
-          return;
-        }
         if (data.type === 'relay-shell-input') {
           const session = activeShellSessions.get(data.shellSessionId);
-          if (session?.proc?.stdin?.writable) {
-            session.proc.stdin.write(data.data);
-          }
-          return;
-        }
-        if (data.type === 'relay-shell-resize') {
-          // PTY resize not available with basic spawn — ignored for non-pty
+          if (session?.proc?.stdin?.writable) session.proc.stdin.write(data.data);
           return;
         }
+        if (data.type === 'relay-shell-resize') return;
         if (data.type === 'relay-shell-kill') {
           const session = activeShellSessions.get(data.shellSessionId);
           if (session?.proc) {
@@ -747,7 +295,6 @@ export async function connect(options = {}) {
           }
           return;
         }
-
         if (data.type === 'pong') return;
         if (data.type === 'error') {
           console.error(chalk.red(`  Server error: ${data.error}`));
@@ -763,7 +310,6 @@ export async function connect(options = {}) {
         console.log(chalk.dim('  Disconnected.'));
         process.exit(0);
       }
-
       reconnectAttempts++;
       if (reconnectAttempts <= MAX_RECONNECT) {
         const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);