cli4ai 1.2.0 → 1.2.2

package/dist/commands/run.js

@@ -0,0 +1,104 @@
+/**
+ * cli4ai run - Execute a tool command
+ */
+import { outputError, log } from '../lib/cli.js';
+import { executeTool, ExecuteToolError } from '../core/execute.js';
+import { remoteRunTool, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
+import { getRemote } from '../core/remotes.js';
+export async function runCommand(packageName, command, args, options) {
+    // Parse environment variables from options (-e KEY=value)
+    const extraEnv = {};
+    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 = 'full';
+    if (options.scope) {
+        const validScopes = ['read', 'write', 'full'];
+        if (!validScopes.includes(options.scope)) {
+            outputError('INVALID_INPUT', `Invalid scope: ${options.scope}`, {
+                validScopes,
+                hint: 'Use --scope read, --scope write, or --scope full'
+            });
+        }
+        scope = options.scope;
+    }
+    // Parse timeout
+    let timeout;
+    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);
+    }
+}

package/dist/commands/scheduler.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Scheduler CLI commands.
+ *
+ * cli4ai scheduler start [--foreground]   # Start daemon
+ * cli4ai scheduler stop                    # Stop daemon
+ * cli4ai scheduler status                  # Show status + upcoming runs
+ * cli4ai scheduler logs [routine]          # View logs
+ * cli4ai scheduler history [routine]       # View execution history
+ * cli4ai scheduler run <routine>           # Manual trigger
+ */
+interface SchedulerStartOptions {
+    foreground?: boolean;
+}
+export declare function schedulerStartCommand(options: SchedulerStartOptions): Promise<void>;
+export declare function schedulerStopCommand(): Promise<void>;
+export declare function schedulerStatusCommand(): Promise<void>;
+interface SchedulerLogsOptions {
+    follow?: boolean;
+    lines?: number;
+}
+export declare function schedulerLogsCommand(options: SchedulerLogsOptions): Promise<void>;
+interface SchedulerHistoryOptions {
+    limit?: number;
+}
+export declare function schedulerHistoryCommand(routineName?: string, options?: SchedulerHistoryOptions): Promise<void>;
+export declare function schedulerRunCommand(routineName: string): Promise<void>;
+export {};

package/dist/commands/scheduler.js

@@ -0,0 +1,350 @@
+/**
+ * Scheduler CLI commands.
+ *
+ * cli4ai scheduler start [--foreground]   # Start daemon
+ * cli4ai scheduler stop                    # Stop daemon
+ * cli4ai scheduler status                  # Show status + upcoming runs
+ * cli4ai scheduler logs [routine]          # View logs
+ * cli4ai scheduler history [routine]       # View execution history
+ * cli4ai scheduler run <routine>           # Manual trigger
+ */
+import { spawn } from 'child_process';
+import { readFileSync, existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { output, outputError, log } from '../lib/cli.js';
+import { isDaemonRunning, getDaemonPid, removeDaemonPid, loadSchedulerState, getRunHistory, Scheduler, SCHEDULER_LOG_FILE, SCHEDULER_PID_FILE } from '../core/scheduler.js';
+import { getScheduledRoutines } from '../core/routines.js';
+export async function schedulerStartCommand(options) {
+    // Check if already running
+    if (isDaemonRunning()) {
+        const pid = getDaemonPid();
+        outputError('INVALID_INPUT', `Scheduler is already running (PID ${pid})`, {
+            hint: 'Use "cli4ai scheduler stop" to stop it first'
+        });
+        return;
+    }
+    // Clean up stale PID file
+    if (existsSync(SCHEDULER_PID_FILE)) {
+        removeDaemonPid();
+    }
+    if (options.foreground) {
+        // Run in foreground (blocking)
+        log('Starting scheduler in foreground mode...');
+        log('Press Ctrl+C to stop');
+        const scheduler = new Scheduler({ projectDir: process.cwd() });
+        await scheduler.start();
+        // Keep running until signal
+        await new Promise((resolve) => {
+            process.on('SIGINT', async () => {
+                log('\nStopping scheduler...');
+                await scheduler.stop();
+                resolve();
+            });
+            process.on('SIGTERM', async () => {
+                await scheduler.stop();
+                resolve();
+            });
+        });
+        output({ status: 'stopped' });
+        return;
+    }
+    // Run as daemon (background)
+    const daemonScript = resolve(dirname(fileURLToPath(import.meta.url)), '../core/scheduler-daemon.ts');
+    // Spawn with detached mode
+    const child = spawn('npx', ['tsx', daemonScript, '--project-dir', process.cwd()], {
+        detached: true,
+        stdio: 'ignore',
+        env: {
+            ...process.env,
+            CLI4AI_DAEMON: 'true'
+        }
+    });
+    // Unref to allow parent to exit
+    child.unref();
+    // Wait a moment for the daemon to write its PID
+    await new Promise(r => setTimeout(r, 500));
+    const pid = getDaemonPid();
+    if (pid && isDaemonRunning()) {
+        log(`Scheduler daemon started (PID ${pid})`);
+        output({ status: 'started', pid });
+    }
+    else {
+        outputError('API_ERROR', 'Failed to start scheduler daemon', {
+            hint: 'Check logs with "cli4ai scheduler logs"'
+        });
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER STOP
+// ═══════════════════════════════════════════════════════════════════════════
+export async function schedulerStopCommand() {
+    const pid = getDaemonPid();
+    if (!pid) {
+        outputError('NOT_FOUND', 'Scheduler daemon is not running');
+        return;
+    }
+    if (!isDaemonRunning()) {
+        // Clean up stale PID file
+        removeDaemonPid();
+        log('Scheduler was not running (cleaned up stale PID file)');
+        output({ status: 'stopped', pid: null });
+        return;
+    }
+    log(`Stopping scheduler daemon (PID ${pid})...`);
+    try {
+        // Send SIGTERM for graceful shutdown
+        process.kill(pid, 'SIGTERM');
+        // Wait for process to exit (up to 10 seconds)
+        const maxWait = 10000;
+        const checkInterval = 100;
+        let waited = 0;
+        while (waited < maxWait) {
+            await new Promise(r => setTimeout(r, checkInterval));
+            waited += checkInterval;
+            if (!isDaemonRunning()) {
+                break;
+            }
+        }
+        if (isDaemonRunning()) {
+            // Force kill if still running
+            log('Scheduler did not stop gracefully, sending SIGKILL...');
+            process.kill(pid, 'SIGKILL');
+            await new Promise(r => setTimeout(r, 500));
+        }
+        removeDaemonPid();
+        log('Scheduler daemon stopped');
+        output({ status: 'stopped', pid });
+    }
+    catch (err) {
+        if (err.code === 'ESRCH') {
+            // Process doesn't exist
+            removeDaemonPid();
+            log('Scheduler was not running (cleaned up stale PID file)');
+            output({ status: 'stopped', pid: null });
+        }
+        else {
+            outputError('API_ERROR', `Failed to stop scheduler: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER STATUS
+// ═══════════════════════════════════════════════════════════════════════════
+export async function schedulerStatusCommand() {
+    const pid = getDaemonPid();
+    const running = isDaemonRunning();
+    // Get scheduled routines
+    const scheduledRoutines = getScheduledRoutines(process.cwd());
+    const state = loadSchedulerState();
+    if (!running) {
+        log('Scheduler: not running');
+        if (scheduledRoutines.length === 0) {
+            log('\nNo scheduled routines found.');
+            log('Add a "schedule" field to your .routine.json files to enable scheduling.');
+        }
+        else {
+            log(`\nFound ${scheduledRoutines.length} scheduled routine(s):`);
+            for (const routine of scheduledRoutines) {
+                const scheduleStr = routine.schedule.cron
+                    ? `cron: ${routine.schedule.cron}`
+                    : `interval: ${routine.schedule.interval}`;
+                log(`  - ${routine.name} (${scheduleStr})`);
+            }
+            log('\nStart the scheduler with: cli4ai scheduler start');
+        }
+        output({
+            running: false,
+            pid: null,
+            routines: scheduledRoutines.map(r => ({
+                name: r.name,
+                schedule: r.schedule,
+                path: r.path
+            }))
+        });
+        return;
+    }
+    log(`Scheduler: running (PID ${pid})`);
+    if (state) {
+        log(`Started: ${state.startedAt}`);
+        const routineStates = Object.values(state.routines);
+        if (routineStates.length === 0) {
+            log('\nNo scheduled routines.');
+        }
+        else {
+            log(`\nScheduled routines (${routineStates.length}):`);
+            log('');
+            for (const routine of routineStates) {
+                const scheduleStr = routine.schedule.cron
+                    ? `cron: ${routine.schedule.cron}`
+                    : `interval: ${routine.schedule.interval}`;
+                const statusIcon = routine.running ? '⏳' :
+                    routine.lastStatus === 'success' ? '✓' :
+                        routine.lastStatus === 'failed' ? '✗' : '○';
+                log(`  ${statusIcon} ${routine.name}`);
+                log(`    Schedule: ${scheduleStr}`);
+                if (routine.nextRunAt) {
+                    const nextRun = new Date(routine.nextRunAt);
+                    const now = new Date();
+                    const diffMs = nextRun.getTime() - now.getTime();
+                    const diffMins = Math.round(diffMs / 60000);
+                    if (diffMins < 1) {
+                        log(`    Next run: in < 1 minute`);
+                    }
+                    else if (diffMins < 60) {
+                        log(`    Next run: in ${diffMins} minute${diffMins === 1 ? '' : 's'}`);
+                    }
+                    else {
+                        const diffHours = Math.round(diffMins / 60);
+                        log(`    Next run: in ${diffHours} hour${diffHours === 1 ? '' : 's'}`);
+                    }
+                }
+                if (routine.lastRunAt) {
+                    log(`    Last run: ${routine.lastRunAt} (${routine.lastStatus})`);
+                }
+                log('');
+            }
+        }
+    }
+    output({
+        running: true,
+        pid,
+        startedAt: state?.startedAt,
+        routines: state ? Object.values(state.routines) : []
+    });
+}
+export async function schedulerLogsCommand(options) {
+    if (!existsSync(SCHEDULER_LOG_FILE)) {
+        log('No scheduler logs found.');
+        output({ logs: [] });
+        return;
+    }
+    const lines = options.lines ?? 50;
+    if (options.follow) {
+        // Tail -f mode
+        log(`Tailing scheduler logs (${SCHEDULER_LOG_FILE})...`);
+        log('Press Ctrl+C to stop\n');
+        // Read initial content
+        const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+        const allLines = content.split('\n');
+        const lastLines = allLines.slice(-lines);
+        process.stdout.write(lastLines.join('\n') + '\n');
+        // Watch for new content
+        const { watch } = await import('fs');
+        let lastSize = content.length;
+        const watcher = watch(SCHEDULER_LOG_FILE, (eventType) => {
+            if (eventType === 'change') {
+                const newContent = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+                if (newContent.length > lastSize) {
+                    process.stdout.write(newContent.slice(lastSize));
+                    lastSize = newContent.length;
+                }
+            }
+        });
+        // Keep running until interrupted
+        await new Promise((resolve) => {
+            let closed = false;
+            const closeWatcher = () => {
+                if (closed)
+                    return;
+                closed = true;
+                try {
+                    watcher.close();
+                }
+                catch {
+                    // ignore
+                }
+            };
+            const stop = () => {
+                closeWatcher();
+                resolve();
+            };
+            process.once('exit', closeWatcher);
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+    }
+    else {
+        // Read last N lines
+        const content = readFileSync(SCHEDULER_LOG_FILE, 'utf-8');
+        const allLines = content.split('\n').filter(l => l.trim());
+        const lastLines = allLines.slice(-lines);
+        for (const line of lastLines) {
+            log(line);
+        }
+        output({ logs: lastLines });
+    }
+}
+export async function schedulerHistoryCommand(routineName, options = {}) {
+    const limit = options.limit ?? 20;
+    const history = getRunHistory(routineName, limit);
+    if (history.length === 0) {
+        log(routineName
+            ? `No execution history found for routine: ${routineName}`
+            : 'No execution history found.');
+        output({ history: [] });
+        return;
+    }
+    log(routineName
+        ? `Execution history for ${routineName} (last ${history.length}):`
+        : `Execution history (last ${history.length}):`);
+    log('');
+    for (const record of history) {
+        const statusIcon = record.status === 'success' ? '✓' : '✗';
+        const duration = record.durationMs < 1000
+            ? `${record.durationMs}ms`
+            : `${(record.durationMs / 1000).toFixed(1)}s`;
+        log(`  ${statusIcon} ${record.routine}`);
+        log(`    Started: ${record.startedAt}`);
+        log(`    Duration: ${duration}`);
+        if (record.retryAttempt > 0) {
+            log(`    Retry: #${record.retryAttempt}`);
+        }
+        if (record.error) {
+            log(`    Error: ${record.error}`);
+        }
+        log('');
+    }
+    output({ history });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// SCHEDULER RUN
+// ═══════════════════════════════════════════════════════════════════════════
+export async function schedulerRunCommand(routineName) {
+    // Check if routine exists and is scheduled
+    const scheduledRoutines = getScheduledRoutines(process.cwd());
+    const routine = scheduledRoutines.find(r => r.name === routineName);
+    if (!routine) {
+        // Check if it exists but isn't scheduled
+        const { resolveRoutine } = await import('../core/routines.js');
+        const exists = resolveRoutine(routineName, process.cwd());
+        if (exists) {
+            outputError('NOT_FOUND', `Routine "${routineName}" exists but has no schedule configured`, {
+                hint: 'Add a "schedule" field to enable scheduling, or use "cli4ai routines run" for one-time execution'
+            });
+        }
+        else {
+            outputError('NOT_FOUND', `Routine not found: ${routineName}`);
+        }
+        return;
+    }
+    log(`Running routine: ${routineName}`);
+    const scheduler = new Scheduler({ projectDir: process.cwd() });
+    scheduler.refreshRoutines();
+    try {
+        const record = await scheduler.runNow(routineName);
+        if (record.status === 'success') {
+            log(`Routine completed successfully in ${record.durationMs}ms`);
+        }
+        else {
+            log(`Routine failed (exit code ${record.exitCode})`);
+            if (record.error) {
+                log(`Error: ${record.error}`);
+            }
+        }
+        output(record);
+    }
+    catch (err) {
+        outputError('API_ERROR', `Failed to run routine: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,9 @@
+/**
+ * cli4ai search - Search for packages
+ */
+interface SearchOptions {
+    limit?: string;
+    remote?: string;
+}
+export declare function searchCommand(query: string, options: SearchOptions): Promise<void>;
+export {};

package/dist/commands/search.js

@@ -0,0 +1,162 @@
+/**
+ * cli4ai search - Search for packages
+ */
+import { readdirSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import { spawnSync } from 'child_process';
+import { platform } from 'os';
+import { output, outputError, log } from '../lib/cli.js';
+// Windows-safe npm command
+const npmCmd = platform() === 'win32' ? 'npm.cmd' : 'npm';
+import { loadConfig, getGlobalPackages, getLocalPackages } from '../core/config.js';
+import { tryLoadManifest } from '../core/manifest.js';
+import { remoteListPackages, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
+export async function searchCommand(query, options) {
+    const limit = parseInt(options.limit || '20', 10);
+    const queryLower = query.toLowerCase();
+    // Handle remote search
+    if (options.remote) {
+        try {
+            const packageList = await remoteListPackages(options.remote);
+            const results = packageList.packages
+                .filter(pkg => pkg.name.toLowerCase().includes(queryLower) ||
+                pkg.path.toLowerCase().includes(queryLower))
+                .slice(0, limit)
+                .map(pkg => ({
+                name: pkg.name,
+                version: pkg.version,
+                source: 'remote',
+                installed: true
+            }));
+            output({
+                remote: options.remote,
+                query,
+                results,
+                count: results.length
+            });
+        }
+        catch (err) {
+            if (err instanceof RemoteConnectionError) {
+                outputError('NETWORK_ERROR', err.message, { remote: err.remoteName, url: err.url });
+            }
+            else if (err instanceof RemoteApiError) {
+                outputError(err.code, err.message, { remote: err.remoteName, details: err.details });
+            }
+            else {
+                throw err;
+            }
+        }
+        return;
+    }
+    const results = [];
+    const seen = new Set();
+    // Get installed packages
+    const installedNames = new Set([
+        ...getLocalPackages(process.cwd()).map(p => p.name),
+        ...getGlobalPackages().map(p => p.name)
+    ]);
+    // Search local registries
+    const config = loadConfig();
+    for (const registryPath of config.localRegistries) {
+        if (!existsSync(registryPath))
+            continue;
+        try {
+            for (const entry of readdirSync(registryPath, { withFileTypes: true })) {
+                if (!entry.isDirectory())
+                    continue;
+                if (seen.has(entry.name))
+                    continue;
+                const pkgPath = resolve(registryPath, entry.name);
+                const manifest = tryLoadManifest(pkgPath);
+                if (!manifest)
+                    continue;
+                // Check if matches query
+                if (matches(manifest, queryLower)) {
+                    seen.add(manifest.name);
+                    results.push({
+                        name: manifest.name,
+                        version: manifest.version,
+                        description: manifest.description,
+                        path: pkgPath,
+                        source: 'local-registry',
+                        installed: installedNames.has(manifest.name)
+                    });
+                }
+                if (results.length >= limit)
+                    break;
+            }
+        }
+        catch {
+            // Skip inaccessible registries
+        }
+        if (results.length >= limit)
+            break;
+    }
+    // Search npm for @cli4ai packages
+    if (results.length < limit) {
+        try {
+            log(`Searching npm for @cli4ai packages...`);
+            // Use spawnSync with argument array to prevent command injection
+            const searchResult = spawnSync(npmCmd, ['search', `@cli4ai/${query}`, '--json'], {
+                encoding: 'utf-8',
+                timeout: 10000,
+                stdio: ['pipe', 'pipe', 'pipe']
+            });
+            let npmResults = searchResult.stdout || '';
+            // Fallback to searching @cli4ai if specific query fails
+            if (!npmResults || npmResults === '[]') {
+                const fallbackResult = spawnSync(npmCmd, ['search', '@cli4ai', '--json'], {
+                    encoding: 'utf-8',
+                    timeout: 10000,
+                    stdio: ['pipe', 'pipe', 'pipe']
+                });
+                npmResults = fallbackResult.stdout || '[]';
+            }
+            const packages = JSON.parse(npmResults || '[]');
+            for (const pkg of packages) {
+                if (seen.has(pkg.name))
+                    continue;
+                // Filter to only @cli4ai scoped packages
+                if (!pkg.name.startsWith('@cli4ai/'))
+                    continue;
+                // Check if matches query
+                const shortName = pkg.name.replace('@cli4ai/', '');
+                if (shortName.toLowerCase().includes(queryLower) ||
+                    pkg.description?.toLowerCase().includes(queryLower) ||
+                    pkg.keywords?.some((k) => k.toLowerCase().includes(queryLower))) {
+                    seen.add(pkg.name);
+                    results.push({
+                        name: shortName,
+                        version: pkg.version,
+                        description: pkg.description,
+                        source: 'npm',
+                        installed: installedNames.has(shortName) || installedNames.has(pkg.name)
+                    });
+                }
+                if (results.length >= limit)
+                    break;
+            }
+        }
+        catch {
+            // npm search failed, continue with local results
+        }
+    }
+    output({
+        query,
+        results: results.slice(0, limit),
+        count: results.length,
+        registries: config.localRegistries
+    });
+}
+function matches(manifest, query) {
+    // Match against name
+    if (manifest.name.toLowerCase().includes(query))
+        return true;
+    // Match against description
+    if (manifest.description?.toLowerCase().includes(query))
+        return true;
+    // Match against keywords
+    if (manifest.keywords?.some(k => k.toLowerCase().includes(query)))
+        return true;
+    return false;
+}

package/dist/commands/secrets.d.ts

@@ -0,0 +1,28 @@
+/**
+ * cli4ai secrets - Manage secrets for CLI tools
+ */
+interface SecretsOptions {
+    package?: string;
+}
+/**
+ * cli4ai secrets set <key> [value]
+ */
+export declare function secretsSetCommand(key: string, value?: string): Promise<void>;
+/**
+ * cli4ai secrets get <key>
+ */
+export declare function secretsGetCommand(key: string): Promise<void>;
+/**
+ * cli4ai secrets list
+ */
+export declare function secretsListCommand(options: SecretsOptions): Promise<void>;
+/**
+ * cli4ai secrets delete <key>
+ */
+export declare function secretsDeleteCommand(key: string): Promise<void>;
+/**
+ * cli4ai secrets init [package]
+ * Interactive setup for a package's required secrets
+ */
+export declare function secretsInitCommand(packageName?: string, options?: SecretsOptions): Promise<void>;
+export {};