@switchbot/openapi-cli 3.2.1 → 3.2.2

package/dist/rules/destructive.js

@@ -1,53 +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;
-}
-//# sourceMappingURL=destructive.js.map

package/dist/rules/destructive.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"destructive.js","sourceRoot":"","sources":["../../src/rules/destructive.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,MAAM;IACN,QAAQ;IACR,eAAe;IACf,aAAa;IACb,cAAc;CACN,CAAC;AAIX;;;;;;;;GAQG;AACH,MAAM,UAAU,WAAW,CAAC,GAAW;IACrC,MAAM,OAAO,GAAG,GAAG,CAAC,IAAI,EAAE,CAAC;IAC3B,IAAI,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAC1B,MAAM,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAEpC,uCAAuC;IACvC,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;QAC7E,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IACD,mDAAmD;IACnD,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,UAAU,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ;QAAE,OAAO,eAAe,CAAC;IAC/E,+CAA+C;IAC/C,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ,IAAI,MAAM,CAAC,CAAC,CAAC,KAAK,QAAQ;QAAE,OAAO,aAAa,CAAC;IAC3E,OAAO,IAAI,CAAC;AACd,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,IAAI;QAAE,OAAO,KAAK,CAAC;IACxB,OAAQ,oBAA0C,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACpE,CAAC;AAED,MAAM,UAAU,iBAAiB,CAAC,GAAW;IAC3C,MAAM,IAAI,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,IAAI,IAAK,oBAA0C,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;QACvE,OAAO,IAA0B,CAAC;IACpC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/rules/engine.d.ts

@@ -1,193 +0,0 @@
-/**
- * Rules engine runtime — orchestrates trigger subscription, matcher
- * pipeline, throttle gate, and action executor.
- *
- * v0.2 PoC scope:
- *   - Loads an `automation` block from a policy file.
- *   - Subscribes to a single MQTT client; routes every shadow message
- *     through `matchesMqttTrigger` → `evaluateConditions` → throttle →
- *     `executeRuleAction`.
- *   - Cron + webhook triggers are **recognised but not wired** — they
- *     surface in the static lint as `unsupported` so users know the
- *     feature is pending (E1/E2 fill it in without a schema change).
- *   - Exposes `start()`, `stop()`, `getStats()` for the rules run
- *     subcommand.
- *
- * Not responsible for: loading the policy file, validating it, talking
- * to the SwitchBot REST API (that's `executeCommand`), or writing
- * audit lines (that's each module's local responsibility).
- */
-import type { AxiosInstance } from 'axios';
-import type { SwitchBotMqttClient } from '../mqtt/client.js';
-import type { MqttCredential } from '../mqtt/credential.js';
-import { type DeviceStatusFetcher } from './matcher.js';
-import { type AutomationBlock, type EngineEvent, type Rule } from './types.js';
-export interface LintIssue {
-    rule: string;
-    severity: 'error' | 'warning';
-    code: string;
-    message: string;
-}
-export interface LintResult {
-    rules: Array<{
-        name: string;
-        enabled: boolean;
-        status: 'ok' | 'error' | 'unsupported' | 'disabled';
-        issues: LintIssue[];
-    }>;
-    valid: boolean;
-    unsupportedCount: number;
-}
-export declare function lintRules(automation: AutomationBlock | null | undefined): LintResult;
-export interface RulesEngineOptions {
-    automation: AutomationBlock | null | undefined;
-    aliases: Record<string, string>;
-    /** Pre-connected MQTT client — owned by the caller. */
-    mqttClient: SwitchBotMqttClient;
-    /** Credential exposed so we know the default shadow topic to subscribe to. */
-    mqttCredential: MqttCredential;
-    /** Optional HTTP client for executeCommand — omit in tests. */
-    httpClient?: AxiosInstance;
-    /** When true, treat every rule as dry_run regardless of policy. */
-    globalDryRun?: boolean;
-    /** Max firings before the engine self-stops — test / demo only. */
-    maxFirings?: number;
-    /** Suppress live API calls. Used by tests that don't want to mock axios. */
-    skipApiCall?: boolean;
-    /** Side channel for unit tests — drop every processed event here. */
-    onFire?: (entry: EngineFireEntry) => void;
-    /**
-     * Webhook bearer token. Required when any rule uses a webhook
-     * trigger; the listener will refuse to start otherwise.
-     */
-    webhookToken?: string;
-    /** Webhook listener port (default 18790). Set 0 to auto-allocate. */
-    webhookPort?: number;
-    /** Webhook listener host (default 127.0.0.1). */
-    webhookHost?: string;
-    /**
-     * Override how device_state conditions fetch live status. Primarily a
-     * test seam — production callers should leave it unset so the engine
-     * goes through the normal `fetchDeviceStatus` path with the shared
-     * axios client.
-     */
-    statusFetcher?: DeviceStatusFetcher;
-}
-export interface EngineFireEntry {
-    ruleName: string;
-    fireId: string;
-    /** Final disposition of the fire. */
-    status: 'fired' | 'dry' | 'throttled' | 'conditions-failed' | 'unsupported' | 'blocked';
-    deviceId?: string;
-    reason?: string;
-}
-export interface EngineStats {
-    started: boolean;
-    rulesLoaded: number;
-    rulesActive: number;
-    eventsProcessed: number;
-    fires: number;
-    dryFires: number;
-    throttled: number;
-    conditionsFailed: number;
-}
-export declare class RulesEngine {
-    private readonly opts;
-    private rules;
-    private aliases;
-    private readonly throttle;
-    /** hysteresis / requires_stable_for: tracks when each (rule::device) trigger was first seen. */
-    private hysteresisFirstSeen;
-    private unsubscribeMessage;
-    private unsubscribeState;
-    private cronScheduler;
-    private webhookListener;
-    private started;
-    private stopped;
-    /**
-     * Sequential dispatch queue. Two MQTT messages arriving in the same
-     * tick would otherwise race inside the throttle check — each sees an
-     * empty lastFireAt map because neither has recorded yet. Serialising
-     * keeps the semantics of `max_per` honest.
-     */
-    private pendingChain;
-    private stats;
-    constructor(opts: RulesEngineOptions);
-    getStats(): EngineStats;
-    getRules(): readonly Rule[];
-    /**
-     * Subscribes to MQTT and begins the pipeline. Throws if the policy
-     * block is missing `enabled: true` or if lint finds errors (e.g.
-     * destructive command in a rule action).
-     */
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    /**
-     * Hot-reload the running engine with a fresh automation block and
-     * alias map — typically triggered by SIGHUP or by the `rules reload`
-     * subcommand writing the reload sentinel file.
-     *
-     * Semantics:
-     *   - Rejects (and keeps the old ruleset) when the new automation is
-     *     disabled or fails lint. The engine never silently degrades.
-     *   - Diffs cron registrations by `rule.name` + `schedule`: unchanged
-     *     entries keep their armed timer, changed/removed entries are
-     *     unregistered, new entries are registered and armed.
-     *   - Hands the fresh webhook rule list to the live listener (keeps
-     *     the bound port / open connections). If the reload removes every
-     *     webhook rule the listener is torn down; if it adds the first
-     *     webhook rule we refuse — spinning up a new listener mid-run
-     *     would silently change the security surface.
-     *   - `ThrottleGate` state is retained for surviving rule names and
-     *     dropped for removed ones. A rule that was throttled before the
-     *     reload stays throttled after it (same name = same window), but
-     *     a renamed rule resets.
-     */
-    reload(nextAutomation: AutomationBlock | null | undefined, nextAliases?: Record<string, string>): Promise<{
-        changed: boolean;
-        errors: string[];
-        warnings: string[];
-    }>;
-    /**
-     * Expose the MQTT pipeline for direct invocation from tests — feeds a
-     * synthetic payload through the same matcher/throttle/action chain.
-     */
-    ingestMqttForTest(payload: unknown): Promise<void>;
-    /**
-     * Dispatch a pre-built EngineEvent through all matching MQTT rules.
-     * Used by tests that need full control over the event timestamp (e.g.
-     * hysteresis tests that advance time manually).
-     */
-    ingestEventForTest(event: EngineEvent): Promise<void>;
-    /**
-     * Fire a cron rule directly without needing the scheduler/timers.
-     * Used by tests that want to exercise the dispatch pipeline without
-     * depending on fake timers or croner's internals.
-     */
-    ingestCronForTest(rule: Rule, when?: Date): Promise<void>;
-    /**
-     * Fire a webhook rule directly without standing up the HTTP listener.
-     */
-    ingestWebhookForTest(rule: Rule, body?: string, when?: Date): Promise<void>;
-    /** Returns the bound webhook port when the listener is active. */
-    getWebhookPort(): number | null;
-    /** Read-only peek at cron schedule state — for `rules list` extras. */
-    getCronSchedule(ruleName: string): {
-        schedule: string;
-        nextAt: Date | null;
-    } | null;
-    /** Test helper — resolves after all queued dispatches complete. */
-    drainForTest(): Promise<void>;
-    /**
-     * Append a task to the dispatch queue; callers get back a promise that
-     * resolves when their task finishes (errors are swallowed — we never
-     * want the queue itself to die because one rule threw). Returning a
-     * promise lets awaited callsites (ingestMqttForTest) observe completion.
-     */
-    private enqueue;
-    private onMqttMessage;
-    private onCronFire;
-    private onWebhookFire;
-    private firesTotal;
-    private dispatchRule;
-}