@switchbot/openapi-cli 2.6.4 → 3.0.0

package/dist/status-sync/manager.js

@@ -0,0 +1,268 @@
+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/audit.js

@@ -1,8 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { getAuditLog } from './flags.js';
-/** Bump when breaking changes to the audit line shape land. */
-export const AUDIT_VERSION = 1;
+/**
+ * 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)

package/dist/utils/help-json.js

@@ -0,0 +1,54 @@
+import { IDENTITY } from '../commands/identity.js';
+export function commandToJson(cmd, opts = {}) {
+    const args = cmd.registeredArguments.map((a) => ({
+        name: a.name(),
+        required: a.required,
+        variadic: a.variadic,
+        description: a.description ?? '',
+    }));
+    const options = cmd.options
+        .filter((o) => o.long !== '--help' && o.long !== '--version')
+        .map((o) => {
+        const entry = { flags: o.flags, description: o.description ?? '' };
+        if (o.defaultValue !== undefined)
+            entry.defaultValue = o.defaultValue;
+        if (o.argChoices && o.argChoices.length > 0)
+            entry.choices = o.argChoices;
+        return entry;
+    });
+    const subcommands = cmd.commands
+        .filter((c) => !c.name().startsWith('_'))
+        .map((c) => ({ name: c.name(), description: c.description() }));
+    const out = {
+        name: cmd.name(),
+        description: cmd.description(),
+        arguments: args,
+        options,
+        subcommands,
+    };
+    if (opts.includeIdentity) {
+        out.product = IDENTITY.product;
+        out.domain = IDENTITY.domain;
+        out.vendor = IDENTITY.vendor;
+        out.apiVersion = IDENTITY.apiVersion;
+        out.apiDocs = IDENTITY.apiDocs;
+        out.productCategories = IDENTITY.productCategories;
+    }
+    return out;
+}
+/** Walk argv tokens (skipping flags) to find the deepest matching subcommand. */
+export function resolveTargetCommand(root, argv) {
+    let cmd = root;
+    for (const token of argv) {
+        if (token.startsWith('-'))
+            continue;
+        const sub = cmd.commands.find((c) => c.name() === token || c.aliases().includes(token));
+        if (sub) {
+            cmd = sub;
+        }
+        else {
+            break;
+        }
+    }
+    return cmd;
+}

package/dist/utils/output.js

@@ -28,6 +28,23 @@ export function emitJsonError(errorPayload) {
         console.error(chalk.red(msg));
     }
 }
+/**
+ * P7: emit the stream-header first line for any NDJSON/streaming command
+ * running under `--json`. Downstream JSON consumers can key on
+ * `{ stream: true }` to distinguish the header from subsequent event
+ * lines, and on `eventKind` / `cadence` to pick a parser strategy.
+ *
+ * Non-streaming commands (single-object / array output) do NOT emit this
+ * header — only watch / events tail / events mqtt-tail.
+ */
+export function emitStreamHeader(opts) {
+    console.log(JSON.stringify({
+        schemaVersion: '1',
+        stream: true,
+        eventKind: opts.eventKind,
+        cadence: opts.cadence,
+    }));
+}
 export function exitWithError(messageOrOpts) {
     const opts = typeof messageOrOpts === 'string' ? { message: messageOrOpts } : messageOrOpts;
     const { message, kind = 'usage', code = 2, hint, context, extra } = opts;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@switchbot/openapi-cli",
-  "version": "2.6.4",
+  "version": "3.0.0",
   "description": "SwitchBot smart home CLI — control devices, run scenes, stream real-time events, and integrate AI agents via MCP. Full API v1.1 coverage.",
   "keywords": [
     "switchbot",
@@ -36,10 +36,12 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsc",
-    "build:prod": "tsc -p tsconfig.build.json",
+    "build": "tsc && node scripts/copy-assets.mjs",
+    "build:prod": "tsc -p tsconfig.build.json && node scripts/copy-assets.mjs",
     "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "dev": "tsx src/index.ts",
+    "lint:md": "markdownlint \"**/*.md\"",
+    "lint:md:changelog": "markdownlint CHANGELOG.md",
     "start": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -48,20 +50,26 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "ajv": "^8.18.0",
+    "ajv-formats": "^3.0.1",
     "axios": "^1.7.9",
     "chalk": "^5.4.1",
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
+    "croner": "^10.0.1",
     "js-yaml": "^4.1.1",
     "mqtt": "^5.3.0",
     "pino": "^9.0.0",
-    "uuid": "^11.0.5"
+    "uuid": "^11.0.5",
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.10.7",
     "@types/uuid": "^10.0.0",
     "@vitest/coverage-v8": "^2.1.9",
+    "markdownlint-cli": "^0.48.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
     "vitest": "^2.1.9"