@maxiaochao/pi-toolkit 0.11.8 → 0.11.10

package/packages/openai-account-pool/src/availability.ts

@@ -1,230 +0,0 @@
-import type { PoolAccount } from "./auth.ts";
-import { ACCOUNT_SCOPE, type AccountAvailability, type Classification } from "./policy.ts";
-import {
-	readPoolState,
-	withPoolStateTransaction,
-	type AccountCooldown,
-	type AccountStateRecord,
-	type AccountUsage,
-	type PoolStateFile,
-} from "./store.ts";
-
-/**
- * Shared availability state. Every pi process using the same agent directory reads the same
- * cooldowns, so a limit one process hit is skipped by the next request anywhere.
- *
- * Two ordering rules keep concurrent requests honest: evidence recorded for an older account
- * generation is ignored after a re-authorization, and a success only clears evidence that was
- * recorded before that request started.
- */
-
-/** Local backoff when the server stated no reset time. Not a claimed quota reset. */
-export const DEFAULT_PROBE_BACKOFF_MS = 60_000;
-export const DEFAULT_PROBE_LEASE_MS = 30_000;
-
-function emptyRecord(): AccountStateRecord {
-	return { cooldowns: {} };
-}
-
-function cooldownEndMs(cooldown: AccountCooldown): number {
-	return Math.max(cooldown.serverResetAtMs ?? 0, cooldown.probeAfterMs ?? 0);
-}
-
-/** Cooldowns that still describe this account: same generation, and in scope for this request. */
-function relevantCooldowns(record: AccountStateRecord | undefined, account: PoolAccount, modelId?: string): AccountCooldown[] {
-	const scopes = modelId ? [ACCOUNT_SCOPE, `model:${modelId}`] : [ACCOUNT_SCOPE];
-	return scopes
-		.map((scope) => record?.cooldowns?.[scope])
-		.filter((cooldown): cooldown is AccountCooldown => !!cooldown && cooldown.generation === account.generation);
-}
-
-export function availabilityFor(input: {
-	accounts: readonly PoolAccount[];
-	state: PoolStateFile;
-	now: number;
-	modelId?: string;
-	/** This process's probe owner id, so its own lease does not block it. */
-	probeOwner?: string;
-}): AccountAvailability[] {
-	return input.accounts.map((account) => {
-		const record = input.state.accounts[account.id];
-		const authInvalid = record?.authInvalidGeneration === account.generation;
-		const cooldowns = relevantCooldowns(record, account, input.modelId);
-		const active = cooldowns.filter((cooldown) => cooldownEndMs(cooldown) > input.now);
-		if (active.length > 0) {
-			const blocking = active.reduce((latest, cooldown) => (cooldownEndMs(cooldown) > cooldownEndMs(latest) ? cooldown : latest));
-			return {
-				id: account.id,
-				ordinal: account.ordinal,
-				authInvalid,
-				needsProbe: false,
-				unavailable: { reason: blocking.reason, untilMs: cooldownEndMs(blocking), serverResetAtMs: blocking.serverResetAtMs },
-			};
-		}
-		const needsProbe = cooldowns.length > 0;
-		const lease = record?.probeLease;
-		if (lease && lease.untilMs > input.now && lease.owner !== input.probeOwner) {
-			// Another process is already testing whether this account recovered.
-			return {
-				id: account.id,
-				ordinal: account.ordinal,
-				authInvalid,
-				needsProbe: true,
-				unavailable: { reason: "probe_in_progress", untilMs: lease.untilMs, serverResetAtMs: null },
-			};
-		}
-		return { id: account.id, ordinal: account.ordinal, authInvalid, needsProbe };
-	});
-}
-
-export async function readAvailability(input: {
-	statePath: string;
-	accounts: readonly PoolAccount[];
-	now: number;
-	modelId?: string;
-	probeOwner?: string;
-}): Promise<AccountAvailability[]> {
-	return availabilityFor({ ...input, state: await readPoolState(input.statePath) });
-}
-
-/** Availability and the manual preference from one read, so a request sees one consistent state. */
-export async function readSelectionState(input: {
-	statePath: string;
-	accounts: readonly PoolAccount[];
-	now: number;
-	modelId?: string;
-	probeOwner?: string;
-}): Promise<{ availability: AccountAvailability[]; preferredAccountId?: string }> {
-	const state = await readPoolState(input.statePath);
-	return { availability: availabilityFor({ ...input, state }), preferredAccountId: state.preferredAccountId };
-}
-
-export async function readPreferredAccountId(statePath: string): Promise<string | undefined> {
-	return (await readPoolState(statePath)).preferredAccountId;
-}
-
-/** Pins the account every process starts from, or clears the pin when given `undefined`. */
-export async function setPreferredAccountId(input: { statePath: string; accountId: string | undefined }): Promise<void> {
-	await withPoolStateTransaction(input.statePath, (state) => {
-		if (state.preferredAccountId === input.accountId) return { result: undefined };
-		const next = { ...state };
-		if (input.accountId === undefined) delete next.preferredAccountId;
-		else next.preferredAccountId = input.accountId;
-		return { value: next, result: undefined };
-	});
-}
-
-/**
- * Stores the quota a response reported. The newest observation wins, so a slow write cannot
- * replace a fresher reading with a stale one. No generation guard: quota belongs to the ChatGPT
- * account itself and survives re-authorization, unlike the credential.
- */
-export async function recordUsage(input: {
-	statePath: string;
-	account: PoolAccount;
-	usage: AccountUsage;
-	/** An available live observation disproves only quota evidence no newer than itself. */
-	clearQuotaCooldowns?: boolean;
-}): Promise<boolean> {
-	return withPoolStateTransaction(input.statePath, (state) => {
-		const existing = state.accounts[input.account.id];
-		if ((existing?.usage?.observedAtMs ?? 0) >= input.usage.observedAtMs) return { result: false };
-		const record: AccountStateRecord = { ...(existing ?? emptyRecord()), usage: input.usage };
-		if (input.clearQuotaCooldowns) {
-			record.cooldowns = Object.fromEntries(
-				Object.entries(record.cooldowns ?? {}).filter(
-					([, cooldown]) =>
-						cooldown.generation !== input.account.generation || cooldown.recordedAtMs > input.usage.observedAtMs,
-				),
-			);
-		}
-		return { value: { ...state, accounts: { ...state.accounts, [input.account.id]: record } }, result: true };
-	});
-}
-
-export async function recordFailure(input: {
-	statePath: string;
-	account: PoolAccount;
-	classification: Classification;
-	now: number;
-	probeBackoffMs?: number;
-}): Promise<void> {
-	const { classification, account, now } = input;
-	if (classification.kind !== "quota" && classification.kind !== "auth_invalid") return;
-	await withPoolStateTransaction(input.statePath, (state) => {
-		const record: AccountStateRecord = { ...(state.accounts[account.id] ?? emptyRecord()) };
-		record.cooldowns = { ...record.cooldowns };
-		if (classification.kind === "auth_invalid") {
-			record.authInvalidGeneration = account.generation;
-			record.authInvalidAtMs = now;
-		} else {
-			const existing = record.cooldowns[classification.scope];
-			// Evidence from an older generation must not outrank a newer login.
-			if (existing && existing.generation > account.generation) return { result: undefined };
-			record.cooldowns[classification.scope] = {
-				reason: classification.reason,
-				generation: account.generation,
-				serverResetAtMs: classification.serverResetAtMs,
-				// Without a server reset time, only a short local backoff before probing again.
-				probeAfterMs: classification.serverResetAtMs === null ? now + (input.probeBackoffMs ?? DEFAULT_PROBE_BACKOFF_MS) : null,
-				recordedAtMs: now,
-			};
-		}
-		delete record.probeLease;
-		return { value: { ...state, accounts: { ...state.accounts, [account.id]: record } }, result: undefined };
-	});
-}
-
-/** Clear only the evidence that predates this request, so a slow success cannot undo a new limit. */
-export async function recordSuccess(input: {
-	statePath: string;
-	account: PoolAccount;
-	requestStartedAtMs: number;
-	clearEvidence?: boolean;
-}): Promise<void> {
-	await withPoolStateTransaction(input.statePath, (state) => {
-		const record = state.accounts[input.account.id];
-		if (!record || input.clearEvidence === false) {
-			return { value: { ...state, currentAccountId: input.account.id }, result: undefined };
-		}
-		const cooldowns: Record<string, AccountCooldown> = {};
-		for (const [scope, cooldown] of Object.entries(record.cooldowns ?? {})) {
-			const stale = cooldown.generation !== input.account.generation;
-			if (!stale && cooldown.recordedAtMs > input.requestStartedAtMs) cooldowns[scope] = cooldown;
-		}
-		// Usage is an observation, not evidence of failure, so success does not invalidate it.
-		const next: AccountStateRecord = { cooldowns, ...(record.usage ? { usage: record.usage } : {}) };
-		if (record.authInvalidGeneration === input.account.generation && (record.authInvalidAtMs ?? 0) > input.requestStartedAtMs) {
-			next.authInvalidGeneration = record.authInvalidGeneration;
-			next.authInvalidAtMs = record.authInvalidAtMs;
-		}
-		return { value: { ...state, currentAccountId: input.account.id, accounts: { ...state.accounts, [input.account.id]: next } }, result: undefined };
-	});
-}
-
-/** Bounded lease so a recovered account is probed by one process, not by all of them. */
-export async function claimProbeLease(input: {
-	statePath: string;
-	accountId: string;
-	owner: string;
-	now: number;
-	ttlMs?: number;
-}): Promise<boolean> {
-	return withPoolStateTransaction(input.statePath, (state) => {
-		const record: AccountStateRecord = { ...(state.accounts[input.accountId] ?? emptyRecord()) };
-		const lease = record.probeLease;
-		if (lease && lease.untilMs > input.now && lease.owner !== input.owner) return { result: false };
-		record.probeLease = { owner: input.owner, untilMs: input.now + (input.ttlMs ?? DEFAULT_PROBE_LEASE_MS) };
-		return { value: { ...state, accounts: { ...state.accounts, [input.accountId]: record } }, result: true };
-	});
-}
-
-export async function releaseProbeLease(input: { statePath: string; accountId: string; owner: string }): Promise<void> {
-	await withPoolStateTransaction(input.statePath, (state) => {
-		const record = state.accounts[input.accountId];
-		if (record?.probeLease?.owner !== input.owner) return { result: undefined };
-		const next = { ...record };
-		delete next.probeLease;
-		return { value: { ...state, accounts: { ...state.accounts, [input.accountId]: next } }, result: undefined };
-	});
-}

package/packages/openai-account-pool/src/command-completions.ts

@@ -1,18 +0,0 @@
-export const CODEX_POOL_SUBCOMMANDS = ["status", "use", "remove", "off"] as const;
-
-export interface CommandCompletion {
-	value: string;
-	label: string;
-}
-
-/**
- * Pi consumes Enter to accept an argument completion. Once a subcommand is exact,
- * hide its identical candidate so Enter submits the slash command immediately.
- */
-export function codexPoolArgumentCompletions(prefix: string): CommandCompletion[] {
-	const normalized = prefix.trim();
-	if (normalized.includes(" ") || CODEX_POOL_SUBCOMMANDS.some((name) => name === normalized)) return [];
-	return CODEX_POOL_SUBCOMMANDS
-		.filter((name) => name.startsWith(normalized))
-		.map((name) => ({ value: name, label: name }));
-}

package/packages/openai-account-pool/src/enrollment.ts

@@ -1,339 +0,0 @@
-import {
-	accountLabel,
-	commitAccount,
-	disablePool,
-	loadPoolSnapshot,
-	maskAccountId,
-	removeAccount,
-	type PoolAccount,
-	type PoolSnapshot,
-} from "./auth.ts";
-import { availabilityFor, setPreferredAccountId } from "./availability.ts";
-import { withEnrollmentLease } from "./lease.ts";
-import { emptyPoolState, readPoolState, withPoolStateTransaction, type AuthEntry, type PoolStateFile } from "./store.ts";
-import { describeSoonestReady, describeUsage, refreshPoolUsage, storedUsage, usageAvailable } from "./usage.ts";
-
-/**
- * `/codex_pool`: ask, log in once, save, ask again. Everything here is UI-agnostic so the TUI,
- * RPC and tests drive the same loop. Each successful login is saved immediately, so ending the
- * loop, pressing escape or closing pi never loses an account that was already added.
- */
-
-export type EnrollmentChoice = "continue" | "remove" | "end";
-
-export interface EnrollmentView {
-	/** Accounts already in the pool before this iteration. */
-	savedAccounts: number;
-	/** Those accounts by label, so the user can see which ones are already in. */
-	savedLabels: string[];
-	/** An existing plain login that the first add will keep as a pool account. */
-	nativeLoginPending: boolean;
-	addedThisRun: number;
-	/** Non-secret sentence about what the previous iteration did. */
-	lastOutcome?: string;
-}
-
-/** The prompt the user reads before every add. Shared by the TUI, RPC and media. */
-export function confirmText(view: EnrollmentView): string {
-	const lines: string[] = [];
-	if (view.lastOutcome) lines.push(view.lastOutcome);
-	if (view.savedLabels.length === 0) lines.push("账号池里还没有账号。");
-	else lines.push(`已保存 ${view.savedAccounts} 个账号：${view.savedLabels.join("、")}。`);
-	if (view.nativeLoginPending) lines.push("原有 openai-codex 登录会在第一次添加时保留并入池。");
-	if (view.savedAccounts === 1) lines.push("再添加一个账号才有备用额度。");
-	if (view.savedAccounts > 0) lines.push("重复登录已有的账号只会更新它的凭据，不会多出一个。");
-	return lines.join("\n");
-}
-
-export interface EnrollmentUi {
-	/** Shows the state and asks what to do next. */
-	confirm(view: EnrollmentView): Promise<EnrollmentChoice>;
-	/** Runs exactly one native OAuth login. Rejects when the user cancels. */
-	login(): Promise<AuthEntry>;
-	/** Picks the account to delete, or undefined when the user backs out. */
-	pickRemoval(accounts: readonly PoolAccount[]): Promise<PoolAccount | undefined>;
-	notify(message: string, kind?: "info" | "warning" | "error"): void;
-}
-
-export interface EnrollmentResult {
-	added: number;
-	updated: number;
-	removed: number;
-	/** Accounts in the pool when the loop ended. */
-	accounts: number;
-	cancelled: boolean;
-}
-
-/** Login failures can quote a raw token response, so only a short, scrubbed reason is shown. */
-export function redactMessage(error: unknown): string {
-	const raw = error instanceof Error ? error.message : String(error);
-	const scrubbed = raw
-		.replace(/https?:\/\/\S+/g, "<url>")
-		.replace(/[A-Za-z0-9._~+/=-]{24,}/g, "<redacted>")
-		.replace(/\s+/g, " ")
-		.trim();
-	return scrubbed.length > 160 ? `${scrubbed.slice(0, 160)}…` : scrubbed || "未知错误";
-}
-
-export function isCancellation(error: unknown): boolean {
-	if (error instanceof Error && error.name === "AbortError") return true;
-	const message = error instanceof Error ? error.message : String(error);
-	return /Login cancelled|cancelled|canceled|aborted/i.test(message);
-}
-
-function describeCommit(result: Awaited<ReturnType<typeof commitAccount>>): string {
-	const label = accountLabel(result.account);
-	const parts = [result.outcome === "added" ? `已添加账号 ${label}` : `${label} 是已在池里的账号，凭据已更新，没有新增`];
-	if (result.migratedExistingLogin) parts.push("原有登录已保留并入池");
-	if (result.readoptedAccounts > 0) parts.push(`恢复了 ${result.readoptedAccounts} 个此前保存的账号`);
-	parts.push(`当前共 ${result.accountCount} 个账号`);
-	return `${parts.join("，")}。`;
-}
-
-export async function runEnrollment(input: {
-	authPath: string;
-	statePath: string;
-	ui: EnrollmentUi;
-	signal?: AbortSignal;
-}): Promise<EnrollmentResult> {
-	// One wizard at a time per agent directory: two callback servers must never race.
-	return withEnrollmentLease({ statePath: input.statePath, purpose: "codex_pool", signal: input.signal }, async () => {
-		const result: EnrollmentResult = { added: 0, updated: 0, removed: 0, accounts: 0, cancelled: false };
-		let lastOutcome: string | undefined;
-
-		while (true) {
-			const snapshot = await loadPoolSnapshot(input.authPath);
-			const sorted = [...snapshot.accounts].sort((left, right) => left.ordinal - right.ordinal);
-			result.accounts = sorted.length;
-			const choice = await input.ui.confirm({
-				savedAccounts: sorted.length,
-				savedLabels: sorted.map((account) => accountLabel(account)),
-				nativeLoginPending: !snapshot.enabled && snapshot.nativeLoginPresent,
-				addedThisRun: result.added + result.updated,
-				lastOutcome,
-			});
-			if (choice === "end") break;
-
-			if (choice === "remove") {
-				lastOutcome = await removeThroughWizard({ ...input, accounts: sorted, result });
-				if (lastOutcome) input.ui.notify(lastOutcome);
-				continue;
-			}
-
-			let credential: AuthEntry;
-			try {
-				credential = await input.ui.login();
-			} catch (error) {
-				if (isCancellation(error)) {
-					result.cancelled = true;
-					break;
-				}
-				// A failed login never retries by itself; the next loop asks again.
-				lastOutcome = `上一次登录失败（${redactMessage(error)}），已保存的账号不受影响。`;
-				continue;
-			}
-
-			try {
-				const committed = await commitAccount({ authPath: input.authPath, credential, signal: input.signal });
-				if (committed.outcome === "added") result.added += 1;
-				else result.updated += 1;
-				result.accounts = committed.accountCount;
-				lastOutcome = describeCommit(committed);
-				input.ui.notify(lastOutcome);
-			} catch (error) {
-				lastOutcome = `上一次保存失败（${redactMessage(error)}），已保存的账号不受影响。`;
-			}
-		}
-
-		const finalSnapshot = await loadPoolSnapshot(input.authPath);
-		result.accounts = finalSnapshot.accounts.length;
-		return result;
-	});
-}
-
-/** Deleting from inside the wizard, so adding and dropping an account need one command. */
-async function removeThroughWizard(input: {
-	authPath: string;
-	statePath: string;
-	ui: EnrollmentUi;
-	accounts: readonly PoolAccount[];
-	result: EnrollmentResult;
-}): Promise<string | undefined> {
-	if (input.accounts.length === 0) return "账号池里没有可删除的账号。";
-	let chosen: PoolAccount | undefined;
-	try {
-		chosen = await input.ui.pickRemoval(input.accounts);
-	} catch (error) {
-		if (isCancellation(error)) return undefined;
-		throw error;
-	}
-	if (!chosen) return undefined;
-	try {
-		const removal = await removePoolAccount({ authPath: input.authPath, statePath: input.statePath, accountId: chosen.id });
-		input.result.removed += 1;
-		input.result.accounts = removal.remaining;
-		return removal.poolDisabled
-			? `已删除最后一个账号 ${accountLabel(chosen)}，账号池已关闭。`
-			: `已删除账号 ${accountLabel(chosen)}，还剩 ${removal.remaining} 个。`;
-	} catch (error) {
-		return `删除失败（${redactMessage(error)}），账号池没有变化。`;
-	}
-}
-
-export type AccountState = "ready" | "cooling" | "reauth" | "probing";
-
-export interface AccountStatusLine {
-	label: string;
-	state: AccountState;
-	detail: string;
-	isCurrent: boolean;
-}
-
-export interface PoolStatus {
-	enabled: boolean;
-	nativeLoginPresent: boolean;
-	accounts: AccountStatusLine[];
-	/** Short non-secret summary line for the user. */
-	summary: string;
-}
-
-/**
- * Pins the account every process starts from, or returns to automatic order with `undefined`.
- * Failover still applies: a pinned account that runs out of quota hands the request on.
- */
-export async function setDefaultAccount(input: { authPath: string; statePath: string; accountId: string | undefined }): Promise<PoolAccount | undefined> {
-	if (input.accountId === undefined) {
-		await setPreferredAccountId({ statePath: input.statePath, accountId: undefined });
-		return undefined;
-	}
-	const snapshot = await loadPoolSnapshot(input.authPath);
-	const account = snapshot.accounts.find((candidate) => candidate.id === input.accountId);
-	if (!account) throw new AccountQueryError("这个账号不在账号池里，无法设为默认。");
-	await setPreferredAccountId({ statePath: input.statePath, accountId: account.id });
-	return account;
-}
-
-export async function poolStatus(input: {
-	authPath: string;
-	statePath: string;
-	now?: number;
-	modelId?: string;
-	refresh?: (credential: AuthEntry, signal?: AbortSignal) => Promise<AuthEntry>;
-	fetch?: typeof globalThis.fetch;
-	signal?: AbortSignal;
-}): Promise<PoolStatus> {
-	const now = input.now ?? Date.now();
-	const snapshot = await loadPoolSnapshot(input.authPath);
-	if (!snapshot.enabled) {
-		return {
-			enabled: false,
-			nativeLoginPresent: snapshot.nativeLoginPresent,
-			accounts: [],
-			summary: snapshot.nativeLoginPresent
-				? "账号池未启用，当前使用原生单账号登录。运行 /codex_pool 添加账号即可启用。"
-				: "账号池未启用，且没有 openai-codex 登录。运行 /codex_pool 添加账号。",
-		};
-	}
-
-	const refreshed = input.refresh
-		? await refreshPoolUsage({
-				authPath: input.authPath,
-				statePath: input.statePath,
-				accounts: snapshot.accounts,
-				refresh: input.refresh,
-				now: () => now,
-				fetch: input.fetch,
-				signal: input.signal,
-			})
-		: [];
-	const refreshById = new Map(refreshed.map((result) => [result.account.id, result]));
-	const state = await readPoolState(input.statePath);
-	const availability = availabilityFor({
-		accounts: snapshot.accounts,
-		state,
-		now,
-		modelId: input.modelId,
-	});
-	const accounts = availability.map((entry, index): AccountStatusLine => {
-		const account = snapshot.accounts[index];
-		const label = accountLabel(account);
-		const isCurrent = account.id === state.currentAccountId;
-		const live = refreshById.get(account.id);
-		const usage = live?.usage ?? storedUsage(state.accounts[account.id]);
-		const usageText = live?.error ? "用量未知" : describeUsage(usage, now) ?? "用量未知";
-		if (entry.authInvalid) return { label, state: "reauth", detail: "需要重新授权，运行 /codex_pool 重新登录这个账号", isCurrent };
-		if (entry.unavailable?.reason === "probe_in_progress") return { label, state: "probing", detail: "另一个进程正在重试", isCurrent };
-		if (entry.unavailable || (usage && !usageAvailable(usage))) {
-			const reset = entry.unavailable?.serverResetAtMs;
-			return {
-				label,
-				state: "cooling",
-				detail: `${usageText}；${reset ? `额度冷却中，约 ${Math.max(1, Math.round((reset - now) / 60_000))} 分钟后恢复` : "额度暂不可用"}`,
-				isCurrent,
-			};
-		}
-		return { label, state: "ready", detail: `${usageText}；${entry.needsProbe ? "冷却已过，下次请求会先试这个账号" : "可用"}`, isCurrent };
-	});
-
-	const ready = accounts.filter((entry) => entry.state === "ready").length;
-	let summary =
-		accounts.length === 1
-			? "账号池已启用，但只有 1 个账号，暂无备用账号。运行 /codex_pool 继续添加。"
-			: `账号池已启用：${accounts.length} 个账号，其中 ${ready} 个现在可用。`;
-	if (ready === 0) {
-		const recovery = describeSoonestReady({ accounts: snapshot.accounts, state, now, modelId: input.modelId });
-		if (recovery) summary += ` ${recovery}。`;
-	}
-	return { enabled: true, nativeLoginPresent: false, accounts, summary };
-}
-
-export class AccountQueryError extends Error {}
-
-/** Accepts the ordinal, the sign-in address, a full account id or the masked suffix from status. */
-export function resolveAccount(snapshot: PoolSnapshot, query: string): PoolAccount {
-	const trimmed = query.trim().replace(/^[#…\s]+/, "");
-	if (!trimmed) throw new AccountQueryError("请提供要删除的账号编号、邮箱或标识，例如 /codex_pool remove 2。");
-	const byOrdinal = /^\d+$/.test(trimmed) ? snapshot.accounts.find((account) => account.ordinal === Number(trimmed)) : undefined;
-	if (byOrdinal) return byOrdinal;
-	const needle = trimmed.toLowerCase();
-	const byEmail = snapshot.accounts.filter((account) => account.email?.toLowerCase().includes(needle));
-	if (byEmail.length === 1) return byEmail[0];
-	if (byEmail.length > 1) throw new AccountQueryError(`“${trimmed}”匹配到 ${byEmail.length} 个账号，请用编号，例如 /codex_pool remove 2。`);
-	const matches = snapshot.accounts.filter((account) => account.id === trimmed || account.id.endsWith(trimmed));
-	if (matches.length === 1) return matches[0];
-	if (matches.length > 1) throw new AccountQueryError(`“${trimmed}”匹配到 ${matches.length} 个账号，请用编号，例如 /codex_pool remove 2。`);
-	throw new AccountQueryError(`没有找到账号“${trimmed}”。用 /codex_pool status 查看编号。`);
-}
-
-/** Forgets everything the pool recorded about accounts it no longer owns. */
-async function forgetState(statePath: string, accountIds: readonly string[] | "all"): Promise<void> {
-	await withPoolStateTransaction(statePath, (state) => {
-		if (accountIds === "all") return { value: { ...emptyPoolState(), enrollment: state.enrollment }, result: undefined };
-		const accounts = { ...state.accounts };
-		for (const accountId of accountIds) delete accounts[accountId];
-		const next: PoolStateFile = { ...state, accounts };
-		// References to an account that no longer exists would silently lie; drop them instead.
-		if (next.preferredAccountId && accountIds.includes(next.preferredAccountId)) delete next.preferredAccountId;
-		if (next.currentAccountId && accountIds.includes(next.currentAccountId)) delete next.currentAccountId;
-		return { value: next, result: undefined };
-	});
-}
-
-export async function endPool(input: { authPath: string; statePath: string; keepAccountId?: string }): Promise<{ kept: PoolAccount; dormantAccounts: number }> {
-	const snapshot = await loadPoolSnapshot(input.authPath);
-	if (!snapshot.enabled) throw new AccountQueryError("账号池未启用，无需关闭。");
-	const keep =
-		snapshot.accounts.find((account) => account.id === input.keepAccountId) ??
-		[...snapshot.accounts].sort((left, right) => left.ordinal - right.ordinal)[0];
-	const result = await disablePool({ authPath: input.authPath, accountId: keep.id });
-	await forgetState(input.statePath, "all");
-	return { kept: result.restored, dormantAccounts: result.dormantAccounts };
-}
-
-export async function removePoolAccount(input: { authPath: string; statePath: string; accountId: string }): Promise<{ removed: PoolAccount; remaining: number; poolDisabled: boolean }> {
-	const result = await removeAccount({ authPath: input.authPath, accountId: input.accountId });
-	await forgetState(input.statePath, result.poolDisabled ? "all" : [input.accountId]);
-	return result;
-}
-
-export { maskAccountId };