tokmon 0.22.7 → 0.23.1

package/dist/chunk-RM3ZE44Z.js

@@ -0,0 +1,193 @@
+#!/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,
+  probeHealth,
+  verifyLock
+};

package/dist/cli.js

@@ -2,8 +2,20 @@
 
 // src/cli.tsx
 import { EventEmitter } from "events";
-process.on("unhandledRejection", () => {
-});
+function describeError(error) {
+  if (error instanceof Error) return error.message || error.name;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error) ?? String(error);
+  } catch {
+    return String(error);
+  }
+}
+function reportFatalError(context, error) {
+  console.error(`tokmon: ${context}: ${describeError(error)}`);
+  if (error instanceof Error && error.stack && error.stack !== error.message) console.error(error.stack);
+  process.exitCode = 1;
+}
 EventEmitter.defaultMaxListeners = 100;
 var emitWarning = process.emitWarning.bind(process);
 process.emitWarning = ((warning, ...rest) => {
@@ -13,60 +25,87 @@ process.emitWarning = ((warning, ...rest) => {
 });
 var args = process.argv.slice(2);
 var subcommand = args[0]?.toLowerCase();
-if (subcommand === "__daemon") {
-  const { runDaemon } = await import("./daemon-IP3UCTPB.js");
-  await runDaemon(args.slice(1), { foreground: false });
-  process.exit(typeof process.exitCode === "number" ? process.exitCode : 0);
+function parsePort(value) {
+  const port = value === void 0 ? Number.NaN : Number(value);
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    throw new Error("--port must be an integer between 0 and 65535");
+  }
+  return port;
 }
-if (subcommand === "serve" || subcommand === "web") {
-  const { runDaemon } = await import("./daemon-IP3UCTPB.js");
-  await runDaemon(args.slice(1), { foreground: true });
-  process.exit(typeof process.exitCode === "number" ? process.exitCode : 0);
+function validateServeArgs(serveArgs) {
+  for (let i = 0; i < serveArgs.length; i++) {
+    const arg = serveArgs[i];
+    if (arg === "--port" || arg === "-p") parsePort(serveArgs[++i]);
+    else if (arg.startsWith("--port=")) parsePort(arg.slice("--port=".length));
+  }
 }
-var interval;
-var asciiFlag = null;
-for (let i = 0; i < args.length; i++) {
-  if ((args[i] === "--interval" || args[i] === "-i") && args[i + 1]) {
-    interval = Math.max(500, Number(args[i + 1]) * 1e3);
-    i++;
+async function main() {
+  if (subcommand === "__daemon") {
+    const { runDaemon } = await import("./daemon-QGCI46US.js");
+    await runDaemon(args.slice(1), { foreground: false });
+    process.exitCode ??= 0;
+    return;
   }
-  if (args[i] === "--ascii") asciiFlag = "on";
-  if (args[i] === "--no-ascii") asciiFlag = "off";
-  if (args[i] === "--help" || args[i] === "-h") {
-    console.log("tokmon - Terminal usage dashboard for your AI coding tools\n");
-    console.log("  Claude \xB7 Codex \xB7 Cursor \xB7 Copilot \xB7 opencode \xB7 pi \xB7 Antigravity \xB7 Gemini \xB7 Grok\n");
-    console.log("Usage: tokmon [options]");
-    console.log("       tokmon serve [--port <n>] [--no-open]   Launch the web dashboard\n");
-    console.log("Options:");
-    console.log("  -i, --interval <seconds>  Refresh interval (default: from config or 2)");
-    console.log("      --ascii               Force ASCII glyphs (also: TOKMON_ASCII=1)");
-    console.log("      --no-ascii            Force Unicode glyphs");
-    console.log("  -h, --help                Show this help\n");
-    console.log("Keybindings:");
-    console.log("  Tab         Switch Dashboard / Table");
-    console.log("  p / P       Cycle table provider");
-    console.log("  a / A       Cycle account focus");
-    console.log("  0-9         Jump to account focus");
-    console.log("  \u2191\u2193          Scroll table");
-    console.log("  w / W       Toggle web dashboard");
-    console.log("  s           Settings");
-    console.log("  q           Quit");
-    process.exit(0);
+  if (subcommand === "serve" || subcommand === "web") {
+    validateServeArgs(args.slice(1));
+    const { runDaemon } = await import("./daemon-QGCI46US.js");
+    await runDaemon(args.slice(1), { foreground: true });
+    process.exitCode ??= 0;
+    return;
   }
+  let interval;
+  let asciiFlag = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--interval" || args[i] === "-i") {
+      const seconds = Number(args[i + 1]);
+      if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error("--interval must be a positive number of seconds");
+      }
+      interval = Math.max(500, seconds * 1e3);
+      i++;
+    }
+    if (args[i] === "--ascii") asciiFlag = "on";
+    if (args[i] === "--no-ascii") asciiFlag = "off";
+    if (args[i] === "--help" || args[i] === "-h") {
+      console.log("tokmon - Terminal usage dashboard for your AI coding tools\n");
+      console.log("  Claude \xB7 Codex \xB7 Cursor \xB7 Copilot \xB7 opencode \xB7 pi \xB7 Antigravity \xB7 Gemini \xB7 Grok\n");
+      console.log("Usage: tokmon [options]");
+      console.log("       tokmon serve [--port <n>] [--no-open]   Launch the web dashboard\n");
+      console.log("Options:");
+      console.log("  -i, --interval <seconds>  Refresh interval (default: from config or 2)");
+      console.log("      --ascii               Force ASCII glyphs (also: TOKMON_ASCII=1)");
+      console.log("      --no-ascii            Force Unicode glyphs");
+      console.log("  -h, --help                Show this help\n");
+      console.log("Keybindings:");
+      console.log("  Tab         Switch Dashboard / Table");
+      console.log("  p / P       Cycle table provider");
+      console.log("  a / A       Cycle account focus");
+      console.log("  0-9         Jump to account focus");
+      console.log("  \u2191\u2193          Scroll table");
+      console.log("  w / W       Toggle web dashboard");
+      console.log("  r / R       Refresh all data");
+      console.log("  s           Settings");
+      console.log("  q           Quit");
+      process.exitCode = 0;
+      return;
+    }
+  }
+  const { loadConfig } = await import("./config-5CNJN3P7.js");
+  const { resolveGlyphs, setGlyphs } = await import("./glyphs-NKCSZLGO.js");
+  const { attachOrSpawn } = await import("./daemon-handle-4F4TXGXJ.js");
+  const config = await loadConfig();
+  setGlyphs(resolveGlyphs({
+    flag: asciiFlag,
+    env: process.env,
+    config: config.ascii,
+    isTTY: !!process.stdout.isTTY,
+    platform: process.platform
+  }));
+  const daemon = await attachOrSpawn();
+  const mode = daemon.kind === "spawned" ? "connected" : "degraded";
+  const { bootstrapInk } = await import("./bootstrap-ink-UD3KDTOB.js");
+  await bootstrapInk({ interval, config, daemon, mode });
 }
-var { loadConfig } = await import("./config-WLRQHLVJ.js");
-var { resolveGlyphs, setGlyphs } = await import("./glyphs-NKCSZLGO.js");
-var { attachOrSpawn } = await import("./daemon-handle-HLSKLMWU.js");
-var config = await loadConfig();
-var isTTY = process.stdout.isTTY === true;
-setGlyphs(resolveGlyphs({
-  flag: asciiFlag,
-  env: process.env,
-  config: config.ascii,
-  isTTY: !!process.stdout.isTTY,
-  platform: process.platform
-}));
-var daemon = await attachOrSpawn();
-var mode = daemon.kind === "spawned" ? "connected" : "degraded";
-var { bootstrapInk } = await import("./bootstrap-ink-OHPQZKGB.js");
-await bootstrapInk({ interval, config, daemon, mode });
+void main().catch((error) => {
+  reportFatalError("fatal error", error);
+});

package/dist/{config-WLRQHLVJ.js → config-5CNJN3P7.js}

@@ -24,7 +24,7 @@ import {
   saveConfigSync,
   slugify,
   snapshotCacheFile
-} from "./chunk-TNIADJ3W.js";
+} from "./chunk-DJPUYMZM.js";
 export {
   ACCENT_COLORS,
   COLOR_PALETTE,

package/dist/daemon-QGCI46US.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+import {
+  startWebServer
+} from "./chunk-AON6GE7D.js";
+import {
+  acquireLock,
+  isAlive,
+  readLock,
+  reclaimAbandonedLock,
+  reclaimDeadLock,
+  unlinkLock,
+  verifyLock,
+  writeLock
+} from "./chunk-RM3ZE44Z.js";
+import {
+  appVersion,
+  browserUrl,
+  openBrowser
+} from "./chunk-HXDAOOSI.js";
+import {
+  flushDisk
+} from "./chunk-PGQK7MOE.js";
+import {
+  loadConfig
+} from "./chunk-DJPUYMZM.js";
+
+// src/web/daemon.ts
+import { randomBytes } from "crypto";
+function parseDaemonArgs(args) {
+  let port;
+  let open = true;
+  let help = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if ((arg === "--port" || arg === "-p") && args[i + 1]) port = Number(args[++i]);
+    else if (arg.startsWith("--port=")) port = Number(arg.slice("--port=".length));
+    else if (arg === "--no-open") open = false;
+    else if (arg === "--help" || arg === "-h") help = true;
+  }
+  if (port !== void 0 && (!Number.isInteger(port) || port < 0 || port > 65535)) port = void 0;
+  return { port, open, help };
+}
+var SERVE_HELP = `tokmon serve - Launch the tokmon web dashboard (local, loopback only)
+
+Usage: tokmon serve [options]
+
+Options:
+  -p, --port <n>   Port to listen on (default: 4317, auto-falls back if taken)
+      --no-open    Don't open the browser automatically
+  -h, --help       Show this help
+`;
+function handshake(lock) {
+  process.stdout.write(JSON.stringify({ ready: 1, url: lock.url, port: lock.port, wsToken: lock.wsToken, version: lock.version }) + "\n");
+}
+function describeExisting(lock, open) {
+  const displayUrl = open ? lock.url : browserUrl(lock.url, lock.wsToken);
+  process.stdout.write(`
+  \u25C6 tokmon web  \u2192  ${displayUrl}
+`);
+  process.stdout.write("    reusing the live singleton daemon\n\n");
+  if (open) {
+    openBrowser(lock.url, lock.wsToken);
+    process.stdout.write("    opening browser\u2026\n");
+  }
+}
+async function runDaemon(args, opts) {
+  const { port, open, help } = parseDaemonArgs(args);
+  if (help && opts.foreground) {
+    process.stdout.write(SERVE_HELP);
+    return;
+  }
+  const version = appVersion();
+  let current = readLock();
+  if (!current && reclaimAbandonedLock()) current = readLock();
+  const live = await verifyLock(current, version);
+  if (live) {
+    if (opts.foreground) describeExisting(live, open);
+    else handshake(live);
+    return;
+  }
+  if (current?.state === "starting" && current.version === version && isAlive(current.pid)) {
+    for (let attempt = 0; attempt < 60; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const winner = await verifyLock(readLock(), version, 250);
+      if (winner) {
+        if (opts.foreground) describeExisting(winner, open);
+        else handshake(winner);
+        return;
+      }
+    }
+  }
+  if (current && isAlive(current.pid)) {
+    const message = "tokmon: another daemon owns the lock but could not be verified (version/token mismatch)";
+    if (opts.foreground) {
+      process.stderr.write(message + "\n");
+      process.exitCode = 1;
+    }
+    return;
+  }
+  if (current) reclaimDeadLock();
+  const ownerId = randomBytes(32).toString("base64url");
+  const token = randomBytes(32).toString("base64url");
+  const reservation = {
+    pid: process.pid,
+    port: 0,
+    url: "",
+    wsToken: token,
+    version,
+    startedAt: Date.now(),
+    ownerId,
+    state: "starting"
+  };
+  if (!acquireLock(reservation)) {
+    for (let attempt = 0; attempt < 60; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      const winner = await verifyLock(readLock(), version, 250);
+      if (winner) {
+        if (opts.foreground) describeExisting(winner, open);
+        else handshake(winner);
+        return;
+      }
+    }
+    if (opts.foreground) {
+      process.stderr.write("tokmon: daemon startup is already in progress\n");
+      process.exitCode = 1;
+    }
+    return;
+  }
+  let controller = null;
+  try {
+    const config = await loadConfig();
+    controller = await startWebServer({ config, port, log: opts.foreground, wsToken: token });
+    const ready = {
+      ...reservation,
+      port: controller.port,
+      url: controller.url,
+      state: "ready"
+    };
+    if (!writeLock(ready)) throw new Error("lost daemon lock ownership during startup");
+    let shuttingDown = false;
+    const shutdown = async (exitCode = 0) => {
+      if (shuttingDown) return;
+      shuttingDown = true;
+      if (opts.foreground) process.stdout.write("\n  stopping tokmon web\u2026\n");
+      try {
+        await controller?.stop();
+      } catch {
+      }
+      await flushDisk().catch(() => {
+      });
+      unlinkLock(ownerId);
+      process.exit(exitCode);
+    };
+    process.once("exit", () => {
+      unlinkLock(ownerId);
+    });
+    process.once("SIGINT", () => {
+      void shutdown(0);
+    });
+    process.once("SIGTERM", () => {
+      void shutdown(0);
+    });
+    if (opts.foreground) {
+      const displayUrl = open ? controller.url : controller.browserUrl;
+      process.stdout.write(`
+  \u25C6 tokmon web  \u2192  ${displayUrl}
+`);
+      process.stdout.write("    live dashboard \xB7 Ctrl-C to stop\n\n");
+      if (open) {
+        openBrowser(controller.url, token);
+        process.stdout.write("    opening browser\u2026\n");
+      }
+    } else {
+      handshake(ready);
+    }
+    await new Promise(() => {
+    });
+  } catch (error) {
+    try {
+      await controller?.stop();
+    } catch {
+    }
+    unlinkLock(ownerId);
+    const message = `tokmon: failed to start web server: ${error.message}`;
+    if (opts.foreground) {
+      process.stderr.write(message + "\n");
+      process.exitCode = 1;
+    }
+  }
+}
+export {
+  runDaemon
+};