@modelprofile.com/authswitch 6.2.0 → 6.4.0

package/dist_ts/classes.authoritybroker.js

@@ -0,0 +1,548 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { AuthSwitchTpmSecretCodec } from './classes.authoritysecrets.js';
+const idHash = (...values) => plugins.crypto.createHash('sha256').update(JSON.stringify(values)).digest('hex');
+const isId = (value) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value);
+const isUuid = (value) => typeof value === 'string' && /^[a-f0-9-]{36}$/.test(value);
+const safeLabel = (value) => typeof value === 'string' && value.trim() === value
+    && value.length > 0 && value.length <= 128 && !/[\u0000-\u001f\u007f]/.test(value);
+const safeScope = (value, maximum) => typeof value === 'string'
+    && value.length > 0 && value.length <= maximum && !/[\u0000-\u001f\u007f]/.test(value);
+const validRevision = (value) => Number.isSafeInteger(value) && Number(value) >= 0;
+const tokenExpiry = (credential) => {
+    try {
+        return plugins.flexAuth.parseOpenAiChatGptTokenInfo(credential.accessToken).expiresAt ?? null;
+    }
+    catch {
+        return null;
+    }
+};
+const openAiGrantId = (accountId) => idHash('authswitch-grant-v1', accountId, 'openai_managed', 'chatgpt');
+const publicAccount = (account, grant) => ({
+    id: account.id, providerId: account.providerId, label: account.label, email: account.email,
+    plan: account.plan, health: account.removed ? 'removed'
+        : grant?.state === 'exchange_may_have_been_sent' ? 'refreshing' : grant?.state ?? 'needs_reauth',
+    owner: grant?.owner ?? 'none', grantGeneration: grant?.grantGeneration ?? 0, revision: account.revision,
+    accessExpiresAt: grant?.accessExpiresAt ?? null, retryAt: grant?.retryAt ?? null, problem: grant?.problem ?? 'none',
+    statusObservedAt: account.statusObservedAt,
+});
+const publicBinding = (binding) => ({
+    id: binding.id, accountId: binding.accountId, runtime: binding.runtime,
+    scopeId: binding.scopeId, incarnationId: binding.incarnationId, revision: binding.revision,
+});
+/** One daemon-owned authority. No management DTO contains a refresh grant. */
+export class AuthSwitchAuthorityBroker {
+    database;
+    provider;
+    secrets;
+    now;
+    proactive;
+    operations = new Map();
+    refreshes = new Map();
+    listeners = new Set();
+    timer;
+    closed = false;
+    constructor(database, options = {}) {
+        this.database = database;
+        this.provider = options.provider ?? new plugins.flexAccounts.OpenAiProviderAdapter();
+        this.secrets = options.secrets ?? new AuthSwitchTpmSecretCodec();
+        this.now = options.now ?? Date.now;
+        this.proactive = options.proactive ?? true;
+    }
+    async start() {
+        const probe = plugins.crypto.randomBytes(32);
+        const probeId = idHash('authswitch-custody-probe-v1');
+        try {
+            const sealed = await this.secrets.seal(probeId, probe);
+            const opened = await this.secrets.unseal(probeId, sealed);
+            try {
+                if (opened.length !== probe.length || !plugins.crypto.timingSafeEqual(opened, probe)) {
+                    throw new Error('Authswitch secret custody self-check failed.');
+                }
+            }
+            finally {
+                opened.fill(0);
+            }
+        }
+        finally {
+            probe.fill(0);
+        }
+        let after = null;
+        while (true) {
+            const page = await this.database.grantsByState('exchange_may_have_been_sent', after);
+            if (!page.length)
+                break;
+            for (const grant of page) {
+                const updateId = plugins.crypto.randomUUID();
+                await this.database.changeGrant(updateId, grant.id, current => {
+                    if (!current || current.state !== 'exchange_may_have_been_sent')
+                        throw new Error('Refresh recovery changed concurrently.');
+                    return { ...current, state: 'needs_reauth', attemptId: null, problem: 'exchange_uncertain',
+                        revision: current.revision + 1, statusObservedAt: new Date(this.now()).toISOString(), updateId };
+                });
+                this.publish();
+            }
+            after = page.at(-1).id;
+        }
+        if (this.proactive)
+            this.schedule();
+    }
+    schedule() {
+        if (this.closed)
+            return;
+        this.timer = setTimeout(() => {
+            void this.refreshDueAccounts().catch(() => {
+                process.stderr.write('Authswitch proactive refresh scan failed; account status may be stale.\n');
+            }).finally(() => this.schedule());
+        }, 30_000);
+        this.timer.unref();
+    }
+    async refreshDueAccounts() {
+        if (this.closed)
+            return;
+        for (const state of ['ready', 'retry_wait']) {
+            let after = null;
+            while (true) {
+                const page = await this.database.grantsByState(state, after);
+                if (!page.length)
+                    break;
+                await Promise.allSettled(page.filter(grant => grant.purpose === 'openai_managed'
+                    && grant.owner === 'daemon' && this.isDue(grant, 0)
+                    && (grant.state !== 'retry_wait' || (grant.retryAt !== null && Date.parse(grant.retryAt) <= this.now())))
+                    .map(grant => this.refreshAccount(grant.accountId)));
+                after = page.at(-1).id;
+            }
+        }
+    }
+    isDue(grant, minValidityMs) {
+        const expires = grant.accessExpiresAt === null ? NaN : Date.parse(grant.accessExpiresAt);
+        return !Number.isFinite(expires) || expires <= this.now() + Math.max(minValidityMs, 0) + 300_000;
+    }
+    publish() {
+        for (const listener of this.listeners)
+            listener();
+    }
+    async snapshot(options = {}) {
+        if ((options.accountAfter !== undefined && !isId(options.accountAfter))
+            || (options.bindingAfter !== undefined && !isId(options.bindingAfter)))
+            throw new Error('Invalid account snapshot cursor.');
+        const page = await this.database.page(options.accountAfter ?? null, options.bindingAfter ?? null, options.limit ?? 128);
+        return { schemaVersion: 1, epoch: page.meta.epoch, revision: page.meta.revision,
+            generatedAt: new Date(this.now()).toISOString(),
+            accounts: page.accounts.filter(item => !item.account.removed)
+                .map(item => publicAccount(item.account, item.grant)),
+            bindings: page.bindings.map(publicBinding),
+            nextAccountCursor: page.nextAccountCursor, nextBindingCursor: page.nextBindingCursor };
+    }
+    async events(epoch, afterRevision, waitMs, signal) {
+        if (!isUuid(epoch) || !validRevision(afterRevision) || !Number.isSafeInteger(waitMs) || waitMs < 0 || waitMs > 30_000) {
+            throw new Error('Invalid account event cursor.');
+        }
+        const inspect = async () => {
+            const meta = await this.database.readMeta();
+            const resyncRequired = epoch !== meta.epoch || afterRevision > meta.revision;
+            const persisted = resyncRequired ? [] : await this.database.eventsAfter(afterRevision);
+            if (!resyncRequired && afterRevision < meta.revision
+                && (persisted.length === 0 || persisted.some((item, index) => item.revision !== afterRevision + index + 1))) {
+                return { epoch: meta.epoch, revision: meta.revision, resyncRequired: true, events: [] };
+            }
+            const events = persisted.map(item => ({ epoch: item.epoch, revision: item.revision, kind: item.kind, accountId: item.accountId }));
+            const revision = events.at(-1)?.revision ?? meta.revision;
+            return { epoch: meta.epoch, revision, resyncRequired, events };
+        };
+        const immediate = await inspect();
+        if (immediate.resyncRequired || immediate.events.length || waitMs === 0 || this.closed || signal?.aborted)
+            return immediate;
+        return new Promise((resolve, reject) => {
+            let finished = false;
+            const fail = (error) => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                this.listeners.delete(wake);
+                signal?.removeEventListener('abort', wake);
+                reject(error);
+            };
+            const wake = () => {
+                if (finished)
+                    return;
+                finished = true;
+                clearTimeout(timer);
+                this.listeners.delete(wake);
+                signal?.removeEventListener('abort', wake);
+                void inspect().then(resolve, reject);
+            };
+            const timer = setTimeout(wake, waitMs);
+            this.listeners.add(wake);
+            signal?.addEventListener('abort', wake, { once: true });
+            // Close the read/register race without holding a database session for the wait.
+            void inspect().then(result => { if (result.resyncRequired || result.events.length)
+                wake(); }, fail);
+        });
+    }
+    identity(credential) {
+        const token = plugins.flexAuth.parseOpenAiChatGptTokenInfo(credential.idToken);
+        const subject = token.chatgptUserId;
+        const workspaceId = token.chatgptAccountId;
+        if (!subject || !workspaceId)
+            throw new Error('OpenAI login omitted a stable user or account identity.');
+        return { id: idHash('authswitch-account-v1', 'openai', subject, workspaceId), subject, workspaceId,
+            email: token.email?.toLowerCase() ?? null, plan: token.chatgptPlanType ?? null };
+    }
+    async sealCredential(grantId, credential) {
+        const bytes = Buffer.from(JSON.stringify(credential), 'utf8');
+        try {
+            return await this.secrets.seal(grantId, bytes);
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    async unsealCredential(account, grant) {
+        if (!grant.ciphertext || grant.owner !== 'daemon' || grant.purpose !== 'openai_managed'
+            || grant.accountId !== account.id)
+            throw new Error('Account has no daemon-owned credential.');
+        const bytes = await this.secrets.unseal(grant.id, grant.ciphertext);
+        try {
+            const value = JSON.parse(Buffer.from(bytes).toString('utf8'));
+            if (!value || typeof value !== 'object')
+                throw new Error();
+            const record = value;
+            if (record.kind !== 'chatgptOAuth' || record.providerId !== 'openai'
+                || typeof record.accessToken !== 'string' || typeof record.refreshToken !== 'string'
+                || typeof record.idToken !== 'string')
+                throw new Error();
+            const credential = value;
+            if (this.identity(credential).id !== account.id)
+                throw new Error();
+            this.provider.inspectCredential(credential);
+            return credential;
+        }
+        catch {
+            throw new Error('Stored account credential is invalid or belongs to another account.');
+        }
+        finally {
+            bytes.fill(0);
+        }
+    }
+    async beginAddOpenAi() { return this.beginLogin(null); }
+    async beginReauthOpenAi(accountId) {
+        if (!isId(accountId))
+            throw new Error('Invalid account ID.');
+        const { account, grant } = await this.database.readAccountAndPrimaryGrant(accountId);
+        if (!account || account.removed || account.providerId !== 'openai')
+            throw new Error('OpenAI account was not found.');
+        if (grant?.owner === 'legacy_native')
+            throw new Error('Stop the legacy native owner before reauthenticating this account.');
+        return this.beginLogin(accountId);
+    }
+    async beginLogin(targetId) {
+        if (this.closed)
+            throw new Error('Authswitch authority is closing.');
+        this.pruneOperations();
+        if ([...this.operations.values()].filter(item => item.public.state === 'pending').length >= 32) {
+            throw new Error('Too many pending device logins.');
+        }
+        const handle = await this.provider.beginLogin({ flow: 'device' });
+        if (handle.prompt.flow !== 'device') {
+            await handle.close();
+            throw new Error('Provider did not start a device login.');
+        }
+        const publicOperation = { id: plugins.crypto.randomUUID(), state: 'pending',
+            prompt: { flow: 'device', verificationUrl: handle.prompt.verificationUrl, userCode: handle.prompt.userCode },
+            account: null, error: null };
+        const operation = { public: publicOperation, handle, task: Promise.resolve(),
+            cancelled: false, committing: false, finishedAt: null };
+        this.operations.set(publicOperation.id, operation);
+        operation.task = handle.completion.then(async (result) => {
+            if (operation.cancelled || this.closed)
+                return;
+            operation.committing = true;
+            const identity = this.identity(result.credential);
+            if (targetId !== null && identity.id !== targetId)
+                throw new Error('The device login selected a different OpenAI account.');
+            const grantId = openAiGrantId(identity.id);
+            const ciphertext = await this.sealCredential(grantId, result.credential);
+            if (operation.cancelled || this.closed)
+                return;
+            const updateId = plugins.crypto.randomUUID();
+            const updated = await this.database.changeAccountAndGrant(updateId, identity.id, grantId, (existing, oldGrant) => {
+                if (targetId === null && existing && !existing.removed)
+                    throw new Error('Account already exists; reauthenticate that account instead.');
+                if (targetId !== null && (!existing || existing.removed))
+                    throw new Error('Target account was removed during login.');
+                if (oldGrant?.owner === 'legacy_native')
+                    throw new Error('The legacy native owner still holds this grant.');
+                const now = new Date(this.now()).toISOString();
+                const account = existing
+                    ? { ...existing, label: existing.label || identity.email || `OpenAI ${identity.workspaceId}`,
+                        email: identity.email, plan: identity.plan, primaryGrantId: grantId, removed: false,
+                        revision: existing.revision + 1, statusObservedAt: now, updateId }
+                    : { id: identity.id, providerId: 'openai', issuer: 'openai', subject: identity.subject,
+                        workspaceId: identity.workspaceId, label: identity.email ?? `OpenAI ${identity.workspaceId}`,
+                        email: identity.email, plan: identity.plan, primaryGrantId: grantId, removed: false,
+                        revision: 1, statusObservedAt: now, updateId };
+                const grant = oldGrant
+                    ? { ...oldGrant, state: 'ready', owner: 'daemon', ciphertext,
+                        grantGeneration: oldGrant.grantGeneration + 1,
+                        authorizationGeneration: oldGrant.authorizationGeneration + 1,
+                        revision: oldGrant.revision + 1, accessExpiresAt: tokenExpiry(result.credential),
+                        attemptId: null, retryAt: null, retryCount: 0, problem: 'none', statusObservedAt: now, updateId }
+                    : { id: grantId, accountId: identity.id, providerId: 'openai', purpose: 'openai_managed',
+                        audience: 'chatgpt', state: 'ready', owner: 'daemon', grantGeneration: 1,
+                        authorizationGeneration: 1, revision: 1, ciphertext,
+                        accessExpiresAt: tokenExpiry(result.credential), attemptId: null,
+                        retryAt: null, retryCount: 0, problem: 'none', statusObservedAt: now, updateId };
+                return { account, grant };
+            });
+            this.publish();
+            operation.public.account = publicAccount(updated.account, updated.grant);
+            operation.public.state = 'complete';
+        }).catch(() => {
+            operation.public.state = operation.cancelled ? 'cancelled' : 'failed';
+            operation.public.error = operation.cancelled ? null : targetId === null
+                ? 'OpenAI login failed or the account could not be saved. No active account was changed.'
+                : 'OpenAI reauthentication failed or selected a different account. The existing account was preserved.';
+        }).finally(async () => {
+            operation.finishedAt = this.now();
+            try {
+                await handle.close();
+            }
+            catch { /* A completed operation remains inspectable. */ }
+        });
+        return structuredClone(publicOperation);
+    }
+    getOperation(operationId) {
+        if (!isUuid(operationId))
+            throw new Error('Invalid operation ID.');
+        this.pruneOperations();
+        const operation = this.operations.get(operationId);
+        if (!operation)
+            throw new Error('Account operation expired or was not found.');
+        return structuredClone(operation.public);
+    }
+    pruneOperations() {
+        for (const [id, operation] of this.operations) {
+            if (operation.finishedAt !== null && this.now() - operation.finishedAt > 600_000)
+                this.operations.delete(id);
+        }
+    }
+    async cancelOperation(operationId) {
+        const operation = this.operations.get(operationId);
+        if (!isUuid(operationId) || !operation)
+            throw new Error('Account operation expired or was not found.');
+        if (operation.public.state !== 'pending')
+            return structuredClone(operation.public);
+        if (operation.committing)
+            throw new Error('Login is completing; check its operation status.');
+        operation.cancelled = true;
+        await operation.handle.cancel();
+        operation.public.state = 'cancelled';
+        operation.public.error = null;
+        return structuredClone(operation.public);
+    }
+    async renameAccount(accountId, expectedRevision, label) {
+        if (!isId(accountId) || !validRevision(expectedRevision) || !safeLabel(label))
+            throw new Error('Invalid account change.');
+        const updateId = plugins.crypto.randomUUID();
+        const updated = await this.database.changeAccount(updateId, accountId, account => {
+            if (!account || account.removed || account.revision !== expectedRevision)
+                throw new Error('Account changed; refresh before editing.');
+            return { ...account, label, revision: account.revision + 1, updateId,
+                statusObservedAt: new Date(this.now()).toISOString() };
+        });
+        this.publish();
+        const grant = updated.account.primaryGrantId ? await this.database.readGrant(updated.account.primaryGrantId) : null;
+        return publicAccount(updated.account, grant);
+    }
+    async removeAccount(accountId, expectedRevision) {
+        if (!isId(accountId) || !validRevision(expectedRevision))
+            throw new Error('Invalid account change.');
+        const updateId = plugins.crypto.randomUUID();
+        const account = await this.database.removeAccountAndGrants(updateId, accountId, expectedRevision, new Date(this.now()).toISOString());
+        this.publish();
+        const grant = account.primaryGrantId ? await this.database.readGrant(account.primaryGrantId) : null;
+        return publicAccount(account, grant);
+    }
+    async bindAccount(input) {
+        if (!isId(input.accountId) || !['flex', 'codex', 'opencode', 'claude'].includes(input.runtime)
+            || !safeScope(input.scopeId, 512) || !safeScope(input.incarnationId, 256))
+            throw new Error('Invalid account binding.');
+        const id = idHash('authswitch-binding-v1', input.runtime, input.scopeId);
+        const capability = plugins.crypto.randomBytes(32).toString('base64url');
+        const capabilityHash = idHash(capability);
+        const updateId = plugins.crypto.randomUUID();
+        const updated = await this.database.changeBinding(updateId, id, input.accountId, (existing, account, grant) => {
+            if (account.removed || grant?.state !== 'ready' || grant.owner !== 'daemon'
+                || grant.purpose !== 'openai_managed' || account.providerId !== 'openai'
+                || input.runtime === 'claude') {
+                throw new Error('Account is not available for this runtime.');
+            }
+            return { id, accountId: input.accountId, grantId: grant.id, runtime: input.runtime, scopeId: input.scopeId,
+                incarnationId: input.incarnationId, revision: (existing?.revision ?? 0) + 1,
+                grantAuthorizationGeneration: grant.authorizationGeneration, capabilityHash, updateId };
+        });
+        this.publish();
+        return { binding: publicBinding(updated.binding), capability };
+    }
+    async resolveAccess(bindingId, capability, minValidityMs) {
+        if (!isId(bindingId) || !/^[A-Za-z0-9_-]{43}$/.test(capability)
+            || !Number.isSafeInteger(minValidityMs) || minValidityMs < 0 || minValidityMs > 3_600_000)
+            throw new Error('Invalid runtime credential request.');
+        const supplied = Buffer.from(idHash(capability), 'hex');
+        for (let attempt = 0; attempt < 4; attempt++) {
+            const initial = await this.database.readBindingContext(bindingId);
+            const binding = initial.binding;
+            const expected = Buffer.from(binding?.capabilityHash ?? '0'.repeat(64), 'hex');
+            if (!binding || !plugins.crypto.timingSafeEqual(supplied, expected)) {
+                throw new Error('Runtime binding is not authorized.');
+            }
+            const { account, grant } = initial;
+            if (!account || account.removed || !grant || grant.id !== binding.grantId
+                || binding.grantAuthorizationGeneration !== grant.authorizationGeneration) {
+                throw new Error('Account needs reauthentication.');
+            }
+            if (grant.state === 'exchange_may_have_been_sent') {
+                const inFlight = this.refreshes.get(account.id);
+                if (!inFlight)
+                    throw new Error('Account refresh is unresolved; reauthentication is required.');
+                await inFlight;
+                continue;
+            }
+            if (grant.owner !== 'daemon' || grant.purpose !== 'openai_managed'
+                || !['ready', 'retry_wait'].includes(grant.state)) {
+                throw new Error('Account needs reauthentication.');
+            }
+            if (this.isDue(grant, minValidityMs)) {
+                if (grant.state === 'ready' || (grant.retryAt !== null && Date.parse(grant.retryAt) <= this.now())) {
+                    await this.refreshAccount(account.id);
+                    continue;
+                }
+                throw new Error('Account access credential is not fresh enough.');
+            }
+            if (!grant.accessExpiresAt)
+                throw new Error('Account access credential is not fresh enough.');
+            const credential = await this.unsealCredential(account, grant);
+            const info = plugins.flexAuth.parseOpenAiChatGptTokenInfo(credential.accessToken);
+            if (info.chatgptAccountId !== account.workspaceId || info.chatgptUserId !== account.subject) {
+                throw new Error('Account access identity changed.');
+            }
+            const latest = await this.database.readBindingContext(bindingId);
+            if (!latest.binding || latest.binding.capabilityHash !== binding.capabilityHash
+                || latest.binding.accountId !== binding.accountId
+                || latest.binding.grantId !== binding.grantId
+                || latest.binding.incarnationId !== binding.incarnationId
+                || latest.binding.grantAuthorizationGeneration !== binding.grantAuthorizationGeneration
+                || latest.account?.removed || !latest.grant
+                || latest.grant.authorizationGeneration !== grant.authorizationGeneration
+                || latest.grant.owner !== 'daemon') {
+                throw new Error('Account binding changed during credential resolution.');
+            }
+            if (latest.grant.grantGeneration !== grant.grantGeneration
+                || latest.grant.state === 'exchange_may_have_been_sent')
+                continue;
+            if (!['ready', 'retry_wait'].includes(latest.grant.state) || this.isDue(latest.grant, minValidityMs)) {
+                throw new Error('Account access credential is not fresh enough.');
+            }
+            return { accessToken: credential.accessToken, accountId: account.workspaceId,
+                isFedrampAccount: info.chatgptAccountIsFedramp, expiresAt: grant.accessExpiresAt,
+                grantGeneration: grant.grantGeneration };
+        }
+        throw new Error('Account credential rotated repeatedly during resolution; retry the request.');
+    }
+    async refreshAccount(accountId) {
+        const prior = this.refreshes.get(accountId);
+        if (prior)
+            return prior;
+        const task = this.performRefresh(accountId).finally(() => { if (this.refreshes.get(accountId) === task)
+            this.refreshes.delete(accountId); });
+        this.refreshes.set(accountId, task);
+        return task;
+    }
+    async performRefresh(accountId) {
+        const initial = await this.database.readAccountAndPrimaryGrant(accountId);
+        const initialGrant = initial.grant;
+        if (!initial.account || initial.account.removed || !initialGrant || initialGrant.purpose !== 'openai_managed'
+            || !['ready', 'retry_wait'].includes(initialGrant.state) || initialGrant.owner !== 'daemon'
+            || !this.isDue(initialGrant, 0)
+            || (initialGrant.state === 'retry_wait'
+                && (initialGrant.retryAt === null || Date.parse(initialGrant.retryAt) > this.now())))
+            return;
+        const credential = await this.unsealCredential(initial.account, initialGrant);
+        const attemptId = plugins.crypto.randomUUID();
+        await this.database.changeGrant(attemptId, initialGrant.id, (grant, account) => {
+            if (account.removed || grant.state !== initialGrant.state || grant.revision !== initialGrant.revision
+                || grant.grantGeneration !== initialGrant.grantGeneration)
+                throw new Error('Account changed before refresh began.');
+            return { ...grant, state: 'exchange_may_have_been_sent', attemptId, retryAt: null,
+                revision: grant.revision + 1, statusObservedAt: new Date(this.now()).toISOString(), updateId: attemptId };
+        });
+        this.publish();
+        try {
+            const refreshed = await this.provider.refreshCredential(credential);
+            if (!refreshed.success) {
+                if (refreshed.requestOutcome === 'notSent') {
+                    const retryId = plugins.crypto.randomUUID();
+                    await this.database.changeGrant(retryId, initialGrant.id, grant => {
+                        if (grant.state !== 'exchange_may_have_been_sent' || grant.attemptId !== attemptId) {
+                            throw new Error('Account ownership changed during refresh.');
+                        }
+                        const backoffMs = Math.min(30_000 * 2 ** Math.min(grant.retryCount, 10), 1_800_000);
+                        const retryMs = Math.max(backoffMs, Math.min(refreshed.retryAfterMs ?? 0, 3_600_000));
+                        return { ...grant, state: 'retry_wait', attemptId: null,
+                            retryAt: new Date(this.now() + retryMs).toISOString(), retryCount: grant.retryCount + 1,
+                            problem: 'provider_unavailable',
+                            revision: grant.revision + 1, statusObservedAt: new Date(this.now()).toISOString(), updateId: retryId };
+                    });
+                    this.publish();
+                    return;
+                }
+                throw new Error('Provider refresh outcome is unknown.');
+            }
+            const identity = this.identity(refreshed.credential);
+            if (identity.id !== accountId)
+                throw new Error('Provider returned a different account.');
+            const ciphertext = await this.sealCredential(initialGrant.id, refreshed.credential);
+            const commitId = plugins.crypto.randomUUID();
+            await this.database.changeGrant(commitId, initialGrant.id, grant => {
+                if (grant.state !== 'exchange_may_have_been_sent' || grant.attemptId !== attemptId) {
+                    throw new Error('Account ownership changed during refresh.');
+                }
+                return { ...grant, state: 'ready', attemptId: null, retryAt: null, retryCount: 0, problem: 'none',
+                    ciphertext, accessExpiresAt: tokenExpiry(refreshed.credential),
+                    grantGeneration: grant.grantGeneration + 1, revision: grant.revision + 1,
+                    statusObservedAt: new Date(this.now()).toISOString(), updateId: commitId };
+            });
+            this.publish();
+        }
+        catch {
+            const uncertainId = plugins.crypto.randomUUID();
+            try {
+                await this.database.changeGrant(uncertainId, initialGrant.id, grant => {
+                    if (grant.state !== 'exchange_may_have_been_sent' || grant.attemptId !== attemptId) {
+                        throw new Error('Account was changed after its refresh attempt.');
+                    }
+                    return { ...grant, state: 'needs_reauth', attemptId: null, retryAt: null,
+                        problem: 'exchange_uncertain', revision: grant.revision + 1,
+                        statusObservedAt: new Date(this.now()).toISOString(), updateId: uncertainId };
+                });
+                this.publish();
+            }
+            catch { /* A persisted attempt marker forces needs_reauth on daemon restart. */ }
+            throw new Error('Refresh result is uncertain. Reauthenticate this account; its old grant will not be replayed.');
+        }
+    }
+    async close() {
+        this.closed = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        for (const wake of this.listeners)
+            wake();
+        await Promise.allSettled([...this.operations.values()].map(item => item.handle.cancel()));
+        await Promise.allSettled([...this.operations.values()].map(item => item.task));
+        await Promise.allSettled([...this.refreshes.values()]);
+        await this.provider.dispose();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authoritybroker.js","sourceRoot":"","sources":["../ts/classes.authoritybroker.ts"],"names":[],"mappings":"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"}