vcode-cli 1.0.0

package/lib/commands/start.js

@@ -0,0 +1,100 @@
+/**
+ * V Code — Start Command.
+ * Launches the bridge, shows animated logo, connects to Vynthen.
+ */
+
+import chalk from 'chalk';
+import { showLogo, startLogoAnimation } from '../logo.js';
+import { getToken, isTokenExpired, getUser } from '../keychain.js';
+import { Bridge } from '../bridge.js';
+import { setSessionApproveAll } from '../permissions.js';
+
+export async function start(opts = {}) {
+  // ── Pre-flight checks ──
+  const token = await getToken();
+
+  if (!token) {
+    console.log(chalk.red('\n  ✗ Not authenticated. Run `vcode login` first.\n'));
+    process.exit(1);
+  }
+
+  if (isTokenExpired(token)) {
+    console.log(chalk.red('\n  ✗ Token expired. Run `vcode login` to re-authenticate.\n'));
+    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();
+  console.log('');
+  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
+  console.log(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge'));
+  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
+  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('');
+
+  // ── Launch bridge ──
+  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':
+          process.exit(1);
+          break;
+        case 'disconnected':
+          break;
+      }
+    },
+    onOperation: (opType, params) => {
+      // Logged inside bridge
+    },
+    onError: (err) => {
+      // Logged inside bridge
+    },
+  });
+
+  // ── Graceful shutdown ──
+  const shutdown = () => {
+    console.log(chalk.gray('\n\n  Shutting down V Code bridge...'));
+    bridge.disconnect();
+    console.log(chalk.gray(`  Session duration: ${bridge.getUptime()}`));
+    console.log(chalk.gray(`  Operations handled: ${bridge.operationCount}`));
+    console.log(chalk.green('  Goodbye! 👋\n'));
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // ── Connect ──
+  try {
+    await bridge.connect();
+  } catch (err) {
+    console.log(chalk.red(`  ✗ ${err.message}\n`));
+    process.exit(1);
+  }
+
+  // Keep process alive
+  await new Promise(() => {});
+}

package/lib/commands/status.js

@@ -0,0 +1,84 @@
+/**
+ * V Code — Status Command.
+ * Shows connection status, logged-in user, and token info.
+ */
+
+import chalk from 'chalk';
+import { getToken, getUser, decodeToken, isTokenExpired } from '../keychain.js';
+import { getAuditPath, readAuditLog } from '../audit.js';
+
+export async function status() {
+  console.log('');
+  console.log(chalk.hex('#a855f7').bold('  V Code — Status\n'));
+
+  // ── Auth Status ──
+  const token = await getToken();
+  const user = await getUser();
+
+  if (!token) {
+    console.log(chalk.white('  Auth:    ') + chalk.red('Not logged in'));
+    console.log(chalk.gray('  Run `vcode login` to authenticate.\n'));
+    return;
+  }
+
+  const expired = isTokenExpired(token);
+  const payload = decodeToken(token);
+
+  console.log(chalk.white('  Auth:    ') + (expired ? chalk.red('Token expired') : chalk.green('Authenticated')));
+  console.log(chalk.white('  User:    ') + chalk.cyan(user || payload?.email || 'unknown'));
+
+  if (payload?.exp) {
+    const expDate = new Date(payload.exp * 1000);
+    const now = Date.now();
+    if (expired) {
+      console.log(chalk.white('  Expired: ') + chalk.red(expDate.toLocaleString()));
+    } else {
+      const remaining = payload.exp * 1000 - now;
+      const hours = Math.floor(remaining / 3600000);
+      const mins = Math.floor((remaining % 3600000) / 60000);
+      console.log(chalk.white('  Expires: ') + chalk.gray(`${expDate.toLocaleString()} (${hours}h ${mins}m remaining)`));
+    }
+  }
+
+  if (payload?.iat) {
+    const iatDate = new Date(payload.iat * 1000);
+    console.log(chalk.white('  Issued:  ') + chalk.gray(iatDate.toLocaleString()));
+  }
+
+  // ── Token storage ──
+  console.log(chalk.white('  Storage: ') + chalk.gray('OS native keychain (encrypted)'));
+
+  // ── Audit log ──
+  const auditPath = getAuditPath();
+  console.log(chalk.white('  Audit:   ') + chalk.gray(auditPath));
+
+  // ── Platform ──
+  console.log('');
+  console.log(chalk.white('  Platform: ') + chalk.gray(`${process.platform} ${process.arch}`));
+  console.log(chalk.white('  Node:     ') + chalk.gray(process.version));
+  console.log(chalk.white('  CWD:      ') + chalk.gray(process.cwd()));
+
+  // ── Recent audit entries ──
+  console.log('');
+  console.log(chalk.white('  Recent operations:'));
+  const log = readAuditLog(5);
+  if (log === '(no audit log yet)') {
+    console.log(chalk.gray('    No operations recorded yet.'));
+  } else {
+    log.split('\n').forEach(line => {
+      if (line.includes('APPROVED')) {
+        console.log(chalk.green(`    ${line}`));
+      } else if (line.includes('DENIED')) {
+        console.log(chalk.red(`    ${line}`));
+      } else {
+        console.log(chalk.gray(`    ${line}`));
+      }
+    });
+  }
+
+  console.log('');
+
+  if (expired) {
+    console.log(chalk.yellow('  ⚠ Your token has expired. Run `vcode login` to re-authenticate.\n'));
+  }
+}

package/lib/dispatcher.js

@@ -0,0 +1,93 @@
+/**
+ * V Code — Operation Dispatcher.
+ * Routes incoming operation requests to the correct handler.
+ */
+
+import { readFileOp, readFileLinesOp, writeFileOp, deleteFileOp, renameFileOp, moveFileOp, createDirOp, deleteDirOp, listDirOp } from './operations/filesystem.js';
+import { execCommandOp, spawnCommandOp } from './operations/terminal.js';
+import { mouseMove, mouseClick, mouseDoubleClick, mouseDrag } from './operations/mouse.js';
+import { keyType, keyPress } from './operations/keyboard.js';
+import { screenshotOp, listDisplaysOp } from './operations/screenshot.js';
+import { listProcessesOp, killProcessOp } from './operations/process.js';
+import { clipboardReadOp, clipboardWriteOp } from './operations/clipboard.js';
+import { openUrlOp, openFolderOp } from './operations/browser.js';
+
+/**
+ * Dispatch an operation by type.
+ * @param {string} type — operation type identifier
+ * @param {object} params — operation parameters
+ * @returns {object} — operation result
+ */
+export async function dispatch(type, params = {}) {
+  switch (type) {
+    // ── File System ──
+    case 'READ_FILE':
+      return readFileOp(params.path);
+    case 'READ_FILE_LINES':
+      return readFileLinesOp(params.path, params.startLine, params.endLine);
+    case 'WRITE_FILE':
+    case 'CREATE_FILE':
+      return writeFileOp(params.path, params.content);
+    case 'DELETE_FILE':
+      return deleteFileOp(params.path);
+    case 'RENAME_FILE':
+      return renameFileOp(params.oldPath, params.newPath);
+    case 'MOVE_FILE':
+      return moveFileOp(params.oldPath, params.newPath);
+    case 'CREATE_DIR':
+      return createDirOp(params.path);
+    case 'DELETE_DIR':
+      return deleteDirOp(params.path);
+    case 'LIST_DIR':
+      return listDirOp(params.path);
+
+    // ── Terminal ──
+    case 'EXEC_COMMAND':
+      return execCommandOp(params.command, params.cwd, params.timeout);
+    case 'SPAWN_COMMAND':
+      return spawnCommandOp(params.command, params.args, params.cwd);
+
+    // ── Mouse ──
+    case 'MOUSE_MOVE':
+      return mouseMove(params.x, params.y);
+    case 'MOUSE_CLICK':
+      return mouseClick(params.button, params.x, params.y);
+    case 'MOUSE_DOUBLE_CLICK':
+      return mouseDoubleClick(params.x, params.y);
+    case 'MOUSE_DRAG':
+      return mouseDrag(params.fromX, params.fromY, params.toX, params.toY);
+
+    // ── Keyboard ──
+    case 'KEY_TYPE':
+      return keyType(params.text);
+    case 'KEY_PRESS':
+      return keyPress(params.keys);
+
+    // ── Screenshot ──
+    case 'SCREENSHOT':
+      return screenshotOp(params.display);
+    case 'LIST_DISPLAYS':
+      return listDisplaysOp();
+
+    // ── Process ──
+    case 'LIST_PROCESSES':
+      return listProcessesOp();
+    case 'KILL_PROCESS':
+      return killProcessOp(params.pid, params.signal);
+
+    // ── Clipboard ──
+    case 'CLIPBOARD_READ':
+      return clipboardReadOp();
+    case 'CLIPBOARD_WRITE':
+      return clipboardWriteOp(params.text);
+
+    // ── Browser / Files ──
+    case 'OPEN_URL':
+      return openUrlOp(params.url);
+    case 'OPEN_FOLDER':
+      return openFolderOp(params.path);
+
+    default:
+      return { success: false, error: `Unknown operation type: ${type}` };
+  }
+}

package/lib/keychain.js

@@ -0,0 +1,74 @@
+/**
+ * V Code — OS Keychain storage via keytar.
+ * Stores JWT token securely in the native credential store.
+ */
+
+import keytar from 'keytar';
+
+const SERVICE = 'vcode-cli';
+const ACCOUNT = 'vynthen-jwt';
+const ACCOUNT_USER = 'vynthen-user';
+
+/**
+ * Store JWT token in OS keychain.
+ */
+export async function storeToken(token) {
+  await keytar.setPassword(SERVICE, ACCOUNT, token);
+}
+
+/**
+ * Retrieve JWT token from OS keychain.
+ * Returns null if not found.
+ */
+export async function getToken() {
+  return await keytar.getPassword(SERVICE, ACCOUNT);
+}
+
+/**
+ * Delete JWT token from OS keychain.
+ */
+export async function deleteToken() {
+  await keytar.deletePassword(SERVICE, ACCOUNT);
+}
+
+/**
+ * Store user email in keychain.
+ */
+export async function storeUser(email) {
+  await keytar.setPassword(SERVICE, ACCOUNT_USER, email);
+}
+
+/**
+ * Retrieve stored user email.
+ */
+export async function getUser() {
+  return await keytar.getPassword(SERVICE, ACCOUNT_USER);
+}
+
+/**
+ * Delete stored user email.
+ */
+export async function deleteUser() {
+  await keytar.deletePassword(SERVICE, ACCOUNT_USER);
+}
+
+/**
+ * Decode a JWT and return its payload (without verification).
+ */
+export function decodeToken(token) {
+  try {
+    const payload = token.split('.')[1];
+    return JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if a JWT token is expired.
+ */
+export function isTokenExpired(token) {
+  const payload = decodeToken(token);
+  if (!payload || !payload.exp) return true;
+  return Date.now() >= payload.exp * 1000;
+}

package/lib/logo.js

@@ -0,0 +1,144 @@
+/**
+ * V Code — Retro ASCII Logo with animated blinking eyes.
+ */
+
+import chalk from 'chalk';
+
+const FRAMES_OPEN = [
+  `
+  ╔═══════════════════════════════════════════════════════╗
+  ║                                                       ║
+  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
+  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
+  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
+  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
+  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
+  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
+  ║                                                       ║
+  ║              ┌──────────────────────┐                  ║
+  ║              │    ◉            ◉    │                  ║
+  ║              │         ───         │                  ║
+  ║              └──────────────────────┘                  ║
+  ║                                                       ║
+  ╚═══════════════════════════════════════════════════════╝`,
+];
+
+const FRAMES_BLINK = [
+  `
+  ╔═══════════════════════════════════════════════════════╗
+  ║                                                       ║
+  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
+  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
+  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
+  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
+  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
+  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
+  ║                                                       ║
+  ║              ┌──────────────────────┐                  ║
+  ║              │    ━            ━    │                  ║
+  ║              │         ───         │                  ║
+  ║              └──────────────────────┘                  ║
+  ║                                                       ║
+  ╚═══════════════════════════════════════════════════════╝`,
+];
+
+const FRAMES_LOOK_LEFT = [
+  `
+  ╔═══════════════════════════════════════════════════════╗
+  ║                                                       ║
+  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
+  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
+  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
+  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
+  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
+  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
+  ║                                                       ║
+  ║              ┌──────────────────────┐                  ║
+  ║              │  ◉              ◉    │                  ║
+  ║              │         ───         │                  ║
+  ║              └──────────────────────┘                  ║
+  ║                                                       ║
+  ╚═══════════════════════════════════════════════════════╝`,
+];
+
+const FRAMES_LOOK_RIGHT = [
+  `
+  ╔═══════════════════════════════════════════════════════╗
+  ║                                                       ║
+  ║     ██╗   ██╗     ██████╗ ██████╗ ██████╗ ███████╗    ║
+  ║     ██║   ██║    ██╔════╝██╔═══██╗██╔══██╗██╔════╝    ║
+  ║     ██║   ██║    ██║     ██║   ██║██║  ██║█████╗      ║
+  ║     ╚██╗ ██╔╝    ██║     ██║   ██║██║  ██║██╔══╝      ║
+  ║      ╚████╔╝     ╚██████╗╚██████╔╝██████╔╝███████╗    ║
+  ║       ╚═══╝       ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝    ║
+  ║                                                       ║
+  ║              ┌──────────────────────┐                  ║
+  ║              │      ◉          ◉    │                  ║
+  ║              │         ───         │                  ║
+  ║              └──────────────────────┘                  ║
+  ║                                                       ║
+  ╚═══════════════════════════════════════════════════════╝`,
+];
+
+const allFrames = [FRAMES_OPEN, FRAMES_BLINK, FRAMES_LOOK_LEFT, FRAMES_LOOK_RIGHT];
+
+function colorize(frame) {
+  return frame
+    .replace(/[██╗╔╚╝║═╗╝╬╦╩╠╣█▀▄]/g, (m) => chalk.hex('#a855f7')(m))
+    .replace(/[◉]/g, () => chalk.hex('#22d3ee')('◉'))
+    .replace(/[━]/g, () => chalk.hex('#64748b')('━'))
+    .replace(/[┌┐└┘│─┘┐]/g, (m) => chalk.hex('#334155')(m))
+    .replace(/───/g, chalk.hex('#f97316')('───'));
+}
+
+/**
+ * Show static logo.
+ */
+export async function showLogo(animate = false) {
+  console.clear();
+  const frame = colorize(FRAMES_OPEN[0]);
+  console.log(frame);
+  console.log(chalk.gray('  ─────────────────────────────────────────────────────'));
+  console.log(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge'));
+  console.log(chalk.gray('  ─────────────────────────────────────────────────────\n'));
+}
+
+/**
+ * Animate logo with blinking eyes.  Returns a stop function.
+ */
+export function startLogoAnimation() {
+  let running = true;
+  const sequence = [
+    { frames: FRAMES_OPEN, duration: 2500 },
+    { frames: FRAMES_BLINK, duration: 150 },
+    { frames: FRAMES_OPEN, duration: 300 },
+    { frames: FRAMES_BLINK, duration: 150 },
+    { frames: FRAMES_OPEN, duration: 3000 },
+    { frames: FRAMES_LOOK_LEFT, duration: 800 },
+    { frames: FRAMES_OPEN, duration: 1500 },
+    { frames: FRAMES_LOOK_RIGHT, duration: 800 },
+    { frames: FRAMES_OPEN, duration: 2000 },
+  ];
+
+  let idx = 0;
+
+  const render = () => {
+    if (!running) return;
+    const step = sequence[idx % sequence.length];
+    // Move cursor to top and re-draw logo portion
+    process.stdout.write('\x1b[1;1H');
+    process.stdout.write(colorize(step.frames[0]));
+    idx++;
+    setTimeout(render, step.duration);
+  };
+
+  console.clear();
+  render();
+  // Print static footer below the logo area
+  process.stdout.write('\n');
+  process.stdout.write(chalk.gray('  ─────────────────────────────────────────────────────\n'));
+  process.stdout.write(chalk.hex('#a855f7').bold('               Vynthen V Code — Local Bridge\n'));
+  process.stdout.write(chalk.gray('  ─────────────────────────────────────────────────────\n'));
+
+  return () => { running = false; };
+}

package/lib/operations/browser.js

@@ -0,0 +1,51 @@
+/**
+ * V Code — Browser & File Manager Operations.
+ * Open URLs in the default browser & folders in the file manager.
+ */
+
+import { requestPermission } from '../permissions.js';
+
+let openModule;
+try {
+  openModule = (await import('open')).default;
+} catch {
+  // Not available
+}
+
+/**
+ * Open a URL in the default browser.
+ */
+export async function openUrlOp(url) {
+  const allowed = await requestPermission('OPEN_URL', url);
+  if (!allowed) return { success: false, error: 'Permission denied' };
+
+  if (!openModule) {
+    return { success: false, error: 'open module not available' };
+  }
+
+  try {
+    await openModule(url);
+    return { success: true, url };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Open a folder in the system file manager.
+ */
+export async function openFolderOp(folderPath) {
+  const allowed = await requestPermission('OPEN_FOLDER', folderPath);
+  if (!allowed) return { success: false, error: 'Permission denied' };
+
+  if (!openModule) {
+    return { success: false, error: 'open module not available' };
+  }
+
+  try {
+    await openModule(folderPath);
+    return { success: true, path: folderPath };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}

package/lib/operations/clipboard.js

@@ -0,0 +1,52 @@
+/**
+ * V Code — Clipboard Operations.
+ * Read and write system clipboard.
+ */
+
+import { requestPermission } from '../permissions.js';
+
+let clipboardy;
+try {
+  clipboardy = await import('clipboardy');
+} catch {
+  // Not available
+}
+
+/**
+ * Read clipboard contents.
+ */
+export async function clipboardReadOp() {
+  const allowed = await requestPermission('CLIPBOARD_READ', 'Read clipboard contents');
+  if (!allowed) return { success: false, error: 'Permission denied' };
+
+  if (!clipboardy) {
+    return { success: false, error: 'clipboardy not available' };
+  }
+
+  try {
+    const text = await clipboardy.default.read();
+    return { success: true, content: text };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}
+
+/**
+ * Write to clipboard.
+ */
+export async function clipboardWriteOp(text) {
+  const preview = text.length > 100 ? text.substring(0, 100) + '...' : text;
+  const allowed = await requestPermission('CLIPBOARD_WRITE', `Write to clipboard: "${preview}"`);
+  if (!allowed) return { success: false, error: 'Permission denied' };
+
+  if (!clipboardy) {
+    return { success: false, error: 'clipboardy not available' };
+  }
+
+  try {
+    await clipboardy.default.write(text);
+    return { success: true };
+  } catch (err) {
+    return { success: false, error: err.message };
+  }
+}