morpheus-cli 0.5.5 → 0.6.0

package/dist/http/routers/chronos.js

@@ -0,0 +1,267 @@
+import { Router } from 'express';
+import { z } from 'zod';
+import { ConfigManager } from '../../config/manager.js';
+import { ChronosConfigSchema } from '../../config/schemas.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { ChronosError } from '../../runtime/chronos/repository.js';
+import { parseScheduleExpression, getNextOccurrences, } from '../../runtime/chronos/parser.js';
+const ScheduleTypeSchema = z.enum(['once', 'cron', 'interval']);
+const CreateJobSchema = z.object({
+    prompt: z.string().min(1).max(10000),
+    schedule_type: ScheduleTypeSchema,
+    schedule_expression: z.string().min(1),
+    timezone: z.string().optional(),
+});
+const UpdateJobSchema = z.object({
+    prompt: z.string().min(1).max(10000).optional(),
+    schedule_expression: z.string().min(1).optional(),
+    timezone: z.string().optional(),
+    enabled: z.boolean().optional(),
+});
+const PreviewSchema = z.object({
+    expression: z.string().min(1),
+    schedule_type: ScheduleTypeSchema,
+    timezone: z.string().optional(),
+});
+const ExecutionsQuerySchema = z.object({
+    limit: z.coerce.number().int().min(1).max(100).default(50),
+});
+// ─── Job Router ───────────────────────────────────────────────────────────────
+export function createChronosJobRouter(repo, _worker) {
+    const router = Router();
+    const configManager = ConfigManager.getInstance();
+    // POST /api/chronos/preview — must be before /:id routes
+    router.post('/preview', (req, res) => {
+        const parsed = PreviewSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        const { expression, schedule_type, timezone } = parsed.data;
+        const globalTz = configManager.getChronosConfig().timezone;
+        const opts = { timezone: timezone ?? globalTz };
+        try {
+            const result = parseScheduleExpression(expression, schedule_type, opts);
+            const next_occurrences = [];
+            if (result.cron_normalized) {
+                const timestamps = getNextOccurrences(result.cron_normalized, opts.timezone ?? 'UTC', 3);
+                for (const ts of timestamps) {
+                    next_occurrences.push(new Date(ts).toLocaleString('en-US', {
+                        timeZone: opts.timezone ?? 'UTC',
+                        year: 'numeric', month: 'short', day: 'numeric',
+                        hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+                    }));
+                }
+            }
+            res.json({
+                next_run_at: result.next_run_at,
+                human_readable: result.human_readable,
+                next_occurrences,
+            });
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos — list jobs
+    router.get('/', (req, res) => {
+        try {
+            const enabled = req.query.enabled;
+            const created_by = req.query.created_by;
+            const jobs = repo.listJobs({
+                enabled: enabled === 'true' ? true : enabled === 'false' ? false : undefined,
+                created_by,
+            });
+            res.json(jobs);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/chronos — create job
+    router.post('/', (req, res) => {
+        const parsed = CreateJobSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        const { prompt, schedule_type, schedule_expression, timezone } = parsed.data;
+        const globalTz = configManager.getChronosConfig().timezone;
+        const tz = timezone ?? globalTz;
+        const opts = { timezone: tz };
+        try {
+            const schedule = parseScheduleExpression(schedule_expression, schedule_type, opts);
+            const job = repo.createJob({
+                prompt,
+                schedule_type,
+                schedule_expression,
+                cron_normalized: schedule.cron_normalized,
+                timezone: tz,
+                next_run_at: schedule.next_run_at,
+                created_by: 'ui',
+            });
+            const display = DisplayManager.getInstance();
+            display.log(`Job ${job.id} created — ${schedule.human_readable}`, { source: 'Chronos' });
+            res.status(201).json({
+                job,
+                human_readable: schedule.human_readable,
+                next_run_formatted: new Date(schedule.next_run_at).toLocaleString('en-US', {
+                    timeZone: tz,
+                    year: 'numeric', month: 'short', day: 'numeric',
+                    hour: '2-digit', minute: '2-digit', timeZoneName: 'short',
+                }),
+            });
+        }
+        catch (err) {
+            if (err instanceof ChronosError) {
+                return res.status(429).json({ error: err.message });
+            }
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos/:id
+    router.get('/:id', (req, res) => {
+        try {
+            const job = repo.getJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // PUT /api/chronos/:id — update job
+    router.put('/:id', (req, res) => {
+        const parsed = UpdateJobSchema.safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const existing = repo.getJob(req.params.id);
+            if (!existing)
+                return res.status(404).json({ error: 'Job not found' });
+            const patch = parsed.data;
+            const tz = patch.timezone ?? existing.timezone;
+            let updatedSchedule = undefined;
+            if (patch.schedule_expression) {
+                updatedSchedule = parseScheduleExpression(patch.schedule_expression, existing.schedule_type, {
+                    timezone: tz,
+                });
+            }
+            const job = repo.updateJob(req.params.id, {
+                prompt: patch.prompt,
+                schedule_expression: patch.schedule_expression,
+                cron_normalized: updatedSchedule?.cron_normalized,
+                timezone: patch.timezone,
+                next_run_at: updatedSchedule?.next_run_at,
+                enabled: patch.enabled,
+            });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // DELETE /api/chronos/:id
+    router.delete('/:id', (req, res) => {
+        try {
+            const deleted = repo.deleteJob(req.params.id);
+            if (!deleted)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json({ success: true, deleted_id: req.params.id });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // PATCH /api/chronos/:id/enable
+    router.patch('/:id/enable', (req, res) => {
+        try {
+            const existing = repo.getJob(req.params.id);
+            if (!existing)
+                return res.status(404).json({ error: 'Job not found' });
+            // Recompute next_run_at
+            let nextRunAt;
+            if (existing.cron_normalized) {
+                // cron_normalized is always a 5-field cron string regardless of the original schedule_type,
+                // so always parse it as 'cron' (not 'interval' or 'once').
+                const schedule = parseScheduleExpression(existing.cron_normalized, 'cron', {
+                    timezone: existing.timezone,
+                });
+                nextRunAt = schedule.next_run_at;
+            }
+            else if (existing.schedule_type === 'once' && existing.next_run_at && existing.next_run_at > Date.now()) {
+                nextRunAt = existing.next_run_at;
+            }
+            repo.updateJob(req.params.id, { enabled: true, next_run_at: nextRunAt ?? undefined });
+            const job = repo.getJob(req.params.id);
+            res.json(job);
+        }
+        catch (err) {
+            res.status(400).json({ error: err.message });
+        }
+    });
+    // PATCH /api/chronos/:id/disable
+    router.patch('/:id/disable', (req, res) => {
+        try {
+            const job = repo.disableJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            res.json(job);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/chronos/:id/executions
+    router.get('/:id/executions', (req, res) => {
+        try {
+            const query = ExecutionsQuerySchema.safeParse(req.query);
+            const limit = query.success ? query.data.limit : 50;
+            const job = repo.getJob(req.params.id);
+            if (!job)
+                return res.status(404).json({ error: 'Job not found' });
+            const executions = repo.listExecutions(req.params.id, limit);
+            res.json(executions);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}
+// ─── Config Router ────────────────────────────────────────────────────────────
+export function createChronosConfigRouter(worker) {
+    const router = Router();
+    const configManager = ConfigManager.getInstance();
+    // GET /api/config/chronos
+    router.get('/', (req, res) => {
+        try {
+            res.json(configManager.getChronosConfig());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/config/chronos
+    router.post('/', async (req, res) => {
+        const parsed = ChronosConfigSchema.partial().safeParse(req.body);
+        if (!parsed.success) {
+            return res.status(400).json({ error: 'Invalid input', details: parsed.error.issues });
+        }
+        try {
+            const current = configManager.get();
+            const newChronos = { ...configManager.getChronosConfig(), ...parsed.data };
+            await configManager.save({ ...current, chronos: newChronos });
+            if (parsed.data.check_interval_ms) {
+                worker.updateInterval(parsed.data.check_interval_ms);
+            }
+            const display = DisplayManager.getInstance();
+            display.log('Chronos configuration updated via UI', { source: 'Zaion', level: 'info' });
+            res.json(configManager.getChronosConfig());
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/http/server.js

@@ -15,9 +15,11 @@ export class HttpServer {
     app;
     server;
     oracle;
-    constructor(oracle) {
+    chronosWorker;
+    constructor(oracle, chronosWorker) {
         this.app = express();
         this.oracle = oracle;
+        this.chronosWorker = chronosWorker;
         // Wire Oracle into the webhook dispatcher so triggers use the full agent
         WebhookDispatcher.setOracle(oracle);
         this.setupMiddleware();
@@ -53,7 +55,7 @@ export class HttpServer {
         // The trigger endpoint is public (validated via x-api-key header internally).
         // All other webhook management endpoints apply authMiddleware internally.
         this.app.use('/api/webhooks', createWebhooksRouter());
-        this.app.use('/api', authMiddleware, createApiRouter(this.oracle));
+        this.app.use('/api', authMiddleware, createApiRouter(this.oracle, this.chronosWorker));
         // Serve static frontend from compiled output
         const uiPath = path.resolve(__dirname, '../ui');
         this.app.use(express.static(uiPath));

package/dist/runtime/chronos/parser.js

@@ -0,0 +1,215 @@
+import * as chrono from 'chrono-node';
+import CronParser from 'cron-parser';
+const parseCron = CronParser.parseExpression.bind(CronParser);
+import cronstrue from 'cronstrue';
+// Maps interval phrases like "every 30 minutes" to a cron expression.
+function intervalToCron(expression) {
+    const lower = expression.toLowerCase().trim();
+    // ── Quantified intervals ──────────────────────────────────────────────────
+    // "every N minutes"
+    const minuteMatch = lower.match(/every\s+(\d+)\s+min(?:ute)?s?/);
+    if (minuteMatch)
+        return `*/${minuteMatch[1]} * * * *`;
+    // "every N hours"
+    const hourMatch = lower.match(/every\s+(\d+)\s+hours?/);
+    if (hourMatch)
+        return `0 */${hourMatch[1]} * * *`;
+    // "every N days"
+    const dayMatch = lower.match(/every\s+(\d+)\s+days?/);
+    if (dayMatch)
+        return `0 0 */${dayMatch[1]} * *`;
+    // "every N weeks" → approximate as every N*7 days
+    const weekNMatch = lower.match(/every\s+(\d+)\s+weeks?/);
+    if (weekNMatch)
+        return `0 0 */${Number(weekNMatch[1]) * 7} * *`;
+    // ── Single-unit shorthands ────────────────────────────────────────────────
+    if (/every\s+minute/.test(lower))
+        return `* * * * *`;
+    if (/every\s+hour/.test(lower))
+        return `0 * * * *`;
+    if (/every\s+day/.test(lower) || lower === 'daily')
+        return `0 0 * * *`;
+    if (/every\s+week(?!\w)/.test(lower) || lower === 'weekly')
+        return `0 0 * * 0`;
+    // ── Weekday / weekend ─────────────────────────────────────────────────────
+    if (/every\s+weekday/.test(lower))
+        return `0 0 * * 1-5`;
+    if (/every\s+weekend/.test(lower))
+        return `0 0 * * 0,6`;
+    // ── Named day(s)-of-week with optional "at HH[:MM] [am|pm]" ─────────────
+    // Handles single and multiple days:
+    //   "every monday"
+    //   "every monday and sunday at 9am"
+    //   "every monday, wednesday and friday at 18:30"
+    const DOW = {
+        sunday: 0, sun: 0,
+        monday: 1, mon: 1,
+        tuesday: 2, tue: 2,
+        wednesday: 3, wed: 3,
+        thursday: 4, thu: 4,
+        friday: 5, fri: 5,
+        saturday: 6, sat: 6,
+    };
+    const DAY_NAMES = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday|sun|mon|tue|wed|thu|fri|sat';
+    // Strip the leading "every " then capture the day-list and optional time tail
+    const multiDowRe = new RegExp(`^every\\s+((?:(?:${DAY_NAMES})(?:\\s*(?:,|\\band\\b)\\s*)?)*)(?:\\s+at\\s+(\\d{1,2})(?::(\\d{2}))?\\s*(am|pm)?)?$`);
+    const multiDowMatch = lower.match(multiDowRe);
+    if (multiDowMatch) {
+        const dayListStr = multiDowMatch[1];
+        const foundDays = dayListStr.match(new RegExp(DAY_NAMES, 'g'));
+        if (foundDays && foundDays.length > 0) {
+            const dowValues = [...new Set(foundDays.map((d) => DOW[d]))].sort((a, b) => a - b);
+            let hour = 0;
+            let minute = 0;
+            if (multiDowMatch[2]) {
+                hour = parseInt(multiDowMatch[2], 10);
+                minute = multiDowMatch[3] ? parseInt(multiDowMatch[3], 10) : 0;
+                const period = multiDowMatch[4];
+                if (period === 'pm' && hour < 12)
+                    hour += 12;
+                if (period === 'am' && hour === 12)
+                    hour = 0;
+            }
+            return `${minute} ${hour} * * ${dowValues.join(',')}`;
+        }
+    }
+    throw new Error(`Cannot parse interval expression: "${expression}". ` +
+        `Supported formats: "every N minutes/hours/days/weeks", "every minute/hour/day/week", ` +
+        `"every monday [at 9am]", "every monday and friday at 18:30", "every weekday", "every weekend", "daily", "weekly".`);
+}
+function formatDatetime(date, timezone) {
+    try {
+        return date.toLocaleString('en-US', {
+            timeZone: timezone,
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            timeZoneName: 'short',
+        });
+    }
+    catch {
+        return date.toISOString();
+    }
+}
+export function parseScheduleExpression(expression, type, opts = {}) {
+    const timezone = opts.timezone ?? 'UTC';
+    const refDate = opts.referenceDate ? new Date(opts.referenceDate) : new Date();
+    switch (type) {
+        case 'once': {
+            let parsed = null;
+            // 1. Relative duration: "in N minutes/hours/days/weeks" (handles abbreviations like "in 5 min")
+            const relMatch = expression.toLowerCase().trim().match(/^in\s+(\d+)\s+(min(?:ute)?s?|hours?|days?|weeks?)$/);
+            if (relMatch) {
+                const amount = parseInt(relMatch[1], 10);
+                const unit = relMatch[2];
+                const ms = unit.startsWith('min') ? amount * 60_000
+                    : unit.startsWith('hour') ? amount * 3_600_000
+                        : unit.startsWith('day') ? amount * 86_400_000
+                            : amount * 7 * 86_400_000;
+                parsed = new Date(refDate.getTime() + ms);
+            }
+            // 2. ISO 8601
+            if (!parsed) {
+                const isoDate = new Date(expression);
+                if (!isNaN(isoDate.getTime()))
+                    parsed = isoDate;
+            }
+            // 3. chrono-node NLP fallback ("tomorrow at 9am", "next friday", etc.)
+            if (!parsed) {
+                const results = chrono.parse(expression, { instant: refDate, timezone });
+                if (results.length > 0 && results[0].date()) {
+                    parsed = results[0].date();
+                }
+            }
+            if (!parsed) {
+                throw new Error(`Could not parse date/time expression: "${expression}". ` +
+                    `Try: "in 30 minutes", "in 2 hours", "tomorrow at 9am", "next friday at 3pm", or an ISO 8601 datetime.`);
+            }
+            if (parsed.getTime() <= refDate.getTime()) {
+                throw new Error(`Scheduled time must be in the future. Got: "${expression}" which resolves to ${parsed.toISOString()}.`);
+            }
+            return {
+                type: 'once',
+                next_run_at: parsed.getTime(),
+                cron_normalized: null,
+                human_readable: formatDatetime(parsed, timezone),
+            };
+        }
+        case 'cron': {
+            let interval;
+            try {
+                interval = parseCron(expression, { tz: timezone, currentDate: refDate });
+            }
+            catch (err) {
+                throw new Error(`Invalid cron expression: "${expression}". ${err.message}`);
+            }
+            // Enforce minimum 60s interval by checking two consecutive occurrences
+            const first = interval.next().toDate();
+            const second = interval.next().toDate();
+            const intervalMs = second.getTime() - first.getTime();
+            if (intervalMs < 60000) {
+                throw new Error(`Minimum interval is 60 seconds. The cron expression "${expression}" triggers more frequently.`);
+            }
+            // Recompute for next_run_at (cron-parser iterator was advanced above)
+            const nextInterval = parseCron(expression, { tz: timezone, currentDate: refDate });
+            const next = nextInterval.next().toDate();
+            let human_readable;
+            try {
+                human_readable = cronstrue.toString(expression, { throwExceptionOnParseError: true });
+            }
+            catch {
+                human_readable = expression;
+            }
+            return {
+                type: 'cron',
+                next_run_at: next.getTime(),
+                cron_normalized: expression,
+                human_readable,
+            };
+        }
+        case 'interval': {
+            const cronExpr = intervalToCron(expression);
+            // Validate via cron case (will also enforce minimum 60s)
+            const result = parseScheduleExpression(cronExpr, 'cron', opts);
+            let human_readable;
+            try {
+                human_readable = cronstrue.toString(cronExpr, { throwExceptionOnParseError: true });
+            }
+            catch {
+                human_readable = expression;
+            }
+            return {
+                type: 'interval',
+                next_run_at: result.next_run_at,
+                cron_normalized: cronExpr,
+                human_readable,
+            };
+        }
+        default:
+            throw new Error(`Unknown schedule type: "${type}"`);
+    }
+}
+/**
+ * Compute the next occurrence for a recurring job after execution.
+ * Used by ChronosWorker after each successful trigger.
+ */
+export function parseNextRun(cronNormalized, timezone, referenceDate) {
+    const refDate = referenceDate ? new Date(referenceDate) : new Date();
+    const interval = parseCron(cronNormalized, { tz: timezone, currentDate: refDate });
+    return interval.next().toDate().getTime();
+}
+/**
+ * Compute the next N occurrences for a recurring schedule.
+ * Used by the preview endpoint.
+ */
+export function getNextOccurrences(cronNormalized, timezone, count = 3, referenceDate) {
+    const refDate = referenceDate ? new Date(referenceDate) : new Date();
+    const interval = parseCron(cronNormalized, { tz: timezone, currentDate: refDate });
+    const results = [];
+    for (let i = 0; i < count; i++) {
+        results.push(interval.next().toDate().getTime());
+    }
+    return results;
+}

package/dist/runtime/chronos/parser.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { parseScheduleExpression } from './parser.js';
+const FUTURE_MS = Date.now() + 60_000 * 60 * 24; // 24 hours from now
+const REF = Date.now();
+describe('parseScheduleExpression — once type', () => {
+    it('parses a valid ISO datetime in the future', () => {
+        const future = new Date(FUTURE_MS).toISOString();
+        const result = parseScheduleExpression(future, 'once', { referenceDate: REF });
+        expect(result.type).toBe('once');
+        expect(result.next_run_at).toBeGreaterThan(REF);
+        expect(result.cron_normalized).toBeNull();
+        expect(result.human_readable).toBeTruthy();
+    });
+    it('throws for a past datetime', () => {
+        const past = new Date(Date.now() - 1000).toISOString();
+        expect(() => parseScheduleExpression(past, 'once', { referenceDate: REF })).toThrow(/must be in the future/i);
+    });
+    it('parses natural language "tomorrow at 9am" in a given timezone', () => {
+        const result = parseScheduleExpression('tomorrow at 9am', 'once', {
+            timezone: 'America/Sao_Paulo',
+            referenceDate: REF,
+        });
+        expect(result.type).toBe('once');
+        expect(result.next_run_at).toBeGreaterThan(REF);
+        expect(result.cron_normalized).toBeNull();
+    });
+});
+describe('parseScheduleExpression — cron type', () => {
+    it('parses a valid 5-field cron expression', () => {
+        const result = parseScheduleExpression('0 9 * * 1-5', 'cron', { referenceDate: REF });
+        expect(result.type).toBe('cron');
+        expect(result.next_run_at).toBeGreaterThan(REF);
+        expect(result.cron_normalized).toBe('0 9 * * 1-5');
+        expect(result.human_readable.length).toBeGreaterThan(0);
+    });
+    it('throws for an invalid cron expression', () => {
+        expect(() => parseScheduleExpression('not a cron', 'cron', { referenceDate: REF })).toThrow(/invalid cron/i);
+    });
+    it('throws when cron interval is less than 60 seconds (every minute)', () => {
+        // "* * * * *" fires every 60s — exactly at the boundary. Accept it.
+        // "*/30 * * * * *" (6-field sub-minute) would fail but cron-parser v4 uses 5-field only.
+        // We test a cron that would trigger at sub-minute intervals if possible.
+        // For 5-field cron the minimum is 60s — "* * * * *" is exactly 60s so it's valid.
+        const result = parseScheduleExpression('* * * * *', 'cron', { referenceDate: REF });
+        expect(result.next_run_at).toBeGreaterThan(REF);
+    });
+});
+describe('parseScheduleExpression — interval type', () => {
+    it('converts "every 30 minutes" to a valid cron with interval >= 60s', () => {
+        const result = parseScheduleExpression('every 30 minutes', 'interval', { referenceDate: REF });
+        expect(result.type).toBe('interval');
+        expect(result.next_run_at).toBeGreaterThan(REF);
+        expect(result.cron_normalized).toBe('*/30 * * * *');
+        expect(result.human_readable.length).toBeGreaterThan(0);
+    });
+    it('converts "every hour" to a valid cron', () => {
+        const result = parseScheduleExpression('every hour', 'interval', { referenceDate: REF });
+        expect(result.cron_normalized).toBe('0 * * * *');
+    });
+    it('throws for an unsupported interval phrase', () => {
+        expect(() => parseScheduleExpression('every 30 seconds', 'interval', { referenceDate: REF })).toThrow();
+    });
+});