@switchbot/openapi-cli 3.1.0 → 3.2.0

package/dist/install/preflight.js

@@ -1,212 +0,0 @@
-/**
- * Install-orchestrator pre-flight (Phase 3A · F5).
- *
- * Pure library — no CLI entry. Consumers (e.g. a future
- * `openclaw plugins install` command) call `runPreflight()` and decide
- * whether to proceed based on the returned result. Nothing here mutates
- * user state: every check is read-only.
- *
- * The check list mirrors `docs/design/phase3-install.md` step 1 minus
- * the bits that require external services (npm registry / SwitchBot API
- * reachability are left for the installer itself to probe when it has
- * a plan to retry, since they are the flakiest of the lot).
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { resolvePolicyPath, loadPolicyFile, PolicyFileNotFoundError } from '../policy/load.js';
-import { validateLoadedPolicy } from '../policy/validate.js';
-import { selectCredentialStore } from '../credentials/keychain.js';
-function parseMajor(version) {
-    const m = /^v?(\d+)\./.exec(version);
-    if (!m)
-        return null;
-    const n = Number(m[1]);
-    return Number.isFinite(n) ? n : null;
-}
-function checkNodeVersion(opts) {
-    const required = opts.minNodeMajor ?? 18;
-    const version = opts.nodeVersion ?? process.version;
-    const major = parseMajor(version);
-    if (major === null) {
-        return {
-            name: 'node',
-            status: 'fail',
-            message: `unrecognised Node.js version string: ${version}`,
-            hint: 'reinstall Node.js from https://nodejs.org',
-        };
-    }
-    if (major < required) {
-        return {
-            name: 'node',
-            status: 'fail',
-            message: `Node.js ${version} < required v${required}`,
-            hint: `upgrade Node.js to v${required} or later`,
-        };
-    }
-    return { name: 'node', status: 'ok', message: `Node.js ${version}` };
-}
-function checkPolicy() {
-    const policyPath = resolvePolicyPath();
-    try {
-        const loaded = loadPolicyFile(policyPath);
-        const result = validateLoadedPolicy(loaded);
-        if (result.valid) {
-            return {
-                name: 'policy',
-                status: 'ok',
-                message: `policy at ${policyPath} validates (v${result.schemaVersion ?? '?'})`,
-            };
-        }
-        return {
-            name: 'policy',
-            status: 'warn',
-            message: `policy at ${policyPath} has ${result.errors.length} validation error(s)`,
-            hint: 'run "switchbot policy validate" to see details before installing',
-        };
-    }
-    catch (err) {
-        if (err instanceof PolicyFileNotFoundError) {
-            return {
-                name: 'policy',
-                status: 'ok',
-                message: `no policy at ${policyPath} (installer will scaffold one)`,
-            };
-        }
-        return {
-            name: 'policy',
-            status: 'warn',
-            message: `policy at ${policyPath} is unreadable: ${err instanceof Error ? err.message : String(err)}`,
-            hint: 'move the file aside, then re-run — the installer will scaffold a fresh copy',
-        };
-    }
-}
-async function checkKeychain() {
-    try {
-        const store = await selectCredentialStore();
-        const desc = store.describe();
-        if (desc.writable) {
-            return {
-                name: 'keychain',
-                status: 'ok',
-                message: `credential backend: ${desc.backend}`,
-            };
-        }
-        return {
-            name: 'keychain',
-            status: 'warn',
-            message: `credential backend ${desc.backend} is not writable — will fall back to file`,
-            hint: desc.notes ?? 'install the OS keychain helper to get native credential storage',
-        };
-    }
-    catch (err) {
-        return {
-            name: 'keychain',
-            status: 'warn',
-            message: `keychain probe failed: ${err instanceof Error ? err.message : String(err)}`,
-            hint: 'the installer will fall back to the file backend',
-        };
-    }
-}
-function checkHomeDirWritable() {
-    const home = os.homedir();
-    const switchbotDir = path.join(home, '.switchbot');
-    try {
-        const homeStat = fs.statSync(home);
-        if (!homeStat.isDirectory()) {
-            return {
-                name: 'home',
-                status: 'fail',
-                message: `home path is not a directory: ${home}`,
-                hint: 'check your HOME/USERPROFILE environment configuration',
-            };
-        }
-        if (fs.existsSync(switchbotDir)) {
-            const sbStat = fs.statSync(switchbotDir);
-            if (!sbStat.isDirectory()) {
-                return {
-                    name: 'home',
-                    status: 'fail',
-                    message: `${switchbotDir} exists but is not a directory`,
-                    hint: 'move the file aside and re-run install',
-                };
-            }
-            fs.accessSync(switchbotDir, fs.constants.W_OK);
-            return { name: 'home', status: 'ok', message: `writable: ${switchbotDir}` };
-        }
-        fs.accessSync(home, fs.constants.W_OK);
-        return { name: 'home', status: 'ok', message: `writable: ${home}` };
-    }
-    catch (err) {
-        return {
-            name: 'home',
-            status: 'fail',
-            message: `cannot write under ${home}: ${err instanceof Error ? err.message : String(err)}`,
-            hint: 'check ownership and permissions on your home directory',
-        };
-    }
-}
-function nearestExistingPath(target) {
-    let cur = target;
-    while (true) {
-        if (fs.existsSync(cur))
-            return cur;
-        const parent = path.dirname(cur);
-        if (parent === cur)
-            return null;
-        cur = parent;
-    }
-}
-function checkAgentSkillDirWritable(opts) {
-    const shouldCheck = opts.agent === 'claude-code' && (opts.expectSkillLink ?? true);
-    if (!shouldCheck)
-        return null;
-    const home = os.homedir();
-    const target = path.join(home, '.claude', 'skills');
-    try {
-        const existing = nearestExistingPath(target);
-        if (!existing) {
-            return {
-                name: 'agent-skills-dir',
-                status: 'fail',
-                message: `cannot resolve an existing parent for ${target}`,
-                hint: 'check your home directory path and permissions',
-            };
-        }
-        const stat = fs.statSync(existing);
-        if (!stat.isDirectory()) {
-            return {
-                name: 'agent-skills-dir',
-                status: 'fail',
-                message: `path component is not a directory: ${existing}`,
-                hint: 'move the blocking file aside and re-run install',
-            };
-        }
-        fs.accessSync(existing, fs.constants.W_OK);
-        return { name: 'agent-skills-dir', status: 'ok', message: `writable: ${target}` };
-    }
-    catch (err) {
-        return {
-            name: 'agent-skills-dir',
-            status: 'fail',
-            message: `cannot write to ${target}: ${err instanceof Error ? err.message : String(err)}`,
-            hint: 'open Claude Code once (it will create ~/.claude) or create the directory manually',
-        };
-    }
-}
-/**
- * Run every pre-flight check and return a combined result. Safe to
- * call multiple times; no state is cached.
- */
-export async function runPreflight(options = {}) {
-    const checks = [];
-    checks.push(checkNodeVersion(options));
-    checks.push(checkPolicy());
-    checks.push(await checkKeychain());
-    checks.push(checkHomeDirWritable());
-    const agentCheck = checkAgentSkillDirWritable(options);
-    if (agentCheck)
-        checks.push(agentCheck);
-    const ok = checks.every((c) => c.status !== 'fail');
-    return { checks, ok };
-}

package/dist/install/steps.js

@@ -1,67 +0,0 @@
-/**
- * Install-orchestrator step runner (Phase 3A · F5).
- *
- * Each step has a deterministic `execute` and a matching `undo`. The
- * runner executes steps in order; on any failure it walks the
- * already-completed steps in reverse and invokes their `undo`. If an
- * `undo` itself fails, the error is captured and surfaced — the
- * runner does NOT abort the rollback. The caller gets a full report
- * and can decide how to surface partial cleanup failures.
- *
- * The module is intentionally agnostic of what steps do; consumers
- * (future `openclaw plugins install`) plug in concrete steps like
- * "npm i -g the CLI" or "write the credential to the keychain".
- */
-/**
- * Run the given steps in order. On the first failure, the runner
- * walks already-executed steps in reverse and invokes each step's
- * undo. Returns a report describing every step's fate.
- */
-export async function runInstall(steps, options = {}) {
-    const ctx = (options.context ?? {});
-    const outcomes = [];
-    const executed = [];
-    let failedAt;
-    for (const step of steps) {
-        try {
-            await step.execute(ctx);
-            outcomes.push({ step: step.name, status: 'succeeded' });
-            executed.push(step);
-        }
-        catch (err) {
-            outcomes.push({
-                step: step.name,
-                status: 'failed',
-                error: err instanceof Error ? err.message : String(err),
-            });
-            failedAt = step.name;
-            break;
-        }
-        if (options.stopAfter === step.name)
-            break;
-    }
-    if (failedAt !== undefined) {
-        // Roll back completed steps in reverse. Undo failures are captured
-        // but do not abort further rollback attempts — the goal is to
-        // leave as little residue as possible.
-        for (let i = executed.length - 1; i >= 0; i--) {
-            const step = executed[i];
-            try {
-                await step.undo(ctx);
-                outcomes.push({ step: step.name, status: 'rolled-back' });
-            }
-            catch (err) {
-                outcomes.push({
-                    step: step.name,
-                    status: 'rollback-failed',
-                    error: err instanceof Error ? err.message : String(err),
-                });
-            }
-        }
-    }
-    return {
-        ok: failedAt === undefined,
-        outcomes,
-        ...(failedAt !== undefined ? { failedAt } : {}),
-    };
-}

package/dist/lib/command-keywords.js

@@ -1,17 +0,0 @@
-export const COMMAND_KEYWORDS = [
-    { pattern: /\boff\b|\bturn.?off\b|\bstop\b/i, command: 'turnOff' },
-    { pattern: /\bon\b|\bturn.?on\b|\bstart\b/i, command: 'turnOn' },
-    { pattern: /\bpress\b|\bclick\b|\btap\b/i, command: 'press' },
-    { pattern: /\block\b/i, command: 'lock' },
-    { pattern: /\bunlock\b/i, command: 'unlock' },
-    { pattern: /\bopen\b|\braise\b|\bup\b/i, command: 'open' },
-    { pattern: /\bclose\b|\blower\b|\bdown\b/i, command: 'close' },
-    { pattern: /\bpause\b/i, command: 'pause' },
-];
-export function inferCommandFromIntent(intent) {
-    for (const k of COMMAND_KEYWORDS) {
-        if (k.pattern.test(intent))
-            return k.command;
-    }
-    return undefined;
-}

package/dist/lib/daemon-state.js

@@ -1,46 +0,0 @@
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-function getStateDir() {
-    return path.join(os.homedir(), '.switchbot');
-}
-function getDaemonPidFile() {
-    return path.join(getStateDir(), 'daemon.pid');
-}
-function getDaemonLogFile() {
-    return path.join(getStateDir(), 'daemon.log');
-}
-function getDaemonStateFile() {
-    return path.join(getStateDir(), 'daemon.state.json');
-}
-function getHealthzPidFile() {
-    return path.join(getStateDir(), 'healthz.pid');
-}
-export const DAEMON_PID_FILE = getDaemonPidFile();
-export const DAEMON_LOG_FILE = getDaemonLogFile();
-export const DAEMON_STATE_FILE = getDaemonStateFile();
-export const HEALTHZ_PID_FILE = getHealthzPidFile();
-function ensureStateDir() {
-    fs.mkdirSync(getStateDir(), { recursive: true, mode: 0o700 });
-}
-export function writeDaemonState(state) {
-    ensureStateDir();
-    fs.writeFileSync(getDaemonStateFile(), JSON.stringify(state, null, 2), { mode: 0o600 });
-}
-export function readDaemonState() {
-    try {
-        const raw = fs.readFileSync(getDaemonStateFile(), 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-export function removeDaemonState() {
-    try {
-        fs.unlinkSync(getDaemonStateFile());
-    }
-    catch {
-        // best effort
-    }
-}

package/dist/lib/destructive-mode.js

@@ -1,12 +0,0 @@
-import { getActiveProfile } from './request-context.js';
-const DIRECT_DESTRUCTIVE_PROFILES = new Set(['dev', 'development']);
-export function allowsDirectDestructiveExecution(profile = getActiveProfile()) {
-    if (process.env.SWITCHBOT_ALLOW_DIRECT_DESTRUCTIVE === '1')
-        return true;
-    if (!profile)
-        return false;
-    return DIRECT_DESTRUCTIVE_PROFILES.has(profile.toLowerCase());
-}
-export function destructiveExecutionHint() {
-    return "Use 'switchbot plan save <file>' -> 'switchbot plan review <planId>' -> 'switchbot plan approve <planId>' -> 'switchbot plan execute <planId>' instead.";
-}