@toddzheng024/dscode-bundle 0.1.0

package/vendor/tui/types/app.d.ts

@@ -0,0 +1,304 @@
+/**
+ * The Ink terminal app: whale-and-wordmark header in DeepSeek blue, the live
+ * transcript, the todo panel, the streaming line, the approval bar, the model
+ * panel, local notices, and the input box with history and slash-command
+ * completion. All state arrives through the transcript store (derived from
+ * the durable session log) plus local input state; the app owns no session
+ * mutation of its own.
+ *
+ * Element construction uses `createElement` (not JSX): the `dsh` source launch
+ * compiles this file through tsx's ESM-only hook, which does not adopt this
+ * package's `jsx: react-jsx` compiler option, and the classic JSX runtime
+ * would demand a React global.
+ *
+ * @module @deepseek-ai/dsh-code/app
+ */
+import { type ReactElement } from 'react';
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+import type { ContentBlock, FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
+import type { AuthorizationInteraction, AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
+import { type ThemeName } from './theme.ts';
+import type { TranscriptStore } from './store.ts';
+import { type TranscriptEntry } from './render/projection.ts';
+import type { ApprovalStore } from './approval.ts';
+import { type CommandsView } from './commands.ts';
+import type { ModelDirectory, ModelRow } from './models.ts';
+import { type DiscoveredModelView, type ProviderConfiguration, type ProviderSettingsDirectory, type ProviderTargetView } from './provider-settings.ts';
+import type { QuestionStore } from './questions.ts';
+import type { SkillsView, SkillRow } from './skills.ts';
+import { type MentionCandidate } from './mentions.ts';
+import type { SubagentFeedView } from './subagents.ts';
+import { type JobRow } from './kernel-panels.ts';
+import type { PresetRow } from './presets.ts';
+import type { PermissionRow } from './permissions.ts';
+import type { PluginRow } from './plugin-inventory.ts';
+import type { SessionDirectoryOptions, SessionRow } from './session-directory.ts';
+import type { GitDiffView } from './git-workflow.ts';
+import { type ProviderAuthorizationDirectory, type ProviderAuthorizationRow } from './authorization.ts';
+import { type FilePathInspection, type ImagePathInspection } from './attachments.ts';
+/** Visual priority for one bounded local notice. */
+export type NoticeTone = 'info' | 'warning' | 'error';
+/** Props the runner hands the app; callbacks stay owned by the runner. */
+export interface AppProps {
+    /** Event-fed transcript store for the live session. */
+    store: TranscriptStore;
+    /** Approval-question store fed by the answerer listener. */
+    approval: ApprovalStore;
+    /** ask_user_question store fed by the single UI provider. */
+    questions: QuestionStore;
+    /** Live subagent activity feed (child sessions of the current root). */
+    subagents: SubagentFeedView;
+    /** Live slash-command descriptor list (completion candidates). */
+    commands: CommandsView;
+    /** Live user-invocable skill catalog (completion candidates). */
+    skills: SkillsView;
+    /** `provider/model` selection serving this session (updated on /model). */
+    model: string;
+    /** Effective reasoning effort in force ('' when none), for the /model picker mark. */
+    effort?: string;
+    /** Working-directory basename the session serves. */
+    cwd: string;
+    /** Absolute working directory used by session filters and references. */
+    workspaceRoot: string;
+    /** Git branch name, empty outside a repository. */
+    branch: string;
+    /** Short session identifier. */
+    sessionId: string;
+    /** Whether this session was resumed from persistence. */
+    resumed: boolean;
+    /** Agent preset selected for the current or pending first session. */
+    mode: string;
+    /** Permission preset selected for the current or pending first session. */
+    permission: string;
+    /**
+     * Submit one line: slash commands to the registry, other text to the agent.
+     * The optional origin names the session the submission was composed for —
+     * an attachment prepare resolves after the app remounted onto another
+     * session, and the runner drops the stale delivery then.
+     */
+    dispatch(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
+    /** Submit steering, with the same stale-delivery guard as {@link dispatch}. */
+    steer(text: string, attachments?: readonly ContentBlock[], origin?: string): void;
+    /**
+     * The FULL current session identity ('' while the first session is pending)
+     * — the stale-delivery origin above. Distinct from the short display id.
+     */
+    sessionKey: string;
+    /** Interrupt the running turn (Esc); true when a turn was cancelled. */
+    interrupt(): boolean;
+    /** Quit: unmount, flush, and request process exit. */
+    quit(): void;
+    /** Load the selectable model directory (called when /model opens). */
+    loadModels(): Promise<ModelDirectory>;
+    /** Load @mention candidates for the typed query (files + sessions). */
+    loadMentions(query: string, signal?: AbortSignal): Promise<readonly MentionCandidate[]>;
+    /** Validate draft image paths without committing attachment objects. */
+    inspectImages(paths: readonly string[]): Promise<readonly ImagePathInspection[]>;
+    /** Validate, normalize and persist images immediately before submission. */
+    prepareImages(paths: readonly string[], signal?: AbortSignal): Promise<readonly ImageBlock[]>;
+    /** Validate draft non-image file paths without committing attachment objects. */
+    inspectFiles(paths: readonly string[]): Promise<readonly FilePathInspection[]>;
+    /** Persist non-image files immediately before submission as durable file blocks. */
+    prepareFiles(paths: readonly string[], signal?: AbortSignal): Promise<readonly FileBlock[]>;
+    /** Apply one /model selection (with an advertised reasoning effort, when picked); returns the display label. */
+    selectModel(row: ModelRow, effortId?: string): string;
+    /** The /subagent override label, '' when delegated agents follow the current model. */
+    subagentModel: string;
+    /** Apply one /subagent model pick; returns the override label. */
+    setSubagentModel(row: ModelRow, effortId?: string): string;
+    /** Drop the /subagent override (delegated agents follow the current model). */
+    clearSubagentModel(): void;
+    /** Delete one session subtree; resolves with the outcome line. */
+    deleteSession(id: string): Promise<string>;
+    /** Load provider/settings/credential facts for the optional /model provider stage. */
+    loadModelProviders?(): Promise<ProviderSettingsDirectory>;
+    /** Subscribe to Harness credential/settings/adapter invalidations while /model is open. */
+    subscribeModelProviders?(listener: () => void): () => void;
+    /** Store or rotate one provider credential through the Harness credential service. */
+    saveModelProviderCredential?(target: ProviderTargetView, key: string): Promise<void>;
+    /** Remove one writable provider credential without removing its settings profile. */
+    unsetModelProviderCredential?(target: ProviderTargetView): Promise<void>;
+    /** Remove one user-owned provider profile and its page-managed credential. */
+    removeModelProvider?(target: ProviderTargetView): Promise<void>;
+    /** Save endpoint and explicit model capacities through the provider profile. */
+    saveModelProviderConfiguration?(target: ProviderTargetView, configuration: ProviderConfiguration): Promise<void>;
+    /**
+     * Interrogate the provider's real endpoint (typed key wins over the stored
+     * credential) for the models it actually serves — the discovery stage of
+     * the provider setup page.
+     */
+    discoverModelProvider?(target: ProviderTargetView, request: {
+        readonly apiKey?: string;
+        readonly baseURL?: string;
+    }, signal?: AbortSignal): Promise<readonly DiscoveredModelView[]>;
+    /** Provider authorization flows and value-free stored-record facts. */
+    loadProviderAuthorizations?(): Promise<ProviderAuthorizationDirectory>;
+    subscribeProviderAuthorizations?(listener: () => void): () => void;
+    beginProviderAuthorization?(row: ProviderAuthorizationRow, method: string, interaction: AuthorizationInteraction, signal: AbortSignal): Promise<AuthorizationStatus>;
+    cancelProviderAuthorization?(row: ProviderAuthorizationRow): void;
+    logoutProviderAuthorization?(row: ProviderAuthorizationRow): Promise<void>;
+    openAuthorizationUrl?(url: string): boolean;
+    copyTextValue?(text: string): Promise<void>;
+    /** Cycle to the next permission preset (Shift+Tab); returns the new label. */
+    cyclePermission(): string;
+    /** Select or inspect a permission preset without requiring a pre-existing session. */
+    setPermission(id: string): string;
+    /** Export the transcript to a markdown file (/export [path]); reports via notices. */
+    exportTranscript(argument: string): Promise<void>;
+    /** Rename the session (/title <text>); returns the outcome line for the notice. */
+    renameTitle(argument: string): string;
+    /** Copy the latest complete assistant response; resolves to notice text. */
+    copyLastResponse(): Promise<string>;
+    /** Load a complete read-only Git diff for the file-oriented viewport. */
+    loadGitDiff(argument: string): Promise<GitDiffView>;
+    /** Start a model review after applying the read-only permission preset. */
+    reviewChanges(argument: string): void;
+    /** Preset/session/plugin kernel operations. */
+    loadPresets(): Promise<readonly PresetRow[]>;
+    switchMode(id: string): Promise<string>;
+    /** Load the switchable permission presets for the /permission panel. */
+    loadPermissions(): Promise<readonly PermissionRow[]>;
+    createSession(mode?: string): void;
+    /** Fork the active session at a completed-turn boundary. */
+    forkSession(argument: string): void;
+    loadSessions(options: SessionDirectoryOptions, signal?: AbortSignal): Promise<readonly SessionRow[]>;
+    loadSessionTranscript(id: string, signal?: AbortSignal): Promise<string>;
+    /** Load this session's subagent conversations (children by lineage). */
+    loadSubagents(): Promise<readonly SessionRow[]>;
+    switchSession(row: SessionRow): void;
+    cancelSessionSwitch(): boolean;
+    loadPlugins(): readonly PluginRow[];
+    /** Caller-visible background jobs (the host jobs registry, read-only). */
+    loadJobs(): readonly JobRow[];
+    /** Registers the app's notice channel with the runner (called once on mount). */
+    onBridgeReady(bridge: {
+        notify(text: string, tone?: NoticeTone): void;
+    }): void;
+    /** Ordered enabled status items (/statusline config); the runner owns persistence. */
+    statusline: readonly string[];
+    /** Persist a new statusline item set; the runner surfaces IO failures as notices. */
+    saveStatusline(items: readonly string[]): void;
+    /** Apply and persist one /theme selection; the runner owns the theme.json file. */
+    saveTheme?(name: ThemeName): void;
+    /** Whether timed animations run at startup (animations.json; on by default
+     * — like parseAnimationsPref, only an explicit false disables them). */
+    animations?: boolean;
+    /** Apply and persist one /animation toggle; the runner owns the file. */
+    saveAnimations?(enabled: boolean): void;
+    /** Persistent cross-session input history (oldest first); the runner owns the file. */
+    history: readonly string[];
+    /** Persist one submitted prompt to the global history file. */
+    recordHistory(text: string): void;
+    /** Cancel one queued inbox message by identity (Delete on the empty composer). */
+    cancelQueued(messageId: string): void;
+    /** Apply the Ctrl+R terminal passthrough to the detected editor (/vscode-keys); resolves to a one-line summary. */
+    applyEditorKeys(): Promise<string>;
+}
+/** One completion candidate row. */
+interface CompletionCandidate {
+    /** Insertion text for the command name (with leading slash). */
+    label: string;
+    /** Human-readable description shown beside the label. */
+    description: string;
+    /** Candidate origin; skills land the same literal text but route through the prompt. */
+    origin: 'command' | 'skill' | 'mention';
+}
+/**
+ * Resolve completion candidates for the current input: TUI-local commands,
+ * the live registry descriptors, and user-invocable skills, filtered by the
+ * typed prefix. Command names win collisions (the dispatch tries the
+ * registry first and only then falls through to the skill gesture), and a
+ * later duplicate name never renders twice.
+ *
+ * A bare `/` returns the FULL merged list — Codex's command popup shows every
+ * command inside a scroll window on an empty filter, and the menu's own
+ * selection window bounds the visible rows, so no slice cap is needed.
+ */
+export declare function completionCandidates(value: string, descriptors: readonly CommandDescriptor[], skills: readonly SkillRow[]): readonly CompletionCandidate[];
+/** One cached settled row: the row Box plus its roomy-prompt spacers. */
+interface SettledRowRecord {
+    /** The row Box element (keyed by the entry's settled index). */
+    box: ReactElement;
+    /** The roomy-prompt spacer BEFORE the row, or undefined. */
+    before: ReactElement | undefined;
+    /** The roomy-prompt spacer AFTER the row, or undefined. */
+    after: ReactElement | undefined;
+    /** Physical rows this record contributes (row body plus spacers) — the
+     * unit of the rendered-history cap. */
+    rows: number;
+}
+/** The incremental settled-history cache (see `computeSettledRows`). */
+interface SettledRowsCache {
+    /** The exact settled entries the cache covers (the WINDOW: the newest
+     * `entries.length` settled entries, oldest dropped entries excluded). */
+    entries: TranscriptEntry[];
+    /** Records keyed by entry identity; mutated in place so the append path
+     * never copies the whole map. */
+    records: Map<TranscriptEntry, SettledRowRecord>;
+    /** The header element (depends only on `resumed`). */
+    header: ReactElement;
+    /** The `resumed` the header was built with. */
+    resumed: boolean;
+    /** The toggle state the rows were built with. */
+    showReasoning: boolean;
+    /** The refreshEpoch the rows was built for; a bump forces a full rebuild. */
+    epoch: number;
+    /** The terminal width the rows were wrapped for; a change forces a rebuild. */
+    columns: number;
+    /** The flat row list (header + optional hint + per-entry before/box/after). */
+    flat: ReactElement[];
+    /** Settled entries dropped from the window's head (rendering only — the
+     * event log keeps everything; Ctrl+O and /export read it directly). */
+    droppedEntries: number;
+    /** Physical rows the window's entries contribute (excludes header/hint). */
+    totalRows: number;
+    /** The window overflowed the trim hysteresis; one source-backed replay
+     * (epoch bump) will re-window the cache. The append path never mutates
+     * flat's head, so <Static> only ever sees tail appends between remounts. */
+    needsTrim: boolean;
+}
+/** One step of `computeSettledRows`. */
+interface SettledRowsResult {
+    cache: SettledRowsCache;
+    /** How many rows had to be BUILT by this step (0 = pure reuse). */
+    built: number;
+}
+/**
+ * The settled `<Static>` row set as a PURE incremental state machine (App
+ * drives it from the memo; tests drive it directly and read `built`).
+ *
+ * The settled prefix is permanently final: the projection only APPENDS below
+ * the flush boundary, removes pending rows at or beyond it, and replaces
+ * running tool/retry/command rows there too. So extending the cache never
+ * rescans the old prefix — a grown boundary builds ONLY the newly settled
+ * suffix and reuses every cached element, letting React bail out of unchanged
+ * rows and keeping long histories out of the per-durable-event path (no O(N)
+ * rebuild of rows, Map, or MarkdownBody parses). `records` is mutated in place
+ * on the append/toggle paths to stay O(delta).
+ *
+ * RENDERED-HISTORY CAP: the window holds at most `rowCap` physical rows of
+ * settled transcript (header and hint reserved on top). The cap exists only
+ * here — the event log, the store projection, /export, Ctrl+O, and /resume
+ * keep the full history. Ink 5's <Static> is a consumption counter
+ * (items.slice(index) keyed on length): deleting head items mid-stream while
+ * appending tail items can permanently swallow new rows, so the append branch
+ * NEVER drops the head — it only accounts rows and flags `needsTrim` once the
+ * window overflows cap + margin. The flag fires one source-backed replay
+ * (epoch bump = the existing clear + <Static> remount), whose rebuild branch
+ * walks the settled entries BACKWARD from the newest, keeps whole entries
+ * until the cap, and counts everything older as `droppedEntries` (those
+ * entries never even reach settledEntryLines). Hysteresis bounds replays to
+ * at most one per 25% growth; resize / Ctrl+L / idle Ctrl+R replays re-window
+ * for free on the same path.
+ *
+ * Full rebuilds run only on the rare, deliberate paths: no cache yet, a
+ * source-backed replay (`epoch` bump: resize / Ctrl+L / an idle Ctrl+R fold
+ * toggle / a cap trim remounts `<Static>` and must re-flush the CURRENT rows
+ * at the CURRENT fold state), a `resumed` change, or a shrink (`store.reset`).
+ * While a turn is busy or streaming, Ctrl+R only flips the live region; rows
+ * already emitted to native scrollback change exclusively through rebuilds.
+ */
+export declare function computeSettledRows(previous: SettledRowsCache | undefined, entries: readonly TranscriptEntry[], settled: number, showReasoning: boolean, resumed: boolean, epoch: number, columns?: number, rowCap?: number): SettledRowsResult;
+/** The whole terminal app; state arrives via the store, output via Ink. */
+export declare function App(props: AppProps): ReactElement;
+export {};

package/vendor/tui/types/approval.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The terminal approval answerer: one `approval/request` waterfall listener
+ * that renders the pending question as a y/n bar and resolves the decision
+ * back into the waterfall. Mirrors the web host's composer takeover — the
+ * service (audit pair, policy gate, fail-closed defaults) all live in
+ * dsh-base; this module only answers for agents this TUI owns.
+ *
+ * Vocabulary note: a client answerer may only ever resolve `'allowed-once'`
+ * or `'rejected'`; `'cancelled'` belongs to the request signal and
+ * `'unavailable'` to the fail-closed waterfall default.
+ *
+ * @module @deepseek-ai/dsh-code/approval
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { ApprovalRequest } from '@deepseek-ai/dsh-user-approval';
+/** The answer values a client answerer may resolve with. */
+export type ApprovalAnswer = 'allowed-once' | 'rejected';
+/** One pending approval question, derived from the request for rendering. */
+export interface PendingApproval {
+    /** The asker's human-readable explanation, or a generic fallback. */
+    headline: string;
+    /** The tool the question is about. */
+    toolName: string;
+    /** Command-line preview resolved from the paired streaming tool call. */
+    command: string;
+    /** Resolve the ask; calling twice is inert (one-shot latch). */
+    answer(outcome: ApprovalAnswer): void;
+}
+/** The pending-question snapshot the renderer subscribes to. */
+export interface ApprovalSnapshot {
+    /** The question on screen (queue head), or undefined when none is asked. */
+    pending: PendingApproval | undefined;
+    /** Presentational: an answer was submitted, the ask has not settled yet. */
+    answered: boolean;
+    /** Further asks waiting behind the on-screen one (FIFO, Codex-style). */
+    queued: number;
+}
+/** Store the pending question lands in; the renderer reads, the answerer writes. */
+export interface ApprovalStore {
+    /** Subscribe to pending-state changes; returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Read the current snapshot (identity-stable between changes). */
+    getSnapshot(): ApprovalSnapshot;
+}
+/**
+ * Create the approval store and mount the answerer listener on the context.
+ * The listener claims only requests for `owns`-owned agents and defers every
+ * other request back into the waterfall (`next()`), so sibling answerers stay
+ * usable. An aborted ask never reaches the human. Plugin teardown removes the
+ * listener; the service then fails its own question closed.
+ * @param ctx - plugin context whose event bus carries `approval/request`.
+ * @param owns - agents this terminal answers for.
+ * @param preview - resolves a tool-call preview for a pending request (the
+ * request contract carries no arguments; the UI self-serves from the
+ * transcript projection via `callId`).
+ * @returns the store the renderer subscribes to.
+ */
+export declare function mountApprovalAnswerer(ctx: Context, owns: (agent: Agent) => boolean, preview: (request: ApprovalRequest) => string): ApprovalStore;

package/vendor/tui/types/attachments.d.ts

@@ -0,0 +1,52 @@
+/** Terminal image- and file-attachment adapter over the Harness durable attachment service. */
+import type { AttachmentStore, ImageMediaType } from '@deepseek-ai/dsh-attachment';
+import type { FileBlock, ImageBlock } from '@deepseek-ai/dsh-llm';
+/** A validated path retained in the editor until submission persists it. */
+export interface ImagePathInspection {
+    readonly path: string;
+    readonly name: string;
+    readonly mediaType: ImageMediaType;
+    readonly bytes: number;
+}
+/** A validated non-image file path retained the same way (0.1.5 file blocks). */
+export interface FilePathInspection {
+    readonly path: string;
+    readonly name: string;
+    readonly bytes: number;
+}
+/**
+ * Terminal-side file admission bounds. Upstream exposes image limits through
+ * the attachment service but no file limits (files ride verbatim storage);
+ * these keep a dragged file from silently ingesting a disk-sized blob and
+ * bound one message the way the image batch is bounded.
+ */
+export declare const MAX_FILE_BYTES: number;
+export declare const MAX_FILES_PER_MESSAGE = 8;
+/** Detect the supported encoded raster formats from bytes, never from a path suffix. */
+export declare function detectImageMediaType(data: Uint8Array): ImageMediaType | undefined;
+/** Whether a path-like token is worth probing as an image attachment. */
+export declare function looksLikeImagePath(path: string): boolean;
+/**
+ * Parse a paste/drop into its image and file paths: image-suffixed tokens
+ * stay images, other path-shaped tokens ride as file attachments (0.1.5
+ * file blocks), and anything that is neither leaves both empty — the caller
+ * then treats the paste as plain text.
+ *
+ * File tokens are held to an absolute-path-with-shape bar (drive/backslash
+ * or a dot-suffixed leaf after a separator): a dropped terminal path always
+ * carries one of those, while prose, slash commands, and option flags never
+ * do. A POSIX absolute path without any dot-suffixed leaf falls through as
+ * text — the @ mention route still attaches such files deliberately.
+ */
+export declare function parsePastedAttachmentPaths(input: string): {
+    readonly images: readonly string[];
+    readonly files: readonly string[];
+};
+/** Validate path, byte size and encoded signature without writing an attachment object. */
+export declare function inspectImagePaths(paths: readonly string[], attachments: AttachmentStore | undefined, cwd?: string): Promise<readonly ImagePathInspection[]>;
+/** Read, validate, and persist an ordered image path list as model content blocks. */
+export declare function saveImagePaths(paths: readonly string[], attachments: AttachmentStore | undefined, signal?: AbortSignal): Promise<readonly ImageBlock[]>;
+/** Validate path and byte size for non-image file attachments without writing. */
+export declare function inspectFilePaths(paths: readonly string[], attachments: AttachmentStore | undefined, cwd?: string): Promise<readonly FilePathInspection[]>;
+/** Read and persist an ordered non-image file path list as model file blocks. */
+export declare function saveFilePaths(paths: readonly string[], attachments: AttachmentStore | undefined, signal?: AbortSignal): Promise<readonly FileBlock[]>;

package/vendor/tui/types/authorization-panel.d.ts

@@ -0,0 +1,22 @@
+/** Bounded Ink surfaces for provider login and logout. */
+import { type ReactElement } from 'react';
+import { type AuthorizationInteraction, type AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
+import type { CredentialKey } from '@deepseek-ai/dsh-credentials';
+import type { ProviderAuthorizationRow } from './authorization.ts';
+export interface ProviderAuthorizationPanelProps {
+    readonly row: ProviderAuthorizationRow;
+    begin(row: ProviderAuthorizationRow, method: string, interaction: AuthorizationInteraction, signal: AbortSignal): Promise<AuthorizationStatus>;
+    cancel(key: CredentialKey): void;
+    openUrl(url: string): boolean;
+    copy(text: string): Promise<void>;
+    done(): void;
+    back(): void;
+}
+/** Run one upstream authorization flow without letting notices or prompts exceed the panel budget. */
+export declare function ProviderAuthorizationPanel(props: ProviderAuthorizationPanelProps): ReactElement;
+export declare function ProviderAuthorizationLogoutPanel({ row, confirm, done, back }: {
+    row: ProviderAuthorizationRow;
+    confirm(row: ProviderAuthorizationRow): Promise<void>;
+    done(): void;
+    back(): void;
+}): ReactElement;

package/vendor/tui/types/authorization.d.ts

@@ -0,0 +1,36 @@
+/** Terminal adapter over the Harness provider-authorization and credential-record seams. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { AuthorizationEntry, AuthorizationInteraction, AuthorizationMethod, AuthorizationStatus } from '@deepseek-ai/dsh-authorization';
+import { type CredentialKey, type CredentialRecordInfo } from '@deepseek-ai/dsh-credentials';
+/** One provider login flow joined with its value-free stored-record facts. */
+export interface ProviderAuthorizationRow {
+    readonly key: CredentialKey;
+    readonly provider: string;
+    readonly label: string;
+    readonly methods: readonly AuthorizationMethod[];
+    readonly inFlight: boolean;
+    readonly record: CredentialRecordInfo;
+}
+/** The provider-login directory plus non-fatal record lookup failures. */
+export interface ProviderAuthorizationDirectory {
+    readonly rows: readonly ProviderAuthorizationRow[];
+    readonly failures: readonly string[];
+}
+/** Load only model-provider flows; unrelated future authorization domains stay out of `/model`. */
+export declare function loadProviderAuthorizations(ctx: Context): Promise<ProviderAuthorizationDirectory>;
+/** Subscribe to login settlement and credential-record changes. */
+export declare function subscribeProviderAuthorizations(ctx: Context, listener: () => void): () => void;
+/** Begin one provider login through the interaction surface owned by the caller. */
+export declare function beginProviderAuthorization(ctx: Context, row: Pick<ProviderAuthorizationRow, 'key'>, method: string, interaction: AuthorizationInteraction, signal?: AbortSignal): Promise<AuthorizationStatus>;
+/** Cancel the attempt currently serving this provider, if any. */
+export declare function cancelProviderAuthorization(ctx: Context, key: CredentialKey): void;
+/** Remove an authorization record without changing the provider's settings profile. */
+export declare function logoutProviderAuthorization(ctx: Context, row: ProviderAuthorizationRow): Promise<void>;
+/** Open an authorization URL with the platform default browser, without invoking a shell. */
+export declare function openAuthorizationUrl(raw: string): boolean;
+/** Compact value-free status for the provider list. */
+export declare function providerAuthorizationStatus(row: ProviderAuthorizationRow | undefined): string;
+/** Find a provider's login flow from a previously loaded directory. */
+export declare function authorizationForProvider(directory: ProviderAuthorizationDirectory | undefined, provider: string): ProviderAuthorizationRow | undefined;
+/** Preserve the upstream entry type in declarations without leaking service internals into the TUI. */
+export type { AuthorizationEntry };

package/vendor/tui/types/commands.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Slash-command bridge: forwards terminal command lines into the shared
+ * `ctx.commands` registry (the same surface the web composer dispatches
+ * through) and exposes the live descriptor list as completion candidates.
+ * The runner keeps only its own TUI-local commands (`/help`, `/quit`,
+ * `/clear`, `/model`) ahead of the registry dispatch.
+ *
+ * @module @deepseek-ai/dsh-tui/commands
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { CommandDescriptor } from '@deepseek-ai/dsh-commands';
+/** Descriptor list snapshot the completion menu renders from. */
+export interface CommandsView {
+    /** Name-sorted descriptors after scoped shadowing. */
+    readonly descriptors: readonly CommandDescriptor[];
+    /** Latest descriptor-read failure; the help panel exposes it in place. */
+    readonly error?: string;
+    /** Subscribe to list changes (`commands/change`); returns the unsubscribe function. */
+    subscribe(listener: () => void): () => void;
+    /** Retarget the agent whose scoped view the list is read through. */
+    setAgent(agent: Agent): void;
+}
+/**
+ * Watch the live command registry. Reads the current list immediately and
+ * re-reads on every registry mutation or agent retarget; notification
+ * failures are contained by the registry itself, so this watcher only ever
+ * re-reads. Without a `commands` service the view stays empty and all lines
+ * fall through to normal prompts.
+ * @param ctx - context carrying the `commands` service (optional).
+ * @returns the view the completion menu subscribes to.
+ */
+export declare function watchCommands(ctx: Context): CommandsView;
+/**
+ * Whether one command line is a syntactically valid slash command.
+ * @param line - the complete candidate line.
+ * @returns true when the line parses as `/name` or `/name input`.
+ */
+export declare function isSlashLine(line: string): boolean;
+/**
+ * The submission payload for one composer line. Trim is a blank check, not a
+ * rewrite: an ordinary prompt keeps its exact leading indentation, inner
+ * layout, and trailing spaces (pasted code must reach the model verbatim).
+ * Only trailing line terminators are stripped — a draft's final newline is a
+ * paste/Enter artifact (an open bracketed paste turns Enter into an inserted
+ * newline), never deliberate content. A syntactic slash line still normalizes
+ * fully so command routing stays stable (completion inserts a trailing space
+ * after `/name`).
+ * @param line - the complete draft text.
+ * @returns the text to submit verbatim.
+ */
+export declare function submissionPayload(line: string): string;

package/vendor/tui/types/editor-keys.d.ts

@@ -0,0 +1,105 @@
+/**
+ * VS Code-family terminal keybinding repair. VS Code hands Ctrl+R to the
+ * workbench (Open Recent) even while an integrated terminal owns focus, so
+ * the reasoning-fold key never reaches the TUI. Workspace-scoped keybindings
+ * do not exist, so the fix is one user-level keybindings.json rule that
+ * forwards the raw Ctrl byte via sendSequence under terminalFocus. This
+ * module detects the hosting editor variant, resolves its user
+ * keybindings.json, and merges the rule idempotently; pure merge/detect
+ * helpers are separated from the fs orchestration so both stay testable.
+ * @module @deepseek-ai/dsh-code/editor-keys
+ */
+/** Integrated-terminal editor variants this module can repair. */
+export type EditorTerminalFamily = 'vscode' | 'cursor' | 'vscodium' | 'windsurf';
+/**
+ * Detect the editor hosting this integrated terminal.
+ * @param env - process environment (TERM_PROGRAM decides; case/whitespace tolerant).
+ * @returns the family, or undefined outside VS Code-family terminals.
+ */
+export declare function detectEditorTerminalFamily(env?: NodeJS.ProcessEnv): EditorTerminalFamily | undefined;
+/**
+ * Whether the pty is hosted away from the editor UI (ssh/container/tunnel).
+ * Keybindings live on the client machine, so a remote session must never
+ * write them server-side.
+ */
+export declare function isRemoteTerminalEnv(env?: NodeJS.ProcessEnv): boolean;
+/** Filesystem anchors used to resolve editor config paths (injectable for tests). */
+export interface EditorPathContext {
+    /** User home directory. */
+    homedir: string;
+    /** %APPDATA% on Windows; only read for win32 resolution. */
+    appdata?: string;
+    /** Node platform qualifier. */
+    platform: NodeJS.Platform;
+}
+/**
+ * Resolve the user keybindings.json candidates for one family, most likely
+ * install first. Only paths that exist on disk are repaired.
+ */
+export declare function editorKeybindingCandidates(family: EditorTerminalFamily, context: EditorPathContext): readonly string[];
+/** The one workbench rule that hands Ctrl+R to the focused terminal. */
+export declare const CTRL_R_PASSTHROUGH_RULE: {
+    readonly key: "ctrl+r";
+    readonly command: "workbench.action.terminal.sendSequence";
+    readonly args: {
+        readonly text: "\u0012";
+    };
+    readonly when: "terminalFocus";
+};
+/**
+ * Remove // and block comments from one JSONC document. Double-quoted strings
+ * survive untouched, so comment markers inside string values are preserved.
+ */
+export declare function stripJsoncComments(text: string): string;
+/** Parse one JSONC document; trailing commas are tolerated. */
+export declare function parseJsonc(text: string): unknown;
+/** Outcome of merging the passthrough rule into one keybindings document. */
+export type KeybindingsMerge = {
+    readonly status: 'present';
+} | {
+    readonly status: 'updated';
+    readonly text: string;
+} | {
+    readonly status: 'created';
+    readonly text: string;
+};
+/**
+ * Merge the Ctrl+R passthrough into one keybindings.json document. The raw
+ * text is preserved verbatim (comments included); the rule is inserted right
+ * after the array opener so it cannot be shadowed by later conflicting user
+ * rules. Missing files resolve to a fresh template.
+ * @throws when the document does not carry a rule array.
+ */
+export declare function mergeCtrlRPassthrough(raw: string | undefined): KeybindingsMerge;
+/** User-level marker file content: the startup hint fires at most once per install. */
+export interface EditorKeysFlag {
+    hintShownAt?: string;
+}
+/** Parse one flag file snapshot; missing or corrupt content degrades to unshown. */
+export declare function parseEditorKeysFlag(raw: string | undefined): EditorKeysFlag;
+/** Persist the shown marker; best-effort, the hint is cosmetic and never a gate. */
+export declare function markEditorKeysHintShown(path: string): Promise<void>;
+/** Inputs shared by the apply and startup-hint flows. */
+export interface EditorKeysEnv {
+    /** Process environment (TERM_PROGRAM / VSCODE_IPC_HOOK_CLI). */
+    env: NodeJS.ProcessEnv;
+    /** Filesystem anchors for editor config resolution. */
+    paths: EditorPathContext;
+    /** Absolute path of the one-shot hint marker under the DSH home. */
+    flagPath: string;
+}
+/**
+ * Apply the Ctrl+R passthrough to every local keybindings.json of the hosting
+ * editor and mark the startup hint shown. Existing files get a .dsh-bak
+ * backup before the first write.
+ * @returns a one-line user-facing summary.
+ * @throws with an actionable message when the environment cannot be repaired.
+ */
+export declare function applyCtrlRPassthrough({ env, paths, flagPath }: EditorKeysEnv): Promise<string>;
+/**
+ * Resolve the one-shot startup hint for VS Code-family terminals. Fires at
+ * most once per install (flag file), never when the passthrough rule is
+ * already present, and never in remote ptys where the repair cannot run.
+ * @returns the hint line, or undefined to stay silent.
+ */
+export declare function resolveEditorKeysStartupHint({ env, paths, flagPath }: EditorKeysEnv): Promise<string | undefined>;

package/vendor/tui/types/editor.d.ts

@@ -0,0 +1,6 @@
+/** Host editor and clipboard adapters used by the terminal surface. */
+import type { TranscriptView } from './render/projection.ts';
+/** Copy UTF-8 text through the platform clipboard command. */
+export declare function copyText(text: string): Promise<void>;
+/** Latest complete assistant text, excluding streaming and reasoning. */
+export declare function latestAssistantText(view: TranscriptView): string | undefined;

package/vendor/tui/types/fork.d.ts

@@ -0,0 +1,8 @@
+/** Pure session-fork boundary policy shared by the TUI command and tests. */
+import type { SessionEvent } from '@deepseek-ai/dsh-session';
+export interface ForkSeed {
+    readonly boundarySeq: number;
+    readonly events: readonly SessionEvent[];
+}
+/** Select a completed turn and trailing between-turn metadata. */
+export declare function selectForkSeed(events: readonly SessionEvent[], atSeq?: number): ForkSeed;