cli4ai 1.2.0 → 1.2.1

package/src/commands/routines.ts

@@ -1,427 +0,0 @@
-/**
- * cli4ai routines - Manage and run routines
- */
-
-import { spawn, spawnSync } from 'child_process';
-import { readFileSync, writeFileSync, existsSync, chmodSync, rmSync } from 'fs';
-import { resolve } from 'path';
-import { stringify as stringifyYaml } from 'yaml';
-import { output, outputError, log } from '../lib/cli.js';
-import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from '../core/config.js';
-import { getGlobalRoutines, getLocalRoutines, resolveRoutine, validateRoutineName, type RoutineInfo } from '../core/routines.js';
-import { loadRoutineDefinition, dryRunRoutine, runRoutine, RoutineParseError, RoutineValidationError, RoutineTemplateError } from '../core/routine-engine.js';
-
-interface RoutinesListOptions {
-  global?: boolean;
-  json?: boolean;
-}
-
-interface RoutinesRunOptions {
-  global?: boolean;
-  var?: string[];
-  dryRun?: boolean;
-}
-
-interface RoutinesCreateOptions {
-  global?: boolean;
-  type?: 'yaml' | 'json' | 'bash';
-}
-
-function ensureValidRoutineName(name: string): void {
-  try {
-    validateRoutineName(name);
-  } catch (err) {
-    outputError('INVALID_INPUT', err instanceof Error ? err.message : String(err), { name });
-  }
-}
-
-function normalizeEnvSegment(value: string): string {
-  return value
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z0-9]+/g, '_')
-    .replace(/^_+|_+$/g, '');
-}
-
-function parseVars(vars: string[] | undefined): Record<string, string> {
-  const result: Record<string, string> = {};
-  if (!vars) return result;
-
-  for (const entry of vars) {
-    const eq = entry.indexOf('=');
-    if (eq <= 0) {
-      outputError('INVALID_INPUT', `Invalid --var (expected KEY=value): ${entry}`);
-    }
-    const key = entry.slice(0, eq).trim();
-    const value = entry.slice(eq + 1);
-    if (!key) {
-      outputError('INVALID_INPUT', `Invalid --var (empty key): ${entry}`);
-    }
-    result[key] = value;
-  }
-
-  return result;
-}
-
-function varsToEnv(vars: Record<string, string>): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const [key, value] of Object.entries(vars)) {
-    const envKey = `CLI4AI_VAR_${normalizeEnvSegment(key)}`;
-    env[envKey] = value;
-  }
-  return env;
-}
-
-function collectStream(stream: NodeJS.ReadableStream): Promise<string> {
-  return new Promise((resolve, reject) => {
-    const chunks: Buffer[] = [];
-    stream.on('data', (chunk) => chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk))));
-    stream.on('error', reject);
-    stream.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
-  });
-}
-
-export async function routinesListCommand(options: RoutinesListOptions): Promise<void> {
-  const local = options.global ? [] : getLocalRoutines(process.cwd());
-  const global = getGlobalRoutines();
-
-  const routines: RoutineInfo[] = [];
-  const seen = new Set<string>();
-
-  for (const r of local) {
-    routines.push(r);
-    seen.add(r.name);
-  }
-
-  for (const r of global) {
-    if (!seen.has(r.name)) {
-      routines.push(r);
-      seen.add(r.name);
-    }
-  }
-
-  if (options.json || !process.stdout.isTTY) {
-    output({
-      routines: routines.map(r => ({
-        name: r.name,
-        kind: r.kind,
-        scope: r.scope,
-        path: r.path
-      })),
-      count: routines.length
-    });
-    return;
-  }
-
-  if (routines.length === 0) {
-    console.log('No routines found');
-    console.log('\nCreate one: cli4ai routines create <name>\n');
-    return;
-  }
-
-  console.log(`\nRoutines (${routines.length}):\n`);
-  for (const r of routines) {
-    const scopeTag = r.scope === 'local' ? '' : ' (global)';
-    console.log(`  ${r.name}${scopeTag}  [${r.kind}]`);
-    console.log(`    ${r.path}`);
-  }
-  console.log('');
-}
-
-function getTargetDir(global: boolean, projectDir: string): string {
-  if (global) {
-    ensureCli4aiHome();
-    return ROUTINES_DIR;
-  }
-  ensureLocalDir(projectDir);
-  return resolve(projectDir, LOCAL_ROUTINES_DIR);
-}
-
-export async function routinesCreateCommand(name: string, options: RoutinesCreateOptions): Promise<void> {
-  ensureValidRoutineName(name);
-  const projectDir = process.cwd();
-  const type = options.type ?? 'yaml';
-  if (type !== 'yaml' && type !== 'bash' && type !== 'json') {
-    outputError('INVALID_INPUT', `Invalid routine type: ${type}`, {
-      allowed: ['yaml', 'json', 'bash']
-    });
-  }
-  const dir = getTargetDir(!!options.global, projectDir);
-
-  const suffixMap: Record<string, string> = {
-    yaml: '.routine.yaml',
-    json: '.routine.json',
-    bash: '.routine.sh'
-  };
-  const suffix = suffixMap[type];
-  const filePath = resolve(dir, `${name}${suffix}`);
-
-  if (existsSync(filePath)) {
-    outputError('INVALID_INPUT', `Routine already exists: ${name}`, { path: filePath });
-  }
-
-  if (type === 'yaml') {
-    const template = {
-      version: 1,
-      name,
-      description: 'TODO: describe this routine',
-      vars: {},
-      steps: [],
-      result: '{{steps}}'
-    };
-    writeFileSync(filePath, stringifyYaml(template));
-  } else if (type === 'json') {
-    const template = {
-      version: 1,
-      name,
-      description: 'TODO: describe this routine',
-      vars: {},
-      steps: [],
-      result: '{{steps}}'
-    };
-    writeFileSync(filePath, JSON.stringify(template, null, 2) + '\n');
-  } else {
-    const template = `#!/usr/bin/env bash
-set -euo pipefail
-
-# Example:
-#   cli4ai run github trending
-#
-# Vars passed via --var KEY=value are available as env vars:
-#   CLI4AI_VAR_KEY=value
-
-echo "TODO: implement ${name}" 1>&2
-`;
-    writeFileSync(filePath, template);
-    try {
-      chmodSync(filePath, 0o755);
-    } catch {}
-  }
-
-  output({
-    action: 'create',
-    name,
-    type,
-    scope: options.global ? 'global' : 'local',
-    path: filePath
-  });
-}
-
-export async function routinesRunCommand(
-  name: string,
-  args: string[],
-  options: RoutinesRunOptions
-): Promise<void> {
-  ensureValidRoutineName(name);
-  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
-  if (!routine) {
-    outputError('NOT_FOUND', `Routine not found: ${name}`, {
-      hint: options.global
-        ? 'Create a global routine in ~/.cli4ai/routines'
-        : 'Create a routine in ./.cli4ai/routines or ~/.cli4ai/routines'
-    });
-  }
-
-  const vars = parseVars(options.var);
-
-  // Structured routines (YAML or JSON) use the routine engine
-  const isStructured = routine.kind === 'yaml' || routine.kind === 'json';
-
-  if (options.dryRun) {
-    if (isStructured) {
-      try {
-        const def = loadRoutineDefinition(routine.path);
-        const plan = await dryRunRoutine(def, vars, process.cwd());
-        output({
-          kind: routine.kind,
-          scope: routine.scope,
-          path: routine.path,
-          ...plan
-        });
-        return;
-      } catch (err) {
-        if (err instanceof RoutineParseError) {
-          outputError('PARSE_ERROR', err.message, { path: err.path });
-        }
-        if (err instanceof RoutineValidationError || err instanceof RoutineTemplateError) {
-          outputError('INVALID_INPUT', err.message, err.details);
-        }
-        throw err;
-      }
-    }
-
-    const plan = {
-      routine: routine.name,
-      kind: routine.kind,
-      scope: routine.scope,
-      path: routine.path,
-      vars,
-      exec: { cmd: 'bash', args: [routine.path, ...args] }
-    };
-
-    if (!process.stdout.isTTY) {
-      output(plan);
-      return;
-    }
-
-    console.log(`\nRoutine: ${routine.name} [${routine.kind}]`);
-    console.log(`Path:    ${routine.path}`);
-    console.log(`Vars:    ${Object.keys(vars).length ? JSON.stringify(vars) : '(none)'}`);
-    console.log(`\nWould run:\n  bash ${routine.path}${args.length ? ' ' + args.join(' ') : ''}\n`);
-    return;
-  }
-
-  if (isStructured) {
-    try {
-      const def = loadRoutineDefinition(routine.path);
-      const summary = await runRoutine(def, vars, process.cwd());
-      output({
-        kind: routine.kind,
-        scope: routine.scope,
-        path: routine.path,
-        ...summary
-      });
-      process.exit(summary.exitCode);
-    } catch (err) {
-      if (err instanceof RoutineParseError) {
-        outputError('PARSE_ERROR', err.message, { path: err.path });
-      }
-      if (err instanceof RoutineValidationError || err instanceof RoutineTemplateError) {
-        outputError('INVALID_INPUT', err.message, err.details);
-      }
-      throw err;
-    }
-  }
-
-  const startTime = Date.now();
-  const isTTY = process.stdout.isTTY;
-  const varEnv = varsToEnv(vars);
-
-  const child = spawn('bash', [routine.path, ...args], {
-    cwd: process.cwd(),
-    stdio: isTTY ? 'inherit' : ['pipe', 'pipe', 'pipe'],
-    env: {
-      ...process.env,
-      ...varEnv,
-      C4AI_ROUTINE_NAME: routine.name,
-      C4AI_ROUTINE_PATH: routine.path
-    }
-  });
-
-  if (isTTY) {
-    const exitCode = await new Promise<number>((resolve) => {
-      child.on('close', (code) => resolve(code ?? 0));
-      child.on('error', (err) => outputError('API_ERROR', `Failed to execute routine: ${err.message}`));
-    });
-    process.exit(exitCode);
-  }
-
-  // Non-TTY: capture and emit single JSON summary.
-  const stdoutPromise = child.stdout ? collectStream(child.stdout) : Promise.resolve('');
-  const stderrPromise = child.stderr ? collectStream(child.stderr) : Promise.resolve('');
-
-  if (child.stderr) {
-    child.stderr.on('data', (chunk) => {
-      process.stderr.write(chunk);
-    });
-  }
-
-  const exitCode = await new Promise<number>((resolve) => {
-    child.on('close', (code) => resolve(code ?? 0));
-    child.on('error', (err) => outputError('API_ERROR', `Failed to execute routine: ${err.message}`));
-  });
-
-  const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
-
-  output({
-    routine: routine.name,
-    kind: routine.kind,
-    scope: routine.scope,
-    status: exitCode === 0 ? 'success' : 'failed',
-    exitCode,
-    durationMs: Date.now() - startTime,
-    stdout,
-    stderr
-  });
-
-  process.exit(exitCode);
-}
-
-export async function routinesShowCommand(name: string, options: { global?: boolean }): Promise<void> {
-  ensureValidRoutineName(name);
-  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
-  if (!routine) {
-    outputError('NOT_FOUND', `Routine not found: ${name}`);
-  }
-
-  const content = readFileSync(routine.path, 'utf-8');
-
-  if (!process.stdout.isTTY) {
-    output({ routine: routine.name, kind: routine.kind, scope: routine.scope, path: routine.path, content });
-    return;
-  }
-
-  log(`\n${routine.path}\n`);
-  process.stdout.write(content);
-  if (!content.endsWith('\n')) process.stdout.write('\n');
-}
-
-export async function routinesRemoveCommand(name: string, options: { global?: boolean }): Promise<void> {
-  ensureValidRoutineName(name);
-  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
-  if (!routine) {
-    outputError('NOT_FOUND', `Routine not found: ${name}`);
-  }
-
-  rmSync(routine.path, { force: true });
-
-  output({
-    action: 'remove',
-    name: routine.name,
-    scope: routine.scope,
-    kind: routine.kind,
-    path: routine.path
-  });
-}
-
-export async function routinesEditCommand(name: string, options: { global?: boolean }): Promise<void> {
-  ensureValidRoutineName(name);
-  const routine = resolveRoutine(name, process.cwd(), { globalOnly: options.global });
-  if (!routine) {
-    outputError('NOT_FOUND', `Routine not found: ${name}`);
-  }
-
-  const editor = process.env.VISUAL || process.env.EDITOR;
-
-  if (!editor || !process.stdout.isTTY || !process.stdin.isTTY) {
-    output({
-      action: 'edit',
-      name: routine.name,
-      path: routine.path,
-      hint: editor ? 'Run your editor with the path above' : 'Set $EDITOR (or $VISUAL) to enable `cli4ai routines edit`'
-    });
-    return;
-  }
-
-  // SECURITY: Parse editor command to prevent shell injection
-  // Common editors may have arguments like "code --wait" or "vim -c 'set nu'"
-  // We split on spaces but this is a simple approach; complex cases should use exec wrapper
-  const editorParts = editor.trim().split(/\s+/);
-  const editorCmd = editorParts[0];
-  const editorArgs = [...editorParts.slice(1), routine.path];
-
-  // Validate editor command doesn't contain shell metacharacters in the base command
-  if (!/^[a-zA-Z0-9_.\-\/]+$/.test(editorCmd)) {
-    outputError('INVALID_INPUT', 'Invalid $EDITOR value - contains unsafe characters', {
-      editor: editorCmd,
-      hint: 'Set $EDITOR to a simple command like "vim", "nano", or "code --wait"'
-    });
-  }
-
-  const result = spawnSync(editorCmd, editorArgs, {
-    stdio: 'inherit'
-    // SECURITY: shell: false (default) prevents command injection
-  });
-
-  process.exit(result.status ?? 1);
-}

package/src/commands/run.ts

@@ -1,127 +0,0 @@
-/**
- * cli4ai run - Execute a tool command
- */
-
-import { output, outputError, log } from '../lib/cli.js';
-import { executeTool, ExecuteToolError, type ScopeLevel } from '../core/execute.js';
-import { remoteRunTool, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
-import { getRemote } from '../core/remotes.js';
-
-interface RunOptions {
-  env?: string[];
-  scope?: string;
-  sandbox?: boolean;
-  remote?: string;
-  timeout?: string;
-}
-
-export async function runCommand(
-  packageName: string,
-  command: string | undefined,
-  args: string[],
-  options: RunOptions
-): Promise<void> {
-  // Parse environment variables from options (-e KEY=value)
-  const extraEnv: Record<string, string> = {};
-  if (options.env) {
-    for (const envVar of options.env) {
-      const eqIndex = envVar.indexOf('=');
-      if (eqIndex > 0) {
-        extraEnv[envVar.slice(0, eqIndex)] = envVar.slice(eqIndex + 1);
-      }
-    }
-  }
-
-  // Validate scope option
-  let scope: ScopeLevel = 'full';
-  if (options.scope) {
-    const validScopes: ScopeLevel[] = ['read', 'write', 'full'];
-    if (!validScopes.includes(options.scope as ScopeLevel)) {
-      outputError('INVALID_INPUT', `Invalid scope: ${options.scope}`, {
-        validScopes,
-        hint: 'Use --scope read, --scope write, or --scope full'
-      });
-    }
-    scope = options.scope as ScopeLevel;
-  }
-
-  // Parse timeout
-  let timeout: number | undefined;
-  if (options.timeout) {
-    timeout = parseInt(options.timeout, 10);
-    if (isNaN(timeout) || timeout < 0) {
-      outputError('INVALID_INPUT', 'Timeout must be a positive number (milliseconds)');
-    }
-  }
-
-  // Remote execution
-  if (options.remote) {
-    const remote = getRemote(options.remote);
-    if (!remote) {
-      outputError('NOT_FOUND', `Remote "${options.remote}" not found`, {
-        hint: 'Use "cli4ai remotes add <name> <url>" to configure a remote'
-      });
-    }
-
-    log(`Executing on remote: ${remote.name} (${remote.url})`);
-
-    try {
-      const result = await remoteRunTool(options.remote, {
-        package: packageName,
-        command,
-        args,
-        env: Object.keys(extraEnv).length > 0 ? extraEnv : undefined,
-        timeout,
-        scope
-      });
-
-      // Output stdout/stderr
-      if (result.stdout) {
-        process.stdout.write(result.stdout);
-      }
-      if (result.stderr) {
-        process.stderr.write(result.stderr);
-      }
-
-      process.exitCode = result.exitCode;
-
-      if (!result.success && result.error) {
-        log(`Remote error: ${result.error.message}`);
-      }
-
-      return;
-    } catch (err) {
-      if (err instanceof RemoteConnectionError) {
-        outputError('NETWORK_ERROR', err.message, { remote: options.remote, url: remote.url });
-      }
-      if (err instanceof RemoteApiError) {
-        outputError(err.code, err.message, err.details);
-      }
-      const message = err instanceof Error ? err.message : String(err);
-      outputError('API_ERROR', message);
-    }
-  }
-
-  // Local execution
-  try {
-    const result = await executeTool({
-      packageName,
-      command,
-      args,
-      cwd: process.cwd(),
-      env: extraEnv,
-      capture: 'inherit',
-      timeoutMs: timeout,
-      scope,
-      sandbox: options.sandbox ?? false
-    });
-    process.exitCode = result.exitCode;
-    return;
-  } catch (err) {
-    if (err instanceof ExecuteToolError) {
-      outputError(err.code, err.message, err.details);
-    }
-    const message = err instanceof Error ? err.message : String(err);
-    outputError('API_ERROR', message);
-  }
-}