upfynai-code 2.6.0 → 2.6.1

package/server/relay-client.js

@@ -1,672 +0,0 @@
-#!/usr/bin/env node
-/**
- * Upfyn-Code Relay Client
- *
- * Connects your local machine to the hosted Upfyn-Code server.
- * Bridges Claude CLI, terminal, filesystem, and git to the web UI.
- *
- * Usage:
- *   upfynai-code connect --server https://upfynai.thinqmesh.com --key upfyn_xxx
- *   upfynai-code connect  (uses saved config from ~/.upfynai/config.json)
- */
-
-import WebSocket from 'ws';
-import os from 'os';
-import fs from 'fs';
-import path from 'path';
-import { spawn, execSync } from 'child_process';
-import { promises as fsPromises } from 'fs';
-import crypto from 'crypto';
-import {
-  c,
-  showConnectStartup,
-  showConnectionBanner,
-  logRelayEvent,
-  createSpinner,
-} from './cli-ui.js';
-
-// Load package.json for version
-import { fileURLToPath } from 'url';
-const __filename_rc = fileURLToPath(import.meta.url);
-const __dirname_rc = path.dirname(__filename_rc);
-let VERSION = '0.0.0';
-try {
-  const pkg = JSON.parse(fs.readFileSync(path.join(__dirname_rc, '../package.json'), 'utf8'));
-  VERSION = pkg.version;
-} catch { /* ignore */ }
-
-const CONFIG_DIR = path.join(os.homedir(), '.upfynai');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
-
-function loadConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
-    }
-  } catch (e) { /* ignore */ }
-  return {};
-}
-
-function saveConfig(config) {
-  if (!fs.existsSync(CONFIG_DIR)) {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
-}
-
-/**
- * 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);
-    });
-  });
-}
-
-/**
- * Resolve a binary name to its full path, checking PATH first then local node_modules/.bin
- */
-function resolveBinary(name) {
-  const isWindows = process.platform === 'win32';
-  try {
-    const result = execSync(`${isWindows ? 'where' : 'which'} ${name}`, { stdio: 'pipe', timeout: 5000 }).toString().trim();
-    return result.split('\n')[0].trim();
-  } catch {
-    const localPath = path.join(__dirname_rc, '../node_modules/.bin', name + (isWindows ? '.cmd' : ''));
-    if (fs.existsSync(localPath)) return localPath;
-    return name; // fallback to bare name
-  }
-}
-
-/**
- * Handle incoming relay commands from the server
- */
-async function handleRelayCommand(data, ws) {
-  const { requestId, action } = data;
-
-  try {
-    switch (action) {
-      case 'claude-query': {
-        const { command, options } = data;
-        logRelayEvent('>', `Claude query: ${command?.slice(0, 60)}...`, 'cyan');
-
-        const args = ['--print'];
-        if (options?.projectPath) args.push('--cwd', options.projectPath);
-        if (options?.sessionId) args.push('--continue', options.sessionId);
-
-        const proc = spawn(resolveBinary('claude'), [...args, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || os.homedir(),
-          env: process.env,
-        });
-
-        proc.stdout.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'claude-response', content: chunk.toString() }
-          }));
-        });
-
-        proc.stderr.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'claude-error', content: chunk.toString() }
-          }));
-        });
-
-        proc.on('close', (code) => {
-          ws.send(JSON.stringify({
-            type: 'relay-complete',
-            requestId,
-            exitCode: code
-          }));
-        });
-        break;
-      }
-
-      case 'codex-query': {
-        const { command, options } = data;
-        logRelayEvent('>', `Codex query: ${command?.slice(0, 60)}...`, 'cyan');
-
-        const codexArgs = ['--quiet'];
-        if (options?.projectPath || options?.cwd) {
-          codexArgs.push('--cwd', options.projectPath || options.cwd);
-        }
-        if (options?.model) codexArgs.push('--model', options.model);
-
-        const codexProc = spawn(resolveBinary('codex'), [...codexArgs, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || options?.cwd || os.homedir(),
-          env: process.env,
-        });
-
-        codexProc.stdout.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'codex-response', content: chunk.toString() }
-          }));
-        });
-
-        codexProc.stderr.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'codex-error', content: chunk.toString() }
-          }));
-        });
-
-        codexProc.on('close', (code) => {
-          ws.send(JSON.stringify({
-            type: 'relay-complete',
-            requestId,
-            exitCode: code
-          }));
-        });
-        break;
-      }
-
-      case 'cursor-query': {
-        const { command, options } = data;
-        logRelayEvent('>', `Cursor query: ${command?.slice(0, 60)}...`, 'cyan');
-
-        const cursorArgs = [];
-        if (options?.projectPath || options?.cwd) {
-          cursorArgs.push('--cwd', options.projectPath || options.cwd);
-        }
-        if (options?.model) cursorArgs.push('--model', options.model);
-
-        const cursorProc = spawn(resolveBinary('cursor-agent'), [...cursorArgs, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || options?.cwd || os.homedir(),
-          env: process.env,
-        });
-
-        cursorProc.stdout.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'cursor-response', content: chunk.toString() }
-          }));
-        });
-
-        cursorProc.stderr.on('data', (chunk) => {
-          ws.send(JSON.stringify({
-            type: 'relay-stream',
-            requestId,
-            data: { type: 'cursor-error', content: chunk.toString() }
-          }));
-        });
-
-        cursorProc.on('close', (code) => {
-          ws.send(JSON.stringify({
-            type: 'relay-complete',
-            requestId,
-            exitCode: code
-          }));
-        });
-        break;
-      }
-
-      case 'detect-agents': {
-        const agents = detectInstalledAgents();
-        ws.send(JSON.stringify({
-          type: 'relay-response',
-          requestId,
-          data: { agents }
-        }));
-        break;
-      }
-
-      case 'shell-command': {
-        const { command: cmd, cwd } = data;
-        if (!cmd || typeof cmd !== 'string') throw new Error('Invalid command');
-        // Block dangerous shell patterns (cross-platform)
-        const cmdLower = cmd.toLowerCase();
-        const dangerous = [
-          'rm -rf /', 'mkfs', 'dd if=', ':(){', 'fork bomb', '> /dev/sd',       // Unix
-          'format c:', 'format d:', 'format e:', 'del /s /q c:\\',               // Windows
-          'rd /s /q c:\\', 'reg delete', 'bcdedit',                              // Windows
-        ];
-        if (dangerous.some(d => cmdLower.includes(d.toLowerCase()))) throw new Error('Command blocked for safety');
-        logRelayEvent('$', `Shell: ${cmd?.slice(0, 50)}`, 'dim');
-        const result = await execCommand(cmd, [], { cwd: cwd || process.cwd(), timeout: 60000 });
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { stdout: result } }));
-        break;
-      }
-
-      case 'file-read': {
-        const { filePath } = data;
-        if (!filePath || typeof filePath !== 'string') throw new Error('Invalid file path');
-        const normalizedPath = path.resolve(filePath);
-        // Block reading sensitive files (cross-platform, case-insensitive)
-        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');
-        logRelayEvent('R', `Read: ${filePath}`, 'dim');
-        const content = await fsPromises.readFile(normalizedPath, 'utf8');
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content } }));
-        break;
-      }
-
-      case 'file-write': {
-        const { filePath: fp, content: fileContent } = data;
-        if (!fp || typeof fp !== 'string') throw new Error('Invalid file path');
-        const normalizedFp = path.resolve(fp);
-        // Block writing to sensitive locations (cross-platform, case-insensitive)
-        const fpLower = normalizedFp.toLowerCase().replace(/\\/g, '/');
-        const blockedWrite = [
-          '/etc/', '/usr/bin/', '/usr/sbin/',                                     // Unix
-          '/windows/system32', '/windows/syswow64', '/program files',             // Windows
-          '.ssh/', '/.env',
-        ];
-        if (blockedWrite.some(d => fpLower.includes(d))) throw new Error('Access denied');
-        // Ensure parent directory exists (works across drives)
-        const parentDir = path.dirname(normalizedFp);
-        await fsPromises.mkdir(parentDir, { recursive: true }).catch(() => {});
-        logRelayEvent('W', `Write: ${fp}`, 'dim');
-        await fsPromises.writeFile(normalizedFp, fileContent, 'utf8');
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { success: true } }));
-        break;
-      }
-
-      case 'file-tree': {
-        const { dirPath, depth = 3 } = data;
-        // Use provided path (any drive), fall back to cwd, then home
-        const resolvedDir = dirPath ? path.resolve(dirPath) : process.cwd();
-        const tree = await buildFileTree(resolvedDir, depth);
-        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { tree } }));
-        break;
-      }
-
-      case 'git-operation': {
-        const { gitCommand, cwd: gitCwd } = data;
-        logRelayEvent('G', `Git: ${gitCommand}`, 'dim');
-        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;
-      }
-
-      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
-    }));
-  }
-}
-
-/**
- * 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, 100)) {
-      if (entry.name.startsWith('.') || entry.name === 'node_modules') continue;
-      const item = { name: entry.name, type: entry.isDirectory() ? 'directory' : 'file' };
-      if (entry.isDirectory() && currentDepth < maxDepth - 1) {
-        item.children = await buildFileTree(path.join(dirPath, entry.name), maxDepth, currentDepth + 1);
-      }
-      items.push(item);
-    }
-    return items;
-  } catch (e) {
-    return [];
-  }
-}
-
-/**
- * Detect which AI CLI agents are installed on this machine
- * Returns an object with agent names and their availability
- */
-function detectInstalledAgents() {
-  const isWindows = process.platform === 'win32';
-  const whichCmd = isWindows ? 'where' : 'which';
-
-  // Also check our own node_modules/.bin for bundled agents
-  const localBinDir = path.join(__dirname_rc, '../node_modules/.bin');
-
-  const agents = [
-    { name: 'claude', binary: 'claude', label: 'Claude Code' },
-    { name: 'codex', binary: 'codex', label: 'OpenAI Codex' },
-    { name: 'cursor', binary: 'cursor-agent', label: 'Cursor Agent' },
-  ];
-
-  const detected = {};
-  for (const agent of agents) {
-    try {
-      const result = execSync(`${whichCmd} ${agent.binary}`, { stdio: 'pipe', timeout: 5000 }).toString().trim();
-      detected[agent.name] = {
-        installed: true,
-        path: result.split('\n')[0].trim(),
-        label: agent.label,
-      };
-    } catch {
-      // Fallback: check bundled node_modules/.bin
-      const localPath = path.join(localBinDir, agent.binary + (isWindows ? '.cmd' : ''));
-      if (fs.existsSync(localPath)) {
-        detected[agent.name] = {
-          installed: true,
-          path: localPath,
-          label: agent.label,
-        };
-      } else {
-        detected[agent.name] = {
-          installed: false,
-          label: agent.label,
-        };
-      }
-    }
-  }
-  return detected;
-}
-
-/**
- * Create WebSocket connection with optional API key in handshake
- */
-function createRelayConnection(wsUrl, config = {}) {
-  const headers = {};
-  // Send API key in WebSocket headers if available
-  if (config.anthropicApiKey) {
-    headers['x-anthropic-api-key'] = config.anthropicApiKey;
-  }
-  headers['x-upfyn-version'] = VERSION;
-  headers['x-upfyn-machine'] = os.hostname();
-  headers['x-upfyn-platform'] = process.platform;
-  headers['x-upfyn-cwd'] = process.cwd();
-
-  return new WebSocket(wsUrl, { headers });
-}
-
-/**
- * Main connect function (interactive — with animation and logging)
- */
-export async function connectToServer(options = {}) {
-  const config = loadConfig();
-  const serverUrl = options.server || config.server || 'https://upfynai-code-production.up.railway.app';
-  const relayKey = options.key || config.relayKey;
-
-  if (!relayKey) {
-    console.log('');
-    console.log(`  ${c.red('FAIL')} No relay key provided.`);
-    console.log('');
-    console.log(`  ${c.gray('Get your relay token from the web UI:')}`);
-    console.log(`  ${c.dim('1.')} Sign in at ${c.cyan('https://cli.upfyn.com')}`);
-    console.log(`  ${c.dim('2.')} Click ${c.bright('Connect')} button`);
-    console.log(`  ${c.dim('3.')} Copy the command and run it here`);
-    console.log('');
-    console.log(`  ${c.gray('Or run:')} ${c.bright('uc connect --server <url> --key upfyn_your_token')}`);
-    console.log('');
-    process.exit(1);
-  }
-
-  // Save config for future use
-  saveConfig({ ...config, server: serverUrl, relayKey });
-
-  // Show beautiful startup with rocket animation
-  await showConnectStartup(
-    serverUrl,
-    os.hostname(),
-    os.userInfo().username,
-    VERSION
-  );
-
-  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
-
-  const spinner = createSpinner('Connecting to server...');
-  spinner.start();
-
-  let reconnectAttempts = 0;
-  const MAX_RECONNECT = 10;
-
-  let lastPongTime = Date.now();
-
-  function connect() {
-    const ws = createRelayConnection(wsUrl, config);
-    lastPongTime = Date.now();
-
-    ws.on('open', () => {
-      reconnectAttempts = 0;
-      lastPongTime = Date.now();
-      // Don't stop spinner yet — wait for relay-connected message
-    });
-
-    ws.on('message', (rawMessage) => {
-      try {
-        const data = JSON.parse(rawMessage);
-
-        if (data.type === 'relay-connected') {
-          spinner.stop('Connected!');
-          // Extract username from message if possible
-          const nameMatch = data.message?.match(/Connected as (.+?)\./);
-          const username = nameMatch ? nameMatch[1] : 'Unknown';
-          showConnectionBanner(username, serverUrl);
-
-          // Detect and report installed agents
-          const agents = detectInstalledAgents();
-          const installed = Object.entries(agents)
-            .filter(([, info]) => info.installed)
-            .map(([name, info]) => info.label);
-          const missing = Object.entries(agents)
-            .filter(([, info]) => !info.installed)
-            .map(([name, info]) => info.label);
-
-          if (installed.length > 0) {
-            logRelayEvent('+', `Agents found: ${installed.join(', ')}`, 'green');
-          }
-          if (missing.length > 0) {
-            logRelayEvent('~', `Not found: ${missing.join(', ')} (install to enable)`, 'yellow');
-          }
-
-          // Send agent capabilities to server
-          ws.send(JSON.stringify({
-            type: 'agent-capabilities',
-            agents,
-            machine: {
-              hostname: os.hostname(),
-              platform: process.platform,
-              cwd: process.cwd(),
-            }
-          }));
-
-          logRelayEvent('*', 'Relay active -- waiting for commands...', 'green');
-          return;
-        }
-
-        if (data.type === 'relay-command') {
-          handleRelayCommand(data, ws);
-          return;
-        }
-
-        if (data.type === 'pong' || data.type === 'server-ping') {
-          lastPongTime = Date.now();
-          // Reply to server-ping so server knows we're alive
-          if (data.type === 'server-ping') {
-            ws.send(JSON.stringify({ type: 'ping' }));
-          }
-          return;
-        }
-
-        if (data.type === 'error') {
-          spinner.fail(`Server error: ${data.error}`);
-          return;
-        }
-      } catch (e) {
-        logRelayEvent('!', `Parse error: ${e.message}`, 'red');
-      }
-    });
-
-    ws.on('close', (code) => {
-      if (code === 1000) {
-        logRelayEvent('-', 'Disconnected gracefully.', 'dim');
-        process.exit(0);
-      }
-
-      reconnectAttempts++;
-      if (reconnectAttempts <= MAX_RECONNECT) {
-        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-        logRelayEvent('~', `Connection lost. Reconnecting in ${delay / 1000}s... (${reconnectAttempts}/${MAX_RECONNECT})`, 'yellow');
-        setTimeout(connect, delay);
-      } else {
-        logRelayEvent('X', 'Max reconnection attempts reached. Exiting.', 'red');
-        process.exit(1);
-      }
-    });
-
-    ws.on('error', (err) => {
-      if (err.code === 'ECONNREFUSED') {
-        spinner.fail(`Cannot reach ${serverUrl}. Is the server running?`);
-      } else if (err.message?.includes('401')) {
-        spinner.fail('Authentication failed (401). Your relay token may be invalid or expired.');
-        logRelayEvent('!', 'Get a new token from the dashboard: https://cli.upfyn.com/dashboard', 'yellow');
-        logRelayEvent('!', 'Then run: uc connect --server <url> --key <new_token>', 'yellow');
-      } else if (err.message?.includes('403') || err.message?.includes('Forbidden')) {
-        spinner.fail('Access forbidden (403). Your account may be inactive.');
-      } else {
-        logRelayEvent('!', `WebSocket error: ${err.message || err.code || 'unknown'}`, 'red');
-      }
-      // close handler will trigger reconnect
-    });
-
-    // Heartbeat every 30 seconds with pong timeout detection
-    const heartbeat = setInterval(() => {
-      if (ws.readyState !== 1) {
-        clearInterval(heartbeat);
-        return;
-      }
-      // If no pong received in 75s, consider connection dead
-      if (Date.now() - lastPongTime > 75000) {
-        clearInterval(heartbeat);
-        logRelayEvent('!', 'No heartbeat response — connection stale, reconnecting...', 'yellow');
-        ws.terminate();
-        return;
-      }
-      ws.send(JSON.stringify({ type: 'ping' }));
-    }, 30000);
-
-    ws.on('close', () => clearInterval(heartbeat));
-    ws.on('error', () => clearInterval(heartbeat));
-  }
-
-  connect();
-
-  // Graceful shutdown
-  process.on('SIGINT', () => {
-    console.log('');
-    logRelayEvent('-', 'Disconnecting...', 'dim');
-    process.exit(0);
-  });
-}
-
-/**
- * Background connect function (silent — used when uc launches Claude Code)
- * Runs relay in the background without animation or user-facing output.
- */
-export function connectToServerBackground(options = {}) {
-  const config = loadConfig();
-  const serverUrl = options.server || config.server;
-  const relayKey = options.key || config.relayKey;
-
-  if (!serverUrl || !relayKey) return;
-
-  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
-
-  let reconnectAttempts = 0;
-  const MAX_RECONNECT = 5;
-  let lastPongTime = Date.now();
-
-  function connect() {
-    const ws = createRelayConnection(wsUrl, config);
-    lastPongTime = Date.now();
-
-    ws.on('message', (rawMessage) => {
-      try {
-        const data = JSON.parse(rawMessage);
-        if (data.type === 'pong' || data.type === 'server-ping') {
-          lastPongTime = Date.now();
-          if (data.type === 'server-ping') {
-            ws.send(JSON.stringify({ type: 'ping' }));
-          }
-          return;
-        }
-        if (data.type === 'relay-command') {
-          handleRelayCommand(data, ws);
-        }
-      } catch { /* ignore */ }
-    });
-
-    ws.on('open', () => {
-      reconnectAttempts = 0;
-      lastPongTime = Date.now();
-    });
-
-    ws.on('close', (code) => {
-      clearInterval(heartbeat);
-      if (code === 1000) return;
-      reconnectAttempts++;
-      if (reconnectAttempts <= MAX_RECONNECT) {
-        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
-        setTimeout(connect, delay);
-      }
-    });
-
-    ws.on('error', () => {
-      clearInterval(heartbeat);
-    });
-
-    // Heartbeat with pong timeout
-    const heartbeat = setInterval(() => {
-      if (ws.readyState !== 1) {
-        clearInterval(heartbeat);
-        return;
-      }
-      if (Date.now() - lastPongTime > 75000) {
-        clearInterval(heartbeat);
-        ws.terminate();
-        return;
-      }
-      ws.send(JSON.stringify({ type: 'ping' }));
-    }, 30000);
-  }
-
-  connect();
-}