@yeaft/webchat-agent 0.0.2

package/sdk/query.js

@@ -0,0 +1,396 @@
+/**
+ * Main query implementation for Claude Code SDK
+ * Handles spawning Claude process and managing message streams
+ */
+
+import { spawn } from 'child_process';
+import { createInterface } from 'readline';
+import { Stream } from './stream.js';
+import { AbortError } from './types.js';
+import { getCleanEnv, logDebug, streamToStdin, resolveClaudeCommand } from './utils.js';
+
+
+/**
+ * Query class manages Claude Code process interaction
+ * Implements AsyncIterableIterator for streaming messages
+ */
+export class Query {
+  constructor(childStdin, childStdout, processExitPromise, canCallTool) {
+    this.pendingControlResponses = new Map();
+    this.cancelControllers = new Map();
+    this.inputStream = new Stream();
+    this.childStdin = childStdin;
+    this.childStdout = childStdout;
+    this.processExitPromise = processExitPromise;
+    this.canCallTool = canCallTool;
+    this.claudeSessionId = null;
+
+    this.readMessages();
+    this.sdkMessages = this.readSdkMessages();
+  }
+
+  /**
+   * Get the Claude session ID
+   */
+  getSessionId() {
+    return this.claudeSessionId;
+  }
+
+  /**
+   * Set an error on the stream
+   */
+  setError(error) {
+    this.inputStream.error(error);
+  }
+
+  /**
+   * AsyncIterableIterator implementation
+   */
+  next(...args) {
+    return this.sdkMessages.next(...args);
+  }
+
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: undefined });
+  }
+
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+
+  /**
+   * Read messages from Claude process stdout
+   */
+  async readMessages() {
+    const rl = createInterface({ input: this.childStdout });
+
+    try {
+      for await (const line of rl) {
+        if (line.trim()) {
+          try {
+            const message = JSON.parse(line);
+
+            // Capture session ID from system messages
+            if (message.type === 'system' && message.session_id) {
+              this.claudeSessionId = message.session_id;
+              logDebug(`Session ID captured: ${this.claudeSessionId}`);
+            }
+
+            if (message.type === 'control_response') {
+              const handler = this.pendingControlResponses.get(message.response.request_id);
+              if (handler) {
+                handler(message.response);
+              }
+              continue;
+            } else if (message.type === 'control_request') {
+              await this.handleControlRequest(message);
+              continue;
+            } else if (message.type === 'control_cancel_request') {
+              this.handleControlCancelRequest(message);
+              continue;
+            }
+
+            this.inputStream.enqueue(message);
+          } catch (e) {
+            logDebug(`Non-JSON line: ${line.substring(0, 100)}`);
+          }
+        }
+      }
+      await this.processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.inputStream.done();
+      this.cleanupControllers();
+      rl.close();
+    }
+  }
+
+  /**
+   * Async generator for SDK messages
+   */
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+
+  /**
+   * Send interrupt request to Claude
+   */
+  async interrupt() {
+    if (!this.childStdin) {
+      throw new Error('Interrupt requires --input-format stream-json');
+    }
+
+    await this.request({
+      subtype: 'interrupt'
+    }, this.childStdin);
+  }
+
+  /**
+   * Send a user message
+   */
+  sendMessage(content) {
+    if (!this.childStdin) {
+      throw new Error('sendMessage requires --input-format stream-json');
+    }
+
+    const msg = {
+      type: 'user',
+      message: {
+        role: 'user',
+        content: typeof content === 'string' ? content : content
+      }
+    };
+
+    this.childStdin.write(JSON.stringify(msg) + '\n');
+  }
+
+  /**
+   * Send control request to Claude process
+   */
+  request(request, childStdin) {
+    const requestId = Math.random().toString(36).substring(2, 15);
+    const sdkRequest = {
+      request_id: requestId,
+      type: 'control_request',
+      request
+    };
+
+    return new Promise((resolve, reject) => {
+      this.pendingControlResponses.set(requestId, (response) => {
+        if (response.subtype === 'success') {
+          resolve(response);
+        } else {
+          reject(new Error(response.error));
+        }
+      });
+
+      childStdin.write(JSON.stringify(sdkRequest) + '\n');
+    });
+  }
+
+  /**
+   * Handle incoming control requests for tool permissions
+   */
+  async handleControlRequest(request) {
+    if (!this.childStdin) {
+      logDebug('Cannot handle control request - no stdin available');
+      return;
+    }
+
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+
+    try {
+      const response = await this.processControlRequest(request, controller.signal);
+      const controlResponse = {
+        type: 'control_response',
+        response: {
+          subtype: 'success',
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlResponse) + '\n');
+    } catch (error) {
+      const controlErrorResponse = {
+        type: 'control_response',
+        response: {
+          subtype: 'error',
+          request_id: request.request_id,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlErrorResponse) + '\n');
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+
+  /**
+   * Handle control cancel requests
+   */
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+
+  /**
+   * Process control requests based on subtype
+   */
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === 'can_use_tool') {
+      if (!this.canCallTool) {
+        throw new Error('canCallTool callback is not provided.');
+      }
+      return this.canCallTool(request.request.tool_name, request.request.input, {
+        signal
+      });
+    }
+
+    throw new Error('Unsupported control request subtype: ' + request.request.subtype);
+  }
+
+  /**
+   * Cleanup method to abort all pending control requests
+   */
+  cleanupControllers() {
+    for (const [requestId, controller] of this.cancelControllers.entries()) {
+      controller.abort();
+      this.cancelControllers.delete(requestId);
+    }
+  }
+}
+
+/**
+ * Main query function to interact with Claude Code
+ * @param {object} config - Configuration object
+ * @param {string|AsyncIterable} config.prompt - The prompt or async iterable of messages
+ * @param {object} config.options - Query options
+ * @returns {Query} Query instance
+ */
+export function query(config) {
+  const {
+    prompt,
+    options: {
+      allowedTools = [],
+      appendSystemPrompt,
+      customSystemPrompt,
+      cwd,
+      disallowedTools = [],
+      maxTurns,
+      permissionMode = 'default',
+      continue: continueConversation,
+      resume,
+      model,
+      canCallTool,
+      abort
+    } = {}
+  } = config;
+
+  // Build command arguments
+  const args = ['--output-format', 'stream-json', '--verbose'];
+
+  if (customSystemPrompt) args.push('--system-prompt', customSystemPrompt);
+  if (appendSystemPrompt) args.push('--append-system-prompt', appendSystemPrompt);
+  if (maxTurns) args.push('--max-turns', maxTurns.toString());
+  if (model) args.push('--model', model);
+  if (canCallTool) {
+    if (typeof prompt === 'string') {
+      throw new Error('canCallTool callback requires --input-format stream-json. Please set prompt as an AsyncIterable.');
+    }
+    args.push('--permission-prompt-tool', 'stdio');
+  }
+  if (continueConversation) args.push('--continue');
+  if (resume) args.push('--resume', resume);
+  if (allowedTools.length > 0) args.push('--allowedTools', ...allowedTools);
+  if (disallowedTools.length > 0) args.push('--disallowedTools', ...disallowedTools);
+  if (permissionMode) args.push('--permission-mode', permissionMode);
+
+  // Handle prompt input
+  if (typeof prompt === 'string') {
+    args.push('--print', prompt.trim());
+  } else {
+    args.push('--input-format', 'stream-json');
+  }
+
+  const { command: claudeCommand, prefixArgs, spawnOpts } = resolveClaudeCommand();
+  const spawnEnv = getCleanEnv();
+
+  console.log(`[SDK] Spawning Claude Code:`);
+  console.log(`[SDK]   command: ${claudeCommand}`);
+  if (prefixArgs.length) console.log(`[SDK]   entrypoint: ${prefixArgs[0]}`);
+  console.log(`[SDK]   args: ${args.join(' ')}`);
+  console.log(`[SDK]   cwd: ${cwd}`);
+  if (spawnOpts.shell) console.log(`[SDK]   shell: ${spawnOpts.shell}`);
+  logDebug(`Spawning Claude Code: ${claudeCommand} ${[...prefixArgs, ...args].join(' ')}`);
+
+  const child = spawn(claudeCommand, [...prefixArgs, ...args], {
+    cwd,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    signal: abort,
+    env: spawnEnv,
+    windowsHide: true,
+    ...spawnOpts,
+  });
+
+  // Handle stdin
+  let childStdin = null;
+  if (typeof prompt === 'string') {
+    child.stdin.end();
+  } else {
+    streamToStdin(prompt, child.stdin, abort);
+    childStdin = child.stdin;
+  }
+
+  // Handle stderr - always capture for debugging
+  let stderrBuffer = '';
+  child.stderr.on('data', (data) => {
+    const text = data.toString();
+    stderrBuffer += text;
+    if (process.env.DEBUG) {
+      console.error('Claude Code stderr:', text);
+    }
+  });
+
+  // Setup cleanup
+  const cleanup = () => {
+    if (!child.killed) {
+      child.kill();
+    }
+  };
+
+  abort?.addEventListener('abort', cleanup);
+  process.on('exit', cleanup);
+
+  // Handle process exit
+  const processExitPromise = new Promise((resolve) => {
+    child.on('close', (code) => {
+      if (abort?.aborted) {
+        queryInstance.setError(new AbortError('Claude Code process aborted by user'));
+      }
+      if (code !== 0) {
+        const errorMsg = stderrBuffer ? `Claude Code process exited with code ${code}: ${stderrBuffer.trim()}` : `Claude Code process exited with code ${code}`;
+        console.error('[SDK] Process error:', errorMsg);
+        queryInstance.setError(new Error(errorMsg));
+      } else {
+        resolve();
+      }
+    });
+  });
+
+  // Create query instance
+  const queryInstance = new Query(childStdin, child.stdout, processExitPromise, canCallTool);
+
+  // Handle process errors
+  child.on('error', (error) => {
+    if (abort?.aborted) {
+      queryInstance.setError(new AbortError('Claude Code process aborted by user'));
+    } else {
+      queryInstance.setError(new Error(`Failed to spawn Claude Code process: ${error.message}`));
+    }
+  });
+
+  // Cleanup on exit
+  processExitPromise.finally(() => {
+    cleanup();
+    abort?.removeEventListener('abort', cleanup);
+  });
+
+  return queryInstance;
+}

package/sdk/stream.js

@@ -0,0 +1,112 @@
+/**
+ * Stream implementation for handling async message streams
+ * Provides an async iterable interface for processing SDK messages
+ */
+
+/**
+ * Generic async stream implementation
+ * Handles queuing, error propagation, and proper cleanup
+ */
+export class Stream {
+  constructor(returned) {
+    this.queue = [];
+    this.readResolve = undefined;
+    this.readReject = undefined;
+    this.isDone = false;
+    this.hasError = undefined;
+    this.started = false;
+    this.returned = returned;
+  }
+
+  /**
+   * Implements async iterable protocol
+   */
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error('Stream can only be iterated once');
+    }
+    this.started = true;
+    return this;
+  }
+
+  /**
+   * Gets the next value from the stream
+   */
+  async next() {
+    // Return queued items first
+    if (this.queue.length > 0) {
+      return Promise.resolve({
+        done: false,
+        value: this.queue.shift()
+      });
+    }
+
+    // Check terminal states
+    if (this.isDone) {
+      return Promise.resolve({ done: true, value: undefined });
+    }
+
+    if (this.hasError) {
+      return Promise.reject(this.hasError);
+    }
+
+    // Wait for new data
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
+    });
+  }
+
+  /**
+   * Adds a value to the stream
+   */
+  enqueue(value) {
+    if (this.readResolve) {
+      // Direct delivery to waiting consumer
+      const resolve = this.readResolve;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      resolve({ done: false, value });
+    } else {
+      // Queue for later consumption
+      this.queue.push(value);
+    }
+  }
+
+  /**
+   * Marks the stream as complete
+   */
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      resolve({ done: true, value: undefined });
+    }
+  }
+
+  /**
+   * Propagates an error through the stream
+   */
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = undefined;
+      this.readReject = undefined;
+      reject(error);
+    }
+  }
+
+  /**
+   * Implements async iterator cleanup
+   */
+  async return() {
+    this.isDone = true;
+    if (this.returned) {
+      this.returned();
+    }
+    return Promise.resolve({ done: true, value: undefined });
+  }
+}

package/sdk/types.js

@@ -0,0 +1,13 @@
+/**
+ * Error classes for Claude Code SDK integration
+ */
+
+/**
+ * Abort error for cancelled operations
+ */
+export class AbortError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AbortError';
+  }
+}

package/sdk/utils.js

@@ -0,0 +1,194 @@
+/**
+ * Utility functions for Claude Code SDK integration
+ * Path resolution, environment setup, and platform compatibility
+ */
+
+import { platform, homedir } from 'os';
+import { join, dirname } from 'path';
+import { existsSync, readFileSync } from 'fs';
+import { execSync } from 'child_process';
+
+/**
+ * Log debug message
+ */
+export function logDebug(message) {
+  if (process.env.DEBUG) {
+    console.log('[SDK Debug]', message);
+  }
+}
+
+/**
+ * Build the full PATH string with common bin directories included.
+ * Used by both getDefaultClaudeCodePath() and getCleanEnv().
+ */
+function getEnhancedPath() {
+  if (isWindows()) {
+    const systemPaths = [
+      'C:\\Windows\\system32',
+      'C:\\Windows',
+      'C:\\Windows\\System32\\Wbem'
+    ];
+    const currentPath = process.env.PATH || process.env.Path || '';
+    const pathParts = currentPath.split(';').filter(p => p);
+    for (const sp of systemPaths) {
+      if (!pathParts.some(p => p.toLowerCase() === sp.toLowerCase())) {
+        pathParts.push(sp);
+      }
+    }
+    return pathParts.join(';');
+  } else {
+    const unixPaths = [
+      '/usr/local/bin',
+      '/usr/bin',
+      '/bin',
+      '/usr/sbin',
+      join(homedir(), '.local', 'bin'),
+      join(homedir(), '.npm-global', 'bin'),
+    ];
+    if (platform() === 'darwin') {
+      unixPaths.push('/opt/homebrew/bin');
+    }
+    // Include the directory where the current node binary lives
+    // This catches nvm/fnm/volta managed node installs and their global bins
+    const nodeBinDir = join(process.execPath, '..');
+    unixPaths.push(nodeBinDir);
+
+    const currentPath = process.env.PATH || '';
+    const pathParts = currentPath.split(':').filter(p => p);
+    for (const sp of unixPaths) {
+      if (!pathParts.includes(sp)) {
+        pathParts.push(sp);
+      }
+    }
+    return pathParts.join(':');
+  }
+}
+
+/**
+ * Get default path to Claude Code executable
+ * Tries CLAUDE_PATH env var first, then checks common install locations,
+ * then auto-discovers via which/where with enhanced PATH.
+ */
+export function getDefaultClaudeCodePath() {
+  if (process.env.CLAUDE_PATH) return process.env.CLAUDE_PATH;
+
+  // Check common locations first (fast, no subprocess)
+  if (!isWindows()) {
+    const candidates = [
+      '/usr/local/bin/claude',
+      join(homedir(), '.local', 'bin', 'claude'),
+      join(homedir(), '.npm-global', 'bin', 'claude'),
+      // nvm/fnm/volta: claude installed globally lives next to node
+      join(process.execPath, '..', 'claude'),
+    ];
+    if (platform() === 'darwin') {
+      candidates.push('/opt/homebrew/bin/claude');
+    }
+    for (const c of candidates) {
+      if (existsSync(c)) return c;
+    }
+  }
+
+  // Try which/where with enhanced PATH (catches nvm, custom installs, etc.)
+  try {
+    const enhancedPath = getEnhancedPath();
+    const cmd = isWindows() ? 'where claude' : 'which claude';
+    const output = execSync(cmd, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 5000,
+      env: { ...process.env, PATH: enhancedPath }
+    }).toString().trim();
+    const lines = output.split('\n').map(l => l.trim()).filter(Boolean);
+
+    if (isWindows() && lines.length > 1) {
+      // On Windows, `where` may return multiple matches. Prefer .cmd/.exe over
+      // the extensionless Unix shell script that npm also creates.
+      const preferred = lines.find(l => /\.(cmd|exe)$/i.test(l));
+      if (preferred) return preferred;
+    }
+
+    if (lines[0]) return lines[0];
+  } catch {}
+
+  // Fallback: bare command, hope it's on PATH
+  return 'claude';
+}
+
+/**
+ * Create a clean environment
+ * Ensures necessary environment variables and PATH entries are present
+ */
+export function getCleanEnv() {
+  const env = { ...process.env };
+
+  if (isWindows()) {
+    if (!env.COMSPEC) {
+      env.COMSPEC = 'C:\\Windows\\system32\\cmd.exe';
+    }
+    if (!env.SystemRoot) {
+      env.SystemRoot = 'C:\\Windows';
+    }
+  }
+
+  env.PATH = getEnhancedPath();
+  return env;
+}
+
+/**
+ * Stream async messages to stdin
+ */
+export async function streamToStdin(stream, stdin, abort) {
+  for await (const message of stream) {
+    if (abort?.aborted) break;
+    stdin.write(JSON.stringify(message) + '\n');
+  }
+  stdin.end();
+}
+
+/**
+ * Check if running on Windows
+ */
+export function isWindows() {
+  return platform() === 'win32';
+}
+
+/**
+ * Resolve Claude executable into { command, prefixArgs, spawnOpts } for spawn().
+ * On Windows (npm install): parses .cmd wrapper to find cli.js, then calls node directly.
+ * This avoids cmd.exe flash and PowerShell script execution policy issues.
+ */
+export function resolveClaudeCommand() {
+  const execPath = getDefaultClaudeCodePath();
+
+  if (isWindows() && execPath.toLowerCase().endsWith('.cmd')) {
+    // npm 生成的 .cmd 内容固定格式，核心行是:
+    //   "%_prog%" "%dp0%\node_modules\@anthropic-ai\claude-code\cli.js" %*
+    // 解析出 cli.js 的相对路径，拼成绝对路径后用 node 直接调用
+    try {
+      const cmdContent = readFileSync(execPath, 'utf-8');
+      const match = cmdContent.match(/%dp0%\\(.+?\.js)"/i) ||
+                    cmdContent.match(/%dp0%\\(.+?\.js)/i);
+      if (match) {
+        const cliJsPath = join(dirname(execPath), match[1]);
+        if (existsSync(cliJsPath)) {
+          return {
+            command: process.execPath, // node
+            prefixArgs: [cliJsPath],
+            spawnOpts: {},
+          };
+        }
+      }
+    } catch {}
+    // 解析失败时 fallback: 用 powershell 执行 .ps1
+    const ps1Path = execPath.slice(0, -4) + '.ps1';
+    if (existsSync(ps1Path)) {
+      return {
+        command: 'powershell.exe',
+        prefixArgs: ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', ps1Path],
+        spawnOpts: {},
+      };
+    }
+  }
+
+  return { command: execPath, prefixArgs: [], spawnOpts: {} };
+}