cabletidy 0.2.0 → 0.3.0-rc.2

package/src/instance-lock.mjs

@@ -1,129 +0,0 @@
-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

@@ -1,185 +0,0 @@
-export class ModelResolveError extends Error {
-  constructor(code, message, details = {}) {
-    super(message);
-    this.name = "ModelResolveError";
-    this.code = code;
-    this.details = details;
-  }
-}
-
-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] };
-  }
-  for (const [profileId, profile] of Object.entries(config.models || {})) {
-    if (allowed && !allowed.has(profileId)) continue;
-    if (
-      profile.clientModelId === clientModelId ||
-      (profile.aliases || []).includes(clientModelId)
-    ) {
-      return { profileId, profile };
-    }
-  }
-  return null;
-}
-
-export function clientModelIdForProfile(profileId, profile) {
-  return profile?.clientModelId || profile?.aliases?.[0] || profileId;
-}
-
-export function listClientModels(config, virtualProvider) {
-  const allowed = virtualProvider?.allowedModels || [];
-  return allowed
-    .map((profileId) => {
-      const profile = config.models?.[profileId];
-      if (!profile) return null;
-      return {
-        id: clientModelIdForProfile(profileId, profile),
-        profileId,
-        aliases: profile.aliases || [],
-        family: profile.family || "unknown",
-        capabilities: profile.capabilities || [],
-        object: "model",
-        owned_by: "cabletidy",
-      };
-    })
-    .filter(Boolean);
-}
-
-export function resolveModelProfile(config, virtualProvider, requestedModel) {
-  if (requestedModel !== undefined && (typeof requestedModel !== "string" || !requestedModel.trim())) {
-    throw new ModelResolveError("invalid_model", "model 必须是非空字符串");
-  }
-  const clientModelId =
-    requestedModel ||
-    virtualProvider?.defaultModel ||
-    null;
-  if (!clientModelId) {
-    throw new ModelResolveError("model_required", "请求没有模型，Virtual Provider 也没有默认模型");
-  }
-
-  // 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 };
-  }
-
-  return {
-    clientModelId: requestedModel || clientModelIdForProfile(match.profileId, match.profile),
-    profileId: match.profileId,
-    profile: match.profile,
-  };
-}
-
-export function effectiveCapabilities(profile, binding) {
-  const capabilities = new Set(profile?.capabilities || []);
-  for (const item of binding?.capabilityOverrides || []) {
-    if (item.startsWith("-")) capabilities.delete(item.slice(1));
-    else if (item.startsWith("+")) capabilities.add(item.slice(1));
-    else capabilities.add(item);
-  }
-  if (profile?.codex?.metadataMode === "override" &&
-      profile.codex.inputModalities && !profile.codex.inputModalities.includes("image")) {
-    capabilities.delete("vision");
-  }
-  return capabilities;
-}
-
-function requiredCapabilities(request = {}) {
-  const required = new Set();
-  if (request.stream) required.add("streaming");
-  if (Array.isArray(request.tools) && request.tools.length) required.add("tools");
-  if (request.tool_choice) required.add("tools");
-  if (request.parallel_tool_calls) required.add("parallel_tool_calls");
-  if (request.reasoning) required.add("reasoning");
-  if (request.thinking && request.thinking.type !== "disabled") required.add("reasoning");
-  if (request.images || request.image_input || containsImage(request.input) || containsImage(request.messages)) required.add("vision");
-  return required;
-}
-
-function containsImage(value) {
-  if (Array.isArray(value)) return value.some(containsImage);
-  if (!value || typeof value !== "object") return false;
-  if (["input_image", "image", "image_url"].includes(value.type)) return true;
-  return containsImage(value.content);
-}
-
-function hasCapabilities(capabilities, required) {
-  return [...required].every((item) => capabilities.has(item));
-}
-
-export function selectBackend(config, virtualProvider, modelResolution, request = {}) {
-  const route = config.routes?.[virtualProvider.route];
-  if (!route) {
-    throw new ModelResolveError("route_not_found", `Route 不存在: ${virtualProvider.route}`);
-  }
-  if (!Array.isArray(route.backends) || route.backends.length !== 1) {
-    throw new ModelResolveError("invalid_route", "每份配置必须且只能连接一个 upstream");
-  }
-
-  const backend = route.backends[0];
-  const upstream = config.upstreams?.[backend?.upstream];
-  const profile = modelResolution.profile;
-  const modelBindings = profile?.upstreams || {};
-  if (Object.keys(modelBindings).length > 1) {
-    throw new ModelResolveError("invalid_model_binding", "每个 Model Profile 只能映射一个 upstream");
-  }
-  const modelBinding = modelBindings[backend?.upstream];
-  const required = requiredCapabilities(request);
-  const capabilities = effectiveCapabilities(profile, modelBinding);
-  let reason;
-  if (!backend || backend.enabled === false || !upstream || upstream.enabled === false) {
-    reason = "upstream_disabled_or_missing";
-  } else if (profile && !backend.models?.includes(modelResolution.profileId)) {
-    reason = "model_not_in_route";
-  } else if (profile && !modelBinding) {
-    reason = "model_binding_missing";
-  } else if (virtualProvider.ingressProtocol !== upstream.protocol) {
-    reason = "protocol_transform_missing";
-  } else if (profile &&
-      (virtualProvider.ingressProtocol !== "anthropic.messages" || profile.capabilities !== undefined || modelBinding?.capabilityOverrides?.length) &&
-      !hasCapabilities(capabilities, required)) {
-    reason = "capability_missing";
-  }
-  if (reason) {
-    throw new ModelResolveError(
-      "no_compatible_upstream",
-      `当前配置的 upstream 无法处理模型 ${modelResolution.clientModelId}`,
-      {
-        profileId: modelResolution.profileId,
-        rejected: [{ index: 0, reason, ...(reason === "capability_missing"
-          ? { missing: [...required].filter((item) => !capabilities.has(item)) } : {}) }],
-      },
-    );
-  }
-  return {
-    routeId: virtualProvider.route,
-    upstream,
-    upstreamModelId: modelBinding?.upstreamModelId || modelResolution.clientModelId,
-    capabilities: [...capabilities],
-  };
-}
-
-export function resolveRequest(config, virtualProvider, requestBody = {}) {
-  const model = resolveModelProfile(config, virtualProvider, requestBody.model);
-  const backend = selectBackend(config, virtualProvider, model, requestBody);
-  return { model, ...backend };
-}
-
-export function rewriteModelFields(value, clientModelId, upstreamModelId) {
-  if (Array.isArray(value)) {
-    return value.map((item) => rewriteModelFields(item, clientModelId, upstreamModelId));
-  }
-  if (!value || typeof value !== "object") return value;
-  const output = {};
-  for (const [key, item] of Object.entries(value)) {
-    if (key === "model" && item === upstreamModelId) {
-      output[key] = clientModelId;
-    } else {
-      output[key] = rewriteModelFields(item, clientModelId, upstreamModelId);
-    }
-  }
-  return output;
-}

package/src/process-identity.mjs

@@ -1,72 +0,0 @@
-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";
-}