@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.codexharness.js

@@ -0,0 +1,199 @@
+import { CodexSwitcher } from './classes.codexswitcher.js';
+import { CodexAccountStatus } from './classes.codexstatus.js';
+import { CodexPreuse } from './classes.codexpreuse.js';
+import { PreuseError } from './preuse.js';
+import { countPaired, enrollmentState } from './helpers.js';
+import { beginSavedOpenAiLogin } from './classes.login.js';
+import { plainText } from './formatting.js';
+/** Codex-specific credentials, remote-control handling and service status. */
+export class CodexHarness {
+    switcher;
+    accountStatus;
+    preuse;
+    id = 'codex';
+    label = 'Codex';
+    loginHint = 'Use authswitch codex login to sign in and save another account.';
+    loginProviders = [{ providerId: 'openai', label: 'OpenAI', flows: ['device'] }];
+    diagnosticsLabel = 'Check credential storage and remote control';
+    constructor(switcher = new CodexSwitcher(), accountStatus = new CodexAccountStatus(), preuse = new CodexPreuse()) {
+        this.switcher = switcher;
+        this.accountStatus = accountStatus;
+        this.preuse = preuse;
+    }
+    beginLogin(options = { providerId: 'openai', flow: 'device' }) {
+        return beginSavedOpenAiLogin(result => {
+            const credential = result.credential;
+            const raw = JSON.stringify({ auth_mode: 'chatgpt', OPENAI_API_KEY: null, tokens: {
+                    access_token: credential.accessToken, refresh_token: credential.refreshToken,
+                    id_token: credential.idToken, account_id: result.account.accountId,
+                }, last_refresh: new Date().toISOString() }, null, 2) + '\n';
+            const identity = this.switcher.auth.identityFromRaw(raw);
+            if (!identity)
+                throw new Error('The new login has no Codex account identity.');
+            const previous = this.switcher.stashes.readMeta(identity.email);
+            this.switcher.stashes.write(identity, raw, previous?.enrollments ?? [], this.switcher.home.dir);
+            if (!this.switcher.stashes.readBack(identity.email, raw))
+                throw new Error('The new Codex login could not be verified.');
+            return { outcome: { lines: [`Saved ${plainText(identity.email)}. Select it to switch Codex.`], problems: [] }, account: { id: identity.email, label: identity.email } };
+        }, options);
+    }
+    readState() {
+        const active = this.switcher.readActive();
+        const accounts = this.switcher.list().map((entryArg) => {
+            const raw = this.switcher.stashes.readAuth(entryArg.email);
+            const identity = raw === null ? null : this.switcher.auth.identityFromRaw(raw);
+            const valid = identity !== null && identity.email === entryArg.email && identity.accountId === entryArg.accountId && identity.kind === entryArg.kind;
+            const isActive = active.identity !== null && active.identity.email === entryArg.email && active.identity.accountId === entryArg.accountId && active.identity.kind === entryArg.kind;
+            const isStashed = valid && (!isActive || raw === active.raw);
+            return {
+                id: entryArg.email,
+                label: entryArg.email,
+                isActive,
+                isStashed,
+                savedAt: entryArg.stashedAt,
+                details: [this.formatRemoteControl(entryArg).trim(), ...(!valid ? ['saved credential missing or does not match its metadata'] : !isStashed ? ['the current login has changed since it was saved'] : [])],
+            };
+        });
+        if (active.identity && !accounts.some((accountArg) => accountArg.isActive)) {
+            accounts.unshift({ id: this.activeAccountId(active.identity.email, active.identity.accountId), label: active.identity.email, isActive: true,
+                isStashed: false, savedAt: null, details: [] });
+        }
+        return {
+            accounts,
+            saveUnavailableReason: active.source === 'keyring'
+                ? 'This login is stored in an OS keyring and cannot be saved by authswitch.'
+                : !active.identity ? 'No identifiable login to save. ' + this.loginHint
+                    : accounts.some((accountArg) => accountArg.label === active.identity.email && !accountArg.isActive)
+                        ? 'A different Codex account with this email is already saved. The email-based Codex store cannot keep both; refusing to replace it.' : null,
+        };
+    }
+    async readAccountStatus(accountIdArg) {
+        const credential = this.readAccountCredential(accountIdArg);
+        if (!credential)
+            return { facts: [], problems: ['No matching credential is available for status lookup.'] };
+        return this.accountStatus.read(credential.raw, credential.identity);
+    }
+    async preuseAccount(accountIdArg, optionsArg) {
+        const credential = this.readAccountCredential(accountIdArg);
+        if (!credential)
+            throw new PreuseError('No matching credential is available for preuse.');
+        return this.preuse.run(credential.raw, credential.identity, optionsArg);
+    }
+    readAccountCredential(accountIdArg) {
+        const active = this.switcher.readActive();
+        const meta = this.switcher.stashes.list().find((entryArg) => entryArg.email === accountIdArg);
+        // The active credential may have been refreshed since its last stash.
+        const useActive = active.identity && (this.activeAccountId(active.identity.email, active.identity.accountId) === accountIdArg ||
+            (meta && active.identity.email === meta.email && active.identity.accountId === meta.accountId && active.identity.kind === meta.kind));
+        const raw = useActive ? active.raw : meta ? this.switcher.stashes.readAuth(meta.email) : null;
+        const identity = raw === null ? null : this.switcher.auth.identityFromRaw(raw);
+        if (!identity || (!useActive && (!meta || identity.email !== meta.email || identity.accountId !== meta.accountId || identity.kind !== meta.kind))) {
+            return null;
+        }
+        return { raw: raw, identity };
+    }
+    activeAccountId(emailArg, accountIdArg) {
+        return JSON.stringify(['active', emailArg, accountIdArg]);
+    }
+    resolveAccount(referenceArg) {
+        const result = this.switcher.stashes.resolve(referenceArg);
+        return 'email' in result ? { id: result.email } : result;
+    }
+    switchAccount(accountIdArg) {
+        const result = this.switcher.use(accountIdArg);
+        return {
+            lines: [`switched ${result.from ? result.from + ' -> ' : ''}${result.to}`,
+                ...result.notes.map((noteArg) => '  ' + noteArg)],
+            problems: result.problems,
+        };
+    }
+    removeAccount(accountIdArg) {
+        const removed = this.switcher.drop(accountIdArg);
+        return { lines: [removed ? 'dropped ' + accountIdArg : 'nothing to drop'],
+            problems: removed ? [] : ['The saved account no longer exists.'] };
+    }
+    saveCurrent(optionsArg) {
+        const { keepActive } = optionsArg;
+        const lines = [];
+        const result = this.switcher.stash({ keepActive });
+        const entry = result.entry;
+        const paired = countPaired(entry.enrollments);
+        const enrollmentNote = paired > 0
+            ? `with ${paired} remote-control pairing(s)`
+            : entry.enrollments.length > 0
+                ? `with ${entry.enrollments.length} registered enrollment(s) but no pairing - run \`codex remote-control pair\` to make this account reachable`
+                : 'no remote-control enrollment found for this account';
+        lines.push(`stashed ${entry.email} ${enrollmentNote}\n`);
+        lines.push(keepActive
+            ? `the credential is still active\n`
+            : `the active credential slot is now empty - run \`codex login\` for another account\n`);
+        return { lines, problems: result.problems };
+    }
+    formatRemoteControl(listingArg) {
+        if (listingArg.enrollmentsPaired > 0) {
+            const unpaired = listingArg.enrollmentsTotal - listingArg.enrollmentsPaired;
+            const extra = unpaired > 0 ? ` +${unpaired} unpaired` : '';
+            return ` remote-control:${listingArg.enrollmentsPaired}${extra}`;
+        }
+        if (listingArg.enrollmentsTotal > 0) {
+            return ` remote-control:not paired (${listingArg.enrollmentsTotal} registered)`;
+        }
+        return ' remote-control:none';
+    }
+    diagnose() {
+        const active = this.switcher.readActive();
+        const lines = [];
+        lines.push(`codex home        ${this.switcher.home.dir}`);
+        lines.push(`state database    ${this.switcher.home.statePath ?? 'not found'}`);
+        lines.push(`stash directory   ${this.switcher.stashes.rootDir}`);
+        const incomplete = this.switcher.stashes.incomplete();
+        if (incomplete.length > 0) {
+            lines.push(`incomplete stashes ${incomplete.join(', ')} - a credential without metadata; remove the directory or re-stash the account`);
+        }
+        const sourceLabel = active.source === 'file'
+            ? 'file'
+            : active.source === 'keyring'
+                ? 'keyring (not switchable)'
+                : 'none';
+        lines.push(`credential store  ${sourceLabel}`);
+        lines.push(`active account    ${active.identity ? active.identity.email : 'none'}`);
+        const remoteAvailable = this.switcher.remoteControl.isAvailable();
+        lines.push(`enrollment table  ${remoteAvailable ? 'present' : 'missing'}`);
+        if (remoteAvailable) {
+            const all = this.switcher.remoteControl.read();
+            const paired = countPaired(all);
+            lines.push(`enrollments       ${all.length} (${paired} paired)`);
+            const activeAccountId = active.identity?.accountId ?? null;
+            for (const enrollmentArg of all) {
+                const state = enrollmentState(enrollmentArg);
+                const label = state === 'paired'
+                    ? 'paired'
+                    : state === 'disabled'
+                        ? 'disabled'
+                        : 'not paired';
+                const whose = activeAccountId !== null && enrollmentArg.accountId === activeAccountId
+                    ? ' this account'
+                    : ' another account';
+                lines.push(`  - ${enrollmentArg.serverName || '(unnamed)'} ${label}${whose} ${enrollmentArg.websocketUrl}`);
+            }
+            if (paired === 0 && all.length > 0) {
+                lines.push(`  note a registered enrollment is not a pairing - run \`codex remote-control pair\` to pair this machine`);
+            }
+        }
+        lines.push(`remote control    ${this.switcher.daemon.isRemoteControlEnabled() ? 'enabled for future starts' : 'disabled'}`);
+        const daemonStatus = this.switcher.daemon.status();
+        if (daemonStatus === null) {
+            const pid = this.switcher.daemon.daemonPid();
+            lines.push(`app-server        codex CLI unreachable${pid === null ? '' : ` (pid file says ${pid})`}`);
+        }
+        else if (daemonStatus.running) {
+            const pid = this.switcher.daemon.daemonPid();
+            lines.push(`app-server        running v${daemonStatus.appServerVersion ?? '?'}${pid === null ? '' : ` pid ${pid}`}`);
+        }
+        else {
+            lines.push(`app-server        not running`);
+        }
+        return { lines, problems: [] };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexharness.js","sourceRoot":"","sources":["../ts/classes.codexharness.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.codexhome.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Resolves the Codex home directory and every path inside it that authswitch touches.
+ *
+ * Codex honours the CODEX_HOME environment variable and falls back to ~/.codex.
+ * Every path is derived here so a test can point the whole tool at a fixture directory.
+ */
+export declare class CodexHome {
+    readonly dir: string;
+    constructor(dirArg?: string);
+    /** The file credential store. Present when Codex uses file storage rather than an OS keyring. */
+    get authFilePath(): string;
+    /** Directory holding the age-encrypted credential store used when a keyring backs the key. */
+    get secretsDir(): string;
+    get configPath(): string;
+    get appServerDaemonDir(): string;
+    get appServerSettingsPath(): string;
+    get appServerPidPath(): string;
+    /**
+     * Codex versions its state database by schema generation (state_5.sqlite today).
+     * Resolve the highest-numbered one that exists rather than hardcoding a number
+     * that a Codex upgrade would silently invalidate.
+     */
+    get statePath(): string | null;
+    exists(): boolean;
+}

package/dist_ts/classes.codexhome.js

@@ -0,0 +1,60 @@
+import * as plugins from './plugins.js';
+/**
+ * Resolves the Codex home directory and every path inside it that authswitch touches.
+ *
+ * Codex honours the CODEX_HOME environment variable and falls back to ~/.codex.
+ * Every path is derived here so a test can point the whole tool at a fixture directory.
+ */
+export class CodexHome {
+    dir;
+    constructor(dirArg) {
+        this.dir = dirArg ?? process.env.CODEX_HOME ?? plugins.path.join(plugins.os.homedir(), '.codex');
+    }
+    /** The file credential store. Present when Codex uses file storage rather than an OS keyring. */
+    get authFilePath() {
+        return plugins.path.join(this.dir, 'auth.json');
+    }
+    /** Directory holding the age-encrypted credential store used when a keyring backs the key. */
+    get secretsDir() {
+        return plugins.path.join(this.dir, 'secrets');
+    }
+    get configPath() {
+        return plugins.path.join(this.dir, 'config.toml');
+    }
+    get appServerDaemonDir() {
+        return plugins.path.join(this.dir, 'app-server-daemon');
+    }
+    get appServerSettingsPath() {
+        return plugins.path.join(this.appServerDaemonDir, 'settings.json');
+    }
+    get appServerPidPath() {
+        return plugins.path.join(this.appServerDaemonDir, 'app-server.pid');
+    }
+    /**
+     * Codex versions its state database by schema generation (state_5.sqlite today).
+     * Resolve the highest-numbered one that exists rather than hardcoding a number
+     * that a Codex upgrade would silently invalidate.
+     */
+    get statePath() {
+        let entries;
+        try {
+            entries = plugins.fs.readdirSync(this.dir);
+        }
+        catch {
+            return null;
+        }
+        const candidates = entries
+            .map((entryArg) => /^state_(\d+)\.sqlite$/.exec(entryArg))
+            .filter((matchArg) => matchArg !== null)
+            .map((matchArg) => ({ name: matchArg[0], generation: Number(matchArg[1]) }))
+            .sort((leftArg, rightArg) => rightArg.generation - leftArg.generation);
+        if (candidates.length === 0) {
+            return null;
+        }
+        return plugins.path.join(this.dir, candidates[0].name);
+    }
+    exists() {
+        return plugins.fs.existsSync(this.dir);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.codexpreuse.d.ts

@@ -0,0 +1,8 @@
+import type { ICodexIdentity } from './interfaces.js';
+import type { IHarnessPreuseOptions, IHarnessPreuseResult } from './interfaces.harness.js';
+/** One tool-free request through the FlexHarness ChatGPT provider, with no credential writes. */
+export declare class CodexPreuse {
+    private readonly fetcher;
+    constructor(fetcher?: typeof fetch);
+    run(rawArg: string, identityArg: ICodexIdentity, optionsArg: IHarnessPreuseOptions): Promise<IHarnessPreuseResult>;
+}

package/dist_ts/classes.codexpreuse.js

@@ -0,0 +1,90 @@
+import * as plugins from './plugins.js';
+import { PreuseError, validatePreuseOptions } from './preuse.js';
+/** One tool-free request through the FlexHarness ChatGPT provider, with no credential writes. */
+export class CodexPreuse {
+    fetcher;
+    constructor(fetcher = globalThis.fetch) {
+        this.fetcher = fetcher;
+    }
+    async run(rawArg, identityArg, optionsArg) {
+        validatePreuseOptions(optionsArg);
+        if (identityArg.kind !== 'chatgpt')
+            throw new PreuseError('Codex preuse requires a ChatGPT subscription login; API-key logins have no subscription reset window.');
+        if (!identityArg.accountId)
+            throw new PreuseError('This login has no account ID for preuse.');
+        const signal = optionsArg.signal
+            ? AbortSignal.any([optionsArg.signal, AbortSignal.timeout(180_000)])
+            : AbortSignal.timeout(180_000);
+        let credentials;
+        let oauth;
+        try {
+            const tokens = JSON.parse(rawArg).tokens;
+            oauth = { kind: 'chatgptOAuth', providerId: 'openai', accessToken: tokens.access_token, refreshToken: tokens.refresh_token, idToken: tokens.id_token };
+            credentials = plugins.flexAccounts.toOpenAiChatGptAuthCredentials(oauth);
+            if (credentials.accountId !== identityArg.accountId)
+                throw new Error('Identity mismatch');
+        }
+        catch {
+            throw new PreuseError('No complete, matching Codex login is available for preuse. Log in again with Codex and save the account.');
+        }
+        let model = optionsArg.model;
+        let reasoningEffort;
+        if (!model) {
+            const adapter = new plugins.flexAccounts.OpenAiProviderAdapter({ fetch: this.fetcher });
+            try {
+                const catalog = await adapter.listModels(oauth, { signal, timeoutMs: 10_000 });
+                if (!catalog.success)
+                    throw new PreuseError(catalog.errorCode === 'CREDENTIAL_REFRESH_REQUIRED'
+                        ? 'The saved login has expired. Log in again with Codex and save it before preuse.'
+                        : 'Could not read the account model catalog. No preuse prompt was sent.');
+                const selected = catalog.models.find(item => item.isDefault && item.inputModalities.includes('text'));
+                if (!selected)
+                    throw new PreuseError('The account catalog has no default text model. Specify --model explicitly.');
+                model = selected.wireModel;
+                reasoningEffort = ['none', 'minimal', 'low'].find(effort => selected.reasoningEfforts.some(item => item.effort === effort)) ?? selected.defaultReasoningEffort;
+            }
+            catch (error) {
+                if (error instanceof PreuseError)
+                    throw error;
+                throw new PreuseError('Could not read the account model catalog. No preuse prompt was sent.');
+            }
+            finally {
+                await adapter.dispose();
+            }
+        }
+        let requestStarted = false;
+        try {
+            signal.throwIfAborted();
+            const connection = plugins.flexAuth.createOpenAiChatGptModelConnection(credentials);
+            connection.settings.fetch = this.fetcher;
+            const languageModel = plugins.flexOpenAi.createOpenAiModelProvider().getModel({ provider: 'openai', model, connection });
+            requestStarted = true;
+            const stream = plugins.flexModels.streamText({
+                model: languageModel,
+                instructions: 'Answer the user prompt with plain text. Do not use tools.',
+                prompt: optionsArg.prompt,
+                providerOptions: { openai: { store: false, ...(reasoningEffort ? { reasoningEffort } : {}) } },
+                abortSignal: signal,
+                maxRetries: 0,
+                // Handle errors here without the SDK's default raw-error console output.
+                onError: () => { },
+            });
+            // Drain the stream; generated prose is neither printed nor persisted.
+            for await (const part of stream.fullStream) {
+                if (part.type === 'error' || part.type === 'abort')
+                    throw new Error('Inference did not complete');
+            }
+            const [finishReason, usage] = await Promise.all([stream.finishReason, stream.totalUsage]);
+            if (finishReason !== 'stop' && finishReason !== 'length')
+                throw new Error('Inference did not complete');
+            const count = (value) => Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+            return { model, inputTokens: count(usage.inputTokens), outputTokens: count(usage.outputTokens), totalTokens: count(usage.totalTokens) };
+        }
+        catch {
+            throw new PreuseError(requestStarted
+                ? 'Preuse did not complete. Tokens may already have been consumed; no automatic retry was made. Check the account status before trying again.'
+                : 'Preuse was cancelled before the prompt was sent.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.codexstatus.d.ts

@@ -0,0 +1,20 @@
+import type { ICodexIdentity } from './interfaces.js';
+import type { IHarnessAccountStatus } from './interfaces.harness.js';
+/**
+ * Read-only ChatGPT status contract verified against Codex 0.154.0.
+ * These source-defined backend routes are isolated here. No token refresh,
+ * credential writes, app-server lifecycle changes or reset consumption occur.
+ */
+export declare class CodexAccountStatus {
+    private readonly fetcher;
+    constructor(fetcher?: typeof fetch);
+    read(rawArg: string, identityArg: ICodexIdentity): Promise<IHarnessAccountStatus>;
+    /** Read the ChatGPT account directly, independent of a harness's on-disk format. */
+    readCredential(accessToken: string, accountId: string, planType?: string | null): Promise<IHarnessAccountStatus>;
+    private get;
+    /** Desktop 26.908.40834 account-check contract; select the credential's exact account. */
+    private billing;
+    private limits;
+    private resets;
+    private activity;
+}