@vibelet/cli 0.1.34 → 0.1.36

package/src/drivers/claude.ts

@@ -0,0 +1,443 @@
+import { spawn, type ChildProcess } from 'child_process';
+import { existsSync } from 'fs';
+import type { Driver, MessageHandler } from './types.js';
+import { config } from '../config.js';
+import { logger as rootLogger } from '../logger.js';
+import { audit } from '../audit.js';
+import { cleanupClaudeHookFiles, createClaudeHookFiles, type ClaudeHookFiles } from '../claude-hooks.js';
+import { writeStderrSafe } from '../safe-stdio.js';
+
+const log = rootLogger.child({ module: 'claude' });
+export const CLAUDE_SYNTHETIC_APPROVAL_PREFIX = 'claude-permission-denial:';
+const ANSI_ESCAPE_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+
+function shouldLogRemote(): boolean {
+  return process.env.VIBE_TEST !== '1' && !process.argv.includes('--test');
+}
+
+function logRemote(message: string): void {
+  if (!shouldLogRemote()) return;
+  writeStderrSafe(`\x1b[33m⚡ [Vibelet] ${message}\x1b[0m\n`);
+}
+
+function extractStructuredToolResultText(content: unknown): string {
+  if (!Array.isArray(content)) return '';
+  return content
+    .map((item) => {
+      if (!item || typeof item !== 'object') return '';
+      if (typeof (item as any).text === 'string') return (item as any).text;
+      if (typeof (item as any).content === 'string') return (item as any).content;
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+}
+
+function isToolReferenceOnlyContent(content: unknown): boolean {
+  return Array.isArray(content)
+    && content.length > 0
+    && content.every((item) => item && typeof item === 'object' && (item as any).type === 'tool_reference');
+}
+
+function stringifyToolResult(content: unknown): string {
+  if (typeof content === 'string') return content;
+  const extracted = extractStructuredToolResultText(content);
+  if (extracted) return extracted;
+  if (isToolReferenceOnlyContent(content)) return '';
+  return JSON.stringify(content);
+}
+
+function looksLikePermissionDenial(message: string): boolean {
+  return /requested permissions|haven't granted/i.test(message);
+}
+
+function sanitizeClaudeErrorText(text: string): string {
+  return text
+    .replace(ANSI_ESCAPE_PATTERN, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function isGenericClaudeErrorText(text: string): boolean {
+  const normalized = text.toLowerCase();
+  return normalized === 'error' || normalized === 'failed' || normalized === 'unknown error';
+}
+
+function looksLikeClaudeUsageLimit(text: string): boolean {
+  return (
+    /\brate limit\b/i.test(text) ||
+    /\busage limit\b/i.test(text) ||
+    /\bquota\b/i.test(text) ||
+    /\btoo many requests\b/i.test(text) ||
+    /\bcredit balance\b/i.test(text) ||
+    /\bcredits? remaining\b/i.test(text) ||
+    /\bmax(?:imum)? usage\b/i.test(text)
+  );
+}
+
+function formatClaudeUsageLimitMessage(detail: string): string {
+  return detail.toLowerCase().startsWith('claude ')
+    ? detail
+    : `Claude usage limit reached. ${detail}`;
+}
+
+function formatClaudeFailureMessage(options: {
+  resultText?: string;
+  stderrLines?: string[];
+  exitCode?: number | null;
+}): string {
+  const normalizedResult = sanitizeClaudeErrorText(options.resultText ?? '');
+  const stderrDetails = (options.stderrLines ?? [])
+    .map(sanitizeClaudeErrorText)
+    .filter(Boolean)
+    .slice(-3);
+  const limitDetail = [normalizedResult, ...stderrDetails].find(
+    (text) => Boolean(text) && looksLikeClaudeUsageLimit(text),
+  );
+
+  if (limitDetail) {
+    return formatClaudeUsageLimitMessage(limitDetail);
+  }
+
+  const detail = [normalizedResult, ...stderrDetails].find(
+    (text) => Boolean(text) && !isGenericClaudeErrorText(text),
+  );
+  if (detail) {
+    if (options.exitCode != null && detail !== normalizedResult) {
+      return `Claude exited with code ${options.exitCode}: ${detail}`;
+    }
+    return detail;
+  }
+
+  if (options.exitCode != null) {
+    return `Claude exited with code ${options.exitCode}`;
+  }
+  return 'Claude returned an error result.';
+}
+
+export function isClaudeSyntheticApprovalRequestId(requestId: string): boolean {
+  return requestId.startsWith(CLAUDE_SYNTHETIC_APPROVAL_PREFIX);
+}
+
+export class ClaudeDriver implements Driver {
+  private proc: ChildProcess | null = null;
+  private handler: MessageHandler | null = null;
+  private sessionId = '';
+  private buffer = '';
+  private cwd = '';
+  private approvalMode?: string;
+  private sawFinalResult = false;
+  private interrupted = false;
+  private exitHandler: ((code: number | null) => void) | null = null;
+  private lastStderr: string[] = [];
+  private pendingPermissionDescriptions = new Map<string, string>();
+  private emittedToolCallIds = new Set<string>();
+  /** True while the CLI is replaying old messages before the new response starts. */
+  private replayPhase = false;
+  private hookPort: number | null = null;
+  private hookSecret: string | null = null;
+  private hookFiles: ClaudeHookFiles | null = null;
+
+  private buildClaudeEnv(): Record<string, string> {
+    const env = config.buildSanitizedEnv();
+    for (const key of Object.keys(env)) {
+      if (key.startsWith('CMUX_')) {
+        delete env[key];
+      }
+    }
+    return env;
+  }
+
+  async start(cwd: string, resumeSessionId?: string, approvalMode?: string): Promise<string> {
+    this.cwd = cwd;
+    this.approvalMode = approvalMode;
+    if (resumeSessionId) this.sessionId = resumeSessionId;
+    if (!this.sessionId) this.sessionId = `pending_${Date.now()}`;
+    log.info({ sessionId: this.sessionId, cwd }, 'session initialized');
+    audit.emit('driver.spawn', { agent: 'claude', sessionId: this.sessionId, cwd });
+    return this.sessionId;
+  }
+
+  configureHookBridge(port: number, secret: string): void {
+    this.hookPort = port;
+    this.hookSecret = secret;
+  }
+
+  sendPrompt(text: string): void {
+    const args = [
+      '-p', text,
+      '--output-format', 'stream-json',
+      '--verbose',
+      '--include-partial-messages',
+    ];
+
+    if (this.sessionId && !this.sessionId.startsWith('pending_')) {
+      args.push('--resume', this.sessionId);
+    }
+
+    cleanupClaudeHookFiles(this.hookFiles);
+    this.hookFiles = null;
+
+    if (this.approvalMode !== 'plan' && this.approvalMode !== 'acceptEdits' && this.approvalMode !== 'autoApprove' && this.hookPort && this.hookSecret) {
+      this.hookFiles = createClaudeHookFiles(this.hookPort, this.hookSecret);
+      args.push('--settings', this.hookFiles.settingsPath);
+    }
+
+    if (this.approvalMode === 'plan') args.push('--permission-mode', 'plan');
+    if (this.approvalMode === 'acceptEdits') args.push('--permission-mode', 'acceptEdits');
+    if (this.approvalMode === 'autoApprove') args.push('--dangerously-skip-permissions');
+
+    const label = this.sessionId.startsWith('pending_') ? '(new)' : `(resume ${this.sessionId.slice(0, 8)})`;
+    log.info({ sessionId: this.sessionId, label, promptPreview: text.slice(0, 50) }, 'running claude');
+    logRemote( `New message: ${text.slice(0, 60)}`);
+    this.sawFinalResult = false;
+    this.interrupted = false;
+    this.lastStderr = [];
+    this.pendingPermissionDescriptions.clear();
+    this.emittedToolCallIds.clear();
+    this.replayPhase = true;
+
+    this.proc = spawn(config.claudePath, args, {
+      cwd: this.cwd || undefined,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: this.buildClaudeEnv(),
+      ...(process.platform === 'win32' ? { shell: true } : {}),
+    });
+
+    this.proc.on('error', (err) => {
+      let message = err.message;
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT' && this.cwd && !existsSync(this.cwd)) {
+        message = `Working directory does not exist: ${this.cwd}`;
+      }
+      log.error({ sessionId: this.sessionId, error: message, cwd: this.cwd }, 'spawn error');
+      audit.emit('driver.error', { agent: 'claude', sessionId: this.sessionId, error: message });
+      this.handler?.({ type: 'error', sessionId: this.sessionId, message });
+    });
+
+    this.buffer = '';
+    this.proc.stdout!.on('data', (chunk: Buffer) => {
+      this.buffer += chunk.toString();
+      const lines = this.buffer.split('\n');
+      this.buffer = lines.pop()!;
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          this.handleRaw(JSON.parse(line));
+        } catch {
+          log.warn({ sessionId: this.sessionId, linePreview: line.slice(0, 100) }, 'failed to parse stdout line');
+        }
+      }
+    });
+
+    this.proc.stderr!.on('data', (chunk: Buffer) => {
+      const t = chunk.toString().trim();
+      if (t) {
+        log.debug({ sessionId: this.sessionId, stderr: t }, 'stderr');
+        this.lastStderr.push(t);
+        if (this.lastStderr.length > 10) this.lastStderr.shift();
+      }
+    });
+
+    this.proc.on('exit', (code, signal) => {
+      log.info({ sessionId: this.sessionId, exitCode: code, signal }, 'process exited');
+      const wasInterrupted = this.interrupted;
+      this.proc = null;
+      cleanupClaudeHookFiles(this.hookFiles);
+      this.hookFiles = null;
+      this.interrupted = false;
+      if (wasInterrupted && !this.sawFinalResult) {
+        this.handler?.({ type: 'session.interrupted', sessionId: this.sessionId });
+      } else if (code && code !== 0 && !this.sawFinalResult) {
+        log.error({ sessionId: this.sessionId, exitCode: code, lastStderr: this.lastStderr.slice(-3) }, 'abnormal exit');
+        this.handler?.({
+          type: 'error',
+          sessionId: this.sessionId,
+          message: formatClaudeFailureMessage({ stderrLines: this.lastStderr, exitCode: code }),
+        });
+      }
+      this.exitHandler?.(code);
+    });
+  }
+
+  respondApproval(requestId: string, approved: boolean): boolean {
+    log.info({ sessionId: this.sessionId, requestId, approved }, 'approval response');
+    if (!this.proc?.stdin?.writable) {
+      log.error({ sessionId: this.sessionId }, 'cannot send approval: stdin not writable');
+      return false;
+    }
+    const response = JSON.stringify({
+      type: 'control_response',
+      request_id: requestId,
+      permission_granted: approved,
+    });
+    this.proc.stdin.write(response + '\n');
+    return true;
+  }
+
+  setApprovalMode(mode: string): void {
+    this.approvalMode = mode;
+    log.info({ sessionId: this.sessionId, approvalMode: mode }, 'approval mode updated');
+  }
+
+  interrupt(): void {
+    if (this.proc && !this.proc.killed) {
+      this.interrupted = true;
+      this.proc.kill('SIGTERM');
+      log.info({ sessionId: this.sessionId }, 'interrupted');
+    }
+  }
+
+  stop(): void {
+    if (!this.proc) return;
+    this.proc.kill('SIGTERM');
+    const p = this.proc;
+    setTimeout(() => { if (!p.killed) p.kill('SIGKILL'); }, 5000).unref();
+    this.proc = null;
+    cleanupClaudeHookFiles(this.hookFiles);
+    this.hookFiles = null;
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.handler = handler;
+  }
+
+  onExit(handler: (code: number | null) => void): void {
+    this.exitHandler = handler;
+  }
+
+  private handleRaw(raw: Record<string, unknown>): void {
+    const type = raw.type as string;
+
+    if (type === 'system' && (raw as any).subtype === 'init') {
+      const newId = (raw as any).session_id ?? '';
+      if (newId && newId !== this.sessionId) {
+        log.info({ oldSessionId: this.sessionId, newSessionId: newId }, 'session ID resolved');
+        audit.emit('driver.init', { agent: 'claude', sessionId: newId });
+        this.sessionId = newId;
+      }
+      return;
+    }
+
+    if (!this.handler) return;
+
+    switch (type) {
+      case 'assistant': {
+        if (this.replayPhase) break; // skip replayed history from --include-partial-messages
+        const content = (raw as any).message?.content;
+        if (!Array.isArray(content)) break;
+        for (const block of content) {
+          if (block.type === 'tool_use' && !this.emittedToolCallIds.has(block.id)) {
+            this.emittedToolCallIds.add(block.id);
+            this.handler({
+              type: 'tool.call', sessionId: this.sessionId,
+              toolName: block.name, input: block.input ?? {}, toolCallId: block.id,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'user': {
+        if (this.replayPhase) break; // skip replayed history from --include-partial-messages
+        const content = (raw as any).message?.content;
+        if (!Array.isArray(content)) break;
+        for (const block of content) {
+          if (block.type === 'tool_result') {
+            const output = stringifyToolResult(block.content);
+            if (!output) continue;
+            if (block.is_error === true && typeof block.tool_use_id === 'string' && looksLikePermissionDenial(output)) {
+              this.pendingPermissionDescriptions.set(block.tool_use_id, output);
+              continue;
+            }
+            this.handler({
+              type: 'tool.result', sessionId: this.sessionId,
+              toolCallId: block.tool_use_id, output,
+            });
+          }
+        }
+        break;
+      }
+
+      case 'control_request': {
+        this.replayPhase = false;
+        const req = (raw as any).request;
+        if (req?.subtype === 'can_use_tool') {
+          audit.emit('approval.request', { agent: 'claude', sessionId: this.sessionId, toolName: req.tool_name });
+          this.handler({
+            type: 'approval.request', sessionId: this.sessionId,
+            requestId: (raw as any).request_id,
+            toolName: req.tool_name ?? 'unknown',
+            input: req.input ?? {},
+            description: req.description ?? req.title ?? '',
+          });
+        }
+        break;
+      }
+
+      case 'stream_event': {
+        this.replayPhase = false; // stream events only come from the new response
+        const event = (raw as any).event;
+        if (event?.type === 'content_block_delta' && event?.delta?.type === 'text_delta' && event?.delta?.text) {
+          this.handler({ type: 'text.delta', sessionId: this.sessionId, content: event.delta.text });
+        }
+        break;
+      }
+
+      case 'result': {
+        this.replayPhase = false;
+        this.sawFinalResult = true;
+        const resultText = typeof (raw as any).result === 'string'
+          ? (raw as any).result
+          : '';
+        if ((raw as any).is_error) {
+          logRemote( 'Claude failed.');
+          this.handler({
+            type: 'error',
+            sessionId: this.sessionId,
+            message: formatClaudeFailureMessage({ resultText, stderrLines: this.lastStderr }),
+          });
+          break;
+        }
+        const permissionDenials = Array.isArray((raw as any).permission_denials)
+          ? (raw as any).permission_denials as Array<Record<string, unknown>>
+          : [];
+        if (permissionDenials.length > 0) {
+          const firstDenial = permissionDenials[0] ?? {};
+          const toolUseId = typeof firstDenial.tool_use_id === 'string'
+            ? firstDenial.tool_use_id
+            : `missing_${Date.now()}`;
+          const toolName = typeof firstDenial.tool_name === 'string'
+            ? firstDenial.tool_name
+            : 'unknown';
+          const input = firstDenial.tool_input && typeof firstDenial.tool_input === 'object'
+            ? firstDenial.tool_input as Record<string, unknown>
+            : {};
+          const description = this.pendingPermissionDescriptions.get(toolUseId)
+            ?? `Claude requested permissions to use ${toolName}.`;
+          audit.emit('approval.request', { agent: 'claude', sessionId: this.sessionId, toolName });
+          this.handler({
+            type: 'approval.request',
+            sessionId: this.sessionId,
+            requestId: `${CLAUDE_SYNTHETIC_APPROVAL_PREFIX}${toolUseId}`,
+            toolName,
+            input,
+            description,
+          });
+        }
+        this.pendingPermissionDescriptions.clear();
+        const cost = (raw as any).total_cost_usd;
+        const usage = (raw as any).usage
+          ? { inputTokens: (raw as any).usage.input_tokens, outputTokens: (raw as any).usage.output_tokens }
+          : undefined;
+        logRemote( 'Claude finished. Run `claude --continue` to continue on desktop.');
+        audit.emit('session.done', { agent: 'claude', sessionId: this.sessionId, cost, usage });
+        this.handler({
+          type: 'session.done', sessionId: this.sessionId,
+          cost,
+          usage,
+        });
+        break;
+      }
+    }
+  }
+}