@switchbot/openapi-cli 2.0.1 → 2.2.0

package/dist/mqtt/credential.js

@@ -1,12 +1,30 @@
-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 };
+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/sinks/dispatcher.js

@@ -0,0 +1,12 @@
+export class SinkDispatcher {
+    sinks;
+    constructor(sinks) {
+        this.sinks = sinks;
+    }
+    async dispatch(event) {
+        await Promise.allSettled(this.sinks.map((s) => s.write(event)));
+    }
+    async close() {
+        await Promise.allSettled(this.sinks.map((s) => s.close?.()));
+    }
+}

package/dist/sinks/file.js

@@ -0,0 +1,19 @@
+import fs from 'node:fs';
+import path from 'node:path';
+export class FileSink {
+    filePath;
+    constructor(filePath) {
+        this.filePath = path.resolve(filePath);
+        const dir = path.dirname(this.filePath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true });
+    }
+    async write(event) {
+        try {
+            fs.appendFileSync(this.filePath, JSON.stringify(event) + '\n', { encoding: 'utf-8' });
+        }
+        catch {
+            // best-effort
+        }
+    }
+}

package/dist/sinks/format.js

@@ -0,0 +1,56 @@
+const ICONS = {
+    'Bot': '🤖',
+    'Curtain': '🪟',
+    'Hub': '📡',
+    'Hub 2': '📡',
+    'Hub 3': '📡',
+    'Hub Mini': '📡',
+    'Smart Lock': '🔒',
+    'Smart Lock Pro': '🔒',
+    'Plug': '🔌',
+    'Plug Mini (US)': '🔌',
+    'Plug Mini (JP)': '🔌',
+    'Color Bulb': '💡',
+    'Strip Light': '💡',
+    'Contact Sensor': '🚪',
+    'Motion Sensor': '👁',
+    'Meter': '🌡',
+    'MeterPro': '🌡',
+    'Climate Panel': '🌡',
+    'WoMeter': '🌡',
+    'WoIOSensor': '🌡',
+};
+function icon(deviceType) {
+    return ICONS[deviceType] ?? '📱';
+}
+export function formatEventText(context) {
+    const type = context.deviceType ?? 'Unknown';
+    const pfx = `${icon(type)} ${type}`;
+    const parts = [];
+    if (context.temperature !== undefined)
+        parts.push(`${context.temperature}°C`);
+    if (context.humidity !== undefined)
+        parts.push(`${context.humidity}%`);
+    if (parts.length)
+        return `${pfx}: ${parts.join(' / ')}`;
+    if (context.power !== undefined)
+        return `${pfx}: ${context.power}`;
+    if (context.lockState !== undefined)
+        return `${pfx}: ${context.lockState}`;
+    if (context.openState !== undefined)
+        return `${pfx}: ${context.openState}`;
+    if (context.detectionState !== undefined)
+        return `${pfx}: ${context.detectionState}`;
+    if (context.brightness !== undefined)
+        return `${pfx}: ${context.brightness}`;
+    return `${pfx}: state change`;
+}
+export function parseSinkEvent(payload) {
+    const p = payload;
+    const context = (p?.context ?? {});
+    return {
+        deviceId: String(context.deviceMac ?? 'unknown'),
+        deviceType: String(context.deviceType ?? 'Unknown'),
+        text: formatEventText(context),
+    };
+}

package/dist/sinks/homeassistant.js

@@ -0,0 +1,44 @@
+export class HomeAssistantSink {
+    url;
+    token;
+    webhookId;
+    eventType;
+    constructor(opts) {
+        this.url = opts.url.replace(/\/$/, '');
+        this.token = opts.token;
+        this.webhookId = opts.webhookId;
+        this.eventType = opts.eventType ?? 'switchbot_event';
+    }
+    async write(event) {
+        try {
+            let endpoint;
+            const headers = { 'content-type': 'application/json' };
+            if (this.webhookId) {
+                // Webhook mode: no auth needed, HA triggers automations directly
+                endpoint = `${this.url}/api/webhook/${this.webhookId}`;
+            }
+            else if (this.token) {
+                // REST event API: fires a custom event on the HA event bus
+                endpoint = `${this.url}/api/events/${this.eventType}`;
+                headers['authorization'] = `Bearer ${this.token}`;
+            }
+            else {
+                console.error('[homeassistant] requires --ha-webhook-id or --ha-token');
+                return;
+            }
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                headers,
+                body: JSON.stringify(event),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                console.error(`[homeassistant] POST failed: HTTP ${res.status} ${body.slice(0, 200)}`);
+            }
+        }
+        catch (err) {
+            console.error(`[homeassistant] error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/sinks/openclaw.js

@@ -0,0 +1,33 @@
+export class OpenClawSink {
+    url;
+    token;
+    model;
+    constructor(opts) {
+        this.url = (opts.url ?? 'http://localhost:18789').replace(/\/$/, '');
+        this.token = opts.token;
+        this.model = opts.model;
+    }
+    async write(event) {
+        try {
+            const res = await fetch(`${this.url}/v1/chat/completions`, {
+                method: 'POST',
+                headers: {
+                    'content-type': 'application/json',
+                    'authorization': `Bearer ${this.token}`,
+                },
+                body: JSON.stringify({
+                    model: this.model,
+                    messages: [{ role: 'user', content: event.text }],
+                }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                console.error(`[openclaw] POST failed: HTTP ${res.status} ${body.slice(0, 200)}`);
+            }
+        }
+        catch (err) {
+            console.error(`[openclaw] error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/sinks/stdout.js

@@ -0,0 +1,5 @@
+export class StdoutSink {
+    async write(event) {
+        console.log(JSON.stringify(event));
+    }
+}

package/dist/sinks/telegram.js

@@ -0,0 +1,28 @@
+export class TelegramSink {
+    token;
+    chatId;
+    constructor(opts) {
+        this.token = opts.token;
+        this.chatId = opts.chatId;
+    }
+    async write(event) {
+        try {
+            const res = await fetch(`https://api.telegram.org/bot${this.token}/sendMessage`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    chat_id: this.chatId,
+                    text: event.text,
+                }),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                const body = await res.text().catch(() => '');
+                console.error(`[telegram] POST failed: HTTP ${res.status} ${body.slice(0, 200)}`);
+            }
+        }
+        catch (err) {
+            console.error(`[telegram] error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/sinks/types.js

@@ -0,0 +1 @@
+export {};

package/dist/sinks/webhook.js

@@ -0,0 +1,22 @@
+export class WebhookSink {
+    url;
+    constructor(url) {
+        this.url = url;
+    }
+    async write(event) {
+        try {
+            const res = await fetch(this.url, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify(event),
+                signal: AbortSignal.timeout(10000),
+            });
+            if (!res.ok) {
+                console.error(`[webhook] POST failed: HTTP ${res.status}`);
+            }
+        }
+        catch (err) {
+            console.error(`[webhook] error: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+}

package/dist/utils/flags.js

@@ -17,7 +17,7 @@ export function isVerbose() {
 export function isDryRun() {
     return process.argv.includes('--dry-run');
 }
-/** HTTP request timeout in milliseconds. Default 30s. */
+/** HTTP request timeout in milliseconds. Default 30s. Minimum 100ms (values below 100ms are ignored). */
 export function getTimeout() {
     const v = getFlagValue('--timeout');
     if (!v)
@@ -25,6 +25,10 @@ export function getTimeout() {
     const n = Number(v);
     if (!Number.isFinite(n) || n <= 0)
         return 30_000;
+    if (n < 100) {
+        process.stderr.write(`Warning: --timeout ${n}ms is too low to complete any request; using 100ms minimum.\n`);
+        return 100;
+    }
     return n;
 }
 /** Override for the credentials file path. */
@@ -36,20 +40,17 @@ export function getProfile() {
     return getFlagValue('--profile');
 }
 /**
- * Audit log path. `--audit-log <path>` enables JSONL append on every mutating
- * command; default path is ~/.switchbot/audit.log when `--audit-log` is given
- * without a value. Returns null when the flag is absent.
+ * Audit log path. `--audit-log` enables JSONL append on every mutating command.
+ * Use `--audit-log-path <path>` to specify a custom file; otherwise defaults to
+ * ~/.switchbot/audit.log. Returns null when --audit-log is absent.
  */
 export function getAuditLog() {
-    const idx = process.argv.indexOf('--audit-log');
-    if (idx === -1)
+    if (!process.argv.includes('--audit-log'))
         return null;
-    const next = process.argv[idx + 1];
-    if (!next || next.startsWith('-')) {
-        // bare --audit-log → default location
-        return `${process.env.HOME ?? process.env.USERPROFILE ?? '.'}/.switchbot/audit.log`;
-    }
-    return next;
+    const customPath = getFlagValue('--audit-log-path');
+    if (customPath)
+        return customPath;
+    return `${process.env.HOME ?? process.env.USERPROFILE ?? '.'}/.switchbot/audit.log`;
 }
 /**
  * Max 429 retries before surfacing the error. Default 3. `--no-retry`

package/dist/utils/format.js

@@ -32,15 +32,16 @@ export function resolveFormat() {
 export function resolveFields() {
     return getFields();
 }
-export function filterFields(headers, rows, fields) {
+export function filterFields(headers, rows, fields, aliases) {
     if (!fields || fields.length === 0)
         return { headers, rows };
-    const unknown = fields.filter((f) => !headers.includes(f));
+    const resolved = aliases ? fields.map((f) => aliases[f] ?? f) : fields;
+    const unknown = fields.filter((_, i) => !headers.includes(resolved[i]));
     if (unknown.length > 0) {
         throw new UsageError(`Unknown field(s): ${unknown.map((f) => `"${f}"`).join(', ')}. ` +
             `Allowed: ${headers.map((f) => `"${f}"`).join(', ')}.`);
     }
-    const indices = fields.map((f) => headers.indexOf(f));
+    const indices = resolved.map((f) => headers.indexOf(f));
     return {
         headers: indices.map((i) => headers[i]),
         rows: rows.map((row) => indices.map((i) => row[i])),
@@ -62,8 +63,8 @@ function rowToObject(headers, row) {
     }
     return obj;
 }
-export function renderRows(headers, rows, format, fields) {
-    const filtered = filterFields(headers, rows, fields);
+export function renderRows(headers, rows, format, fields, aliases) {
+    const filtered = filterFields(headers, rows, fields, aliases);
     const h = filtered.headers;
     const r = filtered.rows;
     switch (format) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@switchbot/openapi-cli",
-  "version": "2.0.1",
-  "description": "Command-line interface for SwitchBot API v1.1",
+  "version": "2.2.0",
+  "description": "SwitchBot smart home CLI — control devices, run scenes, stream real-time events, and integrate AI agents via MCP. Full API v1.1 coverage.",
   "keywords": [
     "switchbot",
     "cli",