upfynai-code 2.5.1 → 2.6.1

package/src/connect.js

@@ -0,0 +1,314 @@
+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 } from './config.js';
+import { getToken, validateToken } from './auth.js';
+
+/**
+ * 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, 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 {
+    return [];
+  }
+}
+
+/**
+ * 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;
+        console.log(chalk.cyan('  [relay] Processing Claude query...'));
+
+        const args = ['--print'];
+        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,
+        });
+
+        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 '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...'));
+        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);
+        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, '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);
+        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 = 3 } = data;
+        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;
+        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;
+      }
+
+      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 `upfyn-code 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 `upfyn-code 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(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'));
+
+      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;
+        }
+        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 ${serverUrl}. Is the server running?`));
+      }
+    });
+  }
+
+  doConnect();
+
+  process.on('SIGINT', () => {
+    console.log(chalk.dim('\n  Disconnecting...'));
+    process.exit(0);
+  });
+}

package/src/launch.js

@@ -0,0 +1,54 @@
+import open from 'open';
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+import { startServer } from './server.js';
+
+export async function openHosted() {
+  const token = getToken();
+
+  if (!token) {
+    console.log(chalk.yellow('\n  No account found. Run `upfyn-code 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 `upfyn-code login` to re-authenticate.\n'));
+    process.exit(1);
+  }
+
+  const config = readConfig();
+  const url = `${config.serverUrl}?token=${encodeURIComponent(token)}`;
+
+  const name = user.first_name || user.username;
+  console.log(chalk.green(`  Welcome back, ${chalk.bold(name)}!`));
+  console.log(chalk.dim('  Opening Upfyn-Code in your browser...\n'));
+
+  await open(url);
+}
+
+export async function startLocal() {
+  const token = getToken();
+
+  if (!token) {
+    console.log(chalk.yellow('\n  No account found. Run `upfyn-code 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 `upfyn-code login` to re-authenticate.\n'));
+    process.exit(1);
+  }
+
+  const config = readConfig();
+  const name = user.first_name || user.username;
+  console.log(chalk.green(`  Welcome back, ${chalk.bold(name)}!`));
+
+  await startServer(config.localPort, config.serverUrl, token);
+}

package/src/mcp.js

@@ -0,0 +1,57 @@
+import chalk from 'chalk';
+import { readConfig } from './config.js';
+import { getToken, validateToken } from './auth.js';
+
+/**
+ * Print MCP configuration for Claude / Cursor / other AI tools.
+ * Optionally accepts --server and --key overrides.
+ */
+export async function mcp(options = {}) {
+  const config = readConfig();
+  const serverUrl = options.server || config.serverUrl;
+  let relayKey = options.key;
+
+  // If no key provided, fetch one using auth token
+  if (!relayKey) {
+    const token = getToken();
+    if (!token) {
+      console.log(chalk.yellow('\n  No account found. Run `upfyn-code login` first.\n'));
+      process.exit(1);
+    }
+
+    const user = await validateToken();
+    if (!user) {
+      console.log(chalk.yellow('\n  Session expired. Run `upfyn-code login` to re-authenticate.\n'));
+      process.exit(1);
+    }
+
+    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);
+    }
+  }
+
+  const mcpConfig = {
+    mcpServers: {
+      'upfyn-code': {
+        url: `${serverUrl}/mcp`,
+        headers: {
+          Authorization: `Bearer ${relayKey}`,
+        },
+      },
+    },
+  };
+
+  console.log(chalk.bold('\n  Upfyn-Code — MCP Integration\n'));
+  console.log(chalk.dim('  Add this to your Claude / Cursor MCP settings:\n'));
+  console.log(chalk.white(JSON.stringify(mcpConfig, null, 2)));
+  console.log('');
+  console.log(chalk.dim('  The JSON above contains your MCP URL and authorization header.\n'));
+}

package/src/server.js

@@ -0,0 +1,54 @@
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+import express from 'express';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import open from 'open';
+import chalk from 'chalk';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const DIST_DIR = join(__dirname, '..', 'dist');
+
+export async function startServer(port, serverUrl, token) {
+  if (!existsSync(DIST_DIR)) {
+    console.log(chalk.red('\n  Error: No built frontend found at dist/.'));
+    console.log(chalk.dim('  Run the build-frontend script first, or use the default mode (no --local flag).\n'));
+    process.exit(1);
+  }
+
+  const app = express();
+
+  // Proxy API calls to the remote Vercel backend
+  app.use('/api', createProxyMiddleware({
+    target: serverUrl,
+    changeOrigin: true,
+    headers: {
+      Authorization: `Bearer ${token}`,
+    },
+  }));
+
+  // Serve the built React frontend
+  app.use(express.static(DIST_DIR));
+
+  // SPA fallback — serve index.html for all non-API, non-static routes
+  app.get('*', (req, res) => {
+    res.sendFile(join(DIST_DIR, 'index.html'));
+  });
+
+  return new Promise((resolve) => {
+    const server = app.listen(port, async () => {
+      const url = `http://localhost:${port}?token=${encodeURIComponent(token)}`;
+      console.log(chalk.green(`\n  Local server running at ${chalk.bold(`http://localhost:${port}`)}`));
+      console.log(chalk.dim('  API proxy active. Press Ctrl+C to stop.\n'));
+      await open(url);
+      resolve(server);
+    });
+
+    const shutdown = () => {
+      console.log(chalk.dim('\n  Shutting down...'));
+      server.close(() => process.exit(0));
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+  });
+}