tokmon 0.22.6 → 0.23.0

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

@@ -1,16 +1,17 @@
 #!/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";
 
 // src/providers/types.ts
-var PROVIDER_IDS = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "antigravity", "gemini"];
+var PROVIDER_IDS = ["claude", "codex", "cursor", "copilot", "pi", "opencode", "antigravity", "gemini", "grok"];
 
 // src/config-schema.ts
 var DEFAULTS = {
+  revision: 0,
   interval: 2,
   billingInterval: 5,
   clearScreen: true,
@@ -48,7 +49,8 @@ var PROVIDER_META = {
   pi: { name: "Pi", color: "blue" },
   opencode: { name: "opencode", color: "yellow" },
   antigravity: { name: "Antigravity", color: "red" },
-  gemini: { name: "Gemini", color: "greenBright" }
+  gemini: { name: "Gemini", color: "greenBright" },
+  grok: { name: "Grok", color: "yellowBright" }
 };
 var EMAIL_RE = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/i;
 var EMAIL_RE_GLOBAL = /[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}/gi;
@@ -198,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,
@@ -283,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 };
@@ -303,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-HV6AYQDB.js

@@ -0,0 +1,192 @@
+#!/usr/bin/env node
+import {
+  cacheDir
+} from "./chunk-DJPUYMZM.js";
+
+// src/web/lockfile.ts
+import { closeSync, fchmodSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync } from "fs";
+import { isAbsolute, join } from "path";
+function lockDir(opts = {}) {
+  const injected = opts.cachePath ?? process.env.TOKMON_DAEMON_CACHE_DIR;
+  return injected && isAbsolute(injected) ? injected : cacheDir();
+}
+function lockfilePath(opts = {}) {
+  return join(lockDir(opts), "daemon.json");
+}
+function isLoopbackUrl(value) {
+  try {
+    const url = new URL(value);
+    return url.protocol === "http:" && (url.hostname === "127.0.0.1" || url.hostname === "localhost" || url.hostname === "::1");
+  } catch {
+    return false;
+  }
+}
+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");
+}
+function readLock(opts = {}) {
+  try {
+    const path = lockfilePath(opts);
+    const stat = statSync(path);
+    if (!stat.isFile() || (stat.mode & 63) !== 0) return null;
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return validLock(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function ensureLockDir(opts) {
+  const dir = lockDir(opts);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  let fd;
+  try {
+    fd = openSync(dir, "r");
+    fchmodSync(fd, 448);
+  } catch {
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function writeNew(path, lock) {
+  let fd;
+  let created = false;
+  try {
+    fd = openSync(path, "wx", 384);
+    created = true;
+    fchmodSync(fd, 384);
+    writeFileSync(fd, JSON.stringify(lock));
+    fsyncSync(fd);
+    return true;
+  } catch {
+    if (created) try {
+      unlinkSync(path);
+    } catch {
+    }
+    return false;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function acquireLock(lock, opts = {}) {
+  try {
+    ensureLockDir(opts);
+    return writeNew(lockfilePath(opts), lock);
+  } catch {
+    return false;
+  }
+}
+function writeLock(lock, opts = {}) {
+  const current = readLock(opts);
+  if (!current || current.ownerId !== lock.ownerId || current.pid !== process.pid) return false;
+  const path = lockfilePath(opts);
+  const tmp = join(lockDir(opts), `daemon.json.${process.pid}.${lock.ownerId}.tmp`);
+  let fd;
+  try {
+    writeFileSync(tmp, JSON.stringify(lock), { mode: 384 });
+    try {
+      fd = openSync(tmp, "r");
+      fchmodSync(fd, 384);
+      fsyncSync(fd);
+    } catch {
+    }
+    renameSync(tmp, path);
+    return true;
+  } catch {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    return false;
+  } finally {
+    if (fd !== void 0) try {
+      closeSync(fd);
+    } catch {
+    }
+  }
+}
+function unlinkLock(ownerId, opts = {}) {
+  const current = readLock(opts);
+  if (!current || current.ownerId !== ownerId || current.pid !== process.pid) return false;
+  try {
+    unlinkSync(lockfilePath(opts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reclaimDeadLock(opts = {}) {
+  const current = readLock(opts);
+  if (!current || isAlive(current.pid)) return false;
+  try {
+    unlinkSync(lockfilePath(opts));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function reclaimAbandonedLock(opts = {}, graceMs = 1e4) {
+  const path = lockfilePath(opts);
+  try {
+    const before = lstatSync(path);
+    if (!before.isFile()) return false;
+    let pid = null;
+    try {
+      const parsed = JSON.parse(readFileSync(path, "utf-8"));
+      if (Number.isInteger(parsed.pid) && parsed.pid > 0) pid = parsed.pid;
+    } catch {
+    }
+    if (pid !== null && isAlive(pid)) return false;
+    if (pid === null && Date.now() - before.mtimeMs < graceMs) return false;
+    const after = lstatSync(path);
+    if (after.dev !== before.dev || after.ino !== before.ino) return false;
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function probeHealth(url, token, version, timeoutMs = 500) {
+  if (!isLoopbackUrl(url) || !token) return false;
+  try {
+    const res = await fetch(`${url.replace(/\/+$/, "")}/healthz`, {
+      headers: { "x-tokmon-token": token },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return false;
+    const body = await res.json();
+    return body.ok === true && body.owner === true && (version === void 0 || body.version === version);
+  } 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;
+}
+
+export {
+  readLock,
+  acquireLock,
+  writeLock,
+  unlinkLock,
+  reclaimDeadLock,
+  reclaimAbandonedLock,
+  isAlive,
+  verifyLock
+};

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
+};