@switchbot/openapi-cli 3.1.1 → 3.2.0

package/dist/mcp/device-history.js

@@ -1,145 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-const MAX_HISTORY = 100;
-const JSONL_ROTATE_BYTES = 50 * 1024 * 1024; // 50 MB
-const JSONL_KEEP_ROTATIONS = 3; // .1 .2 .3
-function historyDir() {
-    return path.join(os.homedir(), '.switchbot', 'device-history');
-}
-export class DeviceHistoryStore {
-    // In-memory size counter so we don't stat() on every append.
-    jsonlSizes = new Map();
-    /** Reset the in-memory size counter. Tests use this between runs. */
-    resetSizes() {
-        this.jsonlSizes.clear();
-    }
-    get dir() {
-        return historyDir();
-    }
-    record(deviceId, topic, deviceType, payload, t) {
-        const entry = { t: t ?? new Date().toISOString(), topic, deviceType, payload };
-        try {
-            if (!fs.existsSync(this.dir))
-                fs.mkdirSync(this.dir, { recursive: true });
-            // 1. Ring-buffer JSON (back-compat with existing consumers).
-            const file = path.join(this.dir, `${deviceId}.json`);
-            const existing = fs.existsSync(file)
-                ? JSON.parse(fs.readFileSync(file, 'utf-8'))
-                : { latest: null, history: [] };
-            existing.latest = entry;
-            existing.history = [entry, ...existing.history].slice(0, MAX_HISTORY);
-            fs.writeFileSync(file, JSON.stringify(existing, null, 2), { mode: 0o600 });
-            // 2. Append-only JSONL for range queries.
-            this.writeJsonl(deviceId, entry);
-        }
-        catch {
-            // best-effort — history loss is non-fatal
-        }
-    }
-    /** Append a mqtt control event (no deviceId) to the dedicated __control.jsonl file. */
-    recordControl(event) {
-        try {
-            if (!fs.existsSync(this.dir))
-                fs.mkdirSync(this.dir, { recursive: true });
-            this.writeJsonl('__control', event);
-        }
-        catch {
-            // best-effort — never block the event stream
-        }
-    }
-    writeJsonl(fileKey, record) {
-        try {
-            const jsonlPath = path.join(this.dir, `${fileKey}.jsonl`);
-            const line = JSON.stringify(record) + '\n';
-            const lineBytes = Buffer.byteLength(line, 'utf-8');
-            // Seed size counter from disk on first touch (avoids drift across restarts).
-            let size = this.jsonlSizes.get(fileKey);
-            if (size === undefined) {
-                try {
-                    size = fs.existsSync(jsonlPath) ? fs.statSync(jsonlPath).size : 0;
-                }
-                catch {
-                    size = 0;
-                }
-            }
-            if (size + lineBytes > JSONL_ROTATE_BYTES) {
-                this.rotateJsonl(fileKey);
-                size = 0;
-            }
-            fs.appendFileSync(jsonlPath, line, { mode: 0o600 });
-            this.jsonlSizes.set(fileKey, size + lineBytes);
-        }
-        catch {
-            // best-effort
-        }
-    }
-    rotateJsonl(fileKey) {
-        const base = path.join(this.dir, `${fileKey}.jsonl`);
-        // .jsonl.3 is dropped; .2 → .3, .1 → .2, current → .1
-        try {
-            const oldest = `${base}.${JSONL_KEEP_ROTATIONS}`;
-            if (fs.existsSync(oldest))
-                fs.rmSync(oldest);
-        }
-        catch { /* swallow */ }
-        for (let i = JSONL_KEEP_ROTATIONS - 1; i >= 1; i--) {
-            const from = `${base}.${i}`;
-            const to = `${base}.${i + 1}`;
-            try {
-                if (fs.existsSync(from))
-                    fs.renameSync(from, to);
-            }
-            catch { /* swallow */ }
-        }
-        try {
-            if (fs.existsSync(base))
-                fs.renameSync(base, `${base}.1`);
-        }
-        catch { /* swallow */ }
-    }
-    getLatest(deviceId) {
-        try {
-            const file = path.join(this.dir, `${deviceId}.json`);
-            if (!fs.existsSync(file))
-                return null;
-            return JSON.parse(fs.readFileSync(file, 'utf-8')).latest;
-        }
-        catch {
-            return null;
-        }
-    }
-    getHistory(deviceId, limit = 20) {
-        try {
-            const file = path.join(this.dir, `${deviceId}.json`);
-            if (!fs.existsSync(file))
-                return [];
-            const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
-            return data.history.slice(0, Math.min(limit, MAX_HISTORY));
-        }
-        catch {
-            return [];
-        }
-    }
-    listDevices() {
-        try {
-            if (!fs.existsSync(this.dir))
-                return [];
-            const seen = new Set();
-            for (const f of fs.readdirSync(this.dir)) {
-                if (f.endsWith('.json'))
-                    seen.add(f.slice(0, -5));
-                else if (f.endsWith('.jsonl'))
-                    seen.add(f.slice(0, -6));
-            }
-            return Array.from(seen);
-        }
-        catch {
-            return [];
-        }
-    }
-    getHistoryDir() {
-        return this.dir;
-    }
-}
-export const deviceHistoryStore = new DeviceHistoryStore();

package/dist/mcp/events-subscription.js

@@ -1,213 +0,0 @@
-import { SwitchBotMqttClient } from '../mqtt/client.js';
-import { fetchMqttCredential } from '../mqtt/credential.js';
-import { parseFilter, applyFilter } from '../utils/filter.js';
-import { fetchDeviceList } from '../lib/devices.js';
-import { getCachedDevice } from '../devices/cache.js';
-import { createClient } from '../api/client.js';
-import { log } from '../logger.js';
-import { deviceHistoryStore } from './device-history.js';
-export class EventSubscriptionManager {
-    mqttClient = null;
-    subscribers = new Map();
-    ringBuffer = [];
-    ringSize = 1000;
-    typeMap = new Map();
-    refreshTypeMapTimer = null;
-    idleCleanupTimer = null;
-    getClient;
-    lastRefreshAttempt = 0;
-    constructor(mqttClient, getClient) {
-        this.mqttClient = mqttClient || null;
-        this.getClient = getClient;
-    }
-    async initialize(token, secret) {
-        if (!this.mqttClient) {
-            const credential = await fetchMqttCredential(token, secret);
-            const client = new SwitchBotMqttClient(credential, () => fetchMqttCredential(token, secret));
-            client.onStateChange((state) => {
-                if (state === 'connected') {
-                    this.emit({
-                        kind: 'events.reconnected',
-                        timestamp: Date.now(),
-                    });
-                    client.subscribe(credential.topics.status);
-                }
-            });
-            client.onMessage((topic, payload) => {
-                try {
-                    const data = JSON.parse(payload.toString());
-                    // Support SwitchBot direct format: { eventType, context: { deviceMac, deviceType, ... } }
-                    // and AWS IoT shadow format: $aws/things/<id>/shadow/... with data.state
-                    const context = data.context;
-                    const deviceId = context?.deviceMac ?? this.extractDeviceId(topic);
-                    const payloadData = context ?? data.state;
-                    const deviceType = String(context?.deviceType ?? 'Unknown');
-                    if (deviceId && payloadData) {
-                        deviceHistoryStore.record(deviceId, topic, deviceType, payloadData);
-                        this.addEvent({
-                            kind: 'shadow.updated',
-                            deviceId,
-                            payload: payloadData,
-                            timestamp: Date.now(),
-                        });
-                    }
-                }
-                catch (err) {
-                    log.debug({ err, topic }, 'failed to parse shadow payload');
-                }
-            });
-            await client.connect();
-            this.mqttClient = client;
-        }
-        this.scheduleIdleCleanup();
-    }
-    subscribe(id, handler, filter) {
-        // Validate filter syntax if provided
-        if (filter) {
-            parseFilter(filter);
-        }
-        const subscriber = {
-            id,
-            handler,
-            filter,
-            lastActivity: Date.now(),
-        };
-        this.subscribers.set(id, subscriber);
-        // Send recent events that match the filter
-        for (const event of this.ringBuffer) {
-            if (this.matchesFilter(event, filter)) {
-                handler(event);
-            }
-        }
-        return () => {
-            this.subscribers.delete(id);
-        };
-    }
-    addEvent(event) {
-        this.ringBuffer.push(event);
-        // Check for overflow
-        if (this.ringBuffer.length > this.ringSize) {
-            const droppedCount = this.ringBuffer.length - this.ringSize;
-            const oldestTimestamp = this.ringBuffer[0]?.timestamp || Date.now();
-            // Emit overflow notice to all subscribers
-            this.emit({
-                kind: 'events.dropped',
-                count: droppedCount,
-                sinceTs: oldestTimestamp,
-            });
-            // Trim buffer
-            this.ringBuffer = this.ringBuffer.slice(-this.ringSize);
-        }
-        // Broadcast to matching subscribers
-        this.emit(event);
-    }
-    emit(event) {
-        for (const subscriber of this.subscribers.values()) {
-            if (this.matchesFilter(event, subscriber.filter)) {
-                subscriber.lastActivity = Date.now();
-                subscriber.handler(event);
-            }
-        }
-    }
-    matchesFilter(event, filter) {
-        if (!filter)
-            return true;
-        // Only filter shadow events
-        if (event.kind !== 'shadow.updated')
-            return true;
-        try {
-            // Parse filter and match against device metadata
-            const clauses = parseFilter(filter);
-            const deviceId = event.deviceId;
-            // Get device info from cache
-            const cached = getCachedDevice(deviceId);
-            if (!cached) {
-                // Lazily refresh type map if device unknown
-                this.scheduleTypeMapRefresh();
-                return false; // Conservative: drop if unknown
-            }
-            // Build a Device-compatible shape for applyFilter
-            const device = {
-                deviceId,
-                deviceType: this.typeMap.get(deviceId) || cached.type,
-                deviceName: cached.name,
-                familyName: cached.familyName,
-                roomName: cached.roomName,
-                enableCloudService: true,
-                hubDeviceId: '',
-            };
-            // Use applyFilter with single device in list
-            const matched = applyFilter(clauses, [device], [], new Map());
-            return matched.length > 0;
-        }
-        catch {
-            return false; // Invalid filter matches nothing
-        }
-    }
-    scheduleTypeMapRefresh() {
-        if (this.refreshTypeMapTimer || Date.now() - this.lastRefreshAttempt < 5000) {
-            return; // Already scheduled or too recent
-        }
-        this.refreshTypeMapTimer = setTimeout(async () => {
-            this.refreshTypeMapTimer = null;
-            this.lastRefreshAttempt = Date.now();
-            try {
-                const client = this.getClient?.() || createClient();
-                const body = await fetchDeviceList(client);
-                for (const d of body.deviceList) {
-                    if (d.deviceType)
-                        this.typeMap.set(d.deviceId, d.deviceType);
-                }
-                for (const ir of body.infraredRemoteList) {
-                    this.typeMap.set(ir.deviceId, ir.remoteType);
-                }
-            }
-            catch {
-                // Silently fail type map refresh
-            }
-        }, 100);
-    }
-    scheduleIdleCleanup() {
-        if (this.idleCleanupTimer)
-            return;
-        this.idleCleanupTimer = setInterval(() => {
-            const now = Date.now();
-            const idleThreshold = 10 * 60 * 1000; // 10 minutes
-            for (const [id, subscriber] of this.subscribers.entries()) {
-                if (now - subscriber.lastActivity > idleThreshold) {
-                    this.subscribers.delete(id);
-                }
-            }
-        }, 60000); // Check every minute
-    }
-    extractDeviceId(topic) {
-        // Topic format: $aws/things/<deviceId>/shadow/update/accepted
-        const match = topic.match(/\$aws\/things\/([^/]+)\/shadow/);
-        return match ? match[1] : null;
-    }
-    getState() {
-        if (!this.mqttClient)
-            return 'disabled';
-        return this.mqttClient.getState();
-    }
-    getSubscriberCount() {
-        return this.subscribers.size;
-    }
-    getRecentEvents(limit = 100) {
-        return this.ringBuffer.slice(-limit);
-    }
-    async shutdown() {
-        if (this.refreshTypeMapTimer) {
-            clearTimeout(this.refreshTypeMapTimer);
-        }
-        if (this.idleCleanupTimer) {
-            clearInterval(this.idleCleanupTimer);
-        }
-        if (this.mqttClient) {
-            await this.mqttClient.disconnect();
-            this.mqttClient = null;
-        }
-        this.subscribers.clear();
-        this.ringBuffer = [];
-    }
-}

package/dist/mqtt/client.js

@@ -1,180 +0,0 @@
-import { connect } from 'mqtt';
-export class SwitchBotMqttClient {
-    client = null;
-    credential;
-    state = 'connecting';
-    credentialExpired = false;
-    reconnectAttempts = 0;
-    maxReconnectAttempts = 10;
-    disconnecting = false;
-    handlers = new Set();
-    messageHandlers = new Set();
-    credentialRefreshCallback;
-    constructor(credential, onCredentialExpired) {
-        this.credential = credential;
-        this.credentialRefreshCallback = onCredentialExpired;
-    }
-    async connect() {
-        if (this.client && this.state === 'connected')
-            return;
-        // Remove stale listeners before replacing the client instance, otherwise
-        // the old client's close event fires after the new connection is established
-        // (AWS IoT drops the old session), triggering a spurious reconnect loop.
-        if (this.client) {
-            this.client.removeAllListeners();
-            this.client.end(true);
-            this.client = null;
-        }
-        this.setState('connecting');
-        this.credentialExpired = false;
-        this.reconnectAttempts = 0;
-        try {
-            const { tls, brokerUrl, clientId } = this.credential;
-            // tls.ca/cert/keyBase64 are PEM strings despite the misleading field name
-            const options = {
-                clientId,
-                ca: tls.caBase64,
-                cert: tls.certBase64,
-                key: tls.keyBase64,
-                rejectUnauthorized: true,
-                clean: true,
-                reconnectPeriod: 0,
-                connectTimeout: 30000,
-                keepalive: 60,
-                reschedulePings: true,
-            };
-            this.client = connect(brokerUrl, options);
-            this.client.on('connect', () => {
-                this.reconnectAttempts = 0;
-                this.setState('connected');
-                this.credentialExpired = false;
-            });
-            this.client.on('message', (topic, payload) => {
-                for (const handler of this.messageHandlers) {
-                    handler(topic, payload);
-                }
-            });
-            this.client.on('error', (err) => {
-                if (err instanceof Error &&
-                    (err.message.includes('certificate') ||
-                        err.message.includes('ECONNRESET') ||
-                        err.message.includes('handshake'))) {
-                    this.credentialExpired = true;
-                }
-            });
-            this.client.on('close', () => {
-                if (this.disconnecting)
-                    return;
-                if (this.credentialExpired) {
-                    this.setState('failed');
-                }
-                else if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                    this.attemptReconnect();
-                }
-                else {
-                    this.setState('failed');
-                }
-            });
-            await new Promise((resolve, reject) => {
-                const timeout = setTimeout(() => {
-                    reject(new Error('MQTT connection timeout'));
-                }, 15000);
-                const onConnect = () => {
-                    clearTimeout(timeout);
-                    this.client?.removeListener('error', onError);
-                    resolve();
-                };
-                const onError = (err) => {
-                    clearTimeout(timeout);
-                    this.client?.removeListener('connect', onConnect);
-                    reject(err);
-                };
-                if (this.client?.connected) {
-                    clearTimeout(timeout);
-                    resolve();
-                }
-                else {
-                    this.client?.once('connect', onConnect);
-                    this.client?.once('error', onError);
-                }
-            });
-        }
-        catch (err) {
-            this.setState('failed');
-            throw err;
-        }
-    }
-    async attemptReconnect() {
-        this.reconnectAttempts++;
-        this.setState('reconnecting');
-        if (this.credentialExpired && this.credentialRefreshCallback) {
-            try {
-                this.credential = await this.credentialRefreshCallback();
-                this.credentialExpired = false;
-            }
-            catch {
-                this.setState('failed');
-                return;
-            }
-        }
-        const delay = Math.min(30000, 1000 * Math.pow(2, this.reconnectAttempts - 1));
-        await new Promise((r) => setTimeout(r, delay));
-        try {
-            await this.connect();
-        }
-        catch {
-            if (this.reconnectAttempts < this.maxReconnectAttempts) {
-                await this.attemptReconnect();
-            }
-            else {
-                this.setState('failed');
-            }
-        }
-    }
-    setState(newState) {
-        if (this.state !== newState) {
-            this.state = newState;
-            for (const handler of this.handlers) {
-                handler(newState);
-            }
-        }
-    }
-    subscribe(topic) {
-        if (this.client && this.state === 'connected') {
-            this.client.subscribe(topic, (err) => {
-                if (err) {
-                    console.error(`Failed to subscribe to ${topic}:`, err);
-                }
-            });
-        }
-    }
-    onStateChange(handler) {
-        this.handlers.add(handler);
-        return () => {
-            this.handlers.delete(handler);
-        };
-    }
-    onMessage(handler) {
-        this.messageHandlers.add(handler);
-        return () => {
-            this.messageHandlers.delete(handler);
-        };
-    }
-    getState() {
-        return this.state;
-    }
-    isConnected() {
-        return this.state === 'connected' && this.client?.connected === true;
-    }
-    async disconnect() {
-        this.disconnecting = true;
-        if (this.client) {
-            await new Promise((resolve) => {
-                this.client?.end(false, () => resolve());
-            });
-            this.client = null;
-        }
-        this.disconnecting = false;
-        this.setState('failed');
-    }
-}

package/dist/mqtt/credential.js

@@ -1,30 +0,0 @@
-import crypto from 'node:crypto';
-import { buildAuthHeaders } from '../auth.js';
-const CREDENTIAL_ENDPOINT = 'https://api.switchbot.net/v1.1/iot/credential';
-export async function fetchMqttCredential(token, secret) {
-    // Use a random instanceId so each CLI session gets its own clientId, avoiding
-    // conflicts with the SwitchBot cloud service that shares the same account credentials.
-    const instanceId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
-    const headers = buildAuthHeaders(token, secret);
-    const res = await fetch(CREDENTIAL_ENDPOINT, {
-        method: 'POST',
-        headers,
-        body: JSON.stringify({ instanceId }),
-        signal: AbortSignal.timeout(15000),
-    });
-    if (!res.ok) {
-        throw new Error(`MQTT credential request failed: HTTP ${res.status} ${res.statusText}`);
-    }
-    const json = (await res.json());
-    if (json.statusCode !== 100) {
-        throw new Error(`MQTT credential API error: statusCode ${json.statusCode}`);
-    }
-    // Response shape: { statusCode, body: { body: { channels: { mqtt: ... } } } }
-    const outer = json.body;
-    const inner = (outer.body ?? outer);
-    const channels = inner.channels;
-    if (!channels?.mqtt) {
-        throw new Error('Unexpected MQTT credential response — channels.mqtt missing');
-    }
-    return channels.mqtt;
-}

package/dist/policy/add-rule.js

@@ -1,124 +0,0 @@
-import { parseDocument, isMap, isSeq, isScalar, LineCounter } from 'yaml';
-import { parse as yamlParse } from 'yaml';
-import { loadPolicyFile } from './load.js';
-import { validateLoadedPolicy } from './validate.js';
-import fs from 'node:fs';
-export class AddRuleError extends Error {
-    code;
-    constructor(message, code) {
-        super(message);
-        this.code = code;
-        this.name = 'AddRuleError';
-    }
-}
-function buildDiff(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');
-}
-function isNullNode(node) {
-    return isScalar(node) && node.value === null;
-}
-export function addRuleToPolicySource(opts) {
-    const loaded = loadPolicyFile(opts.policyPath);
-    const beforeSource = loaded.source;
-    // Parse the incoming rule
-    let ruleObj;
-    try {
-        ruleObj = yamlParse(opts.ruleYaml);
-    }
-    catch (err) {
-        throw new AddRuleError(`Could not parse rule YAML: ${err.message}`, 'invalid-rule-yaml');
-    }
-    if (!ruleObj || typeof ruleObj !== 'object' || Array.isArray(ruleObj)) {
-        throw new AddRuleError('Rule YAML must be a single mapping object', 'invalid-rule-shape');
-    }
-    const ruleName = ruleObj['name'];
-    if (typeof ruleName !== 'string' || !ruleName) {
-        throw new AddRuleError('Rule must have a non-empty "name" field', 'missing-rule-name');
-    }
-    // Clone the document using source round-trip (preserves comments)
-    const clone = parseDocument(beforeSource, { keepSourceTokens: true });
-    if (!isMap(clone.contents)) {
-        throw new AddRuleError('Policy root must be a YAML mapping', 'invalid-policy-shape');
-    }
-    // Ensure automation block exists
-    let automationNode = clone.contents.get('automation', true);
-    if (!automationNode || isNullNode(automationNode)) {
-        clone.setIn(['automation'], clone.createNode({ enabled: false, rules: [] }));
-        automationNode = clone.contents.get('automation', true);
-    }
-    // Ensure automation.rules exists and is a sequence
-    const rulesNode = clone.getIn(['automation', 'rules'], true);
-    if (!rulesNode || isNullNode(rulesNode)) {
-        clone.setIn(['automation', 'rules'], clone.createNode([]));
-    }
-    else if (!isSeq(rulesNode)) {
-        throw new AddRuleError('automation.rules exists but is not a sequence; cannot append', 'invalid-rules-shape');
-    }
-    // Duplicate name check — use JS conversion for simplicity
-    const policyJs = clone.toJS({ maxAliasCount: 100 });
-    const existingRulesJs = policyJs['automation']?.['rules'];
-    const existingRulesArr = Array.isArray(existingRulesJs) ? existingRulesJs : [];
-    const duplicateIdx = existingRulesArr.findIndex((r) => r?.['name'] === ruleName);
-    if (duplicateIdx !== -1 && !opts.force) {
-        throw new AddRuleError(`Rule named "${ruleName}" already exists. Use --force to overwrite.`, 'duplicate-rule-name');
-    }
-    if (duplicateIdx !== -1 && opts.force) {
-        const rulesSeq = clone.getIn(['automation', 'rules'], true);
-        rulesSeq.items.splice(duplicateIdx, 1);
-    }
-    // Enable automation if requested
-    if (opts.enableAutomation) {
-        clone.setIn(['automation', 'enabled'], true);
-    }
-    // Append the rule
-    const ruleNode = clone.createNode(ruleObj);
-    const rulesSeq = clone.getIn(['automation', 'rules'], true);
-    rulesSeq.items.push(ruleNode);
-    const nextSource = String(clone);
-    // Validate the resulting policy
-    const reLC = new LineCounter();
-    const reDoc = parseDocument(nextSource, { lineCounter: reLC, keepSourceTokens: true });
-    const validation = validateLoadedPolicy({
-        path: opts.policyPath,
-        source: nextSource,
-        doc: reDoc,
-        lineCounter: reLC,
-        data: reDoc.toJS({ maxAliasCount: 100 }),
-    });
-    if (!validation.valid) {
-        const msgs = validation.errors.map((e) => `  line ${e.line}: ${e.message}`).join('\n');
-        throw new AddRuleError(`Policy would be invalid after adding the rule:\n${msgs}`, 'validation-failed');
-    }
-    const diff = buildDiff(beforeSource, nextSource);
-    return { ruleName, diff, nextSource };
-}
-export function addRuleToPolicyFile(opts) {
-    const result = addRuleToPolicySource(opts);
-    if (!opts.dryRun) {
-        fs.writeFileSync(opts.policyPath, result.nextSource, 'utf8');
-        return { ...result, written: true };
-    }
-    return { ...result, written: false };
-}