cabletidy 0.1.0 → 0.2.0

package/src/instance-lock.mjs

@@ -0,0 +1,129 @@
+import callbackFs from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import lockfile from "proper-lockfile";
+import { readRuntimeInfo } from "./config.mjs";
+import { inspectProcess, processStartTime } from "./process-identity.mjs";
+
+const STALE_MS = 10_000;
+const ownerName = /^owner-[\da-f-]{36}\.json$/;
+
+export async function acquireInstanceLock(paths) {
+  const identity = { pid: process.pid, startTime: await processStartTime(process.pid), hostname: os.hostname() };
+  const marker = `owner-${randomUUID()}.json`;
+  const filesystem = {
+    ...callbackFs,
+    mkdir(directory, callback) {
+      publishOwner(directory, marker, identity).then(() => callback(), callback);
+    },
+    rmdir(directory, callback) {
+      removeOwner(directory, marker).then(() => callback(), callback);
+    },
+    rmdirSync(directory) {
+      try {
+        callbackFs.unlinkSync(path.join(directory, marker));
+        callbackFs.rmdirSync(directory);
+      } catch (error) {
+        if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code)) throw error;
+      }
+    },
+  };
+  while (true) {
+    try {
+      const release = await lockfile.lock(paths.home, {
+        lockfilePath: paths.lock,
+        // Age alone must never evict a paused process. Reclaim is handled below.
+        stale: Number.MAX_SAFE_INTEGER,
+        update: 2000,
+        fs: filesystem,
+      });
+      return { release, identity };
+    } catch (error) {
+      if (error.code !== "ELOCKED") throw error;
+      const inspection = await inspectLock(paths);
+      if (!inspection) continue;
+      if (inspection.state === "alive" || !inspection.stale) {
+        throw Object.assign(new Error(
+          `此数据目录已有 CableTidy 实例运行，或异常退出后的锁尚未过期 (ELOCKED)；异常退出后等待 10 秒再重试: ${paths.home}`,
+        ), { code: "ELOCKED" });
+      }
+      if (inspection.state === "unknown" || !inspection.marker) {
+        throw Object.assign(new Error(
+          `无法确认旧实例锁的进程身份 (ELOCKUNKNOWN${inspection.pid ? `, PID ${inspection.pid}` : ""})。请先检查并停止使用此数据目录的 CableTidy；确认实例已退出后，手动删除锁目录并重新启动: ${paths.lock}`,
+        ), { code: "ELOCKUNKNOWN" });
+      }
+      await removeOwner(paths.lock, inspection.marker);
+    }
+  }
+}
+
+async function publishOwner(directory, marker, identity) {
+  // Publish a populated directory atomically, so reclaimers never see a new
+  // owner without its identity and cannot rmdir a newly acquired lock.
+  try {
+    await fs.lstat(directory);
+    throw Object.assign(new Error("Lock exists"), { code: "EEXIST" });
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+  const staged = await fs.mkdtemp(path.join(path.dirname(directory), ".daemon-lock-"));
+  try {
+    await fs.writeFile(path.join(staged, marker), JSON.stringify(identity), { mode: 0o600, flag: "wx" });
+    try {
+      await fs.rename(staged, directory);
+    } catch (error) {
+      // Windows reports EPERM/EACCES for an existing destination directory.
+      if (["ENOTEMPTY", "EEXIST", "EPERM", "EACCES"].includes(error.code)) {
+        await fs.lstat(directory);
+        throw Object.assign(error, { code: "EEXIST" });
+      }
+      throw error;
+    }
+  } finally {
+    await fs.rm(staged, { recursive: true, force: true });
+  }
+}
+
+async function removeOwner(directory, marker) {
+  try {
+    // Only remove the inspected generation. A losing reclaimer cannot remove
+    // the new owner's unique marker, and rmdir refuses a populated directory.
+    await fs.unlink(path.join(directory, marker));
+    await fs.rmdir(directory);
+  } catch (error) {
+    if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code)) throw error;
+  }
+}
+
+async function inspectLock(paths) {
+  try {
+    const entries = await fs.readdir(paths.lock);
+    const markers = entries.filter(name => ownerName.test(name) || name === "owner.json");
+    const marker = entries.length === 1 && markers.length === 1 ? markers[0] : null;
+    let identity;
+    if (marker) {
+      try { identity = JSON.parse(await fs.readFile(path.join(paths.lock, marker), "utf8")); }
+      catch (error) {
+        if (error.code === "ENOENT") return null;
+        if (error.name !== "SyntaxError") throw error;
+      }
+    } else if (!entries.length) {
+      // Legacy empty locks have no generation token, so even a dead runtime
+      // PID cannot make their removal safe against concurrent reclaimers.
+      try {
+        const runtime = await readRuntimeInfo(paths);
+        identity = runtime && { pid: runtime.pid, startTime: runtime.pidStartTime };
+      } catch { /* Missing or malformed legacy metadata requires manual recovery. */ }
+    }
+    const state = await inspectProcess(identity);
+    // Another reclaimer may have removed its marker while we read the entries.
+    // Read freshness last so that transition is not mistaken for an old empty lock.
+    const stat = await fs.stat(paths.lock);
+    return { marker, pid: identity?.pid, state, stale: Date.now() - stat.mtimeMs >= STALE_MS };
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}

package/src/model-resolver.mjs

@@ -11,7 +11,7 @@ export function findModelProfile(config, clientModelId, allowedModels) {
   if (!clientModelId) return null;
   const allowed = Array.isArray(allowedModels) ? new Set(allowedModels) : null;
   if (config.models?.[clientModelId] && (!allowed || allowed.has(clientModelId))) {
-    return { profileId: clientModelId, profile: config.models[clientModelId], matchedBy: "id" };
+    return { profileId: clientModelId, profile: config.models[clientModelId] };
   }
   for (const [profileId, profile] of Object.entries(config.models || {})) {
     if (allowed && !allowed.has(profileId)) continue;
@@ -19,7 +19,7 @@ export function findModelProfile(config, clientModelId, allowedModels) {
       profile.clientModelId === clientModelId ||
       (profile.aliases || []).includes(clientModelId)
     ) {
-      return { profileId, profile, matchedBy: "alias" };
+      return { profileId, profile };
     }
   }
   return null;
@@ -63,14 +63,13 @@ export function resolveModelProfile(config, virtualProvider, requestedModel) {
   // allowedModels scopes optional overrides, not the models a client may request.
   const match = findModelProfile(config, clientModelId, virtualProvider?.allowedModels || []);
   if (!match) {
-    return { clientModelId, profileId: null, profile: null, matchedBy: "passthrough" };
+    return { clientModelId, profileId: null, profile: null };
   }
 
   return {
     clientModelId: requestedModel || clientModelIdForProfile(match.profileId, match.profile),
     profileId: match.profileId,
     profile: match.profile,
-    matchedBy: match.matchedBy,
   };
 }
 
@@ -139,7 +138,9 @@ export function selectBackend(config, virtualProvider, modelResolution, request
     reason = "model_binding_missing";
   } else if (virtualProvider.ingressProtocol !== upstream.protocol) {
     reason = "protocol_transform_missing";
-  } else if (profile && !hasCapabilities(capabilities, required)) {
+  } else if (profile &&
+      (virtualProvider.ingressProtocol !== "anthropic.messages" || profile.capabilities !== undefined || modelBinding?.capabilityOverrides?.length) &&
+      !hasCapabilities(capabilities, required)) {
     reason = "capability_missing";
   }
   if (reason) {
@@ -155,12 +156,9 @@ export function selectBackend(config, virtualProvider, modelResolution, request
   }
   return {
     routeId: virtualProvider.route,
-    backend,
-    backendIndex: 0,
     upstream,
     upstreamModelId: modelBinding?.upstreamModelId || modelResolution.clientModelId,
     capabilities: [...capabilities],
-    rejected: [],
   };
 }
 

package/src/process-identity.mjs

@@ -0,0 +1,72 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execute = promisify(execFile);
+export const powershell = path.win32.join(
+  process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe",
+);
+
+export async function processStartTime(pid, {
+  platform = process.platform, readFile = fs.readFile, run = execute,
+} = {}) {
+  if (!Number.isSafeInteger(pid) || pid <= 0) return null;
+  try {
+    if (platform === "linux") {
+      const [stat, boot] = await Promise.all([
+        readFile(`/proc/${pid}/stat`, "utf8"),
+        readFile("/proc/sys/kernel/random/boot_id", "utf8"),
+      ]);
+      const fields = stat.slice(stat.lastIndexOf(")") + 2).trim().split(/\s+/);
+      if (!/^\d+$/.test(fields[19]) || !/^[\da-f-]{36}$/i.test(boot.trim())) return null;
+      return `linux:${boot.trim()}:${fields[19]}`;
+    }
+    const options = { timeout: 5000, maxBuffer: 4096, windowsHide: true };
+    if (platform === "darwin") {
+      const { stdout } = await run("/bin/ps", ["-p", String(pid), "-o", "lstart="], {
+        ...options, env: { ...process.env, LC_ALL: "C", TZ: "UTC" },
+      });
+      const value = stdout.trim().replace(/\s+/g, " ");
+      return /^[A-Z][a-z]{2} [A-Z][a-z]{2} \d{1,2} \d{2}:\d{2}:\d{2} \d{4}$/.test(value)
+        ? `darwin:${value}` : null;
+    }
+    if (platform === "win32") {
+      const { stdout } = await run(powershell, ["-NoLogo", "-NoProfile", "-NonInteractive", "-Command",
+        `$ErrorActionPreference = 'Stop'; (Get-Process -Id ${pid}).StartTime.ToUniversalTime().Ticks.ToString()`,
+      ], options);
+      return /^\d{17,}$/.test(stdout.trim()) ? `win32:${stdout.trim()}` : null;
+    }
+  } catch {
+    // Query failures do not prove that a PID is dead or still has its old owner.
+  }
+  return null;
+}
+
+export async function inspectProcess(identity, {
+  kill = process.kill, readStartTime = processStartTime, hostname = os.hostname(),
+} = {}) {
+  const pid = identity?.pid;
+  if (!Number.isSafeInteger(pid) || pid <= 0 || (identity.hostname && identity.hostname !== hostname)) {
+    return "unknown";
+  }
+  try {
+    kill(pid, 0);
+  } catch (error) {
+    if (error.code === "ESRCH") return "dead";
+    if (error.code !== "EPERM") return "unknown";
+  }
+  if (typeof identity.startTime !== "string" || !identity.startTime) return "unknown";
+  const current = await readStartTime(pid);
+  if (!current) return "unknown";
+  if (/^(linux|darwin|win32):/.test(identity.startTime)) {
+    if (identity.startTime.split(":")[0] !== current.split(":")[0]) return "unknown";
+    return current === identity.startTime ? "alive" : "dead";
+  }
+  // Old Linux ticks can disprove ownership, but without a boot ID cannot prove it.
+  if (/^\d+$/.test(identity.startTime) && current.startsWith("linux:") && current.split(":").at(-1) !== identity.startTime) {
+    return "dead";
+  }
+  return "unknown";
+}