cli4ai 1.2.4 → 1.2.6

package/dist/cli.js

@@ -21,6 +21,7 @@ import { routinesListCommand, routinesRunCommand, routinesShowCommand, routinesC
 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';
+import { downloadCommand } from './commands/download.js';
 export function createProgram() {
     const program = new Command()
         .name('cli4ai')
@@ -276,6 +277,8 @@ Remote Execution:
         .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')
+        .option('--ui', 'Enable the dashboard UI at /ui')
+        .option('--allow-path <path>', 'Allow file downloads from path (can be used multiple times)', (val, prev) => prev.concat([val]), [])
         .addHelpText('after', `
 
 Examples:
@@ -283,13 +286,26 @@ Examples:
   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
+  cli4ai serve --ui                      # Enable dashboard at /ui
+  cli4ai serve --allow-path /data        # Allow file downloads from /data
 
 The service exposes these endpoints:
   GET  /health              - Service health check
   GET  /packages            - List available packages
   GET  /packages/:name      - Get package info
+  GET  /files?path=<path>   - Download file (restricted to allowed paths)
   POST /run                 - Execute a tool
   POST /routines/:name/run  - Run a routine
+
+By default, file downloads are allowed from: cwd, tmpdir, ~/Downloads.
+Use --allow-path to add additional directories.
+
+With --ui flag, additional endpoints are available:
+  GET  /ui                  - Dashboard web interface
+  GET  /api/runs            - Run history
+  GET  /api/routines        - Routine management
+  GET  /api/scheduler       - Scheduler status
+  GET  /api/metrics         - Metrics and stats
 `)
         .action(withErrorHandling(serveCommand));
     const remotes = program
@@ -331,5 +347,20 @@ The service exposes these endpoints:
         .command('packages <name>')
         .description('List packages on a remote')
         .action(withErrorHandling(remotesPackagesCommand));
+    program
+        .command('download <remote> <path>')
+        .description('Download a file from a remote service')
+        .option('-o, --output <path>', 'Local output path (default: current directory)')
+        .addHelpText('after', `
+
+Examples:
+  cli4ai download myserver /path/to/file.jpg
+  cli4ai download myserver /tmp/output.pdf -o ./local.pdf
+  cli4ai download mac ~/Downloads/image.png -o ./image.png
+
+The remote must be configured via 'cli4ai remotes add' first.
+File access is restricted to allowed paths on the server.
+`)
+        .action(withErrorHandling(downloadCommand));
     return program;
 }

package/dist/commands/add.js

@@ -59,11 +59,15 @@ async function confirm(message) {
         input: process.stdin,
         output: process.stderr
     });
-    return new Promise((resolve) => {
+    return new Promise((resolve, reject) => {
         rl.question(`${message} [y/N] `, (answer) => {
             rl.close();
             resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
         });
+        rl.on('error', (err) => {
+            rl.close();
+            reject(err);
+        });
     });
 }
 /**

package/dist/commands/browse.js

@@ -190,61 +190,74 @@ async function multiSelect(items) {
         log('');
     };
     return new Promise((resolve) => {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-        render();
-        const onKeypress = (key) => {
-            // Handle arrow keys (escape sequences)
-            if (key === '\x1B[A' || key === 'k') {
-                // Up arrow or k
-                cursor = Math.max(0, cursor - 1);
-                render();
-            }
-            else if (key === '\x1B[B' || key === 'j') {
-                // Down arrow or j
-                cursor = Math.min(items.length - 1, cursor + 1);
-                render();
-            }
-            else if (key === ' ') {
-                // Space - toggle selection
-                if (selected.has(cursor)) {
-                    selected.delete(cursor);
+        try {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            render();
+            const onKeypress = (key) => {
+                // Handle arrow keys (escape sequences)
+                if (key === '\x1B[A' || key === 'k') {
+                    // Up arrow or k
+                    cursor = Math.max(0, cursor - 1);
+                    render();
                 }
-                else {
-                    selected.add(cursor);
+                else if (key === '\x1B[B' || key === 'j') {
+                    // Down arrow or j
+                    cursor = Math.min(items.length - 1, cursor + 1);
+                    render();
+                }
+                else if (key === ' ') {
+                    // Space - toggle selection
+                    if (selected.has(cursor)) {
+                        selected.delete(cursor);
+                    }
+                    else {
+                        selected.add(cursor);
+                    }
+                    render();
+                }
+                else if (key === '\r' || key === '\n') {
+                    // Enter - confirm
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', onKeypress);
+                    process.stdin.pause();
+                    process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
+                    const selectedPackages = Array.from(selected).map(i => items[i].name);
+                    resolve(selectedPackages);
+                }
+                else if (key === 'q' || key === '\x1B' || key === '\x03') {
+                    // q, Escape, or Ctrl+C - quit
+                    process.stdin.setRawMode(false);
+                    process.stdin.removeListener('data', onKeypress);
+                    process.stdin.pause();
+                    process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
+                    resolve([]);
+                }
+                else if (key === 'a') {
+                    // Select all
+                    items.forEach((_, i) => selected.add(i));
+                    render();
+                }
+                else if (key === 'n') {
+                    // Select none
+                    selected.clear();
+                    render();
+                }
+            };
+            process.stdin.on('data', onKeypress);
+        }
+        finally {
+            // Ensure raw mode is reset even if an error occurs
+            if (process.stdin.isTTY && process.stdin.setRawMode) {
+                try {
+                    process.stdin.setRawMode(false);
+                }
+                catch {
+                    // Ignore errors when resetting raw mode
                 }
-                render();
-            }
-            else if (key === '\r' || key === '\n') {
-                // Enter - confirm
-                process.stdin.setRawMode(false);
-                process.stdin.removeListener('data', onKeypress);
-                process.stdin.pause();
-                process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
-                const selectedPackages = Array.from(selected).map(i => items[i].name);
-                resolve(selectedPackages);
-            }
-            else if (key === 'q' || key === '\x1B' || key === '\x03') {
-                // q, Escape, or Ctrl+C - quit
-                process.stdin.setRawMode(false);
-                process.stdin.removeListener('data', onKeypress);
-                process.stdin.pause();
-                process.stderr.write('\x1B[2J\x1B[H'); // Clear screen
-                resolve([]);
-            }
-            else if (key === 'a') {
-                // Select all
-                items.forEach((_, i) => selected.add(i));
-                render();
-            }
-            else if (key === 'n') {
-                // Select none
-                selected.clear();
-                render();
             }
-        };
-        process.stdin.on('data', onKeypress);
+        }
     });
 }
 /**

package/dist/commands/download.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Download command - Download files from a remote cli4ai service.
+ */
+export interface DownloadCommandOptions {
+    output?: string;
+}
+export declare function downloadCommand(remoteName: string, filePath: string, options: DownloadCommandOptions): Promise<void>;

package/dist/commands/download.js

@@ -0,0 +1,36 @@
+/**
+ * Download command - Download files from a remote cli4ai service.
+ */
+import { basename, resolve } from 'path';
+import { output, outputError, log } from '../lib/cli.js';
+import { remoteDownloadFile, RemoteConnectionError, RemoteApiError } from '../core/remote-client.js';
+export async function downloadCommand(remoteName, filePath, options) {
+    // Determine output path
+    const outputPath = options.output
+        ? resolve(options.output)
+        : resolve(process.cwd(), basename(filePath));
+    log(`Downloading from ${remoteName}: ${filePath}`);
+    log(`Saving to: ${outputPath}`);
+    try {
+        const result = await remoteDownloadFile(remoteName, filePath, outputPath);
+        output({
+            success: true,
+            remote: remoteName,
+            remotePath: filePath,
+            localPath: result.path,
+            size: result.size
+        });
+    }
+    catch (err) {
+        if (err instanceof RemoteConnectionError) {
+            outputError('CONNECTION_ERROR', err.message, {
+                remote: remoteName,
+                url: err.url
+            });
+        }
+        if (err instanceof RemoteApiError) {
+            outputError(err.code, err.message, err.details);
+        }
+        outputError('DOWNLOAD_ERROR', err instanceof Error ? err.message : String(err));
+    }
+}

package/dist/commands/routines.js

@@ -4,8 +4,10 @@
 import { spawn, spawnSync } from 'child_process';
 import { readFileSync, writeFileSync, existsSync, chmodSync, rmSync } from 'fs';
 import { resolve } from 'path';
+import { platform } from 'os';
 import { stringify as stringifyYaml } from 'yaml';
 import { output, outputError, log } from '../lib/cli.js';
+const isWindows = platform() === 'win32';
 import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from '../core/config.js';
 import { getGlobalRoutines, getLocalRoutines, resolveRoutine, validateRoutineName } from '../core/routines.js';
 import { loadRoutineDefinition, dryRunRoutine, runRoutine, RoutineParseError, RoutineValidationError, RoutineTemplateError } from '../core/routine-engine.js';
@@ -30,7 +32,7 @@ function parseVars(vars) {
         return result;
     for (const entry of vars) {
         const eq = entry.indexOf('=');
-        if (eq <= 0) {
+        if (eq < 0) {
             outputError('INVALID_INPUT', `Invalid --var (expected KEY=value): ${entry}`);
         }
         const key = entry.slice(0, eq).trim();
@@ -256,6 +258,7 @@ export async function routinesRunCommand(name, args, options) {
     const child = spawn('bash', [routine.path, ...args], {
         cwd: process.cwd(),
         stdio: isTTY ? 'inherit' : ['pipe', 'pipe', 'pipe'],
+        shell: isWindows,
         env: {
             ...process.env,
             ...varEnv,
@@ -272,9 +275,12 @@ export async function routinesRunCommand(name, args, options) {
     }
     // Non-TTY: capture and emit single JSON summary.
     const stdoutPromise = child.stdout ? collectStream(child.stdout) : Promise.resolve('');
-    const stderrPromise = child.stderr ? collectStream(child.stderr) : Promise.resolve('');
+    // Stream stderr to process.stderr while collecting it
+    const stderrChunks = [];
     if (child.stderr) {
         child.stderr.on('data', (chunk) => {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+            stderrChunks.push(buf);
             process.stderr.write(chunk);
         });
     }
@@ -282,7 +288,8 @@ export async function routinesRunCommand(name, args, options) {
         child.on('close', (code) => resolve(code ?? 0));
         child.on('error', (err) => outputError('API_ERROR', `Failed to execute routine: ${err.message}`));
     });
-    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    const stdout = await stdoutPromise;
+    const stderr = Buffer.concat(stderrChunks).toString('utf-8');
     output({
         routine: routine.name,
         kind: routine.kind,

package/dist/commands/scheduler.js

@@ -12,7 +12,9 @@ import { spawn } from 'child_process';
 import { readFileSync, existsSync } from 'fs';
 import { resolve, dirname } from 'path';
 import { fileURLToPath } from 'url';
+import { platform } from 'os';
 import { output, outputError, log } from '../lib/cli.js';
+const isWindows = platform() === 'win32';
 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) {
@@ -55,6 +57,7 @@ export async function schedulerStartCommand(options) {
     const child = spawn('npx', ['tsx', daemonScript, '--project-dir', process.cwd()], {
         detached: true,
         stdio: 'ignore',
+        shell: isWindows,
         env: {
             ...process.env,
             CLI4AI_DAEMON: 'true'

package/dist/commands/secrets.js

@@ -33,32 +33,45 @@ async function prompt(message, hidden = false) {
             // 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);
+            try {
+                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);
+            }
+            finally {
+                // Ensure raw mode is reset even if an error occurs
+                if (process.stdin.isTTY && process.stdin.setRawMode) {
+                    try {
+                        process.stdin.setRawMode(false);
+                    }
+                    catch {
+                        // Ignore errors when resetting raw mode
                     }
                 }
-                else {
-                    value += char;
-                }
-            };
-            process.stdin.on('data', onData);
+            }
         }
         else {
             rl.question(message, (answer) => {

package/dist/commands/serve.d.ts

@@ -9,5 +9,9 @@ export interface ServeCommandOptions {
     apiKey?: string;
     scope?: string;
     cwd?: string;
+    /** Enable the dashboard UI at /ui */
+    ui?: boolean;
+    /** Additional paths allowed for file downloads */
+    allowPath?: string[];
 }
 export declare function serveCommand(options: ServeCommandOptions): Promise<void>;

package/dist/commands/serve.js

@@ -36,6 +36,15 @@ export async function serveCommand(options) {
         }
         serviceOptions.allowedScopes = scopes;
     }
+    // Enable dashboard UI
+    if (options.ui) {
+        serviceOptions.enableDashboard = true;
+    }
+    // Additional allowed paths for file downloads (adds to defaults)
+    if (options.allowPath && options.allowPath.length > 0) {
+        // Pass extra paths - service will merge with defaults
+        serviceOptions.allowedPaths = options.allowPath;
+    }
     try {
         await startService(serviceOptions);
         output({ status: 'stopped' });

package/dist/commands/update.js

@@ -2,7 +2,9 @@
  * cli4ai update - Update installed packages and cli4ai itself
  */
 import { spawn } from 'child_process';
+import { platform } from 'os';
 import { log } from '../lib/cli.js';
+const isWindows = platform() === 'win32';
 import { getNpmGlobalPackages, getGlobalPackages } from '../core/config.js';
 // ANSI colors
 const RESET = '\x1B[0m';
@@ -50,7 +52,8 @@ 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'
+            stdio: 'pipe',
+            shell: isWindows
         });
         proc.on('close', (code) => {
             resolve(code === 0);
@@ -66,7 +69,8 @@ async function updateCli4aiPackage(packageName) {
 async function updateNpmPackage(packageName) {
     return new Promise((resolve) => {
         const proc = spawn('npm', ['install', '-g', `${packageName}@latest`], {
-            stdio: 'pipe'
+            stdio: 'pipe',
+            shell: isWindows
         });
         proc.on('close', (code) => {
             resolve(code === 0);

package/dist/core/execute.d.ts

@@ -27,6 +27,10 @@ export interface ExecuteToolOptions {
     scope?: ScopeLevel;
     /** Run in sandboxed environment with restricted file system access */
     sandbox?: boolean;
+    /** Callback for each stdout line (for live streaming) */
+    onStdoutLine?: (line: string) => void;
+    /** Callback for each stderr line (for live streaming) */
+    onStderrLine?: (line: string) => void;
 }
 export interface ExecuteToolResult {
     exitCode: number;

package/dist/core/execute.js

@@ -399,8 +399,8 @@ export async function executeTool(options) {
             }
         });
         const exitCode = await new Promise((resolve, reject) => {
-            proc.on('close', (code) => resolve(code ?? 0));
-            proc.on('error', (err) => {
+            proc.once('close', (code) => resolve(code ?? 0));
+            proc.once('error', (err) => {
                 reject(new ExecuteToolError('API_ERROR', `Failed to execute: ${err.message}`));
             });
         });
@@ -437,13 +437,33 @@ export async function executeTool(options) {
         // Don’t block on stdin if nothing is provided
         proc.stdin.end();
     }
-    if (teeStderr && proc.stderr) {
-        proc.stderr.on('data', (chunk) => {
-            process.stderr.write(chunk);
+    // Set up line-by-line streaming for callbacks
+    const stdoutLines = [];
+    const stderrLines = [];
+    const readlineInterfaces = [];
+    if (proc.stdout) {
+        const rl = createInterface({ input: proc.stdout, crlfDelay: Infinity });
+        readlineInterfaces.push(rl);
+        rl.on('line', (line) => {
+            stdoutLines.push(line);
+            if (options.onStdoutLine) {
+                options.onStdoutLine(line);
+            }
+        });
+    }
+    if (proc.stderr) {
+        const rl = createInterface({ input: proc.stderr, crlfDelay: Infinity });
+        readlineInterfaces.push(rl);
+        rl.on('line', (line) => {
+            stderrLines.push(line);
+            if (teeStderr) {
+                process.stderr.write(line + '\n');
+            }
+            if (options.onStderrLine) {
+                options.onStderrLine(line);
+            }
         });
     }
-    const stdoutPromise = proc.stdout ? collectStream(proc.stdout) : Promise.resolve('');
-    const stderrPromise = proc.stderr ? collectStream(proc.stderr) : Promise.resolve('');
     let timeout;
     if (options.timeoutMs && options.timeoutMs > 0) {
         timeout = setTimeout(() => {
@@ -460,18 +480,23 @@ export async function executeTool(options) {
         }, options.timeoutMs);
     }
     const exitCode = await new Promise((resolve, reject) => {
-        proc.on('close', (code) => resolve(code ?? 0));
-        proc.on('error', (err) => reject(new ExecuteToolError('API_ERROR', `Failed to execute: ${err.message}`)));
+        proc.once('close', (code) => resolve(code ?? 0));
+        proc.once('error', (err) => reject(new ExecuteToolError('API_ERROR', `Failed to execute: ${err.message}`)));
     }).finally(() => {
         if (timeout)
             clearTimeout(timeout);
+        // Close all readline interfaces
+        for (const rl of readlineInterfaces) {
+            rl.close();
+        }
     });
-    const [stdout, stderr] = await Promise.all([stdoutPromise, stderrPromise]);
+    // Small delay to ensure all readline events are processed
+    await new Promise(r => setTimeout(r, 10));
     return {
         exitCode,
         durationMs: Date.now() - startTime,
-        stdout,
-        stderr,
+        stdout: stdoutLines.length > 0 ? stdoutLines.join('\n') + '\n' : '',
+        stderr: stderrLines.length > 0 ? stderrLines.join('\n') + '\n' : '',
         packagePath: pkg.path,
         entryPath,
         runtime

package/dist/core/remote-client.d.ts

@@ -88,6 +88,14 @@ export declare function remoteRunTool(remoteName: string, options: RemoteRunOpti
  * Run a routine on a remote
  */
 export declare function remoteRunRoutine(remoteName: string, routineName: string, vars?: Record<string, string>): Promise<RoutineRunSummary>;
+/**
+ * Download a file from a remote
+ */
+export declare function remoteDownloadFile(remoteName: string, filePath: string, outputPath: string): Promise<{
+    success: boolean;
+    size: number;
+    path: string;
+}>;
 /**
  * Test connection to a remote
  */

package/dist/core/remote-client.js

@@ -214,6 +214,73 @@ export async function remoteRunRoutine(remoteName, routineName, vars) {
         throw new RemoteConnectionError(remoteName, remote.url, err instanceof Error ? err.message : String(err));
     }
 }
+/**
+ * Download a file from a remote
+ */
+export async function remoteDownloadFile(remoteName, filePath, outputPath) {
+    const remote = getRemoteOrThrow(remoteName);
+    const url = new URL('/files', remote.url);
+    url.searchParams.set('path', filePath);
+    const { createWriteStream, promises: fs } = await import('fs');
+    const { pipeline } = await import('stream/promises');
+    return new Promise((resolve, reject) => {
+        const isHttps = url.protocol === 'https:';
+        const requestFn = isHttps ? httpsRequest : httpRequest;
+        const headers = {};
+        if (remote.apiKey) {
+            headers['X-API-Key'] = remote.apiKey;
+        }
+        const options = {
+            method: 'GET',
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            headers,
+            timeout: 300000 // 5 min timeout for file downloads
+        };
+        const req = requestFn(options, async (res) => {
+            if (res.statusCode === 200) {
+                try {
+                    const writeStream = createWriteStream(outputPath);
+                    await pipeline(res, writeStream);
+                    const stats = await fs.stat(outputPath);
+                    updateRemoteLastConnected(remoteName);
+                    resolve({
+                        success: true,
+                        size: stats.size,
+                        path: outputPath
+                    });
+                }
+                catch (err) {
+                    reject(new Error(`Failed to write file: ${err instanceof Error ? err.message : String(err)}`));
+                }
+            }
+            else {
+                // Read error response body
+                const chunks = [];
+                res.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+                res.on('end', () => {
+                    const body = Buffer.concat(chunks).toString('utf-8');
+                    try {
+                        const error = JSON.parse(body)?.error;
+                        reject(new RemoteApiError(remoteName, res.statusCode ?? 500, error?.code ?? 'FILE_ERROR', error?.message ?? 'Failed to download file', error?.details));
+                    }
+                    catch {
+                        reject(new RemoteApiError(remoteName, res.statusCode ?? 500, 'FILE_ERROR', body || 'Failed to download file'));
+                    }
+                });
+            }
+        });
+        req.on('error', (err) => {
+            reject(new RemoteConnectionError(remoteName, remote.url, err.message));
+        });
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error('Download timeout'));
+        });
+        req.end();
+    });
+}
 /**
  * Test connection to a remote
  */