@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.credentialstore.d.ts

@@ -0,0 +1,32 @@
+export declare const credentialRecord: (value: unknown) => Record<string, unknown>;
+export declare const credentialText: (value: unknown) => string | undefined;
+export declare const credentialHash: (value: string) => string;
+/** A bounded file read; malformed secrets never become parser diagnostics in the CLI. */
+export declare const readCredentialDocument: (file: string) => {
+    raw: string | null;
+    data: Record<string, unknown>;
+};
+export interface IStoredCredential {
+    schemaVersion: 1;
+    id: string;
+    slotId: string;
+    identity: string;
+    label: string;
+    savedAt: string;
+    /** Harness-owned payload. This object must never cross the public account interface. */
+    credential: Record<string, unknown>;
+}
+/** A single atomic, owner-only record keeps the saved credential and its identity together. */
+export declare class CredentialStore {
+    readonly dir: string;
+    constructor(harness: string, root?: string);
+    id(slot: string, identity: string): string;
+    private file;
+    read(id: string): IStoredCredential;
+    list(): IStoredCredential[];
+    save(entry: Omit<IStoredCredential, 'schemaVersion' | 'id' | 'savedAt'>): IStoredCredential;
+    remove(id: string): void;
+    locked<T>(action: () => T): T;
+}
+/** Native harnesses retain credentials and may refresh them. Refuse writes while one is running. */
+export declare const requireHarnessStopped: (binary: "opencode" | "claude") => void;

package/dist_ts/classes.credentialstore.js

@@ -0,0 +1,115 @@
+import * as plugins from './plugins.js';
+import { writeSecretFileAtomically } from './helpers.js';
+export const credentialRecord = (value) => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Unsupported credential document.');
+    return value;
+};
+export const credentialText = (value) => typeof value === 'string' && value.length > 0 ? value : undefined;
+export const credentialHash = (value) => plugins.crypto.createHash('sha256').update(value).digest('hex');
+/** A bounded file read; malformed secrets never become parser diagnostics in the CLI. */
+export const readCredentialDocument = (file) => {
+    let fd;
+    try {
+        fd = plugins.fs.openSync(file, plugins.fs.constants.O_RDONLY | plugins.fs.constants.O_NONBLOCK);
+        const stat = plugins.fs.fstatSync(fd);
+        if (!stat.isFile() || stat.size > 4 * 1024 * 1024)
+            throw new Error();
+        const buffer = Buffer.alloc(4 * 1024 * 1024 + 1);
+        let size = 0;
+        while (size < buffer.length) {
+            const count = plugins.fs.readSync(fd, buffer, size, buffer.length - size, null);
+            if (!count)
+                break;
+            size += count;
+        }
+        if (size === buffer.length)
+            throw new Error();
+        const raw = buffer.subarray(0, size).toString('utf8');
+        return { raw, data: credentialRecord(JSON.parse(raw)) };
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { raw: null, data: {} };
+        throw new Error('Credential file is unreadable, malformed, or too large; no changes were made.');
+    }
+    finally {
+        if (fd !== undefined)
+            plugins.fs.closeSync(fd);
+    }
+};
+/** A single atomic, owner-only record keeps the saved credential and its identity together. */
+export class CredentialStore {
+    dir;
+    constructor(harness, root = process.env.AUTHSWITCH_HOME || plugins.path.join(plugins.os.homedir(), '.authswitch')) {
+        this.dir = plugins.path.join(root, harness);
+    }
+    id(slot, identity) { return credentialHash(JSON.stringify([slot, identity])); }
+    file(id) {
+        if (!/^[a-f0-9]{64}$/.test(id))
+            throw new Error('Invalid saved account ID.');
+        return plugins.path.join(this.dir, `${id}.json`);
+    }
+    read(id) {
+        const value = readCredentialDocument(this.file(id)).data;
+        if (value.schemaVersion !== 1 || value.id !== id || !credentialText(value.slotId) || !credentialText(value.identity)
+            || !credentialText(value.label) || typeof value.savedAt !== 'string' || !Number.isFinite(Date.parse(value.savedAt))
+            || this.id(value.slotId, value.identity) !== id)
+            throw new Error('Saved account metadata is invalid; restore it from a verified backup.');
+        credentialRecord(value.credential);
+        return value;
+    }
+    list() {
+        if (!plugins.fs.existsSync(this.dir))
+            return [];
+        return plugins.fs.readdirSync(this.dir).filter(name => /^[a-f0-9]{64}\.json$/.test(name))
+            .map(name => this.read(name.slice(0, -5))).sort((a, b) => b.savedAt.localeCompare(a.savedAt));
+    }
+    save(entry) {
+        const record = { ...entry, schemaVersion: 1, id: this.id(entry.slotId, entry.identity), savedAt: new Date().toISOString() };
+        plugins.fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        plugins.fs.chmodSync(this.dir, 0o700);
+        const raw = JSON.stringify(record, null, 2) + '\n';
+        writeSecretFileAtomically(this.file(record.id), raw);
+        if (readCredentialDocument(this.file(record.id)).raw !== raw)
+            throw new Error('Saved credential verification failed; the active login was preserved.');
+        return this.read(record.id);
+    }
+    remove(id) { this.read(id); plugins.fs.unlinkSync(this.file(id)); }
+    locked(action) {
+        plugins.fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+        const file = plugins.path.join(this.dir, '.lock');
+        let fd;
+        try {
+            fd = plugins.fs.openSync(file, 'wx', 0o600);
+        }
+        catch {
+            throw new Error(`Account storage is locked. Close other authswitch operations; if none remain, remove ${file}.`);
+        }
+        try {
+            return action();
+        }
+        finally {
+            plugins.fs.closeSync(fd);
+            plugins.fs.unlinkSync(file);
+        }
+    }
+}
+/** Native harnesses retain credentials and may refresh them. Refuse writes while one is running. */
+export const requireHarnessStopped = (binary) => {
+    let names;
+    try {
+        if (process.platform === 'win32') {
+            names = plugins.childProcess.execFileSync('tasklist', ['/FO', 'CSV', '/NH'], { encoding: 'utf8', timeout: 5000 }).split('\n').map(line => line.split('",')[0].replace(/^"/, ''));
+        }
+        else {
+            names = plugins.childProcess.execFileSync('ps', ['-u', String(process.getuid()), '-o', 'comm='], { encoding: 'utf8', timeout: 5000 }).split('\n').map(line => plugins.path.basename(line.trim()));
+        }
+    }
+    catch {
+        throw new Error(`Could not verify that ${binary} is stopped. No login was changed.`);
+    }
+    if (names.some(name => name === binary || name === `${binary}.exe`))
+        throw new Error(`Exit running ${binary} processes before saving or switching credentials, then start ${binary} again.`);
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.credentialstore.js","sourceRoot":"","sources":["../ts/classes.credentialstore.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.fileharness.d.ts

@@ -0,0 +1,47 @@
+import type { IAuthHarness, IHarnessAccountStatus, IHarnessOutcome, IHarnessState } from './interfaces.harness.js';
+import { CredentialStore } from './classes.credentialstore.js';
+export interface IFileAccount {
+    slotId: string;
+    identity: string;
+    label: string;
+    credential: Record<string, unknown>;
+}
+export interface IFileHarnessSnapshot {
+    accounts: IFileAccount[];
+    unavailable: string | null;
+}
+/** Shared verified preservation for harnesses with independently replaceable credential slots. */
+export declare abstract class FileHarness implements IAuthHarness {
+    abstract readonly id: string;
+    abstract readonly label: string;
+    abstract readonly loginHint: string;
+    readonly diagnosticsLabel = "Check credential storage and account availability";
+    protected abstract readonly store: CredentialStore;
+    protected abstract snapshot(): IFileHarnessSnapshot;
+    protected abstract apply(slotId: string, previous: IFileAccount | undefined, target: IFileAccount | undefined): void;
+    protected abstract beforeMutation(): void;
+    protected abstract inspect(credential: Record<string, unknown>, slotId: string): IFileAccount;
+    abstract readAccountStatus(id: string): Promise<IHarnessAccountStatus>;
+    private saved;
+    readState(): IHarnessState;
+    protected readCredential(id: string): IFileAccount;
+    /** Save a newly authenticated credential without changing a native harness's login. */
+    importCredential(slotId: string, credential: Record<string, unknown>): {
+        accountId: string;
+    };
+    /** Backend-only login handoff. Preserve the outgoing credential before replacing its slot. */
+    activateCredential(slotId: string, credential: Record<string, unknown>): IHarnessOutcome;
+    resolveAccount(reference: string): {
+        id: string;
+    } | {
+        candidates: string[];
+    };
+    private outcome;
+    saveCurrent(options: {
+        keepActive: boolean;
+        accountId?: string;
+    }): IHarnessOutcome;
+    switchAccount(id: string): IHarnessOutcome;
+    removeAccount(id: string): IHarnessOutcome;
+    diagnose(): IHarnessOutcome;
+}

package/dist_ts/classes.fileharness.js

@@ -0,0 +1,119 @@
+import { CredentialStore } from './classes.credentialstore.js';
+import { plainText } from './formatting.js';
+/** Shared verified preservation for harnesses with independently replaceable credential slots. */
+export class FileHarness {
+    diagnosticsLabel = 'Check credential storage and account availability';
+    saved(entry) {
+        const account = this.inspect(entry.credential, entry.slotId);
+        if (account.identity !== entry.identity)
+            throw new Error('Saved credential does not match its account identity.');
+        return account;
+    }
+    readState() {
+        const snapshot = this.snapshot();
+        const saved = this.store.list();
+        const accounts = saved.map(entry => {
+            this.saved(entry);
+            return { id: entry.id, slotId: entry.slotId, label: entry.label, isActive: false, isStashed: true, savedAt: entry.savedAt, details: [`Provider: ${entry.slotId}`] };
+        });
+        for (const active of snapshot.accounts) {
+            const id = this.store.id(active.slotId, active.identity);
+            const existing = accounts.find(account => account.id === id);
+            if (existing) {
+                existing.isActive = true;
+                existing.label = active.label;
+            }
+            else
+                accounts.unshift({ id, slotId: active.slotId, label: active.label, isActive: true, isStashed: false, savedAt: null, details: [`Provider: ${active.slotId}`] });
+        }
+        for (const account of accounts) {
+            if (accounts.some(other => other.id !== account.id && other.label === account.label))
+                account.details.push(`Account ID: ${account.id}`);
+        }
+        return { accounts, saveUnavailableReason: snapshot.unavailable };
+    }
+    readCredential(id) {
+        const active = this.snapshot().accounts.find(account => this.store.id(account.slotId, account.identity) === id);
+        return active ?? this.saved(this.store.read(id));
+    }
+    /** Save a newly authenticated credential without changing a native harness's login. */
+    importCredential(slotId, credential) {
+        return this.store.locked(() => ({ accountId: this.store.save(this.inspect(credential, slotId)).id }));
+    }
+    /** Backend-only login handoff. Preserve the outgoing credential before replacing its slot. */
+    activateCredential(slotId, credential) {
+        return this.outcome(() => {
+            this.beforeMutation();
+            const target = this.inspect(credential, slotId);
+            const snapshot = this.snapshot();
+            if (snapshot.unavailable)
+                throw new Error(snapshot.unavailable);
+            const previous = snapshot.accounts.find(account => account.slotId === slotId);
+            if (previous)
+                this.store.save(previous);
+            this.apply(slotId, previous, target);
+            return `Activated ${plainText(target.label)} (${plainText(slotId)}).`;
+        });
+    }
+    resolveAccount(reference) {
+        const accounts = this.store.list();
+        const exact = accounts.filter(account => account.id === reference || account.label.toLowerCase() === reference.toLowerCase()
+            || `${account.slotId}:${account.label}`.toLowerCase() === reference.toLowerCase());
+        const matches = exact.length ? exact : accounts.filter(account => account.label.toLowerCase().startsWith(reference.toLowerCase()));
+        return matches.length === 1 ? { id: matches[0].id } : { candidates: matches.map(account => `${account.slotId}:${account.label} (${account.id})`) };
+    }
+    outcome(action) {
+        try {
+            return this.store.locked(() => ({ lines: [action()], problems: [] }));
+        }
+        catch (error) {
+            return { lines: [], problems: [error instanceof Error ? error.message : 'Credential operation failed.'] };
+        }
+    }
+    saveCurrent(options) {
+        return this.outcome(() => {
+            this.beforeMutation();
+            const snapshot = this.snapshot();
+            if (snapshot.unavailable)
+                throw new Error(snapshot.unavailable);
+            const matches = snapshot.accounts.filter(account => !options.accountId || this.store.id(account.slotId, account.identity) === options.accountId || account.slotId === options.accountId || account.label === options.accountId);
+            if (matches.length !== 1)
+                throw new Error(matches.length ? 'Several logins are active. Select the account or provider to save.' : 'No matching active login to save.');
+            const active = matches[0];
+            this.store.save(active);
+            if (!options.keepActive)
+                this.apply(active.slotId, active, undefined);
+            return `Saved ${plainText(active.label)} (${plainText(active.slotId)})${options.keepActive ? '; login remains in place.' : `. Start ${this.label} to log in again.`}`;
+        });
+    }
+    switchAccount(id) {
+        return this.outcome(() => {
+            this.beforeMutation();
+            const target = this.saved(this.store.read(id));
+            const snapshot = this.snapshot();
+            if (snapshot.unavailable)
+                throw new Error(snapshot.unavailable);
+            const previous = snapshot.accounts.find(account => account.slotId === target.slotId);
+            // Refresh the outgoing stash even when this account was already saved.
+            if (previous)
+                this.store.save(previous);
+            if (previous?.identity === target.identity)
+                return `${plainText(target.label)} is already active; its latest credential is saved.`;
+            this.apply(target.slotId, previous, target);
+            return `Activated ${plainText(target.label)} (${plainText(target.slotId)}). Start ${this.label} to use it.`;
+        });
+    }
+    removeAccount(id) {
+        return this.outcome(() => { const account = this.store.read(id); this.store.remove(id); return `Removed saved login for ${plainText(account.label)}; the active login is preserved.`; });
+    }
+    diagnose() {
+        try {
+            const state = this.readState();
+            return { lines: [`${this.label}: ${state.accounts.filter(account => account.isActive).length} active login(s), ${state.accounts.filter(account => account.isStashed).length} saved account(s).`, this.loginHint], problems: state.saveUnavailableReason ? [state.saveUnavailableReason] : [] };
+        }
+        catch {
+            return { lines: [], problems: ['Credential storage could not be verified. Check file permissions and saved credential records.'] };
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.fileharness.js","sourceRoot":"","sources":["../ts/classes.fileharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.login.d.ts

@@ -0,0 +1,42 @@
+import * as plugins from './plugins.js';
+import type { IHarnessLoginHandle, IHarnessLoginOptions, IHarnessLoginResult } from './interfaces.harness.js';
+export type TAuthLoginFlow = plugins.flexAccounts.TSmartAiProviderLoginFlow;
+export type TAuthLoginCredential = plugins.flexAccounts.TSmartAiProviderCredential;
+export type TAuthLoginPrompt = plugins.flexAccounts.TSmartAiProviderLoginPrompt;
+export interface IAuthLoginResult extends plugins.flexAccounts.ISmartAiProviderLoginResult {
+}
+export interface IAuthLoginHandle extends plugins.flexAccounts.ISmartAiProviderLoginHandle {
+}
+export interface IAuthLoginProvider extends Pick<plugins.flexAccounts.ISmartAiProviderAdapter, 'descriptor' | 'beginLogin' | 'dispose'> {
+}
+export interface IAuthLoginOptions extends plugins.flexAccounts.ISmartAiProviderLoginOptions {
+    providerId: string;
+}
+export interface IAuthSwitchLoginOptions {
+    /** False when an enclosing provider registry owns disposal of injected adapters. */
+    disposeProviders?: boolean;
+}
+/** Shared login owner for terminal and hosted UIs. Credential results stay on the backend. */
+export declare class AuthSwitchLogin {
+    private readonly options;
+    private readonly providers;
+    private pending;
+    private closed;
+    private closing?;
+    private readonly handles;
+    constructor(providers?: IAuthLoginProvider[], options?: IAuthSwitchLoginOptions);
+    listProviders(): plugins.flexAccounts.ISmartAiProviderDescriptor[];
+    beginLogin(options: IAuthLoginOptions): Promise<IAuthLoginHandle>;
+    close(): Promise<void>;
+    private closeOwnedResources;
+}
+/** A hosted or terminal UI sees only the prompt and saved-account outcome. */
+export declare const beginSavedOpenAiLogin: (save: (result: IAuthLoginResult) => IHarnessLoginResult, options: IHarnessLoginOptions, fetcher?: typeof fetch) => Promise<IHarnessLoginHandle>;
+/** Convert a verified OpenAI login for native OpenCode without exposing it in public account DTOs. */
+export declare const openCodeCredentialFromLogin: (credential: plugins.flexAccounts.IOpenAiChatGptOAuthCredential) => {
+    type: "oauth";
+    access: string;
+    refresh: string;
+    expires: number;
+    accountId?: string;
+};

package/dist_ts/classes.login.js

@@ -0,0 +1,102 @@
+import * as plugins from './plugins.js';
+/** Shared login owner for terminal and hosted UIs. Credential results stay on the backend. */
+export class AuthSwitchLogin {
+    options;
+    providers = new Map();
+    pending = 0;
+    closed = false;
+    closing;
+    handles = new Set();
+    constructor(providers = [new plugins.flexAccounts.OpenAiProviderAdapter()], options = {}) {
+        this.options = options;
+        for (const provider of providers) {
+            if (this.providers.has(provider.descriptor.providerId))
+                throw new Error('Duplicate login provider.');
+            this.providers.set(provider.descriptor.providerId, provider);
+        }
+    }
+    listProviders() {
+        return [...this.providers.values()].map(provider => ({ ...provider.descriptor, loginFlows: [...provider.descriptor.loginFlows] }));
+    }
+    async beginLogin(options) {
+        if (this.closed)
+            throw new Error('Login service is closed.');
+        const provider = this.providers.get(options.providerId);
+        if (!provider?.descriptor.loginFlows.includes(options.flow))
+            throw new Error('This provider does not support the requested login flow.');
+        if (this.pending + this.handles.size >= 8)
+            throw new Error('Too many pending logins. Complete or cancel an existing login first.');
+        this.pending++;
+        try {
+            const handle = await provider.beginLogin(options);
+            if (this.closed) {
+                await handle.close();
+                throw new Error('Login service is closed.');
+            }
+            this.handles.add(handle);
+            // Keep cancellation/close ownership until the consumer has persisted the secret result.
+            return {
+                prompt: handle.prompt,
+                completion: handle.completion,
+                cancel: () => handle.cancel(),
+                close: async () => { await handle.close(); this.handles.delete(handle); },
+            };
+        }
+        catch {
+            throw new Error('Provider login could not be started.');
+        }
+        finally {
+            this.pending--;
+        }
+    }
+    close() { return this.closing ??= this.closeOwnedResources(); }
+    async closeOwnedResources() {
+        this.closed = true;
+        const results = await Promise.allSettled([...this.handles].map(handle => handle.close()));
+        const disposed = this.options.disposeProviders === false ? [] : await Promise.allSettled([...this.providers.values()].map(provider => provider.dispose()));
+        if ([...results, ...disposed].some(result => result.status === 'rejected'))
+            throw new Error('Provider login cleanup failed.');
+        this.handles.clear();
+    }
+}
+/** A hosted or terminal UI sees only the prompt and saved-account outcome. */
+export const beginSavedOpenAiLogin = async (save, options, fetcher) => {
+    if (options.providerId !== 'openai' || options.flow !== 'device')
+        throw new Error('This harness supports OpenAI device login.');
+    const service = new AuthSwitchLogin([new plugins.flexAccounts.OpenAiProviderAdapter({ fetch: fetcher })]);
+    try {
+        const handle = await service.beginLogin({ providerId: 'openai', flow: 'device' });
+        const completion = handle.completion.then(save).catch(() => ({
+            outcome: { lines: [], problems: ['Login did not complete or its saved credential could not be verified. The active login was preserved.'] },
+        })).finally(() => service.close());
+        return { prompt: handle.prompt, completion, cancel: async () => { await handle.cancel(); }, close: () => service.close() };
+    }
+    catch {
+        await service.close();
+        throw new Error('Provider login could not be started.');
+    }
+};
+/** Convert a verified OpenAI login for native OpenCode without exposing it in public account DTOs. */
+export const openCodeCredentialFromLogin = (credential) => {
+    try {
+        const auth = plugins.flexAccounts.toOpenAiChatGptAuthCredentials(credential);
+        const payload = credential.accessToken.split('.')[1];
+        let expires = 0;
+        if (payload && payload.length <= 48 * 1024) {
+            try {
+                const claims = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+                expires = typeof claims?.exp === 'number' ? claims.exp * 1000 : 0;
+            }
+            catch { /* Opaque access tokens are valid; native OpenCode refreshes an unknown expiry. */ }
+        }
+        return {
+            type: 'oauth', access: credential.accessToken, refresh: credential.refreshToken,
+            expires: Number.isSafeInteger(expires) && expires >= 0 ? expires : 0,
+            ...(auth.accountId ? { accountId: auth.accountId } : {}),
+        };
+    }
+    catch {
+        throw new Error('OpenAI login credential is invalid.');
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.opencodeharness.d.ts

@@ -0,0 +1,34 @@
+import { FileHarness, type IFileAccount, type IFileHarnessSnapshot } from './classes.fileharness.js';
+import { CredentialStore } from './classes.credentialstore.js';
+import type { IHarnessAccountStatus, IHarnessLoginOptions, IHarnessLoginProvider } from './interfaces.harness.js';
+export interface IOpenCodeHarnessOptions {
+    dataHome?: string;
+    stashRoot?: string;
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+    /** Process inspection dependency, injectable for isolated installations and tests. */
+    checkStopped?: () => void;
+}
+/** OpenCode owns one login per provider. Replacing a slot never replaces the whole provider set. */
+export declare class OpenCodeHarness extends FileHarness {
+    readonly id = "opencode";
+    readonly label = "OpenCode";
+    readonly loginHint = "Use authswitch opencode login for OpenAI; use opencode auth login for other providers.";
+    readonly loginProviders: IHarnessLoginProvider[];
+    protected readonly store: CredentialStore;
+    private readonly file;
+    private readonly env;
+    private readonly status;
+    private readonly checkStopped;
+    private readonly fetcher?;
+    constructor(options?: IOpenCodeHarnessOptions);
+    protected beforeMutation(): void;
+    /** Public identity only, for reconciling a host's OpenAI association after native refresh/restart. */
+    activeOpenAiAccountId(): string | undefined;
+    beginLogin(options?: IHarnessLoginOptions): Promise<import("./interfaces.harness.js").IHarnessLoginHandle>;
+    private openAiInfo;
+    protected inspect(credential: Record<string, unknown>, slotId: string): IFileAccount;
+    protected snapshot(): IFileHarnessSnapshot;
+    protected apply(slotId: string, previous: IFileAccount | undefined, target: IFileAccount | undefined): void;
+    readAccountStatus(id: string): Promise<IHarnessAccountStatus>;
+}