upfynai-code 2.9.0 → 2.9.2

package/dist/agents/index.js

@@ -1,88 +0,0 @@
-/**
- * Agent Registry
- * Central dispatch for all command actions.
- *
- * Usage:
- *   import { executeAction, isStreamingAction } from 'upfynai-shared/agents';
- *
- *   // Sync action (file-read, git-operation, etc.)
- *   const result = await executeAction('file-read', { filePath: '/foo' }, ctx);
- *   // result = { content: '...' }
- *
- *   // Streaming action (claude-query, codex-query, etc.)
- *   const result = await executeAction('claude-query', params, {
- *     ...ctx,
- *     stream: (data) => ws.send(JSON.stringify({ type: 'relay-stream', requestId, data })),
- *   });
- *   // result = { exitCode: 0, sessionId: '...' }
- */
-import claudeAgent from './claude.js';
-import codexAgent from './codex.js';
-import cursorAgent from './cursor.js';
-import shellAgent from './shell.js';
-import filesAgent from './files.js';
-import gitAgent from './git.js';
-import execAgent from './exec.js';
-import detectAgent from './detect.js';
-import gitagentAgent from './gitagent.js';
-
-const agents = [claudeAgent, codexAgent, cursorAgent, shellAgent, filesAgent, gitAgent, execAgent, detectAgent, gitagentAgent];
-
-/** Map of action name → handler function */
-const actionMap = new Map();
-
-/** Set of actions that use streaming (ctx.stream) instead of returning data */
-const streamingActions = new Set(['claude-query', 'claude-task-query', 'codex-query', 'cursor-query']);
-
-for (const agent of agents) {
-  for (const [action, handler] of Object.entries(agent.actions)) {
-    actionMap.set(action, handler);
-  }
-}
-
-/**
- * Execute an agent action.
- * @param {string} action - Action name (e.g., 'file-read', 'claude-query')
- * @param {object} params - Action parameters from the command payload
- * @param {object} ctx - Execution context:
- *   - stream(data): Send streaming chunk (required for streaming actions)
- *   - requestId: Current request ID
- *   - trackProcess(id, entry): Register process for abort support
- *   - untrackProcess(id): Remove process from tracking
- *   - getPersistentShell(cwd): Get persistent shell instance (CLI only)
- *   - resolveBinary(name): Resolve binary path (CLI only)
- *   - localBinDir: Path to local node_modules/.bin (CLI only)
- *   - streamMode: 'structured' | 'simple' (claude agent only)
- *   - log(msg): Logging function
- * @returns {Promise<object>} Action result
- */
-export async function executeAction(action, params, ctx = {}) {
-  const handler = actionMap.get(action);
-  if (!handler) throw new Error(`Unknown action: ${action}`);
-  return handler(params, ctx);
-}
-
-/**
- * Check if an action uses streaming.
- * Streaming actions require ctx.stream() and return { exitCode, ... } via Promise.
- * Non-streaming actions return { data } directly.
- */
-export function isStreamingAction(action) {
-  return streamingActions.has(action);
-}
-
-/**
- * Check if an action is registered.
- */
-export function hasAction(action) {
-  return actionMap.has(action);
-}
-
-/**
- * Get all registered action names.
- */
-export function getActionNames() {
-  return Array.from(actionMap.keys());
-}
-
-export { agents };

package/dist/agents/shell.js

@@ -1,38 +0,0 @@
-/**
- * Shell Agent
- * Handles: shell-command
- *
- * Two execution modes:
- * - Persistent shell (connect.js) — commands share one shell process
- * - Simple exec (relay-client.js) — each command spawns a new process
- *
- * The caller provides the execution strategy via ctx.execShell or falls back to execCommand.
- */
-import { execCommand, DANGEROUS_SHELL_PATTERNS } from './utils.js';
-
-export default {
-  name: 'shell',
-  actions: {
-    'shell-command': async (params, ctx) => {
-      const { command, cwd } = params;
-      if (!command || typeof command !== 'string') throw new Error('Invalid command');
-
-      // Block dangerous shell patterns
-      const cmdLower = command.toLowerCase();
-      if (DANGEROUS_SHELL_PATTERNS.some(d => cmdLower.includes(d.toLowerCase()))) {
-        throw new Error('Command blocked for safety');
-      }
-
-      // Use persistent shell if provided (connect.js), otherwise simple exec
-      if (ctx.getPersistentShell) {
-        const shell = ctx.getPersistentShell(cwd || process.cwd());
-        const result = await shell.exec(command, { timeoutMs: 60000 });
-        return { stdout: result.stdout, stderr: result.stderr, exitCode: result.exitCode, cwd: result.cwd };
-      }
-
-      // Simple exec fallback
-      const result = await execCommand(command, [], { cwd: cwd || process.cwd(), timeout: 60000 });
-      return { stdout: result };
-    },
-  },
-};

package/dist/agents/utils.js

@@ -1,136 +0,0 @@
-/**
- * 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/scripts/postinstall.js

@@ -1,9 +0,0 @@
-#!/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

@@ -1,58 +0,0 @@
-#!/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',
-  'gitagent.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}`);
-  }
-}
-
-// Copy gitagent module (parser + prompt-builder) — needed by gitagent agent
-const sharedGitagent = join(cliRoot, '..', 'shared', 'gitagent');
-const distGitagent = join(cliRoot, 'dist', 'gitagent');
-if (existsSync(distGitagent)) rmSync(distGitagent, { recursive: true });
-mkdirSync(distGitagent, { recursive: true });
-
-const gitagentFiles = ['index.js', 'parser.js', 'prompt-builder.js'];
-for (const file of gitagentFiles) {
-  const src = join(sharedGitagent, file);
-  const dest = join(distGitagent, file);
-  if (existsSync(src)) {
-    cpSync(src, dest);
-    copied++;
-  }
-}
-
-console.log(`  [prepublish] Copied ${copied} files to dist/`);

package/src/animation.js

@@ -1,228 +0,0 @@
-/**
- * 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');
-}

package/src/auth.js

@@ -1,122 +0,0 @@
-import prompts from 'prompts';
-import chalk from 'chalk';
-import { readConfig, writeConfig, clearConfig, displayUrl } from './config.js';
-
-async function apiCall(path, options = {}) {
-  const config = readConfig();
-  const url = `${config.serverUrl}${path}`;
-  const res = await fetch(url, {
-    ...options,
-    headers: {
-      'Content-Type': 'application/json',
-      ...(options.headers || {}),
-    },
-  });
-  return res;
-}
-
-export function getToken() {
-  const config = readConfig();
-  return config.token || null;
-}
-
-export async function validateToken() {
-  const token = getToken();
-  if (!token) return null;
-
-  try {
-    const res = await apiCall('/api/auth/user', {
-      headers: { Authorization: `Bearer ${token}` },
-    });
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data.user || null;
-  } catch {
-    return null;
-  }
-}
-
-export async function login(options = {}) {
-  // Allow --server flag to override the server URL
-  if (options.server) {
-    writeConfig({ serverUrl: options.server.replace(/\/+$/, '') });
-  }
-
-  console.log(chalk.bold('\n  Upfyn Code — Login\n'));
-
-  const response = await prompts([
-    {
-      type: 'text',
-      name: 'username',
-      message: 'Username',
-      validate: v => (v.trim() ? true : 'Username is required'),
-    },
-    {
-      type: 'password',
-      name: 'password',
-      message: 'Password',
-      validate: v => (v ? true : 'Password is required'),
-    },
-  ], {
-    onCancel: () => {
-      console.log(chalk.dim('\n  Login cancelled.\n'));
-      process.exit(0);
-    },
-  });
-
-  const { username, password } = response;
-
-  try {
-    const res = await apiCall('/api/auth/login', {
-      method: 'POST',
-      body: JSON.stringify({ username: username.trim(), password }),
-    });
-
-    const data = await res.json();
-
-    if (!res.ok) {
-      console.log(chalk.red(`\n  Login failed: ${data.error || 'Unknown error'}\n`));
-      process.exit(1);
-    }
-
-    writeConfig({
-      token: data.token,
-      user: data.user,
-    });
-
-    const name = data.user.first_name || data.user.username;
-    console.log(chalk.green(`\n  Logged in as ${chalk.bold(name)}!\n`));
-  } catch (err) {
-    const config = readConfig();
-    console.log(chalk.red(`\n  Connection error. Could not reach ${displayUrl(config.serverUrl)}.`));
-    console.log(chalk.dim('  Check your network and try again.\n'));
-    process.exit(1);
-  }
-}
-
-export async function logout() {
-  clearConfig();
-  console.log(chalk.green('\n  Logged out. Credentials cleared.\n'));
-}
-
-export async function status() {
-  const config = readConfig();
-
-  if (!config.token) {
-    console.log(chalk.yellow('\n  Not logged in. Run `uc login` to authenticate.\n'));
-    return;
-  }
-
-  console.log(chalk.dim('\n  Checking session...'));
-  const user = await validateToken();
-
-  if (!user) {
-    console.log(chalk.yellow('  Session expired. Run `uc login` to re-authenticate.\n'));
-    return;
-  }
-
-  const name = user.first_name || user.username;
-  console.log(chalk.bold(`  Logged in as: ${chalk.cyan(name)} (${chalk.dim(user.username)})`));
-  console.log(chalk.dim(`  Server:       ${displayUrl(config.serverUrl)}`));
-  console.log(chalk.dim(`  Local port:   ${config.localPort}\n`));
-}