@switchbot/openapi-cli 3.1.0 → 3.2.0

package/dist/commands/uninstall.js

@@ -1,237 +0,0 @@
-/**
- * `switchbot uninstall` — reverse of `switchbot install`.
- *
- * Unlike install, uninstall is not rollback-safe (there's nothing to
- * roll back to). It removes individual pieces independently and keeps
- * going if any single removal fails — the user gets a report and can
- * clean up leftovers manually. Every destructive step defaults to
- * confirmation; `--yes` skips the prompt.
- *
- * What it removes, from least to most destructive:
- *   1. skill symlink  (~/.claude/skills/switchbot)     — default: yes
- *   2. credentials    (keychain entry for the profile) — default: yes  (requires --remove-creds OR --yes)
- *   3. policy.yaml    (only on --remove-policy)         — default: no  (user edits may live here)
- *
- * The CLI itself is never uninstalled: install did not install it,
- * and yanking your own binary mid-run is impolite. Users who want it
- * gone run `npm rm -g @switchbot/openapi-cli`.
- */
-import { InvalidArgumentError } from 'commander';
-import fs from 'node:fs';
-import readline from 'node:readline';
-import { resolvePolicyPath } from '../policy/load.js';
-import { skillLinkPathFor } from '../install/default-steps.js';
-import { selectCredentialStore } from '../credentials/keychain.js';
-import { isJsonMode, printJson } from '../utils/output.js';
-import { getActiveProfile } from '../lib/request-context.js';
-import chalk from 'chalk';
-const AGENT_VALUES = ['claude-code', 'cursor', 'copilot', 'none'];
-function parseAgent(value) {
-    if (!value)
-        return 'claude-code';
-    if (!AGENT_VALUES.includes(value)) {
-        throw new InvalidArgumentError(`--agent must be one of ${AGENT_VALUES.join(', ')} (got "${value}")`);
-    }
-    return value;
-}
-async function prompt(question, defaultYes) {
-    if (!process.stdin.isTTY)
-        return defaultYes;
-    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve) => {
-        const suffix = defaultYes ? ' [Y/n] ' : ' [y/N] ';
-        rl.question(question + suffix, (ans) => {
-            rl.close();
-            const a = ans.trim().toLowerCase();
-            if (!a)
-                return resolve(defaultYes);
-            resolve(a === 'y' || a === 'yes');
-        });
-    });
-}
-export function registerUninstallCommand(program) {
-    program
-        .command('uninstall')
-        .description('Reverse of `switchbot install`: remove skill link, credentials, (optionally) policy')
-        .option('--agent <name>', `target agent: ${AGENT_VALUES.join(' | ')} (default: claude-code)`)
-        .option('--remove-creds', 'delete credentials from the OS keychain (default: prompt)')
-        .option('--remove-policy', 'also delete policy.yaml (default: keep — user edits may live there)')
-        .option('-y, --yes', 'assume yes to every confirmation prompt (non-interactive)')
-        .option('--purge', 'shorthand for --yes --remove-creds --remove-policy: remove everything without prompting')
-        .addHelpText('after', `
-The global --dry-run flag previews what would be removed.
-Global --json emits a structured removal report.
-
-What is never removed here:
-  - the CLI itself (use: npm rm -g @switchbot/openapi-cli)
-  - audit.log (it's your receipt; delete by hand if you want)
-
-Examples:
-  # Interactive: prompts before each destructive step
-  switchbot uninstall
-
-  # Non-interactive, remove everything including the policy
-  switchbot uninstall --yes --remove-policy
-
-  # One-shot: remove absolutely everything without prompting
-  switchbot uninstall --purge
-`)
-        .action(async (opts, command) => {
-        const agent = parseAgent(opts.agent);
-        const profile = getActiveProfile() ?? 'default';
-        const purge = Boolean(opts.purge);
-        const yes = Boolean(opts.yes) || purge;
-        const removePolicy = Boolean(opts.removePolicy) || purge;
-        const removeCreds = Boolean(opts.removeCreds) || yes;
-        const globalOpts = command.parent?.opts() ?? {};
-        const dryRun = Boolean(globalOpts.dryRun);
-        const policyPath = resolvePolicyPath();
-        const skillLink = skillLinkPathFor(agent);
-        const plan = [];
-        // --- Plan: skill symlink removal (default yes) ---
-        if (skillLink) {
-            plan.push({
-                action: 'remove-skill-link',
-                detail: skillLink,
-                run: async () => {
-                    if (!fs.existsSync(skillLink)) {
-                        return { action: 'remove-skill-link', status: 'absent', detail: skillLink };
-                    }
-                    const stat = fs.lstatSync(skillLink);
-                    if (!stat.isSymbolicLink()) {
-                        return {
-                            action: 'remove-skill-link',
-                            status: 'skipped',
-                            detail: `${skillLink} exists but is not a symlink — leaving it alone`,
-                        };
-                    }
-                    const ok = yes ? true : await prompt(`Remove skill link ${skillLink}?`, true);
-                    if (!ok)
-                        return { action: 'remove-skill-link', status: 'skipped', detail: skillLink };
-                    try {
-                        fs.unlinkSync(skillLink);
-                        return { action: 'remove-skill-link', status: 'removed', detail: skillLink };
-                    }
-                    catch (err) {
-                        return {
-                            action: 'remove-skill-link',
-                            status: 'failed',
-                            detail: skillLink,
-                            error: err instanceof Error ? err.message : String(err),
-                        };
-                    }
-                },
-            });
-        }
-        // --- Plan: credential removal (requires --remove-creds OR --yes) ---
-        plan.push({
-            action: 'remove-credentials',
-            detail: `profile=${profile}`,
-            run: async () => {
-                if (!removeCreds) {
-                    return {
-                        action: 'remove-credentials',
-                        status: 'skipped',
-                        detail: 'pass --remove-creds to delete keychain entry',
-                    };
-                }
-                const ok = yes ? true : await prompt(`Delete credentials for profile "${profile}" from the keychain?`, false);
-                if (!ok)
-                    return { action: 'remove-credentials', status: 'skipped', detail: `profile=${profile}` };
-                try {
-                    const store = await selectCredentialStore();
-                    await store.delete(profile);
-                    return {
-                        action: 'remove-credentials',
-                        status: 'removed',
-                        detail: `profile=${profile} (backend=${store.describe().tag})`,
-                    };
-                }
-                catch (err) {
-                    return {
-                        action: 'remove-credentials',
-                        status: 'failed',
-                        detail: `profile=${profile}`,
-                        error: err instanceof Error ? err.message : String(err),
-                    };
-                }
-            },
-        });
-        // --- Plan: policy.yaml removal (opt-in) ---
-        plan.push({
-            action: 'remove-policy',
-            detail: policyPath,
-            run: async () => {
-                if (!removePolicy) {
-                    return {
-                        action: 'remove-policy',
-                        status: 'skipped',
-                        detail: 'pass --remove-policy to delete policy.yaml',
-                    };
-                }
-                if (!fs.existsSync(policyPath)) {
-                    return { action: 'remove-policy', status: 'absent', detail: policyPath };
-                }
-                const ok = yes ? true : await prompt(`Delete policy file ${policyPath}?`, false);
-                if (!ok)
-                    return { action: 'remove-policy', status: 'skipped', detail: policyPath };
-                try {
-                    fs.unlinkSync(policyPath);
-                    return { action: 'remove-policy', status: 'removed', detail: policyPath };
-                }
-                catch (err) {
-                    return {
-                        action: 'remove-policy',
-                        status: 'failed',
-                        detail: policyPath,
-                        error: err instanceof Error ? err.message : String(err),
-                    };
-                }
-            },
-        });
-        if (dryRun) {
-            if (isJsonMode()) {
-                printJson({
-                    dryRun: true,
-                    profile,
-                    agent,
-                    plan: plan.map(({ action, detail }) => ({ action, detail })),
-                });
-            }
-            else {
-                console.log(chalk.bold('switchbot uninstall — dry run'));
-                console.log(`  profile: ${profile}`);
-                console.log(`  agent:   ${agent}`);
-                console.log('');
-                console.log(chalk.bold('Would run:'));
-                for (const p of plan)
-                    console.log(`  • ${p.action}  — ${p.detail}`);
-                console.log('');
-                console.log(chalk.dim('No changes made. Re-run without --dry-run (add --yes to skip prompts).'));
-            }
-            return;
-        }
-        const outcomes = [];
-        for (const p of plan) {
-            outcomes.push(await p.run());
-        }
-        const anyFailed = outcomes.some((o) => o.status === 'failed');
-        if (isJsonMode()) {
-            printJson({ ok: !anyFailed, profile, agent, outcomes });
-        }
-        else {
-            console.log(chalk.bold('switchbot uninstall'));
-            for (const o of outcomes) {
-                const tag = o.status === 'removed' ? chalk.green('✓') :
-                    o.status === 'absent' ? chalk.dim('·') :
-                        o.status === 'skipped' ? chalk.yellow('↷') :
-                            chalk.red('✗');
-                console.log(`  ${tag} ${o.action} [${o.status}]  ${o.detail ?? ''}`);
-                if (o.error)
-                    console.log(`      ${chalk.red(o.error)}`);
-            }
-        }
-        if (anyFailed)
-            process.exit(3);
-    });
-}

package/dist/commands/upgrade-check.js

@@ -1,88 +0,0 @@
-import { createRequire } from 'node:module';
-import https from 'node:https';
-import { isJsonMode, printJson } from '../utils/output.js';
-import chalk from 'chalk';
-const require = createRequire(import.meta.url);
-const { name: pkgName, version: currentVersion } = require('../../package.json');
-function fetchLatestVersion(packageName, timeoutMs = 8000) {
-    const encoded = packageName.replace('/', '%2F');
-    const url = `https://registry.npmjs.org/${encoded}/latest`;
-    return new Promise((resolve, reject) => {
-        const req = https.get(url, { timeout: timeoutMs }, (res) => {
-            const chunks = [];
-            res.on('data', (c) => chunks.push(c));
-            res.on('end', () => {
-                try {
-                    const body = JSON.parse(Buffer.concat(chunks).toString('utf-8'));
-                    if (typeof body.version === 'string')
-                        resolve(body.version);
-                    else
-                        reject(new Error('version field missing from registry response'));
-                }
-                catch (err) {
-                    reject(err);
-                }
-            });
-        });
-        req.on('timeout', () => { req.destroy(); reject(new Error(`registry request timed out after ${timeoutMs}ms`)); });
-        req.on('error', reject);
-    });
-}
-function semverGt(a, b) {
-    const numParts = (v) => v.replace(/-.*$/, '').split('.').map((n) => Number.parseInt(n, 10));
-    const [aMaj, aMin, aPat] = numParts(a);
-    const [bMaj, bMin, bPat] = numParts(b);
-    if (aMaj !== bMaj)
-        return aMaj > bMaj;
-    if (aMin !== bMin)
-        return aMin > bMin;
-    if (aPat !== bPat)
-        return aPat > bPat;
-    // Same numeric version: release (no prerelease) > prerelease
-    return !a.includes('-') && b.includes('-');
-}
-export function registerUpgradeCheckCommand(program) {
-    program
-        .command('upgrade-check')
-        .description('Check whether a newer version of this CLI is available on npm.')
-        .option('--timeout <ms>', 'Registry request timeout in milliseconds (default: 8000)', (v) => Number.parseInt(v, 10))
-        .action(async (opts) => {
-        let latestVersion;
-        try {
-            latestVersion = await fetchLatestVersion(pkgName, opts.timeout ?? 8000);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (isJsonMode()) {
-                printJson({ ok: false, error: msg, current: currentVersion });
-            }
-            else {
-                console.error(chalk.red(`upgrade-check failed: ${msg}`));
-            }
-            process.exit(1);
-        }
-        const upToDate = !semverGt(latestVersion, currentVersion);
-        const currentMajor = Number.parseInt(currentVersion.split('.')[0], 10);
-        const latestMajor = Number.parseInt(latestVersion.split('.')[0], 10);
-        const result = {
-            current: currentVersion,
-            latest: latestVersion,
-            upToDate,
-            updateAvailable: !upToDate,
-            breakingChange: latestMajor > currentMajor,
-            installCommand: upToDate ? null : `npm install -g ${pkgName}@${latestVersion}`,
-        };
-        if (isJsonMode()) {
-            printJson(result);
-            return;
-        }
-        if (upToDate) {
-            console.log(`${chalk.green('✓')} You are running the latest version (${currentVersion}).`);
-        }
-        else {
-            console.log(`${chalk.yellow('!')} Update available: ${chalk.bold(currentVersion)} → ${chalk.bold(latestVersion)}`);
-            console.log(`  Run: ${chalk.cyan(`npm install -g ${pkgName}@${latestVersion}`)}`);
-            process.exit(1);
-        }
-    });
-}

package/dist/commands/watch.js

@@ -1,194 +0,0 @@
-import { printJson, isJsonMode, handleError, UsageError, emitStreamHeader } from '../utils/output.js';
-import { fetchDeviceStatus } from '../lib/devices.js';
-import { getCachedDevice } from '../devices/cache.js';
-import { parseDurationToMs, getFields } from '../utils/flags.js';
-import { intArg, durationArg, stringArg } from '../utils/arg-parsers.js';
-import { createClient } from '../api/client.js';
-import { resolveDeviceId } from '../utils/name-resolver.js';
-import { resolveFieldList, listAllCanonical } from '../schema/field-aliases.js';
-const DEFAULT_INTERVAL_MS = 30_000;
-const MIN_INTERVAL_MS = 1_000;
-function diff(prev, next, fields) {
-    const out = {};
-    const keys = fields ?? Object.keys(next);
-    for (const k of keys) {
-        const a = prev ? prev[k] : undefined;
-        const b = next[k];
-        if (JSON.stringify(a) !== JSON.stringify(b)) {
-            out[k] = { from: prev ? a : null, to: b };
-        }
-    }
-    return out;
-}
-function formatHumanLine(ev) {
-    const when = new Date(ev.t).toLocaleTimeString();
-    const head = `[${when}] ${ev.deviceId}${ev.type ? ` (${ev.type})` : ''}`;
-    if (ev.error)
-        return `${head}: error — ${ev.error}`;
-    const keys = Object.keys(ev.changed);
-    if (keys.length === 0)
-        return `${head}: no changes`;
-    const pairs = keys
-        .map((k) => {
-        const { from, to } = ev.changed[k];
-        if (from === null || from === undefined)
-            return `${k}=${JSON.stringify(to)}`;
-        return `${k}: ${JSON.stringify(from)} → ${JSON.stringify(to)}`;
-    })
-        .join(', ');
-    return `${head} ${pairs}`;
-}
-function sleep(ms, signal) {
-    return new Promise((resolve) => {
-        const t = setTimeout(() => resolve(), ms);
-        const onAbort = () => {
-            clearTimeout(t);
-            resolve();
-        };
-        if (signal.aborted) {
-            clearTimeout(t);
-            resolve();
-        }
-        else {
-            signal.addEventListener('abort', onAbort, { once: true });
-        }
-    });
-}
-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 (or use --name for one device)')
-        .option('--name <query>', 'Resolve one device by fuzzy name (combined with any positional IDs)', stringArg('--name'))
-        .option('--interval <dur>', `Polling interval: "30s", "1m", "500ms", ... (default 30s, min ${MIN_INTERVAL_MS / 1000}s)`, durationArg('--interval'), '30s')
-        .option('--max <n>', 'Stop after N ticks (default: run until Ctrl-C)', intArg('--max', { min: 1 }))
-        .option('--for <dur>', 'Stop after elapsed time (e.g. "5m", "30s"). Combines with --max: first limit wins.', durationArg('--for'))
-        .option('--include-unchanged', 'Emit a tick even when no field changed')
-        .addHelpText('after', `
-Each poll emits one JSON line per deviceId with the shape:
-  { "t": "<ISO>", "tick": <n>, "deviceId": "ID", "type": "Bot",
-    "changed": { "power": { "from": "off", "to": "on" } } }
-
-The very first poll has "from": null for every field (seed).
-
-Examples:
-  $ switchbot devices watch ABC123 --interval 10s
-  $ 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 "Living Room AC" --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.`);
-            }
-            const intervalMs = parsed;
-            let maxTicks = null;
-            if (options.max !== undefined) {
-                const n = Number(options.max);
-                if (!Number.isFinite(n) || n < 1) {
-                    throw new UsageError(`Invalid --max "${options.max}". Must be a positive integer.`);
-                }
-                maxTicks = Math.floor(n);
-            }
-            const forMs = options.for ? parseDurationToMs(options.for) : null;
-            const rawFields = getFields() ?? null;
-            // Resolve aliases upfront against the static canonical registry.
-            // Validating here lets UsageError exit the command before any
-            // polling starts, and keeps mid-loop error handling free of
-            // "misuse" concerns. Unknown fields that are not registered as
-            // aliases but happen to match an API key pass through unchanged.
-            const fields = rawFields
-                ? resolveFieldList(rawFields, listAllCanonical())
-                : null;
-            const ac = new AbortController();
-            const onSig = () => ac.abort();
-            process.on('SIGINT', onSig);
-            process.on('SIGTERM', onSig);
-            const forTimer = forMs !== null && forMs > 0
-                ? setTimeout(() => ac.abort(), forMs)
-                : null;
-            // P7: streaming JSON contract — first line under --json is the
-            // stream header so consumers can route by eventKind/cadence.
-            if (isJsonMode())
-                emitStreamHeader({ eventKind: 'tick', cadence: 'poll' });
-            try {
-                const prev = new Map();
-                const client = createClient();
-                let tick = 0;
-                while (!ac.signal.aborted) {
-                    tick++;
-                    const t = new Date().toISOString();
-                    // Poll all devices in parallel; one failure per device doesn't stop
-                    // the others.
-                    await Promise.all(allIds.map(async (id) => {
-                        const cached = getCachedDevice(id);
-                        try {
-                            const body = await fetchDeviceStatus(id, client);
-                            const changed = diff(prev.get(id), body, fields);
-                            prev.set(id, body);
-                            if (Object.keys(changed).length === 0 && !options.includeUnchanged) {
-                                return;
-                            }
-                            const ev = {
-                                t,
-                                tick,
-                                deviceId: id,
-                                type: cached?.type,
-                                changed,
-                            };
-                            if (isJsonMode()) {
-                                // JSONL: one event per line (printJson with newline).
-                                printJson(ev);
-                            }
-                            else {
-                                console.log(formatHumanLine(ev));
-                            }
-                        }
-                        catch (err) {
-                            const ev = {
-                                t,
-                                tick,
-                                deviceId: id,
-                                type: cached?.type,
-                                changed: {},
-                                error: err instanceof Error ? err.message : String(err),
-                            };
-                            if (isJsonMode()) {
-                                printJson(ev);
-                            }
-                            else {
-                                console.error(formatHumanLine(ev));
-                            }
-                        }
-                    }));
-                    if (maxTicks !== null && tick >= maxTicks)
-                        break;
-                    await sleep(intervalMs, ac.signal);
-                }
-            }
-            catch (err) {
-                handleError(err);
-            }
-            finally {
-                if (forTimer)
-                    clearTimeout(forTimer);
-                process.off('SIGINT', onSig);
-                process.off('SIGTERM', onSig);
-            }
-        }
-        catch (error) {
-            handleError(error);
-        }
-    });
-}