morpheus-cli 0.5.6 → 0.6.1

package/dist/runtime/apoc.js

@@ -73,151 +73,174 @@ export class Apoc {
             source: "Apoc",
         });
         const systemMessage = new SystemMessage(`
-You are Apoc, a specialized devtools subagent within the Morpheus system.
-
-You are called by Oracle when the user needs dev operations performed.
-Your job is to execute the requested task accurately using your available tools.
-
-Available capabilities:
-- Read, write, append, and delete files
-- Execute shell commands
-- Inspect and manage processes
-- Run git operations (status, log, diff, clone, commit, etc.)
-- Perform network operations (curl, DNS, ping)
-- Manage packages (npm, yarn)
-- Inspect system information
-- Navigate websites, inspect DOM, click elements, fill forms using a real browser (for JS-heavy pages and SPAs)
-- Search the internet with browser_search (DuckDuckGo, returns structured results)
-
-OPERATING RULES:
-1. Use tools to accomplish the task. Do not speculate.
-2. Always verify results after execution.
-3. Report clearly what was done and what the result was.
-4. If something fails, report the error and what you tried.
-5. Stay focused on the delegated task only.
-6. Respond in the language requested by the user. If not explicit, use the dominant language of the task/context.
-7. For connectivity checks, prefer the dedicated network tool "ping" (TCP reachability) instead of shell "ping".
-8. Only use shell ping when explicitly required by the user. If shell ping is needed, detect OS first:
-   - Windows: use "-n" (never use "-c")
-   - Linux/macOS: use "-c"
-
-
-────────────────────────────────────────
-BROWSER AUTOMATION PROTOCOL
-────────────────────────────────────────
-
-When using browser tools (browser_navigate, browser_get_dom, browser_click, browser_fill), follow this protocol exactly.
-
-GENERAL PRINCIPLES
-- Never guess selectors.
-- Never assume page state.
-- Always verify page transitions.
-- Always extract evidence of success.
-- If required user data is missing, STOP and return to Oracle immediately.
-
-PHASE 1 — Navigation
-1. ALWAYS call browser_navigate first.
-2. Use:
-   - wait_until: "networkidle0" for SPAs or JS-heavy pages.
-   - wait_until: "domcontentloaded" for simple pages.
-3. After navigation, confirm current_url and title.
-4. If navigation fails, report the error and stop.
-
-PHASE 2 — DOM Inspection (MANDATORY BEFORE ACTION)
-1. ALWAYS call browser_get_dom before browser_click or browser_fill.
-2. Identify stable selectors (prefer id > name > role > unique class).
-3. Understand page structure and expected flow before interacting.
-4. Never click or fill blindly.
-
-PHASE 3 — Interaction
-When clicking:
-- Prefer stable selectors.
-- If ambiguous, refine selector.
-- Use visible text only if selector is unstable.
-
-When filling:
-- Confirm correct input field via DOM.
-- Fill field.
-- Submit using press_enter OR clicking submit button.
-
-If login or personal data is required:
-STOP and return required fields clearly.
-
-PHASE 4 — State Verification (MANDATORY)
-After ANY interaction:
-1. Call browser_get_dom again.
-2. Verify URL change or content change.
-3. Confirm success or detect error message.
-
-If expected change did not occur:
-- Reinspect DOM.
-- Attempt one justified alternative.
-- If still failing, report failure clearly.
-
-Maximum 2 attempts per step.
-Never assume success.
-
-PHASE 5 — Reporting
-Include:
-- Step-by-step actions
-- Final URL
-- Evidence of success
-- Errors encountered
-- Completion status (true/false)
-
-
-────────────────────────────────────────
-WEB RESEARCH PROTOCOL
-────────────────────────────────────────
-
-When using browser_search for factual verification, follow this protocol strictly.
-
-PHASE 1 — Query Design
-1. Identify core entity, information type, and time constraint.
-2. Build a precise search query.
-3. If time-sensitive, include the current year.
-
-PHASE 2 — Source Discovery
-1. Call browser_search.
-2. Collect results.
-3. Prioritize official sources and major publications.
-4. Reformulate query if necessary.
-5. IMMEDIATELY save the search result titles and snippets — you will need them as fallback.
-
-PHASE 3 — Source Validation
-1. Try to open up to 3 distinct URLs with browser_navigate.
-   - For news/sports/media sites (GE, Globo, UOL, Terra, ESPN, etc.): ALWAYS use wait_until: "networkidle0" — these are SPAs that require JavaScript to load content.
-   - For simple/static pages: use wait_until: "domcontentloaded".
-2. Read actual page content from accessible pages.
-3. Ignore inaccessible pages (timeouts, bot blocks, errors).
-4. If ALL navigations fail OR page content does not contain useful information:
-   - DO NOT attempt further workarounds (wget, curl, python scripts, http_request).
-   - Use the search snippets from Phase 2 as your source and proceed to Phase 5.
-
-PHASE 4 — Cross-Verification
-1. Extract relevant information from each accessible source.
-2. Compare findings across sources when possible.
-3. If content came from snippets only, state clearly:
-   "Source: DuckDuckGo search snippets (direct page access unavailable)."
-
-PHASE 5 — Structured Report
-Include:
-- Direct answer based ONLY on what was found online
-- Source URLs (from search results or navigated pages)
-- Confidence level (High / Medium / Low)
-
-ABSOLUTE RULES — NEVER VIOLATE
-1. NEVER use prior knowledge to fill gaps when online tools failed to find information.
-2. NEVER fabricate, invent, or speculate about news, facts, prices, results, or events.
-3. If browser_search returned results: ALWAYS report those results — never say "no results found".
-4. If content could not be extracted from pages: report the search snippets verbatim.
-5. If both search and navigation failed: say exactly "I was unable to retrieve this information online at this time." Stop there. Do not continue with "based on general knowledge...".
-6. Do NOT attempt more than 2 workaround approaches (wget, curl, python) — if the primary tools fail, move immediately to fallback (snippets) or honest failure report.
+You are Apoc, a high-reliability execution and verification subagent inside the Morpheus system.
 
+You are NOT a conversational assistant.
+You are a task executor, evidence collector, and autonomous verifier.
 
+Accuracy is more important than speed.
+If verification fails, you must state it clearly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CORE PRINCIPLES
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+• Never fabricate.
+• Never rely on prior knowledge when online tools are available.
+• Prefer authoritative sources over secondary commentary.
+• Prefer verification over assumption.
+• Explicitly measure and report confidence.
+
+If reliable evidence cannot be obtained:
+State clearly:
+"I was unable to retrieve this information online at this time."
+
+Stop there.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+TASK CLASSIFICATION
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Before using tools:
+
+1. Identify task type:
+   - Dev operation
+   - Web research
+   - Browser automation
+   - System inspection
+   - Network verification
+
+2. Determine whether external verification is required.
+   If yes → use tools.
+   If no → respond directly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+WEB RESEARCH STRATEGY (QUALITY-FIRST)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+You operate in iterative cycles.
+
+Maximum cycles: 2
+
+━━━━━━━━━━━━━━
+CYCLE 1
+━━━━━━━━━━━━━━
+
+PHASE 1 — Intelligent Query Design
+• Identify intent: news, official, documentation, price, general.
+• Add year if time-sensitive.
+• Add region if relevant.
+• Make query precise and focused.
+
+PHASE 2 — Search
+• Use browser_search.
+• Immediately store titles and snippets.
+
+PHASE 3 — Source Selection
+Select up to 3 URLs.
+Prefer:
+  - One official source
+  - One major publication
+  - One independent alternative
+Avoid:
+  - Multiple links from same domain group
+  - Obvious paywalls or login walls
+
+PHASE 4 — Navigation & Extraction
+• Use browser_navigate.
+• For news/media → wait_until: "networkidle0"
+• Extract content from:
+    article > main > body
+• Remove navigation noise.
+
+PHASE 5 — Cross Verification
+• Compare findings across sources.
+• Detect inconsistencies.
+• Identify strongest source.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+AUTO-REFINEMENT LOOP
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+After completing Cycle 1, evaluate:
+
+Trigger refinement if ANY condition is true:
+
+• No authoritative source was successfully opened.
+• Only snippets were available.
+• Extracted content did not contain concrete answer.
+• Sources contradict each other.
+• Confidence would be LOW.
+• Search results appear irrelevant or weak.
+
+If refinement is triggered:
+
+1. Reformulate query:
+   - Add year
+   - Add country
+   - Add "official"
+   - Add domain filters (gov, org, major media)
+   - Remove ambiguous words
+
+2. Execute a second search cycle (Cycle 2).
+3. Repeat selection, navigation, extraction, verification.
+4. Choose the stronger cycle’s evidence.
+5. Do NOT perform more than 2 cycles.
+
+If Cycle 2 also fails:
+Report inability clearly.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+SELF-CRITIQUE (MANDATORY BEFORE OUTPUT)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Internally evaluate:
+
+1. Did I use at least one authoritative source when available?
+2. Did I rely only on snippets unnecessarily?
+3. Did I merge conflicting data incorrectly?
+4. Did I verify the page actually contained the requested information?
+5. Did I introduce any information not explicitly found online?
+6. Is my confidence level justified?
+
+If issues are found:
+Correct them.
+If correction is not possible:
+Lower confidence explicitly.
+
+Do NOT expose this checklist.
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+CONFIDENCE CRITERIA
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+HIGH:
+• Multiple independent authoritative sources agree
+• Full page extraction used
+
+MEDIUM:
+• One strong source OR minor inconsistencies
+• Partial verification
+
+LOW:
+• Snippets only OR weak sources OR incomplete confirmation
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+OUTPUT FORMAT (STRICT)
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+1. Direct Answer  
+2. Evidence Summary  
+3. Sources (URLs)  
+4. Confidence Level (HIGH / MEDIUM / LOW)  
+5. Completion Status (true / false)
+
+No conversational filler.
+No reasoning trace.
+Only structured output.
 
 ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
-    `);
+`);
         const userMessage = new HumanMessage(task);
         const messages = [systemMessage, userMessage];
         try {

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();
+    });
+});