claude-simple 0.1.0

package/server.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+import { createApp, init, PORT } from './src/app.js';
+
+await init();
+
+const { server } = createApp();
+
+server.listen(PORT, () => {
+  console.log(`\n  Claude Simple UI running at http://localhost:${PORT}\n`);
+  if (process.env.AUTH_USERNAME) console.log(`  Auth: env user "${process.env.AUTH_USERNAME}"`);
+  console.log();
+});

package/src/agents/claude.js

@@ -0,0 +1,58 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import crypto from 'crypto';
+
+/**
+ * Run a Claude Code turn via the agent SDK.
+ * Emits the same WS-facing messages as the original runClaude:
+ * session-created, assistant, result, complete, error (+ raw SDK msgs).
+ */
+export async function runClaude(command, options, send, { cliPath, activeSessions }) {
+  const sessionKey = options.sessionId || crypto.randomUUID();
+  const controller = new AbortController();
+  activeSessions.set(sessionKey, { controller, kind: 'claude', startTime: Date.now() });
+
+  const env = { ...process.env };
+  if (options.configDir) env.CLAUDE_CONFIG_DIR = options.configDir;
+
+  const sdkOptions = {
+    env,
+    pathToClaudeCodeExecutable: cliPath,
+    tools: { type: 'preset', preset: 'claude_code' },
+    systemPrompt: { type: 'preset', preset: 'claude_code' },
+    settingSources: ['project', 'user', 'local'],
+    model: options.model || 'claude-sonnet-4-5',
+    abortSignal: controller.signal,
+  };
+  if (options.cwd)       sdkOptions.cwd    = options.cwd;
+  if (options.sessionId) sdkOptions.resume = options.sessionId;
+  if (options.effort)    sdkOptions.effort = options.effort;
+  if (options.permissionMode && options.permissionMode !== 'default') {
+    sdkOptions.permissionMode = options.permissionMode;
+  }
+  if (options.allowDangerouslySkipPermissions) {
+    sdkOptions.allowDangerouslySkipPermissions = true;
+  }
+  if (options.allowedTools?.length) sdkOptions.allowedTools = options.allowedTools;
+
+  let capturedSessionId = null;
+
+  try {
+    const stream = query({ prompt: command, options: sdkOptions });
+    for await (const msg of stream) {
+      if (msg.type === 'system' && msg.session_id && !capturedSessionId) {
+        capturedSessionId = msg.session_id;
+        send({ type: 'session-created', sessionId: capturedSessionId, agent: 'claude' });
+      }
+      send(msg);
+    }
+    send({ type: 'complete', exitCode: 0, sessionId: capturedSessionId || sessionKey, agent: 'claude' });
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      send({ type: 'complete', exitCode: 130, aborted: true, sessionId: capturedSessionId || sessionKey, agent: 'claude' });
+    } else {
+      send({ type: 'error', message: err.message, agent: 'claude' });
+    }
+  } finally {
+    activeSessions.delete(sessionKey);
+  }
+}

package/src/agents/codex.js

@@ -0,0 +1,284 @@
+import { spawn } from 'child_process';
+import readline from 'readline';
+import crypto from 'crypto';
+
+/**
+ * Run OpenAI Codex CLI via `codex exec --json` (same approach as cc-connect).
+ * Multi-turn: first turn starts a thread; later turns use `exec resume <id>`.
+ *
+ * Emits normalized events the frontend already understands:
+ *   session-created, assistant (text), tool_use-style via assistant tool blocks,
+ *   result (usage), complete, error
+ */
+
+function mapPermissionToMode(permissionMode) {
+  switch (permissionMode) {
+    case 'acceptEdits':
+    case 'auto':
+      return 'full-auto';
+    case 'bypassPermissions':
+      return 'yolo';
+    default:
+      return 'suggest';
+  }
+}
+
+function buildArgs(options, isResume) {
+  const mode = options.mode || mapPermissionToMode(options.permissionMode);
+  const args = isResume
+    ? ['exec', 'resume', '--skip-git-repo-check']
+    : ['exec', '--skip-git-repo-check'];
+
+  // exec has no approval IPC → approval_policy=never; sandbox enforces safety.
+  // resume does not accept --sandbox, so use -c overrides instead.
+  switch (mode) {
+    case 'auto-edit':
+    case 'full-auto':
+      if (isResume) {
+        args.push('-c', 'sandbox_mode="workspace-write"', '-c', 'approval_policy="never"');
+      } else {
+        args.push('--sandbox', 'workspace-write', '-c', 'approval_policy="never"');
+      }
+      break;
+    case 'yolo':
+      args.push('--dangerously-bypass-approvals-and-sandbox');
+      break;
+    default: // suggest
+      if (isResume) {
+        args.push('-c', 'sandbox_mode="read-only"', '-c', 'approval_policy="never"');
+      } else {
+        args.push('--sandbox', 'read-only', '-c', 'approval_policy="never"');
+      }
+  }
+
+  if (options.model)  args.push('--model', options.model);
+  if (options.effort) args.push('-c', `model_reasoning_effort="${options.effort}"`);
+
+  if (isResume) {
+    args.push(options.sessionId, '--json', '-');
+  } else {
+    args.push('--json', '--cd', options.cwd || process.cwd(), '-');
+  }
+  return args;
+}
+
+function extractItemText(item) {
+  if (typeof item.text === 'string' && item.text) return item.text;
+  for (const key of ['content', 'output_text', 'summary', 'summary_text']) {
+    const v = item[key];
+    if (typeof v === 'string' && v) return v;
+    if (Array.isArray(v)) {
+      const parts = v
+        .map(p => (typeof p === 'string' ? p : p?.text || p?.output_text || ''))
+        .filter(Boolean);
+      if (parts.length) return parts.join('\n');
+    }
+  }
+  return '';
+}
+
+export function runCodex(command, options, send, { cliPath, activeSessions }) {
+  return new Promise((resolve) => {
+    const isResume = Boolean(options.sessionId);
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const args = buildArgs(options, isResume);
+    const bin = cliPath || 'codex';
+
+    const env = { ...process.env };
+    if (options.codexHome) env.CODEX_HOME = options.codexHome;
+
+    let child;
+    try {
+      child = spawn(bin, args, {
+        cwd: options.cwd || process.cwd(),
+        env,
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      send({ type: 'error', message: `Failed to start codex: ${e.message}`, agent: 'codex' });
+      resolve();
+      return;
+    }
+
+    const entry = { kind: 'codex', child, startTime: Date.now() };
+    activeSessions.set(sessionKey, entry);
+    // Also register under thread id once known so abort-session works
+    let threadId = options.sessionId || null;
+    let pendingText = [];
+    let aborted = false;
+    let stderr = '';
+
+    child.stdin.write(command || '');
+    child.stdin.end();
+
+    child.stderr.on('data', d => { stderr += d.toString(); });
+
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+
+    function flushText() {
+      // Dedupe identical bodies (CLI may emit agent_message + message for one turn)
+      const seen = new Set();
+      for (const text of pendingText) {
+        const t = text?.trim();
+        if (!t || seen.has(t)) continue;
+        seen.add(t);
+        // Stream-friendly: open bubble, dump text, close (codex emits completed items, not token deltas)
+        send({ type: 'assistant_stream_start', agent: 'codex', ts: Date.now() });
+        send({ type: 'assistant_delta', data: t, agent: 'codex' });
+        send({ type: 'assistant_stream_end', agent: 'codex' });
+      }
+      pendingText = [];
+    }
+
+    function handleItem(item, phase) {
+      if (!item || typeof item !== 'object') return;
+      const itemType = item.type;
+
+      if (itemType === 'agent_message' || itemType === 'message') {
+        if (phase === 'completed') {
+          const text = extractItemText(item)?.trim();
+          if (text && !pendingText.some(t => (t || '').trim() === text)) {
+            pendingText.push(text);
+          }
+        }
+        return;
+      }
+
+      if (itemType === 'reasoning') {
+        const text = extractItemText(item);
+        if (text && phase === 'completed') {
+          send({ type: 'assistant', message: { content: [{ type: 'text', text: `💭 ${text}` }] }, agent: 'codex' });
+        }
+        return;
+      }
+
+      if (itemType === 'command_execution') {
+        const command = item.command || '';
+        if (phase === 'started') {
+          send({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name: 'Bash', input: { command } }] },
+            agent: 'codex',
+          });
+        }
+        return;
+      }
+
+      if (itemType === 'function_call') {
+        const name = item.name || 'function';
+        let input = item.arguments;
+        try { input = typeof input === 'string' ? JSON.parse(input) : input; } catch { /* keep string */ }
+        if (phase === 'started' || phase === 'completed') {
+          send({
+            type: 'assistant',
+            message: { content: [{ type: 'tool_use', name, input: input ?? {} }] },
+            agent: 'codex',
+          });
+        }
+        return;
+      }
+
+      // Other known tools
+      const known = {
+        web_search: 'WebSearch',
+        file_search: 'FileSearch',
+        code_interpreter: 'CodeInterpreter',
+        mcp_tool: 'MCP',
+      };
+      if (known[itemType] && phase === 'completed') {
+        send({
+          type: 'assistant',
+          message: { content: [{ type: 'tool_use', name: known[itemType], input: item }] },
+          agent: 'codex',
+        });
+      }
+    }
+
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch { return; }
+
+      const eventType = raw.type;
+      switch (eventType) {
+        case 'thread.started': {
+          if (raw.thread_id) {
+            threadId = raw.thread_id;
+            activeSessions.set(threadId, entry);
+            send({ type: 'session-created', sessionId: threadId, agent: 'codex' });
+          }
+          break;
+        }
+        case 'turn.started':
+          pendingText = [];
+          break;
+        case 'item.started':
+          handleItem(raw.item, 'started');
+          break;
+        case 'item.completed':
+          handleItem(raw.item, 'completed');
+          break;
+        case 'turn.completed': {
+          flushText();
+          const u = raw.usage || {};
+          send({
+            type: 'result',
+            is_error: false,
+            usage: {
+              inputTokens: u.input_tokens || 0,
+              outputTokens: u.output_tokens || 0,
+              cacheReadInputTokens: u.cached_input_tokens || 0,
+            },
+            sessionId: threadId || sessionKey,
+            agent: 'codex',
+          });
+          break;
+        }
+        case 'turn.failed': {
+          const msg = raw.error?.message || raw.message || 'turn failed';
+          send({ type: 'error', message: msg, agent: 'codex' });
+          break;
+        }
+        case 'error': {
+          const msg = raw.message || 'codex error';
+          if (!/Reconnecting|Falling back/i.test(msg)) {
+            send({ type: 'error', message: msg, agent: 'codex' });
+          }
+          break;
+        }
+        default:
+          break;
+      }
+    });
+
+    child.on('close', (code) => {
+      rl.close();
+      activeSessions.delete(sessionKey);
+      if (threadId) activeSessions.delete(threadId);
+      if (aborted) {
+        send({ type: 'complete', exitCode: 130, aborted: true, sessionId: threadId || sessionKey, agent: 'codex' });
+      } else if (code !== 0 && code != null) {
+        const errMsg = stderr.trim() || `codex exited with code ${code}`;
+        // Avoid double-error if we already sent turn.failed
+        send({ type: 'complete', exitCode: code, sessionId: threadId || sessionKey, agent: 'codex', error: errMsg });
+        if (stderr.trim()) send({ type: 'error', message: errMsg, agent: 'codex' });
+      } else {
+        send({ type: 'complete', exitCode: 0, sessionId: threadId || sessionKey, agent: 'codex' });
+      }
+      resolve();
+    });
+
+    child.on('error', (e) => {
+      activeSessions.delete(sessionKey);
+      if (threadId) activeSessions.delete(threadId);
+      send({ type: 'error', message: e.message, agent: 'codex' });
+      resolve();
+    });
+
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000);
+    };
+  });
+}

package/src/agents/grok.js

@@ -0,0 +1,318 @@
+import { spawn } from 'child_process';
+import readline from 'readline';
+import crypto from 'crypto';
+
+/**
+ * Run Grok CLI headlessly with streaming-json over WebSocket (not HTTP SSE).
+ *
+ * New turn:
+ *   grok -p <prompt> --output-format streaming-json --cwd <dir> ...
+ * Resume:
+ *   grok --resume <sessionId> -p <prompt> --output-format streaming-json ...
+ *
+ * Stream events (line-delimited JSON):
+ *   { type: "thought", data: "..." }
+ *   { type: "text",    data: "..." }
+ *   { type: "tool_*",  ... }   // when CLI emits them
+ *   { type: "end", sessionId, usage, ... }
+ *
+ * We forward deltas immediately so the UI updates live instead of dumping at end.
+ */
+
+function mapPermission(permissionMode, allowBypass) {
+  if (allowBypass || permissionMode === 'bypassPermissions') return 'bypassPermissions';
+  if (permissionMode && permissionMode !== 'default') return permissionMode;
+  return null;
+}
+
+function buildArgs(command, options) {
+  const args = [];
+
+  if (options.sessionId) {
+    args.push('--resume', options.sessionId);
+  }
+
+  // -p = headless single-turn (required for non-TTY streaming-json)
+  args.push('-p', command || '');
+  args.push('--output-format', 'streaming-json');
+
+  if (options.cwd) args.push('--cwd', options.cwd);
+  if (options.model) args.push('--model', options.model);
+  if (options.effort) args.push('--reasoning-effort', options.effort);
+
+  const perm = mapPermission(options.permissionMode, options.allowDangerouslySkipPermissions);
+  if (perm) args.push('--permission-mode', perm);
+  if (options.allowDangerouslySkipPermissions || options.permissionMode === 'bypassPermissions') {
+    args.push('--always-approve');
+  }
+
+  if (options.newSessionId && !options.sessionId) {
+    args.push('--session-id', options.newSessionId);
+  }
+
+  return args;
+}
+
+function parseMaybeJson(v) {
+  if (v == null) return {};
+  if (typeof v === 'object') return v;
+  if (typeof v === 'string') {
+    try { return JSON.parse(v); } catch { return { input: v }; }
+  }
+  return { value: v };
+}
+
+export function runGrok(command, options, send, { cliPath, activeSessions }) {
+  return new Promise((resolve) => {
+    const sessionKey = options.sessionId || crypto.randomUUID();
+    const bin = cliPath || 'grok';
+    const args = buildArgs(command, options);
+
+    const env = { ...process.env };
+    env.CI = env.CI || '1';
+    // Reduce pipe buffering if the runtime honors it
+    env.PYTHONUNBUFFERED = '1';
+
+    let child;
+    try {
+      child = spawn(bin, args, {
+        cwd: options.cwd || process.cwd(),
+        env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (e) {
+      send({ type: 'error', message: `Failed to start grok: ${e.message}`, agent: 'grok' });
+      resolve();
+      return;
+    }
+
+    // Unbuffer stdout as much as possible
+    if (child.stdout?.setEncoding) child.stdout.setEncoding('utf8');
+
+    const entry = { kind: 'grok', child, startTime: Date.now() };
+    activeSessions.set(sessionKey, entry);
+
+    let sessionId = options.sessionId || null;
+    let aborted = false;
+    let stderr = '';
+    let gotEnd = false;
+    let streamOpen = false; // live assistant bubble on the client
+    let thoughtOpen = false;
+    let textChars = 0;
+    let thoughtChars = 0;
+
+    // Throttle thought deltas a bit (they're very chatty) but keep text live
+    let thoughtBuf = '';
+    let thoughtTimer = null;
+
+    child.stderr.on('data', d => { stderr += d.toString(); });
+
+    // Use 'readable' + line split for lower latency than waiting for large chunks
+    const rl = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+
+    function ensureStream() {
+      if (!streamOpen) {
+        send({ type: 'assistant_stream_start', agent: 'grok', ts: Date.now() });
+        streamOpen = true;
+      }
+    }
+
+    function endStream() {
+      if (streamOpen) {
+        send({ type: 'assistant_stream_end', agent: 'grok' });
+        streamOpen = false;
+      }
+    }
+
+    function flushThought(force = false) {
+      if (!thoughtBuf) return;
+      if (!force && thoughtBuf.length < 24) return;
+      if (!thoughtOpen) {
+        send({ type: 'thought_stream_start', agent: 'grok' });
+        thoughtOpen = true;
+      }
+      send({ type: 'thought_delta', data: thoughtBuf, agent: 'grok' });
+      thoughtChars += thoughtBuf.length;
+      thoughtBuf = '';
+    }
+
+    function scheduleThoughtFlush() {
+      if (thoughtTimer) return;
+      thoughtTimer = setTimeout(() => {
+        thoughtTimer = null;
+        flushThought(true);
+      }, 120);
+    }
+
+    function emitTool(raw) {
+      // Finalize any open text/thought before tool card
+      if (thoughtTimer) { clearTimeout(thoughtTimer); thoughtTimer = null; }
+      flushThought(true);
+      if (thoughtOpen) {
+        send({ type: 'thought_stream_end', agent: 'grok' });
+        thoughtOpen = false;
+      }
+      endStream();
+
+      const name = raw.name || raw.tool || raw.toolName || raw.tool_name
+        || raw.title || raw.data?.name || 'tool';
+      let input = raw.input ?? raw.arguments ?? raw.args ?? raw.rawInput
+        ?? raw.data?.input ?? raw.data?.arguments ?? raw.data ?? {};
+      input = parseMaybeJson(input);
+
+      send({
+        type: 'assistant',
+        message: { content: [{ type: 'tool_use', name, input }] },
+        agent: 'grok',
+        ts: Date.now(),
+      });
+    }
+
+    rl.on('line', (line) => {
+      if (!line.trim()) return;
+      let raw;
+      try { raw = JSON.parse(line); } catch {
+        // Non-JSON progress line — surface lightly
+        send({ type: 'status', message: line.slice(0, 200), agent: 'grok' });
+        return;
+      }
+
+      const t = String(raw.type || '').toLowerCase();
+
+      // ── Text tokens (stream immediately) ─────────────────────────────────
+      if ((t === 'text' || t === 'message' || t === 'output_text') && raw.data != null) {
+        if (thoughtTimer) { clearTimeout(thoughtTimer); thoughtTimer = null; }
+        flushThought(true);
+        if (thoughtOpen) {
+          send({ type: 'thought_stream_end', agent: 'grok' });
+          thoughtOpen = false;
+        }
+        const chunk = String(raw.data);
+        if (!chunk) return;
+        ensureStream();
+        textChars += chunk.length;
+        send({ type: 'assistant_delta', data: chunk, agent: 'grok' });
+        return;
+      }
+
+      // ── Thinking tokens (throttled stream) ───────────────────────────────
+      if ((t === 'thought' || t === 'thinking' || t === 'reasoning') && raw.data != null) {
+        thoughtBuf += String(raw.data);
+        scheduleThoughtFlush();
+        return;
+      }
+
+      // ── Tools ───────────────────────────────────────────────────────────
+      if (
+        t === 'tool_use' || t === 'tool_call' || t === 'tool_start'
+        || t === 'tool' || t === 'function_call' || t === 'tool_call_start'
+        || t.startsWith('tool_')
+      ) {
+        // Avoid treating tool_result as a new call
+        if (t === 'tool_result' || t === 'tool_call_update' || t === 'tool_end' || t === 'tool_call_end') {
+          return;
+        }
+        emitTool(raw);
+        return;
+      }
+
+      // ── Session id early (some builds emit before end) ───────────────────
+      if ((t === 'session' || t === 'session_started') && (raw.sessionId || raw.session_id)) {
+        sessionId = raw.sessionId || raw.session_id;
+        activeSessions.set(sessionId, entry);
+        if (!options.sessionId) {
+          send({ type: 'session-created', sessionId, agent: 'grok' });
+        }
+        return;
+      }
+
+      // ── End of turn ─────────────────────────────────────────────────────
+      if (t === 'end' || t === 'result' || t === 'done') {
+        gotEnd = true;
+        if (thoughtTimer) { clearTimeout(thoughtTimer); thoughtTimer = null; }
+        flushThought(true);
+        if (thoughtOpen) {
+          send({ type: 'thought_stream_end', agent: 'grok' });
+          thoughtOpen = false;
+        }
+        endStream();
+
+        if (raw.sessionId || raw.session_id) {
+          sessionId = raw.sessionId || raw.session_id;
+          activeSessions.set(sessionId, entry);
+          if (!options.sessionId) {
+            send({ type: 'session-created', sessionId, agent: 'grok' });
+          }
+        }
+
+        const u = raw.usage || {};
+        const costTicks = raw.total_cost_usd_ticks ?? u.cost_usd_ticks ?? u.costUsdTicks;
+        const costUSD = raw.total_cost_usd ?? u.cost_usd ?? u.costUSD
+          ?? (typeof costTicks === 'number' ? costTicks / 1e10 : undefined);
+
+        send({
+          type: 'result',
+          is_error: false,
+          usage: {
+            inputTokens: u.input_tokens || u.inputTokens || 0,
+            outputTokens: u.output_tokens || u.outputTokens || 0,
+            cacheReadInputTokens: u.cache_read_input_tokens || u.cachedReadTokens || 0,
+            totalTokens: u.total_tokens || u.totalTokens
+              || ((u.input_tokens || u.inputTokens || 0) + (u.output_tokens || u.outputTokens || 0)),
+            reasoningTokens: u.reasoning_tokens || u.reasoningTokens || 0,
+            costUSD,
+          },
+          sessionId: sessionId || sessionKey,
+          agent: 'grok',
+          stats: { textChars, thoughtChars },
+        });
+        return;
+      }
+
+      if (t === 'error') {
+        send({ type: 'error', message: raw.message || raw.data || 'grok error', agent: 'grok' });
+      }
+    });
+
+    child.on('close', (code) => {
+      if (thoughtTimer) { clearTimeout(thoughtTimer); thoughtTimer = null; }
+      flushThought(true);
+      if (thoughtOpen) send({ type: 'thought_stream_end', agent: 'grok' });
+      endStream();
+      rl.close();
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+
+      if (aborted) {
+        send({ type: 'complete', exitCode: 130, aborted: true, sessionId: sessionId || sessionKey, agent: 'grok' });
+      } else if (code !== 0 && code != null && !gotEnd) {
+        const errMsg = stderr.trim().split('\n').filter(l => !/stdin is not a terminal/i.test(l)).join('\n')
+          || `grok exited with code ${code}`;
+        send({ type: 'error', message: errMsg, agent: 'grok' });
+        send({ type: 'complete', exitCode: code, sessionId: sessionId || sessionKey, agent: 'grok' });
+      } else {
+        if (sessionId && !options.sessionId && !gotEnd) {
+          send({ type: 'session-created', sessionId, agent: 'grok' });
+        }
+        send({ type: 'complete', exitCode: code ?? 0, sessionId: sessionId || sessionKey, agent: 'grok' });
+      }
+      resolve();
+    });
+
+    child.on('error', (e) => {
+      activeSessions.delete(sessionKey);
+      if (sessionId) activeSessions.delete(sessionId);
+      send({ type: 'error', message: e.message, agent: 'grok' });
+      resolve();
+    });
+
+    entry.abort = () => {
+      aborted = true;
+      try { child.kill('SIGTERM'); } catch {}
+      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000);
+    };
+
+    // Tell UI a run started (typing indicator already on; optional status)
+    send({ type: 'status', message: 'Grok running…', agent: 'grok' });
+  });
+}