cli4ai 1.0.4 → 1.1.1

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/lib/cli.ts

@@ -4,9 +4,16 @@
  */
 
 import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgPath = join(__dirname, '..', '..', 'package.json');
+const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
 
 export const BRAND = 'cli4ai - cli4ai.com';
-export const VERSION = '0.9.2';
+export const VERSION = pkg.version;
 
 // ═══════════════════════════════════════════════════════════════════════════
 // TYPES