cli4ai 1.0.4 → 1.1.0

package/src/core/routine-engine.ts

@@ -4,7 +4,10 @@
 
 import { readFileSync } from 'fs';
 import { spawn } from 'child_process';
+import { parse as parseYaml } from 'yaml';
 import { executeTool, ExecuteToolError } from './execute.js';
+import { remoteRunTool, RemoteConnectionError, RemoteApiError } from './remote-client.js';
+import { getRemote } from './remotes.js';
 
 export class RoutineParseError extends Error {
   constructor(
@@ -78,6 +81,8 @@ export interface RoutineC4aiStep extends RoutineBaseStep {
   env?: Record<string, string>;
   stdin?: string;
   capture?: StepCapture;
+  /** Name of a configured remote to execute on (optional) */
+  remote?: string;
 }
 
 export interface RoutineSetStep extends RoutineBaseStep {
@@ -153,11 +158,13 @@ export function loadRoutineDefinition(path: string): RoutineDefinition {
     throw new RoutineParseError(path, `Failed to read: ${err instanceof Error ? err.message : String(err)}`);
   }
 
+  const isYaml = path.endsWith('.yaml') || path.endsWith('.yml');
   let data: unknown;
   try {
-    data = JSON.parse(content);
-  } catch {
-    throw new RoutineParseError(path, 'Invalid JSON');
+    data = isYaml ? parseYaml(content) : JSON.parse(content);
+  } catch (err) {
+    const format = isYaml ? 'YAML' : 'JSON';
+    throw new RoutineParseError(path, `Invalid ${format}: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   return validateRoutineDefinition(data, path);
@@ -318,6 +325,9 @@ function validateRoutineDefinition(value: unknown, source?: string): RoutineDefi
       if (s.capture !== undefined && !['inherit', 'text', 'json'].includes(String(s.capture))) {
         throw new RoutineValidationError(`Step "${s.id}" has invalid "capture"`, { source, id: s.id, got: s.capture });
       }
+      if (s.remote !== undefined && typeof s.remote !== 'string') {
+        throw new RoutineValidationError(`Step "${s.id}" has invalid "remote" (must be string)`, { source, id: s.id, got: s.remote });
+      }
     }
 
     if (s.type === 'set') {
@@ -718,39 +728,91 @@ export async function runRoutine(def: RoutineDefinition, vars: Record<string, st
       const args = renderStringArray(step.args, ctx, { stepId: step.id, field: 'args' });
       const env = renderEnv(step.env, ctx, { stepId: step.id, field: 'env' });
       const stdin = step.stdin !== undefined ? renderString(step.stdin, ctx, { stepId: step.id, field: 'stdin' }) : undefined;
+      const remoteName = step.remote !== undefined ? renderScalarString(step.remote, ctx, { stepId: step.id, field: 'remote' }) : undefined;
 
       const capture = step.capture ?? 'text';
 
       try {
-        const execRes = await executeTool({
-          packageName: pkg,
-          command: cmd,
-          args,
-          cwd: invocationDir,
-          env,
-          stdin,
-          capture: 'pipe',
-          timeoutMs: step.timeout,
-          teeStderr: true
-        });
+        let execResult: { exitCode: number; durationMs: number; stdout?: string; stderr?: string };
+
+        if (remoteName) {
+          // Remote execution
+          const remote = getRemote(remoteName);
+          if (!remote) {
+            throw new ExecuteToolError('NOT_FOUND', `Remote "${remoteName}" not found`, {
+              step: step.id,
+              hint: 'Use "cli4ai remotes add <name> <url>" to configure a remote'
+            });
+          }
+
+          const remoteRes = await remoteRunTool(remoteName, {
+            package: pkg,
+            command: cmd,
+            args,
+            env: Object.keys(env).length > 0 ? env : undefined,
+            stdin,
+            timeout: step.timeout
+          });
+
+          execResult = {
+            exitCode: remoteRes.exitCode,
+            durationMs: remoteRes.durationMs,
+            stdout: remoteRes.stdout,
+            stderr: remoteRes.stderr
+          };
+
+          // Log stderr from remote
+          if (remoteRes.stderr) {
+            process.stderr.write(remoteRes.stderr);
+          }
+
+          // Handle remote-level errors
+          if (remoteRes.error && !remoteRes.success) {
+            throw new ExecuteToolError(
+              remoteRes.error.code,
+              remoteRes.error.message,
+              remoteRes.error.details
+            );
+          }
+        } else {
+          // Local execution
+          const localRes = await executeTool({
+            packageName: pkg,
+            command: cmd,
+            args,
+            cwd: invocationDir,
+            env,
+            stdin,
+            capture: 'pipe',
+            timeoutMs: step.timeout,
+            teeStderr: true
+          });
+
+          execResult = {
+            exitCode: localRes.exitCode,
+            durationMs: localRes.durationMs,
+            stdout: localRes.stdout,
+            stderr: localRes.stderr
+          };
+        }
 
         const res: StepRunResult = {
           id: step.id,
           type: step.type,
-          status: execRes.exitCode === 0 ? 'success' : 'failed',
-          exitCode: execRes.exitCode,
-          durationMs: execRes.durationMs,
-          stdout: execRes.stdout,
-          stderr: execRes.stderr
+          status: execResult.exitCode === 0 ? 'success' : 'failed',
+          exitCode: execResult.exitCode,
+          durationMs: execResult.durationMs,
+          stdout: execResult.stdout,
+          stderr: execResult.stderr
         };
 
         if (capture === 'json') {
           try {
-            res.json = execRes.stdout ? JSON.parse(execRes.stdout) : null;
+            res.json = execResult.stdout ? JSON.parse(execResult.stdout) : null;
           } catch {
             throw new RoutineTemplateError(`JSON parse error in step "${step.id}": stdout is not valid JSON`, {
               step: step.id,
-              stdout: (execRes.stdout ?? '').slice(0, 200)
+              stdout: (execResult.stdout ?? '').slice(0, 200)
             });
           }
         }
@@ -758,8 +820,8 @@ export async function runRoutine(def: RoutineDefinition, vars: Record<string, st
         stepsById[step.id] = res;
         steps.push(res);
 
-        if (execRes.exitCode !== 0 && !step.continueOnError) {
-          return finalizeFailure(def, ctxVars, steps, Date.now() - startTime, execRes.exitCode);
+        if (execResult.exitCode !== 0 && !step.continueOnError) {
+          return finalizeFailure(def, ctxVars, steps, Date.now() - startTime, execResult.exitCode);
         }
         continue;
       } catch (err) {
@@ -799,6 +861,12 @@ function normalizeError(err: unknown): { code: string; message: string; details?
   if (err instanceof ExecuteToolError) {
     return { code: err.code, message: err.message, details: err.details };
   }
+  if (err instanceof RemoteConnectionError) {
+    return { code: 'NETWORK_ERROR', message: err.message, details: { remote: err.remoteName, url: err.url } };
+  }
+  if (err instanceof RemoteApiError) {
+    return { code: err.code, message: err.message, details: err.details };
+  }
   if (err instanceof RoutineTemplateError) {
     return { code: 'INVALID_INPUT', message: err.message, details: err.details };
   }

package/src/core/routines.ts

@@ -7,15 +7,16 @@
  *
  * Resolution order:
  * - local before global (unless globalOnly)
- * - within a scope: .routine.json before .routine.sh
+ * - within a scope: .routine.yaml > .routine.yml > .routine.json > .routine.sh
  */
 
 import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
 import { resolve } from 'path';
+import { parse as parseYaml } from 'yaml';
 import { ensureCli4aiHome, ensureLocalDir, ROUTINES_DIR, LOCAL_ROUTINES_DIR } from './config.js';
 import { validateScheduleConfig, type RoutineSchedule } from './routine-engine.js';
 
-export type RoutineKind = 'json' | 'bash';
+export type RoutineKind = 'yaml' | 'json' | 'bash';
 export type RoutineScope = 'local' | 'global';
 
 export interface RoutineInfo {
@@ -30,6 +31,8 @@ export interface ResolveRoutineOptions {
 }
 
 const ROUTINE_FILES = [
+  { kind: 'yaml' as const, suffix: '.routine.yaml' },
+  { kind: 'yaml' as const, suffix: '.routine.yml' },
   { kind: 'json' as const, suffix: '.routine.json' },
   { kind: 'bash' as const, suffix: '.routine.sh' }
 ] as const;
@@ -127,13 +130,13 @@ export function getScheduledRoutines(projectDir?: string): ScheduledRoutineInfo[
   const results: ScheduledRoutineInfo[] = [];
   const seen = new Set<string>();
 
-  // Collect all JSON routines
+  // Collect all structured routines (YAML and JSON - bash scripts cannot have schedules)
   const allRoutines: RoutineInfo[] = [];
 
   if (projectDir) {
-    allRoutines.push(...getLocalRoutines(projectDir).filter(r => r.kind === 'json'));
+    allRoutines.push(...getLocalRoutines(projectDir).filter(r => r.kind === 'yaml' || r.kind === 'json'));
   }
-  allRoutines.push(...getGlobalRoutines().filter(r => r.kind === 'json'));
+  allRoutines.push(...getGlobalRoutines().filter(r => r.kind === 'yaml' || r.kind === 'json'));
 
   for (const routine of allRoutines) {
     // Skip if we've already processed a routine with this name (local takes precedence)
@@ -142,7 +145,7 @@ export function getScheduledRoutines(projectDir?: string): ScheduledRoutineInfo[
 
     try {
       const content = readFileSync(routine.path, 'utf-8');
-      const data = JSON.parse(content);
+      const data = routine.kind === 'yaml' ? parseYaml(content) : JSON.parse(content);
 
       if (data.schedule && typeof data.schedule === 'object') {
         // Check if schedule is enabled (defaults to true)

package/src/core/scheduler.ts

@@ -11,7 +11,7 @@
  *     └── scheduler.log      # Daemon logs
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync, readdirSync, appendFileSync } from 'fs';
 import { resolve, join } from 'path';
 import parser from 'cron-parser';
 import { SCHEDULER_DIR, ensureCli4aiHome } from './config.js';
@@ -282,7 +282,7 @@ export function appendSchedulerLog(level: LogLevel, message: string): void {
   ensureSchedulerDirs();
   const timestamp = new Date().toISOString();
   const line = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
-  const fd = require('fs').appendFileSync(SCHEDULER_LOG_FILE, line);
+  appendFileSync(SCHEDULER_LOG_FILE, line);
 }
 
 // ═══════════════════════════════════════════════════════════════════════════

package/src/server/service.ts

@@ -0,0 +1,434 @@
+/**
+ * cli4ai Remote Service
+ *
+ * HTTP server that exposes cli4ai functionality for remote execution.
+ * Run with `cli4ai serve` to start the service.
+ */
+
+import { createServer, IncomingMessage, ServerResponse } from 'http';
+import { hostname } from 'os';
+import { log, output } from '../lib/cli.js';
+import { executeTool, ExecuteToolError, type ScopeLevel } from '../core/execute.js';
+import { findPackage, getGlobalPackages, getLocalPackages } from '../core/config.js';
+import { loadManifest } from '../core/manifest.js';
+import {
+  loadRoutineDefinition,
+  runRoutine,
+  type RoutineRunSummary
+} from '../core/routine-engine.js';
+import { resolveRoutine } from '../core/routines.js';
+
+// ═══════════════════════════════════════════════════════════════════════════
+// TYPES
+// ═══════════════════════════════════════════════════════════════════════════
+
+export interface ServiceConfig {
+  /** Port to listen on (default: 4100) */
+  port: number;
+  /** Host to bind to (default: 0.0.0.0) */
+  host: string;
+  /** API key for authentication (optional but recommended) */
+  apiKey?: string;
+  /** Working directory for command execution */
+  cwd: string;
+  /** Allowed scope levels (defaults to ['read', 'write', 'full']) */
+  allowedScopes?: ScopeLevel[];
+}
+
+export interface RunToolRequest {
+  /** Package name */
+  package: string;
+  /** Command within the package */
+  command?: string;
+  /** Arguments to pass */
+  args?: string[];
+  /** Environment variables */
+  env?: Record<string, string>;
+  /** Standard input to pass to the tool */
+  stdin?: string;
+  /** Timeout in milliseconds */
+  timeout?: number;
+  /** Scope level for execution */
+  scope?: ScopeLevel;
+}
+
+export interface RunToolResponse {
+  success: boolean;
+  exitCode: number;
+  stdout?: string;
+  stderr?: string;
+  durationMs: number;
+  error?: {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+  };
+}
+
+export interface RunRoutineRequest {
+  /** Routine name */
+  routine: string;
+  /** Variables to pass to the routine */
+  vars?: Record<string, string>;
+}
+
+export interface ListPackagesResponse {
+  packages: Array<{
+    name: string;
+    version: string;
+    path: string;
+    source: 'local' | 'registry';
+  }>;
+}
+
+export interface PackageInfoResponse {
+  name: string;
+  version: string;
+  description?: string;
+  commands?: Record<string, { description: string }>;
+}
+
+export interface HealthResponse {
+  status: 'ok';
+  hostname: string;
+  version: string;
+  uptime: number;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// HELPERS
+// ═══════════════════════════════════════════════════════════════════════════
+
+function parseBody(req: IncomingMessage): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    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: ServerResponse, status: number, data: unknown): void {
+  const body = JSON.stringify(data);
+  res.writeHead(status, {
+    'Content-Type': 'application/json',
+    'Content-Length': Buffer.byteLength(body)
+  });
+  res.end(body);
+}
+
+function sendError(res: ServerResponse, status: number, code: string, message: string, details?: Record<string, unknown>): void {
+  sendJson(res, status, { error: { code, message, details } });
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// REQUEST HANDLERS
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function handleHealth(config: ServiceConfig, startTime: number): Promise<HealthResponse> {
+  return {
+    status: 'ok',
+    hostname: hostname(),
+    version: '1.0.0',
+    uptime: Math.floor((Date.now() - startTime) / 1000)
+  };
+}
+
+async function handleListPackages(config: ServiceConfig): Promise<ListPackagesResponse> {
+  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<string>();
+  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: ServiceConfig, packageName: string): Promise<PackageInfoResponse | null> {
+  const pkg = findPackage(packageName, config.cwd);
+  if (!pkg) return null;
+
+  const manifest = loadManifest(pkg.path);
+
+  const commands: Record<string, { description: string }> = {};
+  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: ServiceConfig, request: RunToolRequest): Promise<RunToolResponse> {
+  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: ServiceConfig, request: RunRoutineRequest): Promise<RoutineRunSummary | null> {
+  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: ServiceConfig): ReturnType<typeof createServer> {
+  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: RunToolRequest;
+
+        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: RunRoutineRequest;
+
+        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 interface StartServiceOptions {
+  port?: number;
+  host?: string;
+  apiKey?: string;
+  cwd?: string;
+  allowedScopes?: ScopeLevel[];
+}
+
+export async function startService(options: StartServiceOptions = {}): Promise<void> {
+  const config: ServiceConfig = {
+    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: NodeJS.ErrnoException) => {
+      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);
+  });
+}