@kafca/agentdock 0.1.61 → 0.1.63

package/dist-electron/tests/electron/automation-engine.test.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = __importDefault(require("node:test"));
+const strict_1 = __importDefault(require("node:assert/strict"));
+const automation_trigger_engine_js_1 = require("../../services/local-ai-core/src/automation/automation-trigger-engine.js");
+const automation_condition_engine_js_1 = require("../../services/local-ai-core/src/automation/automation-condition-engine.js");
+const cron_js_1 = require("../../services/local-ai-core/src/scheduler/cron.js");
+const at = (value) => new Date(value);
+(0, node_test_1.default)('activation engines calculate deterministic next and due instants', () => {
+    const cases = [
+        {
+            name: 'cron',
+            activation: { kind: 'cron', expression: '*/15 * * * *', timezone: 'UTC' },
+            after: at('2026-07-05T10:07:31.000Z'),
+            expectedNext: '2026-07-05T10:15:00.000Z',
+            dueAt: '2026-07-05T10:15:00.000Z',
+            notDueAt: '2026-07-05T10:14:59.999Z',
+        },
+        {
+            name: 'once before runAt',
+            activation: { kind: 'once', runAt: '2026-07-05T11:00:00.000Z' },
+            after: at('2026-07-05T10:00:00.000Z'),
+            expectedNext: '2026-07-05T11:00:00.000Z',
+            dueAt: '2026-07-05T11:00:00.000Z',
+            notDueAt: '2026-07-05T10:59:59.999Z',
+        },
+        {
+            name: 'once after runAt does not repeat',
+            activation: { kind: 'once', runAt: '2026-07-05T11:00:00.000Z' },
+            after: at('2026-07-05T11:00:00.000Z'),
+            expectedNext: null,
+        },
+        {
+            name: 'interval remains anchored to the Unix epoch',
+            activation: { kind: 'interval', intervalMs: 60_000 },
+            after: at('2026-07-05T10:00:30.000Z'),
+            expectedNext: '2026-07-05T10:01:00.000Z',
+            dueAt: '2026-07-05T10:01:00.000Z',
+            notDueAt: '2026-07-05T10:00:59.999Z',
+        },
+    ];
+    for (const item of cases) {
+        const next = (0, automation_trigger_engine_js_1.nextActivationAt)(item.activation, item.after);
+        strict_1.default.equal(next?.toISOString() ?? null, item.expectedNext, item.name);
+        if (item.dueAt && item.notDueAt && item.expectedNext) {
+            strict_1.default.equal((0, automation_trigger_engine_js_1.isActivationDue)(item.activation, at(item.notDueAt), item.expectedNext), false, item.name);
+            strict_1.default.equal((0, automation_trigger_engine_js_1.isActivationDue)(item.activation, at(item.dueAt), item.expectedNext), true, item.name);
+        }
+    }
+});
+(0, node_test_1.default)('provider-event activations are external and never timer-due', () => {
+    const activation = {
+        kind: 'provider-event',
+        sourceType: 'stock.quote',
+        sourceConfig: {},
+    };
+    const now = at('2026-07-05T10:00:00.000Z');
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)(activation, now), null);
+    strict_1.default.equal((0, automation_trigger_engine_js_1.isActivationDue)(activation, now, '2026-07-05T09:00:00.000Z'), false);
+    strict_1.default.equal((0, automation_trigger_engine_js_1.missedActivationAt)(activation, undefined, now), null);
+});
+(0, node_test_1.default)('cron timezone limitations are explicit', () => {
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)({ kind: 'cron', expression: '0 9 * * *', timezone: 'Asia/Shanghai' }, at('2026-07-05T00:00:00.000Z')), /only UTC cron timezones/i);
+});
+(0, node_test_1.default)('cron compilation is strict and all activation entry points reject invalid expressions', () => {
+    const invalidExpressions = [
+        '* * * *',
+        '* * * * * *',
+        '*/0 * * * *',
+        '*/x * * * *',
+        '*/1.5 * * * *',
+        '*/-1 * * * *',
+        '1,,2 * * * *',
+        '10-5 * * * *',
+        '60 * * * *',
+        '* 24 * * *',
+        '* * 0 * *',
+        '* * * 13 *',
+        '* * * * 7',
+        'bogus * * * *',
+    ];
+    for (const expression of invalidExpressions) {
+        strict_1.default.throws(() => (0, cron_js_1.compileCronExpression)(expression), /invalid cron/i, expression);
+    }
+    const activation = { kind: 'cron', expression: '*/0 * * * *', timezone: 'UTC' };
+    const now = at('2026-07-05T10:00:00.000Z');
+    for (const invoke of [
+        () => (0, automation_trigger_engine_js_1.nextActivationAt)(activation, now),
+        () => (0, automation_trigger_engine_js_1.isActivationDue)(activation, now, now.toISOString()),
+        () => (0, automation_trigger_engine_js_1.missedActivationAt)(activation, undefined, now),
+    ]) {
+        strict_1.default.throws(invoke, /invalid cron/i);
+    }
+});
+(0, node_test_1.default)('compiled cron search is bounded for annual and impossible schedules', () => {
+    const annual = (0, cron_js_1.findNextCronMatchUtc)((0, cron_js_1.compileCronExpression)('0 0 1 1 *'), at('2026-01-01T00:00:00.000Z'));
+    strict_1.default.equal(annual.date?.toISOString(), '2027-01-01T00:00:00.000Z');
+    strict_1.default.ok(annual.inspectedDays <= 367, `annual search inspected ${annual.inspectedDays} days`);
+    const impossible = (0, cron_js_1.findNextCronMatchUtc)((0, cron_js_1.compileCronExpression)('0 0 31 2 *'), at('2026-01-01T00:00:00.000Z'));
+    strict_1.default.equal(impossible.date, null);
+    strict_1.default.ok(impossible.inspectedDays <= 146_098, `impossible search inspected ${impossible.inspectedDays} days`);
+});
+(0, node_test_1.default)('cron matching keeps legacy day-of-month AND day-of-week semantics', () => {
+    const expression = '0 9 5 * 1';
+    strict_1.default.equal((0, cron_js_1.cronMatchesDate)(expression, new Date(2026, 0, 5, 9)), true);
+    strict_1.default.equal((0, cron_js_1.cronMatchesDate)(expression, new Date(2026, 0, 12, 9)), false);
+    strict_1.default.equal((0, cron_js_1.cronMatchesDate)(expression, new Date(2026, 3, 5, 9)), false);
+});
+(0, node_test_1.default)('legacy cron matching fails closed for malformed expressions', () => {
+    const now = at('2026-07-05T10:00:00.000Z');
+    strict_1.default.equal((0, cron_js_1.cronMatchesDate)('invalid', now), false);
+    strict_1.default.equal((0, cron_js_1.cronMatchesDate)('*/0 * * * *', now), false);
+});
+(0, node_test_1.default)('cron next activation is exclusive at exact boundaries', () => {
+    const activation = { kind: 'cron', expression: '0 * * * *', timezone: 'UTC' };
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)(activation, at('2026-07-05T10:00:00.000Z'))?.toISOString(), '2026-07-05T11:00:00.000Z');
+});
+(0, node_test_1.default)('cron search preserves UTC years from 0 through 99', () => {
+    const activation = { kind: 'cron', expression: '0 0 * * *', timezone: 'UTC' };
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)(activation, at('0050-01-01T00:00:00.000Z'))?.toISOString(), '0050-01-02T00:00:00.000Z');
+});
+(0, node_test_1.default)('previous cron search stops at its exclusive lower bound', () => {
+    const result = (0, cron_js_1.findPreviousCronMatchUtc)((0, cron_js_1.compileCronExpression)('0 0 31 2 *'), at('2026-07-05T10:00:00.000Z'), at('2026-07-04T10:00:00.000Z'));
+    strict_1.default.equal(result.date, null);
+    strict_1.default.ok(result.inspectedDays <= 2, `bounded search inspected ${result.inspectedDays} days`);
+});
+(0, node_test_1.default)('cron search does not return dates outside the JavaScript Date range', () => {
+    const activation = { kind: 'cron', expression: '* * * * *', timezone: 'UTC' };
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)(activation, new Date(8_640_000_000_000_000)), /no UTC cron activation exists/i);
+});
+(0, node_test_1.default)('restart recovery returns only the most recent missed activation', () => {
+    const now = at('2026-07-05T10:05:30.000Z');
+    const cases = [
+        ['cron', { kind: 'cron', expression: '* * * * *', timezone: 'UTC' }, '2026-07-05T10:00:30.000Z', '2026-07-05T10:05:00.000Z'],
+        ['once', { kind: 'once', runAt: '2026-07-05T10:02:00.000Z' }, '2026-07-05T10:00:30.000Z', '2026-07-05T10:02:00.000Z'],
+        ['interval', { kind: 'interval', intervalMs: 60_000 }, '2026-07-05T10:00:30.000Z', '2026-07-05T10:05:00.000Z'],
+        ['nothing before first check', { kind: 'once', runAt: '2026-07-05T10:02:00.000Z' }, undefined, null],
+    ];
+    for (const [name, activation, lastCheckedAt, expected] of cases) {
+        strict_1.default.equal((0, automation_trigger_engine_js_1.missedActivationAt)(activation, lastCheckedAt, now)?.toISOString() ?? null, expected, name);
+    }
+});
+(0, node_test_1.default)('activation helpers validate dates and activations before schedule state shortcuts', () => {
+    const invalidOnce = { kind: 'once', runAt: '2026-02-31T10:00:00.000Z' };
+    const localOnce = { kind: 'once', runAt: '2026-07-05 10:00:00' };
+    const invalidIntervals = [
+        { kind: 'interval', intervalMs: 0 },
+        { kind: 'interval', intervalMs: 1.5 },
+    ];
+    const now = at('2026-07-05T10:00:00.000Z');
+    for (const activation of [invalidOnce, localOnce, ...invalidIntervals]) {
+        strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)(activation, now), /automation/i);
+        strict_1.default.throws(() => (0, automation_trigger_engine_js_1.isActivationDue)(activation, now, now.toISOString()), /automation/i);
+        strict_1.default.throws(() => (0, automation_trigger_engine_js_1.missedActivationAt)(activation, undefined, now), /automation/i);
+    }
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.isActivationDue)({ kind: 'interval', intervalMs: 60_000 }, now, 'not-a-timestamp'), /valid ISO timestamp/i);
+    const maximumInterval = { kind: 'interval', intervalMs: Number.MAX_SAFE_INTEGER };
+    strict_1.default.equal((0, automation_trigger_engine_js_1.nextActivationAt)(maximumInterval, new Date(-1))?.toISOString(), '1970-01-01T00:00:00.000Z');
+    strict_1.default.equal((0, automation_trigger_engine_js_1.isActivationDue)(maximumInterval, now, now.toISOString()), true);
+    strict_1.default.equal((0, automation_trigger_engine_js_1.missedActivationAt)(maximumInterval, undefined, now), null);
+    strict_1.default.throws(() => (0, automation_trigger_engine_js_1.nextActivationAt)(maximumInterval, now), /valid date/i);
+    const valid = { kind: 'interval', intervalMs: 60_000 };
+    for (const invoke of [
+        () => (0, automation_trigger_engine_js_1.nextActivationAt)(valid, new Date(Number.NaN)),
+        () => (0, automation_trigger_engine_js_1.isActivationDue)(valid, new Date(Number.NaN)),
+        () => (0, automation_trigger_engine_js_1.missedActivationAt)(valid, now.toISOString(), new Date(Number.NaN)),
+    ]) {
+        strict_1.default.throws(invoke, /valid date/i);
+    }
+});
+(0, node_test_1.default)('activation and condition engines do not mutate caller inputs', () => {
+    const activation = Object.freeze({ kind: 'interval', intervalMs: 60_000 });
+    const payload = Object.freeze({ price: 101 });
+    const condition = Object.freeze({ kind: 'expression', expression: 'price > 100' });
+    const activationSnapshot = JSON.stringify(activation);
+    const payloadSnapshot = JSON.stringify(payload);
+    (0, automation_trigger_engine_js_1.nextActivationAt)(activation, at('2026-07-05T10:00:30.000Z'));
+    (0, automation_condition_engine_js_1.decideCondition)({ condition, payload, previous: false });
+    strict_1.default.equal(JSON.stringify(activation), activationSnapshot);
+    strict_1.default.equal(JSON.stringify(payload), payloadSnapshot);
+});
+(0, node_test_1.default)('trigger state machine detects rising edges and re-arms after false', () => {
+    const cases = [
+        { name: 'first successful true', previous: undefined, matched: true, outcome: 'matched', decision: 'triggered', next: true },
+        { name: 'false to true', previous: false, matched: true, outcome: 'matched', decision: 'triggered', next: true },
+        { name: 'true to true', previous: true, matched: true, outcome: 'matched', decision: 'not_rising', next: true },
+        { name: 'false re-arms', previous: true, matched: false, outcome: 'not_matched', decision: 'not_rising', next: false },
+        { name: 'cooldown suppresses rising edge', previous: false, matched: true, coolingDown: true, outcome: 'matched', decision: 'skipped_cooldown', next: true },
+        { name: 'running action suppresses rising edge', previous: false, matched: true, actionRunning: true, outcome: 'matched', decision: 'skipped_action_running', next: true },
+    ];
+    for (const item of cases) {
+        strict_1.default.deepEqual((0, automation_condition_engine_js_1.decideTrigger)(item), {
+            conditionOutcome: item.outcome,
+            triggerDecision: item.decision,
+            nextMatch: item.next,
+        }, item.name);
+    }
+});
+(0, node_test_1.default)('evaluation admission explicitly skips concurrent evaluation', () => {
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.admitConditionEvaluation)(false), { admitted: true });
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.admitConditionEvaluation)(true), {
+        admitted: false,
+        conditionOutcome: 'skipped',
+        triggerDecision: 'skipped_concurrent',
+    });
+});
+(0, node_test_1.default)('condition errors preserve the previous successful match', () => {
+    const result = (0, automation_condition_engine_js_1.decideCondition)({
+        condition: { kind: 'expression', expression: 'not valid' },
+        payload: {},
+        previous: true,
+    });
+    strict_1.default.equal(result.kind, 'decision');
+    if (result.kind !== 'decision')
+        strict_1.default.fail('expected a trigger decision');
+    strict_1.default.equal(result.conditionOutcome, 'error');
+    strict_1.default.equal(result.triggerDecision, 'not_evaluated');
+    strict_1.default.equal(result.nextMatch, true);
+    strict_1.default.match(result.error ?? '', /unsupported/i);
+});
+(0, node_test_1.default)('overlap skips without executing the condition evaluator', () => {
+    let calls = 0;
+    const result = (0, automation_condition_engine_js_1.decideCondition)({
+        condition: { kind: 'always' },
+        previous: false,
+        evaluationRunning: true,
+    }, () => {
+        calls += 1;
+        return { kind: 'evaluated', matched: true };
+    });
+    strict_1.default.equal(calls, 0);
+    strict_1.default.deepEqual(result, {
+        kind: 'decision',
+        conditionOutcome: 'skipped',
+        triggerDecision: 'skipped_concurrent',
+        nextMatch: false,
+    });
+});
+(0, node_test_1.default)('condition evaluation supports always and delegates restricted expressions', () => {
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.evaluateCondition)({ kind: 'always' }), { kind: 'evaluated', matched: true });
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.evaluateCondition)({ kind: 'expression', expression: 'price >= 100 && symbol == "AAPL"' }, { price: 101, symbol: 'AAPL' }), { kind: 'evaluated', matched: true });
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.evaluateCondition)({ kind: 'expression', expression: 'quote.price >= 100' }, { quote: { price: 101 } }), { kind: 'evaluated', matched: true });
+    strict_1.default.throws(() => (0, automation_condition_engine_js_1.evaluateCondition)({ kind: 'expression', expression: 'globalThis.process' }, {}), /unsupported/i);
+});
+(0, node_test_1.default)('approved-script conditions return a typed Task 9 delegation request', () => {
+    const condition = {
+        kind: 'approved-script',
+        scriptId: 'script:1',
+        approvedVersionId: 'version:2',
+        edge: 'rising',
+    };
+    strict_1.default.deepEqual((0, automation_condition_engine_js_1.evaluateCondition)(condition, { price: 101 }), {
+        kind: 'script-delegation',
+        request: {
+            scriptId: 'script:1',
+            approvedVersionId: 'version:2',
+            edge: 'rising',
+            payload: { price: 101 },
+        },
+    });
+});