@modelprofile.com/authswitch 8.0.0 → 8.1.0

package/dist_ts/classes.authorityimport.js

@@ -0,0 +1,638 @@
+import * as plugins from './plugins.js';
+import { authSwitchEnvironmentId } from './classes.operations.js';
+import { AuthSwitchTpmSecretCodec } from './classes.authoritysecrets.js';
+import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { ClaudeTokenRefresh } from './classes.claudetokenrefresh.js';
+import { CodexDaemon } from './classes.codexdaemon.js';
+import { CodexHome } from './classes.codexhome.js';
+import { HarnessProcesses } from './classes.harnessprocesses.js';
+import { LegacySourceChangedError, readLegacySourceEnrollments, readLegacySourceMaterial, readLegacySources, resolveLegacySourceLocations } from './ts_migration/legacysources/index.js';
+/**
+ * What the owner must know before importing anything.
+ *
+ * The run-order line is not advice: after an account is imported, its legacy record holds a refresh token
+ * the provider has already rotated away, and the everyday legacy commands would restore or exercise exactly
+ * that record. The import is therefore only safe once those commands run on the authority.
+ */
+const INVENTORY_NOTICE = [
+    'This inventory only reads. It changes no authority record, no legacy store and no credential.',
+    'Importing transfers ownership; it does not copy. Verifying a saved authswitch record refreshes its token, '
+        + 'and the legacy copy is unusable from that moment. The fallback is one device sign-in for that account.',
+    'A native Codex, Claude or OpenCode store is projected, not imported: the native tool stays the only '
+        + 'refresher, and its record is verified by a provider read that rotates nothing.',
+    'Do not import until the everyday commands run on the authority and the native projections exist. Until '
+        + 'then a legacy command could restore or exercise a record whose token an import has already replaced.',
+    'No file under the legacy stores is deleted by an import. Retiring those files is a separate later step.',
+    'The authority store is deliberately not backed up. Losing it later loses the remote-control enrollments '
+        + 'and every runtime binding as well as the logins: each account then needs a device sign-in, and each '
+        + 'enrollment has to be paired again.',
+];
+/** Reads the host: the watch lock file, the process table and Codex's own daemon status. */
+export class AuthSwitchImportHostQuiescence {
+    authSwitchHome;
+    codexHome;
+    constructor(authSwitchHome, codexHome) {
+        this.authSwitchHome = authSwitchHome;
+        this.codexHome = codexHome;
+    }
+    watchHolderPid() {
+        // The lock is read, never acquired: an inventory or an import must not become the watch.
+        let raw;
+        try {
+            raw = plugins.fs.readFileSync(plugins.path.join(this.authSwitchHome, 'watch.lock'), 'utf8');
+        }
+        catch {
+            return null;
+        }
+        let pid;
+        try {
+            pid = JSON.parse(raw).pid;
+        }
+        catch {
+            return null;
+        }
+        if (typeof pid !== 'number' || !Number.isSafeInteger(pid) || pid <= 0)
+            return null;
+        try {
+            process.kill(pid, 0);
+            return pid;
+        }
+        catch (error) {
+            return error.code === 'EPERM' ? pid : null;
+        }
+    }
+    runningHarnessPids(binary) {
+        return new HarnessProcesses(binary).list().map(item => item.pid);
+    }
+    codexAppServerRunning() {
+        const status = new CodexDaemon(new CodexHome(this.codexHome)).status();
+        return status === null ? null : status.running;
+    }
+}
+const idHash = (...values) => plugins.crypto.createHash('sha256').update(JSON.stringify(values)).digest('hex');
+const grantPlan = (record) => {
+    if (record.sourceKind === 'claude_native') {
+        return { providerId: 'anthropic', purpose: 'claude_host_native', audience: 'claude-code-host',
+            settledOwner: 'claude_native' };
+    }
+    if (record.sourceKind === 'opencode_native') {
+        return { providerId: 'openai', purpose: 'opencode_native', audience: 'chatgpt',
+            settledOwner: 'legacy_native' };
+    }
+    if (record.sourceKind === 'codex_native') {
+        return { providerId: 'openai', purpose: 'openai_managed', audience: 'chatgpt',
+            settledOwner: 'legacy_native' };
+    }
+    return record.providerId === 'anthropic'
+        ? { providerId: 'anthropic', purpose: 'claude_host_native', audience: 'claude-code-host',
+            settledOwner: 'daemon' }
+        : { providerId: 'openai', purpose: 'openai_managed', audience: 'chatgpt', settledOwner: 'daemon' };
+};
+/** One grant per account, purpose and audience -- the same rule the device login uses. */
+const importGrantId = (accountId, plan) => idHash('authswitch-grant-v1', accountId, plan.purpose, plan.audience);
+const importHandoffId = (sourceId) => idHash('authswitch-import-handoff-v1', sourceId);
+/** The handoff phases past the pre-send marker: the exchange may already have consumed the refresh token. */
+const spentHandoffPhases = ['source_stopped', 'needs_reauth', 'aborted'];
+/**
+ * What a ledger status asks of the owner.
+ *
+ * An unsettled row is resumed by submitting the same source again -- unless its handoff got past the marker
+ * that says the sign-in exchange may have been sent, because a rotating refresh token is never sent twice.
+ * Reading the handoff here is what keeps this answer truthful: without it a source whose only remaining
+ * repair is a device sign-in would invite a submission that can only end in a quarantine.
+ */
+const importAction = (status, handoff) => {
+    if (status === 'complete')
+        return 'none';
+    if (status === 'quarantined')
+        return 'device_login';
+    return handoff !== null && spentHandoffPhases.includes(handoff.phase) ? 'device_login' : 'resume';
+};
+/** A refusal the owner can act on. It never leaves a half-written import behind. */
+export class AuthSwitchImportRefusal extends Error {
+}
+// The annotation on the binding, not only on the arrow, is what lets a refusal narrow the code after it.
+const refuse = reason => { throw new AuthSwitchImportRefusal(reason); };
+const RUN_ORDER_REFUSAL = 'Importing needs the run-order acknowledgement: an imported source\'s legacy copy '
+    + 'holds a refresh token the provider has rotated away, and the everyday legacy commands would restore or '
+    + 'exercise exactly that copy. Import only once those commands run on the authority and the native '
+    + 'projections exist.';
+/** Strips the source location: a ledger row stores its hash, and no response may carry the path. */
+const publicSource = (record, ledgerStatus) => ({
+    id: record.id,
+    sourceKind: record.sourceKind,
+    sourcePathHash: record.sourcePathHash,
+    sourceDigest: record.sourceDigest,
+    treatment: record.treatment,
+    proof: record.proof,
+    accountId: record.accountId,
+    providerId: record.providerId,
+    email: record.email,
+    plan: record.plan,
+    label: record.label,
+    accessExpiresAt: record.accessExpiresAt,
+    enrollmentCount: record.enrollmentCount,
+    ledgerStatus,
+    problems: [...record.problems],
+});
+/**
+ * The one-time account import.
+ *
+ * It reads the legacy stores through the isolated migration readers and reports them against the authority's
+ * migration ledger. Nothing here is a runtime fallback: no ordinary authority operation reaches this class,
+ * and it never writes to a legacy store.
+ */
+export class AuthSwitchAuthorityImport {
+    database;
+    env;
+    homeDirectory;
+    now;
+    openAi;
+    claudeStatus;
+    claudeTokens;
+    secrets;
+    quiescence;
+    constructor(database, options = {}) {
+        this.database = database;
+        this.env = options.env ?? process.env;
+        this.homeDirectory = options.homeDirectory ?? plugins.os.homedir();
+        this.now = options.now ?? Date.now;
+        this.openAi = options.openAi ?? new plugins.flexAccounts.OpenAiProviderAdapter();
+        this.claudeStatus = options.claudeStatus ?? new ClaudeAccountStatus();
+        this.claudeTokens = options.claudeTokens ?? new ClaudeTokenRefresh();
+        this.secrets = options.secrets ?? new AuthSwitchTpmSecretCodec();
+        const locations = resolveLegacySourceLocations(this.env, this.homeDirectory);
+        this.quiescence = options.quiescence
+            ?? new AuthSwitchImportHostQuiescence(locations.authSwitchHome, locations.codexHome);
+    }
+    /** The credential-free report. Reads the legacy stores and the ledger; writes nothing. */
+    async inventory() {
+        const now = this.now();
+        const report = readLegacySources({ env: this.env, homeDirectory: this.homeDirectory, now });
+        const sources = [];
+        for (const record of report.sources) {
+            const ledger = await this.database.readMigrationLedger(record.id);
+            const source = publicSource(record, ledger?.status ?? null);
+            if (ledger !== null && ledger.sourceDigest !== record.sourceDigest) {
+                // The source changed after its row was written. A later import must not treat the approved bytes and
+                // the current bytes as the same source; the ledger deliberately refuses to move that row.
+                source.problems.push('the source changed after its migration ledger row was written');
+            }
+            if (ledger?.status === 'complete') {
+                source.problems.push('this source is already imported; its legacy copy is retired');
+            }
+            sources.push(source);
+        }
+        return {
+            generatedAt: new Date(now).toISOString(),
+            environmentId: authSwitchEnvironmentId(this.env),
+            notice: [...INVENTORY_NOTICE],
+            sources,
+            problems: [...report.problems],
+        };
+    }
+    /**
+     * Where every source the authority knows about stands.
+     *
+     * Read from the migration ledger, the grants and the handoffs only: it opens no legacy store, so it stays
+     * truthful about what the authority decided even if a source has since been moved or deleted on the host.
+     * A source that was never submitted has no ledger row and belongs to the inventory, not here.
+     */
+    async status(request = {}) {
+        const page = await this.database.migrationLedgerPage(request.after ?? null, request.limit ?? 128);
+        const entries = [];
+        for (const row of page.rows) {
+            const grant = row.grantId === null ? null : await this.database.readGrant(row.grantId);
+            const handoff = await this.database.readHandoff(importHandoffId(row.id));
+            entries.push({
+                sourceId: row.id, sourceKind: row.sourceKind, status: row.status,
+                accountId: row.accountId, loginId: row.grantId, owner: grant?.owner ?? null,
+                action: importAction(row.status, handoff), statusObservedAt: row.statusObservedAt,
+            });
+        }
+        return { generatedAt: this.stamp(), entries, nextCursor: page.nextCursor };
+    }
+    /**
+     * Imports one source.
+     *
+     * A source whose grant the authority takes over is verified by one real refresh, which rotates its token
+     * and is the point of no return; a source a native tool keeps refreshing is verified by a provider read
+     * that rotates nothing. Every step before the refresh is durable, and the marker that says "the exchange
+     * may have been sent" is the handoff's own `source_stopped` phase: a restart that finds it never replays
+     * the grant, it asks for a device sign-in instead.
+     */
+    async submit(request) {
+        if (request.acknowledgeRunOrder !== true)
+            refuse(RUN_ORDER_REFUSAL);
+        if (request.callerQuiescent !== true) {
+            refuse('Importing needs the caller\'s assertion that nothing it owns will use this source meanwhile: '
+                + 'a host that drives the legacy library inside its own process cannot be observed from here.');
+        }
+        const record = this.resolveSource(request.submission);
+        const plan = grantPlan(record);
+        this.assertQuiescent(record);
+        const ledger = await this.database.readMigrationLedger(record.id);
+        if (ledger !== null) {
+            if (ledger.sourceDigest !== record.sourceDigest) {
+                refuse('The source changed after its migration ledger row was written; it is a different source now.');
+            }
+            if (ledger.status === 'complete')
+                refuse('This source is already imported.');
+            if (ledger.status === 'quarantined') {
+                refuse('This source is quarantined: its outcome could not be established, so it needs a device '
+                    + 'sign-in for that account rather than another import.');
+            }
+        }
+        const accountId = record.accountId;
+        const subject = record.subject;
+        const workspaceId = record.workspaceId;
+        if (accountId === null || subject === null || workspaceId === null) {
+            refuse('The source carries no provider identity the authority can bind an account to.');
+        }
+        const grantId = importGrantId(accountId, plan);
+        if (ledger === null)
+            await this.beginLedger(record);
+        const material = this.material(record, request.submission);
+        return record.treatment === 'project'
+            ? this.project(record, plan, { accountId, subject, workspaceId, grantId }, material)
+            : this.adopt(record, plan, { accountId, subject, workspaceId, grantId }, material);
+    }
+    /** The source a submission names, proven to be the one that was inventoried. */
+    resolveSource(submission) {
+        if (submission.kind === 'external') {
+            const identity = this.externalIdentity(submission.credential.idToken);
+            return {
+                id: idHash('authswitch-migration-v1', 'agl_flex', submission.sourcePathHash),
+                sourceKind: 'agl_flex', path: '', sourcePathHash: submission.sourcePathHash,
+                sourceDigest: submission.sourceDigest, treatment: 'import', proof: 'rotating_refresh',
+                accountId: identity.accountId, subject: identity.subject, workspaceId: identity.workspaceId,
+                providerId: 'openai', email: identity.email, plan: identity.plan, label: identity.email,
+                accessExpiresAt: null, enrollmentCount: null, problems: [],
+            };
+        }
+        const report = readLegacySources({ env: this.env, homeDirectory: this.homeDirectory, now: this.now() });
+        const record = report.sources.find(source => source.id === submission.sourceId);
+        if (!record)
+            refuse('That source no longer exists on this host.');
+        if (record.sourceDigest !== submission.sourceDigest) {
+            refuse('The source changed after it was inventoried; review the inventory again before importing.');
+        }
+        if (record.problems.length)
+            refuse(`The source cannot be imported: ${record.problems.join('; ')}.`);
+        if (record.treatment === 'refuse')
+            refuse('This source is not a login the authority can hold.');
+        return record;
+    }
+    externalIdentity(idToken) {
+        let info;
+        try {
+            info = plugins.flexAuth.parseOpenAiChatGptTokenInfo(idToken);
+        }
+        catch {
+            return refuse('The submitted login carries no readable ChatGPT identity.');
+        }
+        if (!info.chatgptUserId || !info.chatgptAccountId) {
+            refuse('The submitted login omits a stable ChatGPT user or account identity.');
+        }
+        return {
+            accountId: idHash('authswitch-account-v1', 'openai', info.chatgptUserId, info.chatgptAccountId),
+            subject: info.chatgptUserId, workspaceId: info.chatgptAccountId,
+            email: info.email?.toLowerCase() ?? null, plan: info.chatgptPlanType ?? null,
+        };
+    }
+    /** Reads the credential the daemon will seal. Only an external submission brings its own. */
+    material(record, submission) {
+        if (submission.kind === 'external') {
+            return { providerId: 'openai', credential: { kind: 'chatgptOAuth', providerId: 'openai',
+                    accessToken: submission.credential.accessToken, refreshToken: submission.credential.refreshToken,
+                    idToken: submission.credential.idToken } };
+        }
+        try {
+            return readLegacySourceMaterial(record);
+        }
+        catch (error) {
+            if (error instanceof LegacySourceChangedError)
+                refuse(error.message);
+            throw error;
+        }
+    }
+    /**
+     * Refuses while anything that could refresh this source is running.
+     *
+     * Unknown counts as running: an import that guessed idle could rotate a token another owner is using.
+     */
+    assertQuiescent(record) {
+        const watch = this.quiescence.watchHolderPid();
+        if (watch !== null) {
+            refuse(`An authswitch watch is running (pid ${watch}); it switches logins. Stop it and import again.`);
+        }
+        const binary = record.providerId === 'anthropic' ? 'claude'
+            : record.sourceKind === 'opencode_native' ? 'opencode' : null;
+        if (binary !== null) {
+            const pids = this.quiescence.runningHarnessPids(binary);
+            if (pids.length) {
+                refuse(`${binary} is running (pid ${pids.join(', ')}) and owns this login. Close it and import again.`);
+            }
+        }
+        if (record.sourceKind === 'codex_native'
+            || (record.sourceKind === 'authswitch_stash' && record.providerId === 'openai')) {
+            const running = this.quiescence.codexAppServerRunning();
+            if (running !== false) {
+                refuse(running === null
+                    ? 'Codex could not be asked whether its app-server is running, and an unknown app-server counts '
+                        + 'as running. Make Codex answerable and import again.'
+                    : 'The Codex app-server is running and refreshes this login on its own schedule. '
+                        + 'Stop it with `codex app-server daemon stop` and import again.');
+            }
+        }
+    }
+    async beginLedger(record) {
+        const updateId = plugins.crypto.randomUUID();
+        // Written before any provider call, so a crash always leaves the source named in the authority.
+        await this.database.changeMigrationLedger(updateId, record.id, () => ({
+            id: record.id, version: 1, sourceKind: record.sourceKind, sourcePathHash: record.sourcePathHash,
+            sourceDigest: record.sourceDigest, status: 'prepared', accountId: null, grantId: null,
+            revision: 1, statusObservedAt: this.stamp(), updateId,
+        }));
+    }
+    async moveLedger(ledgerId, status, accountId, grantId) {
+        const updateId = plugins.crypto.randomUUID();
+        return this.database.changeMigrationLedger(updateId, ledgerId, current => {
+            if (!current)
+                throw new Error('The migration ledger row disappeared during the import.');
+            return { ...current, status, accountId, grantId, revision: current.revision + 1,
+                statusObservedAt: this.stamp(), updateId };
+        });
+    }
+    stamp() { return new Date(this.now()).toISOString(); }
+    account(record, identity, plan, existing, grantId, updateId) {
+        const label = record.label ?? record.email ?? `${plan.providerId} ${identity.workspaceId}`;
+        return existing
+            ? { ...existing, label: existing.label || label, email: record.email, plan: record.plan,
+                removed: false, revision: existing.revision + 1, statusObservedAt: this.stamp(), updateId }
+            : { id: identity.accountId, providerId: plan.providerId, issuer: plan.providerId,
+                subject: identity.subject, workspaceId: identity.workspaceId, label, email: record.email,
+                plan: record.plan, primaryGrantId: grantId, removed: false, revision: 1,
+                statusObservedAt: this.stamp(), updateId };
+    }
+    /** Writes the account and its grant, choosing the primary or the secondary transaction by identity. */
+    async putGrant(identity, record, plan, grantId, make) {
+        const existingAccount = await this.database.readAccount(identity.accountId);
+        const updateId = plugins.crypto.randomUUID();
+        if (existingAccount && existingAccount.primaryGrantId !== grantId) {
+            await this.database.changeSecondaryGrant(updateId, identity.accountId, grantId, grant => make(grant, updateId));
+            return;
+        }
+        await this.database.changeAccountAndGrant(updateId, identity.accountId, grantId, (account, grant) => ({
+            account: this.account(record, identity, plan, account, grantId, updateId),
+            grant: make(grant, updateId),
+        }));
+    }
+    baseGrant(identity, plan, grantId, existing, updateId, overrides) {
+        return {
+            id: grantId, accountId: identity.accountId, providerId: plan.providerId, purpose: plan.purpose,
+            audience: plan.audience, state: 'legacy_native_pending', owner: 'legacy_native',
+            grantGeneration: existing ? existing.grantGeneration : 1,
+            authorizationGeneration: existing ? existing.authorizationGeneration : 1,
+            revision: existing ? existing.revision + 1 : 1, ciphertext: null, accessExpiresAt: null,
+            attemptId: null, retryAt: null, retryCount: 0, problem: 'native_owner',
+            statusObservedAt: this.stamp(), updateId, ...overrides,
+        };
+    }
+    /** Refuses a source whose grant another owner already holds, in either direction. */
+    assertOwnable(existing, plan) {
+        if (!existing)
+            return;
+        if (existing.owner === plan.settledOwner || existing.owner === 'none')
+            return;
+        refuse(existing.owner === 'daemon'
+            ? 'The authority already owns this login; a native store cannot take it over without a handoff.'
+            : 'A native store already owns this login. Its account is registered from that source; select it '
+                + 'there rather than importing a second copy.');
+    }
+    /**
+     * A projected source: the account is registered, the grant stays with its native owner, and the proof is a
+     * provider read that rotates nothing. No refresh is ever sent here.
+     */
+    async project(record, plan, identity, material) {
+        this.assertOwnable(await this.database.readGrant(identity.grantId), plan);
+        await this.putGrant(identity, record, plan, identity.grantId, (existing, updateId) => this.baseGrant(identity, plan, identity.grantId, existing, updateId, { state: 'native', owner: plan.settledOwner }));
+        try {
+            await this.proveWithoutRotation(record, identity, material);
+        }
+        catch (error) {
+            // Not a quarantine: no rotating token was sent here, so nothing was consumed and nothing is lost. The
+            // account stays registered with its native owner, unproven, and the same source is submitted again
+            // once that native tool has refreshed its own store -- which is exactly what the refusal asks for.
+            await this.moveLedger(record.id, 'pending_native_owner', identity.accountId, identity.grantId);
+            throw error;
+        }
+        await this.moveLedger(record.id, 'verified', identity.accountId, identity.grantId);
+        await this.moveLedger(record.id, 'complete', identity.accountId, identity.grantId);
+        return this.result(record, 'complete', identity, []);
+    }
+    /** The non-rotating proof: the stored access token is asked about itself and must name this account. */
+    async proveWithoutRotation(record, identity, material) {
+        if (material.providerId === 'openai') {
+            const result = await this.openAi.getAccountRateLimits({ kind: 'chatgptAccess',
+                providerId: 'openai', accessToken: material.credential.accessToken,
+                accountId: identity.workspaceId, isFedrampAccount: false });
+            if (!result.success) {
+                refuse(`The stored access token could not be proven live (${result.errorCode}); let the native tool `
+                    + 'refresh its own store, then import again.');
+            }
+            // The claims of the very token that answered must still name this account.
+            const claims = plugins.flexAuth.parseOpenAiChatGptTokenInfo(material.credential.accessToken);
+            if (claims.chatgptAccountId !== identity.workspaceId) {
+                refuse('The stored access token belongs to another ChatGPT account.');
+            }
+            return;
+        }
+        const oauth = material.login.claudeAiOauth;
+        const accessToken = typeof oauth.accessToken === 'string' ? oauth.accessToken : '';
+        const scopes = Array.isArray(oauth.scopes)
+            ? oauth.scopes.filter((scope) => typeof scope === 'string') : [];
+        const read = await this.claudeStatus.readDetailed({ accessToken, scopes,
+            identity: { accountUuid: identity.subject, organizationUuid: identity.workspaceId },
+            ...(record.plan === null ? {} : { plan: record.plan }) });
+        if (read.profile === 'mismatch')
+            refuse('The native Claude login belongs to another account.');
+        if (read.profile !== 'verified') {
+            refuse(`The native Claude login could not be proven live (profile ${read.profile}); let Claude Code `
+                + 'refresh its own store, then import again.');
+        }
+    }
+    /**
+     * A source the authority takes over.
+     *
+     * The handoff row is the durable record of how far this went. `source_stopped` is written before the
+     * refresh is sent, so a lost answer is always visible afterwards and is never retried.
+     */
+    async adopt(record, plan, identity, material) {
+        const handoffId = importHandoffId(record.id);
+        let handoff = await this.database.readHandoff(handoffId);
+        if (handoff === null) {
+            this.assertOwnable(await this.database.readGrant(identity.grantId), plan);
+            const ciphertext = await this.seal(identity.grantId, material);
+            await this.putGrant(identity, record, plan, identity.grantId, (existing, updateId) => this.baseGrant(identity, plan, identity.grantId, existing, updateId, { ciphertext }));
+            handoff = await this.moveHandoff(handoffId, record, identity, 'prepared', grant => ({ ...grant, state: 'legacy_native_pending' }));
+        }
+        if (handoff.phase === 'needs_reauth' || handoff.phase === 'aborted') {
+            await this.quarantine(record, identity);
+            refuse('A previous import of this source did not settle; sign in to that account again instead.');
+        }
+        if (handoff.phase === 'prepared') {
+            // The durable marker. Everything after it may have reached the provider.
+            handoff = await this.moveHandoff(handoffId, record, identity, 'source_stopped', grant => ({ ...grant, state: 'legacy_native_pending' }));
+            const rotated = await this.rotate(material);
+            if (rotated === null) {
+                await this.failHandoff(handoffId, record, identity);
+                await this.quarantine(record, identity);
+                refuse('The sign-in service did not give a usable answer, and a rotating refresh token is never '
+                    + 'sent twice. Sign in to that account again to finish this import.');
+            }
+            const ciphertext = await this.seal(identity.grantId, rotated.material);
+            handoff = await this.moveHandoff(handoffId, record, identity, 'target_written', grant => ({
+                ...grant, ciphertext, accessExpiresAt: rotated.accessExpiresAt,
+                grantGeneration: grant.grantGeneration + 1, state: 'legacy_native_pending',
+            }));
+        }
+        if (handoff.phase === 'source_stopped') {
+            // Reached only by a restart: the exchange may have been sent, so the grant is never replayed.
+            await this.failHandoff(handoffId, record, identity);
+            await this.quarantine(record, identity);
+            refuse('This import was interrupted while its sign-in was in flight. A rotating refresh token is '
+                + 'never sent twice; sign in to that account again.');
+        }
+        if (handoff.phase === 'target_written') {
+            handoff = await this.moveHandoff(handoffId, record, identity, 'verified', grant => ({ ...grant, state: 'legacy_native_pending' }));
+        }
+        if (handoff.phase === 'verified') {
+            await this.moveHandoff(handoffId, record, identity, 'committed', grant => ({
+                ...grant, state: 'ready', owner: 'daemon', problem: 'none',
+                authorizationGeneration: grant.authorizationGeneration + 1,
+            }));
+        }
+        const ledger = await this.database.readMigrationLedger(record.id);
+        if (ledger?.status !== 'verified' && ledger?.status !== 'complete') {
+            await this.moveLedger(record.id, 'verified', identity.accountId, identity.grantId);
+        }
+        await this.storeEnrollments(record, identity);
+        if ((await this.database.readMigrationLedger(record.id))?.status !== 'complete') {
+            await this.moveLedger(record.id, 'complete', identity.accountId, identity.grantId);
+        }
+        return this.result(record, 'complete', identity, []);
+    }
+    async moveHandoff(handoffId, record, identity, phase, grantChange) {
+        const updateId = plugins.crypto.randomUUID();
+        const result = await this.database.changeHandoffAndGrant(updateId, handoffId, identity.grantId, (current, grant) => ({
+            handoff: {
+                id: handoffId, accountId: identity.accountId, grantId: identity.grantId,
+                nativeHomeId: record.sourcePathHash, direction: 'to_daemon', phase,
+                operationId: current?.operationId ?? plugins.crypto.randomUUID(),
+                sourceDigest: record.sourceDigest,
+                verifiedSourceDigest: ['verified', 'committed'].includes(phase) ? record.sourceDigest
+                    : current?.verifiedSourceDigest ?? null,
+                revision: current ? current.revision + 1 : 1, statusObservedAt: this.stamp(), updateId,
+            },
+            grant: { ...grantChange(grant), revision: grant.revision + 1,
+                statusObservedAt: this.stamp(), updateId },
+        }));
+        return result.handoff;
+    }
+    async failHandoff(handoffId, record, identity) {
+        await this.moveHandoff(handoffId, record, identity, 'needs_reauth', grant => ({
+            ...grant, state: 'needs_reauth', owner: 'none', ciphertext: null, accessExpiresAt: null,
+            problem: 'exchange_uncertain',
+        }));
+    }
+    /**
+     * Marks a source whose sign-in exchange may already have been consumed. That is its only meaning, so the
+     * refusal a later submission gets needs no further reason: the repair is always a device sign-in.
+     */
+    async quarantine(record, identity) {
+        const ledger = await this.database.readMigrationLedger(record.id);
+        if (!ledger || ledger.status === 'complete' || ledger.status === 'quarantined')
+            return;
+        // A quarantined row keeps the account and grant it names, so the owner knows which account to sign in to.
+        await this.moveLedger(record.id, 'quarantined', identity.accountId, identity.grantId);
+    }
+    /**
+     * The one rotating refresh. `null` means the outcome is unknown and the grant must never be replayed.
+     *
+     * A thrown error is the same answer as a failed one: once the request left this process, whether the
+     * provider consumed the token is unknowable, so both end in a device sign-in rather than a retry.
+     */
+    async rotate(material) {
+        try {
+            return await this.rotateOnce(material);
+        }
+        catch {
+            return null;
+        }
+    }
+    async rotateOnce(material) {
+        if (material.providerId === 'openai') {
+            const result = await this.openAi.refreshCredential(material.credential);
+            if (!result.success)
+                return null;
+            let accessExpiresAt = null;
+            try {
+                accessExpiresAt = plugins.flexAuth.parseOpenAiChatGptTokenInfo(result.credential.accessToken).expiresAt ?? null;
+            }
+            catch {
+                accessExpiresAt = null;
+            }
+            return { material: { providerId: 'openai', credential: { kind: 'chatgptOAuth', providerId: 'openai',
+                        accessToken: result.credential.accessToken, refreshToken: result.credential.refreshToken,
+                        idToken: result.credential.idToken } }, accessExpiresAt };
+        }
+        const outcome = await this.claudeTokens.refreshForAuthority(material.login.claudeAiOauth);
+        if (!outcome.success)
+            return null;
+        return {
+            material: { providerId: 'anthropic', login: { ...material.login,
+                    claudeAiOauth: { ...material.login.claudeAiOauth, accessToken: outcome.tokens.accessToken,
+                        refreshToken: outcome.tokens.refreshToken, expiresAt: outcome.tokens.expiresAt,
+                        scopes: outcome.tokens.scopes } } },
+            accessExpiresAt: new Date(outcome.tokens.expiresAt).toISOString(),
+        };
+    }
+    async seal(grantId, material) {
+        const payload = material.providerId === 'openai' ? material.credential : material.login;
+        const bytes = Buffer.from(JSON.stringify(payload), 'utf8');
+        try {
+            return await this.secrets.seal(grantId, bytes);
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    /** Codex remote-control enrollments travel with the credential; losing them is losing a pairing. */
+    async storeEnrollments(record, identity) {
+        if (record.sourceKind !== 'authswitch_stash' || !record.enrollmentCount)
+            return;
+        const rows = readLegacySourceEnrollments(record);
+        if (!rows.length)
+            return;
+        const enrollmentId = idHash('authswitch-enrollment-v1', identity.accountId);
+        const updateId = plugins.crypto.randomUUID();
+        const bytes = Buffer.from(JSON.stringify(rows), 'utf8');
+        let ciphertext;
+        try {
+            ciphertext = await this.secrets.seal(identity.accountId, bytes);
+        }
+        finally {
+            bytes.fill(0);
+        }
+        await this.database.changeEnrollment(updateId, enrollmentId, identity.accountId, current => ({
+            id: enrollmentId, accountId: identity.accountId, ciphertext,
+            revision: current ? current.revision + 1 : 1, updateId,
+        }));
+    }
+    result(record, status, identity, problems) {
+        return { sourceId: record.id, sourceKind: record.sourceKind, treatment: record.treatment, status,
+            accountId: identity.accountId, loginId: identity.grantId, problems };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityimport.js","sourceRoot":"","sources":["../ts/classes.authorityimport.ts"],"names":[],"mappings":"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"}