claude-simple 0.2.8 → 0.2.10

package/src/agents/cursor.js

@@ -0,0 +1,189 @@
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+
+// Cursor Agent owns its native transcript format.  Keep a small UI journal so
+// sessions started here remain searchable/readable without relying on that
+// private format.
+function journalPath(cursorHome, sessionId) {
+  return path.join(cursorHome, 'claude-simple-ui', 'sessions', `${sessionId}.jsonl`);
+}
+
+function journal(cursorHome, sessionId, value) {
+  if (!sessionId) return;
+  const file = journalPath(cursorHome, sessionId);
+  fs.mkdir(path.dirname(file), { recursive: true })
+    .then(() => fs.appendFile(file, `${JSON.stringify(value)}\n`, 'utf8'))
+    .catch(() => {});
+}
+
+function buildArgs(command, options) {
+  const args = ['--print', '--output-format', 'stream-json', '--stream-partial-output'];
+  if (options.sessionId) args.push('--resume', options.sessionId);
+  if (options.model) args.push('--model', options.model);
+  if (options.cwd) args.push('--workspace', options.cwd);
+  if (options.permissionMode === 'plan') args.push('--mode', 'plan');
+  else if (options.permissionMode === 'ask') args.push('--mode', 'ask');
+  else if (options.allowDangerouslySkipPermissions || ['bypassPermissions', 'acceptEdits', 'auto'].includes(options.permissionMode)) args.push('--force');
+  // The UI has already selected the project directory; do not trigger Cursor's
+  // interactive trust prompt in a non-interactive child process.
+  args.push('--trust', command || '');
+  return args;
+}
+
+function textBlocks(message) {
+  const content = message?.content;
+  if (typeof content === 'string') return content;
+  if (!Array.isArray(content)) return '';
+  return content.filter(b => b?.type === 'text' && b.text).map(b => b.text).join('\n');
+}
+
+function toolBlocks(message) {
+  return Array.isArray(message?.content)
+    ? message.content.filter(b => b?.type === 'tool_use' || b?.type === 'tool-call')
+    : [];
+}
+
+/** Run one Cursor Agent turn in headless stream-json mode. */
+export function runCursor(command, options, send, { cliPath, cursorHome, activeSessions }) {
+  return new Promise(resolve => {
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const home = cursorHome || path.join(process.env.HOME || '', '.cursor');
+    const args = buildArgs(command, options);
+    let child;
+    try {
+      child = spawn(cliPath || 'cursor-agent', args, {
+        cwd: options.cwd || process.cwd(), env: { ...process.env }, stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      send({ type: 'error', message: `Failed to start cursor-agent: ${error.message}`, agent: 'cursor' });
+      resolve();
+      return;
+    }
+
+    const entry = { kind: 'cursor', child, startTime: Date.now(), busy: true, key: sessionKey, sessionId: options.sessionId || null };
+    activeSessions.set(sessionKey, entry);
+    let sessionId = options.sessionId || null;
+    let stderr = '';
+    let textOpen = false;
+    let resultSeen = false;
+    let aborted = false;
+    let finalText = '';
+    let thoughtOpen = false;
+    const emittedTexts = new Set();
+
+    const closeText = () => {
+      if (!textOpen) return;
+      textOpen = false;
+      send({ type: 'assistant_stream_end', agent: 'cursor' });
+    };
+    const attachSession = id => {
+      if (!id || sessionId === id) return;
+      sessionId = id;
+      entry.sessionId = id;
+      activeSessions.set(id, entry);
+      if (!options.sessionId) send({ type: 'session-created', sessionId: id, agent: 'cursor' });
+      journal(home, id, { type: 'session_meta', sessionId: id, cwd: options.cwd || null, model: options.model || null, ts: Date.now() });
+      journal(home, id, { type: 'user', content: command || '', ts: Date.now() });
+    };
+    if (options.sessionId) {
+      journal(home, options.sessionId, { type: 'session_meta', sessionId: options.sessionId, cwd: options.cwd || null, model: options.model || null, ts: Date.now() });
+      journal(home, options.sessionId, { type: 'user', content: command || '', ts: Date.now() });
+    }
+    const emitDelta = text => {
+      if (!text) return;
+      if (!textOpen) {
+        textOpen = true;
+        send({ type: 'assistant_stream_start', agent: 'cursor', ts: Date.now() });
+      }
+      send({ type: 'assistant_delta', data: text, agent: 'cursor' });
+      journal(home, sessionId, { type: 'assistant_delta', data: text, ts: Date.now() });
+    };
+
+    child.stderr.on('data', d => { stderr += String(d); });
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    rl.on('line', line => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch { return; }
+      attachSession(raw.session_id || raw.sessionId);
+      if (raw.type === 'thinking' && raw.subtype === 'delta') {
+        if (!thoughtOpen) {
+          thoughtOpen = true;
+          send({ type: 'thought_stream_start', agent: 'cursor', ts: Date.now() });
+        }
+        send({ type: 'thought_delta', data: raw.text || '', agent: 'cursor' });
+        return;
+      }
+      if (raw.type === 'thinking' && raw.subtype === 'completed' && thoughtOpen) {
+        thoughtOpen = false;
+        send({ type: 'thought_stream_end', agent: 'cursor' });
+        return;
+      }
+      if (raw.type === 'assistant') {
+        const text = textBlocks(raw.message);
+        for (const tool of toolBlocks(raw.message)) {
+          closeText();
+          const input = tool.input ?? tool.args ?? {};
+          send({ type: 'assistant', message: { content: [{ type: 'tool_use', name: tool.name || tool.toolName || 'tool', input }] }, agent: 'cursor' });
+          journal(home, sessionId, { type: 'tool', name: tool.name || tool.toolName || 'tool', input, ts: Date.now() });
+        }
+        // Cursor emits a final assistant message twice in stream-json mode.
+        // Deltas are authoritative; only emit a complete message if no delta
+        // was received for this exact response.
+        if (text && !emittedTexts.has(text)) {
+          emittedTexts.add(text);
+          if (!textOpen) emitDelta(text);
+          finalText = text;
+        }
+        return;
+      }
+      if (raw.type === 'result') {
+        closeText();
+        resultSeen = true;
+        if (raw.is_error || raw.subtype === 'error') {
+          send({ type: 'error', message: raw.result || raw.error || 'Cursor Agent turn failed', agent: 'cursor' });
+        } else {
+          const u = raw.usage || {};
+          const usage = {
+            input_tokens: u.inputTokens ?? u.input_tokens ?? 0,
+            output_tokens: u.outputTokens ?? u.output_tokens ?? 0,
+            cache_read_input_tokens: u.cacheReadTokens ?? u.cache_read_tokens ?? 0,
+            cache_write_input_tokens: u.cacheWriteTokens ?? u.cache_write_tokens ?? 0,
+          };
+          if (raw.result && !finalText) emitDelta(String(raw.result));
+          journal(home, sessionId, { type: 'result', usage, ts: Date.now() });
+          send({ type: 'result', is_error: false, usage, sessionId: sessionId || sessionKey, agent: 'cursor' });
+        }
+      } else if (raw.type === 'error') {
+        send({ type: 'error', message: raw.error?.message || raw.message || 'Cursor Agent error', agent: 'cursor' });
+      }
+    });
+
+    child.on('close', code => {
+      rl.close(); closeText();
+      if (thoughtOpen) send({ type: 'thought_stream_end', agent: 'cursor' });
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      if (aborted) send({ type: 'complete', exitCode: 130, aborted: true, sessionId: sessionId || sessionKey, agent: 'cursor' });
+      else {
+        if (code && !resultSeen) send({ type: 'error', message: stderr.trim() || `cursor-agent exited with code ${code}`, agent: 'cursor' });
+        send({ type: 'complete', exitCode: code || 0, sessionId: sessionId || sessionKey, agent: 'cursor' });
+      }
+      resolve();
+    });
+    child.on('error', error => {
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      send({ type: 'error', message: error.message, agent: 'cursor' });
+      resolve();
+    });
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref?.();
+    };
+  });
+}

package/src/agents/gemini.js

@@ -0,0 +1,182 @@
+import { spawn } from 'child_process';
+import { promises as fs } from 'fs';
+import path from 'path';
+import readline from 'readline';
+import crypto from 'crypto';
+
+// agy (the Antigravity/Gemini CLI) exposes its print mode as NDJSON.  Keeping a
+// small, UI-owned journal alongside its native SQLite conversation store gives
+// the web UI reliable history/search support without depending on the CLI's
+// private protobuf schema.
+function journalPath(geminiHome, sessionId) {
+  return path.join(geminiHome, 'claude-simple-ui', 'sessions', `${sessionId}.jsonl`);
+}
+
+function journal(geminiHome, sessionId, value) {
+  if (!sessionId) return;
+  const file = journalPath(geminiHome, sessionId);
+  fs.mkdir(path.dirname(file), { recursive: true })
+    .then(() => fs.appendFile(file, `${JSON.stringify(value)}\n`, 'utf8'))
+    .catch(() => {});
+}
+
+function isAutoApprove(options) {
+  return options.allowDangerouslySkipPermissions
+    || ['bypassPermissions', 'acceptEdits', 'auto'].includes(options.permissionMode);
+}
+
+function buildArgs(command, options) {
+  const args = ['--output-format', 'stream-json'];
+  if (options.sessionId) args.push('--conversation', options.sessionId);
+  if (options.model) args.push('--model', options.model);
+  if (options.effort && ['low', 'medium', 'high'].includes(options.effort)) {
+    args.push('--effort', options.effort);
+  }
+  // In print mode agy otherwise starts command tools in its scratch directory.
+  // Adding the requested project preserves normal agent access to the workspace.
+  if (options.cwd) args.push('--add-dir', options.cwd);
+  if (isAutoApprove(options)) args.push('--dangerously-skip-permissions');
+  else if (options.permissionMode === 'plan') args.push('--mode', 'plan');
+  else args.push('--mode', 'accept-edits');
+  args.push(`--prompt=${command || ''}`);
+  return args;
+}
+
+function toolInput(update) {
+  const info = update.tool_info || update.toolInfo || {};
+  return info.parameters || info.input || info.args || {};
+}
+
+/** Run a Gemini/Antigravity turn through `agy` print mode. */
+export function runGemini(command, options, send, { cliPath, geminiHome, activeSessions }) {
+  return new Promise(resolve => {
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const home = geminiHome || path.join(process.env.HOME || '', '.gemini');
+    const args = buildArgs(command, options);
+    // A resumed native conversation may predate the UI journal. Start recording
+    // from this turn so its subsequent history/search/usage is still complete.
+    if (options.sessionId) {
+      journal(home, options.sessionId, {
+        type: 'session_meta', sessionId: options.sessionId, cwd: options.cwd || null,
+        model: options.model || null, ts: Date.now(),
+      });
+      journal(home, options.sessionId, { type: 'user', content: command || '', ts: Date.now() });
+    }
+    let child;
+    try {
+      child = spawn(cliPath || 'agy', args, {
+        cwd: options.cwd || process.cwd(),
+        env: { ...process.env },
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      send({ type: 'error', message: `Failed to start agy: ${error.message}`, agent: 'gemini' });
+      resolve();
+      return;
+    }
+
+    const entry = {
+      kind: 'gemini', child, startTime: Date.now(), busy: true,
+      key: sessionKey, sessionId: options.sessionId || null,
+    };
+    activeSessions.set(sessionKey, entry);
+    let sessionId = options.sessionId || null;
+    let stderr = '';
+    let aborted = false;
+    let textOpen = false;
+    let resultSeen = false;
+
+    const closeText = () => {
+      if (!textOpen) return;
+      textOpen = false;
+      send({ type: 'assistant_stream_end', agent: 'gemini' });
+    };
+    const attachSession = id => {
+      if (!id || sessionId === id) return;
+      sessionId = id;
+      entry.sessionId = id;
+      activeSessions.set(id, entry);
+      if (!options.sessionId) send({ type: 'session-created', sessionId: id, agent: 'gemini' });
+      journal(home, id, {
+        type: 'session_meta', sessionId: id, cwd: options.cwd || null,
+        model: options.model || null, ts: Date.now(),
+      });
+      journal(home, id, { type: 'user', content: command || '', ts: Date.now() });
+    };
+    const usage = raw => ({
+      input_tokens: raw?.input_tokens ?? 0,
+      output_tokens: raw?.output_tokens ?? 0,
+      reasoning_tokens: raw?.thinking_tokens ?? 0,
+      cache_read_input_tokens: raw?.cache_read_tokens ?? 0,
+      total_tokens: raw?.total_tokens ?? 0,
+    });
+
+    child.stderr.on('data', d => { stderr += String(d); });
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+    rl.on('line', line => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch { return; }
+      const id = raw.conversation_id || raw.result?.conversation_id || raw.step_update?.conversation_id;
+      attachSession(id);
+
+      if (raw.event === 'step_update') {
+        const update = raw.step_update || {};
+        if (update.step_type === 'agent_response' && update.text_delta) {
+          if (!textOpen) {
+            textOpen = true;
+            send({ type: 'assistant_stream_start', agent: 'gemini', ts: Date.now() });
+          }
+          send({ type: 'assistant_delta', data: update.text_delta, agent: 'gemini' });
+          journal(home, sessionId, { type: 'assistant_delta', data: update.text_delta, ts: Date.now() });
+        }
+        if (update.step_type === 'tool' && update.state === 'ACTIVE') {
+          closeText();
+          const name = update.tool_name || update.toolName || update.tool_info?.name || 'tool';
+          const input = toolInput(update);
+          send({ type: 'assistant', message: { content: [{ type: 'tool_use', name, input }] }, agent: 'gemini' });
+          journal(home, sessionId, { type: 'tool', name, input, ts: Date.now() });
+        }
+        return;
+      }
+      if (raw.event === 'result') {
+        closeText();
+        resultSeen = true;
+        const result = raw.result || {};
+        const u = usage(result.usage);
+        journal(home, sessionId, { type: 'result', usage: u, ts: Date.now() });
+        if (String(result.status || '').toUpperCase() !== 'SUCCESS') {
+          send({ type: 'error', message: result.error || result.response || `Gemini turn ${result.status || 'failed'}`, agent: 'gemini' });
+        } else {
+          send({ type: 'result', is_error: false, usage: u, sessionId: sessionId || sessionKey, agent: 'gemini' });
+        }
+      } else if (raw.event === 'error') {
+        send({ type: 'error', message: raw.error?.message || raw.message || 'Gemini CLI error', agent: 'gemini' });
+      }
+    });
+
+    child.on('close', code => {
+      rl.close();
+      closeText();
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      if (aborted) send({ type: 'complete', exitCode: 130, aborted: true, sessionId: sessionId || sessionKey, agent: 'gemini' });
+      else {
+        if (code && !resultSeen) send({ type: 'error', message: stderr.trim() || `agy exited with code ${code}`, agent: 'gemini' });
+        send({ type: 'complete', exitCode: code || 0, sessionId: sessionId || sessionKey, agent: 'gemini' });
+      }
+      resolve();
+    });
+    child.on('error', error => {
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      send({ type: 'error', message: error.message, agent: 'gemini' });
+      resolve();
+    });
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref?.();
+    };
+  });
+}