cli4ai 1.2.0 → 1.2.2

package/dist/server/service.js

@@ -0,0 +1,304 @@
+/**
+ * cli4ai Remote Service
+ *
+ * HTTP server that exposes cli4ai functionality for remote execution.
+ * Run with `cli4ai serve` to start the service.
+ */
+import { createServer } from 'http';
+import { hostname } from 'os';
+import { log } from '../lib/cli.js';
+import { executeTool, ExecuteToolError } from '../core/execute.js';
+import { findPackage, getGlobalPackages, getLocalPackages } from '../core/config.js';
+import { loadManifest } from '../core/manifest.js';
+import { loadRoutineDefinition, runRoutine } from '../core/routine-engine.js';
+import { resolveRoutine } from '../core/routines.js';
+// ═══════════════════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════════════════
+function parseBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
+        req.on('error', reject);
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+    });
+}
+function sendJson(res, status, data) {
+    const body = JSON.stringify(data);
+    res.writeHead(status, {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body)
+    });
+    res.end(body);
+}
+function sendError(res, status, code, message, details) {
+    sendJson(res, status, { error: { code, message, details } });
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// REQUEST HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════
+async function handleHealth(config, startTime) {
+    return {
+        status: 'ok',
+        hostname: hostname(),
+        version: '1.0.0',
+        uptime: Math.floor((Date.now() - startTime) / 1000)
+    };
+}
+async function handleListPackages(config) {
+    const localPkgs = getLocalPackages(config.cwd);
+    const globalPkgs = getGlobalPackages();
+    const packages = [
+        ...localPkgs.map(p => ({ name: p.name, version: p.version, path: p.path, source: p.source })),
+        ...globalPkgs.map(p => ({ name: p.name, version: p.version, path: p.path, source: p.source }))
+    ];
+    // Deduplicate by name (local takes precedence)
+    const seen = new Set();
+    const unique = packages.filter(p => {
+        if (seen.has(p.name))
+            return false;
+        seen.add(p.name);
+        return true;
+    });
+    return { packages: unique };
+}
+async function handlePackageInfo(config, packageName) {
+    const pkg = findPackage(packageName, config.cwd);
+    if (!pkg)
+        return null;
+    const manifest = loadManifest(pkg.path);
+    const commands = {};
+    if (manifest.commands) {
+        for (const [name, cmd] of Object.entries(manifest.commands)) {
+            commands[name] = { description: cmd.description };
+        }
+    }
+    return {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        commands
+    };
+}
+async function handleRunTool(config, request) {
+    const startTime = Date.now();
+    // Validate scope
+    const scope = request.scope ?? 'full';
+    const allowedScopes = config.allowedScopes ?? ['read', 'write', 'full'];
+    if (!allowedScopes.includes(scope)) {
+        return {
+            success: false,
+            exitCode: 1,
+            durationMs: Date.now() - startTime,
+            error: {
+                code: 'FORBIDDEN',
+                message: `Scope "${scope}" is not allowed on this remote`,
+                details: { allowedScopes }
+            }
+        };
+    }
+    try {
+        const result = await executeTool({
+            packageName: request.package,
+            command: request.command,
+            args: request.args ?? [],
+            cwd: config.cwd,
+            env: request.env,
+            stdin: request.stdin,
+            capture: 'pipe',
+            timeoutMs: request.timeout,
+            scope,
+            teeStderr: false
+        });
+        return {
+            success: result.exitCode === 0,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            durationMs: result.durationMs
+        };
+    }
+    catch (err) {
+        const durationMs = Date.now() - startTime;
+        if (err instanceof ExecuteToolError) {
+            return {
+                success: false,
+                exitCode: 1,
+                durationMs,
+                error: {
+                    code: err.code,
+                    message: err.message,
+                    details: err.details
+                }
+            };
+        }
+        return {
+            success: false,
+            exitCode: 1,
+            durationMs,
+            error: {
+                code: 'API_ERROR',
+                message: err instanceof Error ? err.message : String(err)
+            }
+        };
+    }
+}
+async function handleRunRoutine(config, request) {
+    const resolved = resolveRoutine(request.routine, config.cwd);
+    if (!resolved)
+        return null;
+    const def = loadRoutineDefinition(resolved.path);
+    const result = await runRoutine(def, request.vars ?? {}, config.cwd);
+    return result;
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// MAIN SERVER
+// ═══════════════════════════════════════════════════════════════════════════
+export function createService(config) {
+    const startTime = Date.now();
+    const server = createServer(async (req, res) => {
+        const method = req.method ?? 'GET';
+        const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
+        const path = url.pathname;
+        // CORS headers for cross-origin requests
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-API-Key');
+        // Handle preflight
+        if (method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Authentication check
+        if (config.apiKey) {
+            const providedKey = req.headers['x-api-key'] ||
+                req.headers['authorization']?.replace(/^Bearer\s+/i, '');
+            if (providedKey !== config.apiKey) {
+                sendError(res, 401, 'UNAUTHORIZED', 'Invalid or missing API key');
+                return;
+            }
+        }
+        try {
+            // Route: GET /health
+            if (method === 'GET' && path === '/health') {
+                const data = await handleHealth(config, startTime);
+                sendJson(res, 200, data);
+                return;
+            }
+            // Route: GET /packages
+            if (method === 'GET' && path === '/packages') {
+                const data = await handleListPackages(config);
+                sendJson(res, 200, data);
+                return;
+            }
+            // Route: GET /packages/:name
+            if (method === 'GET' && path.startsWith('/packages/')) {
+                const packageName = path.slice('/packages/'.length);
+                const data = await handlePackageInfo(config, packageName);
+                if (!data) {
+                    sendError(res, 404, 'NOT_FOUND', `Package not found: ${packageName}`);
+                    return;
+                }
+                sendJson(res, 200, data);
+                return;
+            }
+            // Route: POST /run
+            if (method === 'POST' && path === '/run') {
+                const body = await parseBody(req);
+                let request;
+                try {
+                    request = JSON.parse(body);
+                }
+                catch {
+                    sendError(res, 400, 'PARSE_ERROR', 'Invalid JSON body');
+                    return;
+                }
+                if (!request.package || typeof request.package !== 'string') {
+                    sendError(res, 400, 'INVALID_INPUT', 'Missing required field: package');
+                    return;
+                }
+                const data = await handleRunTool(config, request);
+                sendJson(res, data.success ? 200 : 500, data);
+                return;
+            }
+            // Route: POST /routines/:name/run
+            if (method === 'POST' && path.match(/^\/routines\/[^/]+\/run$/)) {
+                const routineName = path.split('/')[2];
+                const body = await parseBody(req);
+                let request;
+                try {
+                    request = body ? JSON.parse(body) : {};
+                    request.routine = routineName;
+                }
+                catch {
+                    sendError(res, 400, 'PARSE_ERROR', 'Invalid JSON body');
+                    return;
+                }
+                const data = await handleRunRoutine(config, request);
+                if (!data) {
+                    sendError(res, 404, 'NOT_FOUND', `Routine not found: ${routineName}`);
+                    return;
+                }
+                sendJson(res, data.status === 'success' ? 200 : 500, data);
+                return;
+            }
+            // 404 for unknown routes
+            sendError(res, 404, 'NOT_FOUND', `Unknown route: ${method} ${path}`);
+        }
+        catch (err) {
+            console.error('Request error:', err);
+            sendError(res, 500, 'API_ERROR', err instanceof Error ? err.message : String(err));
+        }
+    });
+    return server;
+}
+export async function startService(options = {}) {
+    const config = {
+        port: options.port ?? 4100,
+        host: options.host ?? '0.0.0.0',
+        apiKey: options.apiKey,
+        cwd: options.cwd ?? process.cwd(),
+        allowedScopes: options.allowedScopes
+    };
+    const server = createService(config);
+    return new Promise((resolve, reject) => {
+        server.on('error', (err) => {
+            if (err.code === 'EADDRINUSE') {
+                reject(new Error(`Port ${config.port} is already in use`));
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(config.port, config.host, () => {
+            log(`cli4ai service running on http://${config.host}:${config.port}`);
+            log(`Hostname: ${hostname()}`);
+            log(`Working directory: ${config.cwd}`);
+            if (config.apiKey) {
+                log(`Authentication: API key required`);
+            }
+            else {
+                log(`Authentication: None (not recommended for production)`);
+            }
+            log('');
+            log('Endpoints:');
+            log('  GET  /health              - Service health check');
+            log('  GET  /packages            - List available packages');
+            log('  GET  /packages/:name      - Get package info');
+            log('  POST /run                 - Execute a tool');
+            log('  POST /routines/:name/run  - Run a routine');
+            log('');
+            log('Press Ctrl+C to stop');
+        });
+        // Handle graceful shutdown
+        const shutdown = () => {
+            log('\nShutting down...');
+            server.close(() => {
+                resolve();
+            });
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    });
+}

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "cli4ai",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "The package manager for AI CLI tools - cli4ai.com",
   "type": "module",
   "bin": {
-    "cli4ai": "./src/bin.ts"
+    "cli4ai": "./dist/bin.js"
   },
   "scripts": {
     "dev": "npx tsx src/bin.ts",
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -42,7 +44,8 @@
     "cli4ai"
   ],
   "files": [
-    "src/**/*.ts",
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
     "templates/**/*"
   ],
   "publishConfig": {

package/src/bin.ts

@@ -1,118 +0,0 @@
-#!/usr/bin/env npx tsx
-/**
- * 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: number) => new Promise(r => setTimeout(r, ms));
-
-/**
- * Robot eating dots animation
- */
-async function showAnimation(): Promise<void> {
-  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(): Promise<void> {
-  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(): Promise<void> {
-  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(): void {
-  // 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);
-}