cli4ai 1.2.0 → 1.2.1

package/README.md

@@ -91,8 +91,47 @@ cli4ai update
 | Command | Description |
 |---------|-------------|
 | `cli4ai run <pkg> <cmd> [args]` | Run a tool command |
+| `cli4ai run --remote <name> <pkg> <cmd>` | Run on remote server |
 | `cli4ai start <pkg>` | Start package as MCP server |
 
+### Remote Servers
+
+Run tools on remote machines. Perfect for accessing tools on other computers or servers.
+
+| Command | Description |
+|---------|-------------|
+| `cli4ai serve` | Start remote server (default port 4100) |
+| `cli4ai remotes add <name> <url>` | Add a remote server |
+| `cli4ai remotes list` | List configured remotes |
+| `cli4ai remotes remove <name>` | Remove a remote |
+| `cli4ai list --remote <name>` | List packages on remote |
+| `cli4ai info --remote <name> <pkg>` | Get package info from remote |
+| `cli4ai search --remote <name> <query>` | Search packages on remote |
+
+**Example: Set up remote execution**
+
+```bash
+# On the server machine
+cli4ai serve --port 4100
+
+# On your local machine
+cli4ai remotes add my-server http://192.168.1.100:4100
+
+# Run tools remotely
+cli4ai run --remote my-server github notifs
+cli4ai list --remote my-server
+cli4ai info --remote my-server twitter
+```
+
+**Serve options:**
+
+```bash
+cli4ai serve                           # Start on port 4100
+cli4ai serve --port 8080               # Custom port
+cli4ai serve --api-key mysecretkey     # Require authentication
+cli4ai serve --scope read,write        # Restrict to specific scopes
+```
+
 ## MCP Integration
 
 cli4ai tools can run as MCP servers for Claude:

package/dist/bin.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * cli4ai - The package manager for AI CLI tools
+ * cli4ai.com
+ */
+export {};

package/dist/bin.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * cli4ai - The package manager for AI CLI tools
+ * cli4ai.com
+ */
+import { createProgram } from './cli.js';
+import { VERSION } from './lib/cli.js';
+import { getNpmGlobalPackages } from './core/config.js';
+// ANSI codes
+const RESET = '\x1B[0m';
+const BOLD = '\x1B[1m';
+const DIM = '\x1B[2m';
+const CYAN = '\x1B[36m';
+const WHITE = '\x1B[37m';
+const GREEN = '\x1B[32m';
+const YELLOW = '\x1B[33m';
+const MAGENTA = '\x1B[35m';
+/**
+ * Sleep helper
+ */
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+/**
+ * Robot eating dots animation
+ */
+async function showAnimation() {
+    const width = 35;
+    const robot = ['[•_•]', '[•_•]', '[°_°]', '[•_•]'];
+    const food = '·';
+    for (let pos = 0; pos <= width; pos++) {
+        process.stderr.write('\r\x1B[K');
+        const frame = robot[pos % robot.length];
+        const trail = ' '.repeat(pos) + food.repeat(width - pos);
+        process.stderr.write(`  ${CYAN}${frame}${RESET}${DIM}${trail}${RESET}`);
+        await sleep(20);
+    }
+    process.stderr.write('\r\x1B[K');
+}
+/**
+ * Animate the robot face (blinking)
+ */
+async function animateRobotFace() {
+    const faces = ['[•_•]', '[•_•]', '[-_-]', '[•_•]', '[•_•]', '[°_°]', '[•_•]'];
+    const line = ` ${BOLD}${CYAN}cli4ai${RESET} ${DIM}─${RESET} ${WHITE}cli4ai.com${RESET}`;
+    for (const face of faces) {
+        process.stderr.write(`\r  ${CYAN}${face}${RESET}${line}`);
+        await sleep(120);
+    }
+    console.error('');
+}
+async function showBanner() {
+    if (!process.stderr.isTTY)
+        return;
+    console.error('');
+    // Fun robot eating animation
+    await showAnimation();
+    // Animated robot branding (blinking)
+    await animateRobotFace();
+    console.error(`        ${DIM}The package manager for AI CLI tools${RESET}`);
+    console.error(`        ${DIM}v${VERSION}${RESET}`);
+    console.error('');
+    console.error(`  ${BOLD}Commands${RESET}`);
+    console.error(`  ${DIM}${'─'.repeat(40)}${RESET}`);
+    console.error(`  ${GREEN}browse${RESET}              ${DIM}Browse & install packages${RESET}`);
+    console.error(`  ${GREEN}run${RESET} ${CYAN}<pkg> <cmd>${RESET}    ${DIM}Run a tool command${RESET}`);
+    console.error(`  ${GREEN}ls${RESET}                  ${DIM}List installed packages${RESET}`);
+    console.error(`  ${GREEN}update${RESET}              ${DIM}Update all packages${RESET}`);
+    console.error('');
+    console.error(`  ${DIM}Run${RESET} ${WHITE}cli4ai --help${RESET} ${DIM}for all commands${RESET}`);
+    console.error('');
+    // Check for updates in background (non-blocking)
+    checkUpdatesInBackground();
+}
+/**
+ * Check for updates without blocking - spawns detached process
+ */
+function checkUpdatesInBackground() {
+    // Quick local check only - don't hit network
+    try {
+        const packages = getNpmGlobalPackages();
+        if (packages.length > 0) {
+            // Spawn a background process to check updates and cache results
+            const { spawn } = require('child_process');
+            const child = spawn('sh', ['-c', 'timeout 3 npm view cli4ai version 2>/dev/null > /tmp/.cli4ai-update-check 2>&1 &'], {
+                detached: true,
+                stdio: ['ignore', 'ignore', 'ignore']
+            });
+            child.unref();
+        }
+    }
+    catch {
+        // Ignore errors - this is best effort
+    }
+}
+// Check if running without command (just `cli4ai`)
+const args = process.argv.slice(2);
+const hasCommand = args.length > 0 && !args[0].startsWith('-');
+const isHelp = args.includes('--help') || args.includes('-h');
+const isVersion = args.includes('--version') || args.includes('-v');
+if (!hasCommand && !isHelp && !isVersion) {
+    showBanner().then(() => process.exit(0));
+}
+else {
+    const program = createProgram();
+    program.parse(process.argv);
+}

package/dist/cli.d.ts

@@ -0,0 +1,5 @@
+/**
+ * cli4ai CLI - Main program setup
+ */
+import { Command } from 'commander';
+export declare function createProgram(): Command;

package/dist/cli.js

@@ -0,0 +1,335 @@
+/**
+ * cli4ai CLI - Main program setup
+ */
+import { Command } from 'commander';
+import { BRAND, VERSION, withErrorHandling } from './lib/cli.js';
+// Commands
+import { initCommand } from './commands/init.js';
+import { addCommand } from './commands/add.js';
+import { removeCommand } from './commands/remove.js';
+import { listCommand } from './commands/list.js';
+import { runCommand } from './commands/run.js';
+import { infoCommand } from './commands/info.js';
+import { searchCommand } from './commands/search.js';
+import { configCommand } from './commands/config.js';
+import { mcpConfigCommand } from './commands/mcp-config.js';
+import { startCommand } from './commands/start.js';
+import { secretsSetCommand, secretsGetCommand, secretsListCommand, secretsDeleteCommand, secretsInitCommand } from './commands/secrets.js';
+import { browseCommand } from './commands/browse.js';
+import { updateCommand } from './commands/update.js';
+import { routinesListCommand, routinesRunCommand, routinesShowCommand, routinesCreateCommand, routinesEditCommand, routinesRemoveCommand } from './commands/routines.js';
+import { schedulerStartCommand, schedulerStopCommand, schedulerStatusCommand, schedulerLogsCommand, schedulerHistoryCommand, schedulerRunCommand } from './commands/scheduler.js';
+import { remotesListCommand, remotesAddCommand, remotesUpdateCommand, remotesRemoveCommand, remotesShowCommand, remotesTestCommand, remotesPackagesCommand } from './commands/remotes.js';
+import { serveCommand } from './commands/serve.js';
+export function createProgram() {
+    const program = new Command()
+        .name('cli4ai')
+        .version(VERSION, '-v, --version', 'Show version')
+        .description('The package manager for AI CLI tools')
+        .addHelpText('beforeAll', `\n${BRAND}\n`)
+        .configureOutput({
+        writeErr: (str) => {
+            if (!str.includes('"error"')) {
+                process.stderr.write(str);
+            }
+        }
+    });
+    // ═══════════════════════════════════════════════════════════════════════════
+    // PACKAGE MANAGEMENT
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('init [name]')
+        .description('Create a new cli4ai tool project')
+        .option('-t, --template <template>', 'Template to use (basic, api, browser)', 'basic')
+        .option('-r, --runtime <runtime>', 'Runtime (node, bun)', 'node')
+        .option('-y, --yes', 'Skip prompts, use defaults')
+        .action(withErrorHandling(initCommand));
+    program
+        .command('add <packages...>')
+        .description('Install packages')
+        .option('-l, --local', 'Install from local path')
+        .option('-g, --global', 'Install globally')
+        .option('-D, --save-dev', 'Save as dev dependency')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .action(withErrorHandling(addCommand));
+    program
+        .command('remove <packages...>')
+        .alias('rm')
+        .alias('uninstall')
+        .description('Remove packages')
+        .option('-g, --global', 'Remove from global packages')
+        .action(withErrorHandling(removeCommand));
+    program
+        .command('list')
+        .alias('ls')
+        .description('List installed packages')
+        .option('-g, --global', 'List global packages')
+        .option('-r, --remote <name>', 'List packages on a remote server')
+        .option('--json', 'Output as JSON')
+        .action(withErrorHandling(listCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // EXECUTION
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('run <package> [command] [args...]')
+        .description('Run a tool command')
+        .option('-e, --env <vars...>', 'Environment variables (KEY=value)')
+        .option('--scope <level>', 'Permission scope: read, write, or full (default: full)')
+        .option('--sandbox', 'Run in sandboxed environment with restricted file system access')
+        .option('-r, --remote <name>', 'Execute on a remote cli4ai service')
+        .option('--timeout <ms>', 'Timeout in milliseconds')
+        // Allow passing tool flags through (e.g. `cli4ai run chrome screenshot --full-page`)
+        .allowUnknownOption(true)
+        .addHelpText('after', `
+
+Examples:
+  cli4ai run github trending
+  cli4ai run chrome screenshot https://example.com --full-page
+  cli4ai run github list-issues --scope read
+  cli4ai run untrusted-pkg process --sandbox
+  cli4ai run browser screenshot --remote chrome-server
+
+Pass-through:
+  Use "--" to pass flags that would otherwise be parsed by cli4ai:
+  cli4ai run <pkg> <cmd> -- --help
+
+Security:
+  --scope read    Only allow read operations (no mutations)
+  --scope write   Allow write operations
+  --scope full    Full access (default)
+  --sandbox       Restrict file system access to temp directories
+
+Remote Execution:
+  --remote <name>  Execute on a configured remote service
+                   Use "cli4ai remotes add" to configure remotes
+`)
+        .action(withErrorHandling(runCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // DISCOVERY
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('info <package>')
+        .description('Show package information')
+        .option('--versions', 'Show all available versions')
+        .option('-r, --remote <name>', 'Get info from a remote server')
+        .action(withErrorHandling(infoCommand));
+    program
+        .command('search <query>')
+        .description('Search for packages')
+        .option('-l, --limit <n>', 'Max results', '20')
+        .option('-r, --remote <name>', 'Search packages on a remote server')
+        .action(withErrorHandling(searchCommand));
+    program
+        .command('browse')
+        .description('Interactive package browser')
+        .action(withErrorHandling(browseCommand));
+    program
+        .command('update')
+        .alias('upgrade')
+        .description('Update installed packages')
+        .option('-s, --self', 'Update cli4ai framework only')
+        .option('-a, --all', 'Update cli4ai framework and all packages')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .action(withErrorHandling(updateCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // CONFIGURATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('config [key] [value]')
+        .description('Get or set configuration')
+        .option('--list', 'List all config values')
+        .option('--add-registry <path>', 'Add local registry path')
+        .option('--remove-registry <path>', 'Remove local registry path')
+        .action(withErrorHandling(configCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // MCP INTEGRATION
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('mcp-config')
+        .description('Generate MCP configuration for Claude Code')
+        .option('-g, --global', 'Use global packages only')
+        .option('-p, --package <name>', 'Generate for specific package')
+        .option('--snippet', 'Output as config snippet (use with --package)')
+        .action(withErrorHandling(mcpConfigCommand));
+    program
+        .command('start <package>')
+        .description('Start MCP server for a package')
+        .option('--stdio', 'Use stdio transport (default)')
+        .action(withErrorHandling(startCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // SECRETS MANAGEMENT
+    // ═══════════════════════════════════════════════════════════════════════════
+    const secrets = program
+        .command('secrets')
+        .description('Manage secrets for CLI tools');
+    secrets
+        .command('set <key> [value]')
+        .description('Set a secret (prompts for value if not provided)')
+        .action(withErrorHandling(secretsSetCommand));
+    secrets
+        .command('get <key>')
+        .description('Get a secret value')
+        .action(withErrorHandling(secretsGetCommand));
+    secrets
+        .command('list')
+        .alias('ls')
+        .description('List all secrets')
+        .option('-p, --package <name>', 'Show secrets for a specific package')
+        .action(withErrorHandling(secretsListCommand));
+    secrets
+        .command('delete <key>')
+        .alias('rm')
+        .description('Delete a secret')
+        .action(withErrorHandling(secretsDeleteCommand));
+    secrets
+        .command('init <package>')
+        .description('Interactive setup for a package\'s required secrets')
+        .action(withErrorHandling(secretsInitCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // HELP
+    // ═══════════════════════════════════════════════════════════════════════════
+    program.addHelpCommand('help [command]', 'Show help for command');
+    // ═══════════════════════════════════════════════════════════════════════════
+    // ROUTINES
+    // ═══════════════════════════════════════════════════════════════════════════
+    const routines = program
+        .command('routines')
+        .description('Manage and run routines');
+    routines
+        .command('list')
+        .alias('ls')
+        .description('List available routines')
+        .option('-g, --global', 'Use global routines only')
+        .option('--json', 'Output as JSON')
+        .action(withErrorHandling(routinesListCommand));
+    routines
+        .command('show <name>')
+        .description('Show routine definition')
+        .option('-g, --global', 'Use global routines only')
+        .action(withErrorHandling(routinesShowCommand));
+    routines
+        .command('create <name>')
+        .description('Create a new routine')
+        .option('-g, --global', 'Create routine globally')
+        .option('--type <type>', 'Routine type (yaml, json, bash)', 'yaml')
+        .action(withErrorHandling(routinesCreateCommand));
+    routines
+        .command('edit <name>')
+        .description('Edit a routine in $EDITOR')
+        .option('-g, --global', 'Use global routine only')
+        .action(withErrorHandling(routinesEditCommand));
+    routines
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove a routine')
+        .option('-g, --global', 'Use global routine only')
+        .action(withErrorHandling(routinesRemoveCommand));
+    routines
+        .command('run <name> [args...]')
+        .description('Run a routine')
+        .option('-g, --global', 'Use global routine only')
+        .option('--var <vars...>', 'Variables (KEY=value)')
+        .option('--dry-run', 'Show execution plan without running')
+        .action(withErrorHandling(routinesRunCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // SCHEDULER
+    // ═══════════════════════════════════════════════════════════════════════════
+    const scheduler = program
+        .command('scheduler')
+        .description('Manage scheduled routine execution');
+    scheduler
+        .command('start')
+        .description('Start the scheduler daemon')
+        .option('-f, --foreground', 'Run in foreground (blocking)')
+        .action(withErrorHandling(schedulerStartCommand));
+    scheduler
+        .command('stop')
+        .description('Stop the scheduler daemon')
+        .action(withErrorHandling(schedulerStopCommand));
+    scheduler
+        .command('status')
+        .description('Show scheduler status and upcoming runs')
+        .action(withErrorHandling(schedulerStatusCommand));
+    scheduler
+        .command('logs')
+        .description('View scheduler logs')
+        .option('-f, --follow', 'Follow log output')
+        .option('-n, --lines <n>', 'Number of lines to show', '50')
+        .action(withErrorHandling(schedulerLogsCommand));
+    scheduler
+        .command('history [routine]')
+        .description('View routine execution history')
+        .option('-n, --limit <n>', 'Number of records to show', '20')
+        .action(withErrorHandling(schedulerHistoryCommand));
+    scheduler
+        .command('run <routine>')
+        .description('Manually trigger a scheduled routine')
+        .action(withErrorHandling(schedulerRunCommand));
+    // ═══════════════════════════════════════════════════════════════════════════
+    // REMOTE EXECUTION
+    // ═══════════════════════════════════════════════════════════════════════════
+    program
+        .command('serve')
+        .description('Start cli4ai as a remote service')
+        .option('-p, --port <port>', 'Port to listen on', '4100')
+        .option('-H, --host <host>', 'Host to bind to', '0.0.0.0')
+        .option('-k, --api-key <key>', 'API key for authentication')
+        .option('--scope <levels>', 'Comma-separated allowed scopes (read,write,full)')
+        .option('--cwd <dir>', 'Working directory for execution')
+        .addHelpText('after', `
+
+Examples:
+  cli4ai serve                           # Start on port 4100
+  cli4ai serve --port 8080               # Start on port 8080
+  cli4ai serve --api-key mysecretkey     # Require API key
+  cli4ai serve --scope read,write        # Restrict to read/write operations
+
+The service exposes these endpoints:
+  GET  /health              - Service health check
+  GET  /packages            - List available packages
+  GET  /packages/:name      - Get package info
+  POST /run                 - Execute a tool
+  POST /routines/:name/run  - Run a routine
+`)
+        .action(withErrorHandling(serveCommand));
+    const remotes = program
+        .command('remotes')
+        .description('Manage remote cli4ai services');
+    remotes
+        .command('list')
+        .alias('ls')
+        .description('List configured remotes')
+        .action(withErrorHandling(remotesListCommand));
+    remotes
+        .command('add <name> <url>')
+        .description('Add a remote service')
+        .option('-k, --api-key <key>', 'API key for authentication')
+        .option('-d, --description <desc>', 'Description of this remote')
+        .option('--no-test', 'Skip connection test')
+        .action(withErrorHandling(remotesAddCommand));
+    remotes
+        .command('update <name>')
+        .description('Update a remote service')
+        .option('-u, --url <url>', 'New URL')
+        .option('-k, --api-key <key>', 'New API key')
+        .option('-d, --description <desc>', 'New description')
+        .action(withErrorHandling(remotesUpdateCommand));
+    remotes
+        .command('remove <name>')
+        .alias('rm')
+        .description('Remove a remote')
+        .action(withErrorHandling(remotesRemoveCommand));
+    remotes
+        .command('show <name>')
+        .description('Show remote details')
+        .action(withErrorHandling(remotesShowCommand));
+    remotes
+        .command('test <name>')
+        .description('Test connection to a remote')
+        .action(withErrorHandling(remotesTestCommand));
+    remotes
+        .command('packages <name>')
+        .description('List packages on a remote')
+        .action(withErrorHandling(remotesPackagesCommand));
+    return program;
+}

package/dist/commands/add.d.ts

@@ -0,0 +1,11 @@
+/**
+ * cli4ai add - Install packages
+ */
+interface AddOptions {
+    local?: boolean;
+    global?: boolean;
+    saveDev?: boolean;
+    yes?: boolean;
+}
+export declare function addCommand(packages: string[], options: AddOptions): Promise<void>;
+export {};