tokmon 0.28.6 → 0.28.8

package/dist/{chunk-23NB5Z6V.js → chunk-MIXBF6QU.js}

@@ -1,12 +1,14 @@
 #!/usr/bin/env node
 import {
+  classifyDaemonCompatibility,
+  daemonConflictMessage,
   isAlive,
   probeHealth,
   readForeignLock,
   readLock,
   retireIncompatibleCliOwner,
   verifyLock
-} from "./chunk-MMAKKTCU.js";
+} from "./chunk-WHOIUSJM.js";
 import {
   daemonChannelFromWire,
   resolveDaemonChannel
@@ -54,26 +56,43 @@ async function attach(opts, protocolVersion) {
   const lock = await verifyLock(readLock(opts), protocolVersion);
   return lock ? connected(lock.url) : null;
 }
-async function incompatibleDesktopIssue(opts, protocolVersion, timeoutMs) {
+function incompatibleOwnerIssue(owner, protocolVersion, options = {}) {
+  return {
+    kind: owner.ownerKind === "desktop" ? "incompatible-desktop" : owner.ownerKind === "cli" ? "incompatible-cli" : "incompatible-owner",
+    message: daemonConflictMessage(owner, {
+      clientKind: "cli",
+      clientProtocolVersion: protocolVersion,
+      ...options
+    }),
+    ownerKind: owner.ownerKind ?? null,
+    ownerVersion: owner.version ?? null,
+    ownerProtocolVersion: owner.protocolVersion ?? null,
+    clientProtocolVersion: protocolVersion
+  };
+}
+async function arbitrateIncompatibleOwner(opts, protocolVersion, timeoutMs) {
   const owner = readForeignLock(opts);
-  if (!owner || owner.ownerKind !== "desktop" || owner.protocolVersion === void 0 || owner.protocolVersion === protocolVersion || !isAlive(owner.pid)) return null;
+  if (!owner || !isAlive(owner.pid)) return { retired: false, issue: null };
+  const decision = classifyDaemonCompatibility(owner, protocolVersion);
   const verified = await probeHealth(owner.url, owner.wsToken, {
-    ownerKind: "desktop",
     channel: owner.channel,
-    protocolVersion: owner.protocolVersion,
+    ...owner.ownerKind ? { ownerKind: owner.ownerKind } : {},
+    ...owner.protocolVersion === void 0 ? {} : { protocolVersion: owner.protocolVersion },
     ...owner.version ? { version: owner.version } : {}
   }, Math.min(500, timeoutMs));
-  if (!verified) return null;
-  const ownerIsOlder = owner.protocolVersion < protocolVersion;
-  const direction = ownerIsOlder ? "an older" : "a newer";
-  const ownerName = owner.version ? `Tokmon Desktop ${owner.version}` : "Tokmon Desktop";
-  const recovery = ownerIsOlder ? "Update and restart the desktop app, or quit it before running the CLI." : "Update the CLI, or quit the desktop app before running this version. With pnpm release-age filtering, use `pnpm --config.minimum-release-age=0 dlx tokmon@latest` once.";
-  return {
-    kind: "incompatible-desktop",
-    message: `${ownerName} is using ${direction} background service (protocol ${owner.protocolVersion}; this CLI needs ${protocolVersion}). ${recovery}`,
-    ownerVersion: owner.version ?? null,
-    ownerProtocolVersion: owner.protocolVersion,
-    clientProtocolVersion: protocolVersion
+  if (!verified) {
+    return {
+      retired: false,
+      issue: incompatibleOwnerIssue(owner, protocolVersion, { verificationFailed: true })
+    };
+  }
+  if (decision.action !== "retire") {
+    return { retired: false, issue: incompatibleOwnerIssue(owner, protocolVersion) };
+  }
+  const retired = await retireIncompatibleCliOwner(opts, protocolVersion, timeoutMs);
+  return retired ? { retired: true, issue: null } : {
+    retired: false,
+    issue: incompatibleOwnerIssue(owner, protocolVersion, { retirementFailed: true })
   };
 }
 async function attachOrSpawn(opts = {}) {
@@ -84,11 +103,21 @@ async function attachOrSpawn(opts = {}) {
   const lockOpts = { cachePath: opts.cachePath, channel };
   const existing = await attach(lockOpts, protocolVersion);
   if (existing) return existing;
-  const desktopIssue = await incompatibleDesktopIssue(lockOpts, protocolVersion, timeoutMs);
-  if (desktopIssue) return degraded(desktopIssue);
-  await retireIncompatibleCliOwner(lockOpts, protocolVersion, timeoutMs);
-  const upgraded = await attach(lockOpts, protocolVersion);
-  if (upgraded) return upgraded;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const arbitration = await arbitrateIncompatibleOwner(lockOpts, protocolVersion, timeoutMs);
+    if (arbitration.issue) return degraded(arbitration.issue);
+    if (!arbitration.retired) break;
+    const upgraded = await attach(lockOpts, protocolVersion);
+    if (upgraded) return upgraded;
+  }
+  const raced = await attach(lockOpts, protocolVersion);
+  if (raced) return raced;
+  const raceArbitration = await arbitrateIncompatibleOwner(lockOpts, protocolVersion, timeoutMs);
+  if (raceArbitration.issue) return degraded(raceArbitration.issue);
+  if (raceArbitration.retired) {
+    const replacement = await attach(lockOpts, protocolVersion);
+    if (replacement) return replacement;
+  }
   const entry = opts.entry ?? process.argv[1];
   if (!entry) return degraded();
   const execPath = opts.execPath ?? process.execPath;

package/dist/{chunk-MMAKKTCU.js → chunk-WHOIUSJM.js}

@@ -7,6 +7,52 @@ import {
   cacheDir
 } from "./chunk-O7ORALKA.js";
 
+// src/web/daemon-compatibility.ts
+function classifyDaemonCompatibility(owner, clientProtocolVersion) {
+  if (owner.protocolVersion === clientProtocolVersion) {
+    return { action: "attach", reason: "same-protocol" };
+  }
+  if (owner.ownerKind === "desktop") {
+    return { action: "refuse", reason: "desktop-owner" };
+  }
+  if (owner.ownerKind === "cli" && owner.protocolVersion !== void 0) {
+    return owner.protocolVersion < clientProtocolVersion ? { action: "retire", reason: "older-cli" } : { action: "refuse", reason: "newer-cli" };
+  }
+  if (owner.ownerKind === void 0 && owner.protocolVersion === void 0) {
+    return { action: "retire", reason: "legacy-cli" };
+  }
+  return { action: "refuse", reason: "ambiguous-owner" };
+}
+function daemonConflictMessage(owner, context) {
+  const kind = owner.ownerKind === "desktop" ? "Tokmon Desktop" : owner.ownerKind === "cli" ? "Tokmon CLI background service" : "Legacy Tokmon background service";
+  const name = owner.version ? `${kind} ${owner.version}` : kind;
+  const ownerProtocol = owner.protocolVersion === void 0 ? "an implicit legacy protocol" : `protocol ${owner.protocolVersion}`;
+  const client = context.clientKind === "desktop" ? "this desktop app" : "this CLI";
+  if (context.verificationFailed) {
+    return `A live lock claims ${name} using ${ownerProtocol}, but its owner proof could not be verified. It was not signalled. Quit the existing Tokmon process, remove a stale lock only after confirming it has stopped, then retry.`;
+  }
+  if (owner.protocolVersion === context.clientProtocolVersion) {
+    return `${name} claims compatible protocol ${context.clientProtocolVersion}, but its owner proof could not be verified. It was not signalled. Quit the existing Tokmon process, then retry.`;
+  }
+  const summary = `${name} owns the background service using ${ownerProtocol}; ${client} needs protocol ${context.clientProtocolVersion}.`;
+  if (context.retirementFailed) {
+    return `${summary} Tokmon could not stop that older CLI service safely, so it was left running. Quit the existing Tokmon CLI/background service, then retry.`;
+  }
+  if (owner.ownerKind === "desktop") {
+    if (context.clientKind === "desktop") {
+      return owner.protocolVersion !== void 0 && owner.protocolVersion < context.clientProtocolVersion ? `${summary} Fully quit the older Tokmon Desktop instance, install the current release, then reopen Tokmon.` : `${summary} This app is older than the running Tokmon Desktop instance. Reopen the newer app, or replace this installation with the current release.`;
+    }
+    if (owner.protocolVersion !== void 0 && owner.protocolVersion < context.clientProtocolVersion) {
+      return `${summary} In Tokmon Desktop, open Settings \u2192 Desktop App \u2192 Check for Updates, install the update, then restart Tokmon. Alternatively, quit Tokmon Desktop before retrying the CLI.`;
+    }
+    return `${summary} Update the CLI with \`pnpm --config.minimum-release-age=0 dlx tokmon@latest\`, or quit Tokmon Desktop before retrying this CLI.`;
+  }
+  if (owner.ownerKind === "cli" && owner.protocolVersion !== void 0 && owner.protocolVersion > context.clientProtocolVersion) {
+    return context.clientKind === "desktop" ? `${summary} Update Tokmon Desktop and restart it, or stop the newer CLI background service before reopening the app.` : `${summary} Update the CLI with \`pnpm --config.minimum-release-age=0 dlx tokmon@latest\`, or stop the newer background service before retrying.`;
+  }
+  return `${summary} The owner could not be identified safely and was not signalled. Quit the existing Tokmon process, then retry.`;
+}
+
 // src/web/lockfile.ts
 import { closeSync, fchmodSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
 import { isAbsolute, join } from "path";
@@ -247,11 +293,11 @@ async function retireIncompatibleCliOwner(opts, protocolVersion, timeoutMs = TAK
   const compatible = readLock(opts);
   if (compatible?.protocolVersion === protocolVersion) return false;
   const foreign = readForeignLock(opts);
-  const legacyCli = foreign?.ownerKind === void 0 && foreign?.protocolVersion === void 0;
-  if (!foreign || foreign.state !== "ready" || foreign.ownerKind === "desktop" || foreign.ownerKind !== "cli" && !legacyCli || foreign.pid === process.pid || !isAlive(foreign.pid)) return false;
+  const decision = foreign && classifyDaemonCompatibility(foreign, protocolVersion);
+  if (!foreign || foreign.state !== "ready" || decision?.action !== "retire" || foreign.pid === process.pid || !isAlive(foreign.pid)) return false;
   const health = await ownerHealth(foreign.url, foreign.wsToken, Math.min(1e3, timeoutMs));
   const healthChannel = daemonChannelFromWire(health?.channel);
-  if (health?.ok !== true || health.owner !== true || health.ownerKind !== void 0 && health.ownerKind !== "cli" || healthChannel !== foreign.channel) return false;
+  if (health?.ok !== true || health.owner !== true || (decision.reason === "legacy-cli" ? health.ownerKind !== void 0 || health.protocolVersion !== void 0 : health.ownerKind !== "cli" || health.protocolVersion !== foreign.protocolVersion) || healthChannel !== foreign.channel) return false;
   try {
     process.kill(foreign.pid, "SIGTERM");
   } catch {
@@ -279,6 +325,8 @@ async function retireIncompatibleCliOwner(opts, protocolVersion, timeoutMs = TAK
 }
 
 export {
+  classifyDaemonCompatibility,
+  daemonConflictMessage,
   lockfilePath,
   readLock,
   readForeignLock,

package/dist/{cli-command-MW6EBLNA.js → cli-command-XPFM6LUP.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   attachOrSpawn
-} from "./chunk-23NB5Z6V.js";
-import "./chunk-MMAKKTCU.js";
+} from "./chunk-MIXBF6QU.js";
+import "./chunk-WHOIUSJM.js";
 import "./chunk-UYPDMVW5.js";
 import {
   createDaemonRpcClient

package/dist/cli.js

@@ -41,7 +41,7 @@ function validateServeArgs(serveArgs) {
 }
 async function main() {
   if (subcommand && ["usage", "models", "query", "providers", "snapshot", "config"].includes(subcommand)) {
-    const { runQueryCommand } = await import("./cli-command-MW6EBLNA.js");
+    const { runQueryCommand } = await import("./cli-command-XPFM6LUP.js");
     try {
       const output = await runQueryCommand(
         subcommand,
@@ -60,14 +60,14 @@ Run tokmon ${subcommand} --help for usage.
     return;
   }
   if (subcommand === "__daemon") {
-    const { runDaemon } = await import("./daemon-XB6ZORTE.js");
+    const { runDaemon } = await import("./daemon-KFMXYG7V.js");
     await runDaemon(args.slice(1), { foreground: false });
     process.exitCode ??= 0;
     return;
   }
   if (subcommand === "serve" || subcommand === "web") {
     validateServeArgs(args.slice(1));
-    const { runDaemon } = await import("./daemon-XB6ZORTE.js");
+    const { runDaemon } = await import("./daemon-KFMXYG7V.js");
     await runDaemon(args.slice(1), { foreground: true });
     process.exitCode ??= 0;
     return;
@@ -117,7 +117,7 @@ Run tokmon ${subcommand} --help for usage.
   }
   const { loadConfig } = await import("./config-JEDXAKPZ.js");
   const { resolveGlyphs, setGlyphs } = await import("./glyphs-NKCSZLGO.js");
-  const { attachOrSpawn } = await import("./daemon-handle-4WDYZBVL.js");
+  const { attachOrSpawn } = await import("./daemon-handle-6RYUJPC2.js");
   const config = await loadConfig();
   setGlyphs(resolveGlyphs({
     flag: asciiFlag,

package/dist/{daemon-XB6ZORTE.js → daemon-KFMXYG7V.js}

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import {
   acquireLock,
+  classifyDaemonCompatibility,
+  daemonConflictMessage,
   isAlive,
   lockfilePath,
   readForeignLock,
@@ -12,7 +14,7 @@ import {
   unlinkLock,
   verifyLock,
   writeLock
-} from "./chunk-MMAKKTCU.js";
+} from "./chunk-WHOIUSJM.js";
 import {
   appVersion,
   startWebServer
@@ -40,9 +42,13 @@ var OWNER_VERIFY_TIMEOUT_MS = 250;
 var OWNER_TAKEOVER_TIMEOUT_MS = 5e3;
 var localOwners = /* @__PURE__ */ new Map();
 var DaemonOwnerUnavailableError = class extends Error {
-  constructor(message) {
+  owner;
+  clientProtocolVersion;
+  constructor(message, owner = null, clientProtocolVersion = null) {
     super(message);
     this.name = "DaemonOwnerUnavailableError";
+    this.owner = owner;
+    this.clientProtocolVersion = clientProtocolVersion;
   }
 };
 var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
@@ -79,12 +85,31 @@ async function waitForOwner(opts, protocolVersion) {
   }
   return null;
 }
-function incompatibleOwnerError(lock) {
-  if (!lock) return new DaemonOwnerUnavailableError("another legacy CLI daemon owns the lock and could not be retired safely");
+function incompatibleOwnerError(owner, opts, protocolVersion, retirementFailed = false) {
   return new DaemonOwnerUnavailableError(
-    `another ${lock.ownerKind} daemon owns the lock but is not compatible with protocol ${lock.protocolVersion}`
+    daemonConflictMessage(owner, {
+      clientKind: opts.ownerKind,
+      clientProtocolVersion: protocolVersion,
+      retirementFailed
+    }),
+    owner,
+    protocolVersion
   );
 }
+async function retireOrRefuseOwner(owner, opts, protocolVersion) {
+  const decision = classifyDaemonCompatibility(owner, protocolVersion);
+  if (decision.action !== "retire") {
+    throw incompatibleOwnerError(owner, opts, protocolVersion);
+  }
+  const retired = await retireIncompatibleCliOwner(
+    opts,
+    protocolVersion,
+    opts.ownerTakeoverTimeoutMs ?? OWNER_TAKEOVER_TIMEOUT_MS
+  );
+  if (!retired) {
+    throw incompatibleOwnerError(owner, opts, protocolVersion, true);
+  }
+}
 async function discoverOwner(opts, protocolVersion) {
   const local = localOwnerFor(opts, protocolVersion);
   if (local) return local;
@@ -104,25 +129,14 @@ async function discoverOwner(opts, protocolVersion) {
     current = readLock(opts);
   }
   if (current && isAlive(current.pid)) {
-    const retired = await retireIncompatibleCliOwner(
-      opts,
-      protocolVersion,
-      opts.ownerTakeoverTimeoutMs ?? OWNER_TAKEOVER_TIMEOUT_MS
-    );
-    if (retired) return null;
-    throw incompatibleOwnerError(current);
+    await retireOrRefuseOwner(current, opts, protocolVersion);
+    return null;
   }
   if (current) reclaimDeadLock(opts);
   const foreign = readForeignLock(opts);
   if (foreign && isAlive(foreign.pid)) {
-    if (await retireIncompatibleCliOwner(
-      opts,
-      protocolVersion,
-      opts.ownerTakeoverTimeoutMs ?? OWNER_TAKEOVER_TIMEOUT_MS
-    )) return null;
-    throw incompatibleOwnerError(
-      foreign.ownerKind && foreign.protocolVersion ? { ownerKind: foreign.ownerKind, protocolVersion: foreign.protocolVersion } : null
-    );
+    await retireOrRefuseOwner(foreign, opts, protocolVersion);
+    return null;
   }
   return null;
 }
@@ -143,36 +157,23 @@ function reservationFor(opts, version, protocolVersion, capabilities) {
   };
 }
 async function reserveOwnership(opts, reservation) {
-  if (acquireLock(reservation, opts)) return null;
-  const winner = await waitForOwner(opts, reservation.protocolVersion);
-  if (winner) return winner;
-  const current = readLock(opts);
-  if (current && isAlive(current.pid)) {
-    const retired = await retireIncompatibleCliOwner(
-      opts,
-      reservation.protocolVersion,
-      opts.ownerTakeoverTimeoutMs ?? OWNER_TAKEOVER_TIMEOUT_MS
-    );
-    if (!retired) throw incompatibleOwnerError(current);
+  for (let attempt = 0; attempt < 3; attempt++) {
     if (acquireLock(reservation, opts)) return null;
-    const successor2 = await waitForOwner(opts, reservation.protocolVersion);
-    if (successor2) return successor2;
-  }
-  if (current) reclaimDeadLock(opts);
-  const foreign = readForeignLock(opts);
-  if (foreign && isAlive(foreign.pid)) {
-    const retired = await retireIncompatibleCliOwner(
-      opts,
-      reservation.protocolVersion,
-      opts.ownerTakeoverTimeoutMs ?? OWNER_TAKEOVER_TIMEOUT_MS
-    );
-    if (!retired) throw incompatibleOwnerError(
-      foreign.ownerKind && foreign.protocolVersion ? { ownerKind: foreign.ownerKind, protocolVersion: foreign.protocolVersion } : null
-    );
+    const winner = await waitForOwner(opts, reservation.protocolVersion);
+    if (winner) return winner;
+    const current = readLock(opts);
+    if (current && isAlive(current.pid)) {
+      await retireOrRefuseOwner(current, opts, reservation.protocolVersion);
+      continue;
+    }
+    if (current) reclaimDeadLock(opts);
+    const foreign = readForeignLock(opts);
+    if (foreign && isAlive(foreign.pid)) {
+      await retireOrRefuseOwner(foreign, opts, reservation.protocolVersion);
+      continue;
+    }
+    reclaimAbandonedLock(opts, 0);
   }
-  if (acquireLock(reservation, opts)) return null;
-  const successor = await waitForOwner(opts, reservation.protocolVersion);
-  if (successor) return successor;
   throw new DaemonOwnerUnavailableError("daemon startup is already in progress");
 }
 function owned(opts, lock, config, server) {
@@ -212,6 +213,7 @@ async function acquireOrAttachDaemon(opts) {
     protocolVersion,
     capabilities
   );
+  await opts.beforeReserve?.();
   const winner = await reserveOwnership(opts, reservation);
   if (winner) return attached(winner);
   let server = null;

package/dist/{daemon-handle-4WDYZBVL.js → daemon-handle-6RYUJPC2.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import {
   attachOrSpawn
-} from "./chunk-23NB5Z6V.js";
-import "./chunk-MMAKKTCU.js";
+} from "./chunk-MIXBF6QU.js";
+import "./chunk-WHOIUSJM.js";
 import "./chunk-UYPDMVW5.js";
 import "./chunk-UON47FYF.js";
 import "./chunk-O7ORALKA.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tokmon",
-  "version": "0.28.6",
+  "version": "0.28.8",
   "description": "Terminal + web dashboard for Claude Code, Codex, Cursor, Grok, opencode, pi, Copilot, Gemini & more — usage, limits, and costs",
   "type": "module",
   "bin": {