upfynai-code 2.7.5 → 2.8.0

package/bin/cli.js

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 
 import { Command } from 'commander';
 import { login, logout, status } from '../src/auth.js';

package/dist/agents/claude.js

@@ -0,0 +1,197 @@
+/**
+ * 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.
+ *
+ * Two modes:
+ * - stream-json (connect.js) — full structured streaming with session tracking
+ * - simple --print (relay-client.js) — basic stdout streaming
+ *
+ * The caller chooses the mode via ctx.streamMode ('structured' | 'simple').
+ */
+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';
+      const resolveBinary = ctx.resolveBinary || ((name) => name);
+
+      if (mode === 'simple') {
+        return runSimpleClaudeQuery(command, options, ctx, resolveBinary);
+      }
+      return runStructuredClaudeQuery(command, options, ctx, resolveBinary);
+    },
+
+    'claude-task-query': async (params, ctx) => {
+      const { command, options } = params;
+      const resolveBinary = ctx.resolveBinary || ((name) => name);
+      return runClaudeTaskQuery(command, options, ctx, resolveBinary);
+    },
+  },
+};
+
+/**
+ * Structured streaming mode (stream-json).
+ * Parses NDJSON events, computes text deltas, tracks session ID.
+ */
+function runStructuredClaudeQuery(command, options, ctx, resolveBinary) {
+  return new Promise((resolve) => {
+    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
+    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' });
+
+    let stdoutBuffer = '';
+    let capturedSessionId = null;
+    let lastTextLength = 0;
+
+    proc.stdout.on('data', (chunk) => {
+      stdoutBuffer += chunk.toString();
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop();
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const evt = JSON.parse(line);
+
+          if (evt.type === 'system' && evt.subtype === 'init') {
+            if (evt.session_id) capturedSessionId = evt.session_id;
+            lastTextLength = 0;
+            ctx.stream({ type: 'claude-system', sessionId: evt.session_id, model: evt.model, cwd: evt.cwd });
+          } else if (evt.type === 'assistant' && evt.message?.content?.length) {
+            const fullText = evt.message.content[0].text || '';
+            const delta = fullText.slice(lastTextLength);
+            lastTextLength = fullText.length;
+            if (delta) {
+              ctx.stream({ type: 'claude-response', content: delta });
+            }
+          } else if (evt.type === 'result') {
+            lastTextLength = 0;
+            ctx.stream({ type: 'claude-result', sessionId: capturedSessionId, subtype: evt.subtype });
+          }
+        } catch {
+          if (line.trim() && !line.startsWith('%') && !line.includes('claude query')) {
+            ctx.stream({ type: 'claude-response', content: line });
+          }
+        }
+      }
+    });
+
+    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, sessionId: capturedSessionId });
+    });
+
+    proc.on('error', () => {
+      if (ctx.untrackProcess) ctx.untrackProcess(ctx.requestId);
+      resolve({ exitCode: 1, sessionId: capturedSessionId });
+    });
+  });
+}
+
+/**
+ * Simple streaming mode (--print).
+ * Just pipes stdout/stderr chunks.
+ */
+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 });
+    });
+  });
+}
+
+/**
+ * Sub-agent for read-only research tasks.
+ * Uses --allowedTools to restrict to read-only operations.
+ */
+function runClaudeTaskQuery(command, options, ctx, resolveBinary) {
+  return new Promise((resolve) => {
+    const args = ['-p', '--output-format', 'stream-json', '--include-partial-messages'];
+    args.push('--allowedTools', 'View,Glob,Grep,LS,Read');
+
+    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-task-query' });
+    let taskBuffer = '';
+
+    proc.stdout.on('data', (chunk) => {
+      taskBuffer += chunk.toString();
+      const lines = taskBuffer.split('\n');
+      taskBuffer = lines.pop();
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const evt = JSON.parse(line);
+          if (evt.type === 'assistant' && evt.message?.content?.length) {
+            ctx.stream({ type: 'claude-response', content: evt.message.content[0].text || '' });
+          }
+        } catch {
+          if (line.trim()) {
+            ctx.stream({ type: 'claude-response', content: line });
+          }
+        }
+      }
+    });
+
+    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

@@ -0,0 +1,48 @@
+/**
+ * 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

@@ -0,0 +1,48 @@
+/**
+ * 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

@@ -0,0 +1,51 @@
+/**
+ * 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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,105 @@
+/**
+ * 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

@@ -0,0 +1,18 @@
+/**
+ * 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/index.js

@@ -0,0 +1,87 @@
+/**
+ * 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';
+
+const agents = [claudeAgent, codexAgent, cursorAgent, shellAgent, filesAgent, gitAgent, execAgent, detectAgent];
+
+/** 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

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