anypick 1.0.0 → 1.1.1

package/dist/core/proxy-service.js

@@ -1,860 +0,0 @@
-import { AnyPickError } from "../utils/errors.js";
-import { ensureDir, pathExists } from "../utils/fs.js";
-import { accountSnapshotDir } from "./paths.js";
-import { normalizeAccountName } from "../utils/slug.js";
-import { isListenPortFree } from "../utils/process/health.js";
-import { isProcessRunning, readPidFile, readPidRecord } from "../utils/process/pid.js";
-import { followFile } from "../utils/process/follow.js";
-import { PoolStore, poolRuntimeDir } from "./pool-store.js";
-import { realignClientsToAccountProxy } from "./realign-proxy-clients.js";
-import { providerCanProxy } from "./capabilities.js";
-import { ProxyPortAllocator, validatePort } from "./proxy-ports.js";
-import { assertLoopbackHost } from "../utils/network.js";
-import { withMutationLock } from "./mutation-lock.js";
-import { readQuotaGuardState } from "../providers/quota-guard.js";
-import { readFile } from "node:fs/promises";
-import { randomBytes } from "node:crypto";
-//#region src/core/proxy-service.ts
-/** Best-effort port extraction from an endpoint like http://127.0.0.1:8080. */
-function portFromEndpoint(endpoint) {
-	const m = /:(\d+)(?:\/|$)/.exec(endpoint);
-	return m ? Number(m[1]) : 8080;
-}
-/**
-* A single-account proxy is never a pool member, so pool options must not reach
-* it. Older versions persisted `authDirs` onto the primary account's config and
-* nothing removed them when the pool went back to single mode; `authDirs` then
-* takes precedence over the account's own snapshot dir, so the proxy serves
-* whichever account happened to be primary. Dropping them on read retires those
-* records without a migration.
-*/
-function withoutPoolOptions(config) {
-	if (!config.options) return { ...config };
-	const { pool: _pool, authDirs: _authDirs, ...options } = config.options;
-	return {
-		...config,
-		options
-	};
-}
-/**
-* Owns proxy lifecycle and multi-account pools.
-* Constructed by the app composition root and exposed as `app.proxy`.
-*/
-var ProxyService = class {
-	store;
-	registry;
-	quotaGuardPolicy;
-	pools;
-	/**
-	* Optional dependency used when a proxy starts: realign bound clients'
-	* BASE_URLs to the new endpoint. Injected at construction (composition time)
-	* rather than wired afterwards, so the service has no upward dependency on
-	* the app graph.
-	*/
-	realign;
-	/**
-	* Lease table. Every proxy started through this service records a lease keyed
-	* to the owning process, so `reapStaleLeases` can stop orphaned proxies on the
-	* next startup — not just proxies started by the activation pipeline.
-	*
-	* Optional so a caller can build a proxy service without lease bookkeeping,
-	* but supplied at construction: it used to be wired by `setLeaseStore()` after
-	* the fact, which meant the service was observably half-built between the two
-	* calls and could not be constructed in a test without replaying that dance.
-	*/
-	leases;
-	/** Listen-port allocation (see proxy-ports.ts). */
-	ports;
-	constructor(store, registry, pools, realign, leases, quotaGuardPolicy = async () => ({
-		enabled: false,
-		cooldownMinutes: 60
-	})) {
-		this.store = store;
-		this.registry = registry;
-		this.quotaGuardPolicy = quotaGuardPolicy;
-		this.pools = pools ?? new PoolStore(store.root, store.db);
-		this.realign = realign;
-		this.leases = leases;
-		this.ports = new ProxyPortAllocator(registry, store);
-	}
-	/**
-	* Optional re-publisher for the live Codex config block, wired in app.ts so this
-	* service does not depend on Hub/Codex services it was not constructed with.
-	*/
-	codexLiveConfigSync;
-	setCodexLiveConfigSync(fn) {
-		this.codexLiveConfigSync = fn;
-	}
-	async syncCodexLiveConfig() {
-		try {
-			await this.codexLiveConfigSync?.();
-		} catch {}
-	}
-	/**
-	* Record a lease for a freshly started proxy owned by this process, replacing
-	* any prior lease for the same provider/account. No-op when no lease store is
-	* wired. Best-effort: lease bookkeeping must never fail a proxy start.
-	*/
-	recordLease(provider, account, handle, forcedOwnerPid) {
-		if (!this.leases) return;
-		try {
-			const previous = this.leases.findByProviderAccount(provider, account);
-			const ownerPid = forcedOwnerPid ?? (previous && previous.ownerPid !== handle.pid && isProcessRunning(previous.ownerPid) ? previous.ownerPid : process.pid);
-			this.leases.releaseByProviderAccount(provider, account);
-			const lease = this.leases.create({
-				provider,
-				account,
-				port: portFromEndpoint(handle.endpoint),
-				endpoint: handle.endpoint,
-				ownerPid,
-				instanceId: handle.instanceId
-			});
-			handle.leaseId = lease.leaseId;
-			return lease.leaseId;
-		} catch {
-			return;
-		}
-	}
-	/** Release the lease for a stopped proxy. No-op without a lease store. */
-	releaseLease(provider, account) {
-		if (!this.leases) return;
-		try {
-			this.leases.releaseByProviderAccount(provider, account);
-		} catch {}
-	}
-	provider(id) {
-		return this.registry.get(id);
-	}
-	listProviders() {
-		return this.registry.list();
-	}
-	async getPool(providerId) {
-		this.requireProxyProvider(providerId);
-		const accounts = await this.store.listAccounts(providerId);
-		return this.pools.syncMembers(providerId, accounts.map((a) => a.meta.name));
-	}
-	/** Opt-in multi-account pool for a provider. */
-	async enablePoolMulti(providerId, opts = {}) {
-		const provider = this.requireProxyProvider(providerId);
-		const accounts = await this.store.listAccounts(providerId);
-		if (accounts.length === 0) throw new AnyPickError(`No saved logins for ${providerId}. Save one first.`, "NO_ACCOUNTS");
-		const port = validatePort(opts.port ?? provider.defaultProxyPort ?? 8080);
-		assertLoopbackHost(opts.host ?? "127.0.0.1");
-		const pool = await this.pools.enableMulti(providerId, accounts.map((a) => a.meta.name), {
-			port,
-			host: opts.host ?? "127.0.0.1"
-		});
-		let started;
-		if (opts.start !== false) started = await this.startPoolProxy(providerId);
-		return {
-			pool,
-			started
-		};
-	}
-	/** Back to per-account proxies (default). Stops pool process if running. */
-	async disablePoolMulti(providerId) {
-		this.requireProxyProvider(providerId);
-		try {
-			await this.stopPoolProxy(providerId);
-		} catch {}
-		return this.pools.disableMulti(providerId);
-	}
-	async setPoolMemberEnabled(providerId, account, enabled) {
-		this.requireProxyProvider(providerId);
-		const name = normalizeAccountName(account);
-		await this.store.requireAccount(providerId, name);
-		const pool = await this.pools.setMemberEnabled(providerId, name, enabled);
-		if (pool.mode === "multi" && pool.enabled) {
-			if ((await this.poolProxyStatus(providerId)).running) await this.startPoolProxy(providerId);
-		}
-		return pool;
-	}
-	async startPoolProxy(providerId) {
-		const provider = this.requireProxyProvider(providerId);
-		const pool = await this.getPool(providerId);
-		if (pool.mode !== "multi") throw new AnyPickError(`Pool multi-mode is off for ${providerId} (default is single account). Enable with: anypick proxy pool enable ${providerId}`, "POOL_NOT_ENABLED");
-		const enabled = pool.members.filter((m) => m.enabled);
-		if (enabled.length === 0) throw new AnyPickError(`No enabled accounts in ${providerId} pool. Enable a member first.`, "POOL_EMPTY");
-		const host = pool.host ?? "127.0.0.1";
-		assertLoopbackHost(host);
-		const port = validatePort(pool.port ?? provider.defaultProxyPort ?? 8080);
-		await this.pools.set({
-			...pool,
-			enabled: true,
-			host,
-			port
-		});
-		const primary = enabled[0];
-		const config = {
-			enabled: true,
-			host,
-			port
-		};
-		await this.store.setProxyConfig(providerId, primary.account, config);
-		const runtimeDir = poolRuntimeDir(this.store.root, providerId);
-		await ensureDir(runtimeDir);
-		if (!provider.startProxy) throw new AnyPickError("PROXY_NOT_IMPLEMENTED", "PROXY_NOT_IMPLEMENTED");
-		try {
-			await this.stopPoolProxy(providerId);
-		} catch {}
-		try {
-			await this.stopProxyInternal(provider, primary.account);
-		} catch {}
-		const priorState = await this.store.readProxyState(providerId, primary.account);
-		const poolToken = priorState?.token && priorState.token.length > 0 ? priorState.token : randomBytes(32).toString("hex");
-		const quotaGuard = await this.quotaGuardPolicy();
-		const ctx = {
-			providerId,
-			accountName: primary.account,
-			snapshotDir: accountSnapshotDir(this.store.root, providerId, primary.account),
-			runtimeDir,
-			config: {
-				...config,
-				options: {
-					pool: true,
-					authDirs: enabled.map((m) => accountSnapshotDir(this.store.root, providerId, m.account)),
-					quotaGuardAccountNames: enabled.map((m) => m.account),
-					quotaGuard: {
-						enabled: quotaGuard.enabled,
-						cooldownMs: quotaGuard.cooldownMinutes * 6e4
-					}
-				}
-			},
-			token: poolToken
-		};
-		const handle = await provider.startProxy(ctx);
-		await this.store.writeProxyState(providerId, primary.account, {
-			accountName: primary.account,
-			endpoint: handle.endpoint,
-			compatibility: handle.compatibility ?? provider.proxyCompatibility,
-			pid: handle.pid,
-			logPath: handle.logPath,
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			token: poolToken
-		});
-		this.recordLease(providerId, void 0, handle);
-		handle.startedNow = true;
-		return handle;
-	}
-	/** Restart only pools that are currently serving, after changing a pool-wide policy. */
-	async restartRunningPools() {
-		for (const provider of this.registry.list().filter((entry) => providerCanProxy(entry))) try {
-			const pool = await this.getPool(provider.id);
-			const status = await this.poolProxyStatus(provider.id);
-			if (pool.mode === "multi" && pool.enabled && status.running) await this.startPoolProxy(provider.id);
-		} catch {}
-	}
-	/** Secret-free audit events written by an enabled compatibility proxy pool. */
-	async quotaGuardEvents() {
-		const events = [];
-		for (const provider of this.registry.list().filter((entry) => providerCanProxy(entry))) try {
-			if ((await this.getPool(provider.id)).mode !== "multi") continue;
-			const state = await readQuotaGuardState(`${poolRuntimeDir(this.store.root, provider.id)}/quota-guard.json`);
-			events.push(...state.events.map((event) => ({
-				...event,
-				providerId: event.providerId ?? provider.id
-			})));
-		} catch {}
-		return events.toSorted((left, right) => right.createdAt.localeCompare(left.createdAt));
-	}
-	async stopPoolProxy(providerId) {
-		const provider = this.requireProxyProvider(providerId);
-		const primary = (await this.pools.getOrDefault(providerId)).members.find((m) => m.enabled)?.account;
-		const runtimeDir = poolRuntimeDir(this.store.root, providerId);
-		if (provider.stopProxy && primary) {
-			const config = await this.store.getProxyConfig(providerId, primary);
-			await provider.stopProxy({
-				providerId,
-				accountName: primary,
-				snapshotDir: accountSnapshotDir(this.store.root, providerId, primary),
-				runtimeDir,
-				config: {
-					...config,
-					enabled: false
-				}
-			});
-		}
-		this.releaseLease(providerId, void 0);
-	}
-	async poolProxyStatus(providerId) {
-		const provider = this.requireProxyProvider(providerId);
-		const pool = await this.pools.getOrDefault(providerId);
-		const primary = pool.members.find((m) => m.enabled)?.account;
-		if (!primary || pool.mode !== "multi") return {
-			enabled: pool.mode === "multi" && pool.enabled,
-			running: false,
-			detail: pool.mode === "single" ? "single-account mode" : "no enabled members"
-		};
-		const runtimeDir = poolRuntimeDir(this.store.root, providerId);
-		const config = await this.store.getProxyConfig(providerId, primary);
-		if (provider.proxyStatus) return provider.proxyStatus({
-			providerId,
-			accountName: primary,
-			snapshotDir: accountSnapshotDir(this.store.root, providerId, primary),
-			runtimeDir,
-			config: {
-				...config,
-				enabled: pool.enabled,
-				host: pool.host ?? config.host,
-				port: pool.port ?? config.port
-			}
-		});
-		return {
-			enabled: pool.enabled,
-			running: false
-		};
-	}
-	requireProxyProvider(providerId) {
-		const provider = this.registry.get(providerId);
-		if (!providerCanProxy(provider)) throw new AnyPickError(`Provider "${providerId}" does not support a compatibility proxy.`, "PROXY_UNSUPPORTED");
-		return provider;
-	}
-	async enableProxy(providerId, name, opts = {}) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = normalizeAccountName(name);
-		await this.store.requireAccount(providerId, accountName);
-		const existing = await this.store.getProxyConfig(providerId, accountName);
-		const port = await this.ports.resolve(provider, {
-			requested: opts.port,
-			existing: existing.port,
-			providerId,
-			accountName
-		});
-		const config = {
-			...existing,
-			enabled: true,
-			port,
-			host: opts.host ?? existing.host ?? "127.0.0.1",
-			options: opts.options != null ? {
-				...existing.options,
-				...opts.options
-			} : existing.options
-		};
-		assertLoopbackHost(config.host ?? "127.0.0.1");
-		await this.store.setProxyConfig(providerId, accountName, config);
-		let started;
-		const active = await this.store.getActive(providerId);
-		if (opts.start !== false && active === accountName) started = await this.startProxyInternal(provider, accountName, config);
-		this.syncCodexLiveConfig();
-		return {
-			config,
-			started
-		};
-	}
-	/** Restore a previously captured config without starting a process. Scoped
-	* ephemeral runs use this to avoid leaving an account auto-proxy enabled. */
-	async restoreProxyConfig(providerId, name, config) {
-		const accountName = normalizeAccountName(name);
-		await this.store.requireAccount(providerId, accountName);
-		await this.store.setProxyConfig(providerId, accountName, config);
-	}
-	/**
-	* Update proxy listen port/host without toggling enabled.
-	* Restarts the proxy if it is currently running.
-	*/
-	async configureProxy(providerId, name, opts = {}) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = normalizeAccountName(name);
-		await this.store.requireAccount(providerId, accountName);
-		if (opts.port == null && opts.host == null && opts.options == null) throw new AnyPickError("Pass --port and/or --host to configure the proxy.", "PROXY_CONFIG_EMPTY");
-		const existing = await this.store.getProxyConfig(providerId, accountName);
-		let port;
-		if (opts.port != null) {
-			port = validatePort(opts.port);
-			await this.ports.assertAvailable(port, providerId, accountName);
-		} else if (existing.port != null) port = existing.port;
-		else port = await this.ports.allocateFrom(provider.defaultProxyPort ?? 8080, providerId, accountName);
-		const config = {
-			...existing,
-			port,
-			host: opts.host ?? existing.host ?? "127.0.0.1",
-			options: opts.options != null ? {
-				...existing.options,
-				...opts.options
-			} : existing.options
-		};
-		assertLoopbackHost(config.host ?? "127.0.0.1");
-		await this.store.setProxyConfig(providerId, accountName, config);
-		const wasRunning = (await this.proxyStatus(providerId, accountName)).running;
-		let restarted;
-		if (wasRunning && opts.restart !== false) {
-			await this.stopProxyInternal(provider, accountName);
-			restarted = await this.startProxyInternal(provider, accountName, config);
-		}
-		this.syncCodexLiveConfig();
-		return {
-			config,
-			restarted,
-			wasRunning
-		};
-	}
-	async disableProxy(providerId, name) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = normalizeAccountName(name);
-		await this.store.requireAccount(providerId, accountName);
-		const config = {
-			...await this.store.getProxyConfig(providerId, accountName),
-			enabled: false
-		};
-		await this.store.setProxyConfig(providerId, accountName, config);
-		await this.stopProxyInternal(provider, accountName);
-		this.syncCodexLiveConfig();
-		return config;
-	}
-	async startProxy(providerId, name, opts = {}) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = name ? normalizeAccountName(name) : await this.requireActiveName(providerId);
-		const account = await this.store.requireAccount(providerId, accountName);
-		assertLoopbackHost(opts.host ?? account.proxy.host ?? "127.0.0.1");
-		if (!account.proxy.enabled) throw new AnyPickError(`Proxy is not enabled for ${providerId}/${accountName}. Run: anypick proxy enable ${providerId} ${accountName}`, "PROXY_DISABLED");
-		let config = account.proxy;
-		if (opts.port != null || opts.host != null) {
-			let port;
-			if (opts.port != null) {
-				port = validatePort(opts.port);
-				await this.ports.assertAvailable(port, providerId, accountName);
-			} else if (config.port != null) port = config.port;
-			else port = await this.ports.allocateFrom(provider.defaultProxyPort ?? 8080, providerId, accountName);
-			config = {
-				...config,
-				port,
-				host: opts.host ?? config.host ?? "127.0.0.1"
-			};
-			await this.store.setProxyConfig(providerId, accountName, config);
-		} else if (config.port == null) {
-			const port = await this.ports.resolve(provider, {
-				providerId,
-				accountName
-			});
-			config = {
-				...config,
-				port,
-				host: config.host ?? "127.0.0.1"
-			};
-			await this.store.setProxyConfig(providerId, accountName, config);
-		}
-		const handle = await this.startProxyInternal(provider, accountName, config);
-		this.syncCodexLiveConfig();
-		return handle;
-	}
-	async stopProxy(providerId, name) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = name ? normalizeAccountName(name) : await this.requireActiveName(providerId);
-		await this.store.requireAccount(providerId, accountName);
-		await this.stopProxyInternal(provider, accountName);
-		this.syncCodexLiveConfig();
-	}
-	async proxyStatus(providerId, name) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = name ? normalizeAccountName(name) : await this.requireActiveName(providerId);
-		const account = await this.store.requireAccount(providerId, accountName);
-		const ctx = this.buildProxyContext(providerId, accountName, account.proxy);
-		const host = account.proxy.host ?? "127.0.0.1";
-		const port = account.proxy.port ?? provider.defaultProxyPort ?? void 0;
-		let status;
-		if (provider.proxyStatus) status = await provider.proxyStatus(ctx);
-		else {
-			const pid = await readPidFile(this.store.pidPath(providerId, accountName));
-			const running = pid != null && isProcessRunning(pid);
-			const state = await this.store.readProxyState(providerId, accountName);
-			const logPath = this.store.logPath(providerId, accountName);
-			status = {
-				enabled: account.proxy.enabled,
-				running,
-				endpoint: running ? state?.endpoint : void 0,
-				compatibility: running ? state?.compatibility ?? provider.proxyCompatibility : provider.proxyCompatibility,
-				pid: running ? pid ?? void 0 : void 0,
-				logPath: await pathExists(logPath) ? logPath : void 0,
-				detail: running ? void 0 : account.proxy.enabled ? "stopped" : "disabled"
-			};
-		}
-		status.port = port;
-		status.host = host;
-		if (status.running && status.pid != null) {
-			const runtimeState = await this.store.readProxyState(providerId, accountName);
-			if (runtimeState?.pid === status.pid && runtimeState.endpoint) {
-				status.endpoint = runtimeState.endpoint;
-				status.port = portFromEndpoint(runtimeState.endpoint);
-				try {
-					status.host = new URL(runtimeState.endpoint).hostname;
-				} catch {}
-			}
-		}
-		if (!status.endpoint && status.running && port != null) status.endpoint = `http://${host}:${port}`;
-		return status;
-	}
-	async proxyLogs(providerId, name, lines = 50) {
-		const provider = this.requireProxyProvider(providerId);
-		const accountName = name ? normalizeAccountName(name) : await this.requireActiveName(providerId);
-		const account = await this.store.requireAccount(providerId, accountName);
-		const ctx = this.buildProxyContext(providerId, accountName, account.proxy);
-		if (provider.readProxyLogs) return provider.readProxyLogs(ctx, lines);
-		const logPath = this.store.logPath(providerId, accountName);
-		if (!await pathExists(logPath)) return "(no log file yet)";
-		const all = (await readFile(logPath, "utf8")).split(/\r?\n/);
-		return all.slice(Math.max(0, all.length - lines)).join("\n");
-	}
-	/**
-	* Stream proxy logs live (tail -f style). Calls `onLine` for each new line
-	* and resolves when `signal` aborts. Returns immediately if no log file yet.
-	*/
-	async proxyLogsFollow(providerId, name, onLine, opts = {}) {
-		const accountName = name ? normalizeAccountName(name) : await this.requireActiveName(providerId);
-		const logPath = this.store.logPath(providerId, accountName);
-		if (!await pathExists(logPath)) onLine("(waiting for log file…)");
-		if (opts.lines && await pathExists(logPath)) {
-			const all = (await readFile(logPath, "utf8")).split("\n").map((l) => l.replace(/\r$/, "")).filter(Boolean);
-			for (const l of all.slice(Math.max(0, all.length - opts.lines))) onLine(l);
-		}
-		const onAbort = () => {};
-		opts.signal?.addEventListener("abort", onAbort);
-		try {
-			await followFile(logPath, onLine, opts.signal);
-		} finally {
-			opts.signal?.removeEventListener("abort", onAbort);
-		}
-	}
-	/**
-	* List proxy-capable accounts (for `anypick proxy` / status).
-	* If provider omitted → all proxy providers. If name omitted → active or all enabled.
-	*/
-	async listProxyRows(providerId) {
-		const providers = providerId ? [this.requireProxyProvider(providerId)] : this.registry.list().filter((p) => providerCanProxy(p));
-		const rows = [];
-		for (const p of providers) {
-			const active = await this.store.getActive(p.id);
-			const accounts = await this.store.listAccounts(p.id);
-			for (const a of accounts) {
-				const status = await this.proxyStatus(p.id, a.meta.name).catch(() => ({
-					enabled: a.proxy.enabled,
-					running: false,
-					detail: "unavailable"
-				}));
-				if (a.meta.name === active || a.proxy.enabled || status.running) rows.push({
-					provider: p.id,
-					name: a.meta.name,
-					active: a.meta.name === active,
-					status
-				});
-			}
-		}
-		return rows;
-	}
-	/**
-	* Start proxies. No args → active account on each proxy provider (if enabled).
-	*/
-	async startProxies(providerId, name) {
-		const targets = await this.resolveProxyTargets(providerId, name, {
-			requireEnabled: true,
-			preferActive: !name
-		});
-		const out = [];
-		for (const t of targets) try {
-			const handle = await this.startProxy(t.provider, t.name);
-			out.push({
-				provider: t.provider,
-				name: t.name,
-				ok: true,
-				endpoint: handle.endpoint,
-				realignedClients: handle.realignedClients
-			});
-		} catch (err) {
-			out.push({
-				provider: t.provider,
-				name: t.name,
-				ok: false,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		}
-		return out;
-	}
-	async stopProxies(providerId, name) {
-		const targets = await this.resolveProxyTargets(providerId, name, {
-			requireEnabled: false,
-			preferActive: !name,
-			runningOnly: !name && !providerId
-		});
-		const out = [];
-		for (const t of targets) try {
-			await this.stopProxy(t.provider, t.name);
-			out.push({
-				provider: t.provider,
-				name: t.name,
-				ok: true
-			});
-		} catch (err) {
-			out.push({
-				provider: t.provider,
-				name: t.name,
-				ok: false,
-				error: err instanceof Error ? err.message : String(err)
-			});
-		}
-		return out;
-	}
-	/** Transfer all currently running proxy leases to a long-lived supervisor. */
-	async adoptRunningProxies(ownerPid = process.pid) {
-		let adopted = 0;
-		for (const row of await this.listProxyRows()) {
-			const { status } = row;
-			if (!status.running || status.pid == null || !status.endpoint) continue;
-			this.recordLease(row.provider, row.name, {
-				endpoint: status.endpoint,
-				compatibility: status.compatibility,
-				pid: status.pid,
-				logPath: status.logPath
-			}, ownerPid);
-			adopted += 1;
-		}
-		for (const provider of this.registry.list().filter((item) => providerCanProxy(item))) try {
-			const status = await this.poolProxyStatus(provider.id);
-			if (!status.running || status.pid == null || !status.endpoint) continue;
-			this.recordLease(provider.id, void 0, {
-				endpoint: status.endpoint,
-				compatibility: status.compatibility,
-				pid: status.pid,
-				logPath: status.logPath
-			}, ownerPid);
-			adopted += 1;
-		} catch {}
-		return adopted;
-	}
-	/** Stop a proxy during account lifecycle ops (switch/stash/delete). */
-	async stopProxyForAccount(provider, accountName) {
-		await this.stopProxyInternal(provider, accountName);
-		this.syncCodexLiveConfig();
-	}
-	/** Start a proxy as part of account switch (when enabled). */
-	async startProxyForAccount(provider, accountName, config) {
-		if (!providerCanProxy(provider) || !config.enabled) return { running: false };
-		try {
-			const handle = await this.startProxyInternal(provider, accountName, config);
-			this.syncCodexLiveConfig();
-			return {
-				endpoint: handle.endpoint,
-				running: true
-			};
-		} catch (err) {
-			return {
-				running: false,
-				error: err instanceof Error ? err.message : String(err)
-			};
-		}
-	}
-	async resolveProxyTargets(providerId, name, opts) {
-		if (providerId && name) {
-			this.requireProxyProvider(providerId);
-			await this.store.requireAccount(providerId, normalizeAccountName(name));
-			return [{
-				provider: providerId,
-				name: normalizeAccountName(name)
-			}];
-		}
-		if (providerId) {
-			const p = this.requireProxyProvider(providerId);
-			if (opts.preferActive) {
-				const active = await this.store.getActive(p.id);
-				if (active) {
-					const acc = await this.store.requireAccount(p.id, active);
-					if (!opts.requireEnabled || acc.proxy.enabled) return [{
-						provider: p.id,
-						name: active
-					}];
-				}
-			}
-			return (await this.store.listAccounts(p.id)).filter((a) => !opts.requireEnabled || a.proxy.enabled).map((a) => ({
-				provider: p.id,
-				name: a.meta.name
-			}));
-		}
-		const providers = this.registry.list().filter((p) => providerCanProxy(p));
-		const targets = [];
-		for (const p of providers) {
-			if (opts.runningOnly) {
-				const accounts = await this.store.listAccounts(p.id);
-				for (const account of accounts) if ((await this.proxyStatus(p.id, account.meta.name)).running) targets.push({
-					provider: p.id,
-					name: account.meta.name
-				});
-				continue;
-			}
-			const active = await this.store.getActive(p.id);
-			if (active) {
-				const acc = await this.store.getAccount(p.id, active);
-				if (!acc) continue;
-				if (!opts.requireEnabled || acc.proxy.enabled) targets.push({
-					provider: p.id,
-					name: active
-				});
-			}
-		}
-		return targets;
-	}
-	async requireActiveName(providerId) {
-		const active = await this.store.getActive(providerId);
-		if (!active) throw new AnyPickError(`No active account for "${providerId}". Pass an account name.`, "NO_ACTIVE_ACCOUNT");
-		return active;
-	}
-	buildProxyContext(providerId, accountName, config, token) {
-		return {
-			providerId,
-			accountName,
-			snapshotDir: accountSnapshotDir(this.store.root, providerId, accountName),
-			runtimeDir: this.store.runtimeDir(providerId, accountName),
-			config,
-			token
-		};
-	}
-	async startProxyInternal(provider, accountName, config) {
-		return withMutationLock(this.store.root, `proxy/${provider.id}/${accountName}`, () => this.startProxyInternalUnlocked(provider, accountName, config));
-	}
-	async startProxyInternalUnlocked(provider, accountName, config) {
-		if (!provider.startProxy) throw new AnyPickError(`Provider "${provider.id}" declares proxy support but does not implement startProxy().`, "PROXY_NOT_IMPLEMENTED");
-		let effective = withoutPoolOptions(config);
-		const host = effective.host ?? "127.0.0.1";
-		assertLoopbackHost(host);
-		let port = effective.port ?? provider.defaultProxyPort ?? 8080;
-		const existingPid = await readPidFile(this.store.pidPath(provider.id, accountName));
-		const previousState = await this.store.readProxyState(provider.id, accountName);
-		const proxyToken = previousState?.token && previousState.token.length > 0 ? previousState.token : randomBytes(32).toString("hex");
-		if (existingPid != null && isProcessRunning(existingPid) && port !== 0) {
-			const candidates = [previousState?.endpoint, `http://${host}:${port}`].filter((value, index, all) => Boolean(value) && all.indexOf(value) === index);
-			for (const candidate of candidates) try {
-				const { waitForHttp } = await import("../utils/process.js");
-				if (!await waitForHttp(candidate, {
-					timeoutMs: 800,
-					requirePid: existingPid
-				})) continue;
-				const actual = new URL(candidate);
-				const actualHost = actual.hostname === "::1" ? "[::1]" : actual.hostname;
-				const actualPort = Number(actual.port);
-				if (actualPort > 0 && (actualPort !== port || actualHost !== host)) {
-					port = actualPort;
-					effective = {
-						...effective,
-						port,
-						host: actualHost
-					};
-					await this.store.setProxyConfig(provider.id, accountName, effective);
-				}
-				const handle = {
-					endpoint: candidate,
-					compatibility: provider.proxyCompatibility,
-					pid: existingPid,
-					logPath: this.store.logPath(provider.id, accountName),
-					startedNow: false,
-					token: proxyToken
-				};
-				await this.store.writeProxyState(provider.id, accountName, {
-					accountName,
-					endpoint: handle.endpoint,
-					compatibility: handle.compatibility,
-					pid: handle.pid,
-					logPath: handle.logPath,
-					startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-					token: proxyToken
-				});
-				handle.realignedClients = await this.realignBoundClients(provider.id, accountName, handle.endpoint, proxyToken);
-				this.recordLease(provider.id, accountName, handle);
-				return handle;
-			} catch {}
-			await this.stopProxyInternalUnlocked(provider, accountName);
-		} else if (existingPid != null) await this.stopProxyInternalUnlocked(provider, accountName);
-		if (port !== 0 && !await isListenPortFree(port, host)) {
-			const next = await this.ports.allocateFrom(port + 1, provider.id, accountName);
-			effective = {
-				...effective,
-				port: next,
-				host
-			};
-			await this.store.setProxyConfig(provider.id, accountName, effective);
-			port = next;
-		} else if (effective.port == null) {
-			effective = {
-				...effective,
-				port,
-				host
-			};
-			await this.store.setProxyConfig(provider.id, accountName, effective);
-		}
-		const ctx = this.buildProxyContext(provider.id, accountName, effective, proxyToken);
-		const handle = await provider.startProxy(ctx);
-		if (handle.pid != null && !isProcessRunning(handle.pid)) {
-			if (port !== 0) {
-				const next = await this.ports.allocateFrom(port + 1, provider.id, accountName);
-				effective = {
-					...effective,
-					port: next,
-					host
-				};
-				await this.store.setProxyConfig(provider.id, accountName, effective);
-				const retry = await provider.startProxy(this.buildProxyContext(provider.id, accountName, effective, proxyToken));
-				if (retry.pid != null && isProcessRunning(retry.pid)) {
-					await this.store.writeProxyState(provider.id, accountName, {
-						accountName,
-						endpoint: retry.endpoint,
-						compatibility: retry.compatibility ?? provider.proxyCompatibility,
-						pid: retry.pid,
-						logPath: retry.logPath ?? this.store.logPath(provider.id, accountName),
-						startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-						token: proxyToken
-					});
-					retry.startedNow = true;
-					retry.token = proxyToken;
-					this.recordLease(provider.id, accountName, retry);
-					retry.realignedClients = await this.realignBoundClients(provider.id, accountName, retry.endpoint, proxyToken);
-					return retry;
-				}
-			}
-			throw new AnyPickError(`Proxy for ${provider.id}/${accountName} failed to bind (tried port ${port}). Check: anypick proxy logs ${provider.id} ${accountName}`, "PROXY_START_FAILED");
-		}
-		await this.store.writeProxyState(provider.id, accountName, {
-			accountName,
-			endpoint: handle.endpoint,
-			compatibility: handle.compatibility ?? provider.proxyCompatibility,
-			pid: handle.pid,
-			logPath: handle.logPath ?? this.store.logPath(provider.id, accountName),
-			startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			token: proxyToken
-		});
-		handle.startedNow = true;
-		this.recordLease(provider.id, accountName, handle);
-		handle.realignedClients = await this.realignBoundClients(provider.id, accountName, handle.endpoint, proxyToken);
-		return handle;
-	}
-	/** Rewrite bound clients' BASE_URL to the live proxy endpoint. */
-	async realignBoundClients(providerId, accountName, endpoint, token) {
-		if (!this.realign) return [];
-		try {
-			return await realignClientsToAccountProxy(this.realign, providerId, accountName, endpoint, token);
-		} catch {
-			return [];
-		}
-	}
-	async stopProxyInternal(provider, accountName) {
-		return withMutationLock(this.store.root, `proxy/${provider.id}/${accountName}`, () => this.stopProxyInternalUnlocked(provider, accountName));
-	}
-	async stopProxyInternalUnlocked(provider, accountName) {
-		const config = await this.store.getProxyConfig(provider.id, accountName);
-		const ctx = this.buildProxyContext(provider.id, accountName, config);
-		const before = await readPidRecord(this.store.pidPath(provider.id, accountName));
-		if (provider.stopProxy) await provider.stopProxy(ctx);
-		else {
-			const { stopPidFile } = await import("../utils/process.js");
-			await stopPidFile(this.store.pidPath(provider.id, accountName));
-		}
-		if (before && isProcessRunning(before.pid)) {
-			const status = provider.proxyStatus ? await provider.proxyStatus(ctx) : void 0;
-			if (!status || status.running) throw new AnyPickError(`Could not verify that the ${provider.name} proxy stopped (pid ${before.pid}).`, {
-				code: "PROXY_STOP_UNVERIFIED",
-				suggestions: ["Run anypick doctor to inspect the proxy record before retrying."]
-			});
-		}
-		await this.store.clearProxyState(provider.id, accountName);
-		this.releaseLease(provider.id, accountName);
-	}
-};
-//#endregion
-export { ProxyService };
-
-//# sourceMappingURL=proxy-service.js.map