@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/backends/claude/backend.js

@@ -0,0 +1,296 @@
+/**
+ * The Claude Agent backend: detection (SDK importable? executable found?
+ * validated versions? a credential?), session creation and resume with the
+ * credential plan of auth.ts, and the offline session catalog (catalog.ts).
+ *
+ * Resume: the session's record is looked up (its recorded working
+ * directory is where the CLI must run), its model-visible transcript and
+ * subagent transcripts are read and replayed (replay.ts), and only then is
+ * the CLI started with `resume` — the replay fixes the turn / sequence
+ * numbering the live session continues from. An unknown id or a transcript
+ * the CLI refuses fails loudly; nothing falls back to a fresh session.
+ */
+import { randomUUID } from 'node:crypto';
+import { t } from '../../i18n.js';
+import { CLAUDE_BACKEND_ID, CLAUDE_BACKEND_LABEL, cliVersionDrift, sdkVersionDrift, VALIDATED_SDK_VERSION, claudeResumeCommand } from './contract.js';
+import { CLAUDE_OAUTH_PROVIDER, ClaudeChannelConflictError, channelMissingCredential, detectClaudeAuth, originHost, refreshFailureDebugDetail, refreshFailureStatus, resolveClaudeAuth } from './auth.js';
+import { createClaudeCatalog } from './catalog.js';
+import { resolveStartPermissionMode } from './options.js';
+import { fileClaudePrefs } from './prefs.js';
+import { buildClaudeEnv, readClaudeVersion, resolveClaudeExecutable } from './process.js';
+import { activeProfileOf, fileClaudeChannels, hasChannelConnection } from './channels.js';
+import { fileClaudeChannelTokens } from '../shared/channel-tokens.js';
+import { replayClaudeTranscript } from './replay.js';
+import { installedSdkVersion, loadClaudeSdk } from './sdk.js';
+import { openClaudeSession } from './session.js';
+import { errorText } from './narrow.js';
+/** The user-facing refresh failure: a fixed sentence, the HTTP status at most. */
+function refreshFailedNotice(error) {
+    // A channel connection the session must not run on says so itself: the
+    // refusal sentence is already the actionable one.
+    if (error instanceof ClaudeChannelConflictError)
+        return error.message;
+    const status = refreshFailureStatus(error);
+    return t('claude-auth-refresh-failed', { detail: status === undefined ? '' : t('claude-auth-refresh-status', { status }) });
+}
+/** The settings credentials a channel connection replaces (named in a
+ *  notice; a value never is). */
+const SUPERSEDED_CREDENTIAL_KEYS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN'];
+/** The first non-empty value of `key` in an env record, the name matched
+ *  case-insensitively (auth.ts's `valuesOf` rule). */
+function firstNonEmpty(env, key) {
+    const upper = key.toUpperCase();
+    for (const [name, value] of Object.entries(env)) {
+        if (name.toUpperCase() === upper && typeof value === 'string' && value !== '')
+            return value;
+    }
+    return undefined;
+}
+/**
+ * The start notices of an active channel profile against the effective
+ * settings `env`: a base URL that differs from the settings' (cc-switch),
+ * and which settings credentials the channel replaces this session (key
+ * names only, never values).
+ */
+export function channelStartNotices(channel, settingsEnv) {
+    const notices = [];
+    const settingsUrl = firstNonEmpty(settingsEnv, 'ANTHROPIC_BASE_URL');
+    if (channel.baseUrl !== undefined && settingsUrl !== undefined && settingsUrl !== channel.baseUrl) {
+        notices.push(t('channel-conn-settings-mismatch', { name: channel.name }));
+    }
+    if (channel.baseUrl !== undefined || channel.tokenRef !== undefined) {
+        const superseded = SUPERSEDED_CREDENTIAL_KEYS.filter(key => firstNonEmpty(settingsEnv, key) !== undefined);
+        if (superseded.length > 0)
+            notices.push(t('channel-conn-creds-superseded', { keys: superseded.join(', ') }));
+    }
+    return notices;
+}
+/**
+ * The start notices of the resolved permission mode. A remembered bypass
+ * that was not carried into this session is said once and forgotten, so
+ * the next start resolves quietly.
+ */
+export function startModeNotices(start, prefs) {
+    const notices = [];
+    if (start.downgradedFrom !== undefined)
+        notices.push(t('claude-start-mode-downgraded', { mode: start.downgradedFrom }));
+    // The developer override is never silent: a live-test leftover in the
+    // environment would otherwise change every approval without a trace.
+    if (start.source === 'env')
+        notices.push(t('claude-start-mode-env', { mode: start.mode }));
+    if (start.bypassNotCarried === true) {
+        prefs.write({ permissionMode: null });
+        notices.push(t('claude-start-mode-bypass-not-carried'));
+    }
+    if (start.ignoredOverride !== undefined)
+        notices.push(t('claude-start-mode-env-ignored', { mode: start.ignoredOverride }));
+    return notices;
+}
+/**
+ * Where a persisted session lives and what it replays as. Throws (with a
+ * user-facing sentence) when the store has no such session.
+ */
+export async function loadClaudeTranscript(sdk, target, fallbackCwd, debug = () => undefined) {
+    const info = (target.cwd === undefined ? undefined : await sdk.getSessionInfo(target.sessionId, { dir: target.cwd }))
+        ?? await sdk.getSessionInfo(target.sessionId);
+    if (info === undefined)
+        throw new Error(t('claude-resume-not-found', { id: target.sessionId }));
+    const cwd = info.cwd ?? target.cwd ?? fallbackCwd;
+    const [messages, subagentIds] = await Promise.all([
+        sdk.getSessionMessages(target.sessionId, { dir: cwd, includeSystemMessages: true }),
+        sdk.listSubagents(target.sessionId, { dir: cwd }),
+    ]);
+    const subagents = new Map();
+    await Promise.all(subagentIds.map(async (agentId) => {
+        const transcript = await sdk.getSubagentMessages(target.sessionId, agentId, { dir: cwd });
+        // parent_agent_id: the agent that spawned this
+        // child — null/absent = a depth-1 child (main loop) or old-format
+        // metadata, never an orphan to drop. The transcript is keyed by the
+        // delegating call when the messages carry one, and by the child's own
+        // id as well, so replay can heal a nesting whose call attribution the
+        // store never recorded.
+        const parentAgent = transcript.find(message => typeof message.parent_agent_id === 'string')?.parent_agent_id;
+        const entry = { agentId, messages: transcript, ...(typeof parentAgent === 'string' ? { parentAgentId: parentAgent } : {}) };
+        const parent = transcript.find(message => typeof message.parent_tool_use_id === 'string')?.parent_tool_use_id;
+        if (typeof parent === 'string')
+            subagents.set(parent, entry);
+        if (!subagents.has(agentId))
+            subagents.set(agentId, entry);
+    }));
+    const title = info.customTitle?.trim();
+    const replay = replayClaudeTranscript(messages, { cwd, subagents, ...(title === undefined || title === '' ? {} : { title }), debug });
+    return { cwd, replay };
+}
+/** The catalog of the local session store (the SDK loads on first use). */
+const catalogPrefs = fileClaudePrefs();
+export const claudeBackend = {
+    id: CLAUDE_BACKEND_ID,
+    descriptor: { label: CLAUDE_BACKEND_LABEL },
+    /** What is installed and whether it is the validated pair. Never throws. */
+    async detect(host) {
+        try {
+            await loadClaudeSdk();
+        }
+        catch (error) {
+            host.debug(`claude: SDK import failed (${errorText(error)})`);
+            return { installed: false, hint: t('claude-sdk-missing', { version: VALIDATED_SDK_VERSION }) };
+        }
+        let auth = 'unknown';
+        try {
+            auth = await detectClaudeAuth(process.env, host.oauthCredential?.(CLAUDE_OAUTH_PROVIDER));
+        }
+        catch (error) {
+            host.debug(`claude: credential detection failed (${errorText(error)})`);
+        }
+        try {
+            const executable = await resolveClaudeExecutable();
+            const version = executable.path === undefined ? undefined : await readClaudeVersion(executable.path);
+            const drift = cliVersionDrift(version) ?? sdkVersionDrift(installedSdkVersion());
+            return { installed: true, auth, ...(version === undefined ? {} : { version }), ...(drift === undefined ? {} : { drift }), ...(auth === 'missing' ? { hint: t('claude-auth-missing-hint') } : {}) };
+        }
+        catch (error) {
+            host.debug(`claude: detection failed (${errorText(error)})`);
+            return { installed: true, auth };
+        }
+    },
+    launch: {
+        sessionPrefs: debug => {
+            const prefs = fileClaudePrefs(undefined, debug);
+            return {
+                lastSession: () => prefs.read().lastSession,
+                setLastSession: sessionId => { prefs.write({ lastSession: sessionId }); },
+                touch: sessionId => { prefs.touch(sessionId); },
+                forget: sessionId => { prefs.forget(sessionId); },
+            };
+        },
+        resumeCommand: claudeResumeCommand,
+    },
+    catalog: createClaudeCatalog({
+        loadSdk: loadClaudeSdk,
+        cwd: () => process.cwd(),
+        lastUsed: () => catalogPrefs.read().lastUsed ?? {},
+    }),
+    /** Create a session in `target.cwd` (an explicit session id, so the TUI
+     *  knows it before the CLI's first `init`), or resume a persisted one. */
+    async open(target, host) {
+        let sdk;
+        try {
+            sdk = await loadClaudeSdk();
+        }
+        catch (error) {
+            host.debug(`claude: SDK import failed (${errorText(error)})`);
+            throw new Error(t('claude-sdk-missing', { version: VALIDATED_SDK_VERSION }));
+        }
+        const resumed = target.kind === 'resume'
+            ? await loadClaudeTranscript(sdk, target, host.cwd, message => host.debug(message))
+            : undefined;
+        const cwd = resumed?.cwd ?? (target.kind === 'create' ? target.cwd : host.cwd);
+        // The backend-scoped prefs: the remembered model / effort / permission
+        // picks. One store for the whole open — the start resolution reads the
+        // mode here, the session's controls keep writing all three later.
+        const prefs = fileClaudePrefs(undefined, message => host.debug(message));
+        const [executable, start] = await Promise.all([
+            resolveClaudeExecutable(),
+            resolveStartPermissionMode(sdk, cwd, process.env, prefs.read().permissionMode),
+        ]);
+        const sdkVersion = installedSdkVersion();
+        // The credential: a dsh-auth login wins (refreshed now if
+        // it is about to expire), else the environment, else the local login.
+        const credentials = host.oauthCredential?.(CLAUDE_OAUTH_PROVIDER);
+        const baseEnv = buildClaudeEnv();
+        // The route decides whether the subscription token may be injected at
+        // all (auth.ts): the CLI applies the settings' `env`, so a base URL set
+        // in ~/.claude/settings.json counts like one in the environment.
+        const settings = async () => (await sdk.resolveSettings({ cwd, settingSources: ['user', 'project', 'local'] })).effective;
+        // The channel store and the token store are read fresh for every plan
+        // (the open and each reconnect): a /channel switch while the session
+        // lives is picked up by its next spawn.
+        const channels = fileClaudeChannels(undefined, message => host.debug(message));
+        const tokens = fileClaudeChannelTokens(undefined, message => host.debug(message));
+        // A custom endpoint the profile gives no credential (no token, a
+        // dangling ref, no credential key in its env) never spawns; the refusal
+        // says where to add the token.
+        const channelConnection = () => {
+            const active = activeProfileOf(channels.read());
+            if (active === undefined || !hasChannelConnection(active))
+                return undefined;
+            const connection = {
+                ...(active.baseUrl === undefined ? {} : { baseUrl: active.baseUrl }),
+                ...(active.tokenRef === undefined ? {} : { token: tokens.read(active.tokenRef) }),
+                ...(active.env === undefined ? {} : { env: active.env }),
+            };
+            if (channelMissingCredential(connection)) {
+                throw new ClaudeChannelConflictError(t('claude-channel-token-missing', { name: active.name, host: originHost(active.baseUrl ?? '') }));
+            }
+            return connection;
+        };
+        const startNotices = [];
+        // Once per start: which base URL wins this session (the profile's; the
+        // settings file keeps its own for a plain `claude` run) and which
+        // settings credentials the channel replaces (names only).
+        try {
+            const effective = await settings();
+            const settingsEnv = typeof effective.env === 'object' && effective.env !== null ? effective.env : {};
+            const activeAtStart = activeProfileOf(channels.read());
+            if (activeAtStart !== undefined)
+                startNotices.push(...channelStartNotices(activeAtStart, settingsEnv));
+        }
+        catch {
+            // The notices are informational; an unreadable settings file has
+            // already failed closed in the route gate below.
+        }
+        let plan;
+        try {
+            const connection = channelConnection();
+            plan = await resolveClaudeAuth(baseEnv, credentials, { settings, ...(connection === undefined ? {} : { channel: connection }) });
+        }
+        catch (error) {
+            // A channel connection that must not run (a tokenless custom
+            // endpoint, an apiKeyHelper conflict) refuses the start: never a
+            // silent fallback to ambient credentials or an anonymous request.
+            if (error instanceof ClaudeChannelConflictError)
+                throw error;
+            // A failed refresh must not stop the start: the session runs on the
+            // environment or the local login, and says why. The debug log gets a
+            // fixed failure category and at most the HTTP status: the refresh
+            // error can carry the OAuth endpoint's response body, which may echo
+            // request material (auth.ts contract).
+            host.debug(`claude: dsh-auth refresh failed (${refreshFailureDebugDetail(error)})`);
+            startNotices.push(refreshFailedNotice(error));
+            plan = await resolveClaudeAuth(baseEnv, undefined, { settings });
+        }
+        startNotices.push(...startModeNotices(start, prefs));
+        if (sdkVersionDrift(sdkVersion) !== undefined)
+            startNotices.push(t('claude-sdk-drift', { version: sdkVersion ?? '', validated: VALIDATED_SDK_VERSION }));
+        return openClaudeSession({
+            sdk,
+            store: sdk,
+            cwd,
+            sessionId: target.kind === 'resume' ? target.sessionId : randomUUID(),
+            ...(resumed === undefined ? {} : { resume: resumed.replay }),
+            start,
+            executable,
+            env: baseEnv,
+            auth: {
+                plan,
+                // A reconnect re-reads the environment and settings. After an
+                // authentication failure the refused token is refreshed only if
+                // dsh-auth still holds it (compare-and-swap); `/login` uses the
+                // stored credential as is.
+                renew: renewal => {
+                    const channel = channelConnection();
+                    return resolveClaudeAuth(buildClaudeEnv(), credentials, {
+                        settings,
+                        ...(renewal.rejected === undefined ? {} : { rejected: renewal.rejected }),
+                        ...(channel === undefined ? {} : { channel }),
+                    });
+                },
+                failureNotice: refreshFailedNotice,
+            },
+            prefs,
+            host: { debug: message => host.debug(message), ...(host.stderr === undefined ? {} : { stderr: (line) => host.stderr?.(line) }) },
+            ...(sdkVersion === undefined ? {} : { sdkVersion }),
+            startNotices,
+        });
+    },
+};

package/lib/types/backends/claude/catalog.d.ts

@@ -0,0 +1,17 @@
+import type { SDKSessionInfo } from '@anthropic-ai/claude-agent-sdk';
+import type { SessionCatalog } from '../../agent/backend.js';
+import type { SessionSummary } from '../../adapter/ports/channel-session.js';
+import type { ClaudeSessionStoreSdk } from './sdk.js';
+export interface ClaudeCatalogDeps {
+    /** The session-store API (loaded on first use; the SDK is an optional peer). */
+    loadSdk(): Promise<Pick<ClaudeSessionStoreSdk, 'listSessions' | 'getSessionInfo' | 'getSessionMessages' | 'renameSession' | 'deleteSession'>>;
+    /** The directory a listing without a scope looks in. */
+    cwd(): string;
+    /** This install's last-used notes (epoch ms by session id). */
+    lastUsed?(): Readonly<Record<string, number>>;
+}
+/** One SDK record as a browser row. */
+export declare function claudeSessionSummary(info: SDKSessionInfo, lastUsed?: Readonly<Record<string, number>>): SessionSummary;
+/** The catalog over one SDK session store. */
+export declare function createClaudeCatalog(deps: ClaudeCatalogDeps): SessionCatalog;
+//# sourceMappingURL=catalog.d.ts.map

package/lib/types/backends/claude/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/catalog.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,KAAK,EAAE,cAAc,EAAoB,MAAM,wBAAwB,CAAA;AAC9E,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,wCAAwC,CAAA;AAG1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAErD,MAAM,WAAW,iBAAiB;IAChC,gFAAgF;IAChF,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,qBAAqB,EAAE,cAAc,GAAG,gBAAgB,GAAG,oBAAoB,GAAG,eAAe,GAAG,eAAe,CAAC,CAAC,CAAA;IAC7I,wDAAwD;IACxD,GAAG,IAAI,MAAM,CAAA;IACb,+DAA+D;IAC/D,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC9C;AAKD,uCAAuC;AACvC,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,EAAE,QAAQ,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAM,GAAG,cAAc,CAgC1H;AAED,8CAA8C;AAC9C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,iBAAiB,GAAG,cAAc,CAiC3E"}

package/lib/types/backends/claude/catalog.js

@@ -0,0 +1,94 @@
+/**
+ * The Claude Agent backend's offline session catalog: the SDK's session-store
+ * API is the source of truth — the CLI
+ * writes `~/.claude/projects/<cwd>/<id>.jsonl`, the SDK lists, reads, renames,
+ * deletes and forks — and this module only maps its records onto the session
+ * browser's `SessionSummary` rows. Nothing is written to the transcripts here
+ * beyond what the SDK's own mutations write (a rename appends a
+ * `custom-title` entry), and no second index is kept.
+ *
+ * Listing: `includeProgrammatic` is passed `true`. Sessions this
+ * backend creates carry the SDK entrypoint `sdk-ts`, which
+ * `includeProgrammatic:false` (the parity setting of the CLI's own `/resume`
+ * picker) hides — they would vanish from the browser that made them. The
+ * price is that other headless runs (`claude -p`, other SDK hosts) list too.
+ *
+ * Titles: SDK 0.3.287 reports the user's `/rename` title and the CLI's
+ * generated title through the same `customTitle` field (it falls back to
+ * `aiTitle`), so a titled row is `auto`; an untitled one shows its first
+ * prompt (`prompt`), else the directory name (`fallback`).
+ */
+import { basename } from 'node:path';
+import { CLAUDE_BACKEND_ID } from './contract.js';
+import { previewEntries } from './replay.js';
+/** Preview depth when the caller names none. */
+const PREVIEW_LIMIT = 6;
+/** One SDK record as a browser row. */
+export function claudeSessionSummary(info, lastUsed = {}) {
+    const cwd = info.cwd ?? '';
+    const titled = info.customTitle?.trim();
+    const prompt = info.firstPrompt?.trim();
+    const summary = info.summary.trim();
+    const title = titled !== undefined && titled !== ''
+        ? { text: titled, source: 'auto' }
+        : prompt !== undefined && prompt !== ''
+            ? { text: prompt, source: 'prompt' }
+            : summary !== ''
+                ? { text: summary, source: 'prompt' }
+                : { text: basename(cwd) || info.sessionId, source: 'fallback' };
+    const used = lastUsed[info.sessionId];
+    return {
+        id: info.sessionId,
+        backendId: CLAUDE_BACKEND_ID,
+        kind: { kind: 'root' },
+        title,
+        cwd,
+        createdAt: info.createdAt ?? info.lastModified,
+        // The later of the transcript's own mtime and this install's last-used
+        // note (the DSH rule: two lower bounds on "last touched").
+        updatedAt: Math.max(info.lastModified, used ?? 0),
+        bytes: info.fileSize,
+        // The SDK lists only sessions with an extractable prompt or title.
+        hasPrompt: true,
+        agentPreset: undefined,
+        model: undefined,
+        label: undefined,
+        branch: info.gitBranch === undefined || info.gitBranch === '' ? undefined : info.gitBranch,
+        childCount: 0,
+    };
+}
+/** The catalog over one SDK session store. */
+export function createClaudeCatalog(deps) {
+    const lastUsed = () => deps.lastUsed?.() ?? {};
+    const dirOption = (cwd) => cwd === undefined || cwd === '' ? undefined : { dir: cwd };
+    return {
+        async list(scope = {}) {
+            const sdk = await deps.loadSdk();
+            const infos = scope.allProjects === true
+                ? await sdk.listSessions({ includeProgrammatic: true })
+                : await sdk.listSessions({ dir: scope.cwd ?? deps.cwd(), includeProgrammatic: true });
+            const used = lastUsed();
+            return infos.map(info => claudeSessionSummary(info, used)).sort((a, b) => b.updatedAt - a.updatedAt);
+        },
+        async info(sessionId, cwd) {
+            const sdk = await deps.loadSdk();
+            // A session recorded elsewhere than `cwd` is still found: the scoped
+            // lookup first (one directory), then every project.
+            const info = (cwd === undefined ? undefined : await sdk.getSessionInfo(sessionId, { dir: cwd })) ?? await sdk.getSessionInfo(sessionId);
+            return info === undefined ? undefined : claudeSessionSummary(info, lastUsed());
+        },
+        async preview(sessionId, options = {}) {
+            const sdk = await deps.loadSdk();
+            const messages = await sdk.getSessionMessages(sessionId, { ...dirOption(options.cwd) });
+            return previewEntries(messages, options.limit ?? PREVIEW_LIMIT);
+        },
+        async rename(sessionId, title, cwd) {
+            const sdk = await deps.loadSdk();
+            await sdk.renameSession(sessionId, title, dirOption(cwd));
+        },
+        async delete(sessionId, cwd) {
+            const sdk = await deps.loadSdk();
+            await sdk.deleteSession(sessionId, dirOption(cwd));
+        },
+    };
+}

package/lib/types/backends/claude/channels.d.ts

@@ -0,0 +1,63 @@
+import { channelProfileSlug } from '../../channel/channel-slug.js';
+/** One relay channel. */
+export interface ClaudeChannelProfile {
+    /** Stable slug of the name (the file's join key). */
+    readonly id: string;
+    /** Human-facing label (picker rows, notices). */
+    readonly name: string;
+    /** Exact requested-id → actual model (optional). */
+    readonly models?: Readonly<Record<string, string>>;
+    /** Tier keyword → actual model (optional; `default` = the any-model rule). */
+    readonly tiers?: Readonly<Record<string, string>>;
+    /** The relay endpoint the CLI child is pointed at (optional). */
+    readonly baseUrl?: string;
+    /** The credential-store ref holding the channel token (optional; never
+     *  the token itself). */
+    readonly tokenRef?: string;
+    /** Channel-private env layered under baseUrl/token at spawn (optional). */
+    readonly env?: Readonly<Record<string, string>>;
+}
+/** What persists. */
+export interface ClaudeChannelsData {
+    /** The id of the channel whose mapping is live; absent = none. */
+    readonly active?: string;
+    readonly channels: readonly ClaudeChannelProfile[];
+}
+/** Read / switch / upsert access (injectable: tests use an in-memory store). */
+export interface ClaudeChannels {
+    read(): ClaudeChannelsData;
+    /** Make `id` the active channel (a no-op when no such channel exists). */
+    setActive(id: string): void;
+    /** Insert or refresh one profile by id (a re-import refreshes in place). */
+    save(profile: ClaudeChannelProfile): void;
+    /** Drop one profile by id; a dangling `active` goes
+     *  with it (no channel left active until the next pick). */
+    remove(id: string): void;
+}
+/** The stable id of a channel name (shared with the /channel wizard). */
+export declare const channelSlug: typeof channelProfileSlug;
+/** Narrow a parsed document to what persists (anything else reads as absent). */
+export declare function parseChannels(parsed: unknown): ClaudeChannelsData;
+/** The channel whose mapping is live (undefined when none is active). */
+export declare function activeProfileOf(data: ClaudeChannelsData): ClaudeChannelProfile | undefined;
+/** The file-backed profiles under `<dir>` (default `~/.dsh-tui/backends/claude`). */
+export declare function fileClaudeChannels(dir?: string, debug?: (message: string) => void): ClaudeChannels;
+/** An in-memory store (tests, embedders without a home directory). */
+export declare function memoryClaudeChannels(initial?: ClaudeChannelsData): ClaudeChannels & {
+    readonly data: ClaudeChannelsData;
+};
+/**
+ * The channel profile hiding in the CLI settings `env`: the ANTHROPIC_BASE_URL
+ * host names it, the ANTHROPIC_DEFAULT_*_MODEL (+ ANTHROPIC_MODEL) values
+ * become its tiers. Exact `models` are never guessed — those stay the user's
+ * own hand-written entries, and a re-import of the same id keeps them.
+ * Undefined when the env holds neither a base URL nor any model value.
+ */
+export declare function importFromSettingsEnv(env: Record<string, string | undefined>, existing?: ClaudeChannelProfile): ClaudeChannelProfile | undefined;
+/** The channel token in the CLI settings env: the value of
+ *  `ANTHROPIC_AUTH_TOKEN`, for the caller to move into the credential store
+ *  — the profile itself only ever records the derived `tokenRef`. */
+export declare function importTokenFromSettingsEnv(env: Record<string, string | undefined>): string | undefined;
+/** A channel profile's connection carries anything spawn-shaping. */
+export declare function hasChannelConnection(profile: ClaudeChannelProfile | undefined): boolean;
+//# sourceMappingURL=channels.d.ts.map

package/lib/types/backends/claude/channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channels.d.ts","sourceRoot":"","sources":["../../../../src/backends/claude/channels.ts"],"names":[],"mappings":"AAgDA,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAA;AAIlE,yBAAyB;AACzB,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB,iDAAiD;IACjD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oDAAoD;IACpD,QAAQ,CAAC,MAAM,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACjD,iEAAiE;IACjE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;IACzB;6BACyB;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAChD;AAED,qBAAqB;AACrB,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,oBAAoB,EAAE,CAAA;CACnD;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,IAAI,IAAI,kBAAkB,CAAA;IAC1B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,4EAA4E;IAC5E,IAAI,CAAC,OAAO,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACzC;gEAC4D;IAC5D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAA;CACzB;AAID,yEAAyE;AACzE,eAAO,MAAM,WAAW,2BAAqB,CAAA;AAY7C,iFAAiF;AACjF,wBAAgB,aAAa,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CA6BjE;AAED,yEAAyE;AACzE,wBAAgB,eAAe,CAAC,IAAI,EAAE,kBAAkB,GAAG,oBAAoB,GAAG,SAAS,CAE1F;AAsBD,qFAAqF;AACrF,wBAAgB,kBAAkB,CAAC,GAAG,GAAE,MAA6C,EAAE,KAAK,GAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAsB,GAAG,cAAc,CA8DzJ;AAED,sEAAsE;AACtE,wBAAgB,oBAAoB,CAAC,OAAO,GAAE,kBAAqC,GAAG,cAAc,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,CAS3I;AAgBD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACvC,QAAQ,CAAC,EAAE,oBAAoB,GAC9B,oBAAoB,GAAG,SAAS,CAsClC;AAED;;qEAEqE;AACrE,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,GAAG,MAAM,GAAG,SAAS,CAEtG;AAED,qEAAqE;AACrE,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,GAAG,SAAS,GAAG,OAAO,CAGvF"}