vcode-cli 1.0.1 → 1.0.3

package/bin/vcode.js

@@ -33,11 +33,30 @@ program
   .command('start')
   .description('Start the V Code bridge and connect to Vynthen')
   .option('--approve-all', 'Auto-approve all operations for this session')
+  .option('--server', 'Auto-start the WebSocket server (default: true)', true)
+  .option('--local', 'Use local WebSocket server (default, use --no-local for remote)', true)
   .action(async (opts) => {
+    if (!opts.server) {
+      process.env.VCODE_WS_URL = 'ws://localhost:3001';
+    }
     const { start } = await import('../lib/commands/start.js');
     await start(opts);
   });
 
+program
+  .command('serve')
+  .description('Start only the WebSocket server (no Vynthen connection)')
+  .option('--port <number>', 'Port to listen on', '3001')
+  .action(async (opts) => {
+    const { spawn } = await import('child_process');
+    const serverPath = new URL('../lib/server.js', import.meta.url);
+    const proc = spawn('node', [serverPath.pathname], {
+      stdio: 'inherit',
+      env: { ...process.env, VCODE_WS_PORT: opts.port }
+    });
+    proc.on('close', (code) => process.exit(code || 0));
+  });
+
 program
   .command('logout')
   .description('Clear stored authentication token')

package/lib/bridge.js

@@ -10,11 +10,12 @@ import ora from 'ora';
 import { dispatch } from './dispatcher.js';
 import { getToken, isTokenExpired } from './keychain.js';
 
-const WS_URL = 'wss://vynthen.com/api/vcode-ws';
-const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 15000, 30000]; // exponential backoff
+const WS_URL = process.env.VCODE_WS_URL || 
+  (process.env.VCODE_LOCAL === 'false' ? 'wss://vynthen.com/api/vcode-ws' : 'ws://localhost:3001');
+const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 15000, 30000];
 
 export class Bridge {
-  constructor({ onStatusChange, onOperation, onError }) {
+  constructor({ onStatusChange, onOperation, onError, onWorkingDirChange, onTerminalOutput }) {
     this.ws = null;
     this.token = null;
     this.connected = false;
@@ -24,13 +25,13 @@ export class Bridge {
     this.onStatusChange = onStatusChange || (() => {});
     this.onOperation = onOperation || (() => {});
     this.onError = onError || (() => {});
+    this.onWorkingDirChange = onWorkingDirChange || (() => {});
+    this.onTerminalOutput = onTerminalOutput || (() => {});
     this.operationCount = 0;
     this.startTime = null;
+    this.currentWorkingDir = process.cwd();
   }
 
-  /**
-   * Start the bridge connection.
-   */
   async connect() {
     this.token = await getToken();
 
@@ -47,9 +48,6 @@ export class Bridge {
     this._connect();
   }
 
-  /**
-   * Internal connect with reconnection logic.
-   */
   _connect() {
     if (this.intentionalClose) return;
 
@@ -81,7 +79,7 @@ export class Bridge {
             platform: process.platform,
             arch: process.arch,
             nodeVersion: process.version,
-            cwd: process.cwd(),
+            cwd: this.currentWorkingDir,
             hostname: os.hostname(),
             username: os.userInfo().username,
             homedir: os.homedir(),
@@ -134,9 +132,6 @@ export class Bridge {
     });
   }
 
-  /**
-   * Reconnect with exponential backoff.
-   */
   _reconnect() {
     if (this.intentionalClose) return;
 
@@ -152,14 +147,12 @@ export class Bridge {
     }, delay);
   }
 
-  /**
-   * Handle incoming message from server.
-   */
   async _handleMessage(message) {
     const { type, id, data } = message;
 
     switch (type) {
-      case 'OPERATION': {
+      case 'OPERATION':
+      case 'OPERATION_REQUEST': {
         this.operationCount++;
         const opType = data?.operation;
         const params = data?.params || {};
@@ -194,6 +187,17 @@ export class Bridge {
         break;
       }
 
+      case 'TERMINAL_OUTPUT': {
+        this.onTerminalOutput(data);
+        break;
+      }
+
+      case 'WORKING_DIR': {
+        this.currentWorkingDir = data.path;
+        this.onWorkingDirChange(data.path);
+        break;
+      }
+
       case 'PING':
         this.send({ type: 'PONG' });
         break;
@@ -202,24 +206,25 @@ export class Bridge {
         console.log(chalk.hex('#a855f7')(`  ⓘ Server: ${data?.message || ''}`));
         break;
 
+      case 'SET_WORKING_DIR': {
+        const newPath = data.path;
+        if (newPath) {
+          this.send({ type: 'SET_WORKING_DIR', path: newPath });
+        }
+        break;
+      }
+
       default:
-        // Unknown message type — ignore
         break;
     }
   }
 
-  /**
-   * Send a message to the server.
-   */
   send(message) {
     if (this.ws && this.ws.readyState === WebSocket.OPEN) {
       this.ws.send(JSON.stringify(message));
     }
   }
 
-  /**
-   * Gracefully disconnect.
-   */
   disconnect() {
     this.intentionalClose = true;
     if (this.ws) {
@@ -229,9 +234,6 @@ export class Bridge {
     this.connected = false;
   }
 
-  /**
-   * Get uptime in human-readable format.
-   */
   getUptime() {
     if (!this.startTime) return '0s';
     const diff = Date.now() - this.startTime;
@@ -242,4 +244,15 @@ export class Bridge {
     if (mins > 0) return `${mins}m ${secs}s`;
     return `${secs}s`;
   }
-}
+
+  getWorkingDir() {
+    return this.currentWorkingDir;
+  }
+
+  setWorkingDir(path) {
+    this.currentWorkingDir = path;
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.send({ type: 'SET_WORKING_DIR', path });
+    }
+  }
+}

package/lib/commands/start.js

@@ -8,9 +8,11 @@ import { showLogo, startLogoAnimation } from '../logo.js';
 import { getToken, isTokenExpired, getUser } from '../keychain.js';
 import { Bridge } from '../bridge.js';
 import { setSessionApproveAll } from '../permissions.js';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
 
 export async function start(opts = {}) {
-  // ── Pre-flight checks ──
   const token = await getToken();
 
   if (!token) {
@@ -23,21 +25,46 @@ export async function start(opts = {}) {
     process.exit(1);
   }
 
-  // ── Session approve-all mode ──
   if (opts.approveAll) {
     setSessionApproveAll(true);
     console.log(chalk.yellow('\n  ⚠ Auto-approve mode enabled. All operations will be approved automatically.\n'));
   }
 
-  // ── Show animated logo ──
   const stopAnimation = startLogoAnimation();
-
-  // Let animation play for 2.5 seconds then stop for clean UI
   await new Promise(resolve => setTimeout(resolve, 2500));
   stopAnimation();
 
-  // Show connection info
   const user = await getUser();
+  
+  const serverUrl = process.env.VCODE_WS_URL || 
+    (process.env.VCODE_LOCAL === 'false' ? 'wss://vynthen.com/api/vcode-ws' : 'ws://localhost:3001');
+  const autoStartServer = opts.server !== false && opts.server !== undefined;
+  
+  // Try to find the server script
+  const serverScript = path.join(process.cwd(), 'lib', 'server.js');
+  const serverExists = fs.existsSync(serverScript);
+
+  // Start the WebSocket server automatically if not already running
+  let serverProcess = null;
+  
+  if (autoStartServer && serverExists) {
+    console.log(chalk.gray('  Starting V Code WebSocket server...'));
+    
+    serverProcess = spawn('node', [serverScript], {
+      stdio: 'inherit',
+      detached: false
+    });
+    
+    // Wait for server to start
+    await new Promise(resolve => setTimeout(resolve, 1500));
+    
+    if (serverProcess.killed || !serverProcess.pid) {
+      console.log(chalk.yellow('\n  ⚠ Could not start WebSocket server. Make sure port 3001 is available.\n'));
+    } else {
+      console.log(chalk.green('  ✓ WebSocket server started on port 3001'));
+    }
+  }
+
   console.log('');
   console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
   console.log(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge'));
@@ -45,18 +72,18 @@ export async function start(opts = {}) {
   console.log('');
   console.log(chalk.white('  User:     ') + chalk.cyan(user || 'authenticated'));
   console.log(chalk.white('  Mode:     ') + chalk.gray(opts.approveAll ? 'Auto-approve' : 'Human-in-the-loop'));
-  console.log(chalk.white('  Endpoint: ') + chalk.gray('wss://vynthen.com/api/vcode-ws'));
+  console.log(chalk.white('  Endpoint: ') + chalk.gray(serverUrl));
   console.log('');
 
-  // ── Launch bridge ──
+  let currentWorkingDir = process.cwd();
+  let terminalOutput = [];
+
   const bridge = new Bridge({
     onStatusChange: (status) => {
       switch (status) {
         case 'connected':
-          // Already handled inside bridge
           break;
         case 'reconnecting':
-          // Already handled inside bridge
           break;
         case 'auth_failed':
         case 'token_expired':
@@ -67,17 +94,28 @@ export async function start(opts = {}) {
       }
     },
     onOperation: (opType, params) => {
-      // Logged inside bridge
     },
     onError: (err) => {
-      // Logged inside bridge
+    },
+    onWorkingDirChange: (path) => {
+      currentWorkingDir = path;
+      console.log(chalk.gray(`  📁 Working directory: ${path}`));
+    },
+    onTerminalOutput: (output) => {
+      terminalOutput.push(output);
+      if (terminalOutput.length > 100) {
+        terminalOutput = terminalOutput.slice(-100);
+      }
+      process.stdout.write(output);
     },
   });
 
-  // ── Graceful shutdown ──
   const shutdown = () => {
     console.log(chalk.gray('\n\n  Shutting down V Code bridge...'));
     bridge.disconnect();
+    if (serverProcess) {
+      serverProcess.kill();
+    }
     console.log(chalk.gray(`  Session duration: ${bridge.getUptime()}`));
     console.log(chalk.gray(`  Operations handled: ${bridge.operationCount}`));
     console.log(chalk.green('  Goodbye! 👋\n'));
@@ -87,14 +125,15 @@ export async function start(opts = {}) {
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
 
-  // ── Connect ──
   try {
     await bridge.connect();
   } catch (err) {
     console.log(chalk.red(`  ✗ ${err.message}\n`));
+    if (serverProcess) {
+      serverProcess.kill();
+    }
     process.exit(1);
   }
 
-  // Keep process alive
   await new Promise(() => {});
-}
+}

package/lib/server.js

@@ -0,0 +1,410 @@
+/**
+ * V Code WebSocket Server
+ * Handles operations from the Vynthen V Code frontend
+ * Run with: node lib/server.js
+ */
+
+import { WebSocketServer } from 'ws';
+import * as http from 'http';
+import { spawn } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+import os from 'os';
+
+const server = http.createServer((req, res) => {
+  if (req.url === '/health') {
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ status: 'ok', timestamp: new Date().toISOString() }));
+    return;
+  }
+  res.writeHead(200);
+  res.end('Vynthen V Code WS Bridge');
+});
+
+const wss = new WebSocketServer({ server });
+
+const connectedClients = new Map();
+let currentWorkingDir = process.cwd();
+
+function log(msg) {
+  console.log(`[WS] ${new Date().toISOString()} - ${msg}`);
+}
+
+function getProjectPath(params) {
+  const basePath = params.projectPath || currentWorkingDir;
+  return path.resolve(basePath);
+}
+
+async function executeOperation(operation, params, ws) {
+  try {
+    const projectPath = getProjectPath(params);
+    
+    switch (operation) {
+      case 'read_file': {
+        const fullPath = path.join(projectPath, params.path);
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        const content = fs.readFileSync(fullPath, 'utf8');
+        return { success: true, content };
+      }
+      
+      case 'write_file': {
+        const fullPath = path.join(projectPath, params.path);
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        const dir = path.dirname(fullPath);
+        if (!fs.existsSync(dir)) {
+          fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(fullPath, params.content, 'utf8');
+        return { success: true, path: params.path };
+      }
+      
+      case 'create_dir': {
+        const fullPath = path.join(projectPath, params.path);
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        fs.mkdirSync(fullPath, { recursive: true });
+        return { success: true, path: params.path };
+      }
+      
+      case 'delete_path': {
+        const fullPath = path.join(projectPath, params.path);
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        if (fs.existsSync(fullPath)) {
+          const stat = fs.statSync(fullPath);
+          if (stat.isDirectory()) {
+            fs.rmSync(fullPath, { recursive: true });
+          } else {
+            fs.unlinkSync(fullPath);
+          }
+        }
+        return { success: true };
+      }
+      
+      case 'list_dir': {
+        const fullPath = path.join(projectPath, params.path || '.');
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        if (!fs.existsSync(fullPath)) {
+          return { success: false, error: 'Directory does not exist' };
+        }
+        const items = fs.readdirSync(fullPath, { withFileTypes: true });
+        const result = items.map(item => ({
+          name: item.name,
+          path: path.join(params.path || '.', item.name),
+          isDirectory: item.isDirectory(),
+          isFile: item.isFile()
+        }));
+        return { success: true, items: result, path: params.path || '.' };
+      }
+      
+      case 'run_command': {
+        const cwd = path.join(projectPath, params.cwd || '.');
+        return new Promise((resolve) => {
+          const child = spawn(params.command, params.args || [], {
+            shell: true,
+            cwd: cwd
+          });
+          
+          let stdout = '';
+          let stderr = '';
+          
+          child.stdout.on('data', (data) => { 
+            const str = data.toString();
+            stdout += str;
+            ws.send(JSON.stringify({ type: 'TERMINAL_OUTPUT', data: str }));
+          });
+          
+          child.stderr.on('data', (data) => { 
+            const str = data.toString();
+            stderr += str;
+            ws.send(JSON.stringify({ type: 'TERMINAL_OUTPUT', data: str, isError: true }));
+          });
+          
+          child.on('close', (code) => {
+            resolve({ success: code === 0, stdout, stderr, exitCode: code });
+          });
+          
+          child.on('error', (err) => {
+            resolve({ success: false, error: err.message });
+          });
+          
+          setTimeout(() => {
+            child.kill();
+            resolve({ success: false, error: 'Command timeout', stdout, stderr });
+          }, params.timeout || 60000);
+        });
+      }
+      
+      case 'set_working_directory': {
+        const fullPath = path.resolve(projectPath, params.path);
+        if (fs.existsSync(fullPath)) {
+          currentWorkingDir = fullPath;
+          return { success: true, path: fullPath };
+        }
+        return { success: false, error: 'Directory does not exist' };
+      }
+      
+      case 'get_working_directory': {
+        return { success: true, path: currentWorkingDir };
+      }
+      
+      case 'get_platform_info': {
+        return {
+          success: true,
+          platform: process.platform,
+          arch: process.arch,
+          homedir: os.homedir(),
+          hostname: os.hostname(),
+          username: os.userInfo().username,
+          cwd: currentWorkingDir
+        };
+      }
+      
+      case 'get_file_tree': {
+        const fullPath = path.join(projectPath, params.path || '.');
+        if (!fullPath.startsWith(projectPath)) {
+          return { success: false, error: 'Path traversal not allowed' };
+        }
+        
+        function buildTree(dirPath, depth = 0) {
+          if (depth > 5) return null;
+          try {
+            const items = fs.readdirSync(dirPath, { withFileTypes: true });
+            const tree = [];
+            for (const item of items) {
+              const fullItemPath = path.join(dirPath, item.name);
+              const relativePath = path.relative(projectPath, fullItemPath);
+              
+              if (item.name.startsWith('.') || item.name === 'node_modules' || item.name === 'dist' || item.name === 'build') {
+                continue;
+              }
+              
+              const node = {
+                name: item.name,
+                path: relativePath,
+                isDirectory: item.isDirectory()
+              };
+              
+              if (item.isDirectory()) {
+                node.children = buildTree(fullItemPath, depth + 1);
+              }
+              tree.push(node);
+            }
+            return tree.sort((a, b) => {
+              if (a.isDirectory === b.isDirectory) return a.name.localeCompare(b.name);
+              return a.isDirectory ? -1 : 1;
+            });
+          } catch (e) {
+            return [];
+          }
+        }
+        
+        const tree = buildTree(fullPath);
+        return { success: true, tree, path: params.path || '.' };
+      }
+      
+      case 'file_exists': {
+        const fullPath = path.join(projectPath, params.path);
+        return { success: true, exists: fs.existsSync(fullPath) };
+      }
+      
+      case 'read_directory_tree': {
+        const fullPath = path.join(projectPath, params.path || '.');
+        if (!fs.existsSync(fullPath)) {
+          return { success: false, error: 'Directory does not exist' };
+        }
+        
+        function scanDir(dirPath, maxDepth = 3, currentDepth = 0) {
+          if (currentDepth >= maxDepth) return [];
+          
+          const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+          const result = []
+          
+          for (const entry of entries) {
+            if (entry.name.startsWith('.') || ['node_modules', 'dist', 'build', '.git', '__pycache__'].includes(entry.name)) {
+              continue
+            }
+            
+            const fullEntryPath = path.join(dirPath, entry.name)
+            const relativePath = path.relative(projectPath, fullEntryPath)
+            
+            result.push({
+              name: entry.name,
+              path: relativePath,
+              type: entry.isDirectory() ? 'directory' : 'file',
+              ...(entry.isDirectory() && currentDepth < maxDepth - 1 ? { 
+                children: scanDir(fullEntryPath, maxDepth, currentDepth + 1) 
+              } : {})
+            })
+          }
+          
+          return result.sort((a, b) => {
+            if (a.type === b.type) return a.name.localeCompare(b.name)
+            return a.type === 'directory' ? -1 : 1
+          })
+        }
+        
+        return { success: true, entries: scanDir(fullPath), path: params.path || '.' };
+      }
+      
+      default:
+        return { success: false, error: `Unknown operation: ${operation}` };
+    }
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+wss.on('connection', (ws, req) => {
+  const clientId = Date.now().toString(36) + Math.random().toString(36).substr(2);
+  log(`Client connected: ${clientId} from ${req.socket.remoteAddress}`);
+  
+  connectedClients.set(ws, { id: clientId, connectedAt: Date.now(), isCLI: false, platform: null });
+
+  ws.isAuthenticated = false;
+  
+  ws.on('message', async (message) => {
+    try {
+      const parsed = JSON.parse(message.toString());
+      log(`Received: ${parsed.type}`);
+      
+      if (parsed.type === 'CLIENT_INFO') {
+        ws.clientData = parsed.data;
+        ws.isAuthenticated = true;
+        
+        connectedClients.set(ws, { 
+          id: clientId, 
+          connectedAt: Date.now(), 
+          isCLI: true, 
+          platform: parsed.data.platform 
+        });
+        
+        currentWorkingDir = parsed.data.cwd || process.cwd();
+        
+        ws.send(JSON.stringify({ 
+          type: 'SERVER_MESSAGE', 
+          data: { 
+            message: 'Successfully connected to Vynthen V Code backend.',
+            workingDir: currentWorkingDir
+          } 
+        }));
+        
+        log(`CLI authenticated: ${parsed.data.username || 'unknown'} on ${parsed.data.platform} at ${currentWorkingDir}`);
+      }
+      
+      else if (parsed.type === 'REGISTER_FRONTEND') {
+        connectedClients.set(ws, { 
+          id: clientId, 
+          connectedAt: Date.now(), 
+          isCLI: false, 
+          platform: null 
+        });
+        
+        ws.send(JSON.stringify({
+          type: 'WORKING_DIR',
+          data: { path: currentWorkingDir }
+        }));
+        
+        log('Frontend registered');
+      }
+      
+      else if (parsed.type === 'OPERATION' || parsed.type === 'OPERATION_REQUEST') {
+        const operation = parsed.data?.operation || parsed.operation;
+        const params = parsed.data?.params || parsed.params || {};
+        const id = parsed.id || Date.now().toString();
+        
+        log(`Operation: ${operation} on ${params.path || 'root'}`);
+        
+        const result = await executeOperation(operation, params, ws);
+        
+        connectedClients.forEach((info, clientWs) => {
+          if (!info.isCLI && clientWs.readyState === clientWs.OPEN) {
+            clientWs.send(JSON.stringify({
+              type: 'OPERATION_COMPLETED',
+              data: { operation, params, result }
+            }));
+          }
+        });
+        
+        ws.send(JSON.stringify({
+          type: 'OPERATION_RESULT',
+          id,
+          data: result
+        }));
+        
+        if (result.success) {
+          log(`Operation completed: ${operation}`);
+        } else {
+          log(`Operation failed: ${operation} - ${result.error}`);
+        }
+      }
+      
+      else if (parsed.type === 'PING') {
+        ws.send(JSON.stringify({ type: 'PONG' }));
+      }
+      
+      else if (parsed.type === 'SET_WORKING_DIR') {
+        const newPath = path.resolve(currentWorkingDir, parsed.path);
+        if (fs.existsSync(newPath) && fs.statSync(newPath).isDirectory()) {
+          currentWorkingDir = newPath;
+          ws.send(JSON.stringify({
+            type: 'WORKING_DIR',
+            data: { path: currentWorkingDir }
+          }));
+          
+          connectedClients.forEach((info, clientWs) => {
+            if (clientWs.readyState === clientWs.OPEN) {
+              clientWs.send(JSON.stringify({
+                type: 'WORKING_DIR',
+                data: { path: currentWorkingDir }
+              }));
+            }
+          });
+          
+          log(`Working directory changed to: ${currentWorkingDir}`);
+        }
+      }
+      
+    } catch (e) {
+      log(`Parse error: ${e.message}`);
+    }
+  });
+
+  ws.on('close', () => {
+    const info = connectedClients.get(ws);
+    log(`Client disconnected: ${info?.id || 'unknown'} (CLI: ${info?.isCLI})`);
+    connectedClients.delete(ws);
+  });
+
+  ws.on('error', (err) => {
+    log(`WebSocket error: ${err.message}`);
+  });
+
+  ws.send(JSON.stringify({ 
+    type: 'SERVER_MESSAGE', 
+    data: { message: 'Connected to Vynthen V Code Bridge. Waiting for authentication...' } 
+  }));
+});
+
+setInterval(() => {
+  connectedClients.forEach((info, ws) => {
+    if (ws.readyState === ws.OPEN) {
+      ws.send(JSON.stringify({ type: 'PING' }));
+    }
+  });
+}, 30000);
+
+const PORT = process.env.VCODE_WS_PORT || 3001;
+server.listen(PORT, () => {
+  log(`V Code WebSocket server running on port ${PORT}`);
+  log(`Working directory: ${currentWorkingDir}`);
+  log(`V Code is ready! Connect your Vynthen V Code frontend to ws://localhost:${PORT}`);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vcode-cli",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "description": "Connect your local machine to Vynthen V Code — a powerful AI code agent with full system control, secure keychain auth, and human-in-the-loop permissions.",
   "main": "bin/vcode.js",
@@ -9,6 +9,7 @@
   },
   "scripts": {
     "start": "node bin/vcode.js start",
+    "serve": "node lib/server.js",
     "test": "echo \"No tests yet\" && exit 0"
   },
   "keywords": [
@@ -52,4 +53,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}