@switchbot/openapi-cli 1.3.2 → 2.0.1

package/dist/lib/idempotency.js

@@ -0,0 +1,72 @@
+/**
+ * In-memory LRU cache for idempotent request deduplication.
+ * Caches the outcome of a keyed operation for 60 seconds;
+ * duplicate keys within the window return the cached result without re-executing.
+ * Process-local only — not shared across replicas.
+ */
+const DEFAULT_TTL_MS = 60000; // 60 seconds
+const DEFAULT_MAX_ENTRIES = 1024;
+export class IdempotencyCache {
+    cache = new Map();
+    ttlMs;
+    maxEntries;
+    constructor(ttlMs, maxEntries) {
+        this.ttlMs = ttlMs ?? DEFAULT_TTL_MS;
+        this.maxEntries = maxEntries ?? DEFAULT_MAX_ENTRIES;
+    }
+    /**
+     * Execute fn if the key is not cached, or return the cached result if it is.
+     * On new execution, caches the result for ttlMs.
+     */
+    async run(key, fn) {
+        // No key = always execute (not cached)
+        if (!key) {
+            return fn();
+        }
+        const now = Date.now();
+        const cached = this.cache.get(key);
+        // Cached and not expired
+        if (cached && cached.expiresAt > now) {
+            return cached.result;
+        }
+        // Expired or uncached: execute
+        const result = await fn();
+        // Prune if over capacity (LRU: remove oldest entries)
+        if (this.cache.size >= this.maxEntries) {
+            const toRemove = Math.ceil(this.maxEntries * 0.1); // Remove 10%
+            let removed = 0;
+            for (const [k, v] of this.cache.entries()) {
+                if (removed >= toRemove)
+                    break;
+                // Remove expired entries first, then oldest
+                if (v.expiresAt <= now) {
+                    this.cache.delete(k);
+                    removed++;
+                }
+            }
+            // If still over capacity, remove oldest insertion (Map is insertion-ordered)
+            if (this.cache.size >= this.maxEntries) {
+                const firstKey = this.cache.keys().next().value;
+                if (firstKey)
+                    this.cache.delete(firstKey);
+            }
+        }
+        // Cache the result
+        this.cache.set(key, { result, expiresAt: now + this.ttlMs });
+        return result;
+    }
+    /**
+     * Clear all cached entries (mainly for testing).
+     */
+    clear() {
+        this.cache.clear();
+    }
+    /**
+     * Return the number of cached entries.
+     */
+    size() {
+        return this.cache.size;
+    }
+}
+// Global shared instance for the process
+export const idempotencyCache = new IdempotencyCache();

package/dist/lib/request-context.js

@@ -0,0 +1,12 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { getProfile } from '../utils/flags.js';
+export const requestContext = new AsyncLocalStorage();
+export function withRequestContext(ctx, fn) {
+    return requestContext.run(ctx, fn);
+}
+export function getActiveProfile() {
+    const ctx = requestContext.getStore();
+    if (ctx?.profile !== undefined)
+        return ctx.profile;
+    return getProfile();
+}

package/dist/lib/scenes.js

@@ -8,4 +8,3 @@ export async function executeScene(sceneId, client) {
     const c = client ?? createClient();
     await c.post(`/v1.1/scenes/${sceneId}/execute`);
 }
-//# sourceMappingURL=scenes.js.map

package/dist/logger.js

@@ -0,0 +1,16 @@
+import pino from 'pino';
+const logLevel = process.env.LOG_LEVEL || 'warn';
+const logFormat = process.env.LOG_FORMAT || 'json';
+const pinoConfig = {
+    level: logLevel,
+    transport: logFormat === 'pretty'
+        ? { target: 'pino-pretty' }
+        : undefined,
+};
+export const log = pino(pinoConfig);
+export function setLogLevel(level) {
+    log.level = level;
+}
+export function getLogLevel() {
+    return log.level;
+}

package/dist/mcp/events-subscription.js

@@ -0,0 +1,210 @@
+import { SwitchBotMqttClient } from '../mqtt/client.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';
+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(mqttConfig) {
+        if (!this.mqttClient) {
+            const client = new SwitchBotMqttClient(mqttConfig, async () => {
+                // Auth refresh callback - would need credential resolution here
+                return {
+                    username: mqttConfig.username,
+                    password: mqttConfig.password,
+                };
+            });
+            client.onStateChange((state) => {
+                if (state === 'connected') {
+                    this.emit({
+                        kind: 'events.reconnected',
+                        timestamp: Date.now(),
+                    });
+                    client.subscribe('$aws/things/+/shadow/update/accepted');
+                }
+            });
+            client.onMessage((topic, payload) => {
+                try {
+                    const data = JSON.parse(payload.toString());
+                    const deviceId = this.extractDeviceId(topic);
+                    if (deviceId && data.state) {
+                        this.addEvent({
+                            kind: 'shadow.updated',
+                            deviceId,
+                            payload: data.state,
+                            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

@@ -0,0 +1,184 @@
+import { connect } from 'mqtt';
+export class SwitchBotMqttClient {
+    client = null;
+    config;
+    state = 'connecting';
+    authRefreshNeeded = false;
+    reconnectAttempts = 0;
+    maxReconnectAttempts = 10;
+    handlers = new Set();
+    messageHandlers = new Set();
+    authRefreshCallback;
+    stableTimer = null;
+    lastConnectionAttempt = 0;
+    constructor(config, onAuthRefreshNeeded) {
+        this.config = config;
+        this.authRefreshCallback = onAuthRefreshNeeded;
+    }
+    async connect() {
+        if (this.client && this.state === 'connected') {
+            return;
+        }
+        this.setState('connecting');
+        this.authRefreshNeeded = false;
+        this.reconnectAttempts = 0;
+        try {
+            const options = {
+                username: this.config.username,
+                password: this.config.password,
+                clean: true,
+                reconnectPeriod: 0, // Manual reconnect control
+                connectTimeout: 10000,
+                rejectUnauthorized: this.config.rejectUnauthorized ?? true,
+            };
+            this.client = connect(`mqtts://${this.config.host}:${this.config.port}`, options);
+            this.client.on('connect', () => {
+                this.reconnectAttempts = 0;
+                this.setState('connected');
+                this.authRefreshNeeded = false;
+            });
+            this.client.on('message', (topic, payload) => {
+                for (const handler of this.messageHandlers) {
+                    handler(topic, payload);
+                }
+            });
+            this.client.on('error', (err) => {
+                // Check for auth-related errors
+                if ((err instanceof Error &&
+                    (err.message.includes('401') ||
+                        err.message.includes('Unauthorized') ||
+                        err.message.includes('EACCES'))) ||
+                    err.code === 'EACCES') {
+                    this.authRefreshNeeded = true;
+                }
+            });
+            this.client.on('close', () => {
+                this.clearStableTimer();
+                if (this.authRefreshNeeded) {
+                    this.setState('failed');
+                }
+                else if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                    this.attemptReconnect();
+                }
+                else {
+                    this.setState('failed');
+                }
+            });
+            // Wait for connection with timeout
+            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.authRefreshNeeded && this.authRefreshCallback) {
+            try {
+                const refreshed = await this.authRefreshCallback();
+                this.config.username = refreshed.username;
+                this.config.password = refreshed.password;
+                this.authRefreshNeeded = false;
+            }
+            catch (err) {
+                // Auth refresh failed, mark as failed
+                this.setState('failed');
+                return;
+            }
+        }
+        // Exponential backoff: 1s, 2s, 4s, 8s, 16s, 30s...
+        const delay = Math.min(30000, 1000 * Math.pow(2, this.reconnectAttempts - 1));
+        await new Promise((r) => setTimeout(r, delay));
+        try {
+            await this.connect();
+        }
+        catch (err) {
+            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);
+            }
+        }
+    }
+    clearStableTimer() {
+        if (this.stableTimer) {
+            clearTimeout(this.stableTimer);
+            this.stableTimer = null;
+        }
+    }
+    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.clearStableTimer();
+        if (this.client) {
+            await new Promise((resolve) => {
+                this.client?.end(false, () => {
+                    resolve();
+                });
+            });
+            this.client = null;
+            this.setState('failed');
+        }
+    }
+    setAuthRefreshCallback(callback) {
+        this.authRefreshCallback = callback;
+    }
+}

package/dist/mqtt/credential.js

@@ -0,0 +1,12 @@
+export function getMqttConfig() {
+    const host = process.env.SWITCHBOT_MQTT_HOST;
+    const username = process.env.SWITCHBOT_MQTT_USERNAME;
+    const password = process.env.SWITCHBOT_MQTT_PASSWORD;
+    if (!host || !username || !password)
+        return null;
+    const rawPort = process.env.SWITCHBOT_MQTT_PORT;
+    const port = rawPort ? Number(rawPort) : 8883;
+    if (!Number.isFinite(port) || port <= 0 || port > 65535)
+        return null;
+    return { host, port, username, password };
+}

package/dist/utils/audit.js

@@ -40,4 +40,3 @@ export function readAudit(file) {
     }
     return out;
 }
-//# sourceMappingURL=audit.js.map

package/dist/utils/filter.js

@@ -93,4 +93,3 @@ export function applyFilter(clauses, deviceList, infraredRemoteList, hubLocation
         return candidates;
     return candidates.filter((c) => clauses.every((clause) => matches(c, clause)));
 }
-//# sourceMappingURL=filter.js.map

package/dist/utils/flags.js

@@ -139,4 +139,3 @@ export function getCacheMode() {
     }
     return { listTtlMs: ms, statusTtlMs: ms };
 }
-//# sourceMappingURL=flags.js.map

package/dist/utils/format.js

@@ -106,4 +106,3 @@ export function renderRows(headers, rows, format, fields) {
         }
     }
 }
-//# sourceMappingURL=format.js.map

package/dist/utils/name-resolver.js

@@ -76,4 +76,3 @@ export function resolveDeviceId(deviceId, nameQuery) {
     }
     throw new UsageError(`No device matches "${nameQuery}". Run 'switchbot devices list' to see device names.`);
 }
-//# sourceMappingURL=name-resolver.js.map

package/dist/utils/output.js

@@ -2,11 +2,12 @@ import Table from 'cli-table3';
 import chalk from 'chalk';
 import { ApiError, DryRunSignal } from '../api/client.js';
 import { getFormat } from './flags.js';
+export const SCHEMA_VERSION = '1.1';
 export function isJsonMode() {
     return process.argv.includes('--json') || getFormat() === 'json';
 }
 export function printJson(data) {
-    console.log(JSON.stringify(data, null, 2));
+    console.log(JSON.stringify({ schemaVersion: SCHEMA_VERSION, data }, null, 2));
 }
 export function printTable(headers, rows) {
     const table = new Table({
@@ -67,26 +68,50 @@ function classifyApiError(code) {
 }
 export function buildErrorPayload(error) {
     if (error instanceof StructuredUsageError) {
-        const payload = { code: 2, kind: 'usage', message: error.message };
+        const payload = {
+            code: 2,
+            kind: 'usage',
+            message: error.message,
+            errorClass: 'usage',
+            transient: false
+        };
         if (error.context)
             payload.context = error.context;
         return payload;
     }
     if (error instanceof UsageError) {
-        return { code: 2, kind: 'usage', message: error.message };
+        return { code: 2, kind: 'usage', message: error.message, errorClass: 'usage', transient: false };
     }
     const code = error instanceof ApiError ? error.code : 1;
     const kind = error instanceof ApiError ? 'api' : 'runtime';
     const message = error instanceof Error ? error.message : 'An unknown error occurred';
     const hint = error instanceof ApiError ? (error.hint ?? errorHint(error.code)) : null;
     const retryable = error instanceof ApiError ? error.retryable : false;
-    const payload = { code, kind, message };
+    const retryAfterMs = error instanceof ApiError ? error.retryAfterMs : undefined;
+    const transient = error instanceof ApiError ? error.transient : false;
+    // Classify error
+    let errorClass = 'api';
+    if (kind === 'runtime') {
+        errorClass = 'api';
+    }
+    else if (transient && code >= 500) {
+        errorClass = 'api';
+    }
+    else if (code === 0) {
+        errorClass = 'network';
+    }
+    else if (code >= 400) {
+        errorClass = 'api';
+    }
+    const payload = { code, kind, message, errorClass, transient };
     if (error instanceof ApiError)
         payload.subKind = classifyApiError(error.code);
     if (hint)
         payload.hint = hint;
     if (retryable)
         payload.retryable = true;
+    if (retryAfterMs !== undefined)
+        payload.retryAfterMs = retryAfterMs;
     return payload;
 }
 export function handleError(error) {
@@ -95,7 +120,7 @@ export function handleError(error) {
     }
     const payload = buildErrorPayload(error);
     if (isJsonMode()) {
-        console.error(JSON.stringify({ error: payload }));
+        console.error(JSON.stringify({ schemaVersion: SCHEMA_VERSION, error: payload }));
         process.exit(payload.code === 2 ? 2 : 1);
     }
     if (payload.kind === 'usage') {
@@ -135,4 +160,3 @@ function errorHint(code) {
             return null;
     }
 }
-//# sourceMappingURL=output.js.map

package/dist/utils/quota.js

@@ -211,4 +211,3 @@ export function todayUsage(now = new Date()) {
         endpoints: { ...bucket.endpoints },
     };
 }
-//# sourceMappingURL=quota.js.map

package/dist/utils/retry.js

@@ -57,4 +57,3 @@ export function nextRetryDelayMs(attempt, strategy, retryAfterHeader, now = Date
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-//# sourceMappingURL=retry.js.map

package/dist/utils/string.js

@@ -20,4 +20,3 @@ export function levenshtein(a, b) {
 export function normalizeDeviceName(s) {
     return s.toLowerCase().replace(/[^a-z0-9\u4e00-\u9fff ]/g, ' ').replace(/\s+/g, ' ').trim();
 }
-//# sourceMappingURL=string.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@switchbot/openapi-cli",
-  "version": "1.3.2",
+  "version": "2.0.1",
   "description": "Command-line interface for SwitchBot API v1.1",
   "keywords": [
     "switchbot",
@@ -37,12 +37,14 @@
   },
   "scripts": {
     "build": "tsc",
+    "build:prod": "tsc -p tsconfig.build.json",
+    "clean": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
-    "prepublishOnly": "npm run build && npm test"
+    "prepublishOnly": "npm test && npm run clean && npm run build:prod"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
@@ -51,6 +53,8 @@
     "cli-table3": "^0.6.5",
     "commander": "^12.1.0",
     "js-yaml": "^4.1.1",
+    "mqtt": "^5.3.0",
+    "pino": "^9.0.0",
     "uuid": "^11.0.5"
   },
   "devDependencies": {