tokmon 0.28.2 → 0.28.4

package/dist/chunk-5B3XCEMC.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env node
+import {
+  daemonChannelFromWire,
+  resolveDaemonChannel
+} from "./chunk-UYPDMVW5.js";
+import {
+  cacheDir
+} from "./chunk-HNWEJ6MS.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;
+  if (injected && isAbsolute(injected)) return injected;
+  const root = cacheDir();
+  return resolveDaemonChannel(opts.channel) === "dev" ? join(root, "dev") : root;
+}
+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.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") && daemonChannelFromWire(lock.channel) !== null && 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"));
+    if (!validLock(parsed)) return null;
+    const channel = daemonChannelFromWire(parsed.channel);
+    return channel === resolveDaemonChannel(opts.channel) ? { ...parsed, channel } : null;
+  } catch {
+    return null;
+  }
+}
+function readForeignLock(opts = {}) {
+  try {
+    const path = lockfilePath(opts);
+    const stat = statSync(path);
+    if (!stat.isFile() || (stat.mode & 63) !== 0) return null;
+    const value = JSON.parse(readFileSync(path, "utf-8"));
+    const channel = daemonChannelFromWire(value.channel);
+    if (!Number.isInteger(value.pid) || value.pid <= 0 || typeof value.url !== "string" || !isLoopbackUrl(value.url) || typeof value.wsToken !== "string" || value.wsToken.length < 32 || value.state !== "ready" || channel !== resolveDaemonChannel(opts.channel)) return null;
+    if (value.ownerKind !== void 0 && value.ownerKind !== "cli" && value.ownerKind !== "desktop") return null;
+    if (value.protocolVersion !== void 0 && (!Number.isSafeInteger(value.protocolVersion) || value.protocolVersion < 1)) return null;
+    return {
+      pid: value.pid,
+      ...Number.isInteger(value.port) ? { port: value.port } : {},
+      url: value.url,
+      wsToken: value.wsToken,
+      ...typeof value.version === "string" ? { version: value.version } : {},
+      ...typeof value.protocolVersion === "number" ? { protocolVersion: value.protocolVersion } : {},
+      ...Array.isArray(value.capabilities) && value.capabilities.every((item) => typeof item === "string") ? { capabilities: value.capabilities } : {},
+      ...value.ownerKind === "cli" || value.ownerKind === "desktop" ? { ownerKind: value.ownerKind } : {},
+      channel,
+      ...typeof value.startedAt === "number" ? { startedAt: value.startedAt } : {},
+      ...typeof value.ownerId === "string" ? { ownerId: value.ownerId } : {},
+      state: "ready"
+    };
+  } 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 = {}) {
+  if (lock.channel !== resolveDaemonChannel(opts.channel)) return false;
+  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 || lock.channel !== current.channel) 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 reclaimUnhealthyLock(expected, opts = {}, minimumAgeMs = 0) {
+  const path = lockfilePath(opts);
+  try {
+    const before = lstatSync(path);
+    if (!before.isFile()) return false;
+    const current = readLock(opts);
+    if (!current || current.ownerId !== expected.ownerId || current.pid !== expected.pid || current.startedAt !== expected.startedAt || current.state !== "ready" || Date.now() - current.startedAt < minimumAgeMs) 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 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";
+  }
+}
+function sameCapabilities(actual, expected) {
+  return Array.isArray(actual) && actual.length === expected.length && actual.every((capability, index) => capability === expected[index]);
+}
+async function ownerHealth(url, token, timeoutMs = 500) {
+  if (!isLoopbackUrl(url) || !token) return null;
+  try {
+    const res = await fetch(`${url.replace(/\/+$/, "")}/healthz`, {
+      headers: { "x-tokmon-token": token },
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function probeHealth(url, token, expected = {}, timeoutMs = 500) {
+  const body = await ownerHealth(url, token, timeoutMs);
+  const bodyChannel = daemonChannelFromWire(body?.channel);
+  return body !== null && 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) && (expected.channel === void 0 || bodyChannel === expected.channel);
+}
+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;
+}
+var TAKEOVER_TIMEOUT_MS = 5e3;
+var takeoverDelay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function sameForeignOwner(left, right) {
+  return left.pid === right.pid && left.wsToken === right.wsToken && left.ownerId === right.ownerId;
+}
+async function retireIncompatibleCliOwner(opts, protocolVersion, timeoutMs = TAKEOVER_TIMEOUT_MS) {
+  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 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;
+  try {
+    process.kill(foreign.pid, "SIGTERM");
+  } catch {
+    if (!isAlive(foreign.pid)) {
+      reclaimAbandonedLock(opts, 0);
+      return true;
+    }
+    return false;
+  }
+  const deadline = Date.now() + Math.max(0, timeoutMs);
+  while (Date.now() < deadline) {
+    const current = readForeignLock(opts);
+    if (!current || !sameForeignOwner(current, foreign)) return true;
+    if (!isAlive(foreign.pid)) {
+      reclaimAbandonedLock(opts, 0);
+      return true;
+    }
+    await takeoverDelay(50);
+  }
+  if (!isAlive(foreign.pid)) {
+    reclaimAbandonedLock(opts, 0);
+    return true;
+  }
+  return false;
+}
+
+export {
+  lockfilePath,
+  readLock,
+  readForeignLock,
+  acquireLock,
+  writeLock,
+  unlinkLock,
+  reclaimDeadLock,
+  reclaimUnhealthyLock,
+  reclaimAbandonedLock,
+  isAlive,
+  verifyLock,
+  retireIncompatibleCliOwner
+};