upfynai-code 2.7.1 → 2.7.2

package/src/connect.js

@@ -1,758 +1,768 @@
-import WebSocket from 'ws';
-import os from 'os';
-import { spawn } from 'child_process';
-import { promises as fsPromises } from 'fs';
-import path from 'path';
-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';
-
-// Active process tracking (opencode pattern: activeRequests sync.Map)
-const activeProcesses = new Map(); // requestId → { proc, action }
-
-// Active shell sessions for relay terminal (shellSessionId → { proc })
-const activeShellSessions = new Map();
-
-/**
- * Start an interactive shell session on the local machine, relayed to the browser.
- * Spawns a PTY-like process and streams I/O via WebSocket.
- */
-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.
-
-  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
-      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}`] };
-      }
-      return { cmd: 'powershell.exe', args: ['-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'; ${command}`] };
-    }
-    const sh = shellType || 'bash';
-    return { cmd: sh, args: ['-c', `cd "${projectDir}" && ${command}`] };
-  }
-
-  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') {
-    const cursorCmd = data.hasSession && data.sessionId
-      ? `cursor-agent --resume="${data.sessionId}"`
-      : 'cursor-agent';
-    const s = wrapCommand(cursorCmd, projectPath);
-    shellCmd = s.cmd; shellArgs = s.args;
-  } else {
-    // Claude (default)
-    const command = data.initialCommand || 'claude';
-    let claudeCmd;
-    if (isWin) {
-      claudeCmd = data.hasSession && data.sessionId
-        ? `claude --resume ${data.sessionId}`
-        : command;
-    } else {
-      claudeCmd = data.hasSession && data.sessionId
-        ? `claude --resume ${data.sessionId} || claude`
-        : command;
-    }
-    const s = wrapCommand(claudeCmd, projectPath);
-    shellCmd = s.cmd; shellArgs = s.args;
-  }
-
-  // Send ack so browser knows spawn is starting
-  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',
-    },
-    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(),
-      }));
-    }
-  });
-
-  // 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(),
-      }));
-    }
-  });
-
-  proc.on('close', (code) => {
-    activeShellSessions.delete(shellSessionId);
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'relay-shell-exited',
-        shellSessionId,
-        exitCode: code,
-      }));
-    }
-    console.log(chalk.dim(`  [relay] Shell session ended (code ${code})`));
-  });
-
-  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`,
-      }));
-    }
-  });
-}
-
-/**
- * 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
- */
-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);
-      }
-      items.push(item);
-    }
-    return items;
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Handle incoming relay commands from the server
- */
-async function handleRelayCommand(data, ws) {
-  const { requestId, action } = data;
-
-  try {
-    // Permission gate (opencode pattern: dangerous actions require browser approval)
-    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',
-        }));
-        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?.projectPath) args.push('--cwd', options.projectPath);
-        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;
-
-        // 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;
-                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) {
-                // Real-time text delta
-                const text = evt.message.content[0].text || '';
-                ws.send(JSON.stringify({
-                  type: 'relay-stream', requestId,
-                  data: { type: 'claude-response', content: text },
-                }));
-              } else if (evt.type === 'result') {
-                // Session complete — include captured session ID
-                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
-              if (line.trim()) {
-                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');
-        if (taskOpts?.projectPath) taskArgs.push('--cwd', taskOpts.projectPath);
-        // 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;
-      }
-
-      default:
-        ws.send(JSON.stringify({
-          type: 'relay-response',
-          requestId,
-          error: `Unknown action: ${action}`,
-        }));
-    }
-  } catch (err) {
-    ws.send(JSON.stringify({
-      type: 'relay-response',
-      requestId,
-      error: err.message,
-    }));
-  }
-}
-
-/**
- * Connect to the remote server via WebSocket relay.
- * Bridges local Claude Code, shell, filesystem, and git to the web UI.
- */
-export async function connect(options = {}) {
-  const config = readConfig();
-  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) {
-      console.log(chalk.yellow('\n  No account found. Run `uc login` first.\n'));
-      process.exit(1);
-    }
-
-    console.log(chalk.dim('\n  Validating session...'));
-    const user = await validateToken();
-    if (!user) {
-      console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
-      process.exit(1);
-    }
-
-    // Fetch a relay token from the API
-    try {
-      const res = await fetch(`${serverUrl}/api/auth/connect-token`, {
-        headers: { Authorization: `Bearer ${token}` },
-      });
-      if (!res.ok) throw new Error('Failed to get connect token');
-      const data = await res.json();
-      relayKey = data.token;
-    } catch (err) {
-      console.log(chalk.red('\n  Could not get connection token. Check your network and try again.\n'));
-      process.exit(1);
-    }
-  }
-
-  // Save for future use
-  writeConfig({ relayKey });
-
-  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
-
-  console.log(chalk.bold('\n  Upfyn-Code Relay Client\n'));
-  console.log(`  Server:  ${chalk.cyan(displayUrl(serverUrl))}`);
-  console.log(`  Machine: ${chalk.dim(os.hostname())}`);
-  console.log(`  User:    ${chalk.dim(os.userInfo().username)}\n`);
-
-  let reconnectAttempts = 0;
-  const MAX_RECONNECT = 10;
-
-  function doConnect() {
-    const ws = new WebSocket(wsUrl);
-
-    ws.on('open', () => {
-      reconnectAttempts = 0;
-      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(),
-      }));
-      console.log(chalk.dim(`  Default project: ${cwd}\n`));
-
-      const heartbeat = setInterval(() => {
-        if (ws.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: 'ping' }));
-        }
-      }, 30000);
-
-      ws.on('close', () => clearInterval(heartbeat));
-    });
-
-    ws.on('message', (rawMessage) => {
-      try {
-        const data = JSON.parse(rawMessage);
-
-        if (data.type === 'relay-connected') {
-          console.log(chalk.green(`  ${data.message}`));
-          return;
-        }
-        if (data.type === 'relay-command') {
-          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,
-            }));
-            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
-          return;
-        }
-        if (data.type === 'relay-shell-kill') {
-          const session = activeShellSessions.get(data.shellSessionId);
-          if (session?.proc) {
-            session.proc.kill('SIGTERM');
-            activeShellSessions.delete(data.shellSessionId);
-            console.log(chalk.dim('  [relay] Shell session killed'));
-          }
-          return;
-        }
-
-        if (data.type === 'pong') return;
-        if (data.type === 'error') {
-          console.error(chalk.red(`  Server error: ${data.error}`));
-          return;
-        }
-      } catch (e) {
-        // message parse error
-      }
-    });
-
-    ws.on('close', (code) => {
-      if (code === 1000) {
-        console.log(chalk.dim('  Disconnected.'));
-        process.exit(0);
-      }
-
-      reconnectAttempts++;
-      if (reconnectAttempts <= MAX_RECONNECT) {
-        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-        console.log(chalk.dim(`  Connection lost. Reconnecting in ${delay / 1000}s... (${reconnectAttempts}/${MAX_RECONNECT})`));
-        setTimeout(doConnect, delay);
-      } else {
-        console.error(chalk.red('  Max reconnection attempts reached. Exiting.'));
-        process.exit(1);
-      }
-    });
-
-    ws.on('error', (err) => {
-      if (err.code === 'ECONNREFUSED') {
-        console.error(chalk.red(`  Cannot reach ${displayUrl(serverUrl)}. Is the server running?`));
-      }
-    });
-  }
-
-  doConnect();
-
-  process.on('SIGINT', () => {
-    console.log(chalk.dim('\n  Disconnecting...'));
-    process.exit(0);
-  });
-}
+import WebSocket from 'ws';
+import os from 'os';
+import { spawn } from 'child_process';
+import { promises as fsPromises } from 'fs';
+import path from 'path';
+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';
+
+// Active process tracking (opencode pattern: activeRequests sync.Map)
+const activeProcesses = new Map(); // requestId → { proc, action }
+
+// Active shell sessions for relay terminal (shellSessionId → { proc })
+const activeShellSessions = new Map();
+
+/**
+ * Start an interactive shell session on the local machine, relayed to the browser.
+ * Spawns a PTY-like process and streams I/O via WebSocket.
+ */
+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.
+
+  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
+      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}`] };
+      }
+      return { cmd: 'powershell.exe', args: ['-Command', `Set-Location -LiteralPath '${projectDir.replace(/'/g, "''")}'; ${command}`] };
+    }
+    const sh = shellType || 'bash';
+    return { cmd: sh, args: ['-c', `cd "${projectDir}" && ${command}`] };
+  }
+
+  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') {
+    const cursorCmd = data.hasSession && data.sessionId
+      ? `cursor-agent --resume="${data.sessionId}"`
+      : 'cursor-agent';
+    const s = wrapCommand(cursorCmd, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  } else {
+    // Claude (default)
+    const command = data.initialCommand || 'claude';
+    let claudeCmd;
+    if (isWin) {
+      claudeCmd = data.hasSession && data.sessionId
+        ? `claude --resume ${data.sessionId}`
+        : command;
+    } else {
+      claudeCmd = data.hasSession && data.sessionId
+        ? `claude --resume ${data.sessionId} || claude`
+        : command;
+    }
+    const s = wrapCommand(claudeCmd, projectPath);
+    shellCmd = s.cmd; shellArgs = s.args;
+  }
+
+  // Send ack so browser knows spawn is starting
+  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',
+    },
+    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(),
+      }));
+    }
+  });
+
+  // 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(),
+      }));
+    }
+  });
+
+  proc.on('close', (code) => {
+    activeShellSessions.delete(shellSessionId);
+    if (ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        type: 'relay-shell-exited',
+        shellSessionId,
+        exitCode: code,
+      }));
+    }
+    console.log(chalk.dim(`  [relay] Shell session ended (code ${code})`));
+  });
+
+  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`,
+      }));
+    }
+  });
+}
+
+/**
+ * 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
+ */
+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);
+      }
+      items.push(item);
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Handle incoming relay commands from the server
+ */
+async function handleRelayCommand(data, ws) {
+  const { requestId, action } = data;
+
+  try {
+    // Permission gate (opencode pattern: dangerous actions require browser approval)
+    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',
+        }));
+        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?.projectPath) args.push('--cwd', options.projectPath);
+        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');
+        if (taskOpts?.projectPath) taskArgs.push('--cwd', taskOpts.projectPath);
+        // 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;
+      }
+
+      default:
+        ws.send(JSON.stringify({
+          type: 'relay-response',
+          requestId,
+          error: `Unknown action: ${action}`,
+        }));
+    }
+  } catch (err) {
+    ws.send(JSON.stringify({
+      type: 'relay-response',
+      requestId,
+      error: err.message,
+    }));
+  }
+}
+
+/**
+ * Connect to the remote server via WebSocket relay.
+ * Bridges local Claude Code, shell, filesystem, and git to the web UI.
+ */
+export async function connect(options = {}) {
+  const config = readConfig();
+  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) {
+      console.log(chalk.yellow('\n  No account found. Run `uc login` first.\n'));
+      process.exit(1);
+    }
+
+    console.log(chalk.dim('\n  Validating session...'));
+    const user = await validateToken();
+    if (!user) {
+      console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
+      process.exit(1);
+    }
+
+    // Fetch a relay token from the API
+    try {
+      const res = await fetch(`${serverUrl}/api/auth/connect-token`, {
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      if (!res.ok) throw new Error('Failed to get connect token');
+      const data = await res.json();
+      relayKey = data.token;
+    } catch (err) {
+      console.log(chalk.red('\n  Could not get connection token. Check your network and try again.\n'));
+      process.exit(1);
+    }
+  }
+
+  // Save for future use
+  writeConfig({ relayKey });
+
+  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
+
+  console.log(chalk.bold('\n  Upfyn-Code Relay Client\n'));
+  console.log(`  Server:  ${chalk.cyan(displayUrl(serverUrl))}`);
+  console.log(`  Machine: ${chalk.dim(os.hostname())}`);
+  console.log(`  User:    ${chalk.dim(os.userInfo().username)}\n`);
+
+  let reconnectAttempts = 0;
+  const MAX_RECONNECT = 10;
+
+  function doConnect() {
+    const ws = new WebSocket(wsUrl);
+
+    ws.on('open', () => {
+      reconnectAttempts = 0;
+      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(),
+      }));
+      console.log(chalk.dim(`  Default project: ${cwd}\n`));
+
+      const heartbeat = setInterval(() => {
+        if (ws.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: 'ping' }));
+        }
+      }, 30000);
+
+      ws.on('close', () => clearInterval(heartbeat));
+    });
+
+    ws.on('message', (rawMessage) => {
+      try {
+        const data = JSON.parse(rawMessage);
+
+        if (data.type === 'relay-connected') {
+          console.log(chalk.green(`  ${data.message}`));
+          return;
+        }
+        if (data.type === 'relay-command') {
+          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,
+            }));
+            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
+          return;
+        }
+        if (data.type === 'relay-shell-kill') {
+          const session = activeShellSessions.get(data.shellSessionId);
+          if (session?.proc) {
+            session.proc.kill('SIGTERM');
+            activeShellSessions.delete(data.shellSessionId);
+            console.log(chalk.dim('  [relay] Shell session killed'));
+          }
+          return;
+        }
+
+        if (data.type === 'pong') return;
+        if (data.type === 'error') {
+          console.error(chalk.red(`  Server error: ${data.error}`));
+          return;
+        }
+      } catch (e) {
+        // message parse error
+      }
+    });
+
+    ws.on('close', (code) => {
+      if (code === 1000) {
+        console.log(chalk.dim('  Disconnected.'));
+        process.exit(0);
+      }
+
+      reconnectAttempts++;
+      if (reconnectAttempts <= MAX_RECONNECT) {
+        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
+        console.log(chalk.dim(`  Connection lost. Reconnecting in ${delay / 1000}s... (${reconnectAttempts}/${MAX_RECONNECT})`));
+        setTimeout(doConnect, delay);
+      } else {
+        console.error(chalk.red('  Max reconnection attempts reached. Exiting.'));
+        process.exit(1);
+      }
+    });
+
+    ws.on('error', (err) => {
+      if (err.code === 'ECONNREFUSED') {
+        console.error(chalk.red(`  Cannot reach ${displayUrl(serverUrl)}. Is the server running?`));
+      }
+    });
+  }
+
+  doConnect();
+
+  process.on('SIGINT', () => {
+    console.log(chalk.dim('\n  Disconnecting...'));
+    process.exit(0);
+  });
+}