anypick 1.0.0

package/dist/utils/process/pid.d.ts

@@ -0,0 +1,95 @@
+export declare const PID_RECORD_VERSION: 1;
+/**
+ * Structured ownership record replacing the old numeric PID file (PROC-01).
+ *
+ * A numeric PID is not verifiable: PID reuse (ABA) could make AnyPick signal an
+ * unrelated live process. The structured record carries a random instance id,
+ * so a process is only ever treated as owned after its health endpoint echoes
+ * the matching instance id — not merely after the PID is alive.
+ */
+export interface PidRecord {
+    recordVersion: number;
+    instanceId: string;
+    pid: number;
+    endpoint?: string;
+    provider?: string;
+    account?: string;
+    command?: string;
+    createdAt: string;
+}
+export interface SpawnDetachedOptions {
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+    /** Append stdout/stderr here. */
+    logPath: string;
+    /** Write the owner-only structured record here. */
+    pidPath: string;
+    /** Endpoint the child will serve a health check on (for identity verify). */
+    endpoint?: string;
+    /** Provider/account owning the process (recorded, never trusted as proof). */
+    provider?: string;
+    account?: string;
+}
+/**
+ * Spawn a long-running process detached from the CLI.
+ * stdout/stderr are appended to logPath; an owner-only structured record is
+ * written to pidPath (mode 0o600). Returns the child pid and its instance id.
+ */
+export declare function spawnDetached(command: string, args: string[], opts: SpawnDetachedOptions): Promise<{
+    pid: number;
+    instanceId: string;
+}>;
+/**
+ * Write an owner-only (0o600) structured pid record. Any failure throws rather
+ * than leaving a half-written, world-readable record.
+ */
+export declare function writePidRecord(pidPath: string, record: Omit<PidRecord, 'recordVersion' | 'createdAt'>): void;
+/**
+ * Read a structured pid record. Returns null when:
+ *  - the file is absent,
+ *  - it is not valid JSON or is missing required fields (corrupt/partial),
+ *  - it is a legacy numeric PID file (untrusted — fail closed so PID reuse
+ *    cannot make us signal an unrelated live process).
+ */
+export declare function readPidRecord(pidPath: string): Promise<PidRecord | null>;
+/**
+ * Backward-compatible pid reader. Prefers the structured record; returns its
+ * pid. Legacy numeric files are UNTRUSTED and yield null (fail closed).
+ */
+export declare function readPidFile(pidPath: string): Promise<number | null>;
+export declare function isProcessRunning(pid: number): boolean;
+export interface StopPidFileOptions {
+    /** Time allowed for SIGTERM cleanup before SIGKILL. */
+    graceMs?: number;
+    /** Detached processes own a process group; signal it so grandchildren exit too. */
+    processGroup?: boolean;
+    /**
+     * Verify the recorded instance id through the child's health endpoint before
+     * signalling. Defaults to true; only supervisors with a separate ownership
+     * channel (for example the macOS tray state file) may opt out explicitly.
+     */
+    verifyHealth?: boolean;
+    /**
+     * Whether the child echoes ANYPICK_INSTANCE_ID from /health. Defaults to true.
+     *
+     * A third-party binary cannot, so demanding it would leave every external
+     * proxy unstoppable. Ownership is then proved from the process start time
+     * instead: the record is written at spawn, so a live process whose start time
+     * matches `createdAt` cannot be a recycled PID — reuse only happens after the
+     * original exits, which is necessarily later. This is a different proof of
+     * the same fact, not a relaxation of PROC-01.
+     */
+    expectInstanceId?: boolean;
+}
+/** Wall-clock start of a live process, or null if it cannot be determined. */
+export declare function processStartedAt(pid: number): Promise<number | null>;
+/**
+ * Stop a process recorded in pidPath. Returns true if a signal was sent.
+ * Waits until the process is gone (or force-kills) so the listen port can free.
+ *
+ * PROC-01 (fail closed): if the record is absent or unverifiable, stopPidFile
+ * returns false and signals nothing — it must never kill a process it cannot
+ * prove it owns (PID reuse / ABA).
+ */
+export declare function stopPidFile(pidPath: string, opts?: StopPidFileOptions): Promise<boolean>;
+//# sourceMappingURL=pid.d.ts.map

package/dist/utils/process/pid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pid.d.ts","sourceRoot":"","sources":["../../../src/utils/process/pid.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,kBAAkB,EAAG,CAAU,CAAC;AAsB7C;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;IACnB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAC;IACxB,iCAAiC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,mDAAmD;IACnD,OAAO,EAAE,MAAM,CAAC;IAChB,6EAA6E;IAC7E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EAAE,EACd,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAgD9C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,IAAI,CAAC,SAAS,EAAE,eAAe,GAAG,WAAW,CAAC,GACrD,IAAI,CASN;AAaD;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA2B9E;AAiBD;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGzE;AAED,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAOrD;AAED,MAAM,WAAW,kBAAkB;IACjC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mFAAmF;IACnF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;;;;;;OASG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,8EAA8E;AAC9E,wBAAsB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAe1E;AA0CD;;;;;;;GAOG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,OAAO,CAAC,CAyGlB"}

package/dist/utils/process/pid.js

@@ -0,0 +1,243 @@
+import { ensureDir, pathExists } from "../fs.js";
+import { sleep, verifyProcessHealth } from "./health.js";
+import { chmodSync, existsSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { open, readFile, unlink } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+/**
+* How far a process start time may sit from the pid record's `createdAt` and
+* still count as the process we spawned. `ps` reports whole seconds, and the
+* record is written moments after the fork, so this only has to absorb spawn
+* latency — it is deliberately far smaller than any realistic PID-reuse gap.
+*/
+var START_TIME_TOLERANCE_MS = 6e4;
+/**
+* Budget for one ownership proof: a loopback health probe plus, for a
+* third-party child, a `ps` fork.
+*
+* Deliberately not derived from `graceMs`. That is how long a caller will wait
+* for a cooperative exit; this is how long the *proof* may take, and on a loaded
+* machine the probe alone can exceed a second. Folding the two together let a
+* caller asking for a fast kill make ownership unprovable, and an unprovable
+* stop fails closed — leaking a live proxy that still holds its port.
+*/
+var VERIFY_OWNERSHIP_TIMEOUT_MS = 5e3;
+/**
+* Spawn a long-running process detached from the CLI.
+* stdout/stderr are appended to logPath; an owner-only structured record is
+* written to pidPath (mode 0o600). Returns the child pid and its instance id.
+*/
+async function spawnDetached(command, args, opts) {
+	await ensureDir(dirname(opts.logPath));
+	await ensureDir(dirname(opts.pidPath));
+	const logFd = await open(opts.logPath, "a");
+	const instanceId = randomUUID();
+	const childEnv = {
+		...opts.env ?? process.env,
+		ANYPICK_INSTANCE_ID: instanceId
+	};
+	const child = spawn(command, args, {
+		cwd: opts.cwd,
+		env: childEnv,
+		detached: true,
+		stdio: [
+			"ignore",
+			logFd.fd,
+			logFd.fd
+		]
+	});
+	child.unref();
+	await logFd.close();
+	if (child.pid == null) throw new Error(`Failed to spawn ${command}`);
+	try {
+		writePidRecord(opts.pidPath, {
+			instanceId,
+			pid: child.pid,
+			endpoint: opts.endpoint,
+			provider: opts.provider,
+			account: opts.account,
+			command
+		});
+	} catch (err) {
+		signalProcess(child.pid, "SIGTERM", true);
+		throw err;
+	}
+	return {
+		pid: child.pid,
+		instanceId
+	};
+}
+/**
+* Write an owner-only (0o600) structured pid record. Any failure throws rather
+* than leaving a half-written, world-readable record.
+*/
+function writePidRecord(pidPath, record) {
+	const full = {
+		recordVersion: 1,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		...record
+	};
+	writeFileSyncAtomic(`${pidPath}.${randomUUID()}.tmp`, JSON.stringify(full), pidPath);
+}
+function writeFileSyncAtomic(tmp, contents, target) {
+	writeFileSync(tmp, contents, { mode: 384 });
+	renameSync(tmp, target);
+	try {
+		chmodSync(target, 384);
+	} catch {}
+}
+/**
+* Read a structured pid record. Returns null when:
+*  - the file is absent,
+*  - it is not valid JSON or is missing required fields (corrupt/partial),
+*  - it is a legacy numeric PID file (untrusted — fail closed so PID reuse
+*    cannot make us signal an unrelated live process).
+*/
+async function readPidRecord(pidPath) {
+	if (!await pathExists(pidPath)) return null;
+	let raw;
+	try {
+		raw = (await readFile(pidPath, "utf8")).trim();
+	} catch {
+		return null;
+	}
+	if (!raw) return null;
+	if (/^\d+\s*$/.test(raw)) return null;
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	if (!isPidRecord(parsed)) return null;
+	return parsed;
+}
+function isPidRecord(v) {
+	if (typeof v !== "object" || v === null) return false;
+	const r = v;
+	return typeof r.instanceId === "string" && r.instanceId.length > 0 && typeof r.pid === "number" && Number.isInteger(r.pid) && r.pid > 0 && typeof r.recordVersion === "number";
+}
+/**
+* Backward-compatible pid reader. Prefers the structured record; returns its
+* pid. Legacy numeric files are UNTRUSTED and yield null (fail closed).
+*/
+async function readPidFile(pidPath) {
+	const rec = await readPidRecord(pidPath);
+	return rec ? rec.pid : null;
+}
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/** Wall-clock start of a live process, or null if it cannot be determined. */
+async function processStartedAt(pid) {
+	if (process.platform === "win32") return null;
+	try {
+		const { execFile } = await import("node:child_process");
+		const { promisify } = await import("node:util");
+		const { stdout } = await promisify(execFile)("/bin/ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"lstart="
+		], { timeout: 2e3 });
+		const parsed = Date.parse(stdout.trim());
+		return Number.isNaN(parsed) ? null : parsed;
+	} catch {
+		return null;
+	}
+}
+function signalProcess(pid, signal, processGroup) {
+	if (processGroup && process.platform !== "win32") try {
+		process.kill(-pid, signal);
+		return true;
+	} catch {}
+	try {
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		return false;
+	}
+}
+/**
+* Whether `pid` is still the process that was proven owned before SIGTERM.
+*
+* Prefers the start time captured while the child was demonstrably ours: it
+* stays valid through a shutdown that has already closed the health listener.
+* Falls back to the health proof only when the platform cannot report a start
+* time (Windows), and fails closed when neither is available (PROC-01).
+*/
+async function stillSameProcess(pid, ownedStartedAt, verifyViaHealth) {
+	if (ownedStartedAt == null) return verifyViaHealth();
+	const current = await processStartedAt(pid);
+	if (current == null) return false;
+	return Math.abs(current - ownedStartedAt) <= START_TIME_TOLERANCE_MS;
+}
+/**
+* Stop a process recorded in pidPath. Returns true if a signal was sent.
+* Waits until the process is gone (or force-kills) so the listen port can free.
+*
+* PROC-01 (fail closed): if the record is absent or unverifiable, stopPidFile
+* returns false and signals nothing — it must never kill a process it cannot
+* prove it owns (PID reuse / ABA).
+*/
+async function stopPidFile(pidPath, opts = {}) {
+	const rec = await readPidRecord(pidPath);
+	if (rec == null) return false;
+	const pid = rec.pid;
+	const byInstanceId = opts.expectInstanceId !== false;
+	let healthEndpoint;
+	const verifyOwned = async (timeoutMs) => {
+		if (opts.verifyHealth === false) return true;
+		if (!healthEndpoint) return false;
+		const healthy = await verifyProcessHealth(healthEndpoint, {
+			...byInstanceId ? { expectInstanceId: rec.instanceId } : {},
+			requirePid: pid,
+			timeoutMs,
+			intervalMs: 50
+		});
+		if (!healthy || byInstanceId) return healthy;
+		const startedAt = await processStartedAt(pid);
+		if (startedAt == null) return false;
+		return Math.abs(startedAt - Date.parse(rec.createdAt)) <= START_TIME_TOLERANCE_MS;
+	};
+	if (opts.verifyHealth !== false) {
+		if (!rec.endpoint || !rec.instanceId) return false;
+		try {
+			const url = new URL(rec.endpoint);
+			if (url.pathname === "" || url.pathname === "/") url.pathname = "/health";
+			else if (!url.pathname.endsWith("/health")) url.pathname = `${url.pathname.replace(/\/$/, "")}/health`;
+			healthEndpoint = url.toString();
+		} catch {
+			return false;
+		}
+		if (!await verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS)) return false;
+	}
+	let signaled = false;
+	if (isProcessRunning(pid)) {
+		if (!await verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS)) return false;
+		const ownedStartedAt = await processStartedAt(pid);
+		signaled = signalProcess(pid, "SIGTERM", opts.processGroup ?? true);
+		const deadline = Date.now() + (opts.graceMs ?? 3e3);
+		while (isProcessRunning(pid) && Date.now() < deadline) await sleep(50);
+		if (isProcessRunning(pid)) {
+			if (!await stillSameProcess(pid, ownedStartedAt, () => verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS))) return signaled;
+			signalProcess(pid, "SIGKILL", opts.processGroup ?? true);
+			const killDeadline = Date.now() + 1e3;
+			while (isProcessRunning(pid) && Date.now() < killDeadline) await sleep(25);
+		}
+	}
+	if (!isProcessRunning(pid) && existsSync(pidPath)) try {
+		await unlink(pidPath);
+	} catch {}
+	return signaled;
+}
+//#endregion
+export { isProcessRunning, processStartedAt, readPidFile, readPidRecord, spawnDetached, stopPidFile, writePidRecord };
+
+//# sourceMappingURL=pid.js.map

package/dist/utils/process/pid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pid.js","names":[],"sources":["../../../src/utils/process/pid.ts"],"sourcesContent":["import { spawn } from 'node:child_process';\nimport { open, readFile, unlink } from 'node:fs/promises';\nimport { writeFileSync, renameSync, chmodSync, existsSync } from 'node:fs';\nimport { randomUUID } from 'node:crypto';\nimport { ensureDir, pathExists } from '../fs';\nimport { dirname } from 'node:path';\nimport { sleep, verifyProcessHealth } from './health';\n\nexport const PID_RECORD_VERSION = 1 as const;\n\n/**\n * How far a process start time may sit from the pid record's `createdAt` and\n * still count as the process we spawned. `ps` reports whole seconds, and the\n * record is written moments after the fork, so this only has to absorb spawn\n * latency — it is deliberately far smaller than any realistic PID-reuse gap.\n */\nconst START_TIME_TOLERANCE_MS = 60_000;\n\n/**\n * Budget for one ownership proof: a loopback health probe plus, for a\n * third-party child, a `ps` fork.\n *\n * Deliberately not derived from `graceMs`. That is how long a caller will wait\n * for a cooperative exit; this is how long the *proof* may take, and on a loaded\n * machine the probe alone can exceed a second. Folding the two together let a\n * caller asking for a fast kill make ownership unprovable, and an unprovable\n * stop fails closed — leaking a live proxy that still holds its port.\n */\nconst VERIFY_OWNERSHIP_TIMEOUT_MS = 5000;\n\n/**\n * Structured ownership record replacing the old numeric PID file (PROC-01).\n *\n * A numeric PID is not verifiable: PID reuse (ABA) could make AnyPick signal an\n * unrelated live process. The structured record carries a random instance id,\n * so a process is only ever treated as owned after its health endpoint echoes\n * the matching instance id — not merely after the PID is alive.\n */\nexport interface PidRecord {\n  recordVersion: number;\n  instanceId: string;\n  pid: number;\n  endpoint?: string;\n  provider?: string;\n  account?: string;\n  command?: string;\n  createdAt: string;\n}\n\nexport interface SpawnDetachedOptions {\n  cwd?: string;\n  env?: NodeJS.ProcessEnv;\n  /** Append stdout/stderr here. */\n  logPath: string;\n  /** Write the owner-only structured record here. */\n  pidPath: string;\n  /** Endpoint the child will serve a health check on (for identity verify). */\n  endpoint?: string;\n  /** Provider/account owning the process (recorded, never trusted as proof). */\n  provider?: string;\n  account?: string;\n}\n\n/**\n * Spawn a long-running process detached from the CLI.\n * stdout/stderr are appended to logPath; an owner-only structured record is\n * written to pidPath (mode 0o600). Returns the child pid and its instance id.\n */\nexport async function spawnDetached(\n  command: string,\n  args: string[],\n  opts: SpawnDetachedOptions,\n): Promise<{ pid: number; instanceId: string }> {\n  await ensureDir(dirname(opts.logPath));\n  await ensureDir(dirname(opts.pidPath));\n\n  const logFd = await open(opts.logPath, 'a');\n\n  const instanceId = randomUUID();\n\n  // Inject the instance id into the child's env so the proxy can echo it at\n  // /health. Identity verification (not just pid liveness) is what lets us\n  // treat a process as genuinely ours (PROC-01, ABA-safe).\n  const childEnv: NodeJS.ProcessEnv = {\n    ...(opts.env ?? process.env),\n    ANYPICK_INSTANCE_ID: instanceId,\n  };\n\n  const child = spawn(command, args, {\n    cwd: opts.cwd,\n    env: childEnv,\n    detached: true,\n    stdio: ['ignore', logFd.fd, logFd.fd],\n  });\n\n  child.unref();\n  await logFd.close();\n\n  if (child.pid == null) {\n    throw new Error(`Failed to spawn ${command}`);\n  }\n\n  try {\n    writePidRecord(opts.pidPath, {\n      instanceId,\n      pid: child.pid,\n      endpoint: opts.endpoint,\n      provider: opts.provider,\n      account: opts.account,\n      command,\n    });\n  } catch (err) {\n    // The caller cannot later discover an unrecorded detached child. This PID\n    // came directly from this spawn, so cleanup is safe even without a health\n    // endpoint/record verification.\n    signalProcess(child.pid, 'SIGTERM', true);\n    throw err;\n  }\n\n  return { pid: child.pid, instanceId };\n}\n\n/**\n * Write an owner-only (0o600) structured pid record. Any failure throws rather\n * than leaving a half-written, world-readable record.\n */\nexport function writePidRecord(\n  pidPath: string,\n  record: Omit<PidRecord, 'recordVersion' | 'createdAt'>,\n): void {\n  const full: PidRecord = {\n    recordVersion: PID_RECORD_VERSION,\n    createdAt: new Date().toISOString(),\n    ...record,\n  };\n  // Write atomically to a sibling, then rename over the target.\n  const tmp = `${pidPath}.${randomUUID()}.tmp`;\n  writeFileSyncAtomic(tmp, JSON.stringify(full), pidPath);\n}\n\nfunction writeFileSyncAtomic(tmp: string, contents: string, target: string): void {\n  // Synchronous so the record is durable before spawnDetached returns.\n  writeFileSync(tmp, contents, { mode: 0o600 });\n  renameSync(tmp, target);\n  try {\n    chmodSync(target, 0o600);\n  } catch {\n    // best-effort; rename already applied 0o600 on POSIX\n  }\n}\n\n/**\n * Read a structured pid record. Returns null when:\n *  - the file is absent,\n *  - it is not valid JSON or is missing required fields (corrupt/partial),\n *  - it is a legacy numeric PID file (untrusted — fail closed so PID reuse\n *    cannot make us signal an unrelated live process).\n */\nexport async function readPidRecord(pidPath: string): Promise<PidRecord | null> {\n  if (!(await pathExists(pidPath))) {\n    return null;\n  }\n  let raw: string;\n  try {\n    raw = (await readFile(pidPath, 'utf8')).trim();\n  } catch {\n    return null;\n  }\n  if (!raw) {\n    return null;\n  }\n  // Legacy numeric record: never trust it as a pid.\n  if (/^\\d+\\s*$/.test(raw)) {\n    return null;\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch {\n    return null;\n  }\n  if (!isPidRecord(parsed)) {\n    return null;\n  }\n  return parsed;\n}\n\nfunction isPidRecord(v: unknown): v is PidRecord {\n  if (typeof v !== 'object' || v === null) {\n    return false;\n  }\n  const r = v as Record<string, unknown>;\n  return (\n    typeof r.instanceId === 'string' &&\n    r.instanceId.length > 0 &&\n    typeof r.pid === 'number' &&\n    Number.isInteger(r.pid) &&\n    r.pid > 0 &&\n    typeof r.recordVersion === 'number'\n  );\n}\n\n/**\n * Backward-compatible pid reader. Prefers the structured record; returns its\n * pid. Legacy numeric files are UNTRUSTED and yield null (fail closed).\n */\nexport async function readPidFile(pidPath: string): Promise<number | null> {\n  const rec = await readPidRecord(pidPath);\n  return rec ? rec.pid : null;\n}\n\nexport function isProcessRunning(pid: number): boolean {\n  try {\n    process.kill(pid, 0);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nexport interface StopPidFileOptions {\n  /** Time allowed for SIGTERM cleanup before SIGKILL. */\n  graceMs?: number;\n  /** Detached processes own a process group; signal it so grandchildren exit too. */\n  processGroup?: boolean;\n  /**\n   * Verify the recorded instance id through the child's health endpoint before\n   * signalling. Defaults to true; only supervisors with a separate ownership\n   * channel (for example the macOS tray state file) may opt out explicitly.\n   */\n  verifyHealth?: boolean;\n  /**\n   * Whether the child echoes ANYPICK_INSTANCE_ID from /health. Defaults to true.\n   *\n   * A third-party binary cannot, so demanding it would leave every external\n   * proxy unstoppable. Ownership is then proved from the process start time\n   * instead: the record is written at spawn, so a live process whose start time\n   * matches `createdAt` cannot be a recycled PID — reuse only happens after the\n   * original exits, which is necessarily later. This is a different proof of\n   * the same fact, not a relaxation of PROC-01.\n   */\n  expectInstanceId?: boolean;\n}\n\n/** Wall-clock start of a live process, or null if it cannot be determined. */\nexport async function processStartedAt(pid: number): Promise<number | null> {\n  if (process.platform === 'win32') {\n    return null;\n  }\n  try {\n    const { execFile } = await import('node:child_process');\n    const { promisify } = await import('node:util');\n    const { stdout } = await promisify(execFile)('/bin/ps', ['-p', String(pid), '-o', 'lstart='], {\n      timeout: 2000,\n    });\n    const parsed = Date.parse(stdout.trim());\n    return Number.isNaN(parsed) ? null : parsed;\n  } catch {\n    return null;\n  }\n}\n\nfunction signalProcess(pid: number, signal: NodeJS.Signals, processGroup: boolean): boolean {\n  if (processGroup && process.platform !== 'win32') {\n    try {\n      process.kill(-pid, signal);\n      return true;\n    } catch {\n      // The process may not be a group leader (legacy runtime); fall back to its PID.\n    }\n  }\n  try {\n    process.kill(pid, signal);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Whether `pid` is still the process that was proven owned before SIGTERM.\n *\n * Prefers the start time captured while the child was demonstrably ours: it\n * stays valid through a shutdown that has already closed the health listener.\n * Falls back to the health proof only when the platform cannot report a start\n * time (Windows), and fails closed when neither is available (PROC-01).\n */\nasync function stillSameProcess(\n  pid: number,\n  ownedStartedAt: number | null,\n  verifyViaHealth: () => Promise<boolean>,\n): Promise<boolean> {\n  if (ownedStartedAt == null) {\n    return verifyViaHealth();\n  }\n  const current = await processStartedAt(pid);\n  if (current == null) {\n    return false;\n  }\n  return Math.abs(current - ownedStartedAt) <= START_TIME_TOLERANCE_MS;\n}\n\n/**\n * Stop a process recorded in pidPath. Returns true if a signal was sent.\n * Waits until the process is gone (or force-kills) so the listen port can free.\n *\n * PROC-01 (fail closed): if the record is absent or unverifiable, stopPidFile\n * returns false and signals nothing — it must never kill a process it cannot\n * prove it owns (PID reuse / ABA).\n */\nexport async function stopPidFile(\n  pidPath: string,\n  opts: StopPidFileOptions = {},\n): Promise<boolean> {\n  const rec = await readPidRecord(pidPath);\n  if (rec == null) {\n    return false;\n  }\n  const pid = rec.pid;\n\n  // A syntactically valid PID record is not proof of ownership: the PID may\n  // have been recycled since the record was written. Built-in proxies echo\n  // ANYPICK_INSTANCE_ID from /health, so require that identity match before any\n  // signal. If the endpoint/health check is unavailable, fail closed and leave\n  // the record for doctor/recovery rather than risking an unrelated process.\n  const byInstanceId = opts.expectInstanceId !== false;\n  let healthEndpoint: string | undefined;\n  const verifyOwned = async (timeoutMs: number): Promise<boolean> => {\n    if (opts.verifyHealth === false) {\n      return true;\n    }\n    if (!healthEndpoint) {\n      return false;\n    }\n    const healthy = await verifyProcessHealth(healthEndpoint, {\n      ...(byInstanceId ? { expectInstanceId: rec.instanceId } : {}),\n      requirePid: pid,\n      timeoutMs,\n      intervalMs: 50,\n    });\n    if (!healthy || byInstanceId) {\n      return healthy;\n    }\n    const startedAt = await processStartedAt(pid);\n    if (startedAt == null) {\n      return false;\n    }\n    return Math.abs(startedAt - Date.parse(rec.createdAt)) <= START_TIME_TOLERANCE_MS;\n  };\n\n  if (opts.verifyHealth !== false) {\n    if (!rec.endpoint || !rec.instanceId) {\n      return false;\n    }\n    try {\n      const url = new URL(rec.endpoint);\n      if (url.pathname === '' || url.pathname === '/') {\n        url.pathname = '/health';\n      } else if (!url.pathname.endsWith('/health')) {\n        url.pathname = `${url.pathname.replace(/\\/$/, '')}/health`;\n      }\n      healthEndpoint = url.toString();\n    } catch {\n      return false;\n    }\n    const owned = await verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS);\n    if (!owned) {\n      return false;\n    }\n  }\n\n  let signaled = false;\n  if (isProcessRunning(pid)) {\n    // Re-check immediately before signalling. A process can exit and its PID\n    // be recycled during the initial health probe.\n    if (!(await verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS))) {\n      return false;\n    }\n    // Ownership is proven here, while the child is still serving. Capture its\n    // start time now: escalation below cannot re-prove ownership through\n    // /health, because a child that honors SIGTERM closes its listener first\n    // and would then look unowned while it is still shutting down. Start time\n    // is the same PROC-01 proof that survives that window — a recycled PID\n    // necessarily starts later than the process it replaced.\n    const ownedStartedAt = await processStartedAt(pid);\n    signaled = signalProcess(pid, 'SIGTERM', opts.processGroup ?? true);\n    // Wait for graceful exit\n    const deadline = Date.now() + (opts.graceMs ?? 3000);\n    while (isProcessRunning(pid) && Date.now() < deadline) {\n      await sleep(50);\n    }\n    if (isProcessRunning(pid)) {\n      // Never escalate to SIGKILL after a PID-reuse window without proving the\n      // same instance still owns the endpoint.\n      if (\n        !(await stillSameProcess(pid, ownedStartedAt, () =>\n          verifyOwned(VERIFY_OWNERSHIP_TIMEOUT_MS),\n        ))\n      ) {\n        return signaled;\n      }\n      signalProcess(pid, 'SIGKILL', opts.processGroup ?? true);\n      const killDeadline = Date.now() + 1000;\n      while (isProcessRunning(pid) && Date.now() < killDeadline) {\n        await sleep(25);\n      }\n    }\n  }\n\n  // Never discard the only ownership record while the process is still alive.\n  if (!isProcessRunning(pid) && existsSync(pidPath)) {\n    try {\n      await unlink(pidPath);\n    } catch {\n      // ignore\n    }\n  }\n  return signaled;\n}\n"],"mappings":"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"}

package/dist/utils/process.d.ts

@@ -0,0 +1,5 @@
+export * from './process/pid.js';
+export * from './process/health.js';
+export * from './process/binary.js';
+export * from './process/follow.js';
+//# sourceMappingURL=process.d.ts.map

package/dist/utils/process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process.d.ts","sourceRoot":"","sources":["../../src/utils/process.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}

package/dist/utils/process.js

@@ -0,0 +1,5 @@
+import { isListenPortFree, listenPidsOnPort, sleep, verifyProcessHealth, waitForHttp } from "./process/health.js";
+import { isProcessRunning, processStartedAt, readPidFile, readPidRecord, spawnDetached, stopPidFile, writePidRecord } from "./process/pid.js";
+import { resolveBinary } from "./process/binary.js";
+import { followFile } from "./process/follow.js";
+export { followFile, isListenPortFree, isProcessRunning, listenPidsOnPort, processStartedAt, readPidFile, readPidRecord, resolveBinary, sleep, spawnDetached, stopPidFile, verifyProcessHealth, waitForHttp, writePidRecord };

package/dist/utils/slug.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Normalize a slug used for account or profile directory names.
+ *
+ * Human-friendly input is accepted and auto-slugified instead of rejected:
+ *   "Kiro Key - 1k"  →  "kiro-key-1k"
+ *   "Work Team"      →  "work-team"
+ *
+ * Result is safe for filesystem paths: lowercase, [a-z0-9._-], no spaces.
+ */
+export declare function normalizeSlug(raw: string, kind?: string): string;
+/**
+ * Original display form of a name (trimmed), for use as a human label.
+ * Returns undefined when it is empty or identical to the slug.
+ */
+export declare function displayLabelFromName(raw: string, slug: string): string | undefined;
+export declare function normalizeAccountName(raw: string): string;
+export declare function normalizeProfileName(raw: string): string;
+//# sourceMappingURL=slug.d.ts.map

package/dist/utils/slug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../src/utils/slug.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,SAAS,GAAG,MAAM,CAsChE;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMlF;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAExD"}

package/dist/utils/slug.js

@@ -0,0 +1,42 @@
+//#region src/utils/slug.ts
+/**
+* Normalize a slug used for account or profile directory names.
+*
+* Human-friendly input is accepted and auto-slugified instead of rejected:
+*   "Kiro Key - 1k"  →  "kiro-key-1k"
+*   "Work Team"      →  "work-team"
+*
+* Result is safe for filesystem paths: lowercase, [a-z0-9._-], no spaces.
+*/
+var MAX_SLUG_LEN = 64;
+function normalizeSlug(raw, kind = "name") {
+	if (raw == null || String(raw).trim() === "") throw new Error(`${kind} is required.`);
+	let name = String(raw).trim().normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase();
+	name = name.replace(/[/\\]+/g, "-").replace(/\.\.+/g, ".");
+	name = name.replace(/[^a-z0-9._-]+/g, "-");
+	name = name.replace(/-+/g, "-").replace(/_+/g, "_").replace(/\.+/g, ".");
+	name = name.replace(/^[-._]+|[-._]+$/g, "");
+	if (!name) throw new Error(`${kind} "${raw}" has no usable characters. Use letters or digits.`);
+	if (name.length > MAX_SLUG_LEN) name = name.slice(0, MAX_SLUG_LEN).replace(/[-._]+$/g, "");
+	if (!/^[a-z0-9]/.test(name)) throw new Error(`${kind} "${raw}" must start with a letter or digit after normalization.`);
+	return name;
+}
+/**
+* Original display form of a name (trimmed), for use as a human label.
+* Returns undefined when it is empty or identical to the slug.
+*/
+function displayLabelFromName(raw, slug) {
+	const label = String(raw).trim();
+	if (!label || label === slug) return;
+	return label;
+}
+function normalizeAccountName(raw) {
+	return normalizeSlug(raw, "Account name");
+}
+function normalizeProfileName(raw) {
+	return normalizeSlug(raw, "Profile name");
+}
+//#endregion
+export { displayLabelFromName, normalizeAccountName, normalizeProfileName, normalizeSlug };
+
+//# sourceMappingURL=slug.js.map

package/dist/utils/slug.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slug.js","names":[],"sources":["../../src/utils/slug.ts"],"sourcesContent":["/**\n * Normalize a slug used for account or profile directory names.\n *\n * Human-friendly input is accepted and auto-slugified instead of rejected:\n *   \"Kiro Key - 1k\"  →  \"kiro-key-1k\"\n *   \"Work Team\"      →  \"work-team\"\n *\n * Result is safe for filesystem paths: lowercase, [a-z0-9._-], no spaces.\n */\n\nconst MAX_SLUG_LEN = 64;\n\nexport function normalizeSlug(raw: string, kind = 'name'): string {\n  if (raw == null || String(raw).trim() === '') {\n    throw new Error(`${kind} is required.`);\n  }\n\n  // Unicode normalize + strip combining marks so \"café\" → \"cafe\"\n  let name = String(raw)\n    .trim()\n    .normalize('NFKD')\n    .replace(/[\\u0300-\\u036f]/g, '')\n    .toLowerCase();\n\n  // Path separators and parent refs must never survive\n  name = name.replace(/[/\\\\]+/g, '-').replace(/\\.\\.+/g, '.');\n\n  // Everything that is not a safe slug char → hyphen (spaces, punctuation, …)\n  name = name.replace(/[^a-z0-9._-]+/g, '-');\n\n  // Collapse runs of separators (keep dots as single dots when repeated)\n  name = name.replace(/-+/g, '-').replace(/_+/g, '_').replace(/\\.+/g, '.');\n\n  // Trim leading/trailing separators\n  name = name.replace(/^[-._]+|[-._]+$/g, '');\n\n  if (!name) {\n    throw new Error(`${kind} \"${raw}\" has no usable characters. Use letters or digits.`);\n  }\n\n  if (name.length > MAX_SLUG_LEN) {\n    name = name.slice(0, MAX_SLUG_LEN).replace(/[-._]+$/g, '');\n  }\n\n  // Must start with alphanumeric after cleanup\n  if (!/^[a-z0-9]/.test(name)) {\n    throw new Error(`${kind} \"${raw}\" must start with a letter or digit after normalization.`);\n  }\n\n  return name;\n}\n\n/**\n * Original display form of a name (trimmed), for use as a human label.\n * Returns undefined when it is empty or identical to the slug.\n */\nexport function displayLabelFromName(raw: string, slug: string): string | undefined {\n  const label = String(raw).trim();\n  if (!label || label === slug) {\n    return undefined;\n  }\n  return label;\n}\n\nexport function normalizeAccountName(raw: string): string {\n  return normalizeSlug(raw, 'Account name');\n}\n\nexport function normalizeProfileName(raw: string): string {\n  return normalizeSlug(raw, 'Profile name');\n}\n"],"mappings":";;;;;;;;;;AAUA,IAAM,eAAe;AAErB,SAAgB,cAAc,KAAa,OAAO,QAAgB;CAChE,IAAI,OAAO,QAAQ,OAAO,GAAG,CAAC,CAAC,KAAK,MAAM,IACxC,MAAM,IAAI,MAAM,GAAG,KAAK,cAAc;CAIxC,IAAI,OAAO,OAAO,GAAG,CAAC,CACnB,KAAK,CAAC,CACN,UAAU,MAAM,CAAC,CACjB,QAAQ,oBAAoB,EAAE,CAAC,CAC/B,YAAY;CAGf,OAAO,KAAK,QAAQ,WAAW,GAAG,CAAC,CAAC,QAAQ,UAAU,GAAG;CAGzD,OAAO,KAAK,QAAQ,kBAAkB,GAAG;CAGzC,OAAO,KAAK,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,QAAQ,GAAG;CAGvE,OAAO,KAAK,QAAQ,oBAAoB,EAAE;CAE1C,IAAI,CAAC,MACH,MAAM,IAAI,MAAM,GAAG,KAAK,IAAI,IAAI,mDAAmD;CAGrF,IAAI,KAAK,SAAS,cAChB,OAAO,KAAK,MAAM,GAAG,YAAY,CAAC,CAAC,QAAQ,YAAY,EAAE;CAI3D,IAAI,CAAC,YAAY,KAAK,IAAI,GACxB,MAAM,IAAI,MAAM,GAAG,KAAK,IAAI,IAAI,yDAAyD;CAG3F,OAAO;AACT;;;;;AAMA,SAAgB,qBAAqB,KAAa,MAAkC;CAClF,MAAM,QAAQ,OAAO,GAAG,CAAC,CAAC,KAAK;CAC/B,IAAI,CAAC,SAAS,UAAU,MACtB;CAEF,OAAO;AACT;AAEA,SAAgB,qBAAqB,KAAqB;CACxD,OAAO,cAAc,KAAK,cAAc;AAC1C;AAEA,SAAgB,qBAAqB,KAAqB;CACxD,OAAO,cAAc,KAAK,cAAc;AAC1C"}

package/package.json

@@ -0,0 +1,121 @@
+{
+  "name": "anypick",
+  "version": "1.0.0",
+  "description": "Switch accounts, route providers and keep your AI coding tools moving.",
+  "keywords": [
+    "accounts",
+    "auth",
+    "bindings",
+    "claude",
+    "cli",
+    "clients",
+    "codex",
+    "gateways",
+    "gemini",
+    "grok",
+    "kiro",
+    "opencode",
+    "proxy"
+  ],
+  "homepage": "https://anypick.dev",
+  "bugs": {
+    "url": "https://github.com/outof0/anypick/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/outof0/anypick.git"
+  },
+  "bin": {
+    "anypick": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./adapters": {
+      "types": "./dist/adapters.d.ts",
+      "import": "./dist/adapters.js",
+      "default": "./dist/adapters.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    },
+    "./types": {
+      "types": "./dist/public-types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./package.json": "./package.json",
+    "./internal/*": null
+  },
+  "dependencies": {
+    "@clack/core": "0.4.2",
+    "@clack/prompts": "^0.10.1",
+    "commander": "^13.1.0",
+    "ink": "^7.1.1",
+    "picocolors": "^1.1.1",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7"
+  },
+  "devDependencies": {
+    "@tailwindcss/vite": "^4.3.3",
+    "@types/node": "^22.15.21",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^6.0.5",
+    "changelogithub": "^14.0.0",
+    "ink-testing-library": "^4.0.0",
+    "oxfmt": "^0.59.0",
+    "oxlint": "^1.74.0",
+    "oxlint-tsgolint": "^0.24.0",
+    "playwright": "1.55.0",
+    "tailwindcss": "^4.3.3",
+    "tsx": "^4.19.4",
+    "typescript": "7.0.2",
+    "vite": "8.1.5",
+    "vitest": "4.1.10"
+  },
+  "engines": {
+    "node": ">=22.5.0"
+  },
+  "scripts": {
+    "dev": "node scripts/dev.mjs",
+    "start": "node dist/cli.js",
+    "build": "pnpm clean && tsc -p tsconfig.json --emitDeclarationOnly && node scripts/rewrite-declaration-specifiers.mjs && vite build && node scripts/copy-native-assets.mjs && node scripts/check-native-tray.mjs",
+    "clean": "node scripts/clean-dist.mjs",
+    "check": "oxfmt --check && pnpm lint && pnpm typecheck && pnpm release:check && pnpm test",
+    "format": "oxfmt",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "oxlint --type-aware --fix",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "package": "pnpm build && pnpm pack --pack-destination dist",
+    "package:smoke": "pnpm package && node scripts/pack-smoke.mjs",
+    "release": "pnpm release:plan",
+    "release:check": "node scripts/release-plan.mjs check",
+    "release:plan": "node scripts/release-plan.mjs plan",
+    "tray:build": "pnpm tray:ui:build && node scripts/build-tauri-tray.mjs",
+    "tray:check": "pnpm tray:ui:check && pnpm tray:ui:build && cargo check --manifest-path src/tray/tauri/src-tauri/Cargo.toml",
+    "tray:demo": "node scripts/demo-tauri-tray.mjs",
+    "tray:macos": "node scripts/demo-macos-tray.mjs",
+    "tray:smoke": "node scripts/smoke-tauri-tray.mjs",
+    "tray:smoke:probe": "node scripts/smoke-tauri-tray.mjs",
+    "tray:smoke:only": "node scripts/smoke-tauri-tray.mjs --smoke-only",
+    "tray:e2e:ui": "node scripts/e2e-tray-ui.mjs",
+    "tray:ui": "vite --config src/tray/tauri/ui/vite.config.ts",
+    "tray:ui:build": "vite build --config src/tray/tauri/ui/vite.config.ts",
+    "tray:ui:check": "tsc -p src/tray/tauri/ui/tsconfig.json --noEmit"
+  }
+}