@switchbot/openapi-cli 2.5.0 → 2.6.0

package/dist/commands/config.js

@@ -4,7 +4,7 @@ import { execFileSync } from 'node:child_process';
 import { stringArg } from '../utils/arg-parsers.js';
 import { intArg } from '../utils/arg-parsers.js';
 import { saveConfig, showConfig, listProfiles, readProfileMeta } from '../config.js';
-import { isJsonMode, printJson } from '../utils/output.js';
+import { isJsonMode, printJson, emitJsonError } from '../utils/output.js';
 import chalk from 'chalk';
 function parseEnvFile(file) {
     const out = {};
@@ -147,7 +147,7 @@ Files are written with mode 0600. Profiles live under ~/.switchbot/profiles/<nam
             if (!fs.existsSync(options.fromEnvFile)) {
                 const msg = `--from-env-file: file not found: ${options.fromEnvFile}`;
                 if (isJsonMode()) {
-                    console.error(JSON.stringify({ error: { code: 2, kind: 'usage', message: msg } }));
+                    emitJsonError({ code: 2, kind: 'usage', message: msg });
                 }
                 else {
                     console.error(msg);
@@ -162,7 +162,7 @@ Files are written with mode 0600. Profiles live under ~/.switchbot/profiles/<nam
             if (!options.opSecret) {
                 const msg = '--from-op requires --op-secret <ref> for the secret reference.';
                 if (isJsonMode()) {
-                    console.error(JSON.stringify({ error: { code: 2, kind: 'usage', message: msg } }));
+                    emitJsonError({ code: 2, kind: 'usage', message: msg });
                 }
                 else {
                     console.error(msg);
@@ -176,7 +176,7 @@ Files are written with mode 0600. Profiles live under ~/.switchbot/profiles/<nam
             catch (err) {
                 const msg = `1Password CLI read failed: ${err instanceof Error ? err.message : String(err)}`;
                 if (isJsonMode()) {
-                    console.error(JSON.stringify({ error: { code: 1, kind: 'runtime', message: msg, hint: 'Ensure the "op" CLI is installed and authenticated (op signin).' } }));
+                    emitJsonError({ code: 1, kind: 'runtime', message: msg, hint: 'Ensure the "op" CLI is installed and authenticated (op signin).' });
                 }
                 else {
                     console.error(msg);
@@ -189,7 +189,7 @@ Files are written with mode 0600. Profiles live under ~/.switchbot/profiles/<nam
         if ((!token || !secret) && !options.fromEnvFile && !options.fromOp && process.stdin.isTTY) {
             if (isJsonMode()) {
                 const msg = 'Interactive mode cannot run under --json. Provide token/secret via --from-env-file, --from-op, or positional args.';
-                console.error(JSON.stringify({ error: { code: 2, kind: 'usage', message: msg } }));
+                emitJsonError({ code: 2, kind: 'usage', message: msg });
                 process.exit(2);
             }
             try {
@@ -206,7 +206,7 @@ Files are written with mode 0600. Profiles live under ~/.switchbot/profiles/<nam
         if (!token || !secret) {
             const msg = 'Missing token/secret. Run interactively, or use --from-env-file / --from-op, or pass positional arguments (discouraged).';
             if (isJsonMode()) {
-                console.error(JSON.stringify({ error: { code: 2, kind: 'usage', message: msg } }));
+                emitJsonError({ code: 2, kind: 'usage', message: msg });
             }
             else {
                 console.error(msg);

package/dist/commands/device-meta.js

@@ -1,6 +1,6 @@
 import { stringArg } from '../utils/arg-parsers.js';
 import { handleError, isJsonMode, printJson, printTable, UsageError } from '../utils/output.js';
-import { loadDeviceMeta, setDeviceMeta, clearDeviceMeta, getDeviceMeta, getMetaFilePath, } from '../devices/device-meta.js';
+import { loadDeviceMeta, saveDeviceMeta, setDeviceMeta, clearDeviceMeta, getDeviceMeta, getMetaFilePath, } from '../devices/device-meta.js';
 export function registerDevicesMetaCommand(devices) {
     const meta = devices
         .command('meta')
@@ -14,6 +14,7 @@ export function registerDevicesMetaCommand(devices) {
         .option('--hide', 'Hide this device from "devices list"')
         .option('--show', 'Un-hide this device')
         .option('--notes <text>', 'Freeform notes shown in "devices describe"', stringArg('--notes'))
+        .option('--force', 'Reassign alias even if it already belongs to another device')
         .action((deviceId, options) => {
         try {
             if (options.hide && options.show) {
@@ -22,6 +23,22 @@ export function registerDevicesMetaCommand(devices) {
             if (!options.alias && !options.hide && !options.show && !options.notes) {
                 throw new UsageError('Specify at least one of: --alias, --hide, --show, --notes');
             }
+            // Enforce alias uniqueness across devices
+            if (options.alias !== undefined) {
+                const meta = loadDeviceMeta();
+                const holder = Object.entries(meta.devices).find(([id, m]) => m.alias === options.alias && id !== deviceId);
+                if (holder) {
+                    if (!options.force) {
+                        throw new UsageError(`Alias "${options.alias}" is already assigned to device ${holder[0]}. Use --force to reassign.`);
+                    }
+                    // --force: clear the alias from the previous holder
+                    meta.devices[holder[0]] = { ...meta.devices[holder[0]], alias: undefined };
+                    saveDeviceMeta(meta);
+                    if (!isJsonMode()) {
+                        console.log(`(reassigned alias from ${holder[0]})`);
+                    }
+                }
+            }
             const patch = {};
             if (options.alias !== undefined)
                 patch.alias = options.alias;

package/dist/commands/devices.js

@@ -1,11 +1,12 @@
 import { enumArg, stringArg } from '../utils/arg-parsers.js';
-import { printTable, printKeyValue, printJson, isJsonMode, handleError, UsageError } from '../utils/output.js';
+import { printTable, printKeyValue, printJson, isJsonMode, handleError, UsageError, StructuredUsageError, emitJsonError } from '../utils/output.js';
 import { resolveFormat, resolveFields, renderRows } from '../utils/format.js';
 import { findCatalogEntry, getEffectiveCatalog } from '../devices/catalog.js';
-import { getCachedDevice } from '../devices/cache.js';
+import { getCachedDevice, loadCache } from '../devices/cache.js';
 import { loadDeviceMeta } from '../devices/device-meta.js';
-import { resolveDeviceId } from '../utils/name-resolver.js';
+import { resolveDeviceId, ALL_STRATEGIES } from '../utils/name-resolver.js';
 import { fetchDeviceList, fetchDeviceStatus, executeCommand, describeDevice, validateCommand, isDestructiveCommand, getDestructiveReason, buildHubLocationMap, DeviceNotFoundError, } from '../lib/devices.js';
+import { parseFilterExpr, matchClause, FilterSyntaxError } from '../utils/filter.js';
 import { validateParameter } from '../devices/param-validator.js';
 import { registerBatchCommand } from './batch.js';
 import { registerWatchCommand } from './watch.js';
@@ -13,6 +14,7 @@ import { registerExplainCommand } from './explain.js';
 import { registerExpandCommand } from './expand.js';
 import { registerDevicesMetaCommand } from './device-meta.js';
 import { isDryRun } from '../utils/flags.js';
+import { DryRunSignal } from '../api/client.js';
 export function registerDevicesCommand(program) {
     const COMMAND_TYPES = ['command', 'customize'];
     const devices = program
@@ -73,10 +75,12 @@ Examples:
   $ switchbot devices list --filter type="Air Conditioner"
   $ switchbot devices list --filter category=ir
   $ switchbot devices list --filter name=living,category=physical
+  $ switchbot devices list --filter 'name~living'              # explicit substring
+  $ switchbot devices list --filter 'type=/Air.*/'             # regex (case-insensitive)
 `)
         .option('--wide', 'Show all columns (controlType, family, roomID, room, hub, cloud)')
         .option('--show-hidden', 'Include devices hidden via "devices meta set --hide"')
-        .option('--filter <expr>', 'Filter devices: "type=X", "name=X", "category=physical|ir", "room=X" (comma-separated key=value pairs)', stringArg('--filter'))
+        .option('--filter <expr>', 'Filter devices: comma-separated clauses. Each clause is "key=value" (substring; exact for category), "key!=value" (negated substring), "key~value" (explicit substring), or "key=/regex/" (case-insensitive regex). Supported keys: type, name, category, room.', stringArg('--filter'))
         .action(async (options) => {
         try {
             const body = await fetchDeviceList();
@@ -84,36 +88,32 @@ Examples:
             const fmt = resolveFormat();
             const deviceMeta = loadDeviceMeta();
             const hubLocation = buildHubLocationMap(deviceList);
-            let listFilter = null;
+            // Parse --filter into a list of clauses. Shared grammar across
+            // `devices list`, `devices batch`, and `events tail` / `mqtt-tail`.
+            const LIST_KEYS = ['type', 'name', 'category', 'room'];
+            let listClauses = null;
             if (options.filter) {
-                listFilter = {};
-                for (const pair of options.filter.split(',')) {
-                    const eq = pair.indexOf('=');
-                    if (eq === -1)
-                        throw new UsageError(`Invalid --filter pair "${pair.trim()}". Expected key=value.`);
-                    const k = pair.slice(0, eq).trim();
-                    const v = pair.slice(eq + 1).trim();
-                    if (!['type', 'name', 'category', 'room'].includes(k)) {
-                        throw new UsageError(`Unknown --filter key "${k}". Supported: type, name, category, room.`);
-                    }
-                    listFilter[k] = v.toLowerCase();
+                try {
+                    listClauses = parseFilterExpr(options.filter, LIST_KEYS);
+                }
+                catch (err) {
+                    if (err instanceof FilterSyntaxError)
+                        throw new UsageError(err.message);
+                    throw err;
                 }
             }
             const matchesFilter = (entry) => {
-                if (!listFilter)
+                if (!listClauses || listClauses.length === 0)
                     return true;
-                if (listFilter.type && !entry.type.toLowerCase().includes(listFilter.type))
-                    return false;
-                if (listFilter.name && !entry.name.toLowerCase().includes(listFilter.name))
-                    return false;
-                if (listFilter.category && entry.category !== listFilter.category)
-                    return false;
-                if (listFilter.room && !entry.room.toLowerCase().includes(listFilter.room))
-                    return false;
+                for (const c of listClauses) {
+                    const fieldVal = entry[c.key] ?? '';
+                    if (!matchClause(fieldVal, c))
+                        return false;
+                }
                 return true;
             };
             if (fmt === 'json' && process.argv.includes('--json')) {
-                if (listFilter) {
+                if (listClauses) {
                     const filteredDeviceList = deviceList.filter((d) => matchesFilter({ type: d.deviceType || '', name: d.deviceName, category: 'physical', room: d.roomName || '' }));
                     const filteredIrList = infraredRemoteList.filter((d) => {
                         const inherited = hubLocation.get(d.hubDeviceId);
@@ -171,19 +171,19 @@ Examples:
                 ]);
             }
             if (rows.length === 0 && fmt === 'table') {
-                console.log(listFilter ? 'No devices matched the filter.' : 'No devices found');
+                console.log(listClauses ? 'No devices matched the filter.' : 'No devices found');
                 return;
             }
             const defaultFields = options.wide ? undefined : narrowHeaders;
             // Accept API field names and short aliases alongside canonical column names
             const DEVICE_LIST_ALIASES = {
-                name: 'deviceName', deviceType: 'type', type: 'type',
+                id: 'deviceId', name: 'deviceName', deviceType: 'type', type: 'type',
                 roomName: 'room', familyName: 'family',
                 hubDeviceId: 'hub', enableCloudService: 'cloud',
             };
             renderRows(wideHeaders, rows, fmt, userFields ?? defaultFields, DEVICE_LIST_ALIASES);
             if (fmt === 'table') {
-                const totalLabel = listFilter
+                const totalLabel = listClauses
                     ? `${rows.length} match(es) (${deviceList.length} physical + ${infraredRemoteList.length} IR before filter)`
                     : `${deviceList.length} physical device(s), ${infraredRemoteList.length} IR remote device(s)`;
                 console.log(`\nTotal: ${totalLabel}`);
@@ -200,7 +200,7 @@ Examples:
         .description('Query the real-time status of a specific device')
         .argument('[deviceId]', 'Device ID from "devices list" (or use --name or --ids)')
         .option('--name <query>', 'Resolve device by fuzzy name instead of deviceId', stringArg('--name'))
-        .option('--name-strategy <s>', 'Name match strategy: exact|prefix|substring|fuzzy|first|require-unique (default: fuzzy)', stringArg('--name-strategy'))
+        .option('--name-strategy <s>', `Name match strategy: ${ALL_STRATEGIES.join('|')} (default: fuzzy)`, stringArg('--name-strategy'))
         .option('--name-type <type>', 'Narrow --name by device type (e.g. "Bot", "Color Bulb")', stringArg('--name-type'))
         .option('--name-category <cat>', 'Narrow --name by category: physical|ir', enumArg('--name-category', ['physical', 'ir']))
         .option('--name-room <room>', 'Narrow --name by room name (substring match)', stringArg('--name-room'))
@@ -299,14 +299,17 @@ Examples:
         .description('Send a control command to a device')
         .argument('[deviceId]', 'Target device ID (or use --name)')
         .argument('[cmd]', 'Command name, e.g. turnOn, turnOff, setColor, setBrightness, setAll, startClean')
-        .argument('[parameter]', 'Command parameter. Omit for commands like turnOn/turnOff (defaults to "default"). Format depends on the command (see below).')
+        .argument('[parameter]', 'Command parameter. Omit for commands like turnOn/turnOff (defaults to "default"). Format depends on the command (see below). Negative numbers like -1 are accepted as-is (use `--` before them only if Commander mis-parses in your shell).')
+        .allowUnknownOption()
         .option('--name <query>', 'Resolve device by fuzzy name instead of deviceId', stringArg('--name'))
-        .option('--name-strategy <s>', 'Name match strategy: exact|prefix|substring|fuzzy|first|require-unique (default for command: require-unique)', stringArg('--name-strategy'))
+        .option('--name-strategy <s>', `Name match strategy: ${ALL_STRATEGIES.join('|')} (default for command: require-unique)`, stringArg('--name-strategy'))
         .option('--name-type <type>', 'Narrow --name by device type (e.g. "Bot", "Color Bulb")', stringArg('--name-type'))
         .option('--name-category <cat>', 'Narrow --name by category: physical|ir', enumArg('--name-category', ['physical', 'ir']))
         .option('--name-room <room>', 'Narrow --name by room name (substring match)', stringArg('--name-room'))
         .option('--type <commandType>', 'Command type: "command" for built-in commands (default), "customize" for user-defined IR buttons', enumArg('--type', COMMAND_TYPES), 'command')
         .option('--yes', 'Confirm a destructive command (Smart Lock unlock, Garage open, …). --dry-run is always allowed without --yes.')
+        .option('--allow-unknown-device', 'Allow targeting a deviceId that is not in the local cache. By default unknown IDs exit 2 so --dry-run is a reliable pre-flight gate; use this flag for scripted pass-through.')
+        .option('--skip-param-validation', 'Skip client-side parameter validation (escape hatch — prefer fixing the argument over using this).')
         .option('--idempotency-key <key>', 'Client-supplied key to dedupe retries. process-local 60s window; cache is per Node process (MCP session, batch run, plan run). Independent CLI invocations do not share cache.', stringArg('--idempotency-key'))
         .addHelpText('after', `
 ────────────────────────────────────────────────────────────────────────
@@ -354,6 +357,10 @@ Examples:
   $ switchbot devices command <lockId> unlock --yes
 `)
         .action(async (deviceIdArg, cmdArg, parameter, options) => {
+        // Declared outside try so the DryRunSignal catch branch can reference them.
+        let _deviceId;
+        let _cmd;
+        let _parsedParam;
         try {
             // BUG-FIX: When --name is provided, Commander fills positionals left-to-right
             // starting at [deviceId]. Shift them back to their semantic slots.
@@ -387,8 +394,28 @@ Examples:
                 category: options.nameCategory,
                 room: options.nameRoom,
             });
+            _deviceId = deviceId;
             if (!getCachedDevice(deviceId)) {
-                console.error(`Note: device ${deviceId} is not in the local cache — run 'switchbot devices list' first to enable command validation.`);
+                if (options.allowUnknownDevice) {
+                    console.error(`Note: device ${deviceId} is not in the local cache — run 'switchbot devices list' first to enable command validation. (--allow-unknown-device is set, continuing.)`);
+                }
+                else {
+                    const cache = loadCache();
+                    const allIds = cache ? Object.keys(cache.devices) : [];
+                    const candidates = allIds
+                        .filter((id) => id.toLowerCase().includes(deviceId.toLowerCase()) || id.startsWith(deviceId.slice(0, 4)))
+                        .slice(0, 5)
+                        .map((id) => {
+                        const dev = cache.devices[id];
+                        return { deviceId: id, name: dev.name, type: dev.type };
+                    });
+                    throw new StructuredUsageError(`Unknown deviceId "${deviceId}" — not in local cache. Run 'switchbot devices list' first, or pass --allow-unknown-device to bypass this check.`, {
+                        error: 'unknown_device_id',
+                        deviceId,
+                        candidates,
+                        hint: `Pass --allow-unknown-device to skip this check (and rely on the API for validation).`,
+                    });
+                }
             }
             const validation = validateCommand(deviceId, cmd, parameter, options.type);
             if (!validation.ok) {
@@ -398,7 +425,7 @@ Examples:
                     if (err.hint)
                         obj.hint = err.hint;
                     obj.context = { validationKind: err.kind };
-                    console.error(JSON.stringify({ error: obj }));
+                    emitJsonError(obj);
                 }
                 else {
                     console.error(`Error: ${err.message}`);
@@ -424,18 +451,16 @@ Examples:
             }
             // Raw-parameter validation (runs for known (deviceType, command) pairs only).
             const cachedForParam = getCachedDevice(deviceId);
-            if (cachedForParam && options.type === 'command') {
+            if (cachedForParam && options.type === 'command' && !options.skipParamValidation) {
                 const paramCheck = validateParameter(cachedForParam.type, cmd, parameter);
                 if (!paramCheck.ok) {
                     if (isJsonMode()) {
-                        console.error(JSON.stringify({
-                            error: {
-                                code: 2,
-                                kind: 'usage',
-                                message: paramCheck.error,
-                                context: { command: cmd, deviceType: cachedForParam.type, deviceId },
-                            },
-                        }));
+                        emitJsonError({
+                            code: 2,
+                            kind: 'usage',
+                            message: paramCheck.error,
+                            context: { command: cmd, deviceType: cachedForParam.type, deviceId, humanHint: paramCheck.error },
+                        });
                     }
                     else {
                         console.error(`Error: ${paramCheck.error}`);
@@ -452,17 +477,15 @@ Examples:
                 const typeLabel = cachedForGuard?.type ?? 'unknown';
                 const reason = getDestructiveReason(cachedForGuard?.type, cmd, options.type);
                 if (isJsonMode()) {
-                    console.error(JSON.stringify({
-                        error: {
-                            code: 2,
-                            kind: 'guard',
-                            message: `"${cmd}" on ${typeLabel} is destructive and requires --yes.`,
-                            hint: reason
-                                ? `Re-run with --yes to confirm. Reason: ${reason}`
-                                : 'Re-run with --yes to confirm, or --dry-run to preview without sending.',
-                            context: { command: cmd, deviceType: typeLabel, deviceId, ...(reason ? { destructiveReason: reason } : {}) },
-                        },
-                    }));
+                    emitJsonError({
+                        code: 2,
+                        kind: 'guard',
+                        message: `"${cmd}" on ${typeLabel} is destructive and requires --yes.`,
+                        hint: reason
+                            ? `Re-run with --yes to confirm. Reason: ${reason}`
+                            : 'Re-run with --yes to confirm, or --dry-run to preview without sending.',
+                        context: { command: cmd, deviceType: typeLabel, deviceId, ...(reason ? { destructiveReason: reason } : {}) },
+                    });
                 }
                 else {
                     console.error(`Refusing to run destructive command "${cmd}" on ${typeLabel} without --yes.`);
@@ -486,6 +509,9 @@ Examples:
                     // keep as string
                 }
             }
+            // Capture for DryRunSignal catch branch (which runs after executeCommand throws).
+            _cmd = cmd;
+            _parsedParam = parsedParam;
             const body = await executeCommand(deviceId, cmd, parsedParam, options.type, undefined, { idempotencyKey: options.idempotencyKey });
             const isIr = getCachedDevice(deviceId)?.category === 'ir';
             const verification = isIr
@@ -523,6 +549,17 @@ Examples:
             // Error('__exit__')) so they aren't double-handled and the exit code is preserved.
             if (error instanceof Error && error.message === '__exit__')
                 throw error;
+            if (error instanceof DryRunSignal) {
+                const commandType = (options.type ?? 'command');
+                const wouldSend = { deviceId: _deviceId, command: _cmd, parameter: _parsedParam, commandType };
+                if (isJsonMode()) {
+                    printJson({ dryRun: true, wouldSend });
+                }
+                else {
+                    console.log(`[dry-run] Would POST devices/${_deviceId}/commands with ${JSON.stringify({ command: _cmd, parameter: _parsedParam, commandType })}`);
+                }
+                return;
+            }
             handleError(error);
         }
     });
@@ -584,21 +621,52 @@ Examples:
   $ switchbot devices commands Robot --json
 `)
         .action((typeParts) => {
-        const type = typeParts.join(' ');
         try {
-            const match = findCatalogEntry(type);
-            if (!match) {
-                throw new UsageError(`No device type matches "${type}". Try 'switchbot devices types' to see the full list.`);
+            // First try the joined form so legacy multi-word unquoted input still
+            // works (`devices commands Air Conditioner` → "Air Conditioner"). If
+            // that doesn't match and every individual token resolves on its own,
+            // treat it as variadic and emit a section per type.
+            const joined = typeParts.join(' ');
+            const joinedMatch = findCatalogEntry(joined);
+            if (joinedMatch && !Array.isArray(joinedMatch)) {
+                if (isJsonMode()) {
+                    printJson(joinedMatch);
+                }
+                else {
+                    renderCatalogEntry(joinedMatch);
+                }
+                return;
             }
-            if (Array.isArray(match)) {
-                const types = match.map((m) => m.type).join(', ');
-                throw new UsageError(`"${type}" matches multiple types: ${types}. Be more specific.`);
+            if (typeParts.length > 1) {
+                const individualMatches = [];
+                for (const t of typeParts) {
+                    const m = findCatalogEntry(t);
+                    if (!m || Array.isArray(m)) {
+                        individualMatches.length = 0;
+                        break;
+                    }
+                    individualMatches.push(m);
+                }
+                if (individualMatches.length === typeParts.length) {
+                    if (isJsonMode()) {
+                        printJson(individualMatches);
+                    }
+                    else {
+                        individualMatches.forEach((entry, i) => {
+                            if (i > 0)
+                                console.log('');
+                            renderCatalogEntry(entry);
+                        });
+                    }
+                    return;
+                }
             }
-            if (isJsonMode()) {
-                printJson(match);
-                return;
+            if (!joinedMatch) {
+                throw new UsageError(`No device type matches "${joined}". Try 'switchbot devices types' to see the full list.`);
             }
-            renderCatalogEntry(match);
+            // joinedMatch is an ambiguous-match array here
+            const types = joinedMatch.map((m) => m.type).join(', ');
+            throw new UsageError(`"${joined}" matches multiple types: ${types}. Be more specific.`);
         }
         catch (error) {
             handleError(error);
@@ -610,7 +678,7 @@ Examples:
         .description('Describe a device by ID: metadata + supported commands + status fields (1 API call)')
         .argument('[deviceId]', 'Target device ID (or use --name)')
         .option('--name <query>', 'Resolve device by fuzzy name instead of deviceId', stringArg('--name'))
-        .option('--name-strategy <s>', 'Name match strategy: exact|prefix|substring|fuzzy|first|require-unique (default: fuzzy)', stringArg('--name-strategy'))
+        .option('--name-strategy <s>', `Name match strategy: ${ALL_STRATEGIES.join('|')} (default: fuzzy)`, stringArg('--name-strategy'))
         .option('--name-type <type>', 'Narrow --name by device type', stringArg('--name-type'))
         .option('--name-category <cat>', 'Narrow --name by category: physical|ir', enumArg('--name-category', ['physical', 'ir']))
         .option('--name-room <room>', 'Narrow --name by room name (substring match)', stringArg('--name-room'))
@@ -716,8 +784,20 @@ Examples:
         }
         catch (error) {
             if (error instanceof DeviceNotFoundError) {
-                console.error(error.message);
-                console.error(`Try 'switchbot devices list' to see the full list.`);
+                const message = `${error.message} Try 'switchbot devices list' to see the full list.`;
+                if (isJsonMode()) {
+                    emitJsonError({
+                        code: 1,
+                        kind: 'runtime',
+                        message,
+                        errorClass: 'runtime',
+                        transient: false,
+                    });
+                }
+                else {
+                    console.error(error.message);
+                    console.error(`Try 'switchbot devices list' to see the full list.`);
+                }
                 process.exit(1);
             }
             handleError(error);