@switchbot/openapi-cli 1.3.2 → 2.0.0

package/dist/commands/plan.js

@@ -357,4 +357,3 @@ Workflow:
             process.exit(1);
     });
 }
-//# sourceMappingURL=plan.js.map

package/dist/commands/quota.js

@@ -74,4 +74,3 @@ Examples:
         }
     });
 }
-//# sourceMappingURL=quota.js.map

package/dist/commands/scenes.js

@@ -60,4 +60,3 @@ Example:
         }
     });
 }
-//# sourceMappingURL=scenes.js.map

package/dist/commands/schema.js

@@ -1,4 +1,4 @@
-import { printJson, isJsonMode } from '../utils/output.js';
+import { printJson } from '../utils/output.js';
 import { getEffectiveCatalog } from '../devices/catalog.js';
 function toSchemaEntry(e) {
     return {
@@ -65,13 +65,6 @@ Examples:
             generatedAt: new Date().toISOString(),
             types: filtered.map(toSchemaEntry),
         };
-        // Always JSON — schema export without JSON would be a category error.
-        if (isJsonMode()) {
-            printJson(payload);
-        }
-        else {
-            console.log(JSON.stringify(payload, null, 2));
-        }
+        printJson(payload);
     });
 }
-//# sourceMappingURL=schema.js.map

package/dist/commands/watch.js

@@ -160,4 +160,3 @@ Examples:
         }
     });
 }
-//# sourceMappingURL=watch.js.map

package/dist/commands/webhook.js

@@ -179,4 +179,3 @@ Example:
         }
     });
 }
-//# sourceMappingURL=webhook.js.map

package/dist/config.js

@@ -1,11 +1,12 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { getConfigPath, getProfile } from './utils/flags.js';
+import { getConfigPath } from './utils/flags.js';
+import { getActiveProfile } from './lib/request-context.js';
 /**
  * Credential file resolution priority:
  *   1. --config <path> (absolute override — wins over everything)
- *   2. --profile <name> → ~/.switchbot/profiles/<name>.json
+ *   2. active profile (ALS request context, else --profile flag) → ~/.switchbot/profiles/<name>.json
  *   3. default        → ~/.switchbot/config.json
  *
  * Env SWITCHBOT_TOKEN+SWITCHBOT_SECRET still take priority inside loadConfig.
@@ -14,7 +15,7 @@ export function configFilePath() {
     const override = getConfigPath();
     if (override)
         return path.resolve(override);
-    const profile = getProfile();
+    const profile = getActiveProfile();
     if (profile) {
         return path.join(os.homedir(), '.switchbot', 'profiles', `${profile}.json`);
     }
@@ -40,7 +41,7 @@ export function loadConfig() {
     }
     const file = configFilePath();
     if (!fs.existsSync(file)) {
-        const profile = getProfile();
+        const profile = getActiveProfile();
         const hint = profile
             ? `No credentials configured for profile "${profile}". Run: switchbot --profile ${profile} config set-token <token> <secret>`
             : 'No credentials configured. Run: switchbot config set-token <token> <secret>';
@@ -100,4 +101,3 @@ function maskSecret(secret) {
         return '****';
     return secret.slice(0, 2) + '*'.repeat(secret.length - 4) + secret.slice(-2);
 }
-//# sourceMappingURL=config.js.map

package/dist/devices/cache.js

@@ -256,4 +256,3 @@ export function describeCache(now = Date.now()) {
     }
     return { list, status };
 }
-//# sourceMappingURL=cache.js.map

package/dist/devices/catalog.js

@@ -658,4 +658,3 @@ export function getEffectiveCatalog() {
     }
     return Array.from(byType.values());
 }
-//# sourceMappingURL=catalog.js.map

package/dist/devices/device-meta.js

@@ -54,4 +54,3 @@ export function clearDeviceMeta(deviceId) {
     delete meta.devices[deviceId];
     saveDeviceMeta(meta);
 }
-//# sourceMappingURL=device-meta.js.map

package/dist/index.js

@@ -115,4 +115,3 @@ catch (err) {
     }
     throw err;
 }
-//# sourceMappingURL=index.js.map

package/dist/lib/devices.js

@@ -1,4 +1,5 @@
 import { createClient } from '../api/client.js';
+import { idempotencyCache } from './idempotency.js';
 import { findCatalogEntry, suggestedActions, getEffectiveCatalog, } from '../devices/catalog.js';
 import { getCachedDevice, updateCacheFromDeviceList, loadCache, isListCacheFresh, getCachedStatus, setCachedStatus, } from '../devices/cache.js';
 import { getCacheMode } from '../utils/flags.js';
@@ -85,7 +86,7 @@ export async function fetchDeviceStatus(deviceId, client) {
  * (JSON-object when applicable), not a raw CLI string — callers should parse
  * upstream if needed.
  */
-export async function executeCommand(deviceId, cmd, parameter, commandType, client) {
+export async function executeCommand(deviceId, cmd, parameter, commandType, client, options) {
     const c = client ?? createClient();
     const body = {
         command: cmd,
@@ -101,25 +102,29 @@ export async function executeCommand(deviceId, cmd, parameter, commandType, clie
         commandType,
         dryRun: isDryRun(),
     };
-    try {
-        const res = await c.post(`/v1.1/devices/${deviceId}/commands`, body);
-        writeAudit({ ...baseAudit, result: 'ok' });
-        return res.data.body;
-    }
-    catch (err) {
-        // Dry-run intercepts throw DryRunSignal — still log the intent.
-        if (err instanceof Error && err.name === 'DryRunSignal') {
+    // Wrap in idempotency cache if key is provided
+    const execute = async () => {
+        try {
+            const res = await c.post(`/v1.1/devices/${deviceId}/commands`, body);
             writeAudit({ ...baseAudit, result: 'ok' });
+            return res.data.body;
         }
-        else {
-            writeAudit({
-                ...baseAudit,
-                result: 'error',
-                error: err instanceof Error ? err.message : String(err),
-            });
+        catch (err) {
+            // Dry-run intercepts throw DryRunSignal — still log the intent.
+            if (err instanceof Error && err.name === 'DryRunSignal') {
+                writeAudit({ ...baseAudit, result: 'ok' });
+            }
+            else {
+                writeAudit({
+                    ...baseAudit,
+                    result: 'error',
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            throw err;
         }
-        throw err;
-    }
+    };
+    return idempotencyCache.run(options?.idempotencyKey, execute);
 }
 /**
  * Validate a command against the locally-cached device → catalog mapping.
@@ -326,4 +331,3 @@ export function toMcpIrDeviceShape(d) {
         controlType: d.controlType,
     };
 }
-//# sourceMappingURL=devices.js.map

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;
+    }
+}