@switchbot/openapi-cli 2.2.0 → 2.3.0

package/dist/lib/devices.js

@@ -129,8 +129,10 @@ export async function executeCommand(deviceId, cmd, parameter, commandType, clie
 /**
  * Validate a command against the locally-cached device → catalog mapping.
  * Returns `{ ok: true }` when validation passes or is skipped (unknown device,
- * custom IR button, etc.); returns `{ ok: false, error }` when the caller
- * should refuse the call.
+ * custom IR button, etc.). On a case-only mismatch the canonical command name
+ * is returned via `normalized` along with a `caseNormalizedFrom` field so the
+ * caller can emit a warning and continue with the canonical name.
+ * Returns `{ ok: false, error }` only when the caller should refuse the call.
  */
 export function validateCommand(deviceId, cmd, parameter, commandType) {
     if (commandType === 'customize')
@@ -144,24 +146,34 @@ export function validateCommand(deviceId, cmd, parameter, commandType) {
     const builtinCommands = match.commands.filter((c) => c.commandType !== 'customize');
     if (builtinCommands.length === 0)
         return { ok: true };
-    const spec = builtinCommands.find((c) => c.command === cmd);
+    let spec = builtinCommands.find((c) => c.command === cmd);
+    let caseNormalizedFrom;
+    let normalizedCmd = 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', hint),
-        };
+        if (caseMatch) {
+            // Case-only mismatch: normalize and continue.
+            caseNormalizedFrom = cmd;
+            normalizedCmd = caseMatch;
+            spec = builtinCommands.find((c) => c.command === caseMatch);
+        }
+        else {
+            const hint = `Supported commands: ${unique.join(', ')}`;
+            return {
+                ok: false,
+                error: new CommandValidationError(`"${cmd}" is not a supported command for ${cached.name} (${cached.type}).`, 'unknown-command', hint),
+            };
+        }
     }
+    if (!spec)
+        return { ok: true, normalized: normalizedCmd, caseNormalizedFrom };
     const noParamExpected = spec.parameter === '—';
     const userProvidedParam = parameter !== undefined && parameter !== 'default';
     if (noParamExpected && userProvidedParam) {
         return {
             ok: false,
-            error: new CommandValidationError(`"${cmd}" takes no parameter, but one was provided: "${parameter}".`, 'unexpected-parameter', `Try: switchbot devices command ${deviceId} ${cmd}`),
+            error: new CommandValidationError(`"${normalizedCmd}" takes no parameter, but one was provided: "${parameter}".`, 'unexpected-parameter', `Try: switchbot devices command ${deviceId} ${normalizedCmd}`),
         };
     }
     // Warn when a parameter is required but the user omitted it
@@ -170,12 +182,12 @@ export function validateCommand(deviceId, cmd, parameter, commandType) {
         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}"`
+            error: new CommandValidationError(`"${normalizedCmd}" requires a parameter (${spec.parameter}).`, 'missing-parameter', example
+                ? `Example: switchbot devices command <deviceId> ${normalizedCmd} "${example}"`
                 : `See: switchbot devices commands ${cached.type}`),
         };
     }
-    return { ok: true };
+    return { ok: true, normalized: normalizedCmd, caseNormalizedFrom };
 }
 /**
  * Inspect catalog annotations to decide whether a command is destructive,

package/dist/utils/arg-parsers.js

@@ -0,0 +1,65 @@
+import { InvalidArgumentError } from 'commander';
+import { parseDurationToMs } from './flags.js';
+/**
+ * Commander argParser callbacks that fail fast when a required-value flag
+ * swallows the next token (another flag, a subcommand name, etc.) — the
+ * default Commander behavior is to take the next argv token verbatim.
+ *
+ * Use `--flag=<val>` form to pass values that legitimately start with `--`.
+ */
+export function intArg(flagName, opts) {
+    return (value) => {
+        // Flag-like tokens (`--something`, `-x`) are rejected up-front.
+        // Pure negative integers (`-1`, `-42`) fall through to min/max so the
+        // error classifies as a range error rather than "requires a numeric value".
+        if (value.startsWith('-') && !/^-\d+$/.test(value)) {
+            throw new InvalidArgumentError(`${flagName} requires a numeric value, got "${value}". ` +
+                `Did you forget a value? Use ${flagName}=<n> if the value really starts with "-".`);
+        }
+        const n = Number(value);
+        if (!Number.isInteger(n)) {
+            throw new InvalidArgumentError(`${flagName} must be an integer (got "${value}")`);
+        }
+        if (opts?.min !== undefined && n < opts.min) {
+            throw new InvalidArgumentError(`${flagName} must be >= ${opts.min} (got "${value}")`);
+        }
+        if (opts?.max !== undefined && n > opts.max) {
+            throw new InvalidArgumentError(`${flagName} must be <= ${opts.max} (got "${value}")`);
+        }
+        return String(n);
+    };
+}
+export function durationArg(flagName) {
+    return (value) => {
+        if (value.startsWith('-')) {
+            throw new InvalidArgumentError(`${flagName} requires a duration value, got "${value}". ` +
+                `Use ${flagName}=<dur> if the value really starts with "-".`);
+        }
+        const ms = parseDurationToMs(value);
+        if (ms === null) {
+            throw new InvalidArgumentError(`${flagName} must look like "30s", "1m", "500ms", "1h" (got "${value}")`);
+        }
+        return value;
+    };
+}
+export function stringArg(flagName, opts) {
+    return (value) => {
+        if (value.startsWith('--')) {
+            throw new InvalidArgumentError(`${flagName} requires a value. "${value}" looks like another option — ` +
+                `did you forget the value? Use ${flagName}=<val> if your value really starts with "--".`);
+        }
+        if (opts?.disallow?.includes(value)) {
+            throw new InvalidArgumentError(`${flagName} requires a value but got "${value}", which is a subcommand name. ` +
+                `Did you forget the value? Use ${flagName}=<val> or put ${flagName} after the subcommand.`);
+        }
+        return value;
+    };
+}
+export function enumArg(flagName, allowed) {
+    return (value) => {
+        if (!allowed.includes(value)) {
+            throw new InvalidArgumentError(`${flagName} must be one of: ${allowed.join(', ')} (got "${value}")`);
+        }
+        return value;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@switchbot/openapi-cli",
-  "version": "2.2.0",
+  "version": "2.3.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",