cli4ai 1.2.0 → 1.2.1

package/dist/commands/secrets.js

@@ -0,0 +1,236 @@
+/**
+ * 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 } from '../core/secrets.js';
+import { findPackage } from '../core/config.js';
+/**
+ * Expand ~ to home directory in paths
+ */
+function expandTilde(path) {
+    if (path.startsWith('~/')) {
+        return resolve(homedir(), path.slice(2));
+    }
+    if (path === '~') {
+        return homedir();
+    }
+    return path;
+}
+/**
+ * Prompt for input (hidden for secrets)
+ */
+async function prompt(message, hidden = false) {
+    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) => {
+                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, value) {
+    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) {
+    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) {
+    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 = [];
+        for (const [key, def] of Object.entries(envDefs)) {
+            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) {
+    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, options) {
+    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.required)
+        .map(([key, def]) => ({ key, ...def }));
+    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 = [];
+    const skipped = [];
+    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/dist/commands/serve.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Serve command - Start cli4ai as a remote service.
+ *
+ * Allows other cli4ai instances to execute tools on this machine.
+ */
+export interface ServeCommandOptions {
+    port?: string;
+    host?: string;
+    apiKey?: string;
+    scope?: string;
+    cwd?: string;
+}
+export declare function serveCommand(options: ServeCommandOptions): Promise<void>;

package/dist/commands/serve.js

@@ -0,0 +1,49 @@
+/**
+ * Serve command - Start cli4ai as a remote service.
+ *
+ * Allows other cli4ai instances to execute tools on this machine.
+ */
+import { output, outputError } from '../lib/cli.js';
+import { startService } from '../server/service.js';
+export async function serveCommand(options) {
+    const serviceOptions = {
+        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());
+        const validScopes = ['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/dist/commands/start.d.ts

@@ -0,0 +1,8 @@
+/**
+ * cli4ai start - Start MCP server for a package
+ */
+interface StartOptions {
+    stdio?: boolean;
+}
+export declare function startCommand(packageName: string, options: StartOptions): Promise<void>;
+export {};

package/dist/commands/start.js

@@ -0,0 +1,27 @@
+/**
+ * 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';
+export async function startCommand(packageName, options) {
+    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/dist/commands/update.d.ts

@@ -0,0 +1,17 @@
+/**
+ * cli4ai update - Update installed packages and cli4ai itself
+ */
+interface UpdateOptions {
+    self?: boolean;
+    all?: boolean;
+}
+/**
+ * Check for cli4ai framework updates
+ */
+export declare function checkForUpdates(): Promise<{
+    hasUpdate: boolean;
+    current: string;
+    latest: string;
+}>;
+export declare function updateCommand(options: UpdateOptions): Promise<void>;
+export {};

package/dist/commands/update.js

@@ -0,0 +1,210 @@
+/**
+ * cli4ai update - Update installed packages and cli4ai itself
+ */
+import { spawn } from 'child_process';
+import { log } from '../lib/cli.js';
+import { getNpmGlobalPackages, getGlobalPackages } from '../core/config.js';
+// 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) {
+    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();
+        return data.version;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get latest versions for multiple packages in parallel
+ */
+async function getLatestVersions(packageNames) {
+    const results = new Map();
+    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) {
+    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) {
+    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() {
+    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() {
+    const packages = [];
+    const seen = new Set();
+    // 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) {
+    const results = [];
+    // 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 = [];
+    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 = [];
+        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('');
+}

package/dist/core/config.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Global cli4ai configuration (~/.cli4ai/)
+ */
+/**
+ * Check if a path is safe to use (not a malicious symlink)
+ */
+export declare function isPathSafe(path: string): boolean;
+export declare const CLI4AI_HOME: string;
+export declare const CONFIG_FILE: string;
+export declare const PACKAGES_DIR: string;
+export declare const CACHE_DIR: string;
+export declare const ROUTINES_DIR: string;
+export declare const SCHEDULER_DIR: string;
+export declare const CREDENTIALS_FILE: string;
+export declare const LOCAL_DIR = ".cli4ai";
+export declare const LOCAL_PACKAGES_DIR: string;
+export declare const LOCAL_ROUTINES_DIR: string;
+export interface Config {
+    registry: string;
+    localRegistries: string[];
+    defaultRuntime: 'node';
+    mcp: {
+        transport: 'stdio' | 'http';
+        port: number;
+    };
+    audit: {
+        /** Enable audit logging for MCP tool calls */
+        enabled: boolean;
+    };
+    telemetry: boolean;
+}
+export interface InstalledPackage {
+    name: string;
+    version: string;
+    path: string;
+    source: 'local' | 'registry';
+    installedAt: string;
+}
+export declare const DEFAULT_CONFIG: Config;
+/**
+ * Ensure ~/.cli4ai directory exists with required subdirectories
+ */
+export declare function ensureCli4aiHome(): void;
+/**
+ * Ensure local .cli4ai directory exists
+ */
+export declare function ensureLocalDir(projectDir: string): void;
+/**
+ * Load global config, creating defaults if needed
+ */
+export declare function loadConfig(): Config;
+/**
+ * Save global config
+ */
+export declare function saveConfig(config: Config): void;
+/**
+ * Update config with a read-modify-write lock to avoid cross-process races.
+ */
+export declare function updateConfig(mutator: (config: Config) => Config): Config;
+/**
+ * Get a config value
+ */
+export declare function getConfigValue<K extends keyof Config>(key: K): Config[K];
+/**
+ * Set a config value
+ */
+export declare function setConfigValue<K extends keyof Config>(key: K, value: Config[K]): void;
+/**
+ * Add a local registry path
+ */
+export declare function addLocalRegistry(path: string): void;
+/**
+ * Remove a local registry path
+ */
+export declare function removeLocalRegistry(path: string): void;
+/**
+ * Get list of globally installed packages
+ */
+export declare function getGlobalPackages(): InstalledPackage[];
+/**
+ * Get list of locally installed packages (in project)
+ */
+export declare function getLocalPackages(projectDir: string): InstalledPackage[];
+/**
+ * Get all global @cli4ai packages (from both npm and bun)
+ */
+export declare function getNpmGlobalPackages(): InstalledPackage[];
+/**
+ * Find a package by name (checks local, global cli4ai, bun global, then npm global)
+ */
+export declare function findPackage(name: string, projectDir?: string): InstalledPackage | null;