@deepseek-harness-tui/dsh-tui 0.9.0 → 0.9.2

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/command.js

@@ -0,0 +1,67 @@
+/**
+ * The `/auth` command: a textual veneer over the {@link DshAuthApi} — status
+ * listing, login (optionally picking the provider interactively), logout.
+ *
+ * @module dsh-auth/command
+ */
+const USAGE = 'Usage: /auth [status] | /auth login [provider] | /auth logout <provider>';
+function renderStatus(rows) {
+    const lines = rows.map(row => {
+        const state = row.signedIn
+            ? `signed in — token expires ${new Date(row.expiresAt ?? 0).toISOString()}`
+            : row.expired
+                ? 'signed in, token expired — /auth login to refresh'
+                : 'not signed in';
+        return `  ${row.provider.padEnd(14)} ${state}`;
+    });
+    return ['dsh-auth providers:', ...lines].join('\n');
+}
+/** Split the raw input into at most two lowercase words: verb and target. */
+function parseArgs(raw) {
+    const words = raw.trim().split(/\s+/u).filter(word => word !== '');
+    const verb = words[0]?.toLowerCase();
+    const target = words[1];
+    return { verb: words.length === 0 ? undefined : verb, target };
+}
+/**
+ * Build the `/auth` handler. Every failure returns a `CommandResult`, never a
+ * rejection the host would have to translate; unexpected throws still
+ * propagate for the host's own error surface.
+ */
+export function createAuthCommandHandler(api) {
+    return async (invocation) => {
+        const { verb, target } = parseArgs(invocation.rawInput);
+        if (verb === undefined || verb === 'status') {
+            if (target !== undefined)
+                return { kind: 'error', text: USAGE };
+            return { kind: 'success', text: renderStatus(await api.providers()) };
+        }
+        if (verb === 'login') {
+            try {
+                const result = await api.login(target, invocation.signal);
+                return {
+                    kind: 'success',
+                    text: `Signed in to ${result.oauthLabel} (${result.provider}); token expires `
+                        + `${new Date(result.expiresAt).toISOString()}. Its models are selectable via /model.`,
+                };
+            }
+            catch (error) {
+                return { kind: 'error', text: `dsh-auth: ${error instanceof Error ? error.message : String(error)}` };
+            }
+        }
+        if (verb === 'logout') {
+            if (target === undefined)
+                return { kind: 'error', text: USAGE };
+            try {
+                const removed = await api.logout(target);
+                return removed
+                    ? { kind: 'success', text: `Signed out of ${target}; its stored credential was removed.` }
+                    : { kind: 'error', text: `${target} was not signed in.` };
+            }
+            catch (error) {
+                return { kind: 'error', text: `dsh-auth: ${error instanceof Error ? error.message : String(error)}` };
+            }
+        }
+        return { kind: 'error', text: USAGE };
+    };
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/credentials.d.ts

@@ -0,0 +1,64 @@
+/**
+ * File-backed OAuth credential persistence: a pi-ai `CredentialStore` over
+ * one JSON document, one credential per provider id.
+ *
+ * Writes are atomic (temp file + rename) with 0700 directory / 0600 file
+ * permissions best-effort on every platform. All mutations go through
+ * {@link CredentialFile.modify}, which serializes read-modify-write cycles
+ * per provider in-process — pi-ai runs its OAuth refresh *inside* `modify`,
+ * so the exclusion here is what keeps concurrent requests from
+ * double-refreshing a rotated token. The file is the single source of truth;
+ * nothing here ever logs token material, and {@link CredentialFile.describe}
+ * reports only non-secret metadata for status surfaces.
+ *
+ * @module dsh-auth/credentials
+ */
+import type { Credential, CredentialInfo, CredentialStore } from '@earendil-works/pi-ai';
+/** The stored credential shape: a pi-ai `OAuthCredential`. */
+export interface StoredOAuthCredential {
+    type: 'oauth';
+    access: string;
+    refresh: string;
+    expires: number;
+    [key: string]: unknown;
+}
+/** Narrow an unknown parsed value into a stored credential, or reject it. */
+export declare function asStoredCredential(value: unknown): StoredOAuthCredential | undefined;
+/** Default credential file location: `$DSH_HOME/dsh-auth/credentials.json` (or `~/.dsh/…`). */
+export declare function defaultCredentialsFile(): string;
+/**
+ * The credential file. IO failures throw (loud, naming the path) rather than
+ * degrading to an empty store: silently treating a corrupt or unreadable
+ * credential file as "signed out everywhere" would strand every route behind
+ * a fresh login for no reason.
+ */
+export declare class CredentialFile implements CredentialStore {
+    readonly path: string;
+    /** Per-provider operation chains: modify/delete never overlap for one id. */
+    private readonly chains;
+    private cache;
+    constructor(path: string);
+    /** The stored credential for one provider, possibly expired. */
+    read(providerId: string): Promise<Credential | undefined>;
+    /** Stored credential metadata without resolving or exposing secrets. */
+    list(): Promise<readonly CredentialInfo[]>;
+    /**
+     * Serialized read-modify-write for one provider. `fn` sees the current
+     * credential; returning a new credential persists it, returning
+     * `undefined` leaves the entry unchanged. Resolves with the post-write
+     * credential. Rejections from `fn` propagate without touching the file.
+     */
+    modify(providerId: string, fn: (current: Credential | undefined) => Promise<Credential | undefined>): Promise<Credential | undefined>;
+    /** Remove one provider's credential (logout). */
+    delete(providerId: string): Promise<void>;
+    /** Non-secret metadata for every stored credential, for status surfaces. */
+    describe(): Promise<readonly {
+        provider: string;
+        expiresAt: number;
+        expired: boolean;
+    }[]>;
+    /** Run one operation after every earlier operation for the same provider. */
+    private chain;
+    private load;
+    private save;
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/credentials.js

@@ -0,0 +1,170 @@
+/**
+ * File-backed OAuth credential persistence: a pi-ai `CredentialStore` over
+ * one JSON document, one credential per provider id.
+ *
+ * Writes are atomic (temp file + rename) with 0700 directory / 0600 file
+ * permissions best-effort on every platform. All mutations go through
+ * {@link CredentialFile.modify}, which serializes read-modify-write cycles
+ * per provider in-process — pi-ai runs its OAuth refresh *inside* `modify`,
+ * so the exclusion here is what keeps concurrent requests from
+ * double-refreshing a rotated token. The file is the single source of truth;
+ * nothing here ever logs token material, and {@link CredentialFile.describe}
+ * reports only non-secret metadata for status surfaces.
+ *
+ * @module dsh-auth/credentials
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+/** Narrow an unknown parsed value into a stored credential, or reject it. */
+export function asStoredCredential(value) {
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const record = value;
+    if (record['type'] !== 'oauth')
+        return undefined;
+    if (typeof record['access'] !== 'string' || typeof record['refresh'] !== 'string')
+        return undefined;
+    if (typeof record['expires'] !== 'number' || !Number.isFinite(record['expires']))
+        return undefined;
+    return value;
+}
+/** Default credential file location: `$DSH_HOME/dsh-auth/credentials.json` (or `~/.dsh/…`). */
+export function defaultCredentialsFile() {
+    const override = process.env['DSH_AUTH_CREDENTIALS'];
+    if (override !== undefined && override !== '')
+        return override;
+    const root = process.env['DSH_HOME'] ?? join(homedir(), '.dsh');
+    return join(root, 'dsh-auth', 'credentials.json');
+}
+const EMPTY_DOCUMENT = { version: 1, providers: {} };
+/**
+ * The credential file. IO failures throw (loud, naming the path) rather than
+ * degrading to an empty store: silently treating a corrupt or unreadable
+ * credential file as "signed out everywhere" would strand every route behind
+ * a fresh login for no reason.
+ */
+export class CredentialFile {
+    path;
+    /** Per-provider operation chains: modify/delete never overlap for one id. */
+    chains = new Map();
+    cache;
+    constructor(path) {
+        this.path = path;
+    }
+    /** The stored credential for one provider, possibly expired. */
+    async read(providerId) {
+        return (await this.load()).providers[providerId];
+    }
+    /** Stored credential metadata without resolving or exposing secrets. */
+    async list() {
+        const document = await this.load();
+        return Object.entries(document.providers).map(([providerId, credential]) => ({
+            providerId,
+            type: credential.type,
+        }));
+    }
+    /**
+     * Serialized read-modify-write for one provider. `fn` sees the current
+     * credential; returning a new credential persists it, returning
+     * `undefined` leaves the entry unchanged. Resolves with the post-write
+     * credential. Rejections from `fn` propagate without touching the file.
+     */
+    async modify(providerId, fn) {
+        return this.chain(providerId, async () => {
+            const document = await this.load();
+            const current = document.providers[providerId];
+            const replacement = await fn(current);
+            if (replacement === undefined || replacement === current)
+                return current;
+            if (replacement.type !== 'oauth') {
+                throw new Error(`dsh-auth: refusing to store a "${replacement.type}" credential for "${providerId}" — this store holds OAuth credentials only`);
+            }
+            await this.save({ ...document, providers: { ...document.providers, [providerId]: replacement } });
+            return replacement;
+        });
+    }
+    /** Remove one provider's credential (logout). */
+    async delete(providerId) {
+        await this.chain(providerId, async () => {
+            const document = await this.load();
+            if (!(providerId in document.providers))
+                return;
+            const providers = { ...document.providers };
+            delete providers[providerId];
+            await this.save({ ...document, providers });
+        });
+    }
+    /** Non-secret metadata for every stored credential, for status surfaces. */
+    async describe() {
+        const document = await this.load();
+        const now = Date.now();
+        return Object.entries(document.providers)
+            .filter((entry) => entry[1].type === 'oauth')
+            .map(([provider, credential]) => ({
+            provider,
+            expiresAt: credential.expires,
+            expired: credential.expires <= now,
+        }));
+    }
+    /** Run one operation after every earlier operation for the same provider. */
+    chain(provider, operation) {
+        const run = (this.chains.get(provider) ?? Promise.resolve()).then(operation, operation);
+        this.chains.set(provider, run.then(() => undefined, () => undefined));
+        return run;
+    }
+    async load() {
+        if (this.cache !== undefined)
+            return this.cache;
+        let text;
+        try {
+            text = readFileSync(this.path, 'utf8');
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                this.cache = EMPTY_DOCUMENT;
+                return this.cache;
+            }
+            throw new Error(`dsh-auth: cannot read credential file ${this.path}: ${String(error)}`);
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(text);
+        }
+        catch (error) {
+            throw new Error(`dsh-auth: credential file ${this.path} is not valid JSON (${String(error)}); `
+                + 'fix or remove the file by hand — it will not be overwritten silently');
+        }
+        if (typeof parsed !== 'object' || parsed === null) {
+            throw new Error(`dsh-auth: credential file ${this.path} has an unexpected shape; fix or remove it by hand`);
+        }
+        const record = parsed;
+        if (record['version'] !== 1 || typeof record['providers'] !== 'object' || record['providers'] === null) {
+            throw new Error(`dsh-auth: credential file ${this.path} has an unexpected shape; fix or remove it by hand`);
+        }
+        const providers = {};
+        for (const [provider, value] of Object.entries(record['providers'])) {
+            const credential = asStoredCredential(value);
+            if (credential === undefined) {
+                throw new Error(`dsh-auth: credential file ${this.path} holds an invalid entry for "${provider}"; fix or remove it by hand`);
+            }
+            providers[provider] = credential;
+        }
+        this.cache = { version: 1, providers };
+        return this.cache;
+    }
+    async save(document) {
+        const text = JSON.stringify(document, null, 2) + '\n';
+        const directory = dirname(this.path);
+        mkdirSync(directory, { recursive: true, mode: 0o700 });
+        const temporary = join(directory, `.${Math.random().toString(36).slice(2)}.tmp`);
+        try {
+            writeFileSync(temporary, text, { mode: 0o600 });
+            renameSync(temporary, this.path);
+        }
+        catch (error) {
+            throw new Error(`dsh-auth: cannot write credential file ${this.path}: ${String(error)}`);
+        }
+        this.cache = document;
+    }
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * dsh-auth — subscription OAuth sign-in as LLM provider routes.
+ *
+ * One cordis plugin mounts the pi-ai catalog providers that ship OAuth flows
+ * (ChatGPT/Codex, Claude Pro/Max, SuperGrok) as `llm` registry routes, so
+ * their models appear in every model picker the moment the plugin loads —
+ * signing in is the only missing credential. `PiAiAdapter` runs with this
+ * plugin's file-backed pi-ai `CredentialStore` injected
+ * (`PiAiAuthInjection`): requests resolve the stored OAuth credential through
+ * the provider's own auth and rotate refresh tokens under the store's lock.
+ * Login/logout run over the `userQuestions` seam, so they work on any
+ * interactive surface and refuse cleanly where none exists (TUI-RUN-001).
+ *
+ * ```yaml
+ * - id: dsh-auth
+ *   name: 'dsh-auth'
+ *   config:
+ *     providers: [openai-codex, anthropic, xai]   # subset of the mounted set
+ *     # credentialsFile: /secure/path/credentials.json   # default $DSH_HOME/dsh-auth/
+ * ```
+ *
+ * Routes register individually: a route another adapter family already owns
+ * (an llm-pi-ai settings profile for the same provider) is refused by the
+ * registry — that refusal is logged and the remaining routes still mount.
+ *
+ * @module dsh-auth
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import type { LlmModelInfo } from '@deepseek-ai/dsh-llm';
+import { PiAiAdapter } from '@deepseek-ai/dsh-llm-pi-ai';
+import type { PiAiAdapterOptions } from '@deepseek-ai/dsh-llm-pi-ai';
+export declare const name = "dsh-auth";
+/**
+ * Deliberately empty. A hard code-level inject would deadlock any
+ * composition lacking the `llm`/`commands` services at boot ("pending
+ * (waiting for service: …)") — the failure mode dsh-tui documented for its
+ * own optional rows (#183). Both services resolve per call through
+ * `ctx.get` in {@link apply}; compositions that guarantee them (the
+ * dsh-tui patch row, this package's bundle patch) declare the inject at the
+ * *entry* level, where a stale patch cannot deadlock a newer boot.
+ */
+export declare const inject: readonly string[];
+/** Plugin configuration. */
+export interface Config {
+    /** Provider routes to mount; every entry must ship an OAuth flow in the installed pi-ai catalog. */
+    providers?: string[];
+    /** Credential file override; default `$DSH_HOME/dsh-auth/credentials.json`. */
+    credentialsFile?: string;
+}
+export declare const Config: z<Config>;
+export type { DshAuthApi, DshAuthLoginResult, DshAuthSignInStatus, DshAuthService } from './service.js';
+export { createDshAuthApi } from './service.js';
+export { QuestionBridge, describeEvent } from './interaction.js';
+export type { AskFn, QuestionBridgeHelpers } from './interaction.js';
+export { copyToClipboard, openInBrowser, openerFor } from './opener.js';
+export { CredentialFile, defaultCredentialsFile } from './credentials.js';
+export { OAUTH_PROVIDER_IDS, buildOAuthProfile } from './profiles.js';
+/**
+ * The adapter the plugin registers: a {@link PiAiAdapter} whose *advisory
+ * catalog* is credential-gated. A provider with no stored OAuth credential
+ * lists no models — its rows never reach any model picker, which is the
+ * whole point: picking a model that would only fail with "not signed in"
+ * is noise. The gate only shapes `listModels`; `resolveModel` and requests
+ * are untouched, so a model id already saved in a session (or named
+ * explicitly) keeps resolving exactly as the registry contract promises
+ * ("advisory and never changes routing").
+ *
+ * An expired-but-stored credential still lists: token refresh runs on the
+ * next request, and a picker that hid a refreshable provider would look
+ * signed-out when it is not.
+ */
+export declare class CredentialGatedAdapter extends PiAiAdapter {
+    private readonly hasCredential;
+    constructor(options: PiAiAdapterOptions, hasCredential: (provider: string) => Promise<boolean>);
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+}
+/** Mount the routes, the service, and the command. */
+export declare function apply(ctx: Context, config: Config): void;

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/index.js

@@ -0,0 +1,196 @@
+/**
+ * dsh-auth — subscription OAuth sign-in as LLM provider routes.
+ *
+ * One cordis plugin mounts the pi-ai catalog providers that ship OAuth flows
+ * (ChatGPT/Codex, Claude Pro/Max, SuperGrok) as `llm` registry routes, so
+ * their models appear in every model picker the moment the plugin loads —
+ * signing in is the only missing credential. `PiAiAdapter` runs with this
+ * plugin's file-backed pi-ai `CredentialStore` injected
+ * (`PiAiAuthInjection`): requests resolve the stored OAuth credential through
+ * the provider's own auth and rotate refresh tokens under the store's lock.
+ * Login/logout run over the `userQuestions` seam, so they work on any
+ * interactive surface and refuse cleanly where none exists (TUI-RUN-001).
+ *
+ * ```yaml
+ * - id: dsh-auth
+ *   name: 'dsh-auth'
+ *   config:
+ *     providers: [openai-codex, anthropic, xai]   # subset of the mounted set
+ *     # credentialsFile: /secure/path/credentials.json   # default $DSH_HOME/dsh-auth/
+ * ```
+ *
+ * Routes register individually: a route another adapter family already owns
+ * (an llm-pi-ai settings profile for the same provider) is refused by the
+ * registry — that refusal is logged and the remaining routes still mount.
+ *
+ * @module dsh-auth
+ */
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import z from '@deepseek-ai/schemastery';
+import { PiAiAdapter } from '@deepseek-ai/dsh-llm-pi-ai';
+import { CredentialFile, defaultCredentialsFile } from './credentials.js';
+import { buildOAuthProfile, OAUTH_PROVIDER_IDS } from './profiles.js';
+import { createDshAuthApi, DshAuthService } from './service.js';
+import { createAuthCommandHandler } from './command.js';
+export const name = 'dsh-auth';
+/**
+ * Deliberately empty. A hard code-level inject would deadlock any
+ * composition lacking the `llm`/`commands` services at boot ("pending
+ * (waiting for service: …)") — the failure mode dsh-tui documented for its
+ * own optional rows (#183). Both services resolve per call through
+ * `ctx.get` in {@link apply}; compositions that guarantee them (the
+ * dsh-tui patch row, this package's bundle patch) declare the inject at the
+ * *entry* level, where a stale patch cannot deadlock a newer boot.
+ */
+export const inject = [];
+export const Config = z.object({
+    providers: z.array(z.string()).default([...OAUTH_PROVIDER_IDS]),
+    credentialsFile: z.string(),
+});
+export { createDshAuthApi } from './service.js';
+export { QuestionBridge, describeEvent } from './interaction.js';
+export { copyToClipboard, openInBrowser, openerFor } from './opener.js';
+export { CredentialFile, defaultCredentialsFile } from './credentials.js';
+export { OAUTH_PROVIDER_IDS, buildOAuthProfile } from './profiles.js';
+/**
+ * The ambient auth context providers may consult while resolving their own
+ * auth. `env()` answers from the process environment; `fileExists()` answers
+ * about the host process's filesystem (the paths a provider asks about —
+ * `~/.aws/credentials` and friends — are facts about where this process
+ * runs, not about the project under edit).
+ */
+function hostAuthContext() {
+    return {
+        env: async (name) => process.env[name],
+        fileExists: path => Promise.resolve(path.startsWith('~/') ? existsSync(join(homedir(), path.slice(2))) : existsSync(path)),
+    };
+}
+/**
+ * The adapter the plugin registers: a {@link PiAiAdapter} whose *advisory
+ * catalog* is credential-gated. A provider with no stored OAuth credential
+ * lists no models — its rows never reach any model picker, which is the
+ * whole point: picking a model that would only fail with "not signed in"
+ * is noise. The gate only shapes `listModels`; `resolveModel` and requests
+ * are untouched, so a model id already saved in a session (or named
+ * explicitly) keeps resolving exactly as the registry contract promises
+ * ("advisory and never changes routing").
+ *
+ * An expired-but-stored credential still lists: token refresh runs on the
+ * next request, and a picker that hid a refreshable provider would look
+ * signed-out when it is not.
+ */
+export class CredentialGatedAdapter extends PiAiAdapter {
+    hasCredential;
+    constructor(options, hasCredential) {
+        super(options);
+        this.hasCredential = hasCredential;
+    }
+    async listModels(provider) {
+        if (!(await this.hasCredential(provider)))
+            return [];
+        return super.listModels(provider);
+    }
+}
+/** Mount the routes, the service, and the command. */
+export function apply(ctx, config) {
+    const configured = config.providers ?? [...OAUTH_PROVIDER_IDS];
+    const unknown = configured.filter(id => !OAUTH_PROVIDER_IDS.includes(id));
+    if (unknown.length > 0 || configured.length === 0) {
+        throw new Error(`dsh-auth: providers must be a non-empty subset of [${OAUTH_PROVIDER_IDS.join(', ')}]; got [${configured.join(', ')}]`);
+    }
+    // Profile construction validates the installed catalog loudly: a pi-ai
+    // downgrade that dropped a provider fails the boot that asked for it.
+    const profiles = new Map(configured.map(id => [id, buildOAuthProfile(id)]));
+    const store = new CredentialFile(config.credentialsFile ?? defaultCredentialsFile());
+    // Fail closed on store trouble: a credential file that cannot be read
+    // must not surface forty models that would all fail at request time.
+    const hasCredential = async (provider) => {
+        try {
+            return await store.read(provider) !== undefined;
+        }
+        catch {
+            return false;
+        }
+    };
+    const adapter = new CredentialGatedAdapter({
+        // One immutable map for the plugin's lifetime: the snapshot memoizes on
+        // identity, and route changes here always mean a plugin remount anyway.
+        profiles: () => profiles,
+        // No route ever names an api-key credential, so the override stays
+        // undefined and every request authenticates through the collection's
+        // own auth — the OAuth credential this plugin's store holds.
+        resolveApiKey: async () => undefined,
+        auth: {
+            credentials: store,
+            authContext: hostAuthContext(),
+        },
+        resolveAttachments: () => ctx.get('attachments'),
+        onReplayDegrade: ({ provider, model, reason }) => {
+            ctx.logger.warn(`dsh-auth: replay state on assistant history for ${provider}/${model} degraded: ${reason}`);
+        },
+    }, hasCredential);
+    // The service is a thin holder so UIs can find the api without importing
+    // the plugin module; the defensive get-then-create matches how the TUI
+    // mounts userQuestions.
+    const service = ctx.get('dshAuth') ?? new DshAuthService(ctx);
+    const api = createDshAuthApi({
+        profiles,
+        store,
+        resolveAsk: () => {
+            const questions = ctx.get('userQuestions');
+            return questions === undefined ? undefined : request => questions.ask(request);
+        },
+        logger: ctx.logger,
+    });
+    service.api = api;
+    ctx.effect(function* () {
+        const releases = [];
+        // Runtime service resolution (never a code-level inject — see `inject`):
+        // absent services keep this plugin inert and logged, not the whole boot
+        // tree deadlocked.
+        const llm = ctx.get('llm');
+        const commands = ctx.get('commands');
+        if (llm === undefined) {
+            ctx.logger.warn('dsh-auth: no llm service mounted — provider routes stay unregistered');
+        }
+        else {
+            // Individual registrations: one conflicting route must not strand the
+            // rest (the registry keeps the previous owner serving).
+            for (const id of configured) {
+                try {
+                    releases.push(llm.registerAdapter([id], adapter));
+                }
+                catch (error) {
+                    ctx.logger.error(`dsh-auth: route "${id}" was not registered: ${error instanceof Error ? error.message : String(error)} `
+                        + '(another adapter family may own it — check the llm-pi-ai settings section)');
+                }
+            }
+        }
+        const active = new Set();
+        if (commands === undefined) {
+            ctx.logger.warn('dsh-auth: no commands service mounted — the /auth command stays unregistered');
+        }
+        else {
+            const handler = createAuthCommandHandler(api);
+            releases.push(commands.register({
+                name: 'auth',
+                description: 'Provider subscription sign-in (OAuth): status, login, logout',
+                handler: invocation => {
+                    const operation = handler(invocation);
+                    active.add(operation);
+                    void operation.then(() => active.delete(operation), () => active.delete(operation));
+                    return operation;
+                },
+            }));
+        }
+        // Drain before releasing: LIFO composite teardown lets no new invocation
+        // enter while already-started logins finish their final write.
+        yield async () => { await Promise.allSettled([...active]); };
+        yield () => {
+            for (const release of releases)
+                release();
+        };
+    }, 'dsh-auth lifecycle');
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/interaction.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The `AuthInteraction` bridge: pi-ai OAuth flows speak prompts and events;
+ * every interactive surface in this ecosystem speaks `ctx.userQuestions`.
+ *
+ * `prompt()` maps one pi-ai prompt onto one question — `select` prompts carry
+ * their options, text/secret/manual-code prompts expect the custom-answer
+ * input row.
+ *
+ * `notify()` restores the host contract pi-ai's browser flows assume: the
+ * `auth_url` / `device_code` events expect the *host* to open the browser
+ * (their authorize URLs run hundreds of characters — wrapped across panel
+ * lines they are unclickable, and hand-copying picks up wrap artifacts that
+ * corrupt the encoded `redirect_uri`, which the provider then rejects). So
+ * the bridge opens the URL itself, then shows one waiting panel carrying
+ * copy / reopen / cancel actions until the flow settles. The device-code
+ * path gets the same treatment: its short code is the thing to copy, and
+ * the verification page is auto-opened too.
+ *
+ * One `AbortController` owns the whole run: pi-ai reads `interaction.signal`
+ * to abort the flow, every ask request carries it so surfaces close their
+ * panels, and the waiting panel's cancel action fires it.
+ *
+ * Nothing here assumes a browser or GUI *exists* (TUI-RUN-001): when no
+ * opener or clipboard helper is available the panel degrades to showing the
+ * URL / code verbatim with a clear note, and where no question provider is
+ * registered at all, `ask` rejects and the login command turns that into a
+ * clear refusal.
+ *
+ * @module dsh-auth/interaction
+ */
+import type { AuthEvent, AuthInteraction, AuthPrompt } from '@earendil-works/pi-ai';
+import type { AskUserQuestionItem, AskUserQuestionAnswer } from '@deepseek-ai/dsh-user-questions';
+/** The ask surface this bridge drives (usually `ctx.userQuestions.ask`). */
+export type AskFn = (request: {
+    questions: AskUserQuestionItem[];
+    signal?: AbortSignal;
+}) => Promise<AskUserQuestionAnswer>;
+/** Injectable host conveniences (tests substitute recorders). */
+export interface QuestionBridgeHelpers {
+    openUrl?: (url: string) => boolean;
+    copyText?: (text: string) => Promise<boolean>;
+}
+/** Human-readable copy for one notify event. */
+export declare function describeEvent(event: AuthEvent): string;
+/**
+ * The bridge for one login run. At most one waiting panel exists at a time;
+ * `settle()` retires it when the flow ends (any outcome), so a completed or
+ * failed login never leaves an interactive dead end on screen.
+ */
+export declare class QuestionBridge implements AuthInteraction {
+    private readonly ask;
+    private readonly runAbort;
+    readonly signal: AbortSignal;
+    private readonly openUrl;
+    private readonly copy;
+    private waiting;
+    private waitingClosed;
+    constructor(ask: AskFn, runAbort: AbortController, helpers?: QuestionBridgeHelpers);
+    prompt(prompt: AuthPrompt): Promise<string>;
+    notify(event: AuthEvent): void;
+    /** Close the waiting panel (if any) and stop answering for this run. */
+    settle(): Promise<void>;
+    /**
+     * Show the waiting panel until the flow settles or the user cancels,
+     * re-asking after a copy/reopen action with a one-line status prefix.
+     */
+    private runWaitingPanel;
+}