tokmon 0.28.1 → 0.28.2

package/dist/{bootstrap-ink-L7QSJBMS.js → bootstrap-ink-IMT3S5HU.js}

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   createDaemonRpcClient
-} from "./chunk-3RTWFGGD.js";
+} from "./chunk-M7XMV36F.js";
 import {
   accountsByProvider,
   buildAccounts,
   fetchPeak,
   modelColor
-} from "./chunk-FMP3P2WV.js";
+} from "./chunk-44ZSQEOS.js";
 import {
   PROVIDERS,
   PROVIDER_ORDER,
@@ -24,7 +24,8 @@ import {
   time,
   tokens,
   withTimeout
-} from "./chunk-CVKCVHS7.js";
+} from "./chunk-LCAHTRGP.js";
+import "./chunk-WUK3MQUB.js";
 import {
   COLOR_PALETTE,
   DEFAULTS,
@@ -3560,7 +3561,7 @@ function App({ interval: cliInterval, initialConfig, baseUrl = null, mode = "deg
     if (webStartingRef.current) return;
     webStartingRef.current = true;
     try {
-      const { startWebServer } = await import("./server-EUO7CWYH.js");
+      const { startWebServer } = await import("./server-GXXOWUVZ.js");
       const ctrl = await startWebServer({ config: cfg, log: false });
       webRef.current = ctrl;
       openUrl(ctrl.url);

package/dist/{chunk-FMP3P2WV.js → chunk-44ZSQEOS.js}

@@ -5,7 +5,7 @@ import {
   identityFromIdToken,
   readClaudeIdentity,
   readJson
-} from "./chunk-CVKCVHS7.js";
+} from "./chunk-LCAHTRGP.js";
 import {
   expandHome,
   slugify

package/dist/{chunk-S33XIUAW.js → chunk-6ZEW2M6P.js}

@@ -1,28 +1,23 @@
 #!/usr/bin/env node
-import {
-  appVersion,
-  findWebRoot,
-  send,
-  sendJson,
-  serveStatic
-} from "./chunk-SMPY52EV.js";
 import {
   buildAccounts,
   colorHex,
   fetchPeak,
   namedHex
-} from "./chunk-FMP3P2WV.js";
+} from "./chunk-44ZSQEOS.js";
 import {
   PROVIDERS,
+  detectProviders,
+  resolveTimezone,
+  withTimeout
+} from "./chunk-LCAHTRGP.js";
+import {
   TOKMON_CAPABILITIES,
   TOKMON_PROTOCOL_VERSION,
   TOKMON_WS_METHODS,
   TOKMON_WS_PATH,
-  TokmonRpcGroup,
-  detectProviders,
-  resolveTimezone,
-  withTimeout
-} from "./chunk-CVKCVHS7.js";
+  TokmonRpcGroup
+} from "./chunk-WUK3MQUB.js";
 import {
   cacheDir,
   expandHome,
@@ -118,11 +113,127 @@ function tzFor(config) {
   return resolveTimezone(config.timezone);
 }
 
+// src/web/static.ts
+import { createReadStream, existsSync, readFileSync } from "fs";
+import { stat } from "fs/promises";
+import { fileURLToPath } from "url";
+import { extname, join, normalize, sep } from "path";
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".ico": "image/x-icon",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".map": "application/json; charset=utf-8",
+  ".webmanifest": "application/manifest+json"
+};
+function findWebRoot() {
+  const candidates = ["./web/", "../web/", "../dist/web/", "../../dist/web/"];
+  for (const rel of candidates) {
+    try {
+      const dir = fileURLToPath(new URL(rel, import.meta.url));
+      if (existsSync(join(dir, "index.html"))) return dir.replace(/[\\/]+$/, "");
+    } catch {
+    }
+  }
+  return null;
+}
+function resolveStaticPath(webRoot, urlPath) {
+  let clean;
+  try {
+    clean = decodeURIComponent(urlPath.split("?")[0]);
+  } catch {
+    return null;
+  }
+  const rel = normalize(clean).replace(/^(\.\.[/\\])+/, "").replace(/^[/\\]+/, "");
+  const full = join(webRoot, rel);
+  if (full !== webRoot && !full.startsWith(webRoot + sep)) return null;
+  return full;
+}
+function send(res, status, type, body) {
+  res.writeHead(status, {
+    "Content-Type": type,
+    "Cache-Control": "no-store",
+    "Referrer-Policy": "no-referrer",
+    "X-Content-Type-Options": "nosniff"
+  });
+  res.end(body);
+}
+function sendJson(res, status, data) {
+  send(res, status, "application/json; charset=utf-8", JSON.stringify(data));
+}
+function serveStatic(webRoot, urlPath, res) {
+  const path = urlPath.split("?")[0];
+  const filePath = resolveStaticPath(webRoot, path === "/" ? "/index.html" : path);
+  if (!filePath) {
+    send(res, 403, "text/plain", "forbidden");
+    return;
+  }
+  void stat(filePath).then((st) => {
+    if (st.isFile()) {
+      const type = MIME[extname(filePath).toLowerCase()] || "application/octet-stream";
+      const immutable = filePath.includes(`${sep}assets${sep}`);
+      res.writeHead(200, {
+        "Content-Type": type,
+        "Cache-Control": immutable ? "public, max-age=31536000, immutable" : "no-cache",
+        "Referrer-Policy": "no-referrer",
+        "X-Content-Type-Options": "nosniff"
+      });
+      createReadStream(filePath).pipe(res);
+    } else {
+      throw new Error("not a file");
+    }
+  }).catch(() => {
+    if (extname(path)) {
+      send(res, 404, "text/plain", "not found");
+      return;
+    }
+    const indexPath = join(webRoot, "index.html");
+    if (!existsSync(indexPath)) {
+      send(res, 404, "text/plain", "not found");
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": MIME[".html"],
+      "Cache-Control": "no-cache",
+      "Referrer-Policy": "no-referrer",
+      "X-Content-Type-Options": "nosniff"
+    });
+    createReadStream(indexPath).on("error", () => {
+      try {
+        res.destroy();
+      } catch {
+      }
+    }).pipe(res);
+  });
+}
+function appVersion() {
+  for (const rel of ["../package.json", "../../package.json"]) {
+    try {
+      const p = fileURLToPath(new URL(rel, import.meta.url));
+      const pkg = JSON.parse(readFileSync(p, "utf-8"));
+      if (typeof pkg.version === "string") return pkg.version;
+    } catch {
+    }
+  }
+  return "";
+}
+
 // src/web/vite-dev.ts
-import { existsSync } from "fs";
-import { fileURLToPath, pathToFileURL } from "url";
+import { existsSync as existsSync2 } from "fs";
+import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
 import { createRequire } from "module";
-import { join } from "path";
+import { join as join2 } from "path";
 function isDevMode() {
   const forced = process.env.TOKMON_WEB_MODE;
   if (forced === "dev") return true;
@@ -132,8 +243,8 @@ function isDevMode() {
 function findWebSource() {
   for (const rel of ["../../web/", "../web/", "./web/"]) {
     try {
-      const dir = fileURLToPath(new URL(rel, import.meta.url));
-      if (existsSync(join(dir, "vite.config.ts")) && existsSync(join(dir, "index.html"))) {
+      const dir = fileURLToPath2(new URL(rel, import.meta.url));
+      if (existsSync2(join2(dir, "vite.config.ts")) && existsSync2(join2(dir, "index.html"))) {
         return dir.replace(/[\\/]+$/, "");
       }
     } catch {
@@ -148,12 +259,12 @@ async function createViteDevServer(httpServer, log) {
     return null;
   }
   try {
-    const req = createRequire(pathToFileURL(join(root, "package.json")).href);
+    const req = createRequire(pathToFileURL(join2(root, "package.json")).href);
     const vitePath = req.resolve("vite");
     const vite = await import(pathToFileURL(vitePath).href);
     const dev = await vite.createServer({
       root,
-      configFile: join(root, "vite.config.ts"),
+      configFile: join2(root, "vite.config.ts"),
       server: { middlewareMode: true, hmr: { server: httpServer } },
       appType: "spa",
       clearScreen: false,
@@ -177,7 +288,7 @@ code{color:#e6b450}</style></head><body>
 </body></html>`;
 
 // src/web/data-engine.ts
-import { readFileSync, writeFileSync, mkdirSync, renameSync } from "fs";
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, renameSync } from "fs";
 
 // src/web/refresh-queue.ts
 function deferred() {
@@ -335,7 +446,7 @@ function createDataEngine(opts) {
   });
   const hydrateFromCache = () => {
     try {
-      const cached = JSON.parse(readFileSync(snapshotCacheFile(), "utf-8"));
+      const cached = JSON.parse(readFileSync2(snapshotCacheFile(), "utf-8"));
       if (!cached || !Array.isArray(cached.accounts)) return;
       for (const a of cached.accounts) {
         if (a.dashboard || a.table) {
@@ -703,11 +814,11 @@ import { Effect, Exit, Layer, Queue, Scope, Stream } from "effect";
 import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
 
 // src/web/fs.ts
-import { readdir, stat, realpath } from "fs/promises";
+import { readdir, stat as stat2, realpath } from "fs/promises";
 import { homedir } from "os";
-import { join as join2, resolve as resolvePath, isAbsolute, sep } from "path";
+import { join as join3, resolve as resolvePath, isAbsolute, sep as sep2 } from "path";
 function isContained(root, target) {
-  return target === root || target.startsWith(root + sep);
+  return target === root || target.startsWith(root + sep2);
 }
 function parentFor(root, abs) {
   const parentResolved = resolvePath(abs, "..");
@@ -727,7 +838,7 @@ async function listHomeDirectory(rawPath) {
   const abs = isContained(root, real) ? real : root;
   let st;
   try {
-    st = await stat(abs);
+    st = await stat2(abs);
   } catch {
     return { path: abs, parent: parentFor(root, abs), entries: [] };
   }
@@ -742,7 +853,7 @@ async function listHomeDirectory(rawPath) {
   for (const d of dirents) {
     if (d.name.startsWith(".")) continue;
     let dir = d.isDirectory();
-    const full = join2(abs, d.name);
+    const full = join3(abs, d.name);
     if (d.isSymbolicLink()) {
       let real2;
       try {
@@ -752,7 +863,7 @@ async function listHomeDirectory(rawPath) {
       }
       if (!isContained(root, real2)) continue;
       try {
-        dir = (await stat(full)).isDirectory();
+        dir = (await stat2(full)).isDirectory();
       } catch {
         continue;
       }
@@ -957,7 +1068,7 @@ function guardSameOrigin(req, res) {
   }
   return true;
 }
-function createRouter(engine, state, vite, webRoot, wsToken, version) {
+function createRouter(engine, state, vite, webRoot, wsToken, version, protocolVersion, capabilities, ownerKind) {
   return (req, res) => {
     const url = req.url || "/";
     const path = url.split("?")[0];
@@ -973,6 +1084,9 @@ function createRouter(engine, state, vite, webRoot, wsToken, version) {
         ok: true,
         ready: engine.snapshot() !== null,
         version,
+        protocolVersion,
+        capabilities,
+        ownerKind,
         // Discovery requires this proof; public health checks retain their useful 200 response.
         owner: tokenMatches(header2(req, "x-tokmon-token"), wsToken)
       });
@@ -1004,6 +1118,9 @@ async function startWebServer(opts) {
   const state = { config: opts.config };
   const tz = tzFor(state.config);
   const version = appVersion();
+  const protocolVersion = opts.protocolVersion ?? TOKMON_PROTOCOL_VERSION;
+  const capabilities = opts.capabilities ?? TOKMON_CAPABILITIES;
+  const ownerKind = opts.ownerKind ?? "cli";
   const summaryIntervalMs = summaryIntervalFor(state.config);
   const billingIntervalMs = billingIntervalFor(state.config);
   const wsToken = opts.wsToken ?? randomBytes(32).toString("base64url");
@@ -1020,7 +1137,17 @@ async function startWebServer(opts) {
     const webRoot = vite ? null : findWebRoot();
     if (!vite && !webRoot) log("  \u26A0 no dashboard available \u2014 see the page for build/dev instructions");
     engine = createDataEngine({ version, config: state.config, tz, summaryIntervalMs, billingIntervalMs, resolved });
-    server.addListener("request", createRouter(engine, state, vite, webRoot, wsToken, version));
+    server.addListener("request", createRouter(
+      engine,
+      state,
+      vite,
+      webRoot,
+      wsToken,
+      version,
+      protocolVersion,
+      capabilities,
+      ownerKind
+    ));
     closeWsRpc = await mountWsRpc(server, { engine, state });
     const bindHost = state.config.allowNetworkAccess ? NETWORK_HOST : LOOPBACK_HOST;
     const port = await listenWithFallback(server, opts.port ?? DEFAULT_PORT, bindHost);
@@ -1116,5 +1243,6 @@ function listenWithFallback(server, startPort, host) {
 }
 
 export {
+  appVersion,
   startWebServer
 };

package/dist/{chunk-XDA5RJST.js → chunk-J3JW3RFP.js}

@@ -23,7 +23,7 @@ function isLoopbackUrl(value) {
 }
 function validLock(value) {
   const lock = value;
-  return !!lock && typeof lock.pid === "number" && Number.isInteger(lock.pid) && lock.pid > 0 && typeof lock.port === "number" && Number.isInteger(lock.port) && lock.port >= 0 && lock.port <= 65535 && typeof lock.url === "string" && (lock.state === "starting" || isLoopbackUrl(lock.url)) && typeof lock.wsToken === "string" && lock.wsToken.length >= 32 && typeof lock.version === "string" && typeof lock.startedAt === "number" && typeof lock.ownerId === "string" && lock.ownerId.length >= 32 && (lock.state === "starting" || lock.state === "ready");
+  return !!lock && typeof lock.pid === "number" && Number.isInteger(lock.pid) && lock.pid > 0 && typeof lock.port === "number" && Number.isInteger(lock.port) && lock.port >= 0 && lock.port <= 65535 && typeof lock.url === "string" && (lock.state === "starting" || isLoopbackUrl(lock.url)) && typeof lock.wsToken === "string" && lock.wsToken.length >= 32 && typeof lock.version === "string" && typeof lock.protocolVersion === "number" && Number.isSafeInteger(lock.protocolVersion) && lock.protocolVersion >= 1 && Array.isArray(lock.capabilities) && lock.capabilities.every((capability) => typeof capability === "string") && (lock.ownerKind === "cli" || lock.ownerKind === "desktop") && typeof lock.startedAt === "number" && typeof lock.ownerId === "string" && lock.ownerId.length >= 32 && (lock.state === "starting" || lock.state === "ready");
 }
 function readLock(opts = {}) {
   try {
@@ -161,7 +161,10 @@ function isAlive(pid) {
     return err.code === "EPERM";
   }
 }
-async function probeHealth(url, token, version, timeoutMs = 500) {
+function sameCapabilities(actual, expected) {
+  return Array.isArray(actual) && actual.length === expected.length && actual.every((capability, index) => capability === expected[index]);
+}
+async function probeHealth(url, token, expected = {}, timeoutMs = 500) {
   if (!isLoopbackUrl(url) || !token) return false;
   try {
     const res = await fetch(`${url.replace(/\/+$/, "")}/healthz`, {
@@ -170,14 +173,14 @@ async function probeHealth(url, token, version, timeoutMs = 500) {
     });
     if (!res.ok) return false;
     const body = await res.json();
-    return body.ok === true && body.owner === true && (version === void 0 || body.version === version);
+    return body.ok === true && body.owner === true && (expected.version === void 0 || body.version === expected.version) && (expected.protocolVersion === void 0 || body.protocolVersion === expected.protocolVersion) && (expected.capabilities === void 0 || sameCapabilities(body.capabilities, expected.capabilities)) && (expected.ownerKind === void 0 || body.ownerKind === expected.ownerKind);
   } catch {
     return false;
   }
 }
-async function verifyLock(lock, version, timeoutMs) {
-  if (!lock || lock.state !== "ready" || lock.version !== version || !isAlive(lock.pid)) return null;
-  return await probeHealth(lock.url, lock.wsToken, version, timeoutMs) ? lock : null;
+async function verifyLock(lock, protocolVersion, timeoutMs) {
+  if (!lock || lock.state !== "ready" || lock.protocolVersion !== protocolVersion || !isAlive(lock.pid)) return null;
+  return await probeHealth(lock.url, lock.wsToken, lock, timeoutMs) ? lock : null;
 }
 
 export {