agentgui 1.0.831 → 1.0.833

package/lib/claude-runner-acp.js

@@ -0,0 +1,155 @@
+import { spawn } from 'child_process';
+import { AgentRunner, getSpawnOptions, resolveCommand } from './claude-runner.js';
+
+function buildEnhancedHandler({ proc, outputs, sessionRef, promptIdRef, completedRef, drainingRef, requestIdRef, originalHandler, resolve, reject, clearTimeoutHandle, promptText }) {
+  return function(message) {
+    if (message.id && message.result && message.result.sessionId) {
+      sessionRef.value = message.result.sessionId;
+      promptIdRef.value = ++requestIdRef.value;
+      proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: promptIdRef.value, method: 'session/prompt', params: { sessionId: sessionRef.value, prompt: [{ type: 'text', text: promptText }] } }) + '\n');
+      return;
+    }
+    if (promptIdRef.value !== null && message.id === promptIdRef.value && message.result && message.result.stopReason) {
+      completedRef.value = true; drainingRef.value = true;
+      clearTimeoutHandle();
+      setTimeout(() => { drainingRef.value = false; try { proc.kill(); } catch (e) {} resolve({ outputs, sessionId: sessionRef.value }); }, 1000);
+      return;
+    }
+    if (promptIdRef.value !== null && message.id === promptIdRef.value && message.error) {
+      completedRef.value = true; drainingRef.value = true;
+      clearTimeoutHandle();
+      originalHandler(message);
+      setTimeout(() => { drainingRef.value = false; try { proc.kill(); } catch (e) {} reject(new Error(message.error.message || 'ACP prompt error')); }, 1000);
+      return;
+    }
+    originalHandler(message);
+  };
+}
+
+AgentRunner.prototype.runACP = async function(prompt, cwd, config = {}, _retryCount = 0) {
+  const maxRetries = config.maxRetries ?? 1;
+  try {
+    return await this._runACPOnce(prompt, cwd, config);
+  } catch (err) {
+    const isEmptyExit = err.isPrematureEnd || (err.message && err.message.includes('ACP exited with code'));
+    const isBinaryError = err.code === 'ENOENT' || (err.message && err.message.includes('ENOENT'));
+    if ((isEmptyExit || isBinaryError) && _retryCount < maxRetries) {
+      const delay = Math.min(1000 * Math.pow(2, _retryCount), 5000);
+      console.error(`[${this.id}] ACP attempt ${_retryCount + 1} failed: ${err.message}. Retrying in ${delay}ms...`);
+      await new Promise(r => setTimeout(r, delay));
+      return this.runACP(prompt, cwd, config, _retryCount + 1);
+    }
+    if (err.isPrematureEnd) {
+      const premErr = new Error(err.message);
+      premErr.isPrematureEnd = true;
+      premErr.exitCode = err.exitCode;
+      premErr.stderrText = err.stderrText;
+      throw premErr;
+    }
+    throw err;
+  }
+};
+
+AgentRunner.prototype._runACPOnce = function(prompt, cwd, config = {}) {
+  return new Promise((resolve, reject) => {
+    const { timeout = 300000, onEvent = null, onError = null } = config;
+    let cmd, args;
+    if (this.requiresAdapter && this.adapterCommand) {
+      cmd = this.adapterCommand; args = [...this.adapterArgs];
+    } else {
+      const resolved = resolveCommand(this.command, this.npxPackage);
+      cmd = resolved.cmd; args = [...resolved.prefixArgs, ...this.buildArgs(prompt, config)];
+    }
+    const spawnOpts = getSpawnOptions(cwd);
+    if (Object.keys(this.spawnEnv).length > 0) spawnOpts.env = { ...spawnOpts.env, ...this.spawnEnv };
+    const proc = spawn(cmd, args, spawnOpts);
+
+    if (config.onPid) { try { config.onPid(proc.pid); } catch (e) { console.error(`[${this.id}] onPid callback failed:`, e.message); } }
+    if (config.onProcess) { try { config.onProcess(proc); } catch (e) { console.error(`[${this.id}] onProcess callback failed:`, e.message); } }
+
+    const outputs = [];
+    let timedOut = false;
+    let stderrText = '';
+    const sessionRef = { value: null };
+    const promptIdRef = { value: null };
+    const completedRef = { value: false };
+    const drainingRef = { value: false };
+    const requestIdRef = { value: 0 };
+    let initialized = false;
+
+    const timeoutHandle = setTimeout(() => { timedOut = true; proc.kill(); reject(new Error(`${this.name} ACP timeout after ${timeout}ms`)); }, timeout);
+    const clearTimeoutHandle = () => clearTimeout(timeoutHandle);
+
+    const originalHandler = (message) => {
+      const normalized = this.protocolHandler(message, { sessionId: sessionRef.value, initialized });
+      if (!normalized) { if (message.id === 1 && message.result) initialized = true; return; }
+      outputs.push(normalized);
+      if (normalized.session_id) sessionRef.value = normalized.session_id;
+      if (onEvent) { try { onEvent(normalized); } catch (e) { console.error(`[${this.id}] onEvent error: ${e.message}`); } }
+    };
+
+    const enhancedHandler = buildEnhancedHandler({ proc, outputs, sessionRef, promptIdRef, completedRef, drainingRef, requestIdRef, originalHandler, resolve, reject, clearTimeoutHandle, promptText: prompt });
+
+    proc.stdout.on('error', () => {});
+    proc.stderr.on('error', () => {});
+    proc.stderr.on('data', (chunk) => {
+      const errorText = chunk.toString();
+      stderrText += errorText;
+      console.error(`[${this.id}] stderr:`, errorText);
+      if (onError) { try { onError(errorText); } catch (e) {} }
+    });
+
+    proc.stdin.on('error', () => {});
+    proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: ++requestIdRef.value, method: 'initialize', params: { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: true, writeTextFile: true }, terminal: true }, clientInfo: { name: 'agentgui', title: 'AgentGUI', version: '1.0.0' } } }) + '\n');
+
+    let buffer = '';
+    proc.stdout.on('data', (chunk) => {
+      if (timedOut || (completedRef.value && !drainingRef.value)) return;
+      buffer += chunk.toString();
+      const lines = buffer.split('\n'); buffer = lines.pop();
+      for (const line of lines) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+            if (message.id === 1 && message.result) initialized = true;
+            enhancedHandler(message);
+          } catch (e) { console.error(`[${this.id}] JSON parse error:`, line.substring(0, 100)); }
+        }
+      }
+    });
+
+    const checkInitAndSend = () => {
+      if (initialized) {
+        const sessionParams = { cwd, mcpServers: [] };
+        if (config.model) sessionParams.model = config.model;
+        if (config.subAgent) sessionParams.agent = config.subAgent;
+        if (config.systemPrompt) sessionParams.systemPrompt = config.systemPrompt;
+        proc.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: ++requestIdRef.value, method: 'session/new', params: sessionParams }) + '\n');
+      } else {
+        setTimeout(checkInitAndSend, 100);
+      }
+    };
+    setTimeout(checkInitAndSend, 200);
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutHandle);
+      if (timedOut || completedRef.value) return;
+      if (buffer.trim()) {
+        try {
+          const message = JSON.parse(buffer.trim());
+          if (message.id === 1 && message.result) initialized = true;
+          enhancedHandler(message);
+        } catch (e) {}
+      }
+      if (code === 0 || outputs.length > 0) resolve({ outputs, sessionId: sessionRef.value });
+      else {
+        const detail = stderrText ? `: ${stderrText.substring(0, 200)}` : '';
+        const err = new Error(`${this.name} ACP exited with code ${code}${detail}`);
+        err.isPrematureEnd = true; err.exitCode = code; err.stderrText = stderrText;
+        reject(err);
+      }
+    });
+
+    proc.on('error', (err) => { clearTimeout(timeoutHandle); reject(err); });
+  });
+};

package/lib/claude-runner-agents.js

@@ -0,0 +1,104 @@
+import { spawnSync } from 'child_process';
+import { AgentRunner } from './claude-runner.js';
+import { acpProtocolHandler } from './acp-protocol.js';
+import './claude-runner-direct.js';
+import './claude-runner-acp.js';
+
+const isWindows = process.platform === 'win32';
+
+export class AgentRegistry {
+  constructor() { this.agents = new Map(); }
+
+  register(config) {
+    const runner = new AgentRunner(config);
+    this.agents.set(config.id, runner);
+    return runner;
+  }
+
+  get(agentId) { return this.agents.get(agentId); }
+  has(agentId) { return this.agents.has(agentId); }
+
+  list() {
+    return Array.from(this.agents.values()).map(a => ({
+      id: a.id, name: a.name, command: a.command, protocol: a.protocol,
+      requiresAdapter: a.requiresAdapter, supportedFeatures: a.supportedFeatures, npxPackage: a.npxPackage
+    }));
+  }
+
+  listACPAvailable() {
+    return this.list().filter(agent => {
+      try {
+        const whichCmd = isWindows ? 'where' : 'which';
+        const which = spawnSync(whichCmd, [agent.command], { encoding: 'utf-8', timeout: 3000 });
+        if (which.status === 0) {
+          const binPath = (which.stdout || '').trim().split('\n')[0].trim();
+          if (binPath) {
+            const check = spawnSync(binPath, ['--version'], { encoding: 'utf-8', timeout: 10000, shell: isWindows });
+            if (check.status === 0 && (check.stdout || '').trim().length > 0) return true;
+          }
+        }
+        const a = this.agents.get(agent.id);
+        if (a && a.npxPackage) {
+          const npxCheck = spawnSync(whichCmd, ['npx'], { encoding: 'utf-8', timeout: 3000 });
+          if (npxCheck.status === 0) return true;
+          const bunCheck = spawnSync(whichCmd, ['bun'], { encoding: 'utf-8', timeout: 3000 });
+          if (bunCheck.status === 0) return true;
+        }
+        return false;
+      } catch { return false; }
+    });
+  }
+}
+
+export const registry = new AgentRegistry();
+
+function parseClaudeOutput(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (!entry || typeof entry !== 'object') return null;
+    if (entry.type === 'user' && entry.isMeta === true) return null;
+    if (entry.isApiErrorMessage === true && entry.error === 'rate_limit') entry._rateLimitDetected = true;
+    if (entry.type === 'assistant' && entry.message) entry._isFragment = entry.message.stop_reason === null || entry.message.stop_reason === undefined;
+    if (entry.type === 'system' && entry.subtype === 'turn_duration' && entry.durationMs) entry._turnDurationMs = entry.durationMs;
+    if (entry.type === 'system' && entry.subtype === 'compact_boundary' && entry.compactMetadata) entry._preTokens = entry.compactMetadata.preTokens;
+    if (entry.message?.usage) {
+      const u = entry.message.usage;
+      entry._cacheUsage = { cache_creation: u.cache_creation_input_tokens || u['cache_creation.ephemeral_1h_input_tokens'] || u['cache_creation.ephemeral_5m_input_tokens'] || 0, cache_read: u.cache_read_input_tokens || 0 };
+    }
+    return entry;
+  } catch { return null; }
+}
+
+registry.register({
+  id: 'claude-code', name: 'Claude Code', command: 'claude', protocol: 'direct', supportsStdin: false, closeStdin: true,
+  useJsonRpcStdin: false, supportedFeatures: ['streaming', 'resume', 'system-prompt', 'permissions-skip', 'steering'],
+  spawnEnv: { MAX_THINKING_TOKENS: '0', AGENTGUI_SUBPROCESS: '1' },
+  buildArgs(prompt, config) {
+    const { verbose = true, outputFormat = 'stream-json', print = true, resumeSessionId = null, systemPrompt = null, model = null } = config;
+    const flags = [];
+    if (print) flags.push('--print');
+    if (verbose) flags.push('--verbose');
+    flags.push(`--output-format=${outputFormat}`);
+    if (model) flags.push('--model', model);
+    if (resumeSessionId) flags.push('--resume', resumeSessionId);
+    if (systemPrompt) flags.push('--append-system-prompt', systemPrompt);
+    flags.push('--dangerously-skip-permissions');
+    flags.push(typeof prompt === 'string' ? prompt : String(prompt));
+    return flags;
+  },
+  parseOutput: parseClaudeOutput
+});
+
+registry.register({ id: 'opencode', name: 'OpenCode', command: 'opencode', protocol: 'acp', supportsStdin: false, npxPackage: 'opencode-ai', supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'gemini', name: 'Gemini CLI', command: 'gemini', protocol: 'acp', supportsStdin: false, npxPackage: '@google/gemini-cli', supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs(prompt, config) { const args = ['--experimental-acp', '--yolo']; if (config?.model) args.push('--model', config.model); return args; }, protocolHandler: acpProtocolHandler });
+registry.register({ id: 'goose', name: 'Goose', command: 'goose', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'openhands', name: 'OpenHands', command: 'openhands', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'augment', name: 'Augment Code', command: 'augment', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'cline', name: 'Cline', command: 'cline', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'kimi', name: 'Kimi CLI', command: 'kimi', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'qwen', name: 'Qwen Code', command: 'qwen-code', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'codex', name: 'Codex CLI', command: 'codex', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'mistral', name: 'Mistral Vibe', command: 'mistral-vibe', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'kiro', name: 'Kiro CLI', command: 'kiro', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'fast-agent', name: 'fast-agent', command: 'fast-agent', protocol: 'acp', supportsStdin: false, supportedFeatures: ['streaming', 'resume', 'acp-protocol'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });
+registry.register({ id: 'kilo', name: 'Kilo CLI', command: 'kilo', protocol: 'acp', supportsStdin: false, npxPackage: '@kilocode/cli', supportedFeatures: ['streaming', 'resume', 'acp-protocol', 'models'], buildArgs: () => ['acp'], protocolHandler: acpProtocolHandler });

package/lib/claude-runner-direct.js

@@ -0,0 +1,116 @@
+import { spawn } from 'child_process';
+import { AgentRunner, getSpawnOptions } from './claude-runner.js';
+
+AgentRunner.prototype.runDirect = function(prompt, cwd, config = {}) {
+  return new Promise((resolve, reject) => {
+    const { timeout = 300000, onEvent = null, onError = null, onRateLimit = null } = config;
+    const args = this.buildArgs(prompt, config);
+    const spawnOpts = getSpawnOptions(cwd);
+    if (Object.keys(this.spawnEnv).length > 0) spawnOpts.env = { ...spawnOpts.env, ...this.spawnEnv };
+    if (this.closeStdin) spawnOpts.stdio = ['ignore', 'pipe', 'pipe'];
+    const proc = spawn(this.command, args, spawnOpts);
+    console.log(`[${this.id}] Spawned PID ${proc.pid} closeStdin=${this.closeStdin}`);
+
+    if (config.onPid) { try { config.onPid(proc.pid); } catch (e) { console.error(`[${this.id}] onPid callback failed:`, e.message); } }
+    if (config.onProcess) { try { config.onProcess(proc); } catch (e) { console.error(`[${this.id}] onProcess callback failed:`, e.message); } }
+
+    let jsonBuffer = '';
+    const outputs = [];
+    let timedOut = false;
+    let sessionId = null;
+    let rateLimited = false;
+    let retryAfterSec = 60;
+    let authError = false;
+    let authErrorMessage = '';
+
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+      reject(new Error(`${this.name} timeout after ${timeout}ms`));
+    }, timeout);
+
+    if (this.supportsStdin) proc.stdin.write(prompt);
+
+    proc.stdout.on('error', () => {});
+    if (proc.stderr) proc.stderr.on('error', () => {});
+    proc.stdout.on('data', (chunk) => {
+      if (timedOut) return;
+      jsonBuffer += chunk.toString();
+      const lines = jsonBuffer.split('\n');
+      jsonBuffer = lines.pop();
+      for (const line of lines) {
+        if (line.trim()) {
+          const parsed = this.parseOutput(line);
+          if (!parsed) continue;
+          outputs.push(parsed);
+          if (parsed.session_id) sessionId = parsed.session_id;
+          if (onEvent) { try { onEvent(parsed); } catch (e) { console.error(`[${this.id}] onEvent error: ${e.message}`); } }
+        }
+      }
+    });
+
+    if (proc.stderr) proc.stderr.on('data', (chunk) => {
+      const errorText = chunk.toString();
+      console.error(`[${this.id}] stderr:`, errorText);
+      if (/401|unauthorized|invalid.*auth|invalid.*token|auth.*failed|permission denied|access denied/i.test(errorText)) {
+        authError = true;
+        authErrorMessage = errorText.trim();
+      }
+      const rateLimitMatch = errorText.match(/rate.?limit|429|too many requests|overloaded|throttl|hit your limit/i);
+      if (rateLimitMatch) {
+        rateLimited = true;
+        const retryMatch = errorText.match(/retry.?after[:\s]+(\d+)/i);
+        if (retryMatch) {
+          retryAfterSec = parseInt(retryMatch[1], 10) || 60;
+        } else {
+          const resetTimeMatch = errorText.match(/resets?\s+(?:at\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)?\s*\(?(UTC|[A-Z]{2,4})\)?/i);
+          if (resetTimeMatch) {
+            let hours = parseInt(resetTimeMatch[1], 10);
+            const minutes = resetTimeMatch[2] ? parseInt(resetTimeMatch[2], 10) : 0;
+            const period = resetTimeMatch[3]?.toLowerCase();
+            if (period === 'pm' && hours !== 12) hours += 12;
+            if (period === 'am' && hours === 12) hours = 0;
+            const now = new Date();
+            const resetTime = new Date(now);
+            resetTime.setUTCHours(hours, minutes, 0, 0);
+            if (resetTime <= now) resetTime.setUTCDate(resetTime.getUTCDate() + 1);
+            retryAfterSec = Math.max(60, Math.ceil((resetTime.getTime() - now.getTime()) / 1000));
+          }
+        }
+      }
+      if (onError) { try { onError(errorText); } catch (e) {} }
+    });
+
+    proc.on('close', (code) => {
+      clearTimeout(timeoutHandle);
+      if (timedOut) return;
+      if (authError) {
+        const err = new Error(`Authentication failed: ${authErrorMessage || 'Invalid credentials or unauthorized access'}`);
+        err.authError = true;
+        err.nonRetryable = true;
+        reject(err);
+        return;
+      }
+      if (rateLimited) {
+        const err = new Error(`Rate limited - retry after ${retryAfterSec}s`);
+        err.rateLimited = true;
+        err.retryAfterSec = retryAfterSec;
+        if (onRateLimit) { try { onRateLimit({ retryAfterSec }); } catch (e) {} }
+        reject(err);
+        return;
+      }
+      if (jsonBuffer.trim()) {
+        const parsed = this.parseOutput(jsonBuffer);
+        if (parsed) {
+          outputs.push(parsed);
+          if (parsed.session_id) sessionId = parsed.session_id;
+          if (onEvent) { try { onEvent(parsed); } catch (e) {} }
+        }
+      }
+      if (code === 0 || outputs.length > 0) resolve({ outputs, sessionId });
+      else reject(new Error(`${this.name} exited with code ${code}`));
+    });
+
+    proc.on('error', (err) => { clearTimeout(timeoutHandle); reject(err); });
+  });
+};

package/lib/claude-runner-run.js

@@ -0,0 +1,49 @@
+import { registry } from './claude-runner-agents.js';
+
+const communicationGuidelines = `
+COMMUNICATION STYLE: Minimize output. Only inform the user about:
+- Critical errors that block work
+- User needs to know info (e.g., "port in use", "authentication failed", "file not found")
+- Action required from user
+- Important decisions that affect their work
+
+DO NOT output:
+- Progress updates ("doing X now", "completed Y", "searching for...")
+- Verbose summaries of what was done
+- Status checks or verification messages
+- Detailed explanations unless asked
+- "Working on...", "Looking for...", step-by-step progress
+
+INSTEAD:
+- Run tools silently
+- Show results only when relevant
+- Be conversational and direct
+- Let code/output speak for itself
+`;
+
+export async function runClaudeWithStreaming(prompt, cwd, agentId = 'claude-code', config = {}) {
+  const agent = registry.get(agentId);
+  if (!agent) throw new Error(`Unknown agent: ${agentId}. Registered agents: ${registry.list().map(a => a.id).join(', ')}`);
+
+  const enhancedConfig = { ...config };
+  if (!enhancedConfig.systemPrompt) enhancedConfig.systemPrompt = '';
+
+  if (!enhancedConfig.systemPrompt.includes('COMMUNICATION STYLE')) {
+    enhancedConfig.systemPrompt = communicationGuidelines + enhancedConfig.systemPrompt;
+  }
+
+  if (agentId && agentId !== 'claude-code') {
+    const displayAgentId = agentId.split('-·-')[0];
+    const agentPrefix = `use ${displayAgentId} subagent to. `;
+    if (!enhancedConfig.systemPrompt.includes(agentPrefix)) {
+      enhancedConfig.systemPrompt = agentPrefix + enhancedConfig.systemPrompt;
+    }
+  }
+
+  return agent.run(prompt, cwd, enhancedConfig);
+}
+
+export function getRegisteredAgents() { return registry.list(); }
+export function getAvailableAgents() { return registry.listACPAvailable(); }
+export function isAgentRegistered(agentId) { return registry.has(agentId); }
+export default runClaudeWithStreaming;