@modelprofile.com/authswitch 6.4.0 → 7.0.0

package/dist_ts/classes.authorityclient.d.ts

@@ -1,5 +1,18 @@
-import type { IAuthSwitchAccountEvent, IAuthSwitchSnapshot, IReq_AuthSwitchBeginAdd, IReq_AuthSwitchBeginReauth, IReq_AuthSwitchCancelOperation, IReq_AuthSwitchEvents, IReq_AuthSwitchGetOperation, IReq_AuthSwitchRemoveAccount, IReq_AuthSwitchRenameAccount, IReq_AuthSwitchSnapshot } from './authority-contract.js';
-import type { IReq_AuthSwitchBindAccount, IReq_AuthSwitchResolveAccess } from './authority-runtime-contract.js';
+import type { IAuthSwitchAccountEvent, IAuthSwitchSnapshot, IReq_AuthSwitchBeginAdd, IReq_AuthSwitchDoctor, IReq_AuthSwitchBeginReauth, IReq_AuthSwitchCancelOperation, IReq_AuthSwitchClaudeNativeHandoff, IReq_AuthSwitchClaudeNativeHandoffs, IReq_AuthSwitchSwitchClaudeNative, IReq_AuthSwitchEvents, IReq_AuthSwitchGetOperation, IReq_AuthSwitchListOperations, IReq_AuthSwitchRemoveAccount, IReq_AuthSwitchRenameAccount, IReq_AuthSwitchCancelPreuse, IReq_AuthSwitchGetPreuse, IReq_AuthSwitchSnapshot, IReq_AuthSwitchStartPreuse, IReq_AuthSwitchUsage } from './authority-contract.js';
+import type { IReq_AuthSwitchBindAccount, IReq_AuthSwitchReleaseBinding, IReq_AuthSwitchResolveAccess } from './authority-runtime-contract.js';
+/** A snapshot is usable only while state is current; lastVerifiedAt is the last successful daemon proof. */
+export interface IAuthSwitchSubscriptionStatus {
+    state: 'current' | 'unavailable' | 'closed';
+    reason: 'initial' | 'snapshot' | 'event' | 'heartbeat' | 'disconnect' | 'resync' | 'abort' | 'consumer_error';
+    epoch: string | null;
+    revision: number | null;
+    lastVerifiedAt: string | null;
+}
+export interface IAuthSwitchSubscriptionOptions {
+    onStatus?: (status: IAuthSwitchSubscriptionStatus) => void | Promise<void>;
+    /** Bounded long-poll interval; defaults to 30 seconds. */
+    heartbeatMs?: number;
+}
 /** Node-only client for the per-user daemon. Each request has its own bounded Unix connection. */
 export declare class AuthSwitchClient {
     readonly socketPath: string;
@@ -9,26 +22,38 @@ export declare class AuthSwitchClient {
     constructor(socketPath: string, runtimeSocketPath: string);
     private request;
     snapshot(options?: IReq_AuthSwitchSnapshot['request'], signal?: AbortSignal): Promise<IAuthSwitchSnapshot>;
+    /** One independently stamped diagnostic page; callers may continue with its independent cursors. */
+    doctorPage(options?: IReq_AuthSwitchDoctor['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchDoctor['response']['page']>;
+    getUsage(accountId: string, loginId: string, force?: boolean): Promise<IReq_AuthSwitchUsage['response']['usage']>;
     /** Assemble a consistent view from bounded database pages; restart if a writer changes the revision. */
     snapshotAll(options?: {
         limit?: number;
         signal?: AbortSignal;
     }): Promise<IAuthSwitchSnapshot>;
     events(epoch: string, afterRevision: number, waitMs?: number, signal?: AbortSignal): Promise<IReq_AuthSwitchEvents['response']>;
-    /** Always obtains a fresh snapshot after reconnect or an event-log gap. */
-    subscribe(onSnapshot: (snapshot: IAuthSwitchSnapshot) => void | Promise<void>, onEvent: (event: IAuthSwitchAccountEvent) => void | Promise<void>, signal: AbortSignal): Promise<void>;
-    beginAddOpenAi(): Promise<IReq_AuthSwitchBeginAdd['response']['operation']>;
-    beginReauthOpenAi(accountId: string): Promise<IReq_AuthSwitchBeginReauth['response']['operation']>;
-    getOperation(operationId: string): Promise<IReq_AuthSwitchGetOperation['response']['operation']>;
-    cancelOperation(operationId: string): Promise<IReq_AuthSwitchCancelOperation['response']['operation']>;
+    /** Snapshot callback runs after every known change; onStatus invalidates it on disconnect, resync or abort. */
+    subscribe(onSnapshot: (snapshot: IAuthSwitchSnapshot) => void | Promise<void>, onEvent: (event: IAuthSwitchAccountEvent) => void | Promise<void>, signal: AbortSignal, options?: IAuthSwitchSubscriptionOptions): Promise<void>;
+    beginAddOpenAi(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchBeginAdd['response']['operation']>;
+    beginReauthOpenAi(operationId: string, accountId: string, loginId: string, purpose: 'openai_managed', signal?: AbortSignal): Promise<IReq_AuthSwitchBeginReauth['response']['operation']>;
+    listOperations(after?: string, limit?: number): Promise<IReq_AuthSwitchListOperations['response']>;
+    getOperation(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchGetOperation['response']['operation']>;
+    cancelOperation(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchCancelOperation['response']['operation']>;
+    startPreuse(input: IReq_AuthSwitchStartPreuse['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchStartPreuse['response']['operation']>;
+    getPreuse(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchGetPreuse['response']['operation']>;
+    cancelPreuse(operationId: string, signal?: AbortSignal): Promise<IReq_AuthSwitchCancelPreuse['response']['operation']>;
     renameAccount(accountId: string, expectedRevision: number, label: string): Promise<IReq_AuthSwitchRenameAccount['response']['account']>;
     removeAccount(accountId: string, expectedRevision: number): Promise<IReq_AuthSwitchRemoveAccount['response']['account']>;
+    switchClaudeNative(accountId: string, loginId: string): Promise<IReq_AuthSwitchSwitchClaudeNative['response']['handoff']>;
+    getClaudeNativeHandoff(operationId: string): Promise<IReq_AuthSwitchClaudeNativeHandoff['response']['handoff']>;
+    listClaudeNativeHandoffs(after?: string, limit?: number): Promise<IReq_AuthSwitchClaudeNativeHandoffs['response']>;
     bindAccount(input: IReq_AuthSwitchBindAccount['request']): Promise<IReq_AuthSwitchBindAccount['response']>;
     resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']>;
+    releaseBinding(input: IReq_AuthSwitchReleaseBinding['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchReleaseBinding['response']>;
 }
-/** Container-facing client. It can only resolve a previously issued binding capability. */
+/** Container-facing client. It can only resolve or release a previously issued binding capability. */
 export declare class AuthSwitchRuntimeClient {
     private readonly target;
     constructor(runtimeSocketPath: string);
     resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']>;
+    releaseBinding(input: IReq_AuthSwitchReleaseBinding['request'], signal?: AbortSignal): Promise<IReq_AuthSwitchReleaseBinding['response']>;
 }

package/dist_ts/classes.authorityclient.js

@@ -84,31 +84,41 @@ export class AuthSwitchClient {
     async snapshot(options = {}, signal) {
         return (await this.request('authswitch.authority.snapshot', options, 35_000, false, signal)).snapshot;
     }
+    /** One independently stamped diagnostic page; callers may continue with its independent cursors. */
+    async doctorPage(options = {}, signal) {
+        return (await this.request('authswitch.authority.doctor', options, 35_000, false, signal)).page;
+    }
+    async getUsage(accountId, loginId, force = false) {
+        return (await this.request('authswitch.authority.usage', { accountId, loginId, force })).usage;
+    }
     /** Assemble a consistent view from bounded database pages; restart if a writer changes the revision. */
     async snapshotAll(options = {}) {
         while (true) {
             if (options.signal?.aborted)
                 throw options.signal.reason ?? new Error('Account snapshot cancelled.');
             let accountAfter;
+            let loginAfter;
             let bindingAfter;
             let aggregate;
             let changed = false;
             while (true) {
-                const page = await this.snapshot({ accountAfter, bindingAfter, limit: options.limit }, options.signal);
+                const page = await this.snapshot({ accountAfter, loginAfter, bindingAfter, limit: options.limit }, options.signal);
                 if (!aggregate)
-                    aggregate = { ...page, accounts: [...page.accounts], bindings: [...page.bindings] };
+                    aggregate = { ...page, accounts: [...page.accounts], logins: [...page.logins], bindings: [...page.bindings] };
                 else if (aggregate.epoch !== page.epoch || aggregate.revision !== page.revision) {
                     changed = true;
                     break;
                 }
                 else {
                     aggregate.accounts.push(...page.accounts);
+                    aggregate.logins.push(...page.logins);
                     aggregate.bindings.push(...page.bindings);
                 }
                 accountAfter = page.nextAccountCursor ?? accountAfter ?? page.accounts.at(-1)?.id;
+                loginAfter = page.nextLoginCursor ?? loginAfter ?? page.logins.at(-1)?.id;
                 bindingAfter = page.nextBindingCursor ?? bindingAfter ?? page.bindings.at(-1)?.id;
-                if (!page.nextAccountCursor && !page.nextBindingCursor) {
-                    return { ...aggregate, nextAccountCursor: null, nextBindingCursor: null };
+                if (!page.nextAccountCursor && !page.nextLoginCursor && !page.nextBindingCursor) {
+                    return { ...aggregate, nextAccountCursor: null, nextLoginCursor: null, nextBindingCursor: null };
                 }
             }
             if (!changed)
@@ -118,58 +128,131 @@ export class AuthSwitchClient {
     events(epoch, afterRevision, waitMs = 30_000, signal) {
         return this.request('authswitch.authority.events', { epoch, afterRevision, waitMs }, waitMs + 5_000, false, signal);
     }
-    /** Always obtains a fresh snapshot after reconnect or an event-log gap. */
-    async subscribe(onSnapshot, onEvent, signal) {
+    /** Snapshot callback runs after every known change; onStatus invalidates it on disconnect, resync or abort. */
+    async subscribe(onSnapshot, onEvent, signal, options = {}) {
+        const heartbeatMs = options.heartbeatMs ?? 30_000;
+        if (!Number.isSafeInteger(heartbeatMs) || heartbeatMs < 50 || heartbeatMs > 30_000) {
+            throw new Error('Authswitch subscription heartbeat must be 50–30000 ms.');
+        }
         const retry = () => new Promise(resolve => {
             const timer = setTimeout(() => { signal.removeEventListener('abort', aborted); resolve(); }, 250);
             const aborted = () => { clearTimeout(timer); resolve(); };
             signal.addEventListener('abort', aborted, { once: true });
         });
         let snapshot;
-        while (!signal.aborted) {
-            if (!snapshot) {
+        let available = false;
+        let lastVerifiedAt = null;
+        let lastEpoch = null;
+        let lastRevision = null;
+        const status = async (state, reason) => {
+            await options.onStatus?.({ state, reason, epoch: lastEpoch, revision: lastRevision, lastVerifiedAt });
+        };
+        const invalidate = async (reason) => {
+            snapshot = undefined;
+            if (available) {
+                available = false;
+                await status('unavailable', reason);
+            }
+        };
+        try {
+            if (!signal.aborted)
+                await status('unavailable', 'initial');
+            while (!signal.aborted) {
+                if (!snapshot) {
+                    let fresh;
+                    try {
+                        fresh = await this.snapshotAll({ signal });
+                    }
+                    catch {
+                        if (signal.aborted)
+                            break;
+                        await invalidate('disconnect');
+                        await retry();
+                        continue;
+                    }
+                    snapshot = fresh;
+                    await onSnapshot(fresh);
+                    available = true;
+                    lastEpoch = fresh.epoch;
+                    lastRevision = fresh.revision;
+                    lastVerifiedAt = new Date().toISOString();
+                    await status('current', 'snapshot');
+                }
+                let result;
                 try {
-                    snapshot = await this.snapshotAll({ signal });
+                    result = await this.events(snapshot.epoch, snapshot.revision, heartbeatMs, signal);
                 }
                 catch {
                     if (signal.aborted)
                         break;
+                    await invalidate('disconnect');
                     await retry();
                     continue;
                 }
-                await onSnapshot(snapshot);
-            }
-            let result;
-            try {
-                result = await this.events(snapshot.epoch, snapshot.revision, 30_000, signal);
-            }
-            catch {
-                if (signal.aborted)
-                    break;
-                snapshot = undefined;
-                await retry();
-                continue;
-            }
-            if (result.resyncRequired || result.epoch !== snapshot.epoch) {
-                snapshot = undefined;
-                continue;
+                if (result.resyncRequired || result.epoch !== snapshot.epoch
+                    || (result.events.length === 0 && result.revision !== snapshot.revision)) {
+                    await invalidate('resync');
+                    continue;
+                }
+                if (result.events.length) {
+                    let fresh;
+                    try {
+                        fresh = await this.snapshotAll({ signal });
+                    }
+                    catch {
+                        if (signal.aborted)
+                            break;
+                        await invalidate('disconnect');
+                        await retry();
+                        continue;
+                    }
+                    if (fresh.epoch !== result.epoch || fresh.revision < result.revision) {
+                        await invalidate('resync');
+                        continue;
+                    }
+                    snapshot = fresh;
+                    await onSnapshot(fresh);
+                    for (const event of result.events)
+                        await onEvent(event);
+                    lastEpoch = fresh.epoch;
+                    lastRevision = fresh.revision;
+                    lastVerifiedAt = new Date().toISOString();
+                    await status('current', 'event');
+                }
+                else {
+                    lastVerifiedAt = new Date().toISOString();
+                    await status('current', 'heartbeat');
+                }
             }
-            for (const event of result.events)
-                await onEvent(event);
-            snapshot = { ...snapshot, revision: result.revision };
         }
+        finally {
+            available = false;
+            await status('closed', signal.aborted ? 'abort' : 'consumer_error');
+        }
+    }
+    async beginAddOpenAi(operationId, signal) {
+        return (await this.request('authswitch.authority.add', { operationId, providerId: 'openai', flow: 'device' }, 35_000, false, signal)).operation;
+    }
+    async beginReauthOpenAi(operationId, accountId, loginId, purpose, signal) {
+        return (await this.request('authswitch.authority.reauth', { operationId, accountId, loginId, purpose, flow: 'device' }, 35_000, false, signal)).operation;
     }
-    async beginAddOpenAi() {
-        return (await this.request('authswitch.authority.add', { providerId: 'openai', flow: 'device' })).operation;
+    listOperations(after, limit) {
+        return this.request('authswitch.authority.operations', { after, limit });
     }
-    async beginReauthOpenAi(accountId) {
-        return (await this.request('authswitch.authority.reauth', { accountId, flow: 'device' })).operation;
+    async getOperation(operationId, signal) {
+        return (await this.request('authswitch.authority.operation', { operationId }, 35_000, false, signal)).operation;
     }
-    async getOperation(operationId) {
-        return (await this.request('authswitch.authority.operation', { operationId })).operation;
+    async cancelOperation(operationId, signal) {
+        return (await this.request('authswitch.authority.cancel', { operationId }, 35_000, false, signal)).operation;
     }
-    async cancelOperation(operationId) {
-        return (await this.request('authswitch.authority.cancel', { operationId })).operation;
+    async startPreuse(input, signal) {
+        return (await this.request('authswitch.authority.preuse.start', input, 35_000, false, signal)).operation;
+    }
+    async getPreuse(operationId, signal) {
+        return (await this.request('authswitch.authority.preuse.operation', { operationId }, 35_000, false, signal)).operation;
+    }
+    async cancelPreuse(operationId, signal) {
+        return (await this.request('authswitch.authority.preuse.cancel', { operationId }, 35_000, false, signal)).operation;
     }
     async renameAccount(accountId, expectedRevision, label) {
         return (await this.request('authswitch.authority.rename', { accountId, expectedRevision, label })).account;
@@ -177,14 +260,26 @@ export class AuthSwitchClient {
     async removeAccount(accountId, expectedRevision) {
         return (await this.request('authswitch.authority.remove', { accountId, expectedRevision })).account;
     }
+    async switchClaudeNative(accountId, loginId) {
+        return (await this.request('authswitch.authority.claude.switch', { accountId, loginId, purpose: 'claude_host_native' })).handoff;
+    }
+    async getClaudeNativeHandoff(operationId) {
+        return (await this.request('authswitch.authority.claude.handoff', { operationId })).handoff;
+    }
+    listClaudeNativeHandoffs(after, limit) {
+        return this.request('authswitch.authority.claude.handoffs', { after, limit });
+    }
     bindAccount(input) {
         return this.request('authswitch.authority.bind', input);
     }
     resolveAccess(input) {
         return this.request('authswitch.authority.resolveAccess', input, 35_000, true);
     }
+    releaseBinding(input, signal) {
+        return this.request('authswitch.authority.release', input, 35_000, true, signal);
+    }
 }
-/** Container-facing client. It can only resolve a previously issued binding capability. */
+/** Container-facing client. It can only resolve or release a previously issued binding capability. */
 export class AuthSwitchRuntimeClient {
     target;
     constructor(runtimeSocketPath) {
@@ -196,5 +291,8 @@ export class AuthSwitchRuntimeClient {
     resolveAccess(input) {
         return new plugins.typedrequest.TypedRequest(this.target, 'authswitch.authority.resolveAccess').fire(input, { timeoutMs: 35_000, maxRetries: 0 });
     }
+    releaseBinding(input, signal) {
+        return new plugins.typedrequest.TypedRequest(this.target, 'authswitch.authority.release').fire(input, { timeoutMs: 35_000, maxRetries: 0, abortSignal: signal });
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityclient.js","sourceRoot":"","sources":["../ts/classes.authorityclient.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authorityclient.js","sourceRoot":"","sources":["../ts/classes.authorityclient.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.authoritydaemon.d.ts

@@ -1,23 +1,70 @@
 import { AuthSwitchAuthorityBroker, type IAuthSwitchAuthorityBrokerOptions } from './classes.authoritybroker.js';
 import { AuthSwitchAuthorityDatabase, type IAuthSwitchAuthorityDatabaseOptions } from './classes.authoritydatabase.js';
+import { ClaudeNativeAuthority, type IClaudeNativeAuthorityOptions } from './classes.claudeauthority.js';
+import { ClaudeAccountStatus } from './classes.claudestatus.js';
+import { AuthSwitchAuthorityUsage, type IAuthSwitchAuthorityUsageOptions } from './classes.authorityusage.js';
+import { AuthSwitchAuthorityPreuse, type IAuthSwitchAuthorityPreuseOptions } from './classes.authoritypreuse.js';
+import { AuthSwitchManagedCodex, type IAuthSwitchManagedCodexOptions } from './classes.codexmanaged.js';
 export interface IAuthSwitchAuthorityDaemonOptions extends IAuthSwitchAuthorityDatabaseOptions {
     authoritySocketPath: string;
     runtimeSocketPath: string;
     broker?: IAuthSwitchAuthorityBrokerOptions;
+    usage?: Partial<Pick<IAuthSwitchAuthorityUsageOptions, 'now' | 'currentMaxAgeMs' | 'maxStaleAgeMs' | 'minAttemptIntervalMs' | 'retryBaseMs' | 'retryMaxMs' | 'providerTimeoutMs' | 'minAccessValidityMs'>>;
+    preuse?: IAuthSwitchAuthorityPreuseOptions;
+    claudeStatus?: ClaudeAccountStatus;
+    /** Activated only after a verified backend source receipt has registered the native home. */
+    claudeNative?: IClaudeNativeAuthorityOptions;
 }
 /** TypedRequest handlers over a private one-request-per-connection Unix socket. */
 export declare class AuthSwitchAuthorityDaemon {
     private readonly options;
     readonly database: AuthSwitchAuthorityDatabase;
     readonly broker: AuthSwitchAuthorityBroker;
+    readonly usage: AuthSwitchAuthorityUsage;
+    readonly preuse: AuthSwitchAuthorityPreuse;
+    readonly claudeNative?: ClaudeNativeAuthority;
     private readonly managementRouter;
     private readonly runtimeRouter;
     private managementServer?;
     private runtimeServer?;
     private readonly sockets;
+    private readonly managedCodex;
+    private readonly managedCodexHomes;
+    private readonly managedCodexAccountIds;
+    private readonly managedCodexStates;
+    private readonly drainingAccounts;
+    private readonly deviceDrainOwners;
+    private readonly preuseAccounts;
+    private readonly managedCodexStops;
+    private readonly managedCodexFailures;
+    private readonly runtimeBindingActivity;
+    private readonly runtimeBindingReleaseFences;
+    private readonly runtimeBindingReleases;
+    private closing;
     constructor(options: IAuthSwitchAuthorityDaemonOptions);
+    private runtimeBindingKey;
+    private beginRuntimeBindingAccess;
+    private waitForRuntimeBindingAccess;
+    private releaseRuntimeBinding;
+    private releaseDeviceDrain;
+    private beginReauthOpenAi;
     private register;
+    private doctorPage;
     start(): Promise<void>;
+    /** The account fence excludes new admissions while durable detached runs are checked. */
+    private drainManagedCodexAccount;
+    startManagedCodex(input: {
+        accountId: string;
+        loginId: string;
+        purpose: 'openai_managed';
+        scopeId: string;
+        workspaceDirectory: string;
+        codexHomeDirectory: string;
+        executable?: string;
+        onNotification?: IAuthSwitchManagedCodexOptions['onNotification'];
+        onServerRequest?: IAuthSwitchManagedCodexOptions['onServerRequest'];
+    }): Promise<AuthSwitchManagedCodex>;
+    stopManagedCodex(scopeId: string): Promise<void>;
     private listen;
     /** A killed daemon leaves a pathname behind; only remove an unchanged, owned, refused Unix socket. */
     private clearStaleSocket;