upfynai-code 0.1.0 → 2.2.0

package/server/relay-client.js

@@ -0,0 +1,314 @@
+#!/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 } from 'child_process';
+import { promises as fsPromises } from 'fs';
+import crypto from 'crypto';
+
+const CONFIG_DIR = path.join(os.homedir(), '.upfynai');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+// ANSI colors
+const c = {
+  green: (t) => `\x1b[32m${t}\x1b[0m`,
+  red: (t) => `\x1b[31m${t}\x1b[0m`,
+  cyan: (t) => `\x1b[36m${t}\x1b[0m`,
+  dim: (t) => `\x1b[2m${t}\x1b[0m`,
+  bold: (t) => `\x1b[1m${t}\x1b[0m`,
+};
+
+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);
+    });
+  });
+}
+
+/**
+ * Handle incoming relay commands from the server
+ */
+async function handleRelayCommand(data, ws) {
+  const { requestId, action } = data;
+
+  try {
+    switch (action) {
+      case 'claude-query': {
+        // Run Claude via local Agent SDK / CLI
+        const { command, options } = data;
+        console.log(c.cyan(`[RELAY] Claude query: ${command?.slice(0, 80)}...`));
+
+        // Use claude CLI for the 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;
+        console.log(c.dim(`[RELAY] Shell: ${cmd?.slice(0, 60)}`));
+        const result = await execCommand(cmd, [], { cwd: cwd || os.homedir(), timeout: 60000 });
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { stdout: result } }));
+        break;
+      }
+
+      case 'file-read': {
+        const { filePath } = data;
+        const content = await fsPromises.readFile(filePath, 'utf8');
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { content } }));
+        break;
+      }
+
+      case 'file-write': {
+        const { filePath: fp, content: fileContent } = data;
+        await fsPromises.writeFile(fp, fileContent, 'utf8');
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { success: true } }));
+        break;
+      }
+
+      case 'file-tree': {
+        const { dirPath, depth = 3 } = data;
+        const tree = await buildFileTree(dirPath || os.homedir(), depth);
+        ws.send(JSON.stringify({ type: 'relay-response', requestId, data: { tree } }));
+        break;
+      }
+
+      case 'git-operation': {
+        const { gitCommand, cwd: gitCwd } = data;
+        console.log(c.dim(`[RELAY] Git: ${gitCommand}`));
+        const result = await execCommand('git', [gitCommand], { cwd: gitCwd });
+        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)) { // Limit to 100 entries
+      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 [];
+  }
+}
+
+/**
+ * Main connect function
+ */
+export async function connectToServer(options = {}) {
+  const config = loadConfig();
+  const serverUrl = options.server || config.server || 'https://upfynai.thinqmesh.com';
+  const relayKey = options.key || config.relayKey;
+
+  if (!relayKey) {
+    console.error(c.red('No relay key provided.'));
+    console.log('Generate a relay token from Settings > Relay Tokens in the web UI.');
+    console.log(`Then run: ${c.cyan('upfynai-code connect --key upfyn_your_token_here')}`);
+    process.exit(1);
+  }
+
+  // Save config for future use
+  saveConfig({ ...config, server: serverUrl, relayKey });
+
+  const wsUrl = serverUrl.replace(/^http/, 'ws') + '/relay?token=' + encodeURIComponent(relayKey);
+
+  console.log(c.bold('\n  Upfyn-Code Relay Client\n'));
+  console.log(`  Server: ${c.cyan(serverUrl)}`);
+  console.log(`  Machine: ${c.dim(os.hostname())}`);
+  console.log(`  User: ${c.dim(os.userInfo().username)}\n`);
+
+  let reconnectAttempts = 0;
+  const MAX_RECONNECT = 10;
+
+  function connect() {
+    const ws = new WebSocket(wsUrl);
+
+    ws.on('open', () => {
+      reconnectAttempts = 0;
+      console.log(c.green('  Connected! Your local machine is now bridged to the server.'));
+      console.log(c.dim('  Press Ctrl+C to disconnect.\n'));
+
+      // Send heartbeat every 30 seconds
+      const heartbeat = setInterval(() => {
+        if (ws.readyState === 1) {
+          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(c.green(`  ${data.message}`));
+          return;
+        }
+
+        if (data.type === 'relay-command') {
+          handleRelayCommand(data, ws);
+          return;
+        }
+
+        if (data.type === 'pong') return;
+
+        if (data.type === 'error') {
+          console.error(c.red(`  Server error: ${data.error}`));
+          return;
+        }
+      } catch (e) {
+        console.error(c.red(`  Error: ${e.message}`));
+      }
+    });
+
+    ws.on('close', (code) => {
+      if (code === 1000) {
+        console.log(c.dim('  Disconnected.'));
+        process.exit(0);
+      }
+
+      reconnectAttempts++;
+      if (reconnectAttempts <= MAX_RECONNECT) {
+        const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 30000);
+        console.log(c.dim(`  Connection lost. Reconnecting in ${delay / 1000}s... (${reconnectAttempts}/${MAX_RECONNECT})`));
+        setTimeout(connect, delay);
+      } else {
+        console.error(c.red('  Max reconnection attempts reached. Exiting.'));
+        process.exit(1);
+      }
+    });
+
+    ws.on('error', (err) => {
+      if (err.code === 'ECONNREFUSED') {
+        console.error(c.red(`  Cannot reach ${serverUrl}. Is the server running?`));
+      }
+      // close handler will trigger reconnect
+    });
+  }
+
+  connect();
+
+  // Graceful shutdown
+  process.on('SIGINT', () => {
+    console.log(c.dim('\n  Disconnecting...'));
+    process.exit(0);
+  });
+}