anypick 1.0.0

package/dist/core/proxy-service.js

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