@vibecheckai/cli 3.4.0 → 3.5.1

package/mcp-server/lib/executor.ts

@@ -0,0 +1,792 @@
+/**
+ * CLI/Core Execution Layer
+ * 
+ * Thin wrapper around CLI commands with:
+ * - Timeout handling
+ * - Cancellation support
+ * - Output parsing
+ * - Error normalization
+ * 
+ * CRITICAL: Windows-safe. No shell=true. Args array only.
+ * Zero Unix shell assumptions (no head/grep/sed/awk).
+ */
+
+import { spawn, ChildProcess, spawnSync } from 'child_process';
+import { join, dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+import { Errors, ErrorCode, VibecheckError, createErrorEnvelope, createSuccessEnvelope } from './errors.js';
+import { createSandbox } from './sandbox.js';
+import { getLogger } from './logger.js';
+import { getGlobalCache } from './cache.js';
+import { getMetricsCollector } from './metrics.js';
+import { generateRequestId } from './ids.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * CLI subcommands allowed - must be in registry
+ */
+const ALLOWED_SUBCOMMANDS = new Set([
+  'doctor', 'init', 'scan', 'ship', 'prove', 'reality',
+  'fix', 'guard', 'ctx', 'report', 'polish', 'status',
+  'share', 'badge', 'context', 'verify', 'gate',
+]);
+
+/**
+ * Default timeouts per tool (in ms)
+ */
+const DEFAULT_TIMEOUTS: Record<string, number> = {
+  doctor: 30000,
+  init: 60000,
+  scan: 120000,
+  ship: 90000,
+  prove: 600000,
+  reality: 300000,
+  fix: 300000,
+  guard: 60000,
+  ctx: 90000,
+  report: 60000,
+  polish: 60000,
+  status: 10000,
+  share: 30000,
+  badge: 10000,
+};
+
+/**
+ * Execution options
+ */
+export interface ExecuteOptions {
+  projectPath: string;
+  timeout?: number;
+  cacheMode?: 'auto' | 'force' | 'skip';
+  cacheMaxAge?: number;
+  requestId?: string;
+  signal?: AbortSignal;
+}
+
+/**
+ * Execution result
+ */
+export interface ExecuteResult<T> {
+  ok: boolean;
+  data?: T;
+  error?: {
+    code: ErrorCode;
+    message: string;
+  };
+  cached?: boolean;
+  durationMs: number;
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+}
+
+/**
+ * Active processes for cancellation
+ */
+const activeProcesses = new Map<string, ChildProcess>();
+
+/**
+ * Concurrency control
+ */
+const workspaceLocks = new Map<string, number>();
+const MAX_CONCURRENT_PER_WORKSPACE = 2;
+const MAX_CONCURRENT_GLOBAL = 6;
+let globalConcurrentCount = 0;
+
+/**
+ * Get CLI binary path
+ * 
+ * Searches multiple locations for the vibecheck CLI.
+ * Windows-safe: uses spawnSync with args array, no shell interpolation.
+ */
+function getCliBinPath(): string {
+  // Try multiple locations
+  const possiblePaths = [
+    join(__dirname, '..', '..', 'bin', 'vibecheck.js'),
+    join(__dirname, '..', '..', 'packages', 'cli', 'bin', 'vibecheck.js'),
+    join(__dirname, '..', '..', 'packages', 'cli', 'dist', 'standalone.js'),
+    join(__dirname, '..', '..', 'node_modules', '@vibecheckai', 'cli', 'bin', 'vibecheck.js'),
+    join(__dirname, '..', 'node_modules', '.bin', 'vibecheck'),
+  ];
+
+  for (const binPath of possiblePaths) {
+    const resolvedPath = resolve(binPath);
+    if (existsSync(resolvedPath)) {
+      // Verify it works - use args array, NOT shell string
+      try {
+        const result = spawnSync('node', [resolvedPath, '--version'], {
+          encoding: 'utf-8',
+          timeout: 5000,
+          shell: false, // CRITICAL: No shell
+          windowsHide: true,
+        });
+        if (result.status === 0) {
+          return resolvedPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  // Try global vibecheck
+  try {
+    const result = spawnSync(process.platform === 'win32' ? 'where' : 'which', ['vibecheck'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      shell: false,
+      windowsHide: true,
+    });
+    if (result.status === 0 && result.stdout) {
+      return result.stdout.trim().split('\n')[0];
+    }
+  } catch {
+    // Not found globally
+  }
+
+  throw new VibecheckError(
+    ErrorCode.DEPENDENCY_MISSING,
+    'vibecheck CLI not found. Run: npm install -g @vibecheckai/cli',
+    { userAction: 'Install the vibecheck CLI globally or in your project' }
+  );
+}
+
+/**
+ * Check if subcommand is allowed
+ */
+function validateSubcommand(command: string): void {
+  if (!ALLOWED_SUBCOMMANDS.has(command)) {
+    throw new VibecheckError(
+      ErrorCode.INVALID_INPUT,
+      `Unknown CLI subcommand: ${command}. Allowed: ${[...ALLOWED_SUBCOMMANDS].join(', ')}`,
+      { userAction: 'Use a valid vibecheck subcommand' }
+    );
+  }
+}
+
+/**
+ * Acquire concurrency slot
+ */
+async function acquireConcurrencySlot(workspace: string): Promise<void> {
+  // Check global limit
+  if (globalConcurrentCount >= MAX_CONCURRENT_GLOBAL) {
+    throw new VibecheckError(
+      ErrorCode.RATE_LIMITED,
+      `Global concurrency limit reached (${MAX_CONCURRENT_GLOBAL})`,
+      { retryable: true, retryAfterMs: 1000 }
+    );
+  }
+
+  // Check workspace limit
+  const workspaceCount = workspaceLocks.get(workspace) ?? 0;
+  if (workspaceCount >= MAX_CONCURRENT_PER_WORKSPACE) {
+    throw new VibecheckError(
+      ErrorCode.RATE_LIMITED,
+      `Workspace concurrency limit reached (${MAX_CONCURRENT_PER_WORKSPACE})`,
+      { retryable: true, retryAfterMs: 1000 }
+    );
+  }
+
+  // Acquire slot
+  globalConcurrentCount++;
+  workspaceLocks.set(workspace, workspaceCount + 1);
+}
+
+/**
+ * Release concurrency slot
+ */
+function releaseConcurrencySlot(workspace: string): void {
+  globalConcurrentCount = Math.max(0, globalConcurrentCount - 1);
+  const workspaceCount = workspaceLocks.get(workspace) ?? 0;
+  if (workspaceCount <= 1) {
+    workspaceLocks.delete(workspace);
+  } else {
+    workspaceLocks.set(workspace, workspaceCount - 1);
+  }
+}
+
+/**
+ * Parse JSON from CLI output
+ * 
+ * CLI output may contain ANSI codes, warnings, or other non-JSON lines.
+ * We extract the JSON object/array from the output.
+ */
+function parseJsonOutput<T>(stdout: string): T | null {
+  // Try direct parse first
+  try {
+    return JSON.parse(stdout) as T;
+  } catch {
+    // Try to extract JSON from output
+  }
+
+  // Find JSON object or array
+  const jsonMatch = stdout.match(/(\{[\s\S]*\}|\[[\s\S]*\])/);
+  if (jsonMatch) {
+    try {
+      return JSON.parse(jsonMatch[1]) as T;
+    } catch {
+      // Parse failed
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Execute a CLI command
+ * 
+ * CRITICAL: Uses spawn with args array. No shell=true. Windows-safe.
+ */
+export async function executeCli<T>(
+  command: string,
+  args: string[],
+  options: ExecuteOptions
+): Promise<ExecuteResult<T>> {
+  const logger = getLogger();
+  const metrics = getMetricsCollector();
+  const startTime = Date.now();
+  const requestId = options.requestId ?? generateRequestId();
+
+  // Validate subcommand
+  try {
+    validateSubcommand(command);
+  } catch (e) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.INVALID_INPUT, message: (e as Error).message },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Validate project path
+  const sandbox = createSandbox({ workspace: options.projectPath });
+  const validation = sandbox.validate(options.projectPath);
+  if (!validation.allowed) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.PATH_OUTSIDE_SANDBOX, message: validation.reason! },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Check cache
+  const cache = getGlobalCache();
+  const cacheKey = cache.generateKey(command, options.projectPath, { args });
+  
+  if (options.cacheMode !== 'skip') {
+    const cached = cache.get<T>(cacheKey);
+    if (cached.cached) {
+      const maxAge = (options.cacheMaxAge ?? 300) * 1000;
+      if (cached.age < maxAge) {
+        logger.debug('Cache hit', { command, cacheAge: cached.age });
+        metrics.recordToolExecution(`vibecheck.${command}`, Date.now() - startTime, true, true);
+        return {
+          ok: true,
+          data: cached.data,
+          cached: true,
+          durationMs: Date.now() - startTime,
+        };
+      }
+    }
+  }
+
+  // Acquire concurrency slot
+  try {
+    await acquireConcurrencySlot(options.projectPath);
+  } catch (e) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.RATE_LIMITED, message: (e as Error).message },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Build command
+  let binPath: string;
+  try {
+    binPath = getCliBinPath();
+  } catch (e) {
+    releaseConcurrencySlot(options.projectPath);
+    return {
+      ok: false,
+      error: { code: ErrorCode.DEPENDENCY_MISSING, message: (e as Error).message },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Build full args array - args array ONLY, no shell string interpolation
+  const fullArgs = [binPath, command, '--json', ...args];
+  const timeout = options.timeout ?? DEFAULT_TIMEOUTS[command] ?? 120000;
+
+  logger.info('Executing CLI', { command, args, timeout, requestId });
+
+  return new Promise((resolve) => {
+    let stdout = '';
+    let stderr = '';
+    let completed = false;
+    let timeoutId: NodeJS.Timeout | undefined;
+
+    // Spawn process - CRITICAL: shell: false (default, but explicit)
+    const child = spawn('node', fullArgs, {
+      cwd: options.projectPath,
+      env: {
+        ...process.env,
+        VIBECHECK_SKIP_AUTH: '1',
+        VIBECHECK_JSON_OUTPUT: '1',
+        VIBECHECK_REQUEST_ID: requestId,
+        // Don't pass through potentially dangerous vars
+        VIBECHECK_DANGEROUS: undefined,
+      },
+      shell: false, // CRITICAL: No shell
+      windowsHide: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    // Track for cancellation
+    activeProcesses.set(requestId, child);
+
+    // Handle abort signal
+    if (options.signal) {
+      options.signal.addEventListener('abort', () => {
+        if (!completed) {
+          child.kill('SIGTERM');
+          completed = true;
+          activeProcesses.delete(requestId);
+          releaseConcurrencySlot(options.projectPath);
+          clearTimeout(timeoutId);
+          
+          metrics.recordToolExecution(`vibecheck.${command}`, Date.now() - startTime, false, false);
+          resolve({
+            ok: false,
+            error: { code: ErrorCode.CANCELLED, message: 'Operation cancelled' },
+            durationMs: Date.now() - startTime,
+          });
+        }
+      });
+    }
+
+    // Collect output
+    child.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    // Handle timeout
+    timeoutId = setTimeout(() => {
+      if (!completed) {
+        child.kill('SIGTERM');
+        // Give process time to cleanup
+        setTimeout(() => {
+          if (!completed) {
+            child.kill('SIGKILL');
+          }
+        }, 1000);
+        
+        completed = true;
+        activeProcesses.delete(requestId);
+        releaseConcurrencySlot(options.projectPath);
+        
+        metrics.recordToolExecution(`vibecheck.${command}`, Date.now() - startTime, false, false);
+        resolve({
+          ok: false,
+          error: { code: ErrorCode.TIMEOUT, message: `Timeout after ${timeout}ms` },
+          durationMs: Date.now() - startTime,
+        });
+      }
+    }, timeout);
+
+    // Handle completion
+    child.on('close', (code: number | null) => {
+      clearTimeout(timeoutId);
+      if (completed) return;
+      completed = true;
+      activeProcesses.delete(requestId);
+      releaseConcurrencySlot(options.projectPath);
+
+      const durationMs = Date.now() - startTime;
+
+      // Try to parse JSON output
+      const data = parseJsonOutput<T>(stdout);
+      
+      if (code === 0 && data !== null) {
+        // Success
+        if (options.cacheMode !== 'skip') {
+          cache.set(cacheKey, data, { ttl: options.cacheMaxAge ?? 300 });
+        }
+        
+        logger.info('CLI completed', { command, code, durationMs });
+        metrics.recordToolExecution(`vibecheck.${command}`, durationMs, true, false);
+        
+        resolve({
+          ok: true,
+          data,
+          durationMs,
+          cached: false,
+          exitCode: code,
+          stdout,
+          stderr,
+        });
+        return;
+      }
+
+      if (code === 0 && data === null) {
+        // Success but no JSON output - return raw output
+        logger.info('CLI completed (no JSON)', { command, code, durationMs });
+        metrics.recordToolExecution(`vibecheck.${command}`, durationMs, true, false);
+        
+        resolve({
+          ok: true,
+          data: { output: stdout, exitCode: code } as unknown as T,
+          durationMs,
+          cached: false,
+          exitCode: code ?? undefined,
+          stdout,
+          stderr,
+        });
+        return;
+      }
+
+      // Non-zero exit
+      logger.warn('CLI failed', { command, code, stderr, durationMs });
+      metrics.recordToolExecution(`vibecheck.${command}`, durationMs, false, false);
+      
+      resolve({
+        ok: false,
+        error: {
+          code: ErrorCode.CLI_ERROR,
+          message: stderr || stdout || `CLI exited with code ${code}`,
+        },
+        durationMs,
+        exitCode: code ?? undefined,
+        stdout,
+        stderr,
+      });
+    });
+
+    child.on('error', (err: Error) => {
+      clearTimeout(timeoutId);
+      if (completed) return;
+      completed = true;
+      activeProcesses.delete(requestId);
+      releaseConcurrencySlot(options.projectPath);
+
+      logger.error('CLI error', err);
+      metrics.recordToolExecution(`vibecheck.${command}`, Date.now() - startTime, false, false);
+      
+      resolve({
+        ok: false,
+        error: { code: ErrorCode.CLI_ERROR, message: err.message },
+        durationMs: Date.now() - startTime,
+      });
+    });
+  });
+}
+
+/**
+ * Execute CLI synchronously (for simple commands)
+ * 
+ * CRITICAL: Uses spawnSync with args array. No shell. Windows-safe.
+ */
+export function executeCliSync<T>(
+  command: string,
+  args: string[],
+  options: ExecuteOptions
+): ExecuteResult<T> {
+  const startTime = Date.now();
+
+  // Validate subcommand
+  try {
+    validateSubcommand(command);
+  } catch (e) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.INVALID_INPUT, message: (e as Error).message },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  // Validate project path
+  const sandbox = createSandbox({ workspace: options.projectPath });
+  const validation = sandbox.validate(options.projectPath);
+  if (!validation.allowed) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.PATH_OUTSIDE_SANDBOX, message: validation.reason! },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  let binPath: string;
+  try {
+    binPath = getCliBinPath();
+  } catch (e) {
+    return {
+      ok: false,
+      error: { code: ErrorCode.DEPENDENCY_MISSING, message: (e as Error).message },
+      durationMs: Date.now() - startTime,
+    };
+  }
+
+  const fullArgs = [binPath, command, '--json', ...args];
+
+  try {
+    // CRITICAL: shell: false, args array
+    const result = spawnSync('node', fullArgs, {
+      cwd: options.projectPath,
+      encoding: 'utf-8',
+      timeout: options.timeout ?? DEFAULT_TIMEOUTS[command] ?? 120000,
+      maxBuffer: 10 * 1024 * 1024,
+      shell: false, // CRITICAL: No shell
+      windowsHide: true,
+      env: {
+        ...process.env,
+        VIBECHECK_SKIP_AUTH: '1',
+        VIBECHECK_JSON_OUTPUT: '1',
+      },
+    });
+
+    const durationMs = Date.now() - startTime;
+
+    if (result.error) {
+      return {
+        ok: false,
+        error: { code: ErrorCode.CLI_ERROR, message: result.error.message },
+        durationMs,
+      };
+    }
+
+    const stdout = result.stdout ?? '';
+    const data = parseJsonOutput<T>(stdout);
+
+    if (result.status === 0 && data !== null) {
+      return { ok: true, data, durationMs, exitCode: result.status };
+    }
+
+    if (result.status === 0) {
+      return {
+        ok: true,
+        data: { output: stdout } as unknown as T,
+        durationMs,
+        exitCode: result.status,
+      };
+    }
+
+    return {
+      ok: false,
+      error: {
+        code: ErrorCode.CLI_ERROR,
+        message: result.stderr || stdout || `CLI exited with code ${result.status}`,
+      },
+      durationMs,
+      exitCode: result.status ?? undefined,
+    };
+  } catch (err) {
+    const error = err as { message?: string; status?: number };
+    return {
+      ok: false,
+      error: {
+        code: ErrorCode.CLI_ERROR,
+        message: error.message || 'CLI execution failed',
+      },
+      durationMs: Date.now() - startTime,
+    };
+  }
+}
+
+/**
+ * Cancel a running command
+ */
+export function cancelExecution(requestId: string): boolean {
+  const child = activeProcesses.get(requestId);
+  if (child) {
+    child.kill('SIGTERM');
+    activeProcesses.delete(requestId);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Get count of active executions
+ */
+export function getActiveExecutionCount(): number {
+  return activeProcesses.size;
+}
+
+/**
+ * Get concurrency stats
+ */
+export function getConcurrencyStats(): {
+  global: number;
+  maxGlobal: number;
+  workspaces: Record<string, number>;
+  maxPerWorkspace: number;
+} {
+  const workspaces: Record<string, number> = {};
+  for (const [key, value] of workspaceLocks.entries()) {
+    workspaces[key] = value;
+  }
+  return {
+    global: globalConcurrentCount,
+    maxGlobal: MAX_CONCURRENT_GLOBAL,
+    workspaces,
+    maxPerWorkspace: MAX_CONCURRENT_PER_WORKSPACE,
+  };
+}
+
+/**
+ * Tool-specific executors
+ */
+export const ToolExecutors = {
+  async doctor(options: ExecuteOptions) {
+    return executeCli('doctor', [], options);
+  },
+
+  async scan(options: ExecuteOptions & { profile?: string; since?: string; baseline?: string }) {
+    const args: string[] = [];
+    if (options.profile) args.push(`--profile=${options.profile}`);
+    if (options.since) args.push(`--since=${options.since}`);
+    if (options.baseline) args.push(`--baseline=${options.baseline}`);
+    return executeCli('scan', args, options);
+  },
+
+  async ship(options: ExecuteOptions & { strict?: boolean; mockproof?: boolean; ci?: boolean }) {
+    const args: string[] = [];
+    if (options.strict) args.push('--strict');
+    if (options.mockproof !== false) args.push('--mockproof');
+    if (options.ci) args.push('--ci');
+    return executeCli('ship', args, options);
+  },
+
+  async prove(options: ExecuteOptions & { 
+    url?: string; 
+    auth?: string;
+    storageState?: string;
+    maxFixRounds?: number;
+    skipReality?: boolean;
+    skipFix?: boolean;
+  }) {
+    const args: string[] = [];
+    if (options.url) args.push(`--url=${options.url}`);
+    if (options.auth) args.push(`--auth=${options.auth}`);
+    if (options.storageState) args.push(`--storage-state=${options.storageState}`);
+    if (options.maxFixRounds) args.push(`--max-fix-rounds=${options.maxFixRounds}`);
+    if (options.skipReality) args.push('--skip-reality');
+    if (options.skipFix) args.push('--skip-fix');
+    return executeCli('prove', args, { ...options, timeout: options.timeout ?? 600000 });
+  },
+
+  async reality(options: ExecuteOptions & {
+    url: string;
+    auth?: string;
+    verifyAuth?: boolean;
+    storageState?: string;
+    maxPages?: number;
+    headed?: boolean;
+    recordVideo?: boolean;
+    recordTrace?: boolean;
+  }) {
+    const args: string[] = [`--url=${options.url}`];
+    if (options.auth) args.push(`--auth=${options.auth}`);
+    if (options.verifyAuth) args.push('--verify-auth');
+    if (options.storageState) args.push(`--storage-state=${options.storageState}`);
+    if (options.maxPages) args.push(`--max-pages=${options.maxPages}`);
+    if (options.headed) args.push('--headed');
+    if (options.recordVideo) args.push('--record-video');
+    if (options.recordTrace) args.push('--record-trace');
+    return executeCli('reality', args, { ...options, timeout: options.timeout ?? 300000 });
+  },
+
+  async fix(options: ExecuteOptions & {
+    apply?: boolean;
+    promptOnly?: boolean;
+    autopilot?: boolean;
+    maxMissions?: number;
+  }) {
+    const args: string[] = [];
+    if (options.apply) args.push('--apply');
+    if (options.promptOnly) args.push('--prompt-only');
+    if (options.autopilot) args.push('--autopilot');
+    if (options.maxMissions) args.push(`--max-missions=${options.maxMissions}`);
+    return executeCli('fix', args, { ...options, timeout: options.timeout ?? 300000 });
+  },
+
+  async guard(options: ExecuteOptions & {
+    claims?: boolean;
+    hallucinations?: boolean;
+    prompts?: boolean;
+    strict?: boolean;
+  }) {
+    const args: string[] = [];
+    if (options.claims) args.push('--claims');
+    if (options.hallucinations) args.push('--hallucinations');
+    if (options.prompts) args.push('--prompts');
+    if (options.strict) args.push('--strict');
+    return executeCli('guard', args, options);
+  },
+
+  async ctx(options: ExecuteOptions & { snapshot?: boolean; sync?: boolean }) {
+    const args: string[] = [];
+    if (options.snapshot) args.push('--snapshot');
+    if (options.sync) args.push('--sync');
+    return executeCli('ctx', args, options);
+  },
+
+  async report(options: ExecuteOptions & {
+    type?: string;
+    format?: string;
+    output?: string;
+    maxFindings?: number;
+  }) {
+    const args: string[] = [];
+    if (options.type) args.push(`--type=${options.type}`);
+    if (options.format) args.push(`--format=${options.format}`);
+    if (options.output) args.push(`--output=${options.output}`);
+    if (options.maxFindings) args.push(`--max-findings=${options.maxFindings}`);
+    return executeCli('report', args, options);
+  },
+
+  async polish(options: ExecuteOptions & { category?: string; fix?: boolean }) {
+    const args: string[] = [];
+    if (options.category) args.push(`--category=${options.category}`);
+    if (options.fix) args.push('--fix');
+    return executeCli('polish', args, options);
+  },
+
+  async status(options: ExecuteOptions) {
+    return executeCli('status', [], { ...options, timeout: options.timeout ?? 10000 });
+  },
+
+  async share(options: ExecuteOptions & { missionDir?: string }) {
+    const args: string[] = [];
+    if (options.missionDir) args.push(`--mission-dir=${options.missionDir}`);
+    return executeCli('share', args, options);
+  },
+
+  async badge(options: ExecuteOptions & { format?: string; style?: string }) {
+    const args: string[] = [];
+    if (options.format) args.push(`--format=${options.format}`);
+    if (options.style) args.push(`--style=${options.style}`);
+    return executeCli('badge', args, { ...options, timeout: options.timeout ?? 10000 });
+  },
+
+  async init(options: ExecuteOptions & { force?: boolean }) {
+    const args: string[] = [];
+    if (options.force) args.push('--force');
+    return executeCli('init', args, options);
+  },
+};
+
+export default {
+  executeCli,
+  executeCliSync,
+  cancelExecution,
+  getActiveExecutionCount,
+  getConcurrencyStats,
+  ToolExecutors,
+};