@switchbot/openapi-cli 3.1.1 → 3.2.0

package/dist/policy/diff.js

@@ -1,91 +0,0 @@
-export const MAX_POLICY_DIFF_CHANGES = 200;
-function isPlainObject(v) {
-    return !!v && typeof v === 'object' && !Array.isArray(v);
-}
-function collectPolicyDiff(left, right, at, out, limit) {
-    if (out.length >= limit)
-        return;
-    if (Array.isArray(left) && Array.isArray(right)) {
-        const maxLen = Math.max(left.length, right.length);
-        for (let i = 0; i < maxLen; i++) {
-            if (out.length >= limit)
-                return;
-            const path = `${at}[${i}]`;
-            if (i >= left.length) {
-                out.push({ path, kind: 'added', after: right[i] });
-            }
-            else if (i >= right.length) {
-                out.push({ path, kind: 'removed', before: left[i] });
-            }
-            else {
-                collectPolicyDiff(left[i], right[i], path, out, limit);
-            }
-        }
-        return;
-    }
-    if (isPlainObject(left) && isPlainObject(right)) {
-        const keys = new Set([...Object.keys(left), ...Object.keys(right)]);
-        for (const key of [...keys].sort()) {
-            if (out.length >= limit)
-                return;
-            const path = at === '$' ? `$.${key}` : `${at}.${key}`;
-            const leftHas = Object.prototype.hasOwnProperty.call(left, key);
-            const rightHas = Object.prototype.hasOwnProperty.call(right, key);
-            if (!leftHas && rightHas) {
-                out.push({ path, kind: 'added', after: right[key] });
-            }
-            else if (leftHas && !rightHas) {
-                out.push({ path, kind: 'removed', before: left[key] });
-            }
-            else {
-                collectPolicyDiff(left[key], right[key], path, out, limit);
-            }
-        }
-        return;
-    }
-    if (!Object.is(left, right)) {
-        out.push({ path: at, kind: 'changed', before: left, after: right });
-    }
-}
-function buildLineDiff(before, after) {
-    const beforeLines = before.split('\n');
-    const afterLines = after.split('\n');
-    const lines = ['--- before', '+++ after'];
-    let i = 0;
-    let j = 0;
-    while (i < beforeLines.length || j < afterLines.length) {
-        const b = beforeLines[i];
-        const a = afterLines[j];
-        if (i < beforeLines.length && j < afterLines.length && b === a) {
-            lines.push(` ${b}`);
-            i++;
-            j++;
-        }
-        else if (j < afterLines.length && (i >= beforeLines.length || b !== a)) {
-            lines.push(`+${a}`);
-            j++;
-        }
-        else {
-            lines.push(`-${b}`);
-            i++;
-        }
-    }
-    return lines.join('\n');
-}
-export function diffPolicyValues(leftDoc, rightDoc, leftSource, rightSource, maxChanges = MAX_POLICY_DIFF_CHANGES) {
-    const changes = [];
-    collectPolicyDiff(leftDoc, rightDoc, '$', changes, maxChanges);
-    const equal = changes.length === 0;
-    return {
-        equal,
-        changeCount: changes.length,
-        truncated: changes.length >= maxChanges,
-        stats: {
-            added: changes.filter((c) => c.kind === 'added').length,
-            removed: changes.filter((c) => c.kind === 'removed').length,
-            changed: changes.filter((c) => c.kind === 'changed').length,
-        },
-        changes,
-        diff: buildLineDiff(leftSource, rightSource),
-    };
-}

package/dist/policy/format.js

@@ -1,57 +0,0 @@
-import chalk, { Chalk } from 'chalk';
-const noColorChalk = new Chalk({ level: 0 });
-function colorize(enabled) {
-    return enabled ? chalk : noColorChalk;
-}
-function snippet(source, line, col, length, c) {
-    const lines = source.split(/\r?\n/);
-    if (line < 1 || line > lines.length)
-        return '';
-    const lineText = lines[line - 1];
-    const gutter = `  ${line} | `;
-    const pad = ' '.repeat(gutter.length);
-    const caretStart = Math.max(0, col - 1);
-    const caretLen = Math.max(1, length);
-    const caret = `${' '.repeat(caretStart)}${c.red('^'.repeat(caretLen))}`;
-    return `${c.dim(gutter)}${lineText}\n${c.dim(pad)}${caret}`;
-}
-function estimateTokenLength(source, line, col) {
-    const lines = source.split(/\r?\n/);
-    if (line < 1 || line > lines.length)
-        return 1;
-    const lineText = lines[line - 1];
-    const start = Math.max(0, col - 1);
-    if (start >= lineText.length)
-        return 1;
-    const rest = lineText.slice(start);
-    const quoted = rest.match(/^(['"]).*?\1/);
-    if (quoted)
-        return quoted[0].length;
-    const token = rest.match(/^[^\s,\[\]{}]+/);
-    return token ? token[0].length : 1;
-}
-function formatError(err, policyPath, source, opts) {
-    const c = colorize(opts.color ?? true);
-    const loc = err.line !== undefined && err.col !== undefined ? `${err.line}:${err.col}` : '(unknown)';
-    const header = `${c.cyan(policyPath)}:${c.yellow(loc)}`;
-    const body = [`${c.red.bold('error')}: ${err.message}`];
-    if (err.line !== undefined && err.col !== undefined && !opts.noSnippet) {
-        const len = estimateTokenLength(source, err.line, err.col);
-        const snip = snippet(source, err.line, err.col, len, c);
-        if (snip)
-            body.unshift(snip);
-    }
-    if (err.hint)
-        body.push(`${c.green.bold('hint')}:  ${err.hint}`);
-    return [header, ...body].join('\n');
-}
-export function formatValidationResult(result, source, opts = {}) {
-    const c = colorize(opts.color ?? true);
-    if (result.valid) {
-        return `${c.green.bold('✓')} ${result.policyPath} is valid (schema v${result.schemaVersion})`;
-    }
-    const blocks = result.errors.map((e) => formatError(e, result.policyPath, source, opts));
-    const count = result.errors.length;
-    const footer = `${c.red.bold(`✗ ${count} ${count === 1 ? 'error' : 'errors'}`)} in ${result.policyPath} (schema v${result.schemaVersion})`;
-    return [...blocks, '', footer].join('\n\n').replace(/\n{3,}/g, '\n\n');
-}

package/dist/policy/load.js

@@ -1,61 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { parseDocument, LineCounter } from 'yaml';
-export const DEFAULT_POLICY_PATH = join(homedir(), '.config', 'openclaw', 'switchbot', 'policy.yaml');
-export function resolvePolicyPath(options = {}) {
-    const { flag, env = process.env } = options;
-    if (flag && flag.trim().length > 0)
-        return resolve(flag);
-    const fromEnv = env.SWITCHBOT_POLICY_PATH;
-    if (fromEnv && fromEnv.trim().length > 0)
-        return resolve(fromEnv);
-    return DEFAULT_POLICY_PATH;
-}
-export class PolicyFileNotFoundError extends Error {
-    policyPath;
-    constructor(policyPath) {
-        super(`policy file not found: ${policyPath}`);
-        this.policyPath = policyPath;
-        this.name = 'PolicyFileNotFoundError';
-    }
-}
-export class PolicyYamlParseError extends Error {
-    policyPath;
-    yamlErrors;
-    constructor(message, policyPath, yamlErrors) {
-        super(message);
-        this.policyPath = policyPath;
-        this.yamlErrors = yamlErrors;
-        this.name = 'PolicyYamlParseError';
-    }
-}
-export function loadPolicyFile(policyPath) {
-    let source;
-    try {
-        source = readFileSync(policyPath, 'utf-8');
-    }
-    catch (err) {
-        const e = err;
-        if (e.code === 'ENOENT')
-            throw new PolicyFileNotFoundError(policyPath);
-        throw err;
-    }
-    const lineCounter = new LineCounter();
-    const doc = parseDocument(source, { lineCounter, keepSourceTokens: true });
-    if (doc.errors.length > 0) {
-        const yamlErrors = doc.errors.map((e) => {
-            const pos = e.pos?.[0];
-            const loc = pos !== undefined ? lineCounter.linePos(pos) : undefined;
-            return { line: loc?.line, col: loc?.col, message: e.message };
-        });
-        throw new PolicyYamlParseError(doc.errors[0].message, policyPath, yamlErrors);
-    }
-    return {
-        path: policyPath,
-        source,
-        doc,
-        lineCounter,
-        data: doc.toJS({ maxAliasCount: 100 }),
-    };
-}

package/dist/policy/migrate.js

@@ -1,67 +0,0 @@
-import { isMap, isScalar, parseDocument, LineCounter } from 'yaml';
-import { validateLoadedPolicy } from './validate.js';
-export class PolicyMigrationError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.name = 'PolicyMigrationError';
-    }
-}
-const MIGRATION_CHAIN = [];
-function bumpVersionScalar(doc, target) {
-    if (!isMap(doc.contents)) {
-        throw new PolicyMigrationError('policy root must be a YAML mapping (got null or an array)', 'invalid-shape');
-    }
-    const pair = doc.contents.items.find((p) => isScalar(p.key) && p.key.value === 'version');
-    if (!pair || !isScalar(pair.value)) {
-        throw new PolicyMigrationError('policy has no `version` scalar to migrate; add `version: "0.2"` (or `"0.1"`) and retry', 'no-version-field');
-    }
-    pair.value.value = target;
-}
-function findPlan(from, to) {
-    const chain = [];
-    let cur = from;
-    while (cur !== to) {
-        const step = MIGRATION_CHAIN.find((p) => p.fromVersion === cur);
-        if (!step) {
-            throw new PolicyMigrationError(`no migration path from v${from} to v${to} (missing step at v${cur})`, 'no-path');
-        }
-        chain.push(step);
-        cur = step.toVersion;
-    }
-    return chain;
-}
-export function planMigration(loaded, from, to) {
-    if (from === to) {
-        const precheck = validateLoadedPolicy(loaded);
-        return { changed: false, fromVersion: from, toVersion: to, nextSource: loaded.source, precheck };
-    }
-    const plan = findPlan(from, to);
-    // Round-trip through source instead of Document.clone(): keeps comments +
-    // anchors intact, works across yaml library versions, and leaves the
-    // caller's `loaded.doc` untouched.
-    const nextLineCounter = new LineCounter();
-    const clone = parseDocument(loaded.source, {
-        lineCounter: nextLineCounter,
-        keepSourceTokens: true,
-    });
-    for (const step of plan)
-        step.migrate(clone);
-    const nextSource = String(clone);
-    // Re-parse after serialization so `doc` and `source` stay in sync for the
-    // validator's line/col mapping.
-    const reLineCounter = new LineCounter();
-    const reDoc = parseDocument(nextSource, {
-        lineCounter: reLineCounter,
-        keepSourceTokens: true,
-    });
-    const precheck = validateLoadedPolicy({
-        path: loaded.path,
-        source: nextSource,
-        doc: reDoc,
-        lineCounter: reLineCounter,
-        data: reDoc.toJS({ maxAliasCount: 100 }),
-    });
-    return { changed: true, fromVersion: from, toVersion: to, nextSource, precheck };
-}

package/dist/policy/schema.js

@@ -1,18 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-export const SUPPORTED_POLICY_SCHEMA_VERSIONS = ['0.2'];
-export const CURRENT_POLICY_SCHEMA_VERSION = '0.2';
-const schemaCache = new Map();
-export function loadPolicySchema(version = CURRENT_POLICY_SCHEMA_VERSION) {
-    const cached = schemaCache.get(version);
-    if (cached)
-        return cached;
-    const url = new URL(`./schema/v${version}.json`, import.meta.url);
-    const raw = readFileSync(fileURLToPath(url), 'utf-8');
-    const parsed = JSON.parse(raw);
-    schemaCache.set(version, parsed);
-    return parsed;
-}
-export function isSupportedPolicySchemaVersion(v) {
-    return typeof v === 'string' && SUPPORTED_POLICY_SCHEMA_VERSIONS.includes(v);
-}

package/dist/policy/validate.js

@@ -1,262 +0,0 @@
-import { createRequire } from 'node:module';
-import { Ajv2020 } from 'ajv/dist/2020.js';
-import { isMap, isSeq, isScalar } from 'yaml';
-import { loadPolicyFile } from './load.js';
-import { loadPolicySchema, CURRENT_POLICY_SCHEMA_VERSION, SUPPORTED_POLICY_SCHEMA_VERSIONS, isSupportedPolicySchemaVersion, } from './schema.js';
-import { destructiveVerbOf, DESTRUCTIVE_COMMANDS } from '../rules/destructive.js';
-const require = createRequire(import.meta.url);
-const addFormats = require('ajv-formats');
-const validators = new Map();
-function getValidator(version) {
-    const cached = validators.get(version);
-    if (cached)
-        return cached;
-    const ajv = new Ajv2020({ allErrors: true, strict: false, allowUnionTypes: true });
-    addFormats(ajv);
-    const schema = loadPolicySchema(version);
-    const validate = ajv.compile(schema);
-    const compiled = { ajv, validate };
-    validators.set(version, compiled);
-    return compiled;
-}
-function instancePathToSegments(instancePath) {
-    if (!instancePath)
-        return [];
-    return instancePath
-        .slice(1)
-        .split('/')
-        .map((s) => s.replace(/~1/g, '/').replace(/~0/g, '~'));
-}
-function getNodeAt(doc, segments) {
-    let current = doc.contents;
-    for (const seg of segments) {
-        if (isMap(current)) {
-            const pair = current.items.find((p) => {
-                const k = p.key;
-                if (isScalar(k))
-                    return String(k.value) === seg;
-                return false;
-            });
-            if (!pair)
-                return null;
-            current = pair.value;
-        }
-        else if (isSeq(current)) {
-            const idx = Number(seg);
-            if (!Number.isInteger(idx))
-                return null;
-            current = current.items[idx];
-        }
-        else {
-            return null;
-        }
-    }
-    return current ?? null;
-}
-function getKeyNodeAt(doc, parentSegments, key) {
-    const parent = parentSegments.length === 0 ? doc.contents : getNodeAt(doc, parentSegments);
-    if (!parent || !isMap(parent))
-        return null;
-    const pair = parent.items.find((p) => isScalar(p.key) && String(p.key.value) === key);
-    return pair?.key ?? null;
-}
-function locateError(doc, lineCounter, err) {
-    const segments = instancePathToSegments(err.instancePath);
-    if (err.keyword === 'additionalProperties') {
-        const bad = err.params.additionalProperty;
-        if (bad) {
-            const keyNode = getKeyNodeAt(doc, segments, bad);
-            const range = keyNode?.range;
-            if (range) {
-                const pos = lineCounter.linePos(range[0]);
-                return { line: pos.line, col: pos.col };
-            }
-        }
-    }
-    if (err.keyword === 'required' || err.keyword === 'dependentRequired') {
-        const node = getNodeAt(doc, segments);
-        const range = node?.range;
-        if (range) {
-            const pos = lineCounter.linePos(range[0]);
-            return { line: pos.line, col: pos.col };
-        }
-        return { line: 1, col: 1 };
-    }
-    const node = getNodeAt(doc, segments);
-    const range = node?.range;
-    if (!range)
-        return {};
-    const pos = lineCounter.linePos(range[0]);
-    return { line: pos.line, col: pos.col };
-}
-function humanMessage(err) {
-    const path = err.instancePath || '(root)';
-    switch (err.keyword) {
-        case 'required':
-            return `missing required property "${err.params.missingProperty}"`;
-        case 'additionalProperties':
-            return `unknown property "${err.params.additionalProperty}"`;
-        case 'dependentRequired': {
-            const { property, missingProperty } = err.params;
-            const parent = path === '(root)' ? '' : `${path}: `;
-            return `${parent}when "${property}" is set, "${missingProperty}" is also required`;
-        }
-        case 'pattern':
-            return `${path} does not match pattern ${err.params.pattern}`;
-        case 'const':
-            return `${path} must be exactly ${JSON.stringify(err.params.allowedValue)}`;
-        case 'enum':
-            return `${path} must be one of ${JSON.stringify(err.params.allowedValues)}`;
-        case 'type':
-            return `${path} must be ${err.params.type}`;
-        case 'not':
-            return `${path} is not allowed here`;
-        default:
-            return `${path} ${err.message ?? 'is invalid'}`;
-    }
-}
-function hintFor(err) {
-    if (err.keyword === 'pattern' && err.instancePath.startsWith('/aliases/')) {
-        return 'paste the deviceId from `switchbot devices list --format=tsv`, e.g. 01-202407090924-26354212';
-    }
-    if (err.keyword === 'not' && err.instancePath.startsWith('/confirmations/never_confirm/')) {
-        return 'destructive actions (lock/unlock/delete*/factoryReset) cannot be pre-approved in policy.yaml';
-    }
-    if (err.keyword === 'const' && err.instancePath === '/version') {
-        const supported = SUPPORTED_POLICY_SCHEMA_VERSIONS.map((v) => `"${v}"`).join(' / ');
-        return `this CLI supports policy schema versions ${supported}; run \`switchbot policy migrate\` to upgrade an older file`;
-    }
-    if (err.keyword === 'required' && err.instancePath === '') {
-        const missing = err.params.missingProperty;
-        if (missing === 'version')
-            return `add \`version: "${CURRENT_POLICY_SCHEMA_VERSION}"\` at the top of the file`;
-    }
-    return undefined;
-}
-function readDeclaredVersion(data) {
-    if (data && typeof data === 'object' && 'version' in data) {
-        const v = data.version;
-        if (typeof v === 'string')
-            return v;
-    }
-    return undefined;
-}
-function unsupportedVersionResult(loaded, declared) {
-    const supported = SUPPORTED_POLICY_SCHEMA_VERSIONS.map((v) => `"${v}"`).join(' / ');
-    const isLegacy = declared === '0.1';
-    const hint = isLegacy
-        ? `v0.1 policy support was removed in v3.0. Run \`switchbot policy migrate\` with CLI ≤2.15 first, then upgrade.`
-        : `supported versions: ${supported}. upgrade the CLI or downgrade the file.`;
-    return {
-        policyPath: loaded.path,
-        schemaVersion: CURRENT_POLICY_SCHEMA_VERSION,
-        valid: false,
-        errors: [
-            {
-                path: '/version',
-                line: 1,
-                col: 1,
-                keyword: 'unsupported-version',
-                message: `policy schema version "${declared}" is not supported by this CLI`,
-                hint,
-                schemaPath: '#/properties/version',
-            },
-        ],
-    };
-}
-/**
- * Walk `automation.rules[].then[]` and flag any command string whose verb
- * appears in DESTRUCTIVE_COMMANDS. Uses the YAML doc (not the data tree) to
- * get accurate line/col on the offending node.
- *
- * This is deliberately a post-ajv pass rather than a schema rule because
- * JSON Schema cannot parse a command string and compare the verb slot to a
- * blocklist. Keeping it in JS also lets `src/rules/destructive.ts` be the
- * single source of truth shared with the runtime executor.
- */
-function collectDestructiveRuleErrors(loaded) {
-    const data = loaded.data;
-    const rules = data?.automation?.rules;
-    if (!Array.isArray(rules))
-        return [];
-    const out = [];
-    for (let ri = 0; ri < rules.length; ri++) {
-        const rule = rules[ri];
-        const actions = Array.isArray(rule?.then) ? rule.then : [];
-        for (let ai = 0; ai < actions.length; ai++) {
-            const cmd = actions[ai]?.command;
-            if (typeof cmd !== 'string')
-                continue;
-            const verb = destructiveVerbOf(cmd);
-            if (!verb)
-                continue;
-            const instancePath = `/automation/rules/${ri}/then/${ai}/command`;
-            const segments = instancePath.slice(1).split('/');
-            const node = getNodeAt(loaded.doc, segments);
-            const range = node?.range;
-            let line;
-            let col;
-            if (range) {
-                const pos = loaded.lineCounter.linePos(range[0]);
-                line = pos.line;
-                col = pos.col;
-            }
-            const ruleName = typeof rule?.name === 'string' ? rule.name : `#${ri}`;
-            out.push({
-                path: instancePath,
-                line,
-                col,
-                keyword: 'rule-destructive-action',
-                message: `rule "${ruleName}" action #${ai} uses destructive command "${verb}"`,
-                hint: `destructive verbs (${DESTRUCTIVE_COMMANDS.join(', ')}) cannot be pre-approved in automation rules; run them via the interactive CLI so the confirmation gate fires`,
-                schemaPath: '#/properties/automation/properties/rules/items/properties/then/items/properties/command',
-            });
-        }
-    }
-    return out;
-}
-export function validateLoadedPolicy(loaded) {
-    const declared = readDeclaredVersion(loaded.data);
-    if (declared !== undefined && !isSupportedPolicySchemaVersion(declared)) {
-        return unsupportedVersionResult(loaded, declared);
-    }
-    const version = isSupportedPolicySchemaVersion(declared)
-        ? declared
-        : CURRENT_POLICY_SCHEMA_VERSION;
-    const { validate } = getValidator(version);
-    const ok = validate(loaded.data);
-    const errors = [];
-    if (!ok && validate.errors) {
-        for (const err of validate.errors) {
-            const { line, col } = locateError(loaded.doc, loaded.lineCounter, err);
-            errors.push({
-                path: err.instancePath || '',
-                line,
-                col,
-                keyword: err.keyword,
-                message: humanMessage(err),
-                hint: hintFor(err),
-                schemaPath: err.schemaPath,
-            });
-        }
-    }
-    // v0.2-only post-hook: destructive verbs like `unlock` / `factoryReset`
-    // cannot be pre-approved via rules, even if ajv considers the command
-    // string well-formed. Schema can't express this because `command` is a
-    // free-form string; we parse the verb in JS and append errors.
-    if (version === '0.2') {
-        const ruleErrors = collectDestructiveRuleErrors(loaded);
-        errors.push(...ruleErrors);
-    }
-    const valid = ok === true && errors.length === 0;
-    return {
-        policyPath: loaded.path,
-        schemaVersion: version,
-        valid,
-        errors,
-    };
-}
-export function validatePolicyFile(policyPath) {
-    const loaded = loadPolicyFile(policyPath);
-    return validateLoadedPolicy(loaded);
-}