vynthen-vcode 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vynthen-vcode",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Vynthen AI Local Code Agent CLI",
   "main": "vcode.js",
   "bin": {

package/vcode.js

@@ -1,75 +1,136 @@
 #!/usr/bin/env node
 
-/**
- * V Code CLI — Local Bridge for Vynthen AI
- * 
- * This CLI connects your local file system to V Code.
- * When running, V Code can read, edit, and create files on your machine.
- */
-
 const { WebSocket } = require('ws');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
 const { execSync } = require('child_process');
 
-const VYNTHEN_BASE_URL = process.env.VYNTHEN_API_URL || 'http://localhost:3000';
-const VYNTHEN_WS_URL = process.env.VYNTHEN_WS_URL || 'ws://localhost:3000/api/cli-bridge';
+const VYNTHEN_BASE_URL = process.env.VYNTHEN_API_URL || 'https://vynthen.ai';
+const VYNTHEN_WS_URL = process.env.VYNTHEN_WS_URL || 'wss://vynthen.ai/api/cli-bridge';
 const TOKEN_PATH = path.join(os.homedir(), '.vcode_token');
 
+// ── ANSI Colors ───────────────────────────────────────────────────────────
+const C = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[38;2;60;210;255m',
+  violet: '\x1b[38;2;167;139;250m',
+  orange: '\x1b[38;2;251;146;60m',
+  green: '\x1b[38;2;52;211;153m',
+  red: '\x1b[38;2;248;113;113m'
+};
+
+const ANIMATION_FRAMES = [
+  [`╔══════════╗`, `║    /   \\ ║`, `║   / ◠◠ \\ ║`, `║  / ●  ● \\║`, `║ △──────△ ║`, `╚══════════╝`],
+  [`╔══════════╗`, `║    /   \\ ║`, `║   / ◠◠ \\ ║`, `║  / ⊙  ⊙ \\║`, `║ △──────△ ║`, `╚══════════╝`],
+  [`╔══════════╗`, `║    /   \\ ║`, `║   / ◠◠ \\ ║`, `║  / -  - \\║`, `║ △──────△ ║`, `╚══════════╝`]
+];
+
+function drawAvatar(frameIdx, text = '') {
+  const f = ANIMATION_FRAMES[frameIdx % ANIMATION_FRAMES.length];
+  console.clear();
+  console.log(`\n${C.violet}${C.bold}   V CODE COMPANION${C.reset}`);
+  console.log(`${C.cyan}${f[0]}`);
+  console.log(`${f[1]}`);
+  console.log(`${f[2]}    ${C.orange}${text}${C.cyan}`);
+  console.log(`${f[3]}`);
+  console.log(`${f[4]}`);
+  console.log(`${f[5]}${C.reset}\n`);
+}
+
+async function playIntro(text) {
+  return new Promise(resolve => {
+    let tick = 0;
+    const interval = setInterval(() => {
+      drawAvatar(tick, text);
+      tick++;
+      if (tick > 5) {
+        clearInterval(interval);
+        resolve();
+      }
+    }, 200);
+  });
+}
+
 // ── Login Command ────────────────────────────────────────────────────────
 if (process.argv[2] === 'login') {
   const readline = require('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const askEmail = () => new Promise(r => {
+    console.log(`${C.cyan}?${C.reset} ${C.bold}Email:${C.reset}`);
+    rl.question('  > ', ans => r(ans));
   });
 
-  rl.question('Email: ', (email) => {
-    // Simple prompt for password, masking with *
-    const rlPass = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
+  const askPass = () => new Promise(r => {
+    console.log(`\n${C.cyan}?${C.reset} ${C.bold}Password:${C.reset} ${C.dim}(Invisible securely)${C.reset}`);
+    process.stdout.write('  > ');
+    let password = '';
     
-    rlPass.stdoutMuted = true;
-    rlPass._writeToOutput = function _writeToOutput(stringToWrite) {
-      if (rlPass.stdoutMuted) {
-        rlPass.output.write(stringToWrite === '\\r\\n' || stringToWrite === '\\n' ? '\\n' : '*');
-      } else {
-        rlPass.output.write(stringToWrite);
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+    
+    const listener = (chunk) => {
+      chunk = String(chunk);
+      switch (chunk) {
+        case '\n':
+        case '\r':
+        case '\u0004':
+          process.stdin.removeListener('data', listener);
+          process.stdin.setRawMode(false);
+          process.stdin.pause();
+          console.log('');
+          r(password);
+          break;
+        case '\u0003': // Ctrl+C
+          process.exit();
+          break;
+        case '\x7f':
+        case '\b':
+          password = password.slice(0, -1);
+          break;
+        default:
+          password += chunk;
+          break;
       }
     };
+    process.stdin.on('data', listener);
+  });
 
-    rlPass.question('Password: ', async (password) => {
-      rlPass.close();
-      rl.close();
-      console.log('\\nLogging in...');
-
-      try {
-        const fetch = globalThis.fetch || require('node-fetch');
-        const res = await fetch(`${VYNTHEN_BASE_URL}/api/auth/cli-login`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({ email: email.trim(), password })
-        });
-        
-        if (!res.ok) {
-          const err = await res.json().catch(()=>({}));
-          console.error('\\x1b[31m%s\\x1b[0m', `Login failed: ${err.error || res.statusText}`);
-          process.exit(1);
-        }
+  (async () => {
+    await playIntro("Initializing Secure Link...");
+    const email = await askEmail();
+    const password = await askPass();
+    rl.close();
 
-        const data = await res.json();
-        fs.writeFileSync(TOKEN_PATH, data.token, { mode: 0o600 });
-        console.log('\\x1b[32m%s\\x1b[0m', '✓ Successfully logged in. Token saved locally.');
-        process.exit(0);
-      } catch (err) {
-        console.error('\\x1b[31m%s\\x1b[0m', `Connection error: ${err.message}`);
+    console.log(`${C.violet}\n⟳ Authenticating with Vynthen...${C.reset}`);
+
+    try {
+      const fetch = globalThis.fetch || require('node-fetch');
+      const res = await fetch(`${VYNTHEN_BASE_URL}/api/auth/cli-login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ email: email.trim(), password })
+      });
+      
+      if (!res.ok) {
+        const err = await res.json().catch(()=>({}));
+        console.error(`\n${C.red}✖ Login failed:${C.reset} ${err.error || res.statusText}`);
         process.exit(1);
       }
-    });
-  });
+
+      const data = await res.json();
+      fs.writeFileSync(TOKEN_PATH, data.token, { mode: 0o600 });
+      console.log(`\n${C.green}✔ Successfully logged in. Secure Token saved.${C.reset}`);
+      process.exit(0);
+    } catch (err) {
+      console.error(`\n${C.red}✖ Connection error:${C.reset} ${err.message}`);
+      process.exit(1);
+    }
+  })();
   return;
 }
 
@@ -79,136 +140,133 @@ let token = process.env.VYNTHEN_CLI_TOKEN;
 if (!token) {
   try {
     token = fs.readFileSync(TOKEN_PATH, 'utf8').trim();
-  } catch (err) {
-    // file not found or unreadable
-  }
+  } catch (err) {}
 }
 
 if (!token && !process.argv.includes('--anonymous')) {
-  console.error('\\x1b[31m%s\\x1b[0m', 'Error: Not logged in.');
-  console.log('Run `vcode login` or export VYNTHEN_CLI_TOKEN.');
+  console.error(`${C.red}✖ Error: Not logged in.${C.reset}`);
+  console.log(`Run \`${C.cyan}Vcode login${C.reset}\` or export VYNTHEN_CLI_TOKEN.`);
   process.exit(1);
 }
 
-console.log('\\x1b[36m%s\\x1b[0m', 'Initializing V Code CLI Bridge...');
-const ws = new WebSocket(`${VYNTHEN_WS_URL}?token=${token || 'anonymous'}`);
+(async () => {
+  if (process.argv[2] !== '--silent') {
+    await playIntro("Awaiting AI Orders...");
+  }
+  console.log(`${C.violet}≈ Establishing secure bridge to Vynthen...${C.reset}`);
+  const ws = new WebSocket(`${VYNTHEN_WS_URL}?token=${token || 'anonymous'}`);
 
-// ── Handlers ─────────────────────────────────────────────────────────────
+  // ── Handlers ───────────────────────────────────────────────
+  const handleFileRead = (filepath) => {
+    try {
+      const absolutePath = path.resolve(process.cwd(), filepath);
+      const content = fs.readFileSync(absolutePath, 'utf8');
+      return { success: true, content };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  };
 
-const handleFileRead = (filepath) => {
-  try {
-    const absolutePath = path.resolve(process.cwd(), filepath);
-    const content = fs.readFileSync(absolutePath, 'utf8');
-    return { success: true, content };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-};
+  const handleFileWrite = (filepath, content) => {
+    try {
+      const absolutePath = path.resolve(process.cwd(), filepath);
+      fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
+      fs.writeFileSync(absolutePath, content, 'utf8');
+      return { success: true };
+    } catch (err) {
+      return { success: false, error: err.message };
+    }
+  };
 
-const handleFileWrite = (filepath, content) => {
-  try {
-    const absolutePath = path.resolve(process.cwd(), filepath);
-    fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-    fs.writeFileSync(absolutePath, content, 'utf8');
-    return { success: true };
-  } catch (err) {
-    return { success: false, error: err.message };
-  }
-};
+  const handleCommand = (command) => {
+    try {
+      const output = execSync(command, { encoding: 'utf8', cwd: process.cwd(), timeout: 10000 });
+      return { success: true, output };
+    } catch (err) {
+      return { success: false, error: err.message, output: err.stdout ? err.stdout.toString() : '' };
+    }
+  };
 
-const handleCommand = (command) => {
-  try {
-    const output = execSync(command, { encoding: 'utf8', cwd: process.cwd(), timeout: 10000 });
-    return { success: true, output };
-  } catch (err) {
-    return { success: false, error: err.message, output: err.stdout ? err.stdout.toString() : '' };
-  }
-};
+  ws.on('open', () => {
+    console.log(`${C.green}✔ Connected to V Code AI.${C.reset}`);
+    console.log(`${C.dim}Listening in: ${process.cwd()}${C.reset}`);
+    
+    ws.send(JSON.stringify({
+      type: 'init',
+      hostname: os.hostname(),
+      cwd: process.cwd()
+    }));
+  });
 
-// ── WebSocket Logic ──────────────────────────────────────────────────────
-
-ws.on('open', () => {
-  console.log('\x1b[32m%s\x1b[0m', '✓ Connected to V Code.');
-  console.log(`Listening in: ${process.cwd()}`);
-  
-  ws.send(JSON.stringify({
-    type: 'init',
-    hostname: require('os').hostname(),
-    cwd: process.cwd()
-  }));
-});
-
-const readline = require('readline');
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-const askApproval = (question) => {
-  return new Promise(resolve => {
-    rl.question(`\x1b[33m[Authorization Required]\x1b[0m ${question} (y/N): `, answer => {
-      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+  const readline = require('readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  const askApproval = (question) => {
+    return new Promise(resolve => {
+      rl.question(`\n${C.orange}[Authorization]${C.reset} ${question} (y/N): `, answer => {
+        resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+      });
     });
-  });
-};
+  };
 
-ws.on('message', async (data) => {
-  const req = JSON.parse(data);
-  let response = { id: req.id, type: req.type };
-
-  switch (req.type) {
-    case 'read_file':
-      console.log(`\x1b[34m[Agent]\x1b[0m Reading ${req.filepath}`);
-      response.result = handleFileRead(req.filepath);
-      break;
-
-    case 'write_file':
-      console.log(`\n\x1b[34m[Agent Request]\x1b[0m Write to \x1b[36m${req.filepath}\x1b[0m (${req.content.length} bytes)`);
-      const writeApproved = await askApproval(`Allow Agent to modify ${req.filepath}?`);
-      if (writeApproved) {
-        response.result = handleFileWrite(req.filepath, req.content);
-        console.log('\x1b[32m✓ Allowed\x1b[0m');
-      } else {
-        response.result = { success: false, error: 'User denied file write permission.' };
-        console.log('\x1b[31m✕ Denied\x1b[0m');
-      }
-      break;
-
-    case 'run_command':
-      console.log(`\n\x1b[34m[Agent Request]\x1b[0m Execute command: \x1b[36m${req.command}\x1b[0m`);
-      const cmdApproved = await askApproval(`Allow Agent to run this command?`);
-      if (cmdApproved) {
-        response.result = handleCommand(req.command);
-        console.log('\x1b[32m✓ Allowed\x1b[0m');
-      } else {
-        response.result = { success: false, error: 'User denied command execution permission.' };
-        console.log('\x1b[31m✕ Denied\x1b[0m');
-      }
-      break;
+  ws.on('message', async (data) => {
+    const req = JSON.parse(data);
+    let response = { id: req.id, type: req.type };
 
-    case 'ping':
-      response.result = { success: true };
-      break;
+    switch (req.type) {
+      case 'read_file':
+        console.log(`${C.cyan}[Agent]${C.reset} Reading ${req.filepath}`);
+        response.result = handleFileRead(req.filepath);
+        break;
 
-    default:
-      console.error('\x1b[31m%s\x1b[0m', `Unknown command type: ${req.type}`);
-      response.result = { success: false, error: 'Unknown command type' };
-  }
+      case 'write_file':
+        console.log(`\n${C.violet}[Agent]${C.reset} Write to ${C.bold}${req.filepath}${C.reset} (${req.content.length} bytes)`);
+        const writeApproved = await askApproval(`Allow Agent to modify ${req.filepath}?`);
+        if (writeApproved) {
+          response.result = handleFileWrite(req.filepath, req.content);
+          console.log(`${C.green}✔ Allowed${C.reset}`);
+        } else {
+          response.result = { success: false, error: 'User denied permission.' };
+          console.log(`${C.red}✖ Denied${C.reset}`);
+        }
+        break;
+
+      case 'run_command':
+        console.log(`\n${C.violet}[Agent]${C.reset} Execute command: ${C.bold}${req.command}${C.reset}`);
+        const cmdApproved = await askApproval(`Allow Agent to run this command?`);
+        if (cmdApproved) {
+          response.result = handleCommand(req.command);
+          console.log(`${C.green}✔ Allowed${C.reset}`);
+        } else {
+          response.result = { success: false, error: 'User denied permission.' };
+          console.log(`${C.red}✖ Denied${C.reset}`);
+        }
+        break;
 
-  ws.send(JSON.stringify(response));
-});
+      case 'ping':
+        response.result = { success: true };
+        break;
 
-ws.on('close', () => {
-  console.log('\x1b[33m%s\x1b[0m', 'Connection closed. V Code CLI is exiting.');
-  process.exit(0);
-});
+      default:
+        console.error(`${C.red}Unknown command type: ${req.type}${C.reset}`);
+        response.result = { success: false, error: 'Unknown command type' };
+    }
 
-ws.on('error', (err) => {
-  console.error('\x1b[31m%s\x1b[0m', `WebSocket Error: ${err.message}`);
-});
+    ws.send(JSON.stringify(response));
+  });
+
+  ws.on('close', () => {
+    console.log(`${C.orange}\nConnection closed.${C.reset} V Code exiting.`);
+    process.exit(0);
+  });
 
-process.on('SIGINT', () => {
-  console.log('\nGracefully shutting down...');
-  ws.close();
-  process.exit(0);
-});
+  ws.on('error', (err) => {
+    console.error(`${C.red}WebSocket Error:${C.reset} ${err.message}`);
+  });
+
+  process.on('SIGINT', () => {
+    console.log(`\n${C.dim}Gracefully shutting down...${C.reset}`);
+    ws.close();
+    process.exit(0);
+  });
+})();