tokmon 0.22.7 → 0.23.1

package/dist/{chunk-TNIADJ3W.js → chunk-DJPUYMZM.js}

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // src/config.ts
-import { readFile, writeFile, mkdir, rename } from "fs/promises";
-import { mkdirSync, renameSync, writeFileSync } from "fs";
+import { chmod, readFile, writeFile, mkdir, rename, unlink } from "fs/promises";
+import { chmodSync, mkdirSync, renameSync, unlinkSync, writeFileSync } from "fs";
 import { join, isAbsolute } from "path";
 import { homedir } from "os";
 
@@ -11,6 +11,7 @@ var PROVIDER_IDS = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "a
 
 // src/config-schema.ts
 var DEFAULTS = {
+  revision: 0,
   interval: 2,
   billingInterval: 5,
   clearScreen: true,
@@ -199,6 +200,7 @@ function repairConfig(input) {
   }
   const config = {
     ...DEFAULTS,
+    revision: typeof parsed.revision === "number" && Number.isSafeInteger(parsed.revision) && parsed.revision >= 0 ? parsed.revision : DEFAULTS.revision,
     interval: clampNum(parsed.interval, DEFAULTS.interval, 1),
     billingInterval: clampNum(parsed.billingInterval, DEFAULTS.billingInterval, 1),
     clearScreen: typeof parsed.clearScreen === "boolean" ? parsed.clearScreen : DEFAULTS.clearScreen,
@@ -284,12 +286,22 @@ async function loadConfig() {
   } catch {
     return { ...DEFAULTS };
   }
+  try {
+    await chmod(configDir(), 448);
+    await chmod(configLocation(), 384);
+  } catch {
+  }
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
     try {
-      await writeFile(configLocation() + ".bak", raw);
+      const dir = configDir();
+      await mkdir(dir, { recursive: true, mode: 448 });
+      await chmod(dir, 448);
+      const backup = configLocation() + ".bak";
+      await writeFile(backup, raw, { mode: 384 });
+      await chmod(backup, 384);
     } catch {
     }
     return { ...DEFAULTS };
@@ -304,30 +316,51 @@ async function loadConfig() {
   return repaired.config;
 }
 var saveQueue = Promise.resolve();
+var tempSequence = 0;
+function configTempFile(dir) {
+  tempSequence = (tempSequence + 1) % Number.MAX_SAFE_INTEGER;
+  return join(dir, `config.json.${process.pid}.${Date.now()}.${tempSequence}.tmp`);
+}
 function configJson(config) {
   return JSON.stringify(normalizeConfig(config), null, 2) + "\n";
 }
 function saveConfig(config) {
-  saveQueue = saveQueue.then(async () => {
+  const write = async () => {
+    const dir = configDir();
+    await mkdir(dir, { recursive: true, mode: 448 });
+    await chmod(dir, 448);
+    const tmp = configTempFile(dir);
     try {
-      const dir = configDir();
-      await mkdir(dir, { recursive: true });
-      const tmp = join(dir, `config.json.${process.pid}.tmp`);
-      await writeFile(tmp, configJson(config));
+      await writeFile(tmp, configJson(config), { mode: 384 });
+      await chmod(tmp, 384);
       await rename(tmp, configLocation());
-    } catch {
+    } catch (error) {
+      try {
+        await unlink(tmp);
+      } catch {
+      }
+      throw error;
     }
-  });
-  return saveQueue;
+  };
+  const operation = saveQueue.catch(() => void 0).then(write);
+  saveQueue = operation;
+  return operation;
 }
 function saveConfigSync(config) {
+  const dir = configDir();
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  chmodSync(dir, 448);
+  const tmp = configTempFile(dir);
   try {
-    const dir = configDir();
-    mkdirSync(dir, { recursive: true });
-    const tmp = join(dir, `config.json.${process.pid}.tmp`);
-    writeFileSync(tmp, configJson(config));
+    writeFileSync(tmp, configJson(config), { mode: 384 });
+    chmodSync(tmp, 384);
     renameSync(tmp, configLocation());
-  } catch {
+  } catch (error) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw error;
   }
 }
 function expandHome(p) {

package/dist/chunk-HXDAOOSI.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+// 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/open.ts
+import { spawn } from "child_process";
+import { appendFileSync } from "fs";
+function browserUrl(url, wsToken) {
+  return wsToken ? `${url}#tokmonToken=${encodeURIComponent(wsToken)}` : url;
+}
+function openBrowser(url, wsToken) {
+  const target = browserUrl(url, wsToken);
+  if (process.env.TOKMON_OPENLOG) {
+    try {
+      appendFileSync(process.env.TOKMON_OPENLOG, target + "\n");
+    } catch {
+    }
+    return;
+  }
+  try {
+    if (process.platform === "darwin") {
+      spawn("open", [target], { stdio: "ignore", detached: true }).unref();
+    } else if (process.platform === "win32") {
+      spawn("cmd", ["/c", "start", "", target], { stdio: "ignore", detached: true }).unref();
+    } else {
+      spawn("xdg-open", [target], { stdio: "ignore", detached: true }).unref();
+    }
+  } catch {
+  }
+}
+
+export {
+  findWebRoot,
+  send,
+  sendJson,
+  serveStatic,
+  appVersion,
+  browserUrl,
+  openBrowser
+};