@switchbot/openapi-cli 2.0.1 → 2.2.0

package/dist/commands/expand.js

@@ -2,6 +2,7 @@ import { handleError, isJsonMode, printJson, UsageError } from '../utils/output.
 import { getCachedDevice } from '../devices/cache.js';
 import { executeCommand, isDestructiveCommand, getDestructiveReason } from '../lib/devices.js';
 import { isDryRun } from '../utils/flags.js';
+import { resolveDeviceId } from '../utils/name-resolver.js';
 import { DryRunSignal } from '../api/client.js';
 // ---- Mapping tables --------------------------------------------------------
 const AC_MODE_MAP = { auto: 1, cool: 2, dry: 3, fan: 4, heat: 5 };
@@ -85,8 +86,9 @@ export function registerExpandCommand(devices) {
     devices
         .command('expand')
         .description('Send a command with semantic flags instead of raw positional parameters')
-        .argument('<deviceId>', 'Target device ID from "devices list"')
-        .argument('<command>', 'Command name: setAll (AC), setPosition (Curtain/Blind Tilt), setMode (Relay Switch 2)')
+        .argument('[deviceId]', 'Target device ID from "devices list" (or use --name)')
+        .argument('[command]', 'Command name: setAll (AC), setPosition (Curtain/Blind Tilt), setMode (Relay Switch 2)')
+        .option('--name <query>', 'Resolve device by fuzzy name instead of deviceId')
         .option('--temp <celsius>', 'AC setAll: temperature in Celsius (16-30)')
         .option('--mode <mode>', 'AC: auto|cool|dry|fan|heat  Curtain: default|performance|silent  Relay: toggle|edge|detached|momentary')
         .option('--fan <speed>', 'AC setAll: fan speed auto|low|mid|high')
@@ -123,9 +125,24 @@ Examples:
   $ switchbot devices expand <blindId>   setPosition  --direction up --angle 50
   $ switchbot devices expand <relayId>   setMode      --channel 1 --mode edge
   $ switchbot devices expand <acId>      setAll       --temp 22 --mode heat --fan auto --power on --dry-run
+  $ switchbot devices expand --name "客厅空调" setAll --temp 26 --mode cool --fan low --power on
 `)
-        .action(async (deviceId, command, options) => {
+        .action(async (deviceIdArg, commandArg, options) => {
+        let deviceId = '';
+        let command = '';
         try {
+            // When --name is provided, Commander assigns the first positional to deviceIdArg
+            // and leaves commandArg undefined. Detect and shift.
+            let effectiveDeviceIdArg = deviceIdArg;
+            let effectiveCommand = commandArg;
+            if (options.name && deviceIdArg && !commandArg) {
+                effectiveCommand = deviceIdArg;
+                effectiveDeviceIdArg = undefined;
+            }
+            deviceId = resolveDeviceId(effectiveDeviceIdArg, options.name);
+            if (!effectiveCommand)
+                throw new UsageError('A command argument is required (setAll, setPosition, setMode).');
+            command = effectiveCommand;
             const cached = getCachedDevice(deviceId);
             const deviceType = cached?.type ?? '';
             let parameter;

package/dist/commands/mcp.js

@@ -8,11 +8,11 @@ import { fetchScenes, executeScene } from '../lib/scenes.js';
 import { findCatalogEntry } from '../devices/catalog.js';
 import { getCachedDevice } from '../devices/cache.js';
 import { EventSubscriptionManager } from '../mcp/events-subscription.js';
+import { deviceHistoryStore } from '../mcp/device-history.js';
 import { todayUsage } from '../utils/quota.js';
 import { describeCache } from '../devices/cache.js';
 import { withRequestContext } from '../lib/request-context.js';
-import { profileFilePath } from '../config.js';
-import { getMqttConfig } from '../mqtt/credential.js';
+import { profileFilePath, tryLoadConfig } from '../config.js';
 import fs from 'node:fs';
 function mcpError(kind, code, message, options) {
     const obj = { code, kind, message };
@@ -111,6 +111,40 @@ API docs: https://github.com/OpenWonderLabs/SwitchBotAPI`,
             structuredContent: { status: body },
         };
     });
+    // ---- get_device_history ----------------------------------------------------
+    server.registerTool('get_device_history', {
+        title: 'Get locally-persisted device state history',
+        description: 'Return device state history recorded from MQTT events (persisted to ~/.switchbot/device-history/). ' +
+            'No API call — zero quota cost. Use when you need recent historical readings or want to avoid a live API call. ' +
+            'Omit deviceId to list all devices with stored history.',
+        inputSchema: {
+            deviceId: z.string().optional().describe('Device MAC address (deviceId). Omit to list all devices with history.'),
+            limit: z.number().int().min(1).max(100).optional().describe('Max history entries to return (default 20, max 100)'),
+        },
+        outputSchema: {
+            deviceId: z.string().optional(),
+            latest: z.unknown().optional(),
+            history: z.array(z.unknown()).optional(),
+            devices: z.array(z.object({ deviceId: z.string(), latest: z.unknown() })).optional(),
+        },
+    }, async ({ deviceId, limit }) => {
+        if (deviceId) {
+            const latest = deviceHistoryStore.getLatest(deviceId);
+            const history = deviceHistoryStore.getHistory(deviceId, limit ?? 20);
+            const result = { deviceId, latest, history };
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: result,
+            };
+        }
+        const ids = deviceHistoryStore.listDevices();
+        const devices = ids.map((id) => ({ deviceId: id, latest: deviceHistoryStore.getLatest(id) }));
+        const result = { devices };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            structuredContent: result,
+        };
+    });
     // ---- send_command ---------------------------------------------------------
     server.registerTool('send_command', {
         title: 'Send a control command to a device',
@@ -350,7 +384,7 @@ API docs: https://github.com/OpenWonderLabs/SwitchBotAPI`,
             mqtt: z.object({
                 state: z.string(),
                 subscribers: z.number(),
-            }).optional().describe('MQTT connection state (HTTP mode only)'),
+            }).optional().describe('MQTT connection state (present when REST credentials are configured; auto-provisioned via POST /v1.1/iot/credential)'),
         },
     }, async () => {
         const deviceList = await fetchDeviceList();
@@ -398,7 +432,7 @@ API docs: https://github.com/OpenWonderLabs/SwitchBotAPI`,
         server.registerResource('events', 'switchbot://events', {
             title: 'SwitchBot real-time shadow events',
             description: 'Recent device shadow-update events received via MQTT. Returns a JSON snapshot of the ring buffer. ' +
-                'State is "disabled" when MQTT credentials are not configured (set SWITCHBOT_MQTT_HOST / USERNAME / PASSWORD).',
+                'State is "disabled" when REST credentials (SWITCHBOT_TOKEN + SWITCHBOT_SECRET) are not configured.',
             mimeType: 'application/json',
         }, (_uri) => {
             const state = eventManager.getState();
@@ -419,7 +453,7 @@ export function registerMcpCommand(program) {
         .command('mcp')
         .description('Run as a Model Context Protocol server so AI agents can call SwitchBot tools')
         .addHelpText('after', `
-The MCP server exposes seven tools over stdio:
+The MCP server exposes eight tools:
   - list_devices          fetch all physical + IR devices
   - get_device_status     live status for a physical device
   - send_command          control a device (destructive commands need confirm:true)
@@ -427,6 +461,12 @@ The MCP server exposes seven tools over stdio:
   - run_scene             execute a manual scene
   - search_catalog        offline catalog search by type/alias
   - describe_device       metadata + commands + (optionally) live status for one device
+  - account_overview      single cold-start snapshot: devices + scenes + quota + cache + MQTT state
+
+Resource (read-only):
+  - switchbot://events    snapshot of recent MQTT shadow events from the ring buffer
+    Auto-provisioned from SWITCHBOT_TOKEN + SWITCHBOT_SECRET;
+    returns {state:"disabled"} when credentials are not configured.
 
 Example Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
 
@@ -487,17 +527,17 @@ Inspect locally:
                 const { createServer } = await import('node:http');
                 const rateLimitMap = new Map();
                 // Initialize shared EventSubscriptionManager for event streaming.
-                // If MQTT creds are present, connect in the background so the HTTP server
-                // starts immediately; /ready reflects the real state.
+                // Credentials are auto-provisioned from the SwitchBot API using the
+                // account's token+secret — no extra MQTT env vars needed.
                 const eventManager = new EventSubscriptionManager();
-                const mqttConfig = getMqttConfig();
-                if (mqttConfig) {
-                    eventManager.initialize(mqttConfig).catch((err) => {
+                const mqttCreds = tryLoadConfig();
+                if (mqttCreds) {
+                    eventManager.initialize(mqttCreds.token, mqttCreds.secret).catch((err) => {
                         console.error('MQTT initialization failed:', err instanceof Error ? err.message : String(err));
                     });
                 }
                 else {
-                    console.error('MQTT disabled: set SWITCHBOT_MQTT_HOST, SWITCHBOT_MQTT_USERNAME, SWITCHBOT_MQTT_PASSWORD to enable real-time events.');
+                    console.error('MQTT disabled: credentials not configured.');
                 }
                 // Helper: constant-time token comparison
                 const tokenMatch = (provided) => {
@@ -691,7 +731,14 @@ process_uptime_seconds ${Math.floor(process.uptime())}
                 });
                 return;
             }
-            const server = createSwitchBotMcpServer();
+            const eventManager = new EventSubscriptionManager();
+            const mqttCreds = tryLoadConfig();
+            if (mqttCreds) {
+                eventManager.initialize(mqttCreds.token, mqttCreds.secret).catch((err) => {
+                    console.error('MQTT initialization failed:', err instanceof Error ? err.message : String(err));
+                });
+            }
+            const server = createSwitchBotMcpServer({ eventManager });
             const transport = new StdioServerTransport();
             await server.connect(transport);
         }

package/dist/commands/plan.js

@@ -210,10 +210,18 @@ Workflow:
             process.exit(2);
         }
         if (isJsonMode()) {
-            printJson({ valid: true, steps: result.plan.steps.length });
+            const out = { valid: true, steps: result.plan.steps.length };
+            if (result.plan.steps.length === 0)
+                out.warning = 'plan has no steps — nothing will execute';
+            printJson(out);
         }
         else {
-            console.log(`✓ plan valid (${result.plan.steps.length} step${result.plan.steps.length === 1 ? '' : 's'})`);
+            if (result.plan.steps.length === 0) {
+                console.log('✓ plan valid — but 0 steps: nothing will execute');
+            }
+            else {
+                console.log(`✓ plan valid (${result.plan.steps.length} step${result.plan.steps.length === 1 ? '' : 's'})`);
+            }
         }
     });
     plan

package/dist/commands/scenes.js

@@ -27,7 +27,7 @@ Examples:
                 printJson(scenes);
                 return;
             }
-            renderRows(['sceneId', 'sceneName'], scenes.map((s) => [s.sceneId, s.sceneName]), fmt, resolveFields());
+            renderRows(['sceneId', 'sceneName'], scenes.map((s) => [s.sceneId, s.sceneName]), fmt, resolveFields(), { id: 'sceneId', name: 'sceneName' });
             if (fmt === 'table' && scenes.length === 0) {
                 console.log('No scenes found');
             }

package/dist/commands/watch.js

@@ -3,6 +3,7 @@ import { fetchDeviceStatus } from '../lib/devices.js';
 import { getCachedDevice } from '../devices/cache.js';
 import { parseDurationToMs, getFields } from '../utils/flags.js';
 import { createClient } from '../api/client.js';
+import { resolveDeviceId } from '../utils/name-resolver.js';
 const DEFAULT_INTERVAL_MS = 30_000;
 const MIN_INTERVAL_MS = 1_000;
 function diff(prev, next, fields) {
@@ -55,7 +56,8 @@ export function registerWatchCommand(devices) {
     devices
         .command('watch')
         .description('Poll device status on an interval and emit field-level changes (JSONL)')
-        .argument('<deviceId...>', 'One or more deviceIds to watch')
+        .argument('[deviceId...]', 'One or more deviceIds to watch (or use --name for one device)')
+        .option('--name <query>', 'Resolve one device by fuzzy name (combined with any positional IDs)')
         .option('--interval <dur>', `Polling interval: "30s", "1m", "500ms", ... (default 30s, min ${MIN_INTERVAL_MS / 1000}s)`, '30s')
         .option('--max <n>', 'Stop after N ticks (default: run until Ctrl-C)')
         .option('--include-unchanged', 'Emit a tick even when no field changed')
@@ -71,9 +73,18 @@ Examples:
   $ switchbot devices watch ABC123 --fields battery,power --interval 1m
   $ switchbot devices watch ABC123 DEF456 --interval 30s --max 10
   $ switchbot devices watch ABC123 --json | jq 'select(.changed.power)'
+  $ switchbot devices watch --name "客厅空调" --interval 10s
 `)
         .action(async (deviceIds, options) => {
         try {
+            const allIds = [...deviceIds];
+            if (options.name) {
+                const resolved = resolveDeviceId(undefined, options.name);
+                if (!allIds.includes(resolved))
+                    allIds.push(resolved);
+            }
+            if (allIds.length === 0)
+                throw new UsageError('Provide at least one deviceId argument or --name.');
             const parsed = parseDurationToMs(options.interval);
             if (parsed === null || parsed < MIN_INTERVAL_MS) {
                 throw new UsageError(`Invalid --interval "${options.interval}". Minimum is ${MIN_INTERVAL_MS / 1000}s.`);
@@ -101,7 +112,7 @@ Examples:
                     const t = new Date().toISOString();
                     // Poll all devices in parallel; one failure per device doesn't stop
                     // the others.
-                    await Promise.all(deviceIds.map(async (id) => {
+                    await Promise.all(allIds.map(async (id) => {
                         const cached = getCachedDevice(id);
                         try {
                             const body = await fetchDeviceStatus(id, client);

package/dist/config.js

@@ -62,6 +62,29 @@ export function loadConfig() {
         process.exit(1);
     }
 }
+/**
+ * Like loadConfig but returns null instead of exiting. Use this in code paths
+ * that want graceful degradation (e.g. optional MQTT init in `mcp serve`).
+ */
+export function tryLoadConfig() {
+    const envToken = process.env.SWITCHBOT_TOKEN;
+    const envSecret = process.env.SWITCHBOT_SECRET;
+    if (envToken && envSecret)
+        return { token: envToken, secret: envSecret };
+    const file = configFilePath();
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        const cfg = JSON.parse(raw);
+        if (!cfg.token || !cfg.secret)
+            return null;
+        return cfg;
+    }
+    catch {
+        return null;
+    }
+}
 export function saveConfig(token, secret) {
     const file = configFilePath();
     const dir = path.dirname(file);

package/dist/index.js

@@ -37,7 +37,8 @@ program
     .option('--no-cache', 'Disable cache reads (equivalent to --cache off)')
     .option('--config <path>', 'Override credential file location (default: ~/.switchbot/config.json)')
     .option('--profile <name>', 'Use a named profile: ~/.switchbot/profiles/<name>.json')
-    .option('--audit-log [path]', 'Append every mutating command to JSONL audit log (default ~/.switchbot/audit.log)')
+    .option('--audit-log', 'Append every mutating command to JSONL audit log (default path: ~/.switchbot/audit.log)')
+    .option('--audit-log-path <path>', 'Custom audit log file path; use together with --audit-log')
     .showHelpAfterError('(run with --help to see usage)')
     .showSuggestionAfterError();
 registerConfigCommand(program);
@@ -68,9 +69,9 @@ Exit codes:
   2  usage error (bad flag, unknown subcommand, invalid argument, unknown device type)
 
 Environment:
-  SWITCHBOT_TOKEN   credential token (takes priority over config file)
-  SWITCHBOT_SECRET  credential secret (takes priority over config file)
-  NO_COLOR          disable ANSI colors (auto-respected via chalk)
+  SWITCHBOT_TOKEN          credential token (takes priority over config file)
+  SWITCHBOT_SECRET         credential secret (takes priority over config file)
+  NO_COLOR                 disable ANSI colors (auto-respected via chalk)
 
 Examples:
   $ switchbot config set-token <token> <secret>

package/dist/lib/devices.js

@@ -147,9 +147,13 @@ export function validateCommand(deviceId, cmd, parameter, commandType) {
     const spec = builtinCommands.find((c) => c.command === cmd);
     if (!spec) {
         const unique = [...new Set(builtinCommands.map((c) => c.command))];
+        const caseMatch = unique.find((c) => c.toLowerCase() === cmd.toLowerCase());
+        const hint = caseMatch
+            ? `Did you mean "${caseMatch}"? Supported commands: ${unique.join(', ')}`
+            : `Supported commands: ${unique.join(', ')}`;
         return {
             ok: false,
-            error: new CommandValidationError(`"${cmd}" is not a supported command for ${cached.name} (${cached.type}).`, 'unknown-command', `Supported commands: ${unique.join(', ')}`),
+            error: new CommandValidationError(`"${cmd}" is not a supported command for ${cached.name} (${cached.type}).`, 'unknown-command', hint),
         };
     }
     const noParamExpected = spec.parameter === '—';
@@ -160,6 +164,17 @@ export function validateCommand(deviceId, cmd, parameter, commandType) {
             error: new CommandValidationError(`"${cmd}" takes no parameter, but one was provided: "${parameter}".`, 'unexpected-parameter', `Try: switchbot devices command ${deviceId} ${cmd}`),
         };
     }
+    // Warn when a parameter is required but the user omitted it
+    const paramRequired = !noParamExpected && spec.parameter !== 'default';
+    if (paramRequired && !userProvidedParam) {
+        const example = spec.exampleParams?.[0];
+        return {
+            ok: false,
+            error: new CommandValidationError(`"${cmd}" requires a parameter (${spec.parameter}).`, 'missing-parameter', example
+                ? `Example: switchbot devices command <deviceId> ${cmd} "${example}"`
+                : `See: switchbot devices commands ${cached.type}`),
+        };
+    }
     return { ok: true };
 }
 /**

package/dist/mcp/device-history.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const MAX_HISTORY = 100;
+function historyDir() {
+    return path.join(os.homedir(), '.switchbot', 'device-history');
+}
+export class DeviceHistoryStore {
+    dir;
+    constructor() {
+        this.dir = historyDir();
+    }
+    record(deviceId, topic, deviceType, payload, t) {
+        try {
+            if (!fs.existsSync(this.dir))
+                fs.mkdirSync(this.dir, { recursive: true });
+            const file = path.join(this.dir, `${deviceId}.json`);
+            const existing = fs.existsSync(file)
+                ? JSON.parse(fs.readFileSync(file, 'utf-8'))
+                : { latest: null, history: [] };
+            const entry = { t: t ?? new Date().toISOString(), topic, deviceType, payload };
+            existing.latest = entry;
+            existing.history = [entry, ...existing.history].slice(0, MAX_HISTORY);
+            fs.writeFileSync(file, JSON.stringify(existing, null, 2), { mode: 0o600 });
+        }
+        catch {
+            // best-effort — history loss is non-fatal
+        }
+    }
+    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 [];
+            return fs.readdirSync(this.dir)
+                .filter((f) => f.endsWith('.json'))
+                .map((f) => f.slice(0, -5));
+        }
+        catch {
+            return [];
+        }
+    }
+}
+export const deviceHistoryStore = new DeviceHistoryStore();

package/dist/mcp/events-subscription.js

@@ -1,9 +1,11 @@
 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();
@@ -18,33 +20,34 @@ export class EventSubscriptionManager {
         this.mqttClient = mqttClient || null;
         this.getClient = getClient;
     }
-    async initialize(mqttConfig) {
+    async initialize(token, secret) {
         if (!this.mqttClient) {
-            const client = new SwitchBotMqttClient(mqttConfig, async () => {
-                // Auth refresh callback - would need credential resolution here
-                return {
-                    username: mqttConfig.username,
-                    password: mqttConfig.password,
-                };
-            });
+            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('$aws/things/+/shadow/update/accepted');
+                    client.subscribe(credential.topics.status);
                 }
             });
             client.onMessage((topic, payload) => {
                 try {
                     const data = JSON.parse(payload.toString());
-                    const deviceId = this.extractDeviceId(topic);
-                    if (deviceId && data.state) {
+                    // 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: data.state,
+                            payload: payloadData,
                             timestamp: Date.now(),
                         });
                     }

package/dist/mqtt/client.js

@@ -1,41 +1,53 @@
 import { connect } from 'mqtt';
 export class SwitchBotMqttClient {
     client = null;
-    config;
+    credential;
     state = 'connecting';
-    authRefreshNeeded = false;
+    credentialExpired = false;
     reconnectAttempts = 0;
     maxReconnectAttempts = 10;
+    disconnecting = false;
     handlers = new Set();
     messageHandlers = new Set();
-    authRefreshCallback;
-    stableTimer = null;
-    lastConnectionAttempt = 0;
-    constructor(config, onAuthRefreshNeeded) {
-        this.config = config;
-        this.authRefreshCallback = onAuthRefreshNeeded;
+    credentialRefreshCallback;
+    constructor(credential, onCredentialExpired) {
+        this.credential = credential;
+        this.credentialRefreshCallback = onCredentialExpired;
     }
     async connect() {
-        if (this.client && this.state === 'connected') {
+        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.authRefreshNeeded = false;
+        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 = {
-                username: this.config.username,
-                password: this.config.password,
+                clientId,
+                ca: tls.caBase64,
+                cert: tls.certBase64,
+                key: tls.keyBase64,
+                rejectUnauthorized: true,
                 clean: true,
-                reconnectPeriod: 0, // Manual reconnect control
-                connectTimeout: 10000,
-                rejectUnauthorized: this.config.rejectUnauthorized ?? true,
+                reconnectPeriod: 0,
+                connectTimeout: 30000,
+                keepalive: 60,
+                reschedulePings: true,
             };
-            this.client = connect(`mqtts://${this.config.host}:${this.config.port}`, options);
+            this.client = connect(brokerUrl, options);
             this.client.on('connect', () => {
                 this.reconnectAttempts = 0;
                 this.setState('connected');
-                this.authRefreshNeeded = false;
+                this.credentialExpired = false;
             });
             this.client.on('message', (topic, payload) => {
                 for (const handler of this.messageHandlers) {
@@ -43,18 +55,17 @@ export class SwitchBotMqttClient {
                 }
             });
             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;
+                if (err instanceof Error &&
+                    (err.message.includes('certificate') ||
+                        err.message.includes('ECONNRESET') ||
+                        err.message.includes('handshake'))) {
+                    this.credentialExpired = true;
                 }
             });
             this.client.on('close', () => {
-                this.clearStableTimer();
-                if (this.authRefreshNeeded) {
+                if (this.disconnecting)
+                    return;
+                if (this.credentialExpired) {
                     this.setState('failed');
                 }
                 else if (this.reconnectAttempts < this.maxReconnectAttempts) {
@@ -64,7 +75,6 @@ export class SwitchBotMqttClient {
                     this.setState('failed');
                 }
             });
-            // Wait for connection with timeout
             await new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
                     reject(new Error('MQTT connection timeout'));
@@ -97,26 +107,22 @@ export class SwitchBotMqttClient {
     async attemptReconnect() {
         this.reconnectAttempts++;
         this.setState('reconnecting');
-        if (this.authRefreshNeeded && this.authRefreshCallback) {
+        if (this.credentialExpired && this.credentialRefreshCallback) {
             try {
-                const refreshed = await this.authRefreshCallback();
-                this.config.username = refreshed.username;
-                this.config.password = refreshed.password;
-                this.authRefreshNeeded = false;
+                this.credential = await this.credentialRefreshCallback();
+                this.credentialExpired = false;
             }
-            catch (err) {
-                // Auth refresh failed, mark as failed
+            catch {
                 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) {
+        catch {
             if (this.reconnectAttempts < this.maxReconnectAttempts) {
                 await this.attemptReconnect();
             }
@@ -133,12 +139,6 @@ export class SwitchBotMqttClient {
             }
         }
     }
-    clearStableTimer() {
-        if (this.stableTimer) {
-            clearTimeout(this.stableTimer);
-            this.stableTimer = null;
-        }
-    }
     subscribe(topic) {
         if (this.client && this.state === 'connected') {
             this.client.subscribe(topic, (err) => {
@@ -167,18 +167,14 @@ export class SwitchBotMqttClient {
         return this.state === 'connected' && this.client?.connected === true;
     }
     async disconnect() {
-        this.clearStableTimer();
+        this.disconnecting = true;
         if (this.client) {
             await new Promise((resolve) => {
-                this.client?.end(false, () => {
-                    resolve();
-                });
+                this.client?.end(false, () => resolve());
             });
             this.client = null;
-            this.setState('failed');
         }
-    }
-    setAuthRefreshCallback(callback) {
-        this.authRefreshCallback = callback;
+        this.disconnecting = false;
+        this.setState('failed');
     }
 }