@switchbot/openapi-cli 2.3.0 → 2.4.0

package/dist/commands/schema.js

@@ -1,6 +1,7 @@
 import { enumArg, stringArg } from '../utils/arg-parsers.js';
 import { printJson } from '../utils/output.js';
 import { getEffectiveCatalog } from '../devices/catalog.js';
+import { loadCache } from '../devices/cache.js';
 function toSchemaEntry(e) {
     return {
         type: e.type,
@@ -24,6 +25,30 @@ function toSchemaCommand(c) {
         ...(c.exampleParams ? { exampleParams: c.exampleParams } : {}),
     };
 }
+function toCompactEntry(e) {
+    return {
+        type: e.type,
+        category: e.category,
+        role: e.role ?? null,
+        readOnly: e.readOnly ?? false,
+        commands: e.commands.map((c) => ({
+            command: c.command,
+            parameter: c.parameter,
+            commandType: (c.commandType ?? 'command'),
+            idempotent: Boolean(c.idempotent),
+            destructive: Boolean(c.destructive),
+        })),
+        statusFields: e.statusFields ?? [],
+    };
+}
+function projectFields(entry, fields) {
+    const out = {};
+    for (const f of fields) {
+        if (f in entry)
+            out[f] = entry[f];
+    }
+    return out;
+}
 export function registerSchemaCommand(program) {
     const ROLES = ['lighting', 'security', 'sensor', 'climate', 'media', 'cleaning', 'curtain', 'fan', 'power', 'hub', 'other'];
     const CATEGORIES = ['physical', 'ir'];
@@ -32,20 +57,41 @@ export function registerSchemaCommand(program) {
         .description('Export the device catalog as structured JSON (for agent prompts / tooling)');
     schema
         .command('export')
-        .description('Print the full catalog as structured JSON (one object per type)')
+        .description('Print the catalog as structured JSON (one object per type)')
         .option('--type <type>', 'Restrict to a single device type (e.g. "Strip Light")', stringArg('--type'))
+        .option('--types <csv>', 'Restrict to multiple device types (comma-separated)', stringArg('--types'))
         .option('--role <role>', 'Restrict to a functional role: lighting, security, sensor, climate, media, cleaning, curtain, fan, power, hub, other', enumArg('--role', ROLES))
         .option('--category <cat>', 'Restrict to "physical" or "ir"', enumArg('--category', CATEGORIES))
+        .option('--compact', 'Drop descriptions/aliases/example params — emit ~60% smaller payload. Useful for agent prompts.')
+        .option('--used', 'Restrict to device types present in the local devices cache (run "devices list" first)')
+        .option('--project <csv>', 'Project per-type fields (e.g. --project type,commands,statusFields)', stringArg('--project'))
         .addHelpText('after', `
 Output is always JSON (this command ignores --format). The output is a
 catalog export — not a formal JSON Schema standard document — suitable for
 pre-baking LLM prompts or regenerating docs when the catalog changes.
 
+Size tips:
+  --compact --used          Smallest realistic payload for a given account
+                            (< 15 KB on most accounts).
+  --fields type,commands    Strip statusFields / role / etc. when only
+                            commands are needed.
+  --type + --compact        Inspect one type with minimum footprint.
+
+Common top-level fields:
+  schemaVersion             CLI schema version (stable for agent contracts)
+  data.version              Catalog schema version
+  data.types                Array of SchemaEntry (or CompactSchemaEntry with --compact)
+  data._fetchedAt           CLI-added; present on live-query responses ('devices status'),
+                            not on this offline export.
+
 Examples:
   $ switchbot schema export > catalog.json
-  $ switchbot schema export --type Bot | jq '.types[0].commands'
-  $ switchbot schema export --role lighting | jq '[.types[].type]'
+  $ switchbot schema export --compact --used | wc -c   # small prompt-ready payload
+  $ switchbot schema export --type Bot | jq '.data.types[0].commands'
+  $ switchbot schema export --types "Bot,Curtain,Color Bulb"
+  $ switchbot schema export --role lighting | jq '[.data.types[].type]'
   $ switchbot schema export --role security --category physical
+  $ switchbot schema export --project type,commands,statusFields
 `)
         .action((options) => {
         const catalog = getEffectiveCatalog();
@@ -55,6 +101,11 @@ Examples:
             filtered = filtered.filter((e) => e.type.toLowerCase() === q ||
                 (e.aliases ?? []).some((a) => a.toLowerCase() === q));
         }
+        if (options.types) {
+            const set = new Set(options.types.split(',').map((s) => s.trim().toLowerCase()).filter(Boolean));
+            filtered = filtered.filter((e) => set.has(e.type.toLowerCase()) ||
+                (e.aliases ?? []).some((a) => set.has(a.toLowerCase())));
+        }
         if (options.role) {
             const q = options.role.toLowerCase();
             filtered = filtered.filter((e) => (e.role ?? 'other') === q);
@@ -63,11 +114,50 @@ Examples:
             const q = options.category.toLowerCase();
             filtered = filtered.filter((e) => e.category === q);
         }
+        if (options.used) {
+            const cache = loadCache();
+            if (cache) {
+                const usedTypes = new Set(Object.values(cache.devices).map((d) => d.type.toLowerCase()));
+                filtered = filtered.filter((e) => usedTypes.has(e.type.toLowerCase()) ||
+                    (e.aliases ?? []).some((a) => usedTypes.has(a.toLowerCase())));
+            }
+            else {
+                filtered = [];
+            }
+        }
+        const mapped = options.compact
+            ? filtered.map(toCompactEntry)
+            : filtered.map(toSchemaEntry);
+        const projected = options.project
+            ? mapped.map((e) => projectFields(e, options.project.split(',').map((s) => s.trim()).filter(Boolean)))
+            : mapped;
         const payload = {
             version: '1.0',
-            generatedAt: new Date().toISOString(),
-            types: filtered.map(toSchemaEntry),
+            types: projected,
         };
+        if (!options.compact) {
+            payload.generatedAt = new Date().toISOString();
+            payload.cliAddedFields = [
+                {
+                    field: '_fetchedAt',
+                    appliesTo: ['devices status', 'devices describe'],
+                    type: 'string (ISO-8601)',
+                    description: 'CLI-synthesized timestamp indicating when this status response was fetched or served from the cache. Not part of the upstream SwitchBot API.',
+                },
+                {
+                    field: 'replayed',
+                    appliesTo: ['devices command (with --idempotency-key)'],
+                    type: 'boolean',
+                    description: 'CLI-synthesized flag — true when the response was served from the idempotency cache instead of re-executing the command.',
+                },
+                {
+                    field: 'verification',
+                    appliesTo: ['devices command'],
+                    type: 'object',
+                    description: 'CLI-synthesized receipt-acknowledgment metadata. For IR devices, verifiable:false signals that no device-side confirmation is possible.',
+                },
+            ];
+        }
         printJson(payload);
     });
 }

package/dist/config.js

@@ -3,6 +3,12 @@ import path from 'node:path';
 import os from 'node:os';
 import { getConfigPath } from './utils/flags.js';
 import { getActiveProfile } from './lib/request-context.js';
+function sanitizeOptionalString(v) {
+    if (typeof v !== 'string')
+        return undefined;
+    const trimmed = v.trim();
+    return trimmed ? trimmed : undefined;
+}
 /**
  * Credential file resolution priority:
  *   1. --config <path> (absolute override — wins over everything)
@@ -85,15 +91,70 @@ export function tryLoadConfig() {
         return null;
     }
 }
-export function saveConfig(token, secret) {
+export function saveConfig(token, secret, extras) {
     const file = configFilePath();
     const dir = path.dirname(file);
     if (!fs.existsSync(dir)) {
         fs.mkdirSync(dir, { recursive: true });
     }
-    const cfg = { token, secret };
+    // Merge with existing file so label/limits/defaults aren't dropped when the
+    // user just rotates the token.
+    let existing = {};
+    if (fs.existsSync(file)) {
+        try {
+            existing = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        }
+        catch {
+            existing = {};
+        }
+    }
+    const cfg = {
+        token,
+        secret,
+        ...(existing.label ? { label: existing.label } : {}),
+        ...(existing.description ? { description: existing.description } : {}),
+        ...(existing.limits ? { limits: existing.limits } : {}),
+        ...(existing.defaults ? { defaults: existing.defaults } : {}),
+    };
+    if (extras) {
+        const label = sanitizeOptionalString(extras.label);
+        const description = sanitizeOptionalString(extras.description);
+        if (label !== undefined)
+            cfg.label = label;
+        if (description !== undefined)
+            cfg.description = description;
+        if (extras.limits)
+            cfg.limits = { ...(cfg.limits ?? {}), ...extras.limits };
+        if (extras.defaults)
+            cfg.defaults = { ...(cfg.defaults ?? {}), ...extras.defaults };
+    }
     fs.writeFileSync(file, JSON.stringify(cfg, null, 2), { mode: 0o600 });
 }
+/**
+ * Read a profile's metadata (label / description / limits / defaults) without
+ * exposing the token/secret. Returns null when the file is missing or invalid.
+ */
+export function readProfileMeta(profile) {
+    const file = profile
+        ? profileFilePath(profile)
+        : path.join(os.homedir(), '.switchbot', 'config.json');
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        const cfg = JSON.parse(raw);
+        return {
+            label: cfg.label,
+            description: cfg.description,
+            limits: cfg.limits,
+            defaults: cfg.defaults,
+            path: file,
+        };
+    }
+    catch {
+        return null;
+    }
+}
 export function showConfig() {
     const envToken = process.env.SWITCHBOT_TOKEN;
     const envSecret = process.env.SWITCHBOT_SECRET;
@@ -112,8 +173,16 @@ export function showConfig() {
         const raw = fs.readFileSync(file, 'utf-8');
         const cfg = JSON.parse(raw);
         console.log(`Credential source: ${file}`);
+        if (cfg.label)
+            console.log(`label : ${cfg.label}`);
+        if (cfg.description)
+            console.log(`desc  : ${cfg.description}`);
         console.log(`token : ${maskCredential(cfg.token)}`);
         console.log(`secret: ${maskSecret(cfg.secret)}`);
+        if (cfg.limits?.dailyCap)
+            console.log(`limits: dailyCap=${cfg.limits.dailyCap}`);
+        if (cfg.defaults?.flags?.length)
+            console.log(`defaults: ${cfg.defaults.flags.join(' ')}`);
     }
     catch {
         console.error('Failed to read config file');

package/dist/devices/history-query.js

@@ -0,0 +1,181 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readline from 'node:readline';
+const DEFAULT_LIMIT = 1000;
+function historyDir() {
+    return path.join(os.homedir(), '.switchbot', 'device-history');
+}
+/**
+ * Parse a duration shortcut like "7d", "12h", "30m", "45s" into milliseconds.
+ * Returns null on malformed input (caller throws UsageError).
+ */
+export function parseDurationToMs(spec) {
+    const m = spec.trim().match(/^(\d+)(ms|s|m|h|d)$/i);
+    if (!m)
+        return null;
+    const n = Number(m[1]);
+    const unit = m[2].toLowerCase();
+    const factor = unit === 'ms' ? 1 : unit === 's' ? 1_000 : unit === 'm' ? 60_000 : unit === 'h' ? 3_600_000 : 86_400_000;
+    return n * factor;
+}
+/** Parse ISO-8601 (with Z or offset) or Date-parseable string → ms, else null. */
+export function parseInstantToMs(spec) {
+    const ms = Date.parse(spec);
+    return Number.isFinite(ms) ? ms : null;
+}
+function resolveRange(opts) {
+    let fromMs = Number.NEGATIVE_INFINITY;
+    let toMs = Number.POSITIVE_INFINITY;
+    if (opts.since && (opts.from || opts.to)) {
+        throw new Error('--since is mutually exclusive with --from/--to.');
+    }
+    if (opts.since) {
+        const durMs = parseDurationToMs(opts.since);
+        if (durMs === null) {
+            throw new Error(`Invalid --since value "${opts.since}". Expected e.g. "30s", "15m", "1h", "7d".`);
+        }
+        fromMs = Date.now() - durMs;
+    }
+    else {
+        if (opts.from) {
+            const parsed = parseInstantToMs(opts.from);
+            if (parsed === null)
+                throw new Error(`Invalid --from value "${opts.from}". Expected ISO-8601 timestamp.`);
+            fromMs = parsed;
+        }
+        if (opts.to) {
+            const parsed = parseInstantToMs(opts.to);
+            if (parsed === null)
+                throw new Error(`Invalid --to value "${opts.to}". Expected ISO-8601 timestamp.`);
+            toMs = parsed;
+        }
+        if (fromMs > toMs)
+            throw new Error('--from must be <= --to.');
+    }
+    return { fromMs, toMs };
+}
+/** Return jsonl candidate files for a device, oldest-first. */
+export function jsonlFilesForDevice(deviceId, baseDir = historyDir()) {
+    const out = [];
+    if (!fs.existsSync(baseDir))
+        return out;
+    // Oldest-first so range walks can bail early once a line overshoots `toMs`.
+    for (let i = 3; i >= 1; i--) {
+        const p = path.join(baseDir, `${deviceId}.jsonl.${i}`);
+        if (fs.existsSync(p))
+            out.push(p);
+    }
+    const current = path.join(baseDir, `${deviceId}.jsonl`);
+    if (fs.existsSync(current))
+        out.push(current);
+    return out;
+}
+function projectFields(record, fields) {
+    if (fields.length === 0)
+        return record;
+    const projected = {};
+    const payload = (record.payload ?? {});
+    for (const f of fields) {
+        if (f in payload)
+            projected[f] = payload[f];
+    }
+    return { t: record.t, topic: record.topic, deviceType: record.deviceType, payload: projected };
+}
+/**
+ * Stream-read the JSONL rotation files for `deviceId` and return records
+ * within [fromMs, toMs]. Parse failures are silently dropped (best-effort).
+ *
+ * Files whose mtime < fromMs are skipped whole (coarse but sound: the newest
+ * record in the file is <= mtime, so nothing in it can match).
+ */
+export async function queryDeviceHistory(deviceId, opts = {}) {
+    const { fromMs, toMs } = resolveRange(opts);
+    const limit = Math.max(0, opts.limit ?? DEFAULT_LIMIT);
+    const fields = opts.fields ?? [];
+    const files = jsonlFilesForDevice(deviceId);
+    const out = [];
+    for (const file of files) {
+        try {
+            const stat = fs.statSync(file);
+            if (stat.mtimeMs < fromMs)
+                continue;
+        }
+        catch {
+            continue;
+        }
+        const stream = fs.createReadStream(file, { encoding: 'utf-8' });
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            let rec;
+            try {
+                rec = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const tMs = Date.parse(rec.t);
+            if (!Number.isFinite(tMs))
+                continue;
+            if (tMs < fromMs || tMs > toMs)
+                continue;
+            out.push(projectFields(rec, fields));
+            if (out.length >= limit) {
+                rl.close();
+                stream.destroy();
+                return out;
+            }
+        }
+    }
+    return out;
+}
+export function queryDeviceHistoryStats(deviceId) {
+    const dir = historyDir();
+    const files = jsonlFilesForDevice(deviceId);
+    let totalBytes = 0;
+    let oldest = null;
+    let newest = null;
+    let count = 0;
+    for (const file of files) {
+        try {
+            totalBytes += fs.statSync(file).size;
+        }
+        catch { /* */ }
+    }
+    // Walk the oldest file's head + current file's tail for oldest/newest + count.
+    // Counting is O(records) here, acceptable for "stats" which isn't a hot path.
+    for (const file of files) {
+        try {
+            const lines = fs.readFileSync(file, 'utf-8').split('\n');
+            for (const line of lines) {
+                if (!line)
+                    continue;
+                count += 1;
+                try {
+                    const rec = JSON.parse(line);
+                    const tMs = Date.parse(rec.t);
+                    if (Number.isFinite(tMs)) {
+                        if (oldest === null || tMs < oldest)
+                            oldest = tMs;
+                        if (newest === null || tMs > newest)
+                            newest = tMs;
+                    }
+                }
+                catch { /* */ }
+            }
+        }
+        catch { /* */ }
+    }
+    return {
+        deviceId,
+        fileCount: files.length,
+        totalBytes,
+        recordCount: count,
+        oldest: oldest !== null ? new Date(oldest).toISOString() : undefined,
+        newest: newest !== null ? new Date(newest).toISOString() : undefined,
+        jsonlFiles: files.map((f) => path.basename(f)),
+        historyDir: dir,
+    };
+}

package/dist/index.js

@@ -18,6 +18,7 @@ import { registerSchemaCommand } from './commands/schema.js';
 import { registerHistoryCommand } from './commands/history.js';
 import { registerPlanCommand } from './commands/plan.js';
 import { registerCapabilitiesCommand } from './commands/capabilities.js';
+import { registerAgentBootstrapCommand } from './commands/agent-bootstrap.js';
 const require = createRequire(import.meta.url);
 const { version: pkgVersion } = require('../package.json');
 const program = new Command();
@@ -26,7 +27,7 @@ const program = new Command();
 const TOP_LEVEL_COMMANDS = [
     'config', 'devices', 'scenes', 'webhook', 'completion', 'mcp',
     'quota', 'catalog', 'cache', 'events', 'doctor', 'schema',
-    'history', 'plan', 'capabilities',
+    'history', 'plan', 'capabilities', 'agent-bootstrap',
 ];
 const cacheModeArg = (value) => {
     if (value.startsWith('-')) {
@@ -44,8 +45,9 @@ program
     .description('Command-line tool for SwitchBot API v1.1')
     .version(pkgVersion)
     .option('--json', 'Output raw JSON response (disables tables; useful for pipes/scripts)')
-    .option('--format <type>', 'Output format: table (default), json, jsonl, tsv, yaml, id', enumArg('--format', ['table', 'json', 'jsonl', 'tsv', 'yaml', 'id']))
+    .option('--format <type>', 'Output format: table (default), json, jsonl, tsv, yaml, id, markdown', enumArg('--format', ['table', 'json', 'jsonl', 'tsv', 'yaml', 'id', 'markdown']))
     .option('--fields <csv>', 'Comma-separated list of columns to include (e.g. --fields=id,name,type)', stringArg('--fields', { disallow: TOP_LEVEL_COMMANDS }))
+    .option('--table-style <style>', 'Table rendering style: unicode (default on TTY), ascii (default on pipes), simple, markdown', enumArg('--table-style', ['unicode', 'ascii', 'simple', 'markdown']))
     .option('-v, --verbose', 'Log HTTP request/response details to stderr')
     .option('--dry-run', 'Print mutating requests without sending them (GETs still execute)')
     .option('--timeout <ms>', 'HTTP request timeout in milliseconds (default: 30000)', intArg('--timeout', { min: 1 }))
@@ -76,6 +78,7 @@ registerSchemaCommand(program);
 registerHistoryCommand(program);
 registerPlanCommand(program);
 registerCapabilitiesCommand(program);
+registerAgentBootstrapCommand(program);
 program.addHelpText('after', `
 Credentials:
   Provide SwitchBot API v1.1 credentials via either:
@@ -130,6 +133,13 @@ function applyExitOverride(cmd) {
     cmd.commands.forEach(applyExitOverride);
 }
 applyExitOverride(program);
+// Enable "did you mean" suggestions across every subcommand, not just the root.
+// Without this, `switchbot devices lst` fails without suggesting `list`.
+function enableSuggestions(cmd) {
+    cmd.showSuggestionAfterError(true);
+    cmd.commands.forEach(enableSuggestions);
+}
+enableSuggestions(program);
 try {
     await program.parseAsync();
 }

package/dist/lib/devices.js

@@ -124,7 +124,14 @@ export async function executeCommand(deviceId, cmd, parameter, commandType, clie
             throw err;
         }
     };
-    return idempotencyCache.run(options?.idempotencyKey, execute);
+    const { result, replayed } = await idempotencyCache.run(options?.idempotencyKey, execute, { command: cmd, parameter });
+    if (!replayed)
+        return result;
+    // Cached hit — attach replayed marker without mutating the original.
+    if (result && typeof result === 'object') {
+        return { ...result, replayed: true };
+    }
+    return { value: result, replayed: true };
 }
 /**
  * Validate a command against the locally-cached device → catalog mapping.

package/dist/lib/idempotency.js

@@ -1,11 +1,46 @@
 /**
  * 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.
+ * duplicate keys within the window return the cached result (with a
+ * `replayed: true` marker). Duplicate keys within the window for a DIFFERENT
+ * (command, parameter) shape raise {@link IdempotencyConflictError}.
+ *
+ * Keys are stored in-memory as a SHA-256 fingerprint of the user-provided
+ * key — the original string never touches the Map keys, so a later heap dump
+ * or inadvertent log capture does not leak the raw token.
+ *
  * Process-local only — not shared across replicas.
  */
+import crypto from 'node:crypto';
 const DEFAULT_TTL_MS = 60000; // 60 seconds
 const DEFAULT_MAX_ENTRIES = 1024;
+export class IdempotencyConflictError extends Error {
+    key;
+    existingShape;
+    newShape;
+    constructor(message, key, existingShape, newShape) {
+        super(message);
+        this.key = key;
+        this.existingShape = existingShape;
+        this.newShape = newShape;
+        this.name = 'IdempotencyConflictError';
+    }
+}
+function hashKey(key) {
+    return crypto.createHash('sha256').update(key).digest('hex');
+}
+function shapeSignature(command, parameter) {
+    // Canonical-ish JSON — stable enough for object equality with no nested sort
+    // (callers can pass primitives or small objects).
+    let parm;
+    try {
+        parm = JSON.stringify(parameter ?? 'default');
+    }
+    catch {
+        parm = String(parameter);
+    }
+    return `${command}::${parm}`;
+}
 export class IdempotencyCache {
     cache = new Map();
     ttlMs;
@@ -17,56 +52,55 @@ export class IdempotencyCache {
     /**
      * Execute fn if the key is not cached, or return the cached result if it is.
      * On new execution, caches the result for ttlMs.
+     *
+     * When `shape` is provided, a cached hit is validated against the original
+     * (command, parameter) fingerprint; mismatched shape raises
+     * {@link IdempotencyConflictError}.
+     *
+     * Returns a tuple-esque object with `replayed: true` when the cached
+     * result is served. The `result` field is the original cached value.
      */
-    async run(key, fn) {
-        // No key = always execute (not cached)
+    async run(key, fn, shape) {
         if (!key) {
-            return fn();
+            const result = await fn();
+            return { result, replayed: false };
         }
+        const hashed = hashKey(key);
         const now = Date.now();
-        const cached = this.cache.get(key);
-        // Cached and not expired
+        const cached = this.cache.get(hashed);
+        const currentShape = shape ? shapeSignature(shape.command, shape.parameter) : '*';
         if (cached && cached.expiresAt > now) {
-            return cached.result;
+            if (shape && cached.shape !== '*' && cached.shape !== currentShape) {
+                throw new IdempotencyConflictError(`idempotency_conflict: key was first used for ${cached.shape.replace('::', ' ')}; refusing new shape ${currentShape.replace('::', ' ')}`, '<redacted>', cached.shape, currentShape);
+            }
+            return { result: cached.result, replayed: true };
         }
-        // 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%
+            const toRemove = Math.ceil(this.maxEntries * 0.1);
             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;
+        this.cache.set(hashed, { result, expiresAt: now + this.ttlMs, shape: currentShape });
+        return { result, replayed: false };
     }
-    /**
-     * 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();