@imdeadpool/codex-account-switcher 0.1.5 → 0.1.7

package/dist/lib/accounts/account-service.js

@@ -9,64 +9,451 @@ const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
 const paths_1 = require("../config/paths");
 const errors_1 = require("./errors");
-const ACCOUNT_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const auth_parser_1 = require("./auth-parser");
+const registry_1 = require("./registry");
+const usage_1 = require("./usage");
+const service_manager_1 = require("./service-manager");
+const ACCOUNT_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9._@+-]*$/;
 class AccountService {
+    async syncExternalAuthSnapshotIfNeeded() {
+        const authPath = (0, paths_1.resolveAuthPath)();
+        if (!(await this.pathExists(authPath))) {
+            return {
+                synchronized: false,
+                autoSwitchDisabled: false,
+            };
+        }
+        await this.materializeAuthSymlink(authPath);
+        const incomingSnapshot = await (0, auth_parser_1.parseAuthSnapshotFile)(authPath);
+        if (incomingSnapshot.authMode !== "chatgpt") {
+            return {
+                synchronized: false,
+                autoSwitchDisabled: false,
+            };
+        }
+        const activeName = await this.getCurrentAccountName();
+        if (activeName) {
+            const activeSnapshotPath = this.accountFilePath(activeName);
+            if (await this.pathExists(activeSnapshotPath)) {
+                const activeSnapshot = await (0, auth_parser_1.parseAuthSnapshotFile)(activeSnapshotPath);
+                if (this.snapshotsShareIdentity(activeSnapshot, incomingSnapshot)) {
+                    return {
+                        synchronized: false,
+                        autoSwitchDisabled: false,
+                    };
+                }
+            }
+        }
+        const status = await this.getStatus();
+        const autoSwitchDisabled = status.autoSwitchEnabled;
+        if (autoSwitchDisabled) {
+            await this.setAutoSwitchEnabled(false);
+        }
+        const resolvedName = await this.resolveLoginAccountNameFromCurrentAuth();
+        const savedName = await this.saveAccount(resolvedName.name);
+        return {
+            synchronized: true,
+            savedName,
+            autoSwitchDisabled,
+        };
+    }
     async listAccountNames() {
-        if (!(await this.pathExists(paths_1.accountsDir))) {
+        const accountsDir = (0, paths_1.resolveAccountsDir)();
+        if (!(await this.pathExists(accountsDir))) {
             return [];
         }
-        const entries = await promises_1.default.readdir(paths_1.accountsDir, { withFileTypes: true });
+        const entries = await promises_1.default.readdir(accountsDir, { withFileTypes: true });
         return entries
-            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json") && entry.name !== "registry.json")
             .map((entry) => entry.name.replace(/\.json$/i, ""))
             .sort((a, b) => a.localeCompare(b, undefined, { sensitivity: "base" }));
     }
+    async listAccountChoices() {
+        const [accounts, current, registry] = await Promise.all([
+            this.listAccountNames(),
+            this.getCurrentAccountName(),
+            this.loadReconciledRegistry(),
+        ]);
+        return accounts.map((name) => {
+            var _a;
+            return ({
+                name,
+                email: (_a = registry.accounts[name]) === null || _a === void 0 ? void 0 : _a.email,
+                active: current === name,
+            });
+        });
+    }
+    async listAccountMappings() {
+        const [accounts, current, registry] = await Promise.all([
+            this.listAccountNames(),
+            this.getCurrentAccountName(),
+            this.loadReconciledRegistry(),
+        ]);
+        return Promise.all(accounts.map(async (name) => {
+            var _a, _b, _c, _d, _e;
+            const entry = registry.accounts[name];
+            let fallbackSnapshot;
+            if (!(entry === null || entry === void 0 ? void 0 : entry.email) || !(entry === null || entry === void 0 ? void 0 : entry.accountId) || !(entry === null || entry === void 0 ? void 0 : entry.userId) || !(entry === null || entry === void 0 ? void 0 : entry.planType)) {
+                fallbackSnapshot = await (0, auth_parser_1.parseAuthSnapshotFile)(this.accountFilePath(name));
+            }
+            return {
+                name,
+                active: current === name,
+                email: (_a = entry === null || entry === void 0 ? void 0 : entry.email) !== null && _a !== void 0 ? _a : fallbackSnapshot === null || fallbackSnapshot === void 0 ? void 0 : fallbackSnapshot.email,
+                accountId: (_b = entry === null || entry === void 0 ? void 0 : entry.accountId) !== null && _b !== void 0 ? _b : fallbackSnapshot === null || fallbackSnapshot === void 0 ? void 0 : fallbackSnapshot.accountId,
+                userId: (_c = entry === null || entry === void 0 ? void 0 : entry.userId) !== null && _c !== void 0 ? _c : fallbackSnapshot === null || fallbackSnapshot === void 0 ? void 0 : fallbackSnapshot.userId,
+                planType: (_d = entry === null || entry === void 0 ? void 0 : entry.planType) !== null && _d !== void 0 ? _d : fallbackSnapshot === null || fallbackSnapshot === void 0 ? void 0 : fallbackSnapshot.planType,
+                lastUsageAt: entry === null || entry === void 0 ? void 0 : entry.lastUsageAt,
+                usageSource: (_e = entry === null || entry === void 0 ? void 0 : entry.lastUsage) === null || _e === void 0 ? void 0 : _e.source,
+            };
+        }));
+    }
+    async findMatchingAccounts(query) {
+        const normalized = query.trim().toLowerCase();
+        if (!normalized)
+            return [];
+        const choices = await this.listAccountChoices();
+        const registry = await this.loadReconciledRegistry();
+        return choices.filter((choice) => {
+            var _a, _b;
+            if (choice.name.toLowerCase().includes(normalized))
+                return true;
+            if (choice.email && choice.email.toLowerCase().includes(normalized))
+                return true;
+            const meta = registry.accounts[choice.name];
+            if ((_a = meta === null || meta === void 0 ? void 0 : meta.accountId) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(normalized))
+                return true;
+            if ((_b = meta === null || meta === void 0 ? void 0 : meta.userId) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes(normalized))
+                return true;
+            return false;
+        });
+    }
     async getCurrentAccountName() {
-        const currentName = await this.readCurrentNameFile();
+        const currentNamePath = (0, paths_1.resolveCurrentNamePath)();
+        const currentName = await this.readCurrentNameFile(currentNamePath);
         if (currentName)
             return currentName;
-        if (!(await this.pathExists(paths_1.authPath)))
+        const authPath = (0, paths_1.resolveAuthPath)();
+        if (!(await this.pathExists(authPath)))
             return null;
-        const stat = await promises_1.default.lstat(paths_1.authPath);
+        const stat = await promises_1.default.lstat(authPath);
         if (!stat.isSymbolicLink())
             return null;
-        const rawTarget = await promises_1.default.readlink(paths_1.authPath);
-        const resolvedTarget = node_path_1.default.resolve(node_path_1.default.dirname(paths_1.authPath), rawTarget);
-        const accountsRoot = node_path_1.default.resolve(paths_1.accountsDir);
+        const rawTarget = await promises_1.default.readlink(authPath);
+        const resolvedTarget = node_path_1.default.resolve(node_path_1.default.dirname(authPath), rawTarget);
+        const accountsRoot = node_path_1.default.resolve((0, paths_1.resolveAccountsDir)());
         const relative = node_path_1.default.relative(accountsRoot, resolvedTarget);
         if (relative.startsWith(".."))
             return null;
         const base = node_path_1.default.basename(resolvedTarget);
+        if (!base.endsWith(".json") || base === "registry.json")
+            return null;
         return base.replace(/\.json$/i, "");
     }
-    async saveAccount(rawName) {
+    async saveAccount(rawName, options) {
         const name = this.normalizeAccountName(rawName);
-        await this.ensureAuthFileExists();
-        await this.ensureDir(paths_1.accountsDir);
+        const authPath = (0, paths_1.resolveAuthPath)();
+        const accountsDir = (0, paths_1.resolveAccountsDir)();
+        await this.ensureAuthFileExists(authPath);
+        await this.ensureDir(accountsDir);
         const destination = this.accountFilePath(name);
-        await promises_1.default.copyFile(paths_1.authPath, destination);
+        await this.assertSafeSnapshotOverwrite({
+            authPath,
+            destinationPath: destination,
+            accountName: name,
+            force: Boolean(options === null || options === void 0 ? void 0 : options.force),
+        });
+        await promises_1.default.copyFile(authPath, destination);
         await this.writeCurrentName(name);
+        const registry = await this.loadReconciledRegistry();
+        await this.hydrateSnapshotMetadata(registry, name);
+        registry.activeAccountName = name;
+        await this.persistRegistry(registry);
         return name;
     }
+    async inferAccountNameFromCurrentAuth() {
+        var _a;
+        const authPath = (0, paths_1.resolveAuthPath)();
+        await this.ensureAuthFileExists(authPath);
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(authPath);
+        const email = (_a = parsed.email) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+        if (!email || !email.includes("@")) {
+            throw new errors_1.AccountNameInferenceError();
+        }
+        const baseCandidate = this.normalizeAccountName(email);
+        const uniqueName = await this.resolveUniqueInferredName(baseCandidate, parsed);
+        return uniqueName;
+    }
+    async resolveDefaultAccountNameFromCurrentAuth() {
+        const authPath = (0, paths_1.resolveAuthPath)();
+        await this.ensureAuthFileExists(authPath);
+        const activeName = await this.getCurrentAccountName();
+        if (activeName) {
+            const activeSnapshotPath = this.accountFilePath(activeName);
+            if (await this.pathExists(activeSnapshotPath)) {
+                const [activeSnapshot, incomingSnapshot] = await Promise.all([
+                    (0, auth_parser_1.parseAuthSnapshotFile)(activeSnapshotPath),
+                    (0, auth_parser_1.parseAuthSnapshotFile)(authPath),
+                ]);
+                if (this.snapshotsShareIdentity(activeSnapshot, incomingSnapshot)) {
+                    return {
+                        name: activeName,
+                        source: "active",
+                    };
+                }
+            }
+        }
+        return {
+            name: await this.inferAccountNameFromCurrentAuth(),
+            source: "inferred",
+        };
+    }
+    async resolveLoginAccountNameFromCurrentAuth() {
+        return {
+            name: await this.inferAccountNameFromCurrentAuth(),
+            source: "inferred",
+        };
+    }
     async useAccount(rawName) {
         const name = this.normalizeAccountName(rawName);
-        const source = this.accountFilePath(name);
-        if (!(await this.pathExists(source))) {
-            throw new errors_1.AccountNotFoundError(name);
+        await this.activateSnapshot(name);
+        const registry = await this.loadReconciledRegistry();
+        await this.hydrateSnapshotMetadata(registry, name);
+        registry.activeAccountName = name;
+        await this.persistRegistry(registry);
+        return name;
+    }
+    async removeAccounts(accountNames) {
+        const uniqueNames = [...new Set(accountNames.map((name) => this.normalizeAccountName(name)))];
+        if (uniqueNames.length === 0) {
+            return { removed: [] };
         }
-        await this.ensureDir(paths_1.accountsDir);
-        await this.ensureDir(paths_1.codexDir);
-        if (process.platform === "win32") {
-            await promises_1.default.copyFile(source, paths_1.authPath);
+        const current = await this.getCurrentAccountName();
+        const registry = await this.loadReconciledRegistry();
+        const removed = [];
+        for (const name of uniqueNames) {
+            const snapshotPath = this.accountFilePath(name);
+            if (!(await this.pathExists(snapshotPath))) {
+                throw new errors_1.AccountNotFoundError(name);
+            }
+            await promises_1.default.rm(snapshotPath, { force: true });
+            delete registry.accounts[name];
+            removed.push(name);
+        }
+        const removedSet = new Set(removed);
+        let activated;
+        if (current && removedSet.has(current)) {
+            const remaining = (await this.listAccountNames()).filter((name) => !removedSet.has(name));
+            if (remaining.length > 0) {
+                const best = this.selectBestCandidateFromRegistry(remaining, registry);
+                await this.activateSnapshot(best);
+                activated = best;
+                registry.activeAccountName = best;
+            }
+            else {
+                await this.clearActivePointers();
+                delete registry.activeAccountName;
+            }
+        }
+        else if (registry.activeAccountName && removedSet.has(registry.activeAccountName)) {
+            delete registry.activeAccountName;
+        }
+        await this.persistRegistry(registry);
+        return {
+            removed,
+            activated,
+        };
+    }
+    async removeByQuery(query) {
+        const matches = await this.findMatchingAccounts(query);
+        if (matches.length === 0) {
+            throw new errors_1.AccountNotFoundError(query);
+        }
+        if (matches.length > 1) {
+            throw new errors_1.AmbiguousAccountQueryError(query);
+        }
+        return this.removeAccounts([matches[0].name]);
+    }
+    async removeAllAccounts() {
+        const all = await this.listAccountNames();
+        return this.removeAccounts(all);
+    }
+    async getStatus() {
+        const registry = await this.loadReconciledRegistry();
+        return {
+            autoSwitchEnabled: registry.autoSwitch.enabled,
+            serviceState: (0, service_manager_1.getManagedServiceState)(),
+            threshold5hPercent: registry.autoSwitch.threshold5hPercent,
+            thresholdWeeklyPercent: registry.autoSwitch.thresholdWeeklyPercent,
+            usageMode: registry.api.usage ? "api" : "local",
+        };
+    }
+    async setAutoSwitchEnabled(enabled) {
+        const registry = await this.loadReconciledRegistry();
+        registry.autoSwitch.enabled = enabled;
+        if (enabled) {
+            try {
+                await (0, service_manager_1.enableManagedService)();
+            }
+            catch (error) {
+                registry.autoSwitch.enabled = false;
+                await this.persistRegistry(registry);
+                throw new errors_1.AutoSwitchConfigError(`Failed to enable managed auto-switch service: ${error.message}`);
+            }
         }
         else {
-            await this.replaceSymlink(source, paths_1.authPath);
+            await (0, service_manager_1.disableManagedService)();
         }
-        await this.writeCurrentName(name);
-        return name;
+        await this.persistRegistry(registry);
+        return this.getStatus();
+    }
+    async setApiUsageEnabled(enabled) {
+        const registry = await this.loadReconciledRegistry();
+        registry.api.usage = enabled;
+        await this.persistRegistry(registry);
+        return this.getStatus();
+    }
+    async configureAutoSwitchThresholds(input) {
+        const registry = await this.loadReconciledRegistry();
+        if (typeof input.threshold5hPercent === "number") {
+            if (!this.isValidPercent(input.threshold5hPercent)) {
+                throw new errors_1.AutoSwitchConfigError("`--5h` must be an integer from 1 to 100.");
+            }
+            registry.autoSwitch.threshold5hPercent = Math.round(input.threshold5hPercent);
+        }
+        if (typeof input.thresholdWeeklyPercent === "number") {
+            if (!this.isValidPercent(input.thresholdWeeklyPercent)) {
+                throw new errors_1.AutoSwitchConfigError("`--weekly` must be an integer from 1 to 100.");
+            }
+            registry.autoSwitch.thresholdWeeklyPercent = Math.round(input.thresholdWeeklyPercent);
+        }
+        await this.persistRegistry(registry);
+        return this.getStatus();
+    }
+    async runAutoSwitchOnce() {
+        var _a, _b, _c;
+        const registry = await this.loadReconciledRegistry();
+        if (!registry.autoSwitch.enabled) {
+            return { switched: false, reason: "auto-switch is disabled" };
+        }
+        const accountNames = await this.listAccountNames();
+        if (accountNames.length === 0) {
+            return { switched: false, reason: "no saved accounts" };
+        }
+        const active = (_a = (await this.getCurrentAccountName())) !== null && _a !== void 0 ? _a : registry.activeAccountName;
+        if (!active || !accountNames.includes(active)) {
+            return { switched: false, reason: "no active account" };
+        }
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        const activeUsage = await this.refreshAccountUsage(registry, active, {
+            preferApi: registry.api.usage,
+            allowLocalFallback: true,
+        });
+        if (!(0, usage_1.shouldSwitchCurrent)(activeUsage, {
+            threshold5hPercent: registry.autoSwitch.threshold5hPercent,
+            thresholdWeeklyPercent: registry.autoSwitch.thresholdWeeklyPercent,
+        }, nowSeconds)) {
+            await this.persistRegistry(registry);
+            return { switched: false, reason: "active account is above configured thresholds" };
+        }
+        const currentScore = (_b = (0, usage_1.usageScore)(activeUsage, nowSeconds)) !== null && _b !== void 0 ? _b : 0;
+        let bestCandidate;
+        let bestScore = currentScore;
+        for (const candidate of accountNames) {
+            if (candidate === active)
+                continue;
+            const usage = await this.refreshAccountUsage(registry, candidate, {
+                preferApi: registry.api.usage,
+                allowLocalFallback: false,
+            });
+            const score = (_c = (0, usage_1.usageScore)(usage, nowSeconds)) !== null && _c !== void 0 ? _c : 100;
+            if (!bestCandidate || score > bestScore) {
+                bestCandidate = candidate;
+                bestScore = score;
+            }
+        }
+        if (!bestCandidate || bestScore <= currentScore) {
+            await this.persistRegistry(registry);
+            return {
+                switched: false,
+                reason: "no candidate has better remaining quota",
+            };
+        }
+        await this.activateSnapshot(bestCandidate);
+        registry.activeAccountName = bestCandidate;
+        await this.hydrateSnapshotMetadata(registry, bestCandidate);
+        await this.persistRegistry(registry);
+        return {
+            switched: true,
+            fromAccount: active,
+            toAccount: bestCandidate,
+            reason: "switched due to low credits on active account",
+        };
+    }
+    async runDaemon(mode) {
+        if (mode === "once") {
+            await this.runAutoSwitchOnce();
+            return;
+        }
+        for (;;) {
+            try {
+                await this.runAutoSwitchOnce();
+            }
+            catch {
+                // keep daemon alive
+            }
+            await new Promise((resolve) => setTimeout(resolve, 30000));
+        }
+    }
+    selectBestCandidateFromRegistry(candidates, registry) {
+        var _a, _b, _c, _d;
+        const nowSeconds = Math.floor(Date.now() / 1000);
+        let best = candidates[0];
+        let bestScore = (_b = (0, usage_1.usageScore)((_a = registry.accounts[best]) === null || _a === void 0 ? void 0 : _a.lastUsage, nowSeconds)) !== null && _b !== void 0 ? _b : -1;
+        for (const candidate of candidates.slice(1)) {
+            const score = (_d = (0, usage_1.usageScore)((_c = registry.accounts[candidate]) === null || _c === void 0 ? void 0 : _c.lastUsage, nowSeconds)) !== null && _d !== void 0 ? _d : -1;
+            if (score > bestScore) {
+                best = candidate;
+                bestScore = score;
+            }
+        }
+        return best;
+    }
+    async refreshAccountUsage(registry, accountName, options) {
+        var _a;
+        const snapshotPath = this.accountFilePath(accountName);
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(snapshotPath);
+        const entry = (_a = registry.accounts[accountName]) !== null && _a !== void 0 ? _a : {
+            name: accountName,
+            createdAt: new Date().toISOString(),
+        };
+        if (parsed.email)
+            entry.email = parsed.email;
+        if (parsed.accountId)
+            entry.accountId = parsed.accountId;
+        if (parsed.userId)
+            entry.userId = parsed.userId;
+        if (parsed.planType)
+            entry.planType = parsed.planType;
+        let usage = null;
+        if (options.preferApi) {
+            usage = await (0, usage_1.fetchUsageFromApi)(parsed);
+        }
+        if (!usage && options.allowLocalFallback) {
+            usage = await (0, usage_1.fetchUsageFromLocal)((0, paths_1.resolveCodexDir)());
+        }
+        if (usage) {
+            entry.lastUsage = usage;
+            entry.lastUsageAt = usage.fetchedAt;
+            if (usage.planType) {
+                entry.planType = usage.planType;
+            }
+        }
+        registry.accounts[accountName] = entry;
+        return entry.lastUsage;
     }
     accountFilePath(name) {
-        return node_path_1.default.join(paths_1.accountsDir, `${name}.json`);
+        return node_path_1.default.join((0, paths_1.resolveAccountsDir)(), `${name}.json`);
     }
     normalizeAccountName(rawName) {
         if (typeof rawName !== "string") {
@@ -82,18 +469,47 @@ class AccountService {
         }
         return withoutExtension;
     }
-    async ensureAuthFileExists() {
-        if (!(await this.pathExists(paths_1.authPath))) {
-            throw new errors_1.AuthFileMissingError(paths_1.authPath);
+    isValidPercent(value) {
+        return Number.isFinite(value) && Number.isInteger(value) && value >= 1 && value <= 100;
+    }
+    async ensureAuthFileExists(authPath) {
+        if (!(await this.pathExists(authPath))) {
+            throw new errors_1.AuthFileMissingError(authPath);
         }
     }
     async ensureDir(dirPath) {
         await promises_1.default.mkdir(dirPath, { recursive: true });
     }
-    async replaceSymlink(target, linkPath) {
-        await this.removeIfExists(linkPath);
-        const absoluteTarget = node_path_1.default.resolve(target);
-        await promises_1.default.symlink(absoluteTarget, linkPath);
+    async materializeAuthSymlink(authPath) {
+        const stat = await promises_1.default.lstat(authPath);
+        if (!stat.isSymbolicLink()) {
+            return;
+        }
+        const snapshotData = await promises_1.default.readFile(authPath);
+        await this.removeIfExists(authPath);
+        await promises_1.default.writeFile(authPath, snapshotData);
+    }
+    async assertSafeSnapshotOverwrite(input) {
+        var _a, _b;
+        if (input.force || !(await this.pathExists(input.destinationPath))) {
+            return;
+        }
+        const [existingSnapshot, incomingSnapshot] = await Promise.all([
+            (0, auth_parser_1.parseAuthSnapshotFile)(input.destinationPath),
+            (0, auth_parser_1.parseAuthSnapshotFile)(input.authPath),
+        ]);
+        const existingEmail = (_a = existingSnapshot.email) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+        const incomingEmail = (_b = incomingSnapshot.email) === null || _b === void 0 ? void 0 : _b.trim().toLowerCase();
+        if (existingEmail && incomingEmail && existingEmail !== incomingEmail) {
+            throw new errors_1.SnapshotEmailMismatchError(input.accountName, existingEmail, incomingEmail);
+        }
+        if (this.snapshotsShareIdentity(existingSnapshot, incomingSnapshot))
+            return;
+        if (!existingEmail || !incomingEmail)
+            return;
+        const existingIdentity = this.renderSnapshotIdentity(existingSnapshot, existingEmail);
+        const incomingIdentity = this.renderSnapshotIdentity(incomingSnapshot, incomingEmail);
+        throw new errors_1.SnapshotEmailMismatchError(input.accountName, existingIdentity, incomingIdentity);
     }
     async removeIfExists(target) {
         try {
@@ -107,12 +523,13 @@ class AccountService {
         }
     }
     async writeCurrentName(name) {
-        await this.ensureDir(paths_1.codexDir);
-        await promises_1.default.writeFile(paths_1.currentNamePath, `${name}\n`, "utf8");
+        const currentNamePath = (0, paths_1.resolveCurrentNamePath)();
+        await this.ensureDir(node_path_1.default.dirname(currentNamePath));
+        await promises_1.default.writeFile(currentNamePath, `${name}\n`, "utf8");
     }
-    async readCurrentNameFile() {
+    async readCurrentNameFile(currentNamePath) {
         try {
-            const contents = await promises_1.default.readFile(paths_1.currentNamePath, "utf8");
+            const contents = await promises_1.default.readFile(currentNamePath, "utf8");
             const trimmed = contents.trim();
             return trimmed.length ? trimmed : null;
         }
@@ -133,5 +550,103 @@ class AccountService {
             return false;
         }
     }
+    async hydrateSnapshotMetadata(registry, accountName) {
+        var _a;
+        const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(this.accountFilePath(accountName));
+        const entry = (_a = registry.accounts[accountName]) !== null && _a !== void 0 ? _a : {
+            name: accountName,
+            createdAt: new Date().toISOString(),
+        };
+        if (parsed.email)
+            entry.email = parsed.email;
+        if (parsed.accountId)
+            entry.accountId = parsed.accountId;
+        if (parsed.userId)
+            entry.userId = parsed.userId;
+        if (parsed.planType)
+            entry.planType = parsed.planType;
+        registry.accounts[accountName] = entry;
+    }
+    async resolveUniqueInferredName(baseName, incomingSnapshot) {
+        const accountPathFor = (name) => this.accountFilePath(name);
+        const hasMatchingIdentity = async (name) => {
+            const parsed = await (0, auth_parser_1.parseAuthSnapshotFile)(accountPathFor(name));
+            return this.snapshotsShareIdentity(parsed, incomingSnapshot);
+        };
+        const basePath = accountPathFor(baseName);
+        if (!(await this.pathExists(basePath))) {
+            return baseName;
+        }
+        if (await hasMatchingIdentity(baseName)) {
+            return baseName;
+        }
+        for (let i = 2; i <= 99; i += 1) {
+            const candidate = this.normalizeAccountName(`${baseName}--dup-${i}`);
+            const candidatePath = accountPathFor(candidate);
+            if (!(await this.pathExists(candidatePath))) {
+                return candidate;
+            }
+            if (await hasMatchingIdentity(candidate)) {
+                return candidate;
+            }
+        }
+        throw new errors_1.AccountNameInferenceError();
+    }
+    async loadReconciledRegistry() {
+        const accountNames = await this.listAccountNames();
+        const loaded = await (0, registry_1.loadRegistry)();
+        const base = loaded.version === 1 ? loaded : (0, registry_1.createDefaultRegistry)();
+        return (0, registry_1.reconcileRegistryWithAccounts)(base, accountNames);
+    }
+    async persistRegistry(registry) {
+        const reconciled = (0, registry_1.reconcileRegistryWithAccounts)(registry, await this.listAccountNames());
+        await (0, registry_1.saveRegistry)(reconciled);
+    }
+    async activateSnapshot(accountName) {
+        const name = this.normalizeAccountName(accountName);
+        const source = this.accountFilePath(name);
+        if (!(await this.pathExists(source))) {
+            throw new errors_1.AccountNotFoundError(name);
+        }
+        const authPath = (0, paths_1.resolveAuthPath)();
+        await this.ensureDir(node_path_1.default.dirname(authPath));
+        await promises_1.default.copyFile(source, authPath);
+        await this.writeCurrentName(name);
+    }
+    async clearActivePointers() {
+        const currentPath = (0, paths_1.resolveCurrentNamePath)();
+        const authPath = (0, paths_1.resolveAuthPath)();
+        await this.removeIfExists(currentPath);
+        await this.removeIfExists(authPath);
+    }
+    snapshotsShareIdentity(a, b) {
+        var _a, _b;
+        if (a.authMode !== "chatgpt" || b.authMode !== "chatgpt") {
+            return false;
+        }
+        if (a.userId && b.userId && a.accountId && b.accountId) {
+            return a.userId === b.userId && a.accountId === b.accountId;
+        }
+        if (a.accountId && b.accountId) {
+            return a.accountId === b.accountId;
+        }
+        if (a.userId && b.userId) {
+            return a.userId === b.userId;
+        }
+        const aEmail = (_a = a.email) === null || _a === void 0 ? void 0 : _a.trim().toLowerCase();
+        const bEmail = (_b = b.email) === null || _b === void 0 ? void 0 : _b.trim().toLowerCase();
+        if (aEmail && bEmail) {
+            return aEmail === bEmail;
+        }
+        return false;
+    }
+    renderSnapshotIdentity(snapshot, fallbackEmail) {
+        const parts = [fallbackEmail];
+        if (snapshot.accountId)
+            parts.push(`account:${snapshot.accountId}`);
+        if (snapshot.userId)
+            parts.push(`user:${snapshot.userId}`);
+        return parts.join(" | ");
+    }
 }
 exports.AccountService = AccountService;

package/dist/lib/accounts/auth-parser.d.ts

@@ -0,0 +1,3 @@
+import { ParsedAuthSnapshot } from "./types";
+export declare function parseAuthSnapshotData(data: unknown): ParsedAuthSnapshot;
+export declare function parseAuthSnapshotFile(snapshotPath: string): Promise<ParsedAuthSnapshot>;