@modelprofile.com/authswitch 6.3.0 → 6.4.0

package/dist_ts/classes.authorityclient.d.ts

@@ -0,0 +1,34 @@
+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';
+/** Node-only client for the per-user daemon. Each request has its own bounded Unix connection. */
+export declare class AuthSwitchClient {
+    readonly socketPath: string;
+    readonly runtimeSocketPath: string;
+    private readonly target;
+    private readonly runtimeTarget;
+    constructor(socketPath: string, runtimeSocketPath: string);
+    private request;
+    snapshot(options?: IReq_AuthSwitchSnapshot['request'], signal?: AbortSignal): Promise<IAuthSwitchSnapshot>;
+    /** 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']>;
+    renameAccount(accountId: string, expectedRevision: number, label: string): Promise<IReq_AuthSwitchRenameAccount['response']['account']>;
+    removeAccount(accountId: string, expectedRevision: number): Promise<IReq_AuthSwitchRemoveAccount['response']['account']>;
+    bindAccount(input: IReq_AuthSwitchBindAccount['request']): Promise<IReq_AuthSwitchBindAccount['response']>;
+    resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']>;
+}
+/** Container-facing client. It can only resolve a previously issued binding capability. */
+export declare class AuthSwitchRuntimeClient {
+    private readonly target;
+    constructor(runtimeSocketPath: string);
+    resolveAccess(input: IReq_AuthSwitchResolveAccess['request']): Promise<IReq_AuthSwitchResolveAccess['response']>;
+}

package/dist_ts/classes.authorityclient.js

@@ -0,0 +1,200 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityFrameReader, authSwitchAuthorityFrameBytes, maxAuthSwitchAuthorityFrameBytes } from './classes.authorityframing.js';
+const post = (path, payload, signal) => {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(signal.reason);
+            return;
+        }
+        const socket = plugins.net.createConnection(path);
+        let settled = false;
+        const frame = new AuthSwitchAuthorityFrameReader();
+        const finish = (error, response) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', abort);
+            socket.destroy();
+            if (error)
+                reject(error);
+            else if (response)
+                resolve(response);
+            else
+                reject(new Error('Authswitch daemon returned no response.'));
+        };
+        const abort = () => finish(signal?.reason ?? new Error('Account request was cancelled.'));
+        signal?.addEventListener('abort', abort, { once: true });
+        socket.setTimeout(35_000, () => finish(new Error('Authswitch daemon request timed out.')));
+        socket.on('connect', () => {
+            const raw = JSON.stringify(payload);
+            if (authSwitchAuthorityFrameBytes(raw) > maxAuthSwitchAuthorityFrameBytes) {
+                finish(new Error('Account request is too large.'));
+                return;
+            }
+            socket.write(raw + '\n');
+        });
+        socket.on('data', chunk => {
+            if (!Buffer.isBuffer(chunk)) {
+                finish(new Error('Account response must be a byte frame.'));
+                return;
+            }
+            let input;
+            try {
+                input = frame.add(chunk);
+            }
+            catch (error) {
+                finish(error);
+                return;
+            }
+            if (input === null)
+                return;
+            try {
+                finish(undefined, JSON.parse(input));
+            }
+            catch {
+                finish(new Error('Account response could not be decoded.'));
+            }
+        });
+        socket.on('error', () => finish(new Error('Authswitch daemon is unavailable.')));
+        socket.on('close', () => finish(new Error('Authswitch daemon connection closed before its response.')));
+    });
+};
+/** Node-only client for the per-user daemon. Each request has its own bounded Unix connection. */
+export class AuthSwitchClient {
+    socketPath;
+    runtimeSocketPath;
+    target;
+    runtimeTarget;
+    constructor(socketPath, runtimeSocketPath) {
+        this.socketPath = socketPath;
+        this.runtimeSocketPath = runtimeSocketPath;
+        this.target = new plugins.typedrequest.TypedTarget({
+            supportsAbortSignal: true,
+            postMethod: (payload, options) => post(this.socketPath, payload, options?.signal),
+        });
+        this.runtimeTarget = new plugins.typedrequest.TypedTarget({
+            supportsAbortSignal: true,
+            postMethod: (payload, options) => post(this.runtimeSocketPath, payload, options?.signal),
+        });
+    }
+    request(method, request, timeoutMs = 35_000, runtime = false, signal) {
+        return new plugins.typedrequest.TypedRequest(runtime ? this.runtimeTarget : this.target, method)
+            .fire(request, { timeoutMs, maxRetries: 0, abortSignal: signal });
+    }
+    async snapshot(options = {}, signal) {
+        return (await this.request('authswitch.authority.snapshot', options, 35_000, false, signal)).snapshot;
+    }
+    /** 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 bindingAfter;
+            let aggregate;
+            let changed = false;
+            while (true) {
+                const page = await this.snapshot({ accountAfter, bindingAfter, limit: options.limit }, options.signal);
+                if (!aggregate)
+                    aggregate = { ...page, accounts: [...page.accounts], bindings: [...page.bindings] };
+                else if (aggregate.epoch !== page.epoch || aggregate.revision !== page.revision) {
+                    changed = true;
+                    break;
+                }
+                else {
+                    aggregate.accounts.push(...page.accounts);
+                    aggregate.bindings.push(...page.bindings);
+                }
+                accountAfter = page.nextAccountCursor ?? accountAfter ?? page.accounts.at(-1)?.id;
+                bindingAfter = page.nextBindingCursor ?? bindingAfter ?? page.bindings.at(-1)?.id;
+                if (!page.nextAccountCursor && !page.nextBindingCursor) {
+                    return { ...aggregate, nextAccountCursor: null, nextBindingCursor: null };
+                }
+            }
+            if (!changed)
+                throw new Error('Authority snapshot could not complete.');
+        }
+    }
+    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) {
+        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) {
+                try {
+                    snapshot = await this.snapshotAll({ signal });
+                }
+                catch {
+                    if (signal.aborted)
+                        break;
+                    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;
+            }
+            for (const event of result.events)
+                await onEvent(event);
+            snapshot = { ...snapshot, revision: result.revision };
+        }
+    }
+    async beginAddOpenAi() {
+        return (await this.request('authswitch.authority.add', { providerId: 'openai', flow: 'device' })).operation;
+    }
+    async beginReauthOpenAi(accountId) {
+        return (await this.request('authswitch.authority.reauth', { accountId, flow: 'device' })).operation;
+    }
+    async getOperation(operationId) {
+        return (await this.request('authswitch.authority.operation', { operationId })).operation;
+    }
+    async cancelOperation(operationId) {
+        return (await this.request('authswitch.authority.cancel', { operationId })).operation;
+    }
+    async renameAccount(accountId, expectedRevision, label) {
+        return (await this.request('authswitch.authority.rename', { accountId, expectedRevision, label })).account;
+    }
+    async removeAccount(accountId, expectedRevision) {
+        return (await this.request('authswitch.authority.remove', { accountId, expectedRevision })).account;
+    }
+    bindAccount(input) {
+        return this.request('authswitch.authority.bind', input);
+    }
+    resolveAccess(input) {
+        return this.request('authswitch.authority.resolveAccess', input, 35_000, true);
+    }
+}
+/** Container-facing client. It can only resolve a previously issued binding capability. */
+export class AuthSwitchRuntimeClient {
+    target;
+    constructor(runtimeSocketPath) {
+        this.target = new plugins.typedrequest.TypedTarget({
+            supportsAbortSignal: true,
+            postMethod: (payload, options) => post(runtimeSocketPath, payload, options?.signal),
+        });
+    }
+    resolveAccess(input) {
+        return new plugins.typedrequest.TypedRequest(this.target, 'authswitch.authority.resolveAccess').fire(input, { timeoutMs: 35_000, maxRetries: 0 });
+    }
+}
+//# 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

@@ -0,0 +1,26 @@
+import { AuthSwitchAuthorityBroker, type IAuthSwitchAuthorityBrokerOptions } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase, type IAuthSwitchAuthorityDatabaseOptions } from './classes.authoritydatabase.js';
+export interface IAuthSwitchAuthorityDaemonOptions extends IAuthSwitchAuthorityDatabaseOptions {
+    authoritySocketPath: string;
+    runtimeSocketPath: string;
+    broker?: IAuthSwitchAuthorityBrokerOptions;
+}
+/** TypedRequest handlers over a private one-request-per-connection Unix socket. */
+export declare class AuthSwitchAuthorityDaemon {
+    private readonly options;
+    readonly database: AuthSwitchAuthorityDatabase;
+    readonly broker: AuthSwitchAuthorityBroker;
+    private readonly managementRouter;
+    private readonly runtimeRouter;
+    private managementServer?;
+    private runtimeServer?;
+    private readonly sockets;
+    constructor(options: IAuthSwitchAuthorityDaemonOptions);
+    private register;
+    start(): Promise<void>;
+    private listen;
+    /** A killed daemon leaves a pathname behind; only remove an unchanged, owned, refused Unix socket. */
+    private clearStaleSocket;
+    private accept;
+    close(): Promise<void>;
+}

package/dist_ts/classes.authoritydaemon.js

@@ -0,0 +1,249 @@
+import * as plugins from './plugins.js';
+import { AuthSwitchAuthorityBroker } from './classes.authoritybroker.js';
+import { AuthSwitchAuthorityDatabase } from './classes.authoritydatabase.js';
+import { AuthSwitchAuthorityFrameReader, authSwitchAuthorityFrameBytes, maxAuthSwitchAuthorityFrameBytes } from './classes.authorityframing.js';
+const hasKeys = (value, keys) => value !== null && typeof value === 'object' && !Array.isArray(value)
+    && Object.keys(value).length === keys.length && keys.every(key => Object.hasOwn(value, key));
+const invalid = () => { throw new plugins.typedrequest.TypedResponseError('Invalid authswitch authority request.'); };
+/** TypedRequest handlers over a private one-request-per-connection Unix socket. */
+export class AuthSwitchAuthorityDaemon {
+    options;
+    database;
+    broker;
+    managementRouter = new plugins.typedrequest.TypedRouter();
+    runtimeRouter = new plugins.typedrequest.TypedRouter();
+    managementServer;
+    runtimeServer;
+    sockets = new Set();
+    constructor(options) {
+        this.options = options;
+        this.database = new AuthSwitchAuthorityDatabase(options);
+        this.broker = new AuthSwitchAuthorityBroker(this.database, options.broker);
+        this.register();
+    }
+    register() {
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.snapshot', async (request) => {
+            if (request === null || typeof request !== 'object' || Array.isArray(request))
+                invalid();
+            const keys = Object.keys(request);
+            if (keys.some(key => !['accountAfter', 'bindingAfter', 'limit'].includes(key)))
+                invalid();
+            return { snapshot: await this.broker.snapshot(request) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.events', async (request, tools) => {
+            if (!hasKeys(request, ['epoch', 'afterRevision', 'waitMs']))
+                invalid();
+            return this.broker.events(request.epoch, request.afterRevision, request.waitMs, tools?.abortSignal);
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.add', async (request) => {
+            if (!hasKeys(request, ['providerId', 'flow']) || request.providerId !== 'openai' || request.flow !== 'device')
+                invalid();
+            return { operation: await this.broker.beginAddOpenAi() };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.reauth', async (request) => {
+            if (!hasKeys(request, ['accountId', 'flow']) || request.flow !== 'device' || typeof request.accountId !== 'string')
+                invalid();
+            return { operation: await this.broker.beginReauthOpenAi(request.accountId) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.operation', async (request) => {
+            if (!hasKeys(request, ['operationId']) || typeof request.operationId !== 'string')
+                invalid();
+            return { operation: this.broker.getOperation(request.operationId) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.cancel', async (request) => {
+            if (!hasKeys(request, ['operationId']) || typeof request.operationId !== 'string')
+                invalid();
+            return { operation: await this.broker.cancelOperation(request.operationId) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.rename', async (request) => {
+            if (!hasKeys(request, ['accountId', 'expectedRevision', 'label']) || typeof request.accountId !== 'string'
+                || typeof request.expectedRevision !== 'number' || typeof request.label !== 'string')
+                invalid();
+            return { account: await this.broker.renameAccount(request.accountId, request.expectedRevision, request.label) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.remove', async (request) => {
+            if (!hasKeys(request, ['accountId', 'expectedRevision']) || typeof request.accountId !== 'string'
+                || typeof request.expectedRevision !== 'number')
+                invalid();
+            return { account: await this.broker.removeAccount(request.accountId, request.expectedRevision) };
+        }));
+        this.managementRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.bind', async (request) => {
+            if (!hasKeys(request, ['accountId', 'runtime', 'scopeId', 'incarnationId'])
+                || typeof request.accountId !== 'string' || typeof request.scopeId !== 'string'
+                || typeof request.incarnationId !== 'string')
+                invalid();
+            return this.broker.bindAccount(request);
+        }));
+        this.runtimeRouter.addTypedHandler(new plugins.typedrequest.TypedHandler('authswitch.authority.resolveAccess', async (request) => {
+            if (!hasKeys(request, ['bindingId', 'capability', 'minValidityMs'])
+                || typeof request.bindingId !== 'string' || typeof request.capability !== 'string'
+                || typeof request.minValidityMs !== 'number')
+                invalid();
+            return this.broker.resolveAccess(request.bindingId, request.capability, request.minValidityMs);
+        }));
+    }
+    async start() {
+        if (this.managementServer || this.runtimeServer)
+            throw new Error('Authswitch authority daemon is already started.');
+        await this.database.start();
+        try {
+            await this.broker.start();
+            const managementDirectory = plugins.path.dirname(this.options.authoritySocketPath);
+            const runtimeDirectory = plugins.path.dirname(this.options.runtimeSocketPath);
+            const databaseDirectory = plugins.path.dirname(this.options.socketPath);
+            if (managementDirectory === runtimeDirectory || databaseDirectory === runtimeDirectory
+                || managementDirectory.startsWith(runtimeDirectory + plugins.path.sep)
+                || databaseDirectory.startsWith(runtimeDirectory + plugins.path.sep)
+                || runtimeDirectory.startsWith(managementDirectory + plugins.path.sep)
+                || runtimeDirectory.startsWith(databaseDirectory + plugins.path.sep)) {
+                throw new Error('Runtime socket directory must contain no management or database endpoint.');
+            }
+            this.managementServer = await this.listen(this.options.authoritySocketPath, this.managementRouter);
+            this.runtimeServer = await this.listen(this.options.runtimeSocketPath, this.runtimeRouter);
+        }
+        catch (error) {
+            try {
+                await this.close();
+            }
+            catch { /* Preserve startup failure. */ }
+            throw error;
+        }
+    }
+    async listen(path, router) {
+        const directory = plugins.path.dirname(path);
+        await plugins.fs.promises.mkdir(directory, { recursive: true, mode: 0o700 });
+        const stat = await plugins.fs.promises.lstat(directory);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || stat.uid !== process.getuid?.()) {
+            throw new Error('Authswitch authority socket directory is not private.');
+        }
+        await plugins.fs.promises.chmod(directory, 0o700);
+        await this.clearStaleSocket(path);
+        const server = plugins.net.createServer(socket => this.accept(socket, router));
+        try {
+            await new Promise((resolve, reject) => {
+                server.once('error', reject);
+                server.listen(path, () => { server.off('error', reject); resolve(); });
+            });
+            await plugins.fs.promises.chmod(path, 0o600);
+            return server;
+        }
+        catch (error) {
+            if (server.listening)
+                await new Promise(resolve => server.close(() => resolve()));
+            throw error;
+        }
+    }
+    /** A killed daemon leaves a pathname behind; only remove an unchanged, owned, refused Unix socket. */
+    async clearStaleSocket(path) {
+        let before;
+        try {
+            before = await plugins.fs.promises.lstat(path);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return;
+            throw error;
+        }
+        if (!before.isSocket() || before.uid !== process.getuid?.())
+            throw new Error('Authswitch socket path is unsafe.');
+        const refused = await new Promise((resolve, reject) => {
+            const probe = plugins.net.createConnection(path);
+            probe.setTimeout(1_000, () => { probe.destroy(); reject(new Error('Authswitch socket probe timed out.')); });
+            probe.once('connect', () => { probe.destroy(); resolve(false); });
+            probe.once('error', error => {
+                probe.destroy();
+                if (error.code === 'ECONNREFUSED')
+                    resolve(true);
+                else
+                    reject(error);
+            });
+        });
+        if (!refused)
+            throw new Error('Authswitch authority socket is already active.');
+        const after = await plugins.fs.promises.lstat(path);
+        if (!after.isSocket() || after.uid !== before.uid || after.dev !== before.dev || after.ino !== before.ino) {
+            throw new Error('Authswitch socket path changed during startup.');
+        }
+        await plugins.fs.promises.unlink(path);
+    }
+    accept(socket, router) {
+        this.sockets.add(socket);
+        const abort = new AbortController();
+        socket.on('close', () => { this.sockets.delete(socket); abort.abort(); });
+        const frame = new AuthSwitchAuthorityFrameReader();
+        let handled = false;
+        socket.setTimeout(35_000, () => socket.destroy());
+        socket.on('data', chunk => {
+            if (handled) {
+                socket.destroy();
+                return;
+            }
+            if (!Buffer.isBuffer(chunk)) {
+                socket.destroy();
+                return;
+            }
+            let input;
+            try {
+                input = frame.add(chunk);
+            }
+            catch {
+                socket.destroy();
+                return;
+            }
+            if (input === null)
+                return;
+            handled = true;
+            let request;
+            try {
+                request = JSON.parse(input);
+            }
+            catch {
+                socket.destroy();
+                return;
+            }
+            void router.routeAndAddResponse(request, { trustedLocalData: { authoritySocket: socket },
+                trustedAbortSignal: abort.signal })
+                .then(response => {
+                const raw = JSON.stringify(response);
+                if (authSwitchAuthorityFrameBytes(raw) > maxAuthSwitchAuthorityFrameBytes) {
+                    socket.destroy();
+                    return;
+                }
+                socket.end(raw + '\n');
+            }).catch(() => socket.destroy());
+        });
+    }
+    async close() {
+        const errors = [];
+        try {
+            await this.broker.close();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        const management = this.managementServer;
+        const runtime = this.runtimeServer;
+        this.managementServer = undefined;
+        this.runtimeServer = undefined;
+        for (const socket of this.sockets)
+            socket.destroy();
+        for (const server of [management, runtime]) {
+            if (server)
+                try {
+                    await new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()));
+                }
+                catch (error) {
+                    errors.push(error);
+                }
+        }
+        try {
+            await this.database.stop();
+        }
+        catch (error) {
+            errors.push(error);
+        }
+        if (errors.length)
+            throw new AggregateError(errors, 'Authswitch authority shutdown was incomplete.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.authoritydaemon.js","sourceRoot":"","sources":["../ts/classes.authoritydaemon.ts"],"names":[],"mappings":"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"}