@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.tui.js

@@ -0,0 +1,195 @@
+import * as plugins from './plugins.js';
+import { accountDetails, accountPlan, accountQuotaSummary, accountResets, accountState, accountUsageWindows, usagePeriod, until, readAccountRows } from './accounts.js';
+import { plainText } from './formatting.js';
+import { AuthSwitchOperations } from './classes.operations.js';
+/** Owns account-management actions; terminal rendering and interaction belong to smartconsole. */
+export class AuthSwitchTui {
+    harnesses;
+    out;
+    operations;
+    constructor(harnesses, out, operations = new AuthSwitchOperations()) {
+        this.harnesses = harnesses;
+        this.out = out;
+        this.operations = operations;
+    }
+    async run(preferredArg) {
+        let harness = preferredArg ?? this.harnesses[0];
+        if (!harness) {
+            await this.out.warn('No harnesses registered.');
+            return 2;
+        }
+        const ui = this.out.tui;
+        let state;
+        let rows = [];
+        const footer = ui.text('Loading account status…', { height: 2 });
+        const details = ui.viewer('Select an account to inspect its status.');
+        const table = ui.table({
+            rows: [], rowKey: row => JSON.stringify([row.harness.id, row.account.id]),
+            columns: [
+                { key: 'account', title: 'Account', value: row => plainText(row.account.label) },
+                { key: 'state', title: 'State', value: accountState },
+                { key: 'plan', title: 'Plan', value: accountPlan },
+                { key: 'usage', title: 'Usage / reset', value: row => accountQuotaSummary(row, Date.now()).replaceAll('\n', ' / ') },
+                { key: 'resets', title: 'Resets', value: row => row.status?.summary?.resets?.available, render: accountResets, align: 'right' },
+            ],
+            onSelect: () => updateDetails(),
+            onActivate: async (_row, screen) => { await perform(screen, () => switchSelected(screen)); },
+        });
+        const updateDetails = () => { details.setText(table.selected ? accountDetails(table.selected) : state?.saveUnavailableReason ?? harness.loginHint); };
+        const showOutcome = (outcomeArg) => {
+            for (const line of outcomeArg.lines)
+                ui.logs.append(plainText(line));
+            for (const problem of outcomeArg.problems)
+                ui.logs.append('Incomplete: ' + plainText(problem));
+            footer.setText(outcomeArg.problems.length ? 'Incomplete: ' + outcomeArg.problems.map(plainText).join('; ') : outcomeArg.lines.map(plainText).join(' · ') || 'Done.');
+            return outcomeArg.problems.length === 0;
+        };
+        const refresh = async (screen) => {
+            footer.setText(`Loading ${plainText(harness.label)} accounts and live status…`);
+            await screen.invalidate();
+            try {
+                const result = await readAccountRows(harness, { signal: screen.signal, onUpdate: async (updatedArg, stateArg) => {
+                        if (screen.signal.aborted)
+                            return;
+                        rows = updatedArg;
+                        state = stateArg;
+                        table.setRows(rows);
+                        updateDetails();
+                        await screen.invalidate();
+                    } });
+                if (screen.signal.aborted)
+                    return;
+                state = result.state;
+                rows = result.rows;
+                const failures = rows.filter(row => row.status?.problems.length).length;
+                footer.setText(`${rows.length} account(s) · ${failures ? `${failures} with unavailable status sections` : 'Status refreshed'}${state.saveUnavailableReason ? ' · ' + plainText(state.saveUnavailableReason) : ''}`);
+            }
+            catch {
+                state = undefined;
+                rows = [];
+                table.setRows([]);
+                footer.setText(`Could not read ${plainText(harness.label)} accounts. Run authswitch ${harness.id} doctor.`);
+            }
+            updateDetails();
+        };
+        const perform = async (screen, action) => {
+            if (screen.signal.aborted)
+                return;
+            try {
+                await action();
+            }
+            catch {
+                footer.setText(`Operation failed. Run authswitch ${harness.id} doctor for diagnostics.`);
+            }
+            updateDetails();
+        };
+        const save = async (screen, keepActiveArg) => {
+            const latest = await harness.readState();
+            const activeAccounts = latest.accounts.filter(account => account.isActive);
+            const active = activeAccounts.find(account => account.id === table.selected?.account.id) ?? (activeAccounts.length === 1 ? activeAccounts[0] : undefined);
+            if (!active && activeAccounts.length > 1) {
+                footer.setText('Select the active account you want to save.');
+                return;
+            }
+            if (!active || latest.saveUnavailableReason) {
+                footer.setText(latest.saveUnavailableReason ?? 'No active login to save.');
+                return;
+            }
+            if (!await screen.confirm(`Save ${plainText(active.label)}${keepActiveArg ? ' and keep it active' : ' and clear the active login'}?`))
+                return;
+            if (screen.signal.aborted)
+                return;
+            const outcome = await this.operations.run(harness, { harnessId: harness.id, action: 'save', keepActive: keepActiveArg, accountId: active.id }, message => screen.confirm(message));
+            await refresh(screen);
+            showOutcome(outcome);
+        };
+        const switchSelected = async (screen) => {
+            const selected = table.selected;
+            if (!selected)
+                return;
+            const latest = await harness.readState();
+            const target = latest.accounts.find(account => account.id === selected.account.id && account.isStashed);
+            if (!target) {
+                footer.setText('Select an account with a verified saved login.');
+                return;
+            }
+            const active = latest.accounts.find(account => account.isActive && account.slotId === target.slotId);
+            if (active && !active.isStashed) {
+                if (latest.saveUnavailableReason) {
+                    footer.setText(latest.saveUnavailableReason);
+                    return;
+                }
+                if (!await screen.confirm(`${plainText(active.label)} is not saved. Save this login before switching?`, { confirmLabel: 'Save first' }))
+                    return;
+                if (screen.signal.aborted)
+                    return;
+                if (!showOutcome(await this.operations.run(harness, { harnessId: harness.id, action: 'save', keepActive: true, accountId: active.id }, message => screen.confirm(message))))
+                    return;
+                const verified = await harness.readState();
+                if (!verified.accounts.some(account => account.isActive && account.isStashed && account.id === active.id)) {
+                    footer.setText('The current login could not be verified as saved. Switching was cancelled.');
+                    return;
+                }
+            }
+            if (!await screen.confirm(`Switch ${plainText(harness.label)} to ${plainText(target.label)}?`, { confirmLabel: 'Switch' }))
+                return;
+            if (screen.signal.aborted)
+                return;
+            const outcome = await this.operations.run(harness, { harnessId: harness.id, action: 'switch', accountId: target.id }, message => screen.confirm(message));
+            await refresh(screen);
+            showOutcome(outcome);
+        };
+        const remove = async (screen) => {
+            const selected = table.selected;
+            if (!selected || (!selected.account.isStashed && selected.account.savedAt === null)) {
+                footer.setText('Select an account with a saved copy.');
+                return;
+            }
+            if (!await screen.confirm(`Remove the saved login for ${plainText(selected.account.label)}? The active login stays as it is.`, { confirmLabel: 'Remove saved copy' }))
+                return;
+            if (screen.signal.aborted)
+                return;
+            const outcome = await harness.removeAccount(selected.account.id);
+            await refresh(screen);
+            showOutcome(outcome);
+        };
+        const harnessTable = ui.table({
+            rows: this.harnesses, rowKey: item => item.id, selectedKey: harness.id,
+            columns: [{ key: 'harness', title: 'Harness', value: item => item.label }],
+            onActivate: async (selected, screen) => {
+                harness = selected;
+                state = undefined;
+                table.setRows([]);
+                await refresh(screen);
+                screen.focus(table);
+            },
+        });
+        const tabs = ui.tabs([{ title: 'Account details', content: details }, { title: 'Activity log', content: ui.logs }]);
+        await ui.run({
+            view: () => {
+                const usage = accountUsageWindows({ status: table.selected?.status })?.slice(0, 2).map(window => ui.progress(`${usagePeriod(window)} (${window.usedPercent}% used; reset in ${until(window.resetAt, Date.now())})`, Math.min(100, window.usedPercent), 100)) ?? [];
+                const accountView = ui.column([
+                    ui.panel(`${plainText(harness.label)} accounts`, table),
+                    ui.panel('Status and diagnostics', ui.column([...usage, tabs])),
+                ]);
+                return ui.column([
+                    ui.text('authswitch · account management', { height: 1 }),
+                    this.harnesses.length > 1 ? ui.row([ui.panel('Harnesses', harnessTable, { width: 23 }), accountView]) : accountView,
+                    ui.text('Enter switch · a save · c save+clear · d remove · r refresh · g diagnose · Tab focus · q quit', { height: 2 }),
+                    footer,
+                ]);
+            },
+            onReady: async (screen) => { screen.focus(table); await refresh(screen); },
+            keys: {
+                q: screen => screen.close(),
+                r: screen => refresh(screen),
+                a: screen => perform(screen, () => save(screen, true)),
+                c: screen => perform(screen, () => save(screen, false)),
+                d: screen => perform(screen, () => remove(screen)),
+                g: screen => perform(screen, async () => { showOutcome(await harness.diagnose()); }),
+            },
+        });
+        return 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.tui.js","sourceRoot":"","sources":["../ts/classes.tui.ts"],"names":[],"mappings":"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"}

package/dist_ts/formatting.d.ts

@@ -0,0 +1,8 @@
+export declare const dim: (textArg: string) => string;
+export declare const bold: (textArg: string) => string;
+export declare const green: (textArg: string) => string;
+export declare const red: (textArg: string) => string;
+export declare const orange: (textArg: string) => string;
+export declare const cyan: (textArg: string) => string;
+/** Remote labels cannot inject terminal control sequences or extra output rows. */
+export declare const plainText: (textArg: string) => string;

package/dist_ts/formatting.js

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+const styled = () => process.stdout.isTTY === true && !Object.hasOwn(process.env, 'NO_COLOR');
+const render = (textArg, styleArg) => styled() ? plugins.smartconsole.color.toAnsi(plugins.smartconsole.color.text(textArg, styleArg)) : plainText(textArg);
+export const dim = (textArg) => render(textArg, { dim: true });
+export const bold = (textArg) => render(textArg, { bold: true });
+const paint = (textArg, colorArg) => render(textArg, { foreground: colorArg });
+export const green = (textArg) => paint(textArg, 'green');
+export const red = (textArg) => paint(textArg, 'red');
+export const orange = (textArg) => paint(textArg, 'orange');
+export const cyan = (textArg) => paint(textArg, 'cyan');
+/** Remote labels cannot inject terminal control sequences or extra output rows. */
+export const plainText = (textArg) => textArg.replace(/[\u0000-\u001f\u007f-\u009f]/g, '').slice(0, 500);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9ybWF0dGluZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2Zvcm1hdHRpbmcudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSxjQUFjLENBQUM7QUFFeEMsTUFBTSxNQUFNLEdBQUcsR0FBWSxFQUFFLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxLQUFLLEtBQUssSUFBSSxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLFVBQVUsQ0FBQyxDQUFDO0FBQ3ZHLE1BQU0sTUFBTSxHQUFHLENBQUMsT0FBZSxFQUFFLFFBQXlDLEVBQVUsRUFBRSxDQUNwRixNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsT0FBTyxDQUFDLFlBQVksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQyxZQUFZLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLE9BQU8sQ0FBQyxDQUFDO0FBQ3hILE1BQU0sQ0FBQyxNQUFNLEdBQUcsR0FBRyxDQUFDLE9BQWUsRUFBVSxFQUFFLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxFQUFFLEdBQUcsRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0FBQy9FLE1BQU0sQ0FBQyxNQUFNLElBQUksR0FBRyxDQUFDLE9BQWUsRUFBVSxFQUFFLENBQUMsTUFBTSxDQUFDLE9BQU8sRUFBRSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUUsQ0FBQyxDQUFDO0FBQ2pGLE1BQU0sS0FBSyxHQUFHLENBQUMsT0FBZSxFQUFFLFFBQXlDLEVBQVUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxPQUFPLEVBQUUsRUFBRSxVQUFVLEVBQUUsUUFBUSxFQUFFLENBQUMsQ0FBQztBQUNoSSxNQUFNLENBQUMsTUFBTSxLQUFLLEdBQUcsQ0FBQyxPQUFlLEVBQVUsRUFBRSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxDQUFDLENBQUM7QUFDMUUsTUFBTSxDQUFDLE1BQU0sR0FBRyxHQUFHLENBQUMsT0FBZSxFQUFVLEVBQUUsQ0FBQyxLQUFLLENBQUMsT0FBTyxFQUFFLEtBQUssQ0FBQyxDQUFDO0FBQ3RFLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxDQUFDLE9BQWUsRUFBVSxFQUFFLENBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsQ0FBQztBQUM1RSxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQyxPQUFlLEVBQVUsRUFBRSxDQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsTUFBTSxDQUFDLENBQUM7QUFDeEUsbUZBQW1GO0FBQ25GLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxDQUFDLE9BQWUsRUFBVSxFQUFFLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQywrQkFBK0IsRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDIn0=

package/dist_ts/helpers.d.ts

@@ -0,0 +1,39 @@
+import type { IRemoteControlEnrollment, TEnrollmentState } from './interfaces.js';
+/**
+ * Writes a secret to `destinationPathArg` atomically and owner-only.
+ *
+ * Three things matter here, and none of them are free with a plain
+ * `writeFileSync`:
+ *
+ * - The temp file is created with the `wx` flag, so a leftover file from an
+ *   interrupted run cannot silently receive a credential at whatever mode that
+ *   run left behind.
+ * - Its mode is set explicitly after creation, because `writeFileSync`'s `mode`
+ *   option only applies when the file is created.
+ * - It is removed on every failure path, so a complete credential is never left
+ *   at a predictable path that nothing lists, cleans, or reports.
+ *
+ * The rename is atomic within a filesystem, so a reader sees either the old
+ * content or the new one, never a partial write.
+ */
+export declare const writeSecretFileAtomically: (destinationPathArg: string, contentArg: string) => void;
+/**
+ * Trims third-party process output down to something safe to put in an error
+ * message: one line, length-capped, and never empty.
+ */
+export declare const summariseProcessOutput: (stdoutArg: string, stderrArg: string, spawnErrorArg: string | null) => string;
+/**
+ * Classifies an enrollment row. See TEnrollmentState for why NULL and 0 are not
+ * the same answer.
+ */
+export declare const enrollmentState: (enrollmentArg: IRemoteControlEnrollment) => TEnrollmentState;
+/** How many of these enrollments carry a working pairing. */
+export declare const countPaired: (enrollmentsArg: IRemoteControlEnrollment[]) => number;
+/**
+ * Turns a failed Codex invocation into a diagnosis rather than an errno.
+ *
+ * A timeout and a missing binary are different problems with different fixes,
+ * and neither is "the stop command failed" -- surfacing the raw spawn error
+ * leaves the user to guess which one they hit.
+ */
+export declare const describeCodexFailure: (binaryArg: string, stdoutArg: string, stderrArg: string, spawnErrorArg: string | null) => string;

package/dist_ts/helpers.js

@@ -0,0 +1,92 @@
+import * as plugins from './plugins.js';
+/**
+ * Writes a secret to `destinationPathArg` atomically and owner-only.
+ *
+ * Three things matter here, and none of them are free with a plain
+ * `writeFileSync`:
+ *
+ * - The temp file is created with the `wx` flag, so a leftover file from an
+ *   interrupted run cannot silently receive a credential at whatever mode that
+ *   run left behind.
+ * - Its mode is set explicitly after creation, because `writeFileSync`'s `mode`
+ *   option only applies when the file is created.
+ * - It is removed on every failure path, so a complete credential is never left
+ *   at a predictable path that nothing lists, cleans, or reports.
+ *
+ * The rename is atomic within a filesystem, so a reader sees either the old
+ * content or the new one, never a partial write.
+ */
+export const writeSecretFileAtomically = (destinationPathArg, contentArg) => {
+    const tempPath = `${destinationPathArg}.authswitch-tmp`;
+    // A stale temp file means an earlier run died mid-write. Its content is
+    // superseded by what we are about to write, so clearing it is safe -- and
+    // necessary, since `wx` would otherwise fail forever.
+    if (plugins.fs.existsSync(tempPath)) {
+        plugins.fs.rmSync(tempPath, { force: true });
+    }
+    let handle = null;
+    try {
+        handle = plugins.fs.openSync(tempPath, 'wx', 0o600);
+        plugins.fs.fchmodSync(handle, 0o600);
+        plugins.fs.writeFileSync(handle, contentArg, { encoding: 'utf8' });
+        plugins.fs.fsyncSync(handle);
+        plugins.fs.closeSync(handle);
+        handle = null;
+        plugins.fs.renameSync(tempPath, destinationPathArg);
+    }
+    catch (errorArg) {
+        if (handle !== null) {
+            try {
+                plugins.fs.closeSync(handle);
+            }
+            catch {
+                // The handle is being discarded either way.
+            }
+        }
+        plugins.fs.rmSync(tempPath, { force: true });
+        throw errorArg;
+    }
+    plugins.fs.chmodSync(destinationPathArg, 0o600);
+};
+/**
+ * Trims third-party process output down to something safe to put in an error
+ * message: one line, length-capped, and never empty.
+ */
+export const summariseProcessOutput = (stdoutArg, stderrArg, spawnErrorArg) => {
+    const candidate = (spawnErrorArg ?? stderrArg.trim() ?? '') || stdoutArg.trim();
+    if (!candidate) {
+        return 'no output';
+    }
+    const firstLine = candidate.split('\n').find((lineArg) => lineArg.trim().length > 0) ?? '';
+    const collapsed = firstLine.trim();
+    return collapsed.length > 200 ? `${collapsed.slice(0, 200)}...` : collapsed;
+};
+/**
+ * Classifies an enrollment row. See TEnrollmentState for why NULL and 0 are not
+ * the same answer.
+ */
+export const enrollmentState = (enrollmentArg) => {
+    if (enrollmentArg.remoteControlEnabled === null) {
+        return 'unpaired';
+    }
+    return enrollmentArg.remoteControlEnabled === 0 ? 'disabled' : 'paired';
+};
+/** How many of these enrollments carry a working pairing. */
+export const countPaired = (enrollmentsArg) => enrollmentsArg.filter((enrollmentArg) => enrollmentState(enrollmentArg) === 'paired').length;
+/**
+ * Turns a failed Codex invocation into a diagnosis rather than an errno.
+ *
+ * A timeout and a missing binary are different problems with different fixes,
+ * and neither is "the stop command failed" -- surfacing the raw spawn error
+ * leaves the user to guess which one they hit.
+ */
+export const describeCodexFailure = (binaryArg, stdoutArg, stderrArg, spawnErrorArg) => {
+    if (spawnErrorArg && /ETIMEDOUT/i.test(spawnErrorArg)) {
+        return `the Codex app-server did not respond in time - it is running but unresponsive. Try \`codex app-server daemon restart\`, then run this again`;
+    }
+    if (spawnErrorArg && /ENOENT/i.test(spawnErrorArg)) {
+        return `the Codex CLI "${binaryArg}" was not found - put it on PATH or set AUTHSWITCH_CODEX_BIN to its full path`;
+    }
+    return summariseProcessOutput(stdoutArg, stderrArg, spawnErrorArg);
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/index.d.ts

@@ -0,0 +1,22 @@
+export * from './interfaces.js';
+export * from './interfaces.harness.js';
+export * from './interfaces.list.js';
+export * from './classes.codexharness.js';
+export * from './classes.opencodeharness.js';
+export * from './classes.claudecodeharness.js';
+export * from './classes.claudestatus.js';
+export * from './classes.codexstatus.js';
+export * from './classes.codexpreuse.js';
+export * from './preuse.js';
+export * from './helpers.js';
+export * from './classes.codexhome.js';
+export * from './classes.codexauth.js';
+export * from './classes.remotecontrol.js';
+export * from './classes.stashstore.js';
+export * from './classes.codexdaemon.js';
+export * from './classes.codexswitcher.js';
+export * from './classes.cli.js';
+export * from './classes.login.js';
+export * from './classes.operations.js';
+export * from './classes.service.js';
+export declare const runCli: (argvArg?: string[]) => Promise<void>;

package/dist_ts/index.js

@@ -0,0 +1,27 @@
+export * from './interfaces.js';
+export * from './interfaces.harness.js';
+export * from './interfaces.list.js';
+export * from './classes.codexharness.js';
+export * from './classes.opencodeharness.js';
+export * from './classes.claudecodeharness.js';
+export * from './classes.claudestatus.js';
+export * from './classes.codexstatus.js';
+export * from './classes.codexpreuse.js';
+export * from './preuse.js';
+export * from './helpers.js';
+export * from './classes.codexhome.js';
+export * from './classes.codexauth.js';
+export * from './classes.remotecontrol.js';
+export * from './classes.stashstore.js';
+export * from './classes.codexdaemon.js';
+export * from './classes.codexswitcher.js';
+export * from './classes.cli.js';
+export * from './classes.login.js';
+export * from './classes.operations.js';
+export * from './classes.service.js';
+import { AuthSwitchCli } from './classes.cli.js';
+export const runCli = async (argvArg = process.argv.slice(2)) => {
+    const exitCode = await new AuthSwitchCli().run(argvArg);
+    process.exitCode = exitCode;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsOEJBQThCLENBQUM7QUFDN0MsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUM7QUFDekMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLHNCQUFzQixDQUFDO0FBRXJDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVqRCxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsS0FBSyxFQUFFLFVBQW9CLE9BQU8sQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxFQUFpQixFQUFFO0lBQ3ZGLE1BQU0sUUFBUSxHQUFHLE1BQU0sSUFBSSxhQUFhLEVBQUUsQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEQsT0FBTyxDQUFDLFFBQVEsR0FBRyxRQUFRLENBQUM7QUFDOUIsQ0FBQyxDQUFDIn0=

package/dist_ts/interfaces.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Lowercase harness namespace. Adapters are registered independently of the CLI.
+ */
+export type THarnessName = string;
+/**
+ * Where the currently active Codex credential lives.
+ * - 'file'    -> $CODEX_HOME/auth.json
+ * - 'keyring' -> an OS keyring entry (authswitch cannot move these)
+ * - 'none'    -> no credential is active
+ */
+export type TAuthSource = 'file' | 'keyring' | 'none';
+/**
+ * How a stashed credential identifies its account.
+ * - 'chatgpt' -> ChatGPT OAuth login, identified by the id_token email claim
+ * - 'apikey'  -> plain API key login, which carries no email
+ */
+export type TAccountKind = 'chatgpt' | 'apikey';
+/**
+ * Identity extracted from a Codex credential without ever exposing the token.
+ */
+export interface ICodexIdentity {
+    kind: TAccountKind;
+    /** The account email, or a synthetic `apikey:<fingerprint>` label for API-key logins. */
+    email: string;
+    accountId: string | null;
+    planType: string | null;
+    userId: string | null;
+}
+/**
+ * The active credential as found on disk, plus its decoded identity.
+ * `raw` is the verbatim file content and is never logged.
+ */
+export interface IActiveAuth {
+    source: TAuthSource;
+    authFilePath: string;
+    identity: ICodexIdentity | null;
+    raw: string | null;
+}
+/**
+ * One row of the `remote_control_enrollments` table in Codex' state database.
+ * This is the record that binds a Codex app-server to a paired ChatGPT client.
+ */
+export interface IRemoteControlEnrollment {
+    websocketUrl: string;
+    accountId: string;
+    appServerClientName: string;
+    serverId: string;
+    environmentId: string;
+    serverName: string;
+    updatedAt: number;
+    remoteControlEnabled: number | null;
+}
+/**
+ * Metadata stored alongside a stashed credential.
+ */
+export interface IStashEntry {
+    email: string;
+    kind: TAccountKind;
+    accountId: string | null;
+    planType: string | null;
+    userId: string | null;
+    stashedAt: string;
+    codexHome: string;
+    enrollments: IRemoteControlEnrollment[];
+}
+/**
+ * How far along an enrollment row is.
+ *
+ * Codex writes the row when an account registers a server, but its upsert
+ * deliberately leaves `remote_control_enabled` alone, so a freshly logged-in
+ * account starts at NULL. A row is therefore not the same thing as a working
+ * pairing, and the three states have to stay distinguishable:
+ * - 'paired'      -> remote_control_enabled = 1, reachable from the ChatGPT app
+ * - 'disabled'    -> remote_control_enabled = 0, deliberately turned off
+ * - 'unpaired'    -> remote_control_enabled IS NULL, registered but never paired
+ */
+export type TEnrollmentState = 'paired' | 'disabled' | 'unpaired';
+/**
+ * A stash entry plus the derived facts the CLI needs for display.
+ */
+export interface IStashListing extends IStashEntry {
+    slug: string;
+    isActive: boolean;
+    /** Rows stashed for this account, paired or not. */
+    enrollmentsTotal: number;
+    /** Rows that actually carry a working pairing. */
+    enrollmentsPaired: number;
+    /**
+     * True only when at least one enrollment is paired. A registered-but-unpaired
+     * row is not remote control, and reporting it as such would tell the user the
+     * account is reachable when it is not.
+     */
+    hasRemoteControl: boolean;
+}
+/**
+ * The outcome of running a Codex subcommand.
+ */
+export interface ICommandResult {
+    ok: boolean;
+    stdout: string;
+    stderr: string;
+    code: number | null;
+    /** Set when the process could not be spawned at all, or timed out. */
+    spawnError: string | null;
+}
+/**
+ * What `codex app-server daemon version` reports about the managed daemon.
+ */
+export interface IDaemonStatus {
+    running: boolean;
+    backend: string | null;
+    appServerVersion: string | null;
+    cliVersion: string | null;
+    socketPath: string | null;
+}
+export interface ICodexSwitcherOptions {
+    codexHome?: string;
+    stashRoot?: string;
+    codexBinary?: string;
+}
+/**
+ * Result of stashing the active credential.
+ *
+ * `complete` is false when the credential was saved but something the user
+ * cares about did not finish -- the app-server failing to come back, say.
+ */
+export interface IStashResult {
+    entry: IStashEntry;
+    daemonRestarted: boolean;
+    complete: boolean;
+    notes: string[];
+    problems: string[];
+}
+/**
+ * Result of a switch, used for reporting and for the CLI exit code.
+ */
+export interface ISwitchResult {
+    from: string | null;
+    to: string;
+    enrollmentsRestored: number;
+    daemonRestarted: boolean;
+    complete: boolean;
+    notes: string[];
+    problems: string[];
+}