upfynai-code 2.9.0 → 2.9.2

package/bin/cli.js

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { readFileSync } from 'fs';
-import { dirname, join } from 'path';
-import { fileURLToPath } from 'url';
-import { login, logout, status } from '../src/auth.js';
-import { openHosted, startLocal } from '../src/launch.js';
-import { connect } from '../src/connect.js';
-import { mcp } from '../src/mcp.js';
-import { readConfig, writeConfig, clearConfig, DEFAULTS, displayUrl } from '../src/config.js';
-import chalk from 'chalk';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const pkg = JSON.parse(readFileSync(join(__dirname, '..', 'package.json'), 'utf8'));
-
-const program = new Command();
-
-program
-  .name('upfynai-code')
-  .description('Launch Upfyn AI coding environment from your terminal')
-  .version(pkg.version)
-  .option('--local', 'Start a local server instead of opening the hosted app')
-  .action(async (options) => {
-    if (options.local) {
-      await startLocal();
-    } else {
-      await openHosted();
-    }
-  });
-
-program
-  .command('login')
-  .description('Authenticate with your Upfyn account')
-  .option('--server <url>', 'Server URL to authenticate against')
-  .action(async (options) => {
-    await login(options);
-  });
-
-program
-  .command('logout')
-  .description('Clear saved credentials')
-  .action(async () => {
-    await logout();
-  });
-
-program
-  .command('status')
-  .description('Show current auth status and config')
-  .action(async () => {
-    await status();
-  });
-
-program
-  .command('connect')
-  .description('Connect local machine to the remote server (bridges Claude Code, shell, files, git)')
-  .option('--server <url>', 'Server URL to connect to')
-  .option('--key <token>', 'Connection token — get from Settings > Keys & Connect')
-  .action(async (options) => {
-    await connect(options);
-  });
-
-program
-  .command('mcp')
-  .description('Show MCP integration config for Claude / Cursor')
-  .option('--server <url>', 'Server URL')
-  .option('--key <token>', 'Relay token')
-  .action(async (options) => {
-    await mcp(options);
-  });
-
-program
-  .command('config')
-  .description('View or update CLI configuration')
-  .option('--server <url>', 'Set the server URL')
-  .option('--reset', 'Reset config to defaults')
-  .action((options) => {
-    if (options.reset) {
-      clearConfig();
-      console.log(chalk.green('\n  Config reset to defaults.\n'));
-      return;
-    }
-    if (options.server) {
-      const cleaned = options.server.replace(/\/+$/, '');
-      writeConfig({ serverUrl: cleaned });
-      console.log(chalk.green(`\n  Server set to: ${displayUrl(cleaned)}\n`));
-      return;
-    }
-    // Show current config
-    const config = readConfig();
-    console.log(chalk.bold('\n  Upfyn Code — Config\n'));
-    console.log(`  Server:     ${chalk.cyan(displayUrl(config.serverUrl))}`);
-    console.log(`  Local port: ${chalk.cyan(config.localPort)}`);
-    console.log(`  Logged in:  ${config.token ? chalk.green('Yes') : chalk.yellow('No')}\n`);
-  });
-
-program.parse();

package/dist/agents/claude.js

@@ -1,229 +0,0 @@
-/**
- * Claude Agent
- * Handles: claude-query, claude-task-query
- *
- * These are STREAMING actions — they use ctx.stream() to send chunks
- * and return a Promise that resolves when the process completes.
- *
- * Three modes:
- * - sdk (connect.js default) — full SDK streaming with rich messages (tool_use, text, result)
- * - simple --print (relay-client.js) — basic stdout streaming
- *
- * The caller chooses the mode via ctx.streamMode ('structured' | 'simple').
- * 'structured' now maps to SDK mode for rich message forwarding.
- */
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { spawn } from 'child_process';
-import os from 'os';
-
-export default {
-  name: 'claude',
-  actions: {
-    'claude-query': async (params, ctx) => {
-      const { command, options } = params;
-      const mode = ctx.streamMode || 'structured';
-
-      if (mode === 'simple') {
-        const resolveBinary = ctx.resolveBinary || ((name) => name);
-        return runSimpleClaudeQuery(command, options, ctx, resolveBinary);
-      }
-      return runSDKClaudeQuery(command, options, ctx);
-    },
-
-    'claude-task-query': async (params, ctx) => {
-      const { command, options } = params;
-      return runSDKClaudeTaskQuery(command, options, ctx);
-    },
-  },
-};
-
-/**
- * Build SDK options from relay command options.
- * Maps the relay format to SDK Options type.
- */
-function buildSDKOptions(options = {}) {
-  const sdkOptions = {
-    cwd: options.projectPath || os.homedir(),
-    systemPrompt: { type: 'preset', preset: 'claude_code' },
-    settingSources: ['project', 'user', 'local'],
-  };
-
-  if (options.sessionId) {
-    sdkOptions.resume = options.sessionId;
-  }
-
-  if (options.model) {
-    sdkOptions.model = options.model;
-  }
-
-  if (options.maxBudgetUsd) {
-    sdkOptions.maxBudgetUsd = options.maxBudgetUsd;
-  }
-
-  if (options.permissionMode && options.permissionMode !== 'default') {
-    sdkOptions.permissionMode = options.permissionMode;
-  }
-
-  if (options.allowedTools && options.allowedTools.length > 0) {
-    sdkOptions.allowedTools = options.allowedTools;
-  }
-
-  if (options.disallowedTools && options.disallowedTools.length > 0) {
-    sdkOptions.disallowedTools = options.disallowedTools;
-  }
-
-  if (options.maxTurns) {
-    sdkOptions.maxTurns = options.maxTurns;
-  }
-
-  // Pass through tools preset to make all Claude Code tools available
-  sdkOptions.tools = { type: 'preset', preset: 'claude_code' };
-
-  return sdkOptions;
-}
-
-/**
- * SDK-based structured streaming mode.
- * Forwards rich SDK messages (tool_use, tool_result, text, system, result)
- * through ctx.stream() for the relay to forward to the frontend.
- */
-async function runSDKClaudeQuery(command, options, ctx) {
-  const sdkOptions = buildSDKOptions(options);
-
-  // Set stream-close timeout for interactive tools
-  const prevStreamTimeout = process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
-  process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = '300000';
-
-  let queryInstance;
-  try {
-    queryInstance = query({
-      prompt: command || '',
-      options: sdkOptions,
-    });
-  } finally {
-    // Restore immediately — Query constructor already captured the value
-    if (prevStreamTimeout !== undefined) {
-      process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT = prevStreamTimeout;
-    } else {
-      delete process.env.CLAUDE_CODE_STREAM_CLOSE_TIMEOUT;
-    }
-  }
-
-  // Track the query instance for abort support (uses .interrupt() instead of .kill())
-  if (ctx.trackProcess) {
-    ctx.trackProcess(ctx.requestId, { instance: queryInstance, action: 'claude-query' });
-  }
-
-  let capturedSessionId = null;
-
-  try {
-    for await (const message of queryInstance) {
-      // Capture session ID from first message that has one
-      if (message.session_id && !capturedSessionId) {
-        capturedSessionId = message.session_id;
-      }
-
-      // Forward the full SDK message — the backend routeViaRelay() will
-      // detect 'claude-sdk-message' type and forward directly to frontend,
-      // matching the same format as queryClaudeSDK() in claude-sdk.js
-      ctx.stream({
-        type: 'claude-sdk-message',
-        data: message,
-        sessionId: capturedSessionId,
-      });
-    }
-
-    return { exitCode: 0, sessionId: capturedSessionId };
-  } catch (error) {
-    ctx.stream({ type: 'claude-error', content: error.message || 'SDK query failed' });
-    return { exitCode: 1, sessionId: capturedSessionId };
-  } finally {
-    if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-  }
-}
-
-/**
- * SDK-based sub-agent for read-only research tasks.
- * Restricts tools to read-only operations.
- */
-async function runSDKClaudeTaskQuery(command, options, ctx) {
-  const sdkOptions = buildSDKOptions(options);
-
-  // Restrict to read-only tools
-  sdkOptions.allowedTools = ['View', 'Glob', 'Grep', 'LS', 'Read'];
-
-  let queryInstance;
-  try {
-    queryInstance = query({
-      prompt: command || '',
-      options: sdkOptions,
-    });
-  } catch (error) {
-    ctx.stream({ type: 'claude-error', content: error.message || 'SDK task query failed' });
-    return { exitCode: 1 };
-  }
-
-  if (ctx.trackProcess) {
-    ctx.trackProcess(ctx.requestId, { instance: queryInstance, action: 'claude-task-query' });
-  }
-
-  let capturedSessionId = null;
-
-  try {
-    for await (const message of queryInstance) {
-      if (message.session_id && !capturedSessionId) {
-        capturedSessionId = message.session_id;
-      }
-
-      ctx.stream({
-        type: 'claude-sdk-message',
-        data: message,
-        sessionId: capturedSessionId,
-      });
-    }
-
-    return { exitCode: 0, sessionId: capturedSessionId };
-  } catch (error) {
-    ctx.stream({ type: 'claude-error', content: error.message || 'SDK task query failed' });
-    return { exitCode: 1, sessionId: capturedSessionId };
-  } finally {
-    if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-  }
-}
-
-/**
- * Simple streaming mode (--print).
- * Just pipes stdout/stderr chunks. Kept for backward compat with relay-client.js.
- */
-function runSimpleClaudeQuery(command, options, ctx, resolveBinary) {
-  return new Promise((resolve) => {
-    const args = ['--print'];
-    if (options?.sessionId) args.push('--continue', options.sessionId);
-
-    const proc = spawn(resolveBinary('claude'), [...args, command || ''], {
-      shell: true,
-      cwd: options?.projectPath || os.homedir(),
-      env: process.env,
-    });
-
-    if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'claude-query' });
-
-    proc.stdout.on('data', (chunk) => {
-      ctx.stream({ type: 'claude-response', content: chunk.toString() });
-    });
-
-    proc.stderr.on('data', (chunk) => {
-      ctx.stream({ type: 'claude-error', content: chunk.toString() });
-    });
-
-    proc.on('close', (code) => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: code });
-    });
-
-    proc.on('error', () => {
-      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-      resolve({ exitCode: 1 });
-    });
-  });
-}

package/dist/agents/codex.js

@@ -1,48 +0,0 @@
-/**
- * Codex Agent
- * Handles: codex-query
- * Spawns the OpenAI Codex CLI and streams output.
- */
-import { spawn } from 'child_process';
-import os from 'os';
-
-export default {
-  name: 'codex',
-  actions: {
-    'codex-query': async (params, ctx) => {
-      const { command, options } = params;
-      const resolveBinary = ctx.resolveBinary || ((name) => name);
-
-      return new Promise((resolve) => {
-        const args = ['--quiet'];
-        if (options?.model) args.push('--model', options.model);
-
-        const proc = spawn(resolveBinary('codex'), [...args, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || options?.cwd || os.homedir(),
-          env: process.env,
-        });
-
-        if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'codex-query' });
-
-        proc.stdout.on('data', (chunk) => {
-          ctx.stream({ type: 'codex-response', content: chunk.toString() });
-        });
-
-        proc.stderr.on('data', (chunk) => {
-          ctx.stream({ type: 'codex-error', content: chunk.toString() });
-        });
-
-        proc.on('close', (code) => {
-          if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-          resolve({ exitCode: code });
-        });
-
-        proc.on('error', () => {
-          if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-          resolve({ exitCode: 1 });
-        });
-      });
-    },
-  },
-};

package/dist/agents/cursor.js

@@ -1,48 +0,0 @@
-/**
- * Cursor Agent
- * Handles: cursor-query
- * Spawns the Cursor Agent CLI and streams output.
- */
-import { spawn } from 'child_process';
-import os from 'os';
-
-export default {
-  name: 'cursor',
-  actions: {
-    'cursor-query': async (params, ctx) => {
-      const { command, options } = params;
-      const resolveBinary = ctx.resolveBinary || ((name) => name);
-
-      return new Promise((resolve) => {
-        const args = [];
-        if (options?.model) args.push('--model', options.model);
-
-        const proc = spawn(resolveBinary('cursor-agent'), [...args, command || ''], {
-          shell: true,
-          cwd: options?.projectPath || options?.cwd || os.homedir(),
-          env: process.env,
-        });
-
-        if (ctx.trackProcess) ctx.trackProcess(ctx.requestId, { proc, action: 'cursor-query' });
-
-        proc.stdout.on('data', (chunk) => {
-          ctx.stream({ type: 'cursor-response', content: chunk.toString() });
-        });
-
-        proc.stderr.on('data', (chunk) => {
-          ctx.stream({ type: 'cursor-error', content: chunk.toString() });
-        });
-
-        proc.on('close', (code) => {
-          if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-          resolve({ exitCode: code });
-        });
-
-        proc.on('error', () => {
-          if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
-          resolve({ exitCode: 1 });
-        });
-      });
-    },
-  },
-};

package/dist/agents/detect.js

@@ -1,51 +0,0 @@
-/**
- * Detect Agent
- * Handles: detect-agents
- * Checks which AI CLI agents are installed on the local machine.
- */
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
-
-const AGENT_DEFINITIONS = [
-  { name: 'claude', binary: 'claude', label: 'Claude Code' },
-  { name: 'codex', binary: 'codex', label: 'OpenAI Codex' },
-  { name: 'cursor', binary: 'cursor-agent', label: 'Cursor Agent' },
-];
-
-export default {
-  name: 'detect',
-  actions: {
-    'detect-agents': async (params, ctx) => {
-      const isWindows = process.platform === 'win32';
-      const whichCmd = isWindows ? 'where' : 'which';
-      const localBinDir = ctx.localBinDir || null;
-
-      const agents = {};
-      for (const agent of AGENT_DEFINITIONS) {
-        try {
-          const result = execSync(`${whichCmd} ${agent.binary}`, {
-            stdio: 'pipe',
-            timeout: 5000,
-          }).toString().trim();
-          agents[agent.name] = {
-            installed: true,
-            path: result.split('\n')[0].trim(),
-            label: agent.label,
-          };
-        } catch {
-          // Check local node_modules/.bin as fallback
-          if (localBinDir) {
-            const localPath = path.join(localBinDir, agent.binary + (isWindows ? '.cmd' : ''));
-            if (fs.existsSync(localPath)) {
-              agents[agent.name] = { installed: true, path: localPath, label: agent.label };
-              continue;
-            }
-          }
-          agents[agent.name] = { installed: false, label: agent.label };
-        }
-      }
-      return { agents };
-    },
-  },
-};

package/dist/agents/exec.js

@@ -1,31 +0,0 @@
-/**
- * Exec Agent
- * Handles: exec (arbitrary command execution)
- */
-import { execSync } from 'child_process';
-
-export default {
-  name: 'exec',
-  actions: {
-    'exec': async (params) => {
-      const { command, timeout: cmdTimeout = 60000, cwd } = params;
-      if (!command) throw new Error('No command provided');
-
-      try {
-        const output = execSync(command, {
-          encoding: 'utf8',
-          timeout: cmdTimeout,
-          cwd: cwd || process.cwd(),
-          stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return { output, exitCode: 0 };
-      } catch (execErr) {
-        return {
-          output: execErr.stdout || '',
-          stderr: execErr.stderr || '',
-          exitCode: execErr.status || 1,
-        };
-      }
-    },
-  },
-};

package/dist/agents/files.js

@@ -1,105 +0,0 @@
-/**
- * File System Agent
- * Handles: file-read, file-write, file-tree, browse-dirs, validate-path, create-folder
- */
-import { promises as fsPromises } from 'fs';
-import os from 'os';
-import path from 'path';
-import {
-  buildFileTree,
-  resolveTildePath,
-  isBlockedPath,
-  BLOCKED_READ_PATTERNS,
-  BLOCKED_WRITE_PATTERNS,
-} from './utils.js';
-
-export default {
-  name: 'files',
-  actions: {
-    'file-read': async (params) => {
-      let { filePath, encoding } = params;
-      if (!filePath || typeof filePath !== 'string') throw new Error('Invalid file path');
-
-      filePath = resolveTildePath(filePath);
-      const normalizedPath = path.resolve(filePath);
-      if (isBlockedPath(normalizedPath, BLOCKED_READ_PATTERNS)) throw new Error('Access denied');
-
-      const content = await fsPromises.readFile(normalizedPath, encoding === 'base64' ? null : 'utf8');
-      const result = encoding === 'base64' ? content.toString('base64') : content;
-      return { content: result };
-    },
-
-    'file-write': async (params) => {
-      let { filePath, content } = params;
-      if (!filePath || typeof filePath !== 'string') throw new Error('Invalid file path');
-
-      filePath = resolveTildePath(filePath);
-      const normalizedPath = path.resolve(filePath);
-      if (isBlockedPath(normalizedPath, BLOCKED_WRITE_PATTERNS)) throw new Error('Access denied');
-
-      const parentDir = path.dirname(normalizedPath);
-      await fsPromises.mkdir(parentDir, { recursive: true }).catch(() => {});
-      await fsPromises.writeFile(normalizedPath, content, 'utf8');
-      return { success: true };
-    },
-
-    'file-tree': async (params) => {
-      const { dirPath, depth, maxDepth } = params;
-      const treeDepth = depth || maxDepth || 3;
-      const resolvedDir = dirPath ? path.resolve(dirPath) : process.cwd();
-      const tree = await buildFileTree(resolvedDir, treeDepth, 0, {
-        maxEntries: 200,
-        includeStats: true,
-        skipDotfilesAtRoot: true,
-      });
-      return { files: tree };
-    },
-
-    'browse-dirs': async (params) => {
-      const { dirPath: browsePath } = params;
-      let targetDir = resolveTildePath(browsePath);
-      targetDir = path.resolve(targetDir);
-
-      let drives = [];
-      // On Windows, detect available drives
-      if (process.platform === 'win32') {
-        try {
-          const { execSync } = await import('child_process');
-          const wmicOut = execSync('wmic logicaldisk get name', { encoding: 'utf8', timeout: 5000 });
-          drives = wmicOut.split('\n')
-            .map(l => l.trim())
-            .filter(l => /^[A-Z]:$/.test(l))
-            .map(d => ({ name: d + '\\', path: d + '\\', type: 'drive' }));
-        } catch { /* wmic not available */ }
-      }
-
-      const entries = await fsPromises.readdir(targetDir, { withFileTypes: true });
-      const dirs = entries
-        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-        .map(e => ({ name: e.name, path: path.join(targetDir, e.name), type: 'directory' }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-
-      return { path: targetDir, suggestions: dirs, drives, homedir: os.homedir() };
-    },
-
-    'validate-path': async (params) => {
-      const { targetPath } = params;
-      const checkPath = resolveTildePath(targetPath);
-      const resolved = path.resolve(checkPath);
-
-      try {
-        const stats = await fsPromises.stat(resolved);
-        return { exists: true, isDirectory: stats.isDirectory(), resolvedPath: resolved };
-      } catch {
-        return { exists: false, resolvedPath: resolved };
-      }
-    },
-
-    'create-folder': async (params) => {
-      const { folderPath } = params;
-      const mkPath = path.resolve(resolveTildePath(folderPath));
-      await fsPromises.mkdir(mkPath, { recursive: true });
-      return { success: true, path: mkPath };
-    },
-  },
-};

package/dist/agents/git.js

@@ -1,18 +0,0 @@
-/**
- * Git Agent
- * Handles: git-operation
- */
-import path from 'path';
-import { execCommand } from './utils.js';
-
-export default {
-  name: 'git',
-  actions: {
-    'git-operation': async (params) => {
-      const { gitCommand, cwd } = params;
-      const resolvedCwd = cwd ? path.resolve(cwd) : process.cwd();
-      const result = await execCommand('git', [gitCommand], { cwd: resolvedCwd });
-      return { stdout: result };
-    },
-  },
-};

package/dist/agents/gitagent.js

@@ -1,67 +0,0 @@
-/**
- * Gitagent Agent
- * Handles: gitagent-detect, gitagent-parse
- *
- * Relay-compatible actions for detecting and parsing gitagent directory structures
- * on the user's local machine.
- */
-import fs from 'fs';
-import { promises as fsp } from 'fs';
-import path from 'path';
-import { detectGitagent, parseGitagentRepo } from '../gitagent/parser.js';
-
-/** fs-backed helpers injected into the parser */
-async function fsFileExists(filePath) {
-  try {
-    await fsp.access(filePath, fs.constants.F_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-async function fsReadFile(filePath) {
-  try {
-    return await fsp.readFile(filePath, 'utf8');
-  } catch {
-    return null;
-  }
-}
-
-async function fsListDir(dirPath) {
-  try {
-    return await fsp.readdir(dirPath);
-  } catch {
-    return [];
-  }
-}
-
-export default {
-  name: 'gitagent',
-  actions: {
-    /**
-     * Lightweight check for agent.yaml existence.
-     * @param {{ projectPath: string }} params
-     * @returns {{ detected: boolean }}
-     */
-    'gitagent-detect': async (params) => {
-      const projectPath = params.projectPath;
-      if (!projectPath) return { detected: false };
-      const detected = await detectGitagent(projectPath, fsFileExists);
-      return { detected };
-    },
-
-    /**
-     * Full parse — returns the complete GitagentDefinition as JSON.
-     * @param {{ projectPath: string }} params
-     * @returns {{ definition: object|null }}
-     */
-    'gitagent-parse': async (params) => {
-      const projectPath = params.projectPath;
-      if (!projectPath) return { definition: null };
-
-      const definition = await parseGitagentRepo(projectPath, fsReadFile, fsListDir);
-      return { definition };
-    },
-  },
-};