cli4ai 0.8.0

package/src/commands/secrets.ts

@@ -0,0 +1,273 @@
+/**
+ * cli4ai secrets - Manage secrets for CLI tools
+ */
+
+import { createInterface } from 'readline';
+import { resolve } from 'path';
+import { existsSync, readFileSync } from 'fs';
+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';
+
+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');
+  }
+
+  setSecret(key, value);
+  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) {
+      setSecret(key, value);
+      log(`  ✓ ${key} saved`);
+      configured.push(key);
+    } else {
+      log(`  ○ ${key} skipped`);
+      skipped.push(key);
+    }
+  }
+
+  log('\n');
+  output({ package: pkgName, configured, skipped });
+}

package/src/commands/start.ts

@@ -0,0 +1,40 @@
+/**
+ * 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

@@ -0,0 +1,218 @@
+/**
+ * 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 (async)
+ */
+async function updatePackageAsync(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 }> = [];
+
+  // Get npm global @cli4ai packages
+  for (const pkg of getNpmGlobalPackages()) {
+    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 updatePackageAsync('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' : ''} in parallel...${RESET}`);
+
+    const updatePromises = toUpdate.map(async (pkg) => {
+      const success = await updatePackageAsync(pkg.npmName);
+      return { ...pkg, success };
+    });
+
+    const updateResults = await Promise.all(updatePromises);
+
+    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;
+
+  console.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}`);
+  }
+  console.log('');
+}