@switchbot/openapi-cli 3.1.1 → 3.2.0

package/dist/status-sync/manager.js

@@ -1,268 +0,0 @@
-import { spawn, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { tryLoadConfig } from '../config.js';
-import { getActiveProfile } from '../lib/request-context.js';
-import { UsageError } from '../utils/output.js';
-import { getConfigPath } from '../utils/flags.js';
-const DEFAULT_OPENCLAW_URL = 'http://localhost:18789';
-function resolveStatusSyncRuntime(options) {
-    if (!tryLoadConfig()) {
-        throw new UsageError('No credentials found. Run \'switchbot config set-token\' or set SWITCHBOT_TOKEN and SWITCHBOT_SECRET.');
-    }
-    const openclawToken = options.openclawToken ?? process.env.OPENCLAW_TOKEN;
-    if (!openclawToken) {
-        throw new UsageError('--openclaw-token is required or set OPENCLAW_TOKEN in the environment.');
-    }
-    const openclawModel = options.openclawModel ?? process.env.OPENCLAW_MODEL;
-    if (!openclawModel) {
-        throw new UsageError('--openclaw-model is required or set OPENCLAW_MODEL in the environment.');
-    }
-    return {
-        openclawUrl: options.openclawUrl ?? process.env.OPENCLAW_URL ?? DEFAULT_OPENCLAW_URL,
-        openclawToken,
-        openclawModel,
-        ...(options.topic ? { topic: options.topic } : {}),
-    };
-}
-export function resolveStatusSyncPaths(explicitStateDir) {
-    const stateDir = path.resolve(explicitStateDir
-        ?? process.env.SWITCHBOT_STATUS_SYNC_HOME
-        ?? path.join(os.homedir(), '.switchbot', 'status-sync'));
-    return {
-        stateDir,
-        stateFile: path.join(stateDir, 'state.json'),
-        stdoutLog: path.join(stateDir, 'stdout.log'),
-        stderrLog: path.join(stateDir, 'stderr.log'),
-    };
-}
-export function buildStatusSyncChildArgs(options) {
-    const scriptPath = process.argv[1];
-    if (!scriptPath) {
-        throw new Error('Cannot determine the current CLI entrypoint path.');
-    }
-    const args = [path.resolve(scriptPath)];
-    const configPath = getConfigPath();
-    const profile = getActiveProfile();
-    if (configPath) {
-        args.push('--config', path.resolve(configPath));
-    }
-    else if (profile) {
-        args.push('--profile', profile);
-    }
-    args.push('events', 'mqtt-tail', '--sink', 'openclaw', '--openclaw-url', options.openclawUrl, '--openclaw-model', options.openclawModel);
-    if (options.topic) {
-        args.push('--topic', options.topic);
-    }
-    return args;
-}
-function safeUnlink(filePath) {
-    try {
-        fs.unlinkSync(filePath);
-    }
-    catch {
-        // best-effort cleanup
-    }
-}
-function isProcessRunning(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'EPERM')
-            return true;
-        return false;
-    }
-}
-function readStateFile(paths) {
-    if (!fs.existsSync(paths.stateFile))
-        return null;
-    try {
-        const raw = JSON.parse(fs.readFileSync(paths.stateFile, 'utf-8'));
-        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
-            safeUnlink(paths.stateFile);
-            return null;
-        }
-        const parsed = raw;
-        if (typeof parsed.pid !== 'number' ||
-            !Number.isInteger(parsed.pid) ||
-            parsed.pid < 1 ||
-            typeof parsed.startedAt !== 'string' ||
-            !Array.isArray(parsed.command) ||
-            typeof parsed.stdoutLog !== 'string' ||
-            typeof parsed.stderrLog !== 'string') {
-            safeUnlink(paths.stateFile);
-            return null;
-        }
-        return {
-            pid: parsed.pid,
-            startedAt: parsed.startedAt,
-            command: parsed.command.map(String),
-            openclawUrl: typeof parsed.openclawUrl === 'string' ? parsed.openclawUrl : DEFAULT_OPENCLAW_URL,
-            openclawModel: typeof parsed.openclawModel === 'string' ? parsed.openclawModel : '',
-            topic: typeof parsed.topic === 'string' ? parsed.topic : null,
-            configPath: typeof parsed.configPath === 'string' ? parsed.configPath : null,
-            profile: typeof parsed.profile === 'string' ? parsed.profile : null,
-            stdoutLog: parsed.stdoutLog,
-            stderrLog: parsed.stderrLog,
-        };
-    }
-    catch {
-        safeUnlink(paths.stateFile);
-        return null;
-    }
-}
-function toStatus(paths, state, running) {
-    return {
-        running,
-        pid: running && state ? state.pid : null,
-        startedAt: running && state ? state.startedAt : null,
-        stateDir: paths.stateDir,
-        stateFile: paths.stateFile,
-        stdoutLog: state?.stdoutLog ?? paths.stdoutLog,
-        stderrLog: state?.stderrLog ?? paths.stderrLog,
-        command: running && state ? state.command : null,
-        openclawUrl: running && state ? state.openclawUrl : null,
-        openclawModel: running && state ? state.openclawModel : null,
-        topic: running && state ? state.topic : null,
-        configPath: running && state ? state.configPath : null,
-        profile: running && state ? state.profile : null,
-    };
-}
-function killProcessTree(pid) {
-    if (process.platform === 'win32') {
-        const result = spawnSync('taskkill', ['/PID', String(pid), '/T', '/F'], { stdio: 'ignore' });
-        if (result.error)
-            throw result.error;
-        if (result.status !== 0 && isProcessRunning(pid)) {
-            throw new Error(`Failed to stop status-sync process tree (PID ${pid}).`);
-        }
-        return;
-    }
-    try {
-        process.kill(-pid, 'SIGTERM');
-    }
-    catch (err) {
-        const code = err.code;
-        if (code === 'ESRCH') {
-            return;
-        }
-        process.kill(pid, 'SIGTERM');
-    }
-}
-export function getStatusSyncStatus(options = {}) {
-    const paths = resolveStatusSyncPaths(options.stateDir);
-    const state = readStateFile(paths);
-    if (!state) {
-        return toStatus(paths, null, false);
-    }
-    if (!isProcessRunning(state.pid)) {
-        safeUnlink(paths.stateFile);
-        return toStatus(paths, null, false);
-    }
-    return toStatus(paths, state, true);
-}
-export function stopStatusSync(options = {}) {
-    const paths = resolveStatusSyncPaths(options.stateDir);
-    const state = readStateFile(paths);
-    if (!state) {
-        return {
-            stopped: false,
-            stale: false,
-            pid: null,
-            status: toStatus(paths, null, false),
-        };
-    }
-    if (!isProcessRunning(state.pid)) {
-        safeUnlink(paths.stateFile);
-        return {
-            stopped: false,
-            stale: true,
-            pid: state.pid,
-            status: toStatus(paths, null, false),
-        };
-    }
-    killProcessTree(state.pid);
-    if (isProcessRunning(state.pid)) {
-        throw new Error(`Failed to stop status-sync process (PID ${state.pid}); process is still running.`);
-    }
-    safeUnlink(paths.stateFile);
-    return {
-        stopped: true,
-        stale: false,
-        pid: state.pid,
-        status: toStatus(paths, null, false),
-    };
-}
-export function startStatusSync(options = {}) {
-    const runtime = resolveStatusSyncRuntime(options);
-    const paths = resolveStatusSyncPaths(options.stateDir);
-    const existing = getStatusSyncStatus({ stateDir: paths.stateDir });
-    if (existing.running) {
-        if (!options.force) {
-            throw new UsageError(`status-sync is already running (PID ${existing.pid}). Run 'switchbot status-sync stop' first or re-run with --force.`);
-        }
-        stopStatusSync({ stateDir: paths.stateDir });
-    }
-    fs.mkdirSync(paths.stateDir, { recursive: true });
-    const configPath = getConfigPath();
-    const command = buildStatusSyncChildArgs(runtime);
-    let stdoutFd = null;
-    let stderrFd = null;
-    try {
-        stdoutFd = fs.openSync(paths.stdoutLog, 'a');
-        stderrFd = fs.openSync(paths.stderrLog, 'a');
-        const child = spawn(process.execPath, command, {
-            detached: true,
-            stdio: ['ignore', stdoutFd, stderrFd],
-            windowsHide: true,
-            env: { ...process.env, OPENCLAW_TOKEN: runtime.openclawToken },
-        });
-        if (!child.pid) {
-            throw new Error('Failed to start status-sync child process.');
-        }
-        child.unref();
-        const state = {
-            pid: child.pid,
-            startedAt: new Date().toISOString(),
-            command: [process.execPath, ...command],
-            openclawUrl: runtime.openclawUrl,
-            openclawModel: runtime.openclawModel,
-            topic: runtime.topic ?? null,
-            configPath: configPath ? path.resolve(configPath) : null,
-            profile: configPath ? null : (getActiveProfile() ?? null),
-            stdoutLog: paths.stdoutLog,
-            stderrLog: paths.stderrLog,
-        };
-        fs.writeFileSync(paths.stateFile, JSON.stringify(state, null, 2), { mode: 0o600 });
-        return toStatus(paths, state, true);
-    }
-    finally {
-        if (stdoutFd !== null)
-            fs.closeSync(stdoutFd);
-        if (stderrFd !== null)
-            fs.closeSync(stderrFd);
-    }
-}
-export async function runStatusSyncForeground(options = {}) {
-    const runtime = resolveStatusSyncRuntime(options);
-    const command = buildStatusSyncChildArgs(runtime);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(process.execPath, command, {
-            stdio: 'inherit',
-            windowsHide: true,
-            env: { ...process.env, OPENCLAW_TOKEN: runtime.openclawToken },
-        });
-        child.once('error', reject);
-        child.once('exit', (code, signal) => {
-            if (signal) {
-                resolve(1);
-                return;
-            }
-            resolve(code ?? 0);
-        });
-    });
-}

package/dist/utils/arg-parsers.js

@@ -1,66 +0,0 @@
-import { InvalidArgumentError } from 'commander';
-import { parseDurationToMs } from './flags.js';
-/**
- * Commander argParser callbacks that fail fast when a required-value flag
- * swallows the next token (another flag, a subcommand name, etc.) — the
- * default Commander behavior is to take the next argv token verbatim.
- *
- * Use `--flag=<val>` form to pass values that legitimately start with `--`.
- */
-export function intArg(flagName, opts) {
-    return (value) => {
-        // Flag-like tokens (`--something`, `-x`) are rejected up-front.
-        // Pure negative integers (`-1`, `-42`) fall through to min/max so the
-        // error classifies as a range error rather than "requires a numeric value".
-        if (value.startsWith('-') && !/^-\d+$/.test(value)) {
-            throw new InvalidArgumentError(`${flagName} requires a numeric value, got "${value}". ` +
-                `Did you forget a value? Use ${flagName}=<n> if the value really starts with "-".`);
-        }
-        const n = Number(value);
-        if (!Number.isInteger(n)) {
-            throw new InvalidArgumentError(`${flagName} must be an integer (got "${value}")`);
-        }
-        if (opts?.min !== undefined && n < opts.min) {
-            throw new InvalidArgumentError(`${flagName} must be >= ${opts.min} (got "${value}")`);
-        }
-        if (opts?.max !== undefined && n > opts.max) {
-            throw new InvalidArgumentError(`${flagName} must be <= ${opts.max} (got "${value}")`);
-        }
-        return String(n);
-    };
-}
-export function durationArg(flagName) {
-    return (value) => {
-        if (value.startsWith('-')) {
-            throw new InvalidArgumentError(`${flagName} requires a duration value, got "${value}". ` +
-                `Use ${flagName}=<dur> if the value really starts with "-".`);
-        }
-        const ms = parseDurationToMs(value);
-        if (ms === null) {
-            throw new InvalidArgumentError(`${flagName} must look like "30s", "1m", "500ms", "1h", "7d", "2w" ` +
-                `(supported units: ms, s, m, h, d, w — got "${value}")`);
-        }
-        return value;
-    };
-}
-export function stringArg(flagName, opts) {
-    return (value) => {
-        if (value.startsWith('--')) {
-            throw new InvalidArgumentError(`${flagName} requires a value. "${value}" looks like another option — ` +
-                `did you forget the value? Use ${flagName}=<val> if your value really starts with "--".`);
-        }
-        if (opts?.disallow?.includes(value)) {
-            throw new InvalidArgumentError(`${flagName} requires a value but got "${value}", which is a subcommand name. ` +
-                `Did you forget the value? Use ${flagName}=<val> or put ${flagName} after the subcommand.`);
-        }
-        return value;
-    };
-}
-export function enumArg(flagName, allowed) {
-    return (value) => {
-        if (!allowed.includes(value)) {
-            throw new InvalidArgumentError(`${flagName} must be one of: ${allowed.join(', ')} (got "${value}")`);
-        }
-        return value;
-    };
-}

package/dist/utils/audit.js

@@ -1,121 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { getAuditLog } from './flags.js';
-export const DEFAULT_AUDIT_PATH = path.join(os.homedir(), '.switchbot', 'audit.log');
-/**
- * Bump when breaking changes to the audit line shape land.
- *
- * History:
- *   1 — initial command audit (kind: 'command' only).
- *   2 — adds rule-engine kinds ('rule-fire', 'rule-fire-dry',
- *       'rule-throttled', 'rule-webhook-rejected') and a sibling `rule`
- *       block describing which rule fired and why. Reader stays backwards
- *       compatible: v1 lines parse as command entries with `rule`
- *       undefined.
- */
-export const AUDIT_VERSION = 2;
-function resolveAuditPath() {
-    const flag = getAuditLog();
-    if (flag === null)
-        return null;
-    return path.resolve(flag);
-}
-export function writeAudit(entry) {
-    let file = resolveAuditPath();
-    if (!file && entry.planId)
-        file = DEFAULT_AUDIT_PATH;
-    if (!file)
-        return;
-    const dir = path.dirname(file);
-    try {
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        const stamped = { auditVersion: AUDIT_VERSION, ...entry };
-        fs.appendFileSync(file, JSON.stringify(stamped) + '\n');
-    }
-    catch {
-        // Best-effort — never let audit failures break the actual command.
-    }
-}
-export function readAudit(file) {
-    if (!fs.existsSync(file))
-        return [];
-    const raw = fs.readFileSync(file, 'utf-8');
-    const out = [];
-    for (const line of raw.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        try {
-            out.push(JSON.parse(trimmed));
-        }
-        catch {
-            // skip malformed lines
-        }
-    }
-    return out;
-}
-export function verifyAudit(file) {
-    const report = {
-        file,
-        totalLines: 0,
-        parsedLines: 0,
-        skippedBlankLines: 0,
-        malformedLines: 0,
-        unversionedEntries: 0,
-        versionCounts: {},
-        problems: [],
-    };
-    if (!fs.existsSync(file)) {
-        report.fileMissing = true;
-        return report;
-    }
-    const raw = fs.readFileSync(file, 'utf-8');
-    const lines = raw.split(/\r?\n/);
-    let minT;
-    let maxT;
-    for (let i = 0; i < lines.length; i++) {
-        const trimmed = lines[i].trim();
-        if (!trimmed) {
-            report.skippedBlankLines++;
-            continue;
-        }
-        report.totalLines++;
-        let entry = null;
-        try {
-            entry = JSON.parse(trimmed);
-        }
-        catch {
-            report.malformedLines++;
-            report.problems.push({
-                line: i + 1,
-                reason: 'JSON parse failed',
-                preview: trimmed.slice(0, 80),
-            });
-            continue;
-        }
-        report.parsedLines++;
-        const v = entry.auditVersion;
-        if (v === undefined) {
-            report.unversionedEntries++;
-            report.versionCounts['unversioned'] = (report.versionCounts['unversioned'] ?? 0) + 1;
-        }
-        else {
-            const key = String(v);
-            report.versionCounts[key] = (report.versionCounts[key] ?? 0) + 1;
-        }
-        if (entry.t) {
-            if (!minT || entry.t < minT)
-                minT = entry.t;
-            if (!maxT || entry.t > maxT)
-                maxT = entry.t;
-        }
-    }
-    if (minT)
-        report.earliest = minT;
-    if (maxT)
-        report.latest = maxT;
-    return report;
-}

package/dist/utils/filter.js

@@ -1,189 +0,0 @@
-export class FilterSyntaxError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'FilterSyntaxError';
-    }
-}
-/**
- * Parse a comma-separated filter expression into discrete clauses.
- *
- * Grammar (per clause, recognition order):
- *   1. key=/pattern/   → regex (case-insensitive); invalid regex throws.
- *   2. key!=value      → 'neq' op (negated substring; exact-negated for keys
- *                        listed in matchClause's `exactKeys` option).
- *   3. key~value       → substring (case-insensitive).
- *   4. key=value       → 'eq' op (substring; caller decides whether to treat
- *                        as exact for specific keys via matchClause's
- *                        `exactKeys` option).
- *
- * `allowedKeys` is command-specific: `devices list` uses
- * {type,name,category,room}; `devices batch` uses {type,family,room,category};
- * `events tail` uses {deviceId,type}.
- */
-export function parseFilterExpr(expr, allowedKeys, options) {
-    if (!expr)
-        return [];
-    const parts = expr.split(',').map((p) => p.trim()).filter((p) => p.length > 0);
-    const clauses = [];
-    for (const part of parts) {
-        const regexMatch = /^([^=~!]+)=\/(.*)\/$/.exec(part);
-        const neqIdx = part.indexOf('!=');
-        const tildeIdx = part.indexOf('~');
-        const eqIdx = part.indexOf('=');
-        let key;
-        let op;
-        let raw;
-        let regex;
-        if (regexMatch) {
-            key = regexMatch[1].trim();
-            op = 'regex';
-            raw = regexMatch[2];
-            try {
-                regex = new RegExp(raw, 'i');
-            }
-            catch (err) {
-                throw new FilterSyntaxError(`Invalid regex in --filter "${part}": ${err.message}`);
-            }
-        }
-        else if (neqIdx !== -1 && (tildeIdx === -1 || neqIdx < tildeIdx)) {
-            key = part.slice(0, neqIdx).trim();
-            op = 'neq';
-            raw = part.slice(neqIdx + 2).trim();
-        }
-        else if (tildeIdx !== -1 && (eqIdx === -1 || tildeIdx < eqIdx)) {
-            key = part.slice(0, tildeIdx).trim();
-            op = 'sub';
-            raw = part.slice(tildeIdx + 1).trim();
-            if (raw.startsWith('=')) {
-                throw new FilterSyntaxError(`Invalid filter clause "${part}" — "~=" is no longer supported. Use "${key}~${raw.slice(1)}" instead.`);
-            }
-        }
-        else if (eqIdx !== -1) {
-            key = part.slice(0, eqIdx).trim();
-            op = 'eq';
-            raw = part.slice(eqIdx + 1).trim();
-        }
-        else {
-            throw new FilterSyntaxError(`Invalid filter clause "${part}" — expected "<key>=<value>", "<key>!=<value>", "<key>~<value>", or "<key>=/<regex>/"`);
-        }
-        if (!key) {
-            throw new FilterSyntaxError(`Empty key in filter clause "${part}"`);
-        }
-        if (!raw) {
-            throw new FilterSyntaxError(`Empty value for filter clause "${part}"`);
-        }
-        let resolvedKey = key;
-        if (options?.resolveKey) {
-            try {
-                resolvedKey = options.resolveKey(key);
-            }
-            catch (err) {
-                if (err instanceof Error) {
-                    throw new FilterSyntaxError(err.message);
-                }
-                throw err;
-            }
-        }
-        if (!allowedKeys.includes(resolvedKey)) {
-            const printableKeys = options?.supportedKeys ?? allowedKeys;
-            throw new FilterSyntaxError(`Unknown filter key "${key}" – supported: ${printableKeys.join(', ')}`);
-        }
-        clauses.push({ key: resolvedKey, op, raw, regex });
-    }
-    return clauses;
-}
-/**
- * Match a single candidate string against a clause.
- *
- * - `regex` → RegExp.test against the candidate (case-insensitive by construction).
- * - `sub`   → case-insensitive substring.
- * - `eq`    → case-insensitive substring, except for keys listed in
- *             `exactKeys`, which get case-insensitive exact comparison.
- *             Default `exactKeys` is `['category']` to preserve the existing
- *             list/batch behavior for that key.
- * - `neq`   → logical inverse of `eq` (negated substring; exact-negated for
- *             `exactKeys`). `undefined` candidates remain non-matching so a
- *             `neq` clause does NOT accidentally match missing data.
- */
-export function matchClause(candidate, clause, options) {
-    if (candidate === undefined) {
-        // Missing field: `neq` treats absence as "definitely not X"; everything
-        // else treats it as "no evidence — don't match".
-        return clause.op === 'neq';
-    }
-    if (clause.op === 'regex') {
-        return clause.regex.test(candidate);
-    }
-    const cLower = candidate.toLowerCase();
-    const vLower = clause.raw.toLowerCase();
-    if (clause.op === 'sub') {
-        return cLower.includes(vLower);
-    }
-    const exactKeys = options?.exactKeys ?? ['category'];
-    const exact = exactKeys.includes(clause.key);
-    if (clause.op === 'neq') {
-        return exact ? cLower !== vLower : !cLower.includes(vLower);
-    }
-    if (exact) {
-        return cLower === vLower;
-    }
-    return cLower.includes(vLower);
-}
-const BATCH_KEYS = ['type', 'family', 'room', 'category'];
-/**
- * Back-compat narrow signature: parses with the batch key set. Callers that
- * need a different key set (list, events tail) should call parseFilterExpr
- * directly.
- */
-export function parseFilter(expr) {
-    return parseFilterExpr(expr, BATCH_KEYS);
-}
-/** Normalize a physical / IR device entry to the shape the filter matcher expects. */
-function toFilterable(d, isPhysical, hubLocation) {
-    if (isPhysical) {
-        const p = d;
-        return {
-            deviceId: p.deviceId,
-            type: p.deviceType ?? '',
-            family: p.familyName ?? undefined,
-            room: p.roomName ?? undefined,
-            category: 'physical',
-        };
-    }
-    const ir = d;
-    const inherited = hubLocation?.get(ir.hubDeviceId);
-    return {
-        deviceId: ir.deviceId,
-        type: ir.remoteType ?? '',
-        family: inherited?.family,
-        room: inherited?.room,
-        category: 'ir',
-    };
-}
-function candidateFor(d, key) {
-    switch (key) {
-        case 'type':
-            return d.type;
-        case 'family':
-            return d.family;
-        case 'room':
-            return d.room;
-        case 'category':
-            return d.category;
-        default:
-            return undefined;
-    }
-}
-/**
- * Apply the parsed clauses to a mixed list of physical devices + IR remotes.
- * Returns the filterable entries that satisfy every clause.
- */
-export function applyFilter(clauses, deviceList, infraredRemoteList, hubLocation) {
-    const candidates = [
-        ...deviceList.map((d) => toFilterable(d, true)),
-        ...infraredRemoteList.map((d) => toFilterable(d, false, hubLocation)),
-    ];
-    if (clauses.length === 0)
-        return candidates;
-    return candidates.filter((c) => clauses.every((clause) => matchClause(candidateFor(c, clause.key), clause)));
-}