upfynai-code 2.7.5 → 2.8.1

package/dist/agents/utils.js

@@ -0,0 +1,136 @@
+/**
+ * Shared utilities for agent command handlers.
+ * Used by both CLI relay clients and backend server.
+ */
+import { spawn } from 'child_process';
+import { promises as fsPromises } from 'fs';
+import os from 'os';
+import path from 'path';
+
+/**
+ * Execute a shell command and return stdout.
+ * @param {string} cmd - Command to run
+ * @param {string[]} args - Command arguments
+ * @param {object} options - { cwd, env, timeout }
+ * @returns {Promise<string>} stdout
+ */
+export 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 (recursive).
+ * @param {string} dirPath - Directory to scan
+ * @param {number} maxDepth - Maximum recursion depth
+ * @param {number} currentDepth - Current depth (internal)
+ * @param {object} options - { maxEntries, includeStats, skipDotfilesAtRoot }
+ * @returns {Promise<Array>} File tree items
+ */
+export async function buildFileTree(dirPath, maxDepth, currentDepth = 0, options = {}) {
+  const { maxEntries = 200, includeStats = false, skipDotfilesAtRoot = false } = options;
+  if (currentDepth >= maxDepth) return [];
+
+  const SKIP_DIRS = new Set(['node_modules', '.git', 'dist', 'build', '.svn', '.hg']);
+
+  try {
+    const entries = await fsPromises.readdir(dirPath, { withFileTypes: true });
+    const items = [];
+    for (const entry of entries.slice(0, maxEntries)) {
+      if (SKIP_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith('.') && skipDotfilesAtRoot && currentDepth === 0) continue;
+
+      const itemPath = path.join(dirPath, entry.name);
+      const item = {
+        name: entry.name,
+        path: itemPath,
+        type: entry.isDirectory() ? 'directory' : 'file',
+      };
+
+      if (includeStats) {
+        try {
+          const stats = await fsPromises.stat(itemPath);
+          item.size = stats.size;
+          item.modified = stats.mtime.toISOString();
+        } catch { /* ignore stat errors */ }
+      }
+
+      if (entry.isDirectory() && currentDepth < maxDepth - 1) {
+        item.children = await buildFileTree(itemPath, maxDepth, currentDepth + 1, options);
+      }
+      items.push(item);
+    }
+    return items;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Resolve a path that may start with ~ to an absolute path.
+ * @param {string} inputPath - Path to resolve
+ * @returns {string} Resolved absolute path
+ */
+export function resolveTildePath(inputPath) {
+  if (!inputPath) return os.homedir();
+  if (inputPath === '~') return os.homedir();
+  if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
+    return path.join(os.homedir(), inputPath.slice(2));
+  }
+  return path.resolve(inputPath);
+}
+
+/** Blocked paths for file reads (security) */
+export const BLOCKED_READ_PATTERNS = ['/etc/shadow', '/etc/passwd', '.ssh/id_rsa', '.ssh/id_ed25519', '/.env'];
+
+/** Blocked paths for file writes (security) */
+export const BLOCKED_WRITE_PATTERNS = [
+  '/etc/', '/usr/bin/', '/usr/sbin/',
+  '/windows/system32', '/windows/syswow64', '/program files',
+  '.ssh/', '/.env',
+];
+
+/** Dangerous shell patterns to block */
+export const DANGEROUS_SHELL_PATTERNS = [
+  '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',
+];
+
+/**
+ * Check if a normalized path matches any blocked patterns.
+ * @param {string} normalizedPath - Absolute path (resolved)
+ * @param {string[]} patterns - Blocked patterns to check
+ * @returns {boolean}
+ */
+export function isBlockedPath(normalizedPath, patterns) {
+  const lower = normalizedPath.toLowerCase().replace(/\\/g, '/');
+  return patterns.some(b => lower.includes(b));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "upfynai-code",
-  "version": "2.7.5",
+  "version": "2.8.1",
   "description": "Unified AI coding interface — access AI chat, terminal, file explorer, git, and visual canvas from any browser. Connect your local machine and code from anywhere.",
   "type": "module",
   "bin": {
@@ -11,11 +11,14 @@
     "bin/",
     "src/",
     "dist/",
+    "scripts/",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "start": "node bin/cli.js"
+    "start": "node bin/cli.js",
+    "postinstall": "node scripts/postinstall.js",
+    "prepublishOnly": "node scripts/prepublish.js"
   },
   "keywords": [
     "upfyn",

package/scripts/postinstall.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { playInstallAnimation } from '../src/animation.js';
+
+try {
+  await playInstallAnimation();
+} catch {
+  // Silently fail — animation is cosmetic, don't break installs
+  console.log('\n  ✓ upfynai-code installed. Run `uc --help` to get started.\n');
+}

package/scripts/prepublish.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+/**
+ * Prepublish script — copies shared agents into dist/ for npm distribution.
+ *
+ * In the monorepo, connect.js imports from ../../shared/agents/.
+ * For npm, we copy those files into dist/agents/ and connect.js
+ * resolves them at runtime.
+ */
+import { cpSync, mkdirSync, rmSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const cliRoot = join(__dirname, '..');
+const distAgents = join(cliRoot, 'dist', 'agents');
+const sharedAgents = join(cliRoot, '..', 'shared', 'agents');
+
+// Clean
+if (existsSync(distAgents)) rmSync(distAgents, { recursive: true });
+mkdirSync(distAgents, { recursive: true });
+
+// Copy all agent files
+const files = [
+  'index.js', 'utils.js',
+  'claude.js', 'codex.js', 'cursor.js',
+  'shell.js', 'files.js', 'git.js', 'exec.js', 'detect.js',
+];
+
+let copied = 0;
+for (const file of files) {
+  const src = join(sharedAgents, file);
+  const dest = join(distAgents, file);
+  if (existsSync(src)) {
+    cpSync(src, dest);
+    copied++;
+  } else {
+    console.warn(`  [WARN] Missing: ${file}`);
+  }
+}
+
+console.log(`  [prepublish] Copied ${copied} agent files to dist/agents/`);

package/src/animation.js

@@ -0,0 +1,228 @@
+/**
+ * CLI spaceship-to-star animation for Upfyn-Code.
+ * Plays after install (postinstall) and before `uc connect` starts.
+ */
+
+const STAR_FRAMES = ['✦', '✧', '✦', '★'];
+
+// Spaceship frames (4 animation states)
+const SHIP = [
+  '  ╱▏▔▔╲   ',
+  ' ╱ ▏══ ╲  ',
+  '╱  ▏▁▁  ╲ ',
+  '  ╱▏▔▔╲   ',
+];
+
+// Simpler inline ship for the travel animation
+const SHIP_R = [
+  '     ▄▄     ',
+  '  ◁━━██━━▷  ',
+  '     ▀▀     ',
+];
+
+const SHIP_SMALL = '◁━━▶';
+const SHIP_TRAVEL = '⟫⟫';
+const EXHAUST_CHARS = ['░', '▒', '▓', '═', '~', '·'];
+
+function sleep(ms) {
+  return new Promise(r => setTimeout(r, ms));
+}
+
+function clearLines(n) {
+  for (let i = 0; i < n; i++) {
+    process.stdout.write('\x1b[1A\x1b[2K');
+  }
+}
+
+function dim(s) { return `\x1b[2m${s}\x1b[0m`; }
+function cyan(s) { return `\x1b[36m${s}\x1b[0m`; }
+function yellow(s) { return `\x1b[33m${s}\x1b[0m`; }
+function bold(s) { return `\x1b[1m${s}\x1b[0m`; }
+function magenta(s) { return `\x1b[35m${s}\x1b[0m`; }
+function white(s) { return `\x1b[97m${s}\x1b[0m`; }
+function green(s) { return `\x1b[32m${s}\x1b[0m`; }
+function blue(s) { return `\x1b[34m${s}\x1b[0m`; }
+
+/**
+ * Generate a star field background line
+ */
+function starFieldLine(width, density = 0.08, frame = 0) {
+  let line = '';
+  for (let i = 0; i < width; i++) {
+    if (Math.random() < density) {
+      const stars = ['.', '·', '∘', '°', '✧'];
+      const s = stars[Math.floor(Math.random() * stars.length)];
+      line += dim(s);
+    } else {
+      line += ' ';
+    }
+  }
+  return line;
+}
+
+/**
+ * Main spaceship-to-star animation
+ * @param {'install'|'connect'} mode
+ */
+export async function playSpaceshipAnimation(mode = 'connect') {
+  const cols = Math.min(process.stdout.columns || 70, 80);
+  const totalFrames = 28;
+  const LINES = 11; // total lines we'll use
+
+  const starX = cols - 6;
+
+  // Phase 1: Launch sequence text
+  const tagline = mode === 'install'
+    ? 'Installation complete!'
+    : 'Launching relay bridge...';
+
+  console.log('');
+  console.log(dim('  ─'.repeat(Math.floor(cols / 3))));
+  console.log('');
+
+  // Phase 2: Spaceship travels across the screen toward a star
+  for (let frame = 0; frame < totalFrames; frame++) {
+    const progress = frame / (totalFrames - 1); // 0 → 1
+    const shipX = Math.floor(progress * (cols - 16)) + 2;
+
+    // Build exhaust trail
+    const exhaustLen = Math.min(shipX, Math.floor(progress * 20));
+    let exhaust = '';
+    for (let e = 0; e < exhaustLen; e++) {
+      const intensity = 1 - (e / exhaustLen);
+      if (intensity > 0.7) exhaust = '▓' + exhaust;
+      else if (intensity > 0.4) exhaust = '▒' + exhaust;
+      else if (intensity > 0.2) exhaust = '░' + exhaust;
+      else exhaust = '·' + exhaust;
+    }
+
+    // Star pulse
+    const starChar = STAR_FRAMES[frame % STAR_FRAMES.length];
+    const starGlow = progress > 0.7 ? yellow('✦ ') : '';
+
+    // Build the 5 display lines
+    const lines = [];
+
+    // Line 1: starfield
+    lines.push('  ' + starFieldLine(cols - 4, 0.05, frame));
+
+    // Line 2: top space
+    lines.push('  ' + starFieldLine(cols - 4, 0.03, frame));
+
+    // Line 3: ship row (main action)
+    let shipRow = '';
+    const beforeShip = Math.max(0, shipX - exhaustLen);
+    shipRow += ' '.repeat(beforeShip);
+    shipRow += dim(exhaust);
+    shipRow += cyan('  ◁━━▶');
+    // Fill to star position
+    const afterShip = Math.max(0, starX - shipX - 7);
+    // Dots between ship and star
+    let midSpace = '';
+    for (let d = 0; d < afterShip; d++) {
+      midSpace += Math.random() < 0.06 ? dim('·') : ' ';
+    }
+    shipRow += midSpace;
+    if (progress < 0.92) {
+      shipRow += starGlow + yellow(starChar);
+    } else {
+      shipRow += yellow('✦★✦');
+    }
+    lines.push(shipRow);
+
+    // Line 4: thrust glow
+    let thrustRow = ' '.repeat(Math.max(0, shipX + 1));
+    if (frame % 2 === 0) {
+      thrustRow += dim(magenta('~≈~'));
+    } else {
+      thrustRow += dim(magenta('≈~≈'));
+    }
+    lines.push(thrustRow);
+
+    // Line 5: starfield
+    lines.push('  ' + starFieldLine(cols - 4, 0.04, frame));
+
+    // Line 6: message (centered)
+    const msg = progress < 0.3
+      ? dim(`  ${tagline}`)
+      : progress < 0.6
+        ? cyan(`  ⟫ Navigating to the stars...`)
+        : progress < 0.9
+          ? magenta(`  ⟫⟫ Almost there...`)
+          : green(`  ★ ${mode === 'install' ? 'Ready for launch!' : 'Connection established!'}`);
+    lines.push(msg);
+
+    // Line 7: progress bar
+    const barWidth = cols - 10;
+    const filled = Math.floor(progress * barWidth);
+    const bar = '  ' + dim('[')
+      + cyan('█'.repeat(filled))
+      + dim('░'.repeat(barWidth - filled))
+      + dim(']')
+      + dim(` ${Math.floor(progress * 100)}%`);
+    lines.push(bar);
+
+    // Print
+    if (frame > 0) clearLines(lines.length);
+    for (const l of lines) console.log(l);
+
+    // Speed: start slow, middle fast, end slow
+    const delay = progress < 0.2 ? 120
+      : progress > 0.85 ? 150
+      : 60;
+    await sleep(delay);
+  }
+
+  // Phase 3: Final flash
+  await sleep(200);
+  clearLines(7);
+
+  // Arrival burst
+  const burstLines = [];
+  burstLines.push('  ' + starFieldLine(cols - 4, 0.06));
+  burstLines.push('');
+  burstLines.push(
+    ' '.repeat(Math.floor(cols / 2 - 12))
+    + yellow('· ✧ · ★ ')
+    + bold(white('UPFYN'))
+    + yellow(' ★ · ✧ ·')
+  );
+  burstLines.push('');
+
+  if (mode === 'install') {
+    burstLines.push(
+      ' '.repeat(Math.floor(cols / 2 - 20))
+      + green('✓ ') + bold('upfynai-code') + dim(' installed successfully')
+    );
+    burstLines.push('');
+    burstLines.push(dim('  Quick start:'));
+    burstLines.push(cyan('    uc login       ') + dim('— authenticate'));
+    burstLines.push(cyan('    uc connect     ') + dim('— bridge to cloud'));
+    burstLines.push(cyan('    uc --local     ') + dim('— start local server'));
+  } else {
+    burstLines.push(
+      ' '.repeat(Math.floor(cols / 2 - 16))
+      + green('✓ ') + bold('Relay bridge activated')
+    );
+  }
+
+  burstLines.push('');
+  burstLines.push(dim('  ─'.repeat(Math.floor(cols / 3))));
+  burstLines.push('');
+
+  for (const l of burstLines) console.log(l);
+}
+
+/**
+ * Postinstall animation (shorter variant)
+ */
+export async function playInstallAnimation() {
+  return playSpaceshipAnimation('install');
+}
+
+/**
+ * Connect animation
+ */
+export async function playConnectAnimation() {
+  return playSpaceshipAnimation('connect');
+}