@switchbot/openapi-cli 3.1.1 → 3.2.0

package/dist/rules/cron-scheduler.js

@@ -1,186 +0,0 @@
-/**
- * Cron trigger scheduler for the rules engine.
- *
- * Each cron rule gets its own scheduler entry. On every tick the
- * scheduler synthesises an `EngineEvent` with `source: 'cron'` and hands
- * it to the same dispatch path the MQTT pipeline uses, so conditions,
- * throttle, and action execution behave identically regardless of
- * trigger source.
- *
- * Tests can drive the scheduler deterministically via `fireNowForTest()`
- * — the scheduler's internal timer still uses `setTimeout`, which means
- * `vi.useFakeTimers()` plus `vi.advanceTimersByTime()` also work. Croner
- * is used only for `nextRun(fromDate)` calculations; we own the
- * timer/dispatch loop so the engine can drain events through a single
- * serialised queue.
- */
-import { Cron } from 'croner';
-/** Maps JS getDay() (0=Sun) to 3-letter abbreviation. */
-const JS_DAY_TO_ABBR = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat'];
-/** Expand a days[] entry to its canonical 3-letter abbr so comparisons are O(1). */
-function normaliseDay(d) {
-    return d.toLowerCase().slice(0, 3);
-}
-/** Return true if `t` falls on one of the listed days (or days is absent/empty). */
-export function matchesDayFilter(days, t) {
-    if (!days || days.length === 0)
-        return true;
-    const todayAbbr = JS_DAY_TO_ABBR[t.getDay()];
-    return days.some((d) => normaliseDay(d) === todayAbbr);
-}
-export class CronScheduler {
-    opts;
-    entries = new Map();
-    started = false;
-    stopped = false;
-    constructor(opts) {
-        this.opts = opts;
-    }
-    getScheduledFor(ruleName) {
-        const s = this.entries.get(ruleName);
-        if (!s)
-            return null;
-        return { schedule: s.schedule, nextAt: s.nextAt };
-    }
-    hasRegistered(ruleName) {
-        return this.entries.has(ruleName);
-    }
-    /**
-     * Register a cron rule. Validates the pattern eagerly — an invalid
-     * schedule throws synchronously so engine start can surface the error.
-     */
-    register(rule) {
-        if (rule.when.source !== 'cron') {
-            throw new Error(`CronScheduler.register called for non-cron rule "${rule.name}"`);
-        }
-        if (this.entries.has(rule.name)) {
-            throw new Error(`CronScheduler: duplicate rule name "${rule.name}"`);
-        }
-        const schedule = rule.when.schedule;
-        let pattern;
-        try {
-            pattern = new Cron(schedule, { paused: true });
-        }
-        catch (err) {
-            throw new Error(`CronScheduler: invalid cron expression for rule "${rule.name}": ${schedule} (${err instanceof Error ? err.message : String(err)})`);
-        }
-        const entry = {
-            rule,
-            schedule,
-            pattern,
-            timer: null,
-            nextAt: null,
-        };
-        this.entries.set(rule.name, entry);
-        if (this.started && !this.stopped)
-            this.arm(entry);
-    }
-    unregister(ruleName) {
-        const e = this.entries.get(ruleName);
-        if (!e)
-            return;
-        if (e.timer)
-            clearTimeout(e.timer);
-        try {
-            e.pattern.stop();
-        }
-        catch {
-            // croner throws when already stopped — ignore.
-        }
-        this.entries.delete(ruleName);
-    }
-    start() {
-        if (this.stopped) {
-            throw new Error('CronScheduler: cannot start after stop().');
-        }
-        if (this.started)
-            return;
-        this.started = true;
-        for (const entry of this.entries.values())
-            this.arm(entry);
-    }
-    stop() {
-        if (this.stopped)
-            return;
-        this.stopped = true;
-        this.started = false;
-        for (const e of this.entries.values()) {
-            if (e.timer)
-                clearTimeout(e.timer);
-            e.timer = null;
-            try {
-                e.pattern.stop();
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    /**
-     * Test helper — compute the pattern's next run after a reference
-     * timestamp without actually scheduling it. Handy for regression tests.
-     */
-    nextRunAfter(ruleName, after) {
-        const e = this.entries.get(ruleName);
-        if (!e)
-            return null;
-        return e.pattern.nextRun(after) ?? null;
-    }
-    /**
-     * Test helper — fire a rule immediately, bypassing the timer. Used by
-     * unit tests to skip vi.advanceTimersByTime logic when the focus is on
-     * dispatch behaviour, not scheduling accuracy.
-     */
-    async fireNowForTest(ruleName) {
-        const e = this.entries.get(ruleName);
-        if (!e)
-            throw new Error(`CronScheduler.fireNowForTest: no rule "${ruleName}"`);
-        await this.fire(e);
-    }
-    nowDate() {
-        return this.opts.now ? this.opts.now() : new Date();
-    }
-    arm(entry) {
-        if (this.stopped)
-            return;
-        const now = this.nowDate();
-        const next = entry.pattern.nextRun(now);
-        if (!next) {
-            entry.nextAt = null;
-            return;
-        }
-        entry.nextAt = next;
-        const delayMs = Math.max(0, next.getTime() - now.getTime());
-        entry.timer = setTimeout(() => {
-            entry.timer = null;
-            // Fire and then re-arm, regardless of outcome — we never want one
-            // misbehaving rule to kill its own future ticks.
-            this.fire(entry)
-                .catch(() => undefined)
-                .finally(() => {
-                if (!this.stopped && this.entries.has(entry.rule.name))
-                    this.arm(entry);
-            });
-        }, delayMs);
-        // Unref so a process with only cron rules still exits on SIGINT when
-        // the user expects (e.g. in integration tests).
-        if (typeof entry.timer.unref === 'function') {
-            entry.timer.unref();
-        }
-    }
-    async fire(entry) {
-        const when = this.nowDate();
-        // Apply the optional day-of-week filter before dispatching.
-        const trigger = entry.rule.when;
-        if (trigger.source === 'cron' && !matchesDayFilter(trigger.days, when)) {
-            return;
-        }
-        const event = {
-            source: 'cron',
-            event: entry.schedule,
-            t: when,
-            payload: { schedule: entry.schedule },
-        };
-        await this.opts.dispatch(entry.rule, event);
-    }
-}

package/dist/rules/destructive.js

@@ -1,52 +0,0 @@
-/**
- * Destructive command parsing — single source of truth shared between the
- * policy validator post-hook (rejects destructive commands inside
- * `automation.rules[].then[].command`) and the runtime executor (second-
- * line guard that refuses to shell out even if validation was bypassed).
- */
-export const DESTRUCTIVE_COMMANDS = [
-    'lock',
-    'unlock',
-    'deleteWebhook',
-    'deleteScene',
-    'factoryReset',
-];
-/**
- * Parse the verb out of a rule action command string. The expected form
- * mirrors what the engine will eventually build: `devices command <id> <verb> [args...]`.
- * We also accept scene shorthands (`scenes run <id>`, `webhooks delete <id>`).
- *
- * Returns null for anything we cannot confidently attribute to a known verb
- * slot — the validator treats null as "probably fine, let the engine's own
- * guard handle it if it's not."
- */
-export function extractVerb(cmd) {
-    const trimmed = cmd.trim();
-    if (!trimmed)
-        return null;
-    const tokens = trimmed.split(/\s+/);
-    // `devices command <id> <verb> [args]`
-    if (tokens[0] === 'devices' && tokens[1] === 'command' && tokens.length >= 4) {
-        return tokens[3];
-    }
-    // `webhooks delete <id>` → verb is "deleteWebhook"
-    if (tokens[0] === 'webhooks' && tokens[1] === 'delete')
-        return 'deleteWebhook';
-    // `scenes delete <id>` → verb is "deleteScene"
-    if (tokens[0] === 'scenes' && tokens[1] === 'delete')
-        return 'deleteScene';
-    return null;
-}
-export function isDestructiveCommand(cmd) {
-    const verb = extractVerb(cmd);
-    if (!verb)
-        return false;
-    return DESTRUCTIVE_COMMANDS.includes(verb);
-}
-export function destructiveVerbOf(cmd) {
-    const verb = extractVerb(cmd);
-    if (verb && DESTRUCTIVE_COMMANDS.includes(verb)) {
-        return verb;
-    }
-    return null;
-}