cartethyia 2.5.3 → 2.5.6

package/scripts/cli/gateway/drain-token.ts

@@ -1,78 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-/**
- * The install's drain token, persisted in the config directory.
- *
- * Why it persists instead of being generated per run: the tray that "Hide to
- * tray" starts runs in a different process and drains the gateway through the
- * loopback endpoint, so the token has to match across processes. A token
- * regenerated on each start could never authenticate against a gateway another
- * process had started.
- *
- * It is kept out of `.env` on purpose: it authorises a shutdown, so it belongs
- * in a machine-written file the operator never hand-edits and never commits.
- * Mode 0600 where the platform honours it.
- */
-const RUNTIME_STATE_FILE = "runtime.json";
-
-interface RuntimeState {
-  readonly drainToken: string;
-}
-
-function statePath(): string | null {
-  const configDir = process.env.CARTETHYIA_CONFIG_DIR;
-  return configDir ? join(configDir, RUNTIME_STATE_FILE) : null;
-}
-
-function readState(): RuntimeState | null {
-  const path = statePath();
-  if (path === null || !existsSync(path)) return null;
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-    if (
-      parsed !== null &&
-      typeof parsed === "object" &&
-      "drainToken" in parsed &&
-      typeof parsed.drainToken === "string" &&
-      parsed.drainToken.length > 0
-    ) {
-      return { drainToken: parsed.drainToken };
-    }
-  } catch {
-    // A corrupt or stale state file reads as "no token".
-  }
-  return null;
-}
-
-/**
- * Returns the install's drain token, creating and persisting one on first use.
- *
- * Every start calls this, so a gateway started from the menu, from `tray`, or
- * from `cartethyia start` all authenticate with the same token and `stop`
- * always has the one that works.
- */
-export function ensureDrainToken(): string {
-  const existing = readState();
-  if (existing !== null) return existing.drainToken;
-
-  const token = crypto.randomUUID().replace(/-/g, "") + crypto.randomUUID().replace(/-/g, "");
-  const path = statePath();
-  if (path !== null) {
-    try {
-      writeFileSync(path, JSON.stringify({ drainToken: token }), {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-    } catch {
-      // A read-only config directory still yields a usable in-process token;
-      // only `stop` from another process is lost.
-    }
-  }
-  return token;
-}
-
-/** The persisted token, or null when this install has never started. */
-export function readPersistedDrainToken(): string | null {
-  return readState()?.drainToken ?? null;
-}

package/scripts/cli/gateway/instance-lock.ts

@@ -1,105 +0,0 @@
-import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-/**
- * A marker that one gateway owns this install's port.
- *
- * The port probe alone cannot tell a healthy gateway from a stranger's process:
- * something answering on 12800 is not necessarily ours, so a start that found
- * the port busy either failed outright or — worse — would have to guess before
- * stopping anything. The lock names the PID and the token it was written with,
- * which is what makes "is this our gateway?" answerable without guessing.
- *
- * It is advisory, not an OS lock: a stale file from a crashed process is the
- * normal case this exists to recover from, so presence alone never blocks a
- * start. Liveness is decided by probing the port, and identity by the token.
- */
-export interface InstanceLock {
-  readonly pid: number;
-  readonly port: number;
-  /** Fingerprint of the drain token, never the token itself. */
-  readonly tokenFingerprint: string;
-  readonly startedAt: string;
-}
-
-const LOCK_FILE = "instance.json";
-
-function lockPath(): string | null {
-  const configDir = process.env.CARTETHYIA_CONFIG_DIR;
-  return configDir ? join(configDir, LOCK_FILE) : null;
-}
-
-/** A short, non-reversible fingerprint so the token itself is never written. */
-export function fingerprint(token: string): string {
-  let hash = 0;
-  for (let i = 0; i < token.length; i += 1) {
-    hash = (hash * 31 + token.charCodeAt(i)) | 0;
-  }
-  return (hash >>> 0).toString(16).padStart(8, "0");
-}
-
-export function writeInstanceLock(port: number, pid: number, token: string): void {
-  const path = lockPath();
-  if (path === null) return;
-  const lock: InstanceLock = {
-    pid,
-    port,
-    tokenFingerprint: fingerprint(token),
-    startedAt: new Date().toISOString(),
-  };
-  try {
-    writeFileSync(path, JSON.stringify(lock), { encoding: "utf8", mode: 0o600 });
-  } catch {
-    // A read-only config directory costs the marker, not the run.
-  }
-}
-
-export function readInstanceLock(): InstanceLock | null {
-  const path = lockPath();
-  if (path === null || !existsSync(path)) return null;
-  try {
-    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
-    if (
-      parsed !== null &&
-      typeof parsed === "object" &&
-      "pid" in parsed &&
-      typeof parsed.pid === "number" &&
-      "port" in parsed &&
-      typeof parsed.port === "number" &&
-      "tokenFingerprint" in parsed &&
-      typeof parsed.tokenFingerprint === "string"
-    ) {
-      const startedAt = "startedAt" in parsed && typeof parsed.startedAt === "string" ? parsed.startedAt : "";
-      return {
-        pid: parsed.pid,
-        port: parsed.port,
-        tokenFingerprint: parsed.tokenFingerprint,
-        startedAt,
-      };
-    }
-  } catch {
-    // A corrupt marker reads as none.
-  }
-  return null;
-}
-
-export function clearInstanceLock(): void {
-  const path = lockPath();
-  if (path === null) return;
-  try {
-    unlinkSync(path);
-  } catch {
-    // Already gone, or the directory is read-only.
-  }
-}
-
-/** Whether a process id is alive. `0` is never a real pid. */
-export function pidAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}

package/scripts/cli/gateway/stop.ts

@@ -1,51 +0,0 @@
-/**
- * Stops a gateway this process started, gracefully where possible.
- *
- * The drain endpoint is the only graceful path: it lets in-flight responses
- * finish. The OS-level kill is the fallback, and it is reached whenever the
- * endpoint is unreachable — which is also what happens when the gateway is
- * already on its way out, so a failure here is not necessarily an error the
- * operator needs to act on.
- */
-export async function stopGateway(
-  current: Bun.Subprocess,
-  port: number,
-  drainToken: string,
-): Promise<void> {
-  let drainAccepted = false;
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/admin/drain`, {
-      method: "POST",
-      headers: { "x-drain-token": drainToken },
-      signal: AbortSignal.timeout(2_000),
-    });
-    drainAccepted = response.status === 202;
-  } catch {
-    // The process may already be exiting; fall back to its OS-level termination.
-  }
-  if (!drainAccepted) {
-    console.error("Could not request a graceful gateway drain; terminating the gateway process.");
-    current.kill();
-    await current.exited;
-    return;
-  }
-
-  // The drain is bounded: a gateway that accepted the request but never exits
-  // would otherwise hang the CLI. 30 s is the drain budget `src/main.ts` uses.
-  // The timer is cleared unconditionally afterwards — leaving it pending keeps
-  // the event loop alive for its full 30 s after the gateway is already gone,
-  // which made every `carte` exit take half a minute.
-  let timer: Timer | undefined;
-  const drained = await Promise.race([
-    current.exited,
-    new Promise<null>((resolveExit) => {
-      timer = setTimeout(() => resolveExit(null), 30_000);
-    }),
-  ]);
-  clearTimeout(timer);
-  if (drained === null) {
-    console.error("Graceful drain timed out; terminating the gateway process.");
-    current.kill();
-    await current.exited;
-  }
-}

package/scripts/cli/support/bun.ts

@@ -1,27 +0,0 @@
-/** Minimum Bun the repository declares in `package.json` `engines`. */
-export const MINIMUM_BUN_VERSION = "1.4.0";
-
-/**
- * True when `actual` is at least `minimum`, compared as dotted integers.
- * A non-numeric segment reads as 0, so a malformed version fails closed
- * against a real minimum instead of passing.
- */
-export function bunVersionAtLeast(actual: string, minimum: string): boolean {
-  const left = actual.split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const right = minimum.split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const length = Math.max(left.length, right.length);
-  for (let i = 0; i < length; i += 1) {
-    const a = left[i] ?? 0;
-    const b = right[i] ?? 0;
-    if (a !== b) return a > b;
-  }
-  return true;
-}
-
-/** Throws unless the running Bun satisfies the declared minimum. */
-export function assertBunVersion(): void {
-  if (bunVersionAtLeast(Bun.version, MINIMUM_BUN_VERSION)) return;
-  throw new Error(
-    `Bun ${MINIMUM_BUN_VERSION} or newer is required (found ${Bun.version}). Install it from https://bun.sh and run this command again.`,
-  );
-}

package/scripts/cli/support/version.ts

@@ -1,37 +0,0 @@
-import { resolvePackagePath } from "../../../src/config/package-paths";
-
-/** Reads the version from the installed package manifest. */
-export async function readInstalledVersion(): Promise<string> {
-  const metadata: unknown = await Bun.file(resolvePackagePath("package.json")).json();
-  if (
-    metadata === null ||
-    typeof metadata !== "object" ||
-    !("version" in metadata) ||
-    typeof metadata.version !== "string"
-  ) {
-    throw new Error("Cartethyia package version is unavailable");
-  }
-  return metadata.version;
-}
-
-/** Asks the npm registry for the newest published version, or null on failure. */
-export async function readLatestPublishedVersion(): Promise<string | null> {
-  try {
-    const response = await fetch("https://registry.npmjs.org/cartethyia/latest", {
-      signal: AbortSignal.timeout(4_000),
-    });
-    if (!response.ok) return null;
-    const metadata: unknown = await response.json();
-    if (
-      metadata !== null &&
-      typeof metadata === "object" &&
-      "version" in metadata &&
-      typeof metadata.version === "string"
-    ) {
-      return metadata.version;
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}