anypick 1.0.0

package/dist/core/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/core/service.ts"],"names":[],"mappings":"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"}

package/dist/core/service.js

@@ -0,0 +1,643 @@
+import { AnyPickError, isAnyPickError } from "../utils/errors.js";
+import { displayLabelFromName, normalizeAccountName } from "../utils/slug.js";
+import { providerCanProxy } from "./capabilities.js";
+import { withMutationLocks } from "./mutation-lock.js";
+import { ProxyService } from "./proxy-service.js";
+import { providerScope } from "./refs.js";
+import { exportAccountEnvelope, importAccountEnvelope } from "./account-transfer.js";
+import { join } from "node:path";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+//#region src/core/service.ts
+/**
+* Account name used when a login must be saved but cannot be named from its own
+* identity — either the provider reports no identity, or the identity contains
+* no slug-safe characters.
+*/
+var FALLBACK_ACCOUNT_NAME = "stash";
+/**
+* High-level account operations: save, switch, stash, refresh, delete,
+* and account metadata listing. Proxy lifecycle, pools, and port allocation
+* live in the injected `ProxyService` (exposed as `app.proxy`); this service
+* delegates to it for the proxy side effects of switch/stash/delete.
+*
+* CLI commands call this for account CRUD, and `app.proxy` for proxy control.
+*/
+var AccountService = class {
+	store;
+	registry;
+	/** Proxy lifecycle collaborator (start/stop/pool/port). */
+	proxy;
+	/**
+	* Optional post-delete side effects (Proxy Hub source prune, pool member
+	* sync). Wired from app.ts after Hub exists — AccountService is constructed
+	* before Hub to avoid a cycle.
+	*/
+	afterDelete;
+	/**
+	* `proxy` stays optional for callers that only need account CRUD (several
+	* tests, and any embedder that never starts a proxy). When omitted a private
+	* one is built here — deliberately without a lease store, because a service
+	* that was never handed the app's lease table must not record leases into a
+	* table nobody reaps.
+	*/
+	constructor(store, registry, proxy) {
+		this.store = store;
+		this.registry = registry;
+		this.proxy = proxy ?? new ProxyService(store, registry);
+	}
+	setAfterDelete(fn) {
+		this.afterDelete = fn;
+	}
+	provider(id) {
+		return this.registry.get(id);
+	}
+	listProviders() {
+		return this.registry.list();
+	}
+	/** Currently active (live) account name for a provider, if any. */
+	async getActive(providerId) {
+		return this.store.getActive(providerId);
+	}
+	/** Load a saved account or return null if missing. */
+	async get(providerId, name) {
+		return this.store.getAccount(providerId, normalizeAccountName(name));
+	}
+	/** Saved local name for an upstream identity, if one is already known. */
+	async findNameByIdentity(providerId, identity) {
+		return this.findAccountNameByIdentity(providerId, identity);
+	}
+	/**
+	* Capture the real local login before a switch. The checkpoint is private to
+	* the current operation and must be cleaned by `discardLiveAuthCheckpoint`.
+	*/
+	async checkpointLiveAuth(providerId, opts = {}) {
+		const provider = this.registry.get(providerId);
+		const checkpointRoot = opts.durable ? join(this.store.root, "recovery", "live-auth") : tmpdir();
+		await mkdir(checkpointRoot, {
+			recursive: true,
+			mode: 448
+		});
+		const directory = await mkdtemp(join(checkpointRoot, "anypick-live-checkpoint-"));
+		try {
+			const activeAccount = await this.store.getActive(providerId);
+			const live = await provider.detectLive();
+			if (live.present) await provider.backup(directory);
+			return {
+				providerId,
+				activeAccount,
+				hadLiveAuth: live.present,
+				directory
+			};
+		} catch (err) {
+			await rm(directory, {
+				recursive: true,
+				force: true
+			});
+			throw err;
+		}
+	}
+	/** Restore a checkpoint, including the provider active pointer. */
+	async restoreLiveAuthCheckpoint(checkpoint) {
+		const provider = this.registry.get(checkpoint.providerId);
+		if (checkpoint.hadLiveAuth) await provider.restore(checkpoint.directory);
+		else if (provider.clearLive) await provider.clearLive();
+		else throw new AnyPickError(`Cannot restore an empty ${provider.name} login state safely.`, "SWITCH_ROLLBACK_UNAVAILABLE");
+		if (checkpoint.activeAccount) await this.store.setActive(checkpoint.providerId, checkpoint.activeAccount);
+		else await this.store.clearActive(checkpoint.providerId);
+	}
+	async discardLiveAuthCheckpoint(checkpoint) {
+		await rm(checkpoint.directory, {
+			recursive: true,
+			force: true
+		});
+	}
+	async list(providerId) {
+		const providers = providerId ? [this.registry.get(providerId)] : this.registry.list();
+		const out = [];
+		for (const p of providers) {
+			const active = await this.store.getActive(p.id);
+			const accounts = await this.store.listAccounts(p.id);
+			const live = await p.detectLive();
+			const materialMatches = await Promise.all(accounts.map((account) => computeLiveMatch(p, account, live)));
+			const matchedNames = accounts.filter((_, index) => materialMatches[index] === true).map((account) => account.meta.name);
+			let liveAccountName = (active && matchedNames.includes(active) ? active : matchedNames[0]) ?? null;
+			const liveIdentity = live.identity;
+			if (!liveAccountName && liveIdentity) {
+				const identityMatches = accounts.filter((account) => account.meta.credentialKind !== "proxy-only" && account.meta.identity && identitiesMatch(account.meta.identity, liveIdentity)).map((account) => account.meta.name);
+				liveAccountName = (active && identityMatches.includes(active) ? active : identityMatches[0]) ?? null;
+			}
+			if (!liveAccountName && active && live.present) {
+				const activeIndex = accounts.findIndex((account) => account.meta.name === active);
+				if (activeIndex >= 0 && materialMatches[activeIndex] === null) liveAccountName = active;
+			}
+			for (const [index, a] of accounts.entries()) {
+				const proxyStatus = providerCanProxy(p) && a.proxy.enabled ? await this.proxy.proxyStatus(p.id, a.meta.name) : null;
+				out.push({
+					name: a.meta.name,
+					provider: p.id,
+					identity: a.meta.identity,
+					label: a.meta.label,
+					active: active === a.meta.name,
+					updatedAt: a.meta.updatedAt,
+					createdAt: a.meta.createdAt,
+					proxyEnabled: a.proxy.enabled,
+					proxyRunning: proxyStatus?.running ?? false,
+					isLiveMatch: liveAccountName === a.meta.name,
+					liveMatchKnown: materialMatches[index] !== null
+				});
+			}
+		}
+		return out;
+	}
+	async current(providerId) {
+		const provider = this.registry.get(providerId);
+		const active = await this.store.getActive(providerId);
+		const live = await provider.detectLive();
+		const account = active ? await this.store.getAccount(providerId, active) : null;
+		const proxy = providerCanProxy(provider) && account ? await this.proxy.proxyStatus(providerId, account.meta.name) : null;
+		const liveMatch = account ? await computeLiveMatch(provider, account, live) : null;
+		let isLiveMatch = liveMatch === true || liveMatch === null && active !== null && live.present;
+		if (!isLiveMatch && account?.meta.credentialKind !== "proxy-only" && account?.meta.identity && live.identity && identitiesMatch(account.meta.identity, live.identity)) isLiveMatch = true;
+		return {
+			active,
+			live,
+			account,
+			proxy,
+			isLiveMatch,
+			liveMatchKnown: liveMatch !== null
+		};
+	}
+	/** Best-effort usage for the provider's currently live local login only. */
+	async liveUsage(providerId) {
+		const provider = this.registry.get(providerId);
+		return provider.liveUsage ? provider.liveUsage() : null;
+	}
+	/**
+	* Save current live auth as a named account.
+	* If the name already exists, overwrite the snapshot (refresh).
+	* Proxy config is preserved.
+	*/
+	async save(providerId, name, opts = {}) {
+		return withMutationLocks(this.store.root, [providerScope(providerId)], () => this.saveLocked(providerId, name, opts));
+	}
+	async saveLocked(providerId, name, opts) {
+		const provider = this.registry.get(providerId);
+		const requestedAccountName = normalizeAccountName(name);
+		let accountName = requestedAccountName;
+		if (opts.input && !provider.backupInput) throw new AnyPickError(`${provider.name} does not accept a ${opts.input.kind} credential.`, "UNSUPPORTED_CREDENTIAL_INPUT");
+		const live = opts.input ? { present: true } : opts.source && provider.detectLiveSource ? await provider.detectLiveSource(opts.source) : await provider.detectLive();
+		if (!live.present) throw new AnyPickError(`No live ${provider.name} login to save.`, {
+			code: "NO_LIVE_AUTH",
+			suggestions: [`Sign in with the official tool first, then re-run this command.`, `Or clear the live auth without saving it: anypick add account ${providerId} --new --no-backup`]
+		});
+		accountName = await this.resolveIdentityTarget(providerId, live.identity, accountName, opts.force === true);
+		const existing = await this.store.getAccount(providerId, accountName);
+		if (!opts.input && existing?.meta.credentialKind === "proxy-only") throw new AnyPickError(`${providerId}/${accountName} holds a credential you supplied, not a login on this machine.`, {
+			code: "CREDENTIAL_KIND_MISMATCH",
+			suggestions: [`Save the live login under a different name.`, `To replace the stored credential, re-run the command that created it.`]
+		});
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const prepared = await this.store.prepareSnapshot(providerId, accountName);
+		let meta;
+		try {
+			const fromProvider = opts.input && provider.backupInput ? await provider.backupInput(opts.input, prepared.snapshotDir) : opts.source && provider.backupSource ? await provider.backupSource(opts.source, prepared.snapshotDir) : await provider.backup(prepared.snapshotDir);
+			meta = {
+				name: accountName,
+				provider: providerId,
+				createdAt: existing?.meta.createdAt ?? now,
+				updatedAt: now,
+				label: opts.label ?? existing?.meta.label ?? fromProvider.label ?? (accountName === requestedAccountName ? displayLabelFromName(name, accountName) : void 0),
+				identity: fromProvider.identity ?? live.identity ?? existing?.meta.identity,
+				notes: opts.notes ?? existing?.meta.notes ?? fromProvider.notes,
+				credentialKind: fromProvider.credentialKind
+			};
+			await this.store.writeMeta(meta);
+		} catch (err) {
+			if (existing) await this.store.getAccount(providerId, accountName).catch(() => null);
+			else await rm(prepared.accountDir, {
+				recursive: true,
+				force: true
+			}).catch(() => {});
+			throw err;
+		}
+		if (!await this.store.getActive(providerId)) await this.store.setActive(providerId, accountName);
+		return meta;
+	}
+	/**
+	* Resolve the saved name for the auth material currently on disk.
+	*
+	* Existing identities always win so a refreshed token overwrites its saved
+	* snapshot instead of creating an alias such as "default". A new login gets
+	* a stable identity-derived name unless the caller supplied one.
+	*/
+	async resolveCurrentSaveName(providerId, requestedName) {
+		const provider = this.registry.get(providerId);
+		const live = await provider.detectLive();
+		if (!live.present) throw new AnyPickError(`No live ${provider.name} login to save.`, {
+			code: "NO_LIVE_AUTH",
+			suggestions: ["Sign in with the official tool first, then try again."]
+		});
+		if (live.identity) {
+			const existingName = await this.findAccountNameByIdentity(providerId, live.identity);
+			if (existingName) return existingName;
+		}
+		if (requestedName?.trim()) return normalizeAccountName(requestedName);
+		const active = await this.store.getActive(providerId);
+		if (active) {
+			const activeAccount = await this.store.getAccount(providerId, active);
+			if (activeAccount && (!live.identity || activeAccount.meta.identity && identitiesMatch(activeAccount.meta.identity, live.identity))) return active;
+		}
+		if (live.identity) return accountNameFromIdentity(live.identity);
+		throw new AnyPickError(`Name the ${provider.name} login before saving it.`, {
+			code: "MISSING_ACCOUNT_NAME",
+			suggestions: [`anypick add account ${providerId} --current --name <name>`]
+		});
+	}
+	/** Save current auth, reusing its existing account whenever possible. */
+	async saveCurrent(providerId, requestedName) {
+		const accountName = await this.resolveCurrentSaveName(providerId, requestedName);
+		return this.save(providerId, accountName, { force: true });
+	}
+	/**
+	* Switch live auth to a saved account.
+	* Stops the previous account's proxy, restores auth, starts the new proxy if enabled.
+	*/
+	async use(providerId, name, opts = {}) {
+		return withMutationLocks(this.store.root, [providerScope(providerId)], () => this.useLocked(providerId, name, opts));
+	}
+	async useLocked(providerId, name, opts) {
+		const provider = this.registry.get(providerId);
+		const accountName = normalizeAccountName(name);
+		const target = await this.store.requireAccount(providerId, accountName);
+		const previous = await this.store.getActive(providerId);
+		let refreshedPrevious = false;
+		let refreshedAccount;
+		if (target.meta.credentialKind !== "proxy-only") await provider.preflightRestore?.(target.snapshotDir);
+		const checkpoint = await this.checkpointLiveAuth(providerId);
+		let previousProxyWasRunning = false;
+		try {
+			if (previous && previous !== accountName && providerCanProxy(provider)) {
+				previousProxyWasRunning = (await this.proxy.proxyStatus(providerId, previous)).running;
+				await this.proxy.stopProxyForAccount(provider, previous);
+			}
+			if (!opts.noRefresh && previous && previous !== accountName) {
+				const live = await provider.detectLive();
+				const previousMeta = await this.store.getAccount(providerId, previous);
+				if (live.present && previousMeta?.meta.credentialKind !== "proxy-only") {
+					refreshedAccount = await this.saveLiveIntoExistingAccount(providerId, previous);
+					refreshedPrevious = refreshedAccount === previous;
+				}
+			}
+			if (target.meta.credentialKind !== "proxy-only") await provider.restore(target.snapshotDir);
+			await this.store.setActive(providerId, accountName);
+			let proxy;
+			if (!opts.noProxy && providerCanProxy(provider)) {
+				const result = await this.proxy.startProxyForAccount(provider, accountName, target.proxy);
+				if (result.error) throw new AnyPickError(`Could not start the ${provider.name} proxy: ${result.error}`, { code: "PROXY_START_FAILED" });
+				proxy = {
+					enabled: target.proxy.enabled,
+					running: result.running,
+					endpoint: result.endpoint,
+					compatibility: provider.proxyCompatibility
+				};
+			} else proxy = {
+				enabled: false,
+				running: false
+			};
+			return {
+				provider: providerId,
+				providerName: provider.name,
+				from: previous,
+				to: accountName,
+				refreshedPrevious,
+				refreshedAccount,
+				proxy
+			};
+		} catch (err) {
+			try {
+				await this.restoreLiveAuthCheckpoint(checkpoint);
+				if (previousProxyWasRunning && previous && providerCanProxy(provider)) {
+					const prior = await this.store.requireAccount(providerId, previous);
+					await this.proxy.startProxyForAccount(provider, previous, prior.proxy);
+				}
+			} catch (rollbackErr) {
+				throw new AnyPickError(`Account switch failed and rollback could not complete: ${rollbackErr instanceof Error ? rollbackErr.message : String(rollbackErr)}`, "SWITCH_ROLLBACK_FAILED");
+			}
+			throw err;
+		} finally {
+			await this.discardLiveAuthCheckpoint(checkpoint);
+		}
+	}
+	/**
+	* Stash live auth: auto-backup (prefer matching email), then remove local
+	* live files so the tool allows a new login — WITHOUT server-side logout/revoke.
+	*/
+	async stash(providerId, opts = {}) {
+		return withMutationLocks(this.store.root, [providerScope(providerId)], () => this.stashLocked(providerId, opts));
+	}
+	async stashLocked(providerId, opts) {
+		const provider = this.registry.get(providerId);
+		const clear = opts.source && provider.clearLiveSource ? () => provider.clearLiveSource(opts.source) : provider.clearLive ? () => provider.clearLive() : null;
+		if (!clear) throw new AnyPickError(`Provider "${providerId}" does not support stash (clear live auth).`, "STASH_UNSUPPORTED");
+		const live = opts.source && provider.detectLiveSource ? await provider.detectLiveSource(opts.source) : await provider.detectLive();
+		let backedUpTo = null;
+		let matchedByIdentity = false;
+		const previousIdentity = live.identity;
+		let skippedBackup = !live.present;
+		if (live.present && !opts.noBackup) {
+			const resolved = await this.resolveStashBackupTarget(providerId, live.identity, opts.as);
+			matchedByIdentity = resolved.matchedByIdentity;
+			try {
+				backedUpTo = (await this.save(providerId, resolved.name, {
+					force: true,
+					source: opts.source
+				})).name;
+			} catch (err) {
+				if (isAnyPickError(err) && err.code === "NO_LIVE_AUTH") skippedBackup = true;
+				else if (isAnyPickError(err) && err.code === "ACCOUNT_IDENTITY_EXISTS") throw err;
+				else throw new AnyPickError(`Could not back up the live ${provider.name} login before clearing it.`, {
+					code: "STASH_BACKUP_FAILED",
+					suggestions: [`Fix whatever is blocking the live login, then try again.`, `Or clear it without a backup (unsaved tokens will be lost): anypick add account ${providerId} --new --no-backup`]
+				});
+			}
+		}
+		if (providerCanProxy(provider)) {
+			const active = await this.store.getActive(providerId);
+			if (active) try {
+				await this.proxy.stopProxyForAccount(provider, active);
+			} catch {}
+		}
+		if (live.present) await clear();
+		return {
+			provider: providerId,
+			cleared: live.present,
+			backedUpTo,
+			previousIdentity,
+			matchedByIdentity,
+			skippedBackup
+		};
+	}
+	/**
+	* Pick account name for stash auto-backup, preferring same-email reuse.
+	*/
+	async resolveStashBackupTarget(providerId, liveIdentity, explicitAs) {
+		if (explicitAs) return {
+			name: normalizeAccountName(explicitAs),
+			matchedByIdentity: false
+		};
+		if (liveIdentity) {
+			const byIdentity = await this.findAccountNameByIdentity(providerId, liveIdentity);
+			if (byIdentity) return {
+				name: byIdentity,
+				matchedByIdentity: true
+			};
+		}
+		const active = await this.store.getActive(providerId);
+		if (active) {
+			const activeAccount = await this.store.getAccount(providerId, active);
+			if (!liveIdentity || !activeAccount?.meta.identity || identitiesMatch(activeAccount.meta.identity, liveIdentity)) return {
+				name: active,
+				matchedByIdentity: false
+			};
+		}
+		if (liveIdentity) return {
+			name: accountNameFromIdentity(liveIdentity),
+			matchedByIdentity: false
+		};
+		return {
+			name: FALLBACK_ACCOUNT_NAME,
+			matchedByIdentity: false
+		};
+	}
+	async findAccountNameByIdentity(providerId, identity) {
+		const accounts = await this.store.listAccounts(providerId);
+		for (const a of accounts) if (a.meta.identity && identitiesMatch(a.meta.identity, identity)) return a.meta.name;
+		return null;
+	}
+	/**
+	* Save live auth only into an already-saved account.
+	*
+	* Switching must never invent a new account or overwrite a stale active
+	* pointer with another identity. An unsaved login is blocked so the caller
+	* can explicitly name/save it before replacing the live auth file.
+	*/
+	async saveLiveIntoExistingAccount(providerId, fallbackActiveName) {
+		const provider = this.registry.get(providerId);
+		const live = await provider.detectLive();
+		if (!live.present) throw new AnyPickError(`No live ${provider.name} login to preserve.`, "NO_LIVE_AUTH");
+		let targetName = live.identity ? await this.findAccountNameByIdentity(providerId, live.identity) : null;
+		if (!targetName && !live.identity) {
+			const ordered = (await this.store.listAccounts(providerId)).toSorted((a, b) => {
+				if (a.meta.name === fallbackActiveName) return -1;
+				if (b.meta.name === fallbackActiveName) return 1;
+				return a.meta.name.localeCompare(b.meta.name);
+			});
+			for (const account of ordered) if (await computeLiveMatch(provider, account, live) === true) {
+				targetName = account.meta.name;
+				break;
+			}
+		}
+		if (!targetName) throw new AnyPickError(`The live ${provider.name} login${live.identity ? ` (${live.identity})` : ""} is not saved yet.`, {
+			code: "UNSAVED_LIVE_AUTH",
+			suggestions: [`Save it first: anypick add account ${providerId} --current${live.identity ? "" : " --name <name>"}`]
+		});
+		return (await this.save(providerId, targetName, { force: true })).name;
+	}
+	/** Resolve a duplicate identity to its existing local account after confirmation. */
+	async resolveIdentityTarget(providerId, identity, accountName, allowOverwrite) {
+		if (!identity?.trim()) return accountName;
+		const existingName = await this.findAccountNameByIdentity(providerId, identity);
+		if (existingName && existingName !== accountName) {
+			if (allowOverwrite) return existingName;
+			throw new AnyPickError(`Login ${identity} is already saved as ${providerId}/${existingName}.`, {
+				code: "ACCOUNT_IDENTITY_EXISTS",
+				suggestions: [`Use ${providerId}/${existingName} instead of saving a duplicate.`],
+				details: {
+					provider: providerId,
+					identity,
+					existingName
+				}
+			});
+		}
+		return accountName;
+	}
+	/**
+	* Refresh OAuth/OIDC tokens.
+	*
+	* - `refresh codex` → live auth (+ sync into active saved account if any)
+	* - `refresh codex lucy` → saved snapshot `lucy` (+ restore to live if active)
+	* - `refresh codex --all` → every saved account for a provider
+	*/
+	async refresh(providerId, name, opts = {}) {
+		return withMutationLocks(this.store.root, [providerScope(providerId)], () => this.refreshLocked(providerId, name, opts));
+	}
+	async refreshLocked(providerId, name, opts) {
+		const provider = this.registry.get(providerId);
+		if (!provider.refreshAuth) throw new AnyPickError(`Provider "${providerId}" does not support token refresh.`, "REFRESH_UNSUPPORTED");
+		const results = [];
+		if (opts.all) {
+			const accounts = await this.store.listAccounts(providerId);
+			for (const a of accounts) results.push(await this.refreshSavedAccount(provider, a.meta.name));
+			if (results.length === 0) throw new AnyPickError(`No saved accounts for ${providerId}.`, "REFRESH_EMPTY");
+			return results;
+		}
+		if (name) {
+			results.push(await this.refreshSavedAccount(provider, normalizeAccountName(name)));
+			return results;
+		}
+		results.push(await this.refreshLiveAuth(provider));
+		return results;
+	}
+	async refreshSavedAccount(provider, accountName) {
+		const target = `${provider.id}/${accountName}`;
+		try {
+			const account = await this.store.requireAccount(provider.id, accountName);
+			const from = await provider.refreshAuth(account.snapshotDir);
+			const meta = {
+				...account.meta,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				identity: from.identity ?? account.meta.identity
+			};
+			await this.store.writeMeta(meta);
+			if (await this.store.getActive(provider.id) === accountName) await provider.restore(account.snapshotDir);
+			return {
+				target,
+				identity: meta.identity,
+				ok: true
+			};
+		} catch (err) {
+			return {
+				target,
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	async refreshLiveAuth(provider) {
+		const target = `${provider.id}/live`;
+		try {
+			const live = await provider.detectLive();
+			if (!live.present) {
+				const active = await this.store.getActive(provider.id);
+				if (active) return this.refreshSavedAccount(provider, active);
+				return {
+					target,
+					ok: false,
+					error: "No live auth and no active account."
+				};
+			}
+			const dir = await mkdtemp(join(tmpdir(), "anypick-refresh-"));
+			try {
+				await provider.backup(dir);
+				const from = await provider.refreshAuth(dir);
+				await provider.restore(dir);
+				const active = await this.store.getActive(provider.id);
+				let syncError;
+				if (active) try {
+					await this.saveLiveIntoExistingAccount(provider.id, active);
+				} catch (err) {
+					syncError = err instanceof Error ? err.message : String(err);
+				}
+				return {
+					target,
+					identity: from.identity ?? live.identity,
+					ok: !syncError,
+					...syncError ? { error: `Live auth refreshed, but saved account sync failed: ${syncError}` } : {}
+				};
+			} finally {
+				await rm(dir, {
+					recursive: true,
+					force: true
+				});
+			}
+		} catch (err) {
+			return {
+				target,
+				ok: false,
+				error: err instanceof Error ? err.message : String(err)
+			};
+		}
+	}
+	/** Update display metadata without touching the credential snapshot bytes. */
+	async edit(providerId, name, opts) {
+		const accountName = normalizeAccountName(name);
+		return withMutationLocks(this.store.root, [providerScope(providerId)], async () => {
+			const account = await this.store.requireAccount(providerId, accountName);
+			const label = opts.label === null ? void 0 : opts.label?.trim() || account.meta.label;
+			const meta = {
+				...account.meta,
+				label,
+				updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			await this.store.writeMeta(meta);
+			return meta;
+		});
+	}
+	async delete(providerId, name) {
+		const provider = this.registry.get(providerId);
+		const accountName = normalizeAccountName(name);
+		await withMutationLocks(this.store.root, [providerScope(providerId)], async () => {
+			if (providerCanProxy(provider)) await this.proxy.stopProxyForAccount(provider, accountName);
+			await this.store.deleteAccount(providerId, accountName);
+		});
+		try {
+			await this.afterDelete?.(providerId, accountName);
+		} catch {}
+	}
+	async exportAccount(providerId, name, outPath) {
+		await exportAccountEnvelope(this.store, providerId, name, outPath);
+	}
+	async importAccount(providerId, name, inPath, opts = {}) {
+		return withMutationLocks(this.store.root, [providerScope(providerId)], async () => {
+			const provider = this.registry.get(providerId);
+			return importAccountEnvelope({
+				store: this.store,
+				provider,
+				resolveIdentityTarget: (pid, identity, accountName, force) => this.resolveIdentityTarget(pid, identity, accountName, force)
+			}, providerId, name, inPath, opts);
+		});
+	}
+};
+function identitiesMatch(a, b) {
+	return a.trim().toLowerCase() === b.trim().toLowerCase();
+}
+/**
+* Whether a saved snapshot's auth material matches the current live login.
+* Capsule: delegates to the provider (which owns the fingerprint logic) and
+* falls back to identity equality when the provider does not implement it.
+*/
+async function computeLiveMatch(provider, account, knownLive) {
+	if (account.meta.credentialKind === "proxy-only") return false;
+	const { snapshotDir } = account;
+	if (typeof provider.snapshotMatchesLive === "function") try {
+		return await provider.snapshotMatchesLive(snapshotDir);
+	} catch (err) {
+		if (isAnyPickError(err) && err.code === "NOT_DETERMINABLE") return null;
+	}
+	const live = knownLive ?? await provider.detectLive();
+	if (!live.identity) return false;
+	const described = provider.describeSnapshot ? await provider.describeSnapshot(snapshotDir) : {};
+	return described.identity != null && identitiesMatch(described.identity, live.identity);
+}
+/**
+* Derive a stable account slug from an email / identity string.
+*
+* Falls back to the same generic name the caller uses when there is no identity
+* at all: an identity that slugifies to nothing (all punctuation, non-Latin
+* script) is not a failure the user can act on, and refusing here would block
+* saving a real login over a cosmetic naming problem. `--name` overrides it.
+*/
+function accountNameFromIdentity(identity) {
+	const trimmed = identity.trim();
+	const local = trimmed.includes("@") ? trimmed.split("@")[0] : trimmed;
+	try {
+		return normalizeAccountName(local);
+	} catch {
+		return FALLBACK_ACCOUNT_NAME;
+	}
+}
+//#endregion
+export { AccountService };
+
+//# sourceMappingURL=service.js.map