@modelprofile.com/authswitch 2.1.2

package/dist_ts/classes.service.js

@@ -0,0 +1,142 @@
+import * as plugins from './plugins.js';
+import { CodexHarness } from './classes.codexharness.js';
+import { OpenCodeHarness } from './classes.opencodeharness.js';
+import { ClaudeCodeHarness } from './classes.claudecodeharness.js';
+import { readAccountList } from './classes.accountlist.js';
+import { assertAuthSwitchMutation, authSwitchEnvironmentId, runAuthSwitchMutation } from './classes.operations.js';
+const publicOutcome = (outcome) => ({ lines: [...outcome.lines], problems: [...outcome.problems] });
+const publicResult = (result) => result.status === 'complete'
+    ? { status: 'complete', outcome: publicOutcome(result.outcome) }
+    : result.status === 'busy' ? { status: 'busy', message: result.message } : { status: 'unavailable' };
+const publicPrompt = (prompt) => prompt.flow === 'device'
+    ? { flow: 'device', verificationUrl: prompt.verificationUrl, userCode: prompt.userCode }
+    : { flow: 'browser', authUrl: prompt.authUrl };
+export const assertAuthSwitchServiceRequest = value => {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error('Invalid authswitch request.');
+    const request = value;
+    const keys = request.action === 'login' ? ['harnessId', 'providerId', 'flow'] : request.action === 'list' ? ['harnessId']
+        : request.action === 'mutate' ? ['coordination'] : ['operationId'];
+    if (request.protocolVersion !== 1 || !['list', 'login', 'mutate', 'get', 'cancel'].includes(String(request.action))
+        || Object.keys(request).some(key => !['protocolVersion', 'action', ...keys].includes(key)))
+        throw new Error('Unsupported authswitch request.');
+    if (request.action === 'mutate') {
+        const coordination = request.coordination;
+        if (!coordination || coordination.protocolVersion !== 1 || typeof coordination.waitForIdle !== 'boolean'
+            || typeof coordination.contextId !== 'string' || !/^[a-f0-9]{64}$/.test(coordination.contextId)
+            || Object.keys(coordination).some(key => !['protocolVersion', 'contextId', 'mutation', 'waitForIdle'].includes(key)))
+            throw new Error('Invalid coordination request.');
+        assertAuthSwitchMutation(coordination.mutation);
+    }
+    else if (request.action === 'get' || request.action === 'cancel') {
+        if (typeof request.operationId !== 'string' || !/^[a-f0-9-]{36}$/.test(request.operationId))
+            throw new Error('Invalid operation ID.');
+    }
+    else if ((request.harnessId !== undefined || request.action === 'login')
+        && (typeof request.harnessId !== 'string' || !/^[a-z][a-z0-9-]{0,63}$/.test(request.harnessId)))
+        throw new Error('Invalid harness ID.');
+    if (request.action === 'login' && (typeof request.providerId !== 'string' || !/^[a-z][a-z0-9-]{0,63}$/.test(request.providerId)
+        || !['device', 'browser'].includes(String(request.flow))))
+        throw new Error('Invalid login provider or flow.');
+};
+/** Hosted account manager. Operations outlive HTTP connections and are retained briefly for polling. */
+export class AuthSwitchService {
+    harnesses;
+    coordinator;
+    operations = new Map();
+    closed = false;
+    constructor(harnesses = [new CodexHarness(), new OpenCodeHarness(), new ClaudeCodeHarness()], coordinator) {
+        this.harnesses = harnesses;
+        this.coordinator = coordinator;
+    }
+    harness(id) {
+        const harness = this.harnesses.find(item => item.id === id);
+        if (!harness)
+            throw new Error('Unknown harness.');
+        return harness;
+    }
+    snapshot(operation) { return structuredClone(operation.status); }
+    async request(request) {
+        assertAuthSwitchServiceRequest(request);
+        if (this.closed)
+            throw new Error('Account manager is closed.');
+        for (const [id, operation] of this.operations) {
+            if (operation.finishedAt !== undefined && Date.now() - operation.finishedAt > 10 * 60_000)
+                this.operations.delete(id);
+        }
+        if (request.action === 'get' || request.action === 'cancel') {
+            const operation = this.operations.get(request.operationId);
+            if (!operation)
+                throw new Error('Operation expired or belongs to another controller. Check account status before retrying.');
+            if (request.action === 'cancel') {
+                if (operation.status.state === 'pending' && !operation.status.prompt)
+                    throw new Error('Only a pending login can be cancelled.');
+                operation.cancelled = true;
+                await operation.login?.cancel();
+            }
+            return this.snapshot(operation);
+        }
+        if (this.operations.size >= 64 || [...this.operations.values()].filter(item => item.status.state === 'pending').length >= 8) {
+            throw new Error('Account manager operation limit reached. Finish pending operations before starting another.');
+        }
+        const operation = { status: { id: plugins.crypto.randomUUID(), contextId: authSwitchEnvironmentId(), state: 'pending' }, task: Promise.resolve(), cancelled: false };
+        this.operations.set(operation.status.id, operation);
+        operation.task = Promise.resolve().then(async () => {
+            switch (request.action) {
+                case 'list': {
+                    operation.status.accounts = await readAccountList(request.harnessId ? [this.harness(request.harnessId)] : this.harnesses);
+                    operation.status.loginCapabilities = this.harnesses.filter(item => item.beginLogin).map(item => ({ harnessId: item.id,
+                        providers: (item.loginProviders ?? []).map(provider => ({ providerId: provider.providerId, label: provider.label, flows: [...provider.flows] })) }));
+                    break;
+                }
+                case 'mutate': {
+                    if (request.coordination.contextId !== authSwitchEnvironmentId()) {
+                        operation.status.result = { status: 'complete', outcome: { lines: [], problems: ['AGL and authswitch use different credential locations. Use matching credential environment settings before switching.'] } };
+                        break;
+                    }
+                    const harness = this.harness(request.coordination.mutation.harnessId);
+                    const coordinated = this.coordinator ? await this.coordinator(request.coordination) : { status: 'unavailable' };
+                    operation.status.result = publicResult(coordinated.status === 'unavailable'
+                        ? { status: 'complete', outcome: await runAuthSwitchMutation(harness, request.coordination.mutation) } : coordinated);
+                    break;
+                }
+                case 'login': {
+                    const harness = this.harness(request.harnessId);
+                    if (!harness.beginLogin)
+                        throw new Error('This harness does not support hosted login.');
+                    if (!harness.loginProviders?.some(provider => provider.providerId === request.providerId && provider.flows.includes(request.flow)))
+                        throw new Error('This harness does not support that login flow.');
+                    const login = await harness.beginLogin({ providerId: request.providerId, flow: request.flow });
+                    operation.login = login;
+                    operation.status.prompt = publicPrompt(login.prompt);
+                    if (operation.cancelled || this.closed)
+                        await login.cancel();
+                    try {
+                        const result = await login.completion;
+                        operation.status.result = { status: 'complete', outcome: publicOutcome(result.outcome) };
+                        operation.status.account = result.account ? { id: result.account.id, label: result.account.label, slotId: result.account.slotId } : undefined;
+                    }
+                    finally {
+                        await login.close();
+                        operation.login = undefined;
+                    }
+                    break;
+                }
+            }
+            operation.status.state = 'complete';
+        }).catch(() => {
+            operation.status.state = 'failed';
+            operation.status.error = 'Account operation failed. Check account and runtime status before retrying.';
+        }).finally(() => { operation.finishedAt = Date.now(); });
+        return this.snapshot(operation);
+    }
+    async close() {
+        this.closed = true;
+        await Promise.allSettled([...this.operations.values()].map(async (operation) => {
+            operation.cancelled = true;
+            await operation.login?.cancel();
+        }));
+        await Promise.all([...this.operations.values()].map(operation => operation.task));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.service.js","sourceRoot":"","sources":["../ts/classes.service.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.stashstore.d.ts

@@ -0,0 +1,63 @@
+import type { ICodexIdentity, IRemoteControlEnrollment, IStashEntry, THarnessName } from './interfaces.js';
+/**
+ * Filesystem-backed store for Codex credentials and enrollment metadata.
+ * Other harness adapters own their storage format; this is not a universal auth schema.
+ *
+ * A stash is deliberately a directory of files rather than a database: the thing
+ * being stored *is* a credential file, the store must survive with no services
+ * running, and it must be greppable and removable by hand when something goes
+ * wrong. Everything is written owner-only.
+ */
+export declare class StashStore {
+    readonly rootDir: string;
+    readonly harness: THarnessName;
+    constructor(harnessArg: THarnessName, rootDirArg?: string);
+    /**
+     * Turns an account email into a directory name that is safe on every
+     * filesystem while staying readable, so `ls ~/.authswitch/codex` is useful.
+     */
+    slugFor(emailArg: string): string;
+    entryDir(emailArg: string): string;
+    has(emailArg: string): boolean;
+    /**
+     * Writes a credential and its remote-control enrollments under the account email,
+     * replacing any existing stash for the same account.
+     *
+     * Both files go through an atomic temp-and-rename, and the metadata is written
+     * last: a crash mid-write therefore leaves either the previous complete stash
+     * or a credential whose metadata is still the old one, never a directory that
+     * `list()` skips because its metadata never arrived. The caller is expected to
+     * verify with `readBack()` before destroying the original.
+     */
+    write(identityArg: ICodexIdentity, rawAuthArg: string, enrollmentsArg: IRemoteControlEnrollment[], codexHomeArg: string): IStashEntry;
+    /**
+     * Reads a stash back and confirms it matches what was meant to be written.
+     * Callers use this before clearing the active credential, so a stash is only
+     * ever trusted once it has been proven readable.
+     */
+    readBack(emailArg: string, expectedAuthArg: string): boolean;
+    readMeta(emailArg: string): IStashEntry | null;
+    readAuth(emailArg: string): string | null;
+    /** Every stash, newest first. Unreadable directories are skipped, not fatal. */
+    list(): IStashEntry[];
+    /**
+     * Directories under the stash root that hold a credential but no readable
+     * metadata -- the shape an interrupted write would leave behind. Reported by
+     * `doctor` so they are visible rather than silently skipped by `list()`.
+     */
+    incomplete(): string[];
+    /**
+     * Resolves a user-supplied account reference to a stashed email.
+     *
+     * Accepts the exact email, the directory slug, the local part, or a prefix.
+     * Deliberately not a substring match: this reference selects which credential
+     * becomes active, so an incidental substring hit would activate an account the
+     * user never named.
+     */
+    resolve(referenceArg: string): {
+        email: string;
+    } | {
+        candidates: string[];
+    };
+    remove(emailArg: string): boolean;
+}

package/dist_ts/classes.stashstore.js

@@ -0,0 +1,192 @@
+import * as plugins from './plugins.js';
+import { writeSecretFileAtomically } from './helpers.js';
+const AUTH_FILE_NAME = 'auth.json';
+const META_FILE_NAME = 'stash.json';
+/**
+ * Filesystem-backed store for Codex credentials and enrollment metadata.
+ * Other harness adapters own their storage format; this is not a universal auth schema.
+ *
+ * A stash is deliberately a directory of files rather than a database: the thing
+ * being stored *is* a credential file, the store must survive with no services
+ * running, and it must be greppable and removable by hand when something goes
+ * wrong. Everything is written owner-only.
+ */
+export class StashStore {
+    rootDir;
+    harness;
+    constructor(harnessArg, rootDirArg) {
+        if (!/^[a-z][a-z0-9-]*$/.test(harnessArg)) {
+            throw new Error('invalid harness namespace');
+        }
+        this.harness = harnessArg;
+        const base = rootDirArg ??
+            process.env.AUTHSWITCH_HOME ??
+            plugins.path.join(plugins.os.homedir(), '.authswitch');
+        this.rootDir = plugins.path.join(base, harnessArg);
+    }
+    /**
+     * Turns an account email into a directory name that is safe on every
+     * filesystem while staying readable, so `ls ~/.authswitch/codex` is useful.
+     */
+    slugFor(emailArg) {
+        const slug = emailArg
+            .toLowerCase()
+            .replace(/[^a-z0-9._@+-]+/g, '_')
+            .replace(/^[._]+|[._]+$/g, '');
+        if (slug.length === 0) {
+            throw new Error(`cannot derive a stash name from "${emailArg}"`);
+        }
+        return slug;
+    }
+    entryDir(emailArg) {
+        return plugins.path.join(this.rootDir, this.slugFor(emailArg));
+    }
+    has(emailArg) {
+        return plugins.fs.existsSync(plugins.path.join(this.entryDir(emailArg), META_FILE_NAME));
+    }
+    /**
+     * Writes a credential and its remote-control enrollments under the account email,
+     * replacing any existing stash for the same account.
+     *
+     * Both files go through an atomic temp-and-rename, and the metadata is written
+     * last: a crash mid-write therefore leaves either the previous complete stash
+     * or a credential whose metadata is still the old one, never a directory that
+     * `list()` skips because its metadata never arrived. The caller is expected to
+     * verify with `readBack()` before destroying the original.
+     */
+    write(identityArg, rawAuthArg, enrollmentsArg, codexHomeArg) {
+        const previous = this.readMeta(identityArg.email);
+        if (previous && (previous.email !== identityArg.email || previous.accountId !== identityArg.accountId || previous.kind !== identityArg.kind)) {
+            throw new Error('a different Codex account already occupies this email-based stash; refusing to replace its credential');
+        }
+        const dir = this.entryDir(identityArg.email);
+        plugins.fs.mkdirSync(this.rootDir, { recursive: true, mode: 0o700 });
+        plugins.fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        // mkdirSync's mode is subject to the umask and is ignored for a directory
+        // that already exists, so tighten both levels explicitly.
+        plugins.fs.chmodSync(this.rootDir, 0o700);
+        plugins.fs.chmodSync(dir, 0o700);
+        const entry = {
+            email: identityArg.email,
+            kind: identityArg.kind,
+            accountId: identityArg.accountId,
+            planType: identityArg.planType,
+            userId: identityArg.userId,
+            stashedAt: new Date().toISOString(),
+            codexHome: codexHomeArg,
+            enrollments: enrollmentsArg,
+        };
+        writeSecretFileAtomically(plugins.path.join(dir, AUTH_FILE_NAME), rawAuthArg);
+        writeSecretFileAtomically(plugins.path.join(dir, META_FILE_NAME), `${JSON.stringify(entry, null, 2)}\n`);
+        return entry;
+    }
+    /**
+     * Reads a stash back and confirms it matches what was meant to be written.
+     * Callers use this before clearing the active credential, so a stash is only
+     * ever trusted once it has been proven readable.
+     */
+    readBack(emailArg, expectedAuthArg) {
+        const meta = this.readMeta(emailArg);
+        const auth = this.readAuth(emailArg);
+        return meta !== null && auth === expectedAuthArg;
+    }
+    readMeta(emailArg) {
+        const metaPath = plugins.path.join(this.entryDir(emailArg), META_FILE_NAME);
+        if (!plugins.fs.existsSync(metaPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(plugins.fs.readFileSync(metaPath, 'utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    readAuth(emailArg) {
+        const authPath = plugins.path.join(this.entryDir(emailArg), AUTH_FILE_NAME);
+        if (!plugins.fs.existsSync(authPath)) {
+            return null;
+        }
+        return plugins.fs.readFileSync(authPath, 'utf8');
+    }
+    /** Every stash, newest first. Unreadable directories are skipped, not fatal. */
+    list() {
+        if (!plugins.fs.existsSync(this.rootDir)) {
+            return [];
+        }
+        const entries = [];
+        for (const nameArg of plugins.fs.readdirSync(this.rootDir)) {
+            const metaPath = plugins.path.join(this.rootDir, nameArg, META_FILE_NAME);
+            if (!plugins.fs.existsSync(metaPath)) {
+                continue;
+            }
+            try {
+                entries.push(JSON.parse(plugins.fs.readFileSync(metaPath, 'utf8')));
+            }
+            catch {
+                continue;
+            }
+        }
+        return entries.sort((leftArg, rightArg) => rightArg.stashedAt.localeCompare(leftArg.stashedAt));
+    }
+    /**
+     * Directories under the stash root that hold a credential but no readable
+     * metadata -- the shape an interrupted write would leave behind. Reported by
+     * `doctor` so they are visible rather than silently skipped by `list()`.
+     */
+    incomplete() {
+        if (!plugins.fs.existsSync(this.rootDir)) {
+            return [];
+        }
+        return plugins.fs.readdirSync(this.rootDir).filter((nameArg) => {
+            const dir = plugins.path.join(this.rootDir, nameArg);
+            if (!plugins.fs.statSync(dir).isDirectory()) {
+                return false;
+            }
+            const hasAuth = plugins.fs.existsSync(plugins.path.join(dir, AUTH_FILE_NAME));
+            const hasMeta = plugins.fs.existsSync(plugins.path.join(dir, META_FILE_NAME));
+            return hasAuth && !hasMeta;
+        });
+    }
+    /**
+     * Resolves a user-supplied account reference to a stashed email.
+     *
+     * Accepts the exact email, the directory slug, the local part, or a prefix.
+     * Deliberately not a substring match: this reference selects which credential
+     * becomes active, so an incidental substring hit would activate an account the
+     * user never named.
+     */
+    resolve(referenceArg) {
+        const needle = referenceArg.toLowerCase();
+        const all = this.list();
+        const exact = all.find((entryArg) => entryArg.email.toLowerCase() === needle);
+        if (exact) {
+            return { email: exact.email };
+        }
+        const bySlug = all.find((entryArg) => this.slugFor(entryArg.email) === needle);
+        if (bySlug) {
+            return { email: bySlug.email };
+        }
+        const byLocalPart = all.filter((entryArg) => entryArg.email.toLowerCase().split('@')[0] === needle);
+        if (byLocalPart.length === 1) {
+            return { email: byLocalPart[0].email };
+        }
+        if (byLocalPart.length > 1) {
+            return { candidates: byLocalPart.map((entryArg) => entryArg.email) };
+        }
+        const byPrefix = all.filter((entryArg) => entryArg.email.toLowerCase().startsWith(needle));
+        if (byPrefix.length === 1) {
+            return { email: byPrefix[0].email };
+        }
+        return { candidates: byPrefix.map((entryArg) => entryArg.email) };
+    }
+    remove(emailArg) {
+        const dir = this.entryDir(emailArg);
+        if (!plugins.fs.existsSync(dir)) {
+            return false;
+        }
+        plugins.fs.rmSync(dir, { recursive: true, force: true });
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.stashstore.js","sourceRoot":"","sources":["../ts/classes.stashstore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AAOxC,OAAO,EAAE,yBAAyB,EAAE,MAAM,cAAc,CAAC;AAEzD,MAAM,cAAc,GAAG,WAAW,CAAC;AACnC,MAAM,cAAc,GAAG,YAAY,CAAC;AAEpC;;;;;;;;GAQG;AACH,MAAM,OAAO,UAAU;IACL,OAAO,CAAS;IAChB,OAAO,CAAe;IAEtC,YAAY,UAAwB,EAAE,UAAmB;QACvD,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,KAAK,CAAC,2BAA2B,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC1B,MAAM,IAAI,GACR,UAAU;YACV,OAAO,CAAC,GAAG,CAAC,eAAe;YAC3B,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,EAAE,aAAa,CAAC,CAAC;QACzD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;IACrD,CAAC;IAED;;;OAGG;IACI,OAAO,CAAC,QAAgB;QAC7B,MAAM,IAAI,GAAG,QAAQ;aAClB,WAAW,EAAE;aACb,OAAO,CAAC,kBAAkB,EAAE,GAAG,CAAC;aAChC,OAAO,CAAC,gBAAgB,EAAE,EAAE,CAAC,CAAC;QACjC,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,oCAAoC,QAAQ,GAAG,CAAC,CAAC;QACnE,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC9B,OAAO,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjE,CAAC;IAEM,GAAG,CAAC,QAAgB;QACzB,OAAO,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;IAC3F,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CACV,WAA2B,EAC3B,UAAkB,EAClB,cAA0C,EAC1C,YAAoB;QAEpB,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAClD,IAAI,QAAQ,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,WAAW,CAAC,KAAK,IAAI,QAAQ,CAAC,SAAS,KAAK,WAAW,CAAC,SAAS,IAAI,QAAQ,CAAC,IAAI,KAAK,WAAW,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7I,MAAM,IAAI,KAAK,CAAC,uGAAuG,CAAC,CAAC;QAC3H,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC7C,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACrE,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAC5D,0EAA0E;QAC1E,0DAA0D;QAC1D,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC1C,OAAO,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAEjC,MAAM,KAAK,GAAgB;YACzB,KAAK,EAAE,WAAW,CAAC,KAAK;YACxB,IAAI,EAAE,WAAW,CAAC,IAAI;YACtB,SAAS,EAAE,WAAW,CAAC,SAAS;YAChC,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,MAAM,EAAE,WAAW,CAAC,MAAM;YAC1B,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YACnC,SAAS,EAAE,YAAY;YACvB,WAAW,EAAE,cAAc;SAC5B,CAAC;QAEF,yBAAyB,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,EAAE,UAAU,CAAC,CAAC;QAC9E,yBAAyB,CACvB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,EACtC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CACtC,CAAC;QACF,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,QAAgB,EAAE,eAAuB;QACvD,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACrC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,eAAe,CAAC;IACnD,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC9B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAgB,CAAC;QAC9E,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAEM,QAAQ,CAAC,QAAgB;QAC9B,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC,CAAC;QAC5E,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;YACrC,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;IACnD,CAAC;IAED,gFAAgF;IACzE,IAAI;QACT,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACzC,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,OAAO,GAAkB,EAAE,CAAC;QAClC,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3D,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,EAAE,cAAc,CAAC,CAAC;YAC1E,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,CAAC;gBACrC,SAAS;YACX,CAAC;YACD,IAAI,CAAC;gBACH,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAgB,CAAC,CAAC;YACrF,CAAC;YAAC,MAAM,CAAC;gBACP,SAAS;YACX,CAAC;QACH,CAAC;QACD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IAClG,CAAC;IAED;;;;OAIG;IACI,UAAU;QACf,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC;YACzC,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,OAAO,OAAO,CAAC,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE;YAC7D,MAAM,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;YACrD,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;gBAC5C,OAAO,KAAK,CAAC;YACf,CAAC;YACD,MAAM,OAAO,GAAG,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC;YAC9E,MAAM,OAAO,GAAG,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC,CAAC;YAC9E,OAAO,OAAO,IAAI,CAAC,OAAO,CAAC;QAC7B,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;OAOG;IACI,OAAO,CAAC,YAAoB;QACjC,MAAM,MAAM,GAAG,YAAY,CAAC,WAAW,EAAE,CAAC;QAC1C,MAAM,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAExB,MAAM,KAAK,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,MAAM,CAAC,CAAC;QAC9E,IAAI,KAAK,EAAE,CAAC;YACV,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,CAAC;QAChC,CAAC;QACD,MAAM,MAAM,GAAG,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,CAAC;QAC/E,IAAI,MAAM,EAAE,CAAC;YACX,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC;QACjC,CAAC;QACD,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,CAC5B,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,MAAM,CACpE,CAAC;QACF,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,OAAO,EAAE,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;QACzC,CAAC;QACD,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC3B,OAAO,EAAE,UAAU,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QACvE,CAAC;QACD,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3F,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC1B,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;QACtC,CAAC;QACD,OAAO,EAAE,UAAU,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;IACpE,CAAC;IAEM,MAAM,CAAC,QAAgB;QAC5B,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAChC,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;QACzD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist_ts/classes.tui.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from './plugins.js';
+import type { IAuthHarness } from './interfaces.harness.js';
+import { AuthSwitchOperations } from './classes.operations.js';
+/** Owns account-management actions; terminal rendering and interaction belong to smartconsole. */
+export declare class AuthSwitchTui {
+    private readonly harnesses;
+    private readonly out;
+    private readonly operations;
+    constructor(harnesses: readonly IAuthHarness[], out: plugins.smartconsole.SmartConsole, operations?: AuthSwitchOperations);
+    run(preferredArg?: IAuthHarness): Promise<number>;
+}