@getdial/cli 0.19.1 → 0.20.1

package/dist/cli.js

@@ -22,12 +22,20 @@ import { runLocalTargetAddCmd } from "./commands/local-target/add-cmd.js";
 import { runLocalTargetRemove } from "./commands/local-target/remove.js";
 import { runLocalTargetList } from "./commands/local-target/list.js";
 import { runMcp } from "./commands/mcp.js";
+import { runUpdate } from "./commands/update.js";
+import { runUninstall } from "./commands/uninstall.js";
+import { maybeAutoUpdate } from "./lib/update.js";
 const program = new Command();
 program
     .name("dial")
     .description("Dial CLI — set up your account and run the listen service.")
     .version(VERSION)
     .enablePositionalOptions();
+// Hourly detached self-update; a no-op for exempt commands, non-npm installs,
+// fresh stamps, and DIAL_NO_AUTO_UPDATE=1. Never touches stdout/stderr.
+program.hook("preAction", (_thisCommand, actionCommand) => {
+    maybeAutoUpdate(actionCommand.name());
+});
 program
     .command("doctor")
     .description("Report state and what to do next.")
@@ -243,6 +251,16 @@ program
     .command("mcp")
     .description("Run a local stdio MCP server exposing Dial as agent tools (reuses your saved API key).")
     .action(async () => process.exit(await runMcp()));
+program
+    .command("update")
+    .description("Update the CLI to the latest published version (global npm installs).")
+    .option("--json", "machine-readable output")
+    .action(async (opts) => process.exit(await runUpdate({ json: !!opts.json })));
+program
+    .command("uninstall")
+    .description("Remove the listen daemon, agent skills, and all local Dial state, then print how to remove the package.")
+    .option("--json", "machine-readable output")
+    .action(async (opts) => process.exit(await runUninstall({ json: !!opts.json })));
 program.parseAsync(process.argv).catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(2);

package/dist/commands/listen/index.js

@@ -3,19 +3,22 @@ import { readAuth } from "../../lib/state.js";
 import { startWorker } from "../../lib/pubnub.js";
 import { appendJsonl } from "../../lib/log.js";
 import { paths } from "../../lib/paths.js";
+import { nextSkewState, recordListenVersion, safeInstalledVersion, VERSION_POLL_INTERVAL_MS, } from "../../lib/listen-version.js";
+import { VERSION } from "../../lib/version.js";
 function isSupervised() {
     return Boolean(process.env.LAUNCHD_SOCKET || process.env.LAUNCH_DAEMON || process.env.INVOCATION_ID);
 }
 export async function runListen() {
     const auth = readAuth();
     if (!auth) {
-        appendJsonl(paths().listenLog, { ts: new Date().toISOString(), lifecycle: "startup", ok: false, error: "no auth.json" });
+        appendJsonl(paths().listenLog, { ts: new Date().toISOString(), lifecycle: "startup", ok: false, error: "no saved auth" });
         if (isSupervised()) {
             await delay(30_000);
         }
         return 1;
     }
     appendJsonl(paths().listenLog, { ts: new Date().toISOString(), lifecycle: "startup", ok: true, accountId: auth.accountId });
+    recordListenVersion();
     const ctrl = startWorker(auth.apiKey, auth.accountId);
     const onSignal = async (sig) => {
         appendJsonl(paths().listenLog, { ts: new Date().toISOString(), lifecycle: "shutdown", signal: sig });
@@ -23,7 +26,30 @@ export async function runListen() {
     };
     process.on("SIGTERM", onSignal);
     process.on("SIGINT", onSignal);
+    // When an update replaces the installed CLI, drain and exit non-zero so the
+    // supervisor (launchd KeepAlive / systemd on-failure) relaunches us onto the
+    // new code. Exit 1 restarts under both supervisors.
+    let skew = { streak: 0 };
+    const versionPoll = setInterval(() => {
+        const installed = safeInstalledVersion();
+        const decision = nextSkewState(skew, VERSION, installed);
+        skew = decision.state;
+        if (decision.restart) {
+            clearInterval(versionPoll);
+            appendJsonl(paths().listenLog, {
+                ts: new Date().toISOString(),
+                lifecycle: "restart",
+                reason: "version-skew",
+                running: VERSION,
+                installed,
+            });
+            process.exitCode = 1;
+            void ctrl.stop();
+        }
+    }, VERSION_POLL_INTERVAL_MS);
+    versionPoll.unref();
     await ctrl.whenStopped;
+    clearInterval(versionPoll);
     const code = process.exitCode;
     return typeof code === "number" ? code : 0;
 }

package/dist/commands/uninstall.js

@@ -0,0 +1,25 @@
+import { uninstallEverything } from "../lib/ops/uninstall.js";
+export async function runUninstall(opts) {
+    const report = uninstallEverything();
+    if (opts.json) {
+        console.log(JSON.stringify(report));
+        return report.ok ? 0 : 2;
+    }
+    const daemonLine = report.daemon.status === "removed"
+        ? "removed"
+        : report.daemon.status === "skipped"
+            ? `skipped (${report.daemon.reason})`
+            : `failed (${report.daemon.reason})`;
+    console.log(`listen daemon: ${daemonLine}`);
+    const removedSkills = report.skills.filter((s) => s.removed);
+    console.log(removedSkills.length
+        ? `agent skills: removed from ${removedSkills.map((s) => s.agent).join(", ")}`
+        : "agent skills: none installed");
+    const removedDirs = report.dirs.filter((d) => d.removed);
+    console.log(removedDirs.length ? `state dirs: removed ${removedDirs.map((d) => d.path).join(", ")}` : "state dirs: none present");
+    for (const e of report.errors) {
+        console.error(`error in ${e.step}: ${e.message}`);
+    }
+    console.log(`\nDial is removed from this machine. Finish with:\n  ${report.hint}`);
+    return report.ok ? 0 : 2;
+}

package/dist/commands/update.js

@@ -0,0 +1,42 @@
+import { execFileSync } from "node:child_process";
+import { detectInstallKind, installedVersion, npmUpdateCommand } from "../lib/update.js";
+import { VERSION } from "../lib/version.js";
+export async function runUpdate(opts) {
+    const kind = detectInstallKind(process.argv[1] ?? "");
+    if (kind !== "global-npm") {
+        const guidance = kind === "npx"
+            ? "npx already runs the latest version on each invocation — nothing to update."
+            : "this dial is not a global npm install (source checkout or custom binary) — update it the way it was installed.";
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: "not_updatable", kind, message: guidance }));
+        else
+            console.error(`update unavailable: ${guidance}`);
+        return 2;
+    }
+    const previous = VERSION;
+    const { command, args } = npmUpdateCommand();
+    try {
+        execFileSync(command, args, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf8" });
+    }
+    catch (err) {
+        const e = err;
+        const detail = (e.stderr?.trim() || e.message).trim();
+        const hint = detail.includes("EACCES")
+            ? " (permission denied — fix your npm prefix or re-run with elevated permissions)"
+            : "";
+        if (opts.json)
+            console.log(JSON.stringify({ ok: false, error: "npm_failed", message: `${detail}${hint}` }));
+        else
+            console.error(`update failed: ${detail}${hint}`);
+        return 2;
+    }
+    const installed = installedVersion();
+    const updated = installed !== previous;
+    if (opts.json)
+        console.log(JSON.stringify({ ok: true, previous, installed, updated }));
+    else if (updated)
+        console.log(`updated ${previous} → ${installed}. The new version applies from your next dial command.`);
+    else
+        console.log(`already up to date (${previous}).`);
+    return 0;
+}

package/dist/lib/api.js

@@ -1,6 +1,6 @@
 import { request } from "undici";
 import { logger } from "./log.js";
-const DEFAULT_BASE = "https://dial.up.railway.app";
+const DEFAULT_BASE = "https://getdial.ai";
 export function baseUrl() {
     return process.env.DIAL_API_URL ?? DEFAULT_BASE;
 }

package/dist/lib/listen-version.js

@@ -0,0 +1,42 @@
+import { z } from "zod";
+import { logger } from "./log.js";
+import { paths } from "./paths.js";
+import { installedVersion } from "./update.js";
+import { defineVersionedFile } from "./versioned-file.js";
+import { VERSION } from "./version.js";
+export const VERSION_POLL_INTERVAL_MS = 60 * 1000;
+/** Mismatches must hold this many consecutive ticks — npm may be mid-replace. */
+export const SKEW_CONFIRM_TICKS = 2;
+const listenVersionFile = defineVersionedFile({
+    dir: () => paths().stateDir,
+    base: "listen-version",
+    version: 1,
+    schema: z.object({ version: z.string(), pid: z.number(), startedAt: z.string() }),
+    migrations: {},
+});
+/** Non-blocking startup side effect: failure is a warning, never an abort. */
+export function recordListenVersion(now = new Date()) {
+    try {
+        listenVersionFile.write({ version: VERSION, pid: process.pid, startedAt: now.toISOString() });
+    }
+    catch (err) {
+        logger.warn({ err }, "could not record the listen service version");
+    }
+}
+/** installedVersion() that reports unreadable/unparsable as null instead of throwing. */
+export function safeInstalledVersion() {
+    try {
+        return installedVersion();
+    }
+    catch (err) {
+        logger.warn({ err }, "could not read the installed CLI version");
+        return null;
+    }
+}
+export function nextSkewState(state, running, installed) {
+    if (installed === null || installed === running) {
+        return { state: { streak: 0 }, restart: false };
+    }
+    const streak = state.streak + 1;
+    return { state: { streak }, restart: streak >= SKEW_CONFIRM_TICKS };
+}

package/dist/lib/local-targets.js

@@ -1,7 +1,7 @@
-import { mkdirSync, readFileSync, writeFileSync, chmodSync } from "node:fs";
-import { dirname, isAbsolute } from "node:path";
+import { isAbsolute } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.js";
+import { defineVersionedFile } from "./versioned-file.js";
 const LOOPBACK_HOSTS = new Set(["127.0.0.1", "0.0.0.0", "localhost", "::1", "[::1]"]);
 export const DEFAULT_TIMEOUT_SECONDS = 5;
 export const DEFAULT_SIGNATURE_HEADER = "X-Dial-Signature";
@@ -49,42 +49,18 @@ export function assertLoopbackUrl(raw) {
 export function targetId(t) {
     return t.kind === "url" ? t.url : t.path;
 }
-function ensureDir(file) {
-    mkdirSync(dirname(file), { recursive: true, mode: 0o700 });
-}
+const registryFile = defineVersionedFile({
+    dir: () => paths().configDir,
+    base: "local-targets",
+    version: 1,
+    schema: RegistrySchema,
+    migrations: { 0: (legacy) => legacy },
+});
 function readRegistry() {
-    const file = paths().localTargetsFile;
-    let raw;
-    try {
-        raw = readFileSync(file, "utf8");
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return { targets: [] };
-        throw err;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return { targets: [] };
-    }
-    const result = RegistrySchema.safeParse(parsed);
-    if (!result.success)
-        return { targets: [] };
-    return result.data;
+    return registryFile.read() ?? { targets: [] };
 }
 function writeRegistry(reg) {
-    const file = paths().localTargetsFile;
-    ensureDir(file);
-    writeFileSync(file, JSON.stringify(reg, null, 2), { mode: 0o600 });
-    try {
-        chmodSync(file, 0o600);
-    }
-    catch {
-        // chmod can fail on some filesystems; the create-mode is the important guarantee
-    }
+    registryFile.write(reg);
 }
 export function listTargets() {
     return readRegistry().targets;

package/dist/lib/ops/account.js

@@ -1,4 +1,4 @@
-import { readAuth, readPendingSignup, writePendingSignup, clearPendingSignup, writeAuth } from "../state.js";
+import { readAuth, readPendingSignup, writePendingSignup, clearPendingSignup, writeAuth, authFilePath } from "../state.js";
 import { apiGet, apiPost, baseUrl, pingBackend } from "../api.js";
 import { supervisorStatus, lastEventAtFromLog, supervisorAvailability } from "../supervisor/index.js";
 import { paths } from "../paths.js";
@@ -126,7 +126,7 @@ export async function onboard(opts) {
     return {
         apiKey,
         apiKeyFingerprint: apiKey.slice(-4),
-        apiKeyPath: paths().authFile,
+        apiKeyPath: authFilePath(),
         accountId: res.data.accountId,
         phoneNumber: res.data.phoneNumber ?? null,
         phoneNumberId: res.data.phoneNumberId ?? null,

package/dist/lib/ops/uninstall.js

@@ -0,0 +1,54 @@
+import { existsSync, rmSync } from "node:fs";
+import { paths } from "../paths.js";
+import { SUPPORTED_AGENTS, uninstallSkill } from "../skill-install.js";
+import { supervisorAvailability, uninstallSupervised } from "../supervisor/index.js";
+export const UNINSTALL_HINT = "npm uninstall -g @getdial/cli";
+/**
+ * Full local teardown, best-effort: every step runs even if an earlier one
+ * fails, and failures are collected into `errors`. Spec §A.
+ */
+export function uninstallEverything(deps = {}) {
+    const availability = deps.availability ?? supervisorAvailability;
+    const uninstallDaemon = deps.uninstallDaemon ?? uninstallSupervised;
+    const errors = [];
+    let daemon;
+    const supervisor = availability();
+    if (!supervisor.available) {
+        daemon = { status: "skipped", reason: supervisor.reason };
+    }
+    else {
+        try {
+            uninstallDaemon();
+            daemon = { status: "removed" };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            daemon = { status: "failed", reason: message };
+            errors.push({ step: "daemon", message });
+        }
+    }
+    const skills = [];
+    for (const agent of SUPPORTED_AGENTS) {
+        try {
+            skills.push(uninstallSkill(agent, { home: deps.home, cwd: deps.cwd }));
+        }
+        catch (err) {
+            errors.push({ step: `skill:${agent}`, message: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    const p = paths();
+    const dirs = [];
+    for (const dir of [p.configDir, p.dataDir, p.stateDir]) {
+        try {
+            const existed = existsSync(dir);
+            if (existed)
+                rmSync(dir, { recursive: true, force: true });
+            dirs.push({ path: dir, removed: existed });
+        }
+        catch (err) {
+            dirs.push({ path: dir, removed: false });
+            errors.push({ step: `dir:${dir}`, message: err instanceof Error ? err.message : String(err) });
+        }
+    }
+    return { ok: errors.length === 0, daemon, skills, dirs, hint: UNINSTALL_HINT, errors };
+}

package/dist/lib/paths.js

@@ -12,10 +12,6 @@ export function paths() {
         configDir,
         dataDir,
         stateDir,
-        configFile: join(configDir, "config.json"),
-        authFile: join(dataDir, "auth.json"),
-        pendingSignupFile: join(dataDir, "pending-signup.json"),
-        localTargetsFile: join(configDir, "local-targets.json"),
         listenLog: join(stateDir, "listen.log"),
         listenOutLog: join(stateDir, "listen.out.log"),
         listenErrLog: join(stateDir, "listen.err.log"),

package/dist/lib/skill-install.js

@@ -78,6 +78,17 @@ export function readSkillMarkdown(tarball = tarballPath()) {
         rmSync(tmp, { recursive: true, force: true });
     }
 }
+/** Removes the agent's installed `dial-cli` skill directory, if present. */
+export function uninstallSkill(agent, opts = {}) {
+    const home = opts.home ?? process.env.HOME ?? homedir();
+    const cwd = opts.cwd ?? process.cwd();
+    const skillDir = dirname(targetPath(agent, home, cwd));
+    if (!existsSync(skillDir)) {
+        return { agent, path: skillDir, removed: false };
+    }
+    rmSync(skillDir, { recursive: true, force: true });
+    return { agent, path: skillDir, removed: true };
+}
 export function installSkill(agent, opts = {}) {
     const home = opts.home ?? process.env.HOME ?? homedir();
     const cwd = opts.cwd ?? process.cwd();

package/dist/lib/state.js

@@ -1,8 +1,6 @@
-import { mkdirSync, readFileSync, writeFileSync, unlinkSync, statSync, chmodSync } from "node:fs";
-import { dirname } from "node:path";
 import { z } from "zod";
 import { paths } from "./paths.js";
-import { logger } from "./log.js";
+import { defineVersionedFile } from "./versioned-file.js";
 export const AuthSchema = z.object({
     apiKey: z.string(),
     accountId: z.string(),
@@ -15,81 +13,41 @@ export const PendingSignupSchema = z.object({
     email: z.string(),
     createdAt: z.string(),
 });
-const CHMOD_UNSUPPORTED_CODES = new Set(["ENOTSUP", "EOPNOTSUPP", "EPERM"]);
-function ensureDir(path) {
-    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-    try {
-        chmodSync(dirname(path), 0o700);
-    }
-    catch (err) {
-        const code = err.code;
-        if (code && CHMOD_UNSUPPORTED_CODES.has(code)) {
-            logger.warn({ err, code, path: dirname(path) }, "chmod 0700 unsupported, continuing");
-            return;
-        }
-        throw err;
-    }
-}
-function readSecure(path, schema) {
-    let stat;
-    try {
-        stat = statSync(path);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return null;
-        throw err;
-    }
-    const mode = stat.mode & 0o777;
-    if (mode & 0o077) {
-        throw new Error(`${path} has insecure permissions (mode ${mode.toString(8)})`);
-    }
-    const raw = readFileSync(path, "utf8");
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        logger.warn({ err, path }, "failed to parse state file");
-        return null;
-    }
-    const result = schema.safeParse(parsed);
-    if (!result.success) {
-        logger.warn({ path, issues: result.error.issues }, "state file did not match expected schema");
-        return null;
-    }
-    return result.data;
-}
-function writeSecure(path, data) {
-    ensureDir(path);
-    writeFileSync(path, JSON.stringify(data, null, 2), { mode: 0o600 });
-    chmodSync(path, 0o600);
-}
+const authFile = defineVersionedFile({
+    dir: () => paths().dataDir,
+    base: "auth",
+    version: 1,
+    schema: AuthSchema,
+    migrations: { 0: (legacy) => legacy },
+    secure: true,
+});
+const pendingSignupFile = defineVersionedFile({
+    dir: () => paths().dataDir,
+    base: "pending-signup",
+    version: 1,
+    schema: PendingSignupSchema,
+    migrations: { 0: (legacy) => legacy },
+    secure: true,
+});
 export function readAuth() {
-    return readSecure(paths().authFile, AuthSchema);
+    return authFile.read();
 }
 export function writeAuth(auth) {
-    writeSecure(paths().authFile, auth);
-}
-function unlinkIfExists(path) {
-    try {
-        unlinkSync(path);
-    }
-    catch (err) {
-        if (err.code === "ENOENT")
-            return;
-        throw err;
-    }
+    authFile.write(auth);
 }
 export function clearAuth() {
-    unlinkIfExists(paths().authFile);
+    authFile.clear();
+}
+/** Where the API key lives, for display (doctor). */
+export function authFilePath() {
+    return authFile.path;
 }
 export function readPendingSignup() {
-    return readSecure(paths().pendingSignupFile, PendingSignupSchema);
+    return pendingSignupFile.read();
 }
 export function writePendingSignup(p) {
-    writeSecure(paths().pendingSignupFile, p);
+    pendingSignupFile.write(p);
 }
 export function clearPendingSignup() {
-    unlinkIfExists(paths().pendingSignupFile);
+    pendingSignupFile.clear();
 }

package/dist/lib/update.js

@@ -0,0 +1,125 @@
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, realpathSync } from "node:fs";
+import { dirname, join, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { appendJsonl, logger } from "./log.js";
+import { paths } from "./paths.js";
+import { defineVersionedFile } from "./versioned-file.js";
+export const AUTO_UPDATE_INTERVAL_MS = 60 * 60 * 1000;
+export const AUTO_UPDATE_EXEMPT_COMMANDS = new Set(["update", "uninstall"]);
+export function detectInstallKind(scriptPath, binOverride = process.env.DIAL_BIN_OVERRIDE) {
+    if (binOverride)
+        return "other";
+    let real = scriptPath;
+    try {
+        real = realpathSync(scriptPath);
+    }
+    catch (err) {
+        logger.debug({ err, scriptPath }, "could not resolve script path, classifying as-is");
+    }
+    if (/[/\\]_npx[/\\]/.test(real))
+        return "npx";
+    if (real.includes(`${sep}node_modules${sep}@getdial${sep}cli${sep}`))
+        return "global-npm";
+    return "other";
+}
+const updateCheckFile = defineVersionedFile({
+    dir: () => paths().stateDir,
+    base: "update-check",
+    version: 1,
+    schema: z.object({ lastAttemptAt: z.string() }),
+    migrations: {},
+});
+/** Attempt-based throttle: a persistently failing npm still only retries hourly. */
+export function updateCheckDue(now) {
+    const stamp = updateCheckFile.read();
+    if (!stamp)
+        return true;
+    const last = Date.parse(stamp.lastAttemptAt);
+    if (Number.isNaN(last))
+        return true;
+    return now.getTime() - last >= AUTO_UPDATE_INTERVAL_MS;
+}
+export function recordUpdateAttempt(now) {
+    updateCheckFile.write({ lastAttemptAt: now.toISOString() });
+}
+export function shouldAutoUpdate(input) {
+    if (input.env.DIAL_NO_AUTO_UPDATE === "1")
+        return false;
+    if (AUTO_UPDATE_EXEMPT_COMMANDS.has(input.command))
+        return false;
+    if (detectInstallKind(input.scriptPath, input.env.DIAL_BIN_OVERRIDE) !== "global-npm")
+        return false;
+    return updateCheckDue(input.now);
+}
+/** Prefers the npm sitting next to the running node, like resolveListenCommand does for npx. */
+export function npmUpdateCommand() {
+    const sibling = join(dirname(process.execPath), "npm");
+    return {
+        command: existsSync(sibling) ? sibling : "npm",
+        args: ["install", "-g", "@getdial/cli@latest"],
+    };
+}
+function packageJsonPath() {
+    // dist/lib/update.js (or src/lib/update.ts under tsx) → ../../package.json.
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+}
+/**
+ * The version installed on disk right now — unlike VERSION, which is whatever
+ * was on disk when this process started. The two diverge after an update.
+ */
+export function installedVersion() {
+    const pkg = JSON.parse(readFileSync(packageJsonPath(), "utf8"));
+    return pkg.version;
+}
+/**
+ * Failures of the background path go to cli.log, never stdout/stderr — the
+ * hook runs under --json consumers and the MCP stdio server.
+ */
+function logUpdateFailure(context, err) {
+    const line = {
+        ts: new Date().toISOString(),
+        source: "auto-update",
+        context,
+        error: err instanceof Error ? (err.stack ?? err.message) : String(err),
+    };
+    try {
+        appendJsonl(paths().cliLog, line);
+    }
+    catch (logErr) {
+        logger.warn({ err, logErr, context }, "auto-update failed and could not write cli.log");
+    }
+}
+/** Spawns the npm update fully detached, stdio appended to cli.log. Never throws. */
+export function spawnDetachedUpdate() {
+    try {
+        const p = paths();
+        mkdirSync(p.stateDir, { recursive: true });
+        const fd = openSync(p.cliLog, "a");
+        const { command, args } = npmUpdateCommand();
+        const child = spawn(command, args, { detached: true, stdio: ["ignore", fd, fd] });
+        child.unref();
+        closeSync(fd);
+    }
+    catch (err) {
+        logUpdateFailure("spawn", err);
+    }
+}
+/**
+ * The hourly background check, called from the CLI's preAction hook. Records
+ * the attempt before spawning and never throws — a broken update path must
+ * not break the command the user actually ran.
+ */
+export function maybeAutoUpdate(command) {
+    try {
+        const now = new Date();
+        if (!shouldAutoUpdate({ command, scriptPath: process.argv[1] ?? "", env: process.env, now }))
+            return;
+        recordUpdateAttempt(now);
+        spawnDetachedUpdate();
+    }
+    catch (err) {
+        logUpdateFailure(`check:${command}`, err);
+    }
+}

package/dist/lib/versioned-file.js

@@ -0,0 +1,132 @@
+import { chmodSync, mkdirSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { logger } from "./log.js";
+const CHMOD_UNSUPPORTED_CODES = new Set(["ENOTSUP", "EOPNOTSUPP", "EPERM"]);
+function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    try {
+        chmodSync(dir, 0o700);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code && CHMOD_UNSUPPORTED_CODES.has(code)) {
+            logger.warn({ err, code, path: dir }, "chmod 0700 unsupported, continuing");
+            return;
+        }
+        throw err;
+    }
+}
+function statIfExists(path) {
+    try {
+        return statSync(path);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+function unlinkIfExists(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+export function defineVersionedFile(opts) {
+    const mode = opts.mode ?? 0o600;
+    /** v0 is the legacy unversioned `<base>.json`. */
+    const filePath = (version) => join(opts.dir(), version === 0 ? `${opts.base}.json` : `${opts.base}.v${version}.json`);
+    function parseAt(path) {
+        if (opts.secure) {
+            const fileMode = statSync(path).mode & 0o777;
+            if (fileMode & 0o077) {
+                throw new Error(`${path} has insecure permissions (mode ${fileMode.toString(8)})`);
+            }
+        }
+        try {
+            return JSON.parse(readFileSync(path, "utf8"));
+        }
+        catch (err) {
+            logger.warn({ err, path }, "failed to parse state file");
+            return null;
+        }
+    }
+    function validate(value, path) {
+        const result = opts.schema.safeParse(value);
+        if (!result.success) {
+            logger.warn({ path, issues: result.error.issues }, "state file did not match expected schema");
+            return null;
+        }
+        return result.data;
+    }
+    function write(value) {
+        ensureDir(opts.dir());
+        const path = filePath(opts.version);
+        const tmp = `${path}.tmp`;
+        writeFileSync(tmp, JSON.stringify(value, null, 2), { mode });
+        try {
+            chmodSync(tmp, mode);
+        }
+        catch (err) {
+            const code = err.code;
+            if (!code || !CHMOD_UNSUPPORTED_CODES.has(code))
+                throw err;
+            logger.warn({ err, code, path: tmp }, "chmod unsupported, relying on create mode");
+        }
+        renameSync(tmp, path);
+    }
+    function migrateFrom(found, payload, foundPath) {
+        let value = payload;
+        for (let step = found; step < opts.version; step++) {
+            const migration = opts.migrations[step];
+            if (!migration) {
+                logger.warn({ path: foundPath, from: step, to: step + 1 }, "no migration registered for state file version");
+                return null;
+            }
+            try {
+                value = migration(value);
+            }
+            catch (err) {
+                logger.warn({ err, path: foundPath, from: step, to: step + 1 }, "state file migration failed");
+                return null;
+            }
+        }
+        const migrated = validate(value, foundPath);
+        if (migrated === null)
+            return null;
+        write(migrated);
+        unlinkIfExists(foundPath);
+        return migrated;
+    }
+    function read() {
+        for (let version = opts.version; version >= 0; version--) {
+            const path = filePath(version);
+            if (!statIfExists(path))
+                continue;
+            const payload = parseAt(path);
+            if (payload === null)
+                return null;
+            if (version === opts.version)
+                return validate(payload, path);
+            return migrateFrom(version, payload, path);
+        }
+        return null;
+    }
+    function clear() {
+        for (let version = opts.version; version >= 0; version--) {
+            unlinkIfExists(filePath(version));
+        }
+    }
+    return {
+        read,
+        write,
+        clear,
+        get path() {
+            return filePath(opts.version);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getdial/cli",
-  "version": "0.19.1",
+  "version": "0.20.1",
   "description": "Dial CLI — install, sign up, and run the local listen service.",
   "license": "MIT",
   "repository": {