@the-open-engine/zeroshot 5.4.0

package/task-lib/runner.js

@@ -0,0 +1,190 @@
+import { fork } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { LOGS_DIR } from './config.js';
+import { addTask, generateId, ensureDirs } from './store.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { prepareSingleAgentProviderCommand } = require('./provider-helper-runtime.js');
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export function spawnTask(prompt, options = {}) {
+  ensureDirs();
+
+  const id = generateId();
+  const logFile = join(LOGS_DIR, `${id}.log`);
+  const cwd = options.cwd || process.cwd();
+
+  const outputFormat = resolveOutputFormat(options);
+  const jsonSchema = resolveJsonSchema(options, outputFormat);
+  const prepared = prepareSingleAgentProviderCommand({
+    provider: options.provider || null,
+    context: prompt,
+    options: buildProviderOptions(options, outputFormat, jsonSchema, cwd),
+  });
+  const providerName = prepared.adapter.id;
+  const modelSpec = prepared.options.modelSpec;
+  const commandSpec = prepared.commandSpec;
+
+  const task = buildTaskRecord({
+    id,
+    prompt,
+    cwd,
+    options,
+    logFile,
+    providerName,
+    modelSpec,
+  });
+
+  addTask(task);
+
+  const watcherConfig = buildWatcherConfig(
+    outputFormat,
+    jsonSchema,
+    options,
+    providerName,
+    commandSpec
+  );
+  const watcherScript = resolveWatcherScript(options);
+  spawnWatcher({
+    watcherScript,
+    id,
+    cwd,
+    logFile,
+    finalArgs: commandSpec.args,
+    watcherConfig,
+  });
+
+  return task;
+}
+
+function resolveOutputFormat(options) {
+  return options.outputFormat || 'stream-json';
+}
+
+function resolveJsonSchema(options, outputFormat) {
+  let jsonSchema = options.jsonSchema || null;
+  if (jsonSchema && outputFormat !== 'json') {
+    console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
+    jsonSchema = null;
+  }
+  return jsonSchema;
+}
+
+function buildProviderOptions(options, outputFormat, jsonSchema, cwd) {
+  return {
+    outputFormat,
+    jsonSchema,
+    cwd,
+    autoApprove: true,
+    ...modelSpecOption(options),
+    ...(options.resume ? { resumeSessionId: options.resume } : {}),
+    ...(options.continue ? { continueSession: true } : {}),
+  };
+}
+
+function modelSpecOption(options) {
+  const modelSpec = resolveRequestedModelSpec(options);
+  return modelSpec === undefined ? {} : { modelSpec };
+}
+
+function resolveRequestedModelSpec(options) {
+  if (options.model) {
+    return {
+      model: options.model,
+      ...(options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}),
+    };
+  }
+
+  if (options.reasoningEffort) {
+    return {
+      ...(options.modelLevel ? { level: options.modelLevel } : {}),
+      reasoningEffort: options.reasoningEffort,
+    };
+  }
+  if (options.modelLevel) return { level: options.modelLevel };
+  return undefined;
+}
+
+function buildTaskRecord({ id, prompt, cwd, options, logFile, providerName, modelSpec }) {
+  return {
+    id,
+    prompt: prompt.slice(0, 200) + (prompt.length > 200 ? '...' : ''),
+    fullPrompt: prompt,
+    cwd,
+    status: 'running',
+    pid: null,
+    sessionId: options.resume || options.sessionId || null,
+    logFile,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    exitCode: null,
+    error: null,
+    provider: providerName,
+    model: modelSpec?.model || null,
+    // Schedule reference (if spawned by scheduler)
+    scheduleId: options.scheduleId || null,
+    // Attach support
+    socketPath: null,
+    attachable: false,
+  };
+}
+
+function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec) {
+  return {
+    outputFormat,
+    jsonSchema,
+    silentJsonOutput: options.silentJsonOutput || false,
+    provider: providerName,
+    command: commandSpec.binary,
+    env: commandSpec.env || {},
+    commandSpec: buildWatcherCommandSpec(commandSpec),
+  };
+}
+
+function buildWatcherCommandSpec(commandSpec) {
+  const watcherCommandSpec = { ...commandSpec };
+  delete watcherCommandSpec.args;
+  return watcherCommandSpec;
+}
+
+function resolveWatcherScript(options) {
+  const useAttachable = options.attachable !== false && !options.jsonSchema;
+  return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
+}
+
+function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfig }) {
+  const watcher = fork(
+    watcherScript,
+    [id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
+    {
+      detached: true,
+      stdio: 'ignore',
+    }
+  );
+
+  watcher.unref();
+  watcher.disconnect(); // Close IPC channel so parent can exit
+}
+
+export function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function killTask(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}

package/task-lib/scheduler.js

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+
+/**
+ * Scheduler daemon - runs as background process
+ * Checks for due scheduled tasks and spawns them
+ */
+
+import { readFileSync, writeFileSync, existsSync, appendFileSync, unlinkSync } from 'fs';
+import { loadSchedules, updateSchedule } from './store.js';
+import { spawnTask } from './runner.js';
+import { SCHEDULER_PID_FILE, SCHEDULER_LOG } from './config.js';
+
+const CHECK_INTERVAL = 60000; // 60 seconds
+
+/**
+ * Parse human-readable interval to milliseconds
+ * Supports: 30s, 5m, 2h, 1d, 1w
+ */
+export function parseInterval(str) {
+  const match = str.match(/^(\d+)([smhdw])$/i);
+  if (!match) return null;
+
+  const value = parseInt(match[1], 10);
+  const unit = match[2].toLowerCase();
+
+  const multipliers = {
+    s: 1000,
+    m: 60 * 1000,
+    h: 60 * 60 * 1000,
+    d: 24 * 60 * 60 * 1000,
+    w: 7 * 24 * 60 * 60 * 1000,
+  };
+
+  return value * multipliers[unit];
+}
+
+/**
+ * Parse cron expression and get next run time
+ * Simple cron parser supporting: minute hour day month weekday
+ */
+export function getNextCronTime(cronExpr, fromDate = new Date()) {
+  const parts = cronExpr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+
+  const [minute, hour] = parts;
+
+  // Simple implementation - just handle basic cases
+  // For full cron support, use cron-parser package
+  const next = new Date(fromDate);
+  next.setSeconds(0);
+  next.setMilliseconds(0);
+
+  // Handle simple cases
+  if (minute !== '*') {
+    const mins = minute.split(',').map((m) => parseInt(m, 10));
+    const currentMin = next.getMinutes();
+    const nextMin = mins.find((m) => m > currentMin) ?? mins[0];
+    if (nextMin <= currentMin) {
+      next.setHours(next.getHours() + 1);
+    }
+    next.setMinutes(nextMin);
+  }
+
+  if (hour !== '*') {
+    const hours = hour.split(',').map((h) => parseInt(h, 10));
+    const currentHour = next.getHours();
+    const nextHour = hours.find((h) => h > currentHour) ?? hours[0];
+    if (nextHour <= currentHour && minute === '*') {
+      next.setDate(next.getDate() + 1);
+    }
+    if (nextHour !== currentHour) {
+      next.setMinutes(minute === '*' ? 0 : parseInt(minute, 10));
+    }
+    next.setHours(nextHour);
+  }
+
+  // For complex cron expressions, fall back to 1 hour from now
+  // Full implementation would need cron-parser
+  if (next <= fromDate) {
+    next.setTime(fromDate.getTime() + 60 * 60 * 1000);
+  }
+
+  return next;
+}
+
+/**
+ * Calculate next run time for a schedule
+ */
+export function calculateNextRun(schedule) {
+  if (schedule.interval) {
+    return new Date(Date.now() + schedule.interval);
+  }
+  if (schedule.cron) {
+    return getNextCronTime(schedule.cron);
+  }
+  return null;
+}
+
+/**
+ * Log to scheduler log file
+ */
+function log(msg) {
+  const timestamp = new Date().toISOString();
+  const line = `[${timestamp}] ${msg}\n`;
+  appendFileSync(SCHEDULER_LOG, line);
+}
+
+/**
+ * Check and run due schedules
+ */
+async function checkSchedules() {
+  const schedules = loadSchedules();
+  const now = new Date();
+
+  for (const schedule of Object.values(schedules)) {
+    if (!schedule.enabled) continue;
+
+    const nextRun = new Date(schedule.nextRunAt);
+    if (nextRun > now) continue;
+
+    // Schedule is due - spawn task
+    log(`Running scheduled task: ${schedule.id} - "${schedule.prompt.slice(0, 50)}..."`);
+
+    try {
+      const task = await spawnTask(schedule.prompt, {
+        cwd: schedule.cwd,
+        scheduleId: schedule.id,
+      });
+
+      // Update schedule with next run time
+      const nextRunAt = calculateNextRun(schedule);
+      updateSchedule(schedule.id, {
+        lastRunAt: now.toISOString(),
+        lastTaskId: task.id,
+        nextRunAt: nextRunAt ? nextRunAt.toISOString() : null,
+      });
+
+      log(
+        `Spawned task ${task.id} for schedule ${schedule.id}, next run: ${nextRunAt?.toISOString() || 'none'}`
+      );
+    } catch (err) {
+      log(`Error spawning task for schedule ${schedule.id}: ${err.message}`);
+    }
+  }
+}
+
+/**
+ * Start the scheduler daemon
+ */
+export function startDaemon() {
+  // Check if already running
+  if (existsSync(SCHEDULER_PID_FILE)) {
+    const existingPid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+    try {
+      process.kill(existingPid, 0);
+      console.log(`Scheduler already running (PID: ${existingPid})`);
+      return false;
+    } catch {
+      // Process not running, clean up stale PID file
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+  }
+
+  // Write PID file
+  writeFileSync(SCHEDULER_PID_FILE, String(process.pid));
+
+  log(`Scheduler daemon started (PID: ${process.pid})`);
+  console.log(`Scheduler daemon started (PID: ${process.pid})`);
+
+  // Run check loop
+  const runLoop = async () => {
+    while (true) {
+      try {
+        await checkSchedules();
+      } catch (err) {
+        // Log error with full stack trace - scheduler errors are critical bugs
+        const errorMsg = `SCHEDULER ERROR: ${err.message}\nStack: ${err.stack}`;
+        log(errorMsg);
+        console.error(errorMsg);
+      }
+      await new Promise((r) => setTimeout(r, CHECK_INTERVAL));
+    }
+  };
+
+  // Handle shutdown
+  process.on('SIGTERM', () => {
+    log('Scheduler daemon stopping (SIGTERM)');
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+    process.exit(0);
+  });
+
+  process.on('SIGINT', () => {
+    log('Scheduler daemon stopping (SIGINT)');
+    if (existsSync(SCHEDULER_PID_FILE)) {
+      unlinkSync(SCHEDULER_PID_FILE);
+    }
+    process.exit(0);
+  });
+
+  runLoop();
+  return true;
+}
+
+/**
+ * Stop the scheduler daemon
+ */
+export function stopDaemon() {
+  if (!existsSync(SCHEDULER_PID_FILE)) {
+    console.log('Scheduler is not running');
+    return false;
+  }
+
+  const pid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+
+  try {
+    process.kill(pid, 'SIGTERM');
+    unlinkSync(SCHEDULER_PID_FILE);
+    console.log(`Scheduler stopped (PID: ${pid})`);
+    log(`Scheduler daemon stopped by user (PID: ${pid})`);
+    return true;
+  } catch {
+    // Process not running, clean up
+    unlinkSync(SCHEDULER_PID_FILE);
+    console.log('Scheduler was not running (cleaned up stale PID file)');
+    return false;
+  }
+}
+
+/**
+ * Get daemon status
+ */
+export function getDaemonStatus() {
+  if (!existsSync(SCHEDULER_PID_FILE)) {
+    return { running: false, pid: null };
+  }
+
+  const pid = parseInt(readFileSync(SCHEDULER_PID_FILE, 'utf-8').trim(), 10);
+
+  try {
+    process.kill(pid, 0);
+    return { running: true, pid };
+  } catch {
+    return { running: false, pid: null, stale: true };
+  }
+}
+
+// If run directly, start daemon
+if (process.argv[1]?.endsWith('scheduler.js')) {
+  startDaemon();
+}