cli4ai 1.1.5 → 1.2.1

package/src/commands/secrets.ts

@@ -1,292 +0,0 @@
-/**
- * cli4ai secrets - Manage secrets for CLI tools
- */
-
-import { createInterface } from 'readline';
-import { resolve } from 'path';
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-import { output, outputError, log } from '../lib/cli.js';
-
-import {
-  getSecret,
-  setSecret,
-  deleteSecret,
-  listSecretKeys,
-  getSecretSource,
-  hasSecret
-} from '../core/secrets.js';
-import { findPackage } from '../core/config.js';
-
-/**
- * Expand ~ to home directory in paths
- */
-function expandTilde(path: string): string {
-  if (path.startsWith('~/')) {
-    return resolve(homedir(), path.slice(2));
-  }
-  if (path === '~') {
-    return homedir();
-  }
-  return path;
-}
-
-interface SecretsOptions {
-  package?: string;
-}
-
-/**
- * Prompt for input (hidden for secrets)
- */
-async function prompt(message: string, hidden = false): Promise<string> {
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stderr
-  });
-
-  return new Promise((resolve) => {
-    if (hidden && process.stdin.isTTY) {
-      // Hide input for secrets
-      process.stderr.write(message);
-      let value = '';
-
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding('utf8');
-
-      const onData = (char: string) => {
-        if (char === '\n' || char === '\r') {
-          process.stdin.setRawMode(false);
-          process.stdin.removeListener('data', onData);
-          process.stderr.write('\n');
-          rl.close();
-          resolve(value);
-        } else if (char === '\u0003') {
-          // Ctrl+C
-          process.exit(1);
-        } else if (char === '\u007F') {
-          // Backspace
-          if (value.length > 0) {
-            value = value.slice(0, -1);
-          }
-        } else {
-          value += char;
-        }
-      };
-
-      process.stdin.on('data', onData);
-    } else {
-      rl.question(message, (answer) => {
-        rl.close();
-        resolve(answer);
-      });
-    }
-  });
-}
-
-/**
- * cli4ai secrets set <key> [value]
- */
-export async function secretsSetCommand(key: string, value?: string): Promise<void> {
-  if (!key) {
-    outputError('INVALID_INPUT', 'Secret key is required');
-  }
-
-  // Prompt for value if not provided
-  if (!value) {
-    value = await prompt(`Enter value for ${key}: `, true);
-  }
-
-  if (!value) {
-    outputError('INVALID_INPUT', 'Secret value cannot be empty');
-  }
-
-  // Expand ~ to home directory for paths
-  const expandedValue = expandTilde(value);
-  setSecret(key, expandedValue);
-  log(`✓ Secret '${key}' saved to vault`);
-
-  output({ key, status: 'saved' });
-}
-
-/**
- * cli4ai secrets get <key>
- */
-export async function secretsGetCommand(key: string): Promise<void> {
-  if (!key) {
-    outputError('INVALID_INPUT', 'Secret key is required');
-  }
-
-  const value = getSecret(key);
-  const source = getSecretSource(key);
-
-  if (!value) {
-    outputError('NOT_FOUND', `Secret '${key}' not found`, {
-      hint: `Set it with: cli4ai secrets set ${key}`
-    });
-  }
-
-  // Output value to stdout (for piping)
-  console.log(value);
-}
-
-/**
- * cli4ai secrets list
- */
-export async function secretsListCommand(options: SecretsOptions): Promise<void> {
-  const vaultKeys = listSecretKeys();
-
-  // If package specified, show status of required secrets
-  if (options.package) {
-    const pkg = findPackage(options.package, process.cwd());
-    if (!pkg) {
-      outputError('NOT_FOUND', `Package not found: ${options.package}`);
-    }
-
-    const cli4aiPath = resolve(pkg.path, 'cli4ai.json');
-    if (!existsSync(cli4aiPath)) {
-      outputError('NOT_FOUND', 'Package has no cli4ai.json');
-    }
-
-    const manifest = JSON.parse(readFileSync(cli4aiPath, 'utf-8'));
-    const envDefs = manifest.env || {};
-
-    log(`\nSecrets for ${options.package}:\n`);
-
-    const secrets: Array<{ key: string; required: boolean; source: string; description?: string }> = [];
-
-    for (const [key, def] of Object.entries(envDefs) as [string, { required?: boolean; description?: string }][]) {
-      const source = getSecretSource(key);
-      secrets.push({
-        key,
-        required: def.required ?? false,
-        source,
-        description: def.description
-      });
-
-      const status = source === 'env' ? '✓ (env)' :
-                     source === 'vault' ? '✓ (vault)' :
-                     def.required ? '✗ missing' : '○ optional';
-
-      log(`  ${status.padEnd(12)} ${key}`);
-      if (def.description) {
-        log(`              ${def.description}`);
-      }
-    }
-
-    log('');
-    output({ package: options.package, secrets });
-    return;
-  }
-
-  // List all secrets in vault
-  if (vaultKeys.length === 0) {
-    log('No secrets stored in vault.\n');
-    log('Set a secret:  cli4ai secrets set SLACK_BOT_TOKEN');
-    log('From env var:  Secrets are also read from environment variables\n');
-    output({ secrets: [] });
-    return;
-  }
-
-  log('\nSecrets in vault:\n');
-
-  const secrets = vaultKeys.map(key => {
-    const source = getSecretSource(key);
-    const overridden = source === 'env';
-    log(`  ${key}${overridden ? ' (overridden by env)' : ''}`);
-    return { key, overriddenByEnv: overridden };
-  });
-
-  log('\n');
-  output({ secrets });
-}
-
-/**
- * cli4ai secrets delete <key>
- */
-export async function secretsDeleteCommand(key: string): Promise<void> {
-  if (!key) {
-    outputError('INVALID_INPUT', 'Secret key is required');
-  }
-
-  const deleted = deleteSecret(key);
-
-  if (!deleted) {
-    outputError('NOT_FOUND', `Secret '${key}' not found in vault`);
-  }
-
-  log(`✓ Secret '${key}' deleted from vault`);
-  output({ key, status: 'deleted' });
-}
-
-/**
- * cli4ai secrets init [package]
- * Interactive setup for a package's required secrets
- */
-export async function secretsInitCommand(packageName?: string, options?: SecretsOptions): Promise<void> {
-  const pkgName = packageName || options?.package;
-
-  if (!pkgName) {
-    outputError('INVALID_INPUT', 'Package name required', {
-      hint: 'Usage: cli4ai secrets init <package>'
-    });
-  }
-
-  const pkg = findPackage(pkgName, process.cwd());
-  if (!pkg) {
-    outputError('NOT_FOUND', `Package not found: ${pkgName}`);
-  }
-
-  const cli4aiPath = resolve(pkg.path, 'cli4ai.json');
-  if (!existsSync(cli4aiPath)) {
-    outputError('NOT_FOUND', 'Package has no cli4ai.json');
-  }
-
-  const manifest = JSON.parse(readFileSync(cli4aiPath, 'utf-8'));
-  const envDefs = manifest.env || {};
-
-  const required = Object.entries(envDefs)
-    .filter(([_, def]) => (def as { required?: boolean }).required)
-    .map(([key, def]) => ({ key, ...(def as { description?: string }) }));
-
-  if (required.length === 0) {
-    log(`\n${pkgName} has no required secrets.\n`);
-    output({ package: pkgName, configured: [] });
-    return;
-  }
-
-  log(`\nConfiguring secrets for ${pkgName}:\n`);
-
-  const configured: string[] = [];
-  const skipped: string[] = [];
-
-  for (const { key, description } of required) {
-    const source = getSecretSource(key);
-
-    if (source !== 'missing') {
-      log(`  ✓ ${key} (already set via ${source})`);
-      skipped.push(key);
-      continue;
-    }
-
-    if (description) {
-      log(`\n  ${key}: ${description}`);
-    }
-
-    const value = await prompt(`  Enter ${key}: `, true);
-
-    if (value) {
-      // Expand ~ to home directory for paths
-      const expandedValue = expandTilde(value);
-      setSecret(key, expandedValue);
-      log(`  ✓ ${key} saved`);
-      configured.push(key);
-    } else {
-      log(`  ○ ${key} skipped`);
-      skipped.push(key);
-    }
-  }
-
-  log('\n');
-  output({ package: pkgName, configured, skipped });
-}

package/src/commands/serve.ts

@@ -1,66 +0,0 @@
-/**
- * Serve command - Start cli4ai as a remote service.
- *
- * Allows other cli4ai instances to execute tools on this machine.
- */
-
-import { output, outputError, log } from '../lib/cli.js';
-import { startService, type StartServiceOptions } from '../server/service.js';
-import type { ScopeLevel } from '../core/execute.js';
-
-export interface ServeCommandOptions {
-  port?: string;
-  host?: string;
-  apiKey?: string;
-  scope?: string;
-  cwd?: string;
-}
-
-export async function serveCommand(options: ServeCommandOptions): Promise<void> {
-  const serviceOptions: StartServiceOptions = {
-    cwd: options.cwd ?? process.cwd()
-  };
-
-  // Parse port
-  if (options.port) {
-    const port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 1 || port > 65535) {
-      outputError('INVALID_INPUT', 'Port must be a number between 1 and 65535');
-    }
-    serviceOptions.port = port;
-  }
-
-  // Parse host
-  if (options.host) {
-    serviceOptions.host = options.host;
-  }
-
-  // API key
-  if (options.apiKey) {
-    serviceOptions.apiKey = options.apiKey;
-  }
-
-  // Parse allowed scopes
-  if (options.scope) {
-    const scopes = options.scope.split(',').map(s => s.trim()) as ScopeLevel[];
-    const validScopes: ScopeLevel[] = ['read', 'write', 'full'];
-
-    for (const scope of scopes) {
-      if (!validScopes.includes(scope)) {
-        outputError('INVALID_INPUT', `Invalid scope "${scope}". Must be one of: read, write, full`);
-      }
-    }
-
-    serviceOptions.allowedScopes = scopes;
-  }
-
-  try {
-    await startService(serviceOptions);
-    output({ status: 'stopped' });
-  } catch (err) {
-    if (err instanceof Error) {
-      outputError('API_ERROR', err.message);
-    }
-    throw err;
-  }
-}

package/src/commands/start.ts

@@ -1,40 +0,0 @@
-/**
- * cli4ai start - Start MCP server for a package
- */
-
-import { outputError } from '../lib/cli.js';
-import { findPackage } from '../core/config.js';
-import { loadManifest } from '../core/manifest.js';
-import { startMcpServer } from '../mcp/server.js';
-
-interface StartOptions {
-  stdio?: boolean;
-}
-
-export async function startCommand(
-  packageName: string,
-  options: StartOptions
-): Promise<void> {
-  const cwd = process.cwd();
-
-  // Find the package
-  const pkg = findPackage(packageName, cwd);
-  if (!pkg) {
-    outputError('NOT_FOUND', `Package not found: ${packageName}`, {
-      hint: 'Install the package first with "cli4ai add <package>"'
-    });
-  }
-
-  // Load manifest
-  const manifest = loadManifest(pkg!.path);
-
-  // Check if MCP is enabled
-  if (!manifest.mcp?.enabled) {
-    outputError('INVALID_INPUT', `Package ${packageName} does not have MCP enabled`, {
-      hint: 'Add "mcp": { "enabled": true } to cli4ai.json'
-    });
-  }
-
-  // Start MCP server (stdio mode is default/only mode for now)
-  await startMcpServer(manifest, pkg!.path);
-}

package/src/commands/update.ts

@@ -1,252 +0,0 @@
-/**
- * cli4ai update - Update installed packages and cli4ai itself
- */
-
-import { spawn } from 'child_process';
-import { log, outputError } from '../lib/cli.js';
-import {
-  getNpmGlobalPackages,
-  getGlobalPackages,
-  getLocalPackages
-} from '../core/config.js';
-
-interface UpdateOptions {
-  self?: boolean;
-  all?: boolean;
-}
-
-interface UpdateResult {
-  name: string;
-  from: string;
-  to: string;
-  status: 'updated' | 'current' | 'failed';
-}
-
-// ANSI colors
-const RESET = '\x1B[0m';
-const BOLD = '\x1B[1m';
-const DIM = '\x1B[2m';
-const CYAN = '\x1B[36m';
-const GREEN = '\x1B[32m';
-const YELLOW = '\x1B[33m';
-
-/**
- * Get latest version from npm registry API (fast!)
- */
-async function getLatestVersion(packageName: string): Promise<string | null> {
-  try {
-    // URL-encode the package name to handle scoped packages like @cli4ai/foo
-    // npm registry expects: @scope%2Fpackage (slash encoded, @ not encoded)
-    const encodedName = packageName.replace('/', '%2F');
-    const response = await fetch(`https://registry.npmjs.org/${encodedName}/latest`, {
-      headers: { 'Accept': 'application/json' }
-    });
-    if (!response.ok) return null;
-    const data = await response.json() as { version: string };
-    return data.version;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get latest versions for multiple packages in parallel
- */
-async function getLatestVersions(packageNames: string[]): Promise<Map<string, string | null>> {
-  const results = new Map<string, string | null>();
-  const promises = packageNames.map(async (name) => {
-    const version = await getLatestVersion(name);
-    results.set(name, version);
-  });
-  await Promise.all(promises);
-  return results;
-}
-
-/**
- * Update a single package using cli4ai add -g (reinstalls to ~/.cli4ai/packages/)
- */
-async function updateCli4aiPackage(packageName: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    // Use cli4ai add -g to reinstall the package (same location as original install)
-    const proc = spawn('cli4ai', ['add', '-g', packageName, '-y'], {
-      stdio: 'pipe'
-    });
-    proc.on('close', (code) => {
-      resolve(code === 0);
-    });
-    proc.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Update cli4ai itself via npm
- */
-async function updateNpmPackage(packageName: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const proc = spawn('npm', ['install', '-g', `${packageName}@latest`], {
-      stdio: 'pipe'
-    });
-    proc.on('close', (code) => {
-      resolve(code === 0);
-    });
-    proc.on('error', () => {
-      resolve(false);
-    });
-  });
-}
-
-/**
- * Check for cli4ai framework updates
- */
-export async function checkForUpdates(): Promise<{ hasUpdate: boolean; current: string; latest: string }> {
-  const { VERSION } = await import('../lib/cli.js');
-  const latest = await getLatestVersion('cli4ai');
-
-  if (!latest) {
-    return { hasUpdate: false, current: VERSION, latest: VERSION };
-  }
-
-  const hasUpdate = latest !== VERSION;
-  return { hasUpdate, current: VERSION, latest };
-}
-
-/**
- * Get all updateable packages
- */
-function getUpdateablePackages(): Array<{ name: string; npmName: string; version: string }> {
-  const packages: Array<{ name: string; npmName: string; version: string }> = [];
-  const seen = new Set<string>();
-
-  // Get packages from ~/.cli4ai/packages/ (where cli4ai add -g installs)
-  for (const pkg of getGlobalPackages()) {
-    if (!seen.has(pkg.name)) {
-      seen.add(pkg.name);
-      packages.push({
-        name: pkg.name,
-        npmName: `@cli4ai/${pkg.name}`,
-        version: pkg.version
-      });
-    }
-  }
-
-  // Also check npm global @cli4ai packages (for packages installed via npm directly)
-  for (const pkg of getNpmGlobalPackages()) {
-    if (!seen.has(pkg.name)) {
-      seen.add(pkg.name);
-      packages.push({
-        name: pkg.name,
-        npmName: `@cli4ai/${pkg.name}`,
-        version: pkg.version
-      });
-    }
-  }
-
-  return packages;
-}
-
-export async function updateCommand(options: UpdateOptions): Promise<void> {
-  const results: UpdateResult[] = [];
-
-  // Update cli4ai itself first if --self or --all
-  if (options.self || options.all) {
-    log(`\n${BOLD}Checking cli4ai framework...${RESET}`);
-
-    const { hasUpdate, current, latest } = await checkForUpdates();
-
-    if (hasUpdate) {
-      log(`  ${CYAN}↑${RESET} cli4ai ${DIM}${current}${RESET} → ${GREEN}${latest}${RESET}`);
-      const success = await updateNpmPackage('cli4ai');
-
-      if (success) {
-        log(`  ${GREEN}✓${RESET} cli4ai updated\n`);
-        results.push({ name: 'cli4ai', from: current, to: latest, status: 'updated' });
-      } else {
-        log(`  ${YELLOW}✗${RESET} Failed to update cli4ai\n`);
-        results.push({ name: 'cli4ai', from: current, to: latest, status: 'failed' });
-      }
-    } else {
-      log(`  ${GREEN}✓${RESET} cli4ai is up to date (${current})\n`);
-      results.push({ name: 'cli4ai', from: current, to: current, status: 'current' });
-    }
-
-    if (options.self && !options.all) {
-      return;
-    }
-  }
-
-  // Get all installed packages
-  const packages = getUpdateablePackages();
-
-  if (packages.length === 0) {
-    log(`${DIM}No @cli4ai packages installed.${RESET}`);
-    log(`${DIM}Run ${RESET}cli4ai browse${DIM} to install packages.${RESET}\n`);
-    return;
-  }
-
-  log(`${BOLD}Checking ${packages.length} package${packages.length !== 1 ? 's' : ''} for updates...${RESET}\n`);
-
-  // Fetch all versions in parallel (fast!)
-  const npmNames = packages.map(p => p.npmName);
-  const latestVersions = await getLatestVersions(npmNames);
-
-  // Separate packages that need updates vs current
-  const toUpdate: Array<{ name: string; npmName: string; from: string; to: string }> = [];
-
-  for (const pkg of packages) {
-    const latest = latestVersions.get(pkg.npmName);
-
-    if (!latest) {
-      log(`  ${DIM}${pkg.name}${RESET} - ${YELLOW}could not check${RESET}`);
-      continue;
-    }
-
-    if (latest === pkg.version) {
-      log(`  ${GREEN}✓${RESET} ${pkg.name} ${DIM}${pkg.version}${RESET}`);
-      results.push({ name: pkg.name, from: pkg.version, to: pkg.version, status: 'current' });
-    } else {
-      log(`  ${CYAN}↑${RESET} ${pkg.name} ${DIM}${pkg.version}${RESET} → ${GREEN}${latest}${RESET}`);
-      toUpdate.push({ name: pkg.name, npmName: pkg.npmName, from: pkg.version, to: latest });
-    }
-  }
-
-  // Update all packages in parallel
-  if (toUpdate.length > 0) {
-    log(`\n${BOLD}Updating ${toUpdate.length} package${toUpdate.length !== 1 ? 's' : ''}...${RESET}`);
-
-    const updateResults: Array<(typeof toUpdate)[number] & { success: boolean }> = [];
-    for (const pkg of toUpdate) {
-      // Use cli4ai add -g to update packages in ~/.cli4ai/packages/
-      const success = await updateCli4aiPackage(pkg.name);
-      updateResults.push({ ...pkg, success });
-    }
-
-    log('');
-    for (const result of updateResults) {
-      if (result.success) {
-        log(`  ${GREEN}✓${RESET} ${result.name} updated`);
-        results.push({ name: result.name, from: result.from, to: result.to, status: 'updated' });
-      } else {
-        log(`  ${YELLOW}✗${RESET} ${result.name} failed`);
-        results.push({ name: result.name, from: result.from, to: result.to, status: 'failed' });
-      }
-    }
-  }
-
-  // Summary
-  const updated = results.filter(r => r.status === 'updated').length;
-  const failed = results.filter(r => r.status === 'failed').length;
-
-  log('');
-  if (updated > 0) {
-    log(`${GREEN}${updated} package${updated !== 1 ? 's' : ''} updated${RESET}`);
-  }
-  if (failed > 0) {
-    log(`${YELLOW}${failed} package${failed !== 1 ? 's' : ''} failed to update${RESET}`);
-  }
-  if (updated === 0 && failed === 0) {
-    log(`${GREEN}All packages are up to date${RESET}`);
-  }
-  log('');
-}