dsh-ssh-tui 0.5.2 → 0.5.4

package/lib/types/quota.d.ts

@@ -0,0 +1,94 @@
+/**
+ * OpenCode / SuperGrok / DeepSeek quota and prepaid-balance parsers.
+ */
+/** A recognized OpenCode provider route, used by /usage and /quota. */
+export type OpenCodeFlavor = 'zen' | 'go';
+export interface OpenCodeSource {
+    provider: string;
+    flavor: OpenCodeFlavor;
+    label: string;
+    apiKeyEnv: string;
+    baseURL?: string;
+}
+export interface LlmPiAiProviderProfile {
+    displayName?: unknown;
+    apiKeyEnv?: unknown;
+    baseURL?: unknown;
+    api?: unknown;
+    models?: unknown;
+    reasoning?: unknown;
+}
+export interface LlmPiAiSection {
+    providers?: Record<string, LlmPiAiProviderProfile>;
+}
+/** Build per-model reasoningEfforts from a provider-level reasoning default. */
+export declare function reasoningEffortsForDefault(reasoning: unknown): Record<string, string | null> | undefined;
+export declare const OPENCODE_GO_USAGE_URL = "https://opencode.ai/zen/go/v1/usage";
+export declare const OPENCODE_ZEN_BASE_URL = "https://opencode.ai/zen/v1";
+export declare const SUPERGROK_BILLING_URL = "https://cli-chat-proxy.grok.com/v1/billing?format=credits";
+export declare const DEEPSEEK_PUBLIC_BASE_URL = "https://api.deepseek.com";
+/** OpenAI-completions gateways: probe these relative to the configured base URL. */
+export declare const OPENAI_COMPAT_BALANCE_PATHS: readonly ["/user/balance", "/dashboard/billing/credit_grants", "/v1/dashboard/billing/credit_grants", "/v1/dashboard/billing/subscription"];
+/**
+ * Classify the currently selected provider as an OpenCode route. Built-in
+ * `opencode`/`opencode-go` ids are recognized directly, and custom llm-pi-ai
+ * routes are recognized by their `opencode.ai` base URL.
+ */
+export declare function openCodeSourceFor(provider: string, llmPiAiSection: unknown): OpenCodeSource | null;
+export type QuotaPeriod = 'hourly' | 'weekly' | 'monthly' | 'unknown';
+export interface QuotaWindow {
+    label: string;
+    period: QuotaPeriod;
+    /** Remaining percent of the window (100 = unused). */
+    remainingPercent: number;
+    resetsAt?: string;
+}
+export interface QuotaSnapshot {
+    provider: string;
+    plan: string;
+    windows: QuotaWindow[];
+}
+export declare function remainingPercentFromUsed(usedPercent: number): number;
+/** Cross a remaining-percent threshold from above (50 / 25 / 10 / 5).
+ *  Only the tightest (lowest) crossed threshold is returned, so one drop
+ *  never paints 50/25/10 as three identical warnings. */
+export declare function crossedQuotaThresholds(previousRemaining: number | undefined, remaining: number): number[];
+export declare function quotaAlertText(snapshot: QuotaSnapshot, window: QuotaWindow): string;
+/**
+ * How often to re-fetch quota or prepaid balance, counted in model steps.
+ * Default is every 10 steps. Near a remaining-percent threshold, hourly
+ * windows refresh every 4 steps.
+ */
+export declare function quotaRefreshEverySteps(window: QuotaWindow | undefined): number;
+/** @deprecated Same cadence as {@link quotaRefreshEverySteps}; the name predates step accounting. */
+export declare const quotaRefreshEveryTurns: typeof quotaRefreshEverySteps;
+export declare function parseSuperGrokBilling(payload: unknown): QuotaSnapshot;
+export declare function parseOpenCodeGoQuota(payload: unknown, provider: string): QuotaSnapshot;
+export declare function formatQuotaSnapshot(snapshot: QuotaSnapshot): string;
+/** Compact `/status` quota line: tightest window first, then the rest. */
+export declare function formatQuotaStatusLine(snapshot: QuotaSnapshot | undefined): string;
+/** Tightest remaining window — used for threshold alerts. */
+export declare function tightestQuotaWindow(snapshot: QuotaSnapshot): QuotaWindow | undefined;
+/** Render the OpenCode Go quota payload as a transcript block. */
+export declare function formatOpenCodeGoUsage(payload: unknown, source: OpenCodeSource): string;
+export interface AccountBalanceLine {
+    label: string;
+    amount: string;
+    currency?: string;
+}
+export interface AccountBalanceSnapshot {
+    provider: string;
+    plan: string;
+    available?: boolean;
+    lines: AccountBalanceLine[];
+    sourcePath?: string;
+}
+export declare function joinUrl(base: string, path: string): string;
+export declare function parseDeepSeekBalance(payload: unknown, provider?: string): AccountBalanceSnapshot;
+/** Best-effort parse of OpenAI-compatible credit/balance JSON. */
+export declare function parseOpenAiCompatibleBalance(payload: unknown, provider: string, path: string): AccountBalanceSnapshot | undefined;
+/** Compact footer chip: `余额 86.42 CNY`. Prefers remaining/available lines. */
+export declare function formatFooterBalance(snapshot: AccountBalanceSnapshot): string | undefined;
+export declare function formatAccountBalance(snapshot: AccountBalanceSnapshot): string;
+/** Extract a safe human-readable message from an OpenCode error payload. */
+export declare function openCodeApiErrorMessage(payload: unknown): string;

package/lib/types/session-list.d.ts

@@ -38,4 +38,17 @@ export interface ResumableSession {
 }
 /** `MM-DD HH:mm` local-time label for session lists. */
 export declare function formatSessionTime(timestamp: number): string;
+/**
+ * List resumable top-level sessions, newest first.
+ *
+ * Subagent-owned sessions and the current session are excluded. Sessions
+ * whose event log cannot be inspected are kept (marked `unreadable`) instead
+ * of silently disappearing from history; readable sessions with user input
+ * sort first. The label is the persisted title, then the user's first input,
+ * then the id.
+ * @param persistence - the session persistence service.
+ * @param currentId - the live session to exclude (empty at launch).
+ * @returns every resumable candidate in display order (attachable live
+ *   hosts first, then readable logs, then unreadable).
+ */
 export declare function listResumableSessions(persistence: SessionPersistence, currentId: string, listHosts?: typeof listAttachableHosts): Promise<ResumableSession[]>;

package/lib/types/term-text.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Terminal cell metrics, wrapping, markdown, and input folding.
+ *
+ * Isolated so the launch session picker can clip labels without loading
+ * the interactive TUI class.
+ */
+/**
+ * Codex-style compact elapsed: `0s`, `1m 05s`, `1h 01m 01s`.
+ * Used by the workspace wait card while the model has not streamed yet.
+ */
+export declare function fmtElapsedCompact(elapsedSecs: number): string;
+/**
+ * Sweep highlight across `text` (Codex `shimmer.rs`). Truecolor blends a
+ * highlight band; otherwise DIM / default / BOLD. Process-start based so
+ * every paint of the same frame stays in phase.
+ */
+export declare function shimmerText(text: string, nowMs: number, color: boolean): string;
+/**
+ * Codex `extract_first_bold`: the first **closed** `**bold**` in the thinking
+ * stream, else the first markdown heading. An unclosed `**` means the title
+ * has not arrived yet, so return undefined and keep the default header —
+ * never fall back to hard-truncated reasoning, reply, or prompt text.
+ */
+export declare function waitSummaryFromReasoning(text: string): string | undefined;
+/** Wait-card header + optional detail. Header tracks model work when known. */
+export declare function waitCardCopy(input: {
+    toolTitle?: string;
+    toolSummary?: string;
+    reasoning?: string;
+}): {
+    header: string;
+    detail?: string;
+};
+/**
+ * Codex `wrapped_details_lines`: word-wrap the wait-card detail under the
+ * `  └ ` prefix, continue wrapped rows at the prefix width, cap at 3 rows and
+ * end the last one with an ellipsis when the text does not fit.
+ */
+export declare function wrapWaitDetails(detail: string, width: number, maxLines?: number): string[];
+/**
+ * Terminal cell width for one string.
+ *
+ * Match glibc wcwidth / typical UTF-8 SSH terminals: CJK ideographs and
+ * fullwidth forms occupy two cells; East-Asian Ambiguous box-drawing and
+ * ornaments (`─`, `●`, `·`, `▸`, `❯`, Braille spinners) occupy one. Counting
+ * those ambiguous glyphs as two made `repeatToWidth('─', cols)` paint a
+ * half-width rule and parked the input cursor half a cell past the text.
+ *
+ * Overflow into the input box is handled by clipping/padding painted rows to
+ * the measured column count, not by inflating glyph width.
+ */
+export declare function displayWidth(text: string): number;
+/** Pad or clip one already-sanitized line so it occupies exactly `width` cells. */
+export declare function padToWidth(text: string, width: number): string;
+/**
+ * Pad an already-styled ANSI line to `width` cells without resetting SGR.
+ * Diff add/del rows keep their background across the whole terminal row
+ * instead of only the glyphs.
+ */
+export declare function padAnsiToWidth(text: string, width: number): string;
+/** Visible width of an ANSI-styled line, ignoring CSI / OSC sequences. */
+export declare function visibleWidth(text: string): number;
+/** Repeat a glyph until it occupies exactly `width` cells. */
+export declare function repeatToWidth(glyph: string, width: number): string;
+/** Strip terminal control sequences and expand tabs for display output. */
+export declare function sanitizeTerminalText(text: string): string;
+/** UTF-16 length of the first code point, so fallback cuts never split a surrogate pair. */
+export declare function firstCodePointLength(text: string): number;
+export declare function wrap(text: string, width: number): string[];
+/** One colored span inside a tool-card header line. Offsets are UTF-16 char indices. */
+export interface TextSegment {
+    start: number;
+    end: number;
+    sgr: string;
+}
+/** Wrap plain text and report each output line's char range in the source. */
+export declare function wrapTracked(text: string, width: number): {
+    line: string;
+    start: number;
+    end: number;
+}[];
+/** Paint one already-wrapped output line by the segments overlapping its range. */
+export declare function paintSegmentedLine(line: string, start: number, end: number, segments: readonly TextSegment[]): string;
+/** Wrap `text` and color each output line by overlapping `segments`. */
+export declare function wrapSegmented(text: string, width: number, segments: readonly TextSegment[]): string[];
+export declare function truncate(text: string, maxLines: number): string;
+/**
+ * Render workspace markdown into width-bounded terminal rows. Assistant
+ * replies get a bold-white base; code blocks, headings, quotes, lists, rules,
+ * links and inline spans keep their own ANSI treatment.
+ */
+export declare function renderMarkdownLines(text: string, width: number, color: boolean): string[];
+/** Cut one line to fit a width, appending an ellipsis when truncated. */
+export declare function truncateToWidth(text: string, width: number): string;
+/**
+ * Clip an already-styled ANSI line to `width` terminal cells without dropping
+ * the reset/SGR sequences. Used by the incremental painter so a leftover wide
+ * glyph cannot wrap into the next row.
+ */
+export declare function clipAnsiToWidth(text: string, width: number): string;
+/** One renderable view of the input line: text plus the cursor's visual offset. */
+export interface InputView {
+    text: string;
+    cursorOffset: number;
+    folded: boolean;
+}
+/**
+ * Fold a long input into one terminal row around the cursor.
+ *
+ * Newlines from a paste are display-only: they do not occupy cells, so a
+ * naive `displayWidth(input)` under-counts a multi-line paste and parks the
+ * caret in the middle of later text. Fold the *current line* (between the
+ * surrounding newlines) and keep `\n` out of the visible slice.
+ */
+export declare function foldInputView(input: string, cursor: number, maxWidth: number): InputView;
+/**
+ * Map a character index in the input text to its visual (row, col) after the
+ * same width wrapping `wrap()` applies to the rendered input. `row` is the
+ * 0-based input display line, `col` the 0-based column within that line
+ * (before any prompt prefix). This keeps the cursor on the correct line/column
+ * when the input contains literal newlines from multi-line pastes.
+ */
+export declare function cursorVisualPosition(text: string, cursor: number, width: number): {
+    row: number;
+    col: number;
+};
+/** Take the first `max` code points of a string without splitting surrogates. */
+export declare function sliceCodePoints(text: string, max: number): string;
+/** Take the last `max` code points of a string without splitting surrogates. */
+export declare function lastCodePoints(text: string, max: number): string;

package/lib/types/tool-present.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Tool-card presentation: headers, diffs, compact bursts, JSON bodies.
+ */
+import type { AskUserQuestionItem } from '@deepseek-ai/dsh-user-questions';
+import { type TextSegment } from './term-text.js';
+import type { DisplayKind, Row, ToolDiffHunk } from './transcript-types.js';
+export declare const SHELL_TOOL_NAMES: Set<string>;
+export declare const DIFF_TOOL_NAMES: Set<string>;
+/** Format a model list compactly: show the first few entries and an ellipsis. */
+export declare function formatModelList(models: readonly string[], max?: number): string;
+/** Prefer the fields a human scans for; fall back to the first scalar pairs. */
+export declare function friendlyArgsSummary(name: string, args: string): string;
+export declare function countDiffLines(hunks: readonly ToolDiffHunk[] | undefined): number;
+/** Added / removed line counts for a diff (`oldText: null` means a new file). */
+export declare function countDiffAddDel(hunks: readonly ToolDiffHunk[] | undefined): {
+    add: number;
+    del: number;
+};
+/**
+ * Git diffstat token, deletions first like `-13 +24`. Zero parts drop out
+ * (a new file shows only `+24`); empty when the diff has no counted lines.
+ */
+export declare function diffStatToken(add: number, del: number): string;
+export declare const READ_TOOL_NAMES: Set<string>;
+export declare const TOOL_FLIP_MS = 280;
+export declare function toolTargetPath(name: string, args: string, fallback?: string): string;
+/** Path shown on a compact single-file edit summary. */
+export declare function compactEditPath(item: {
+    name: string;
+    args: string;
+    summary?: string;
+    diff?: readonly {
+        path?: string;
+    }[];
+}): string;
+export declare function sameToolPath(left: string, right: string): boolean;
+export declare function countOutputLines(text: string): number;
+export declare function mergeableToolKind(name: string): 'read' | 'edit' | undefined;
+/**
+ * Consecutive same-path reads (or edits) collapse onto one card.
+ * A → B → C → A becomes four cards; A ×5 stays one card with repeats=5.
+ */
+export declare function canMergeToolCall(previous: Extract<Row, {
+    kind: 'tool';
+}> | undefined, next: {
+    name: string;
+    args: string;
+}): previous is Extract<Row, {
+    kind: 'tool';
+}>;
+export declare function compactToolGroups(tools: readonly Extract<Row, {
+    kind: 'tool';
+}>[]): {
+    edits: Extract<Row, {
+        kind: 'tool';
+    }>[];
+    calls: Extract<Row, {
+        kind: 'tool';
+    }>[];
+    failedCalls: number;
+};
+/**
+ * Split compact-view tools into the bursts that belong with each assistant
+ * reply: tools after reply N sit with that reply, until the next reply.
+ */
+export declare function compactToolBursts(rows: readonly Row[]): Array<{
+    after: Extract<Row, {
+        kind: 'assistant';
+    }> | undefined;
+    groups: ReturnType<typeof compactToolGroups>;
+}>;
+export declare const SUBAGENT_TOOL_NAMES: Set<string>;
+/**
+ * Tool calls that already have a dedicated transcript card (goal/change,
+ * plan dock, question dialog). Showing them again as raw `get_goal` cards
+ * just duplicates chrome.
+ */
+export declare const HIDDEN_TOOL_NAMES: Set<string>;
+export declare function toolTitle(name: string): string;
+export declare function planReviewOf(question: AskUserQuestionItem): boolean;
+/** Derive the intended file change from a mutation tool's arguments. */
+export declare function diffHunksFromArgs(name: string, argsRaw: string): ToolDiffHunk[] | null;
+/** One-line friendly tool-call presentation (command / path / arg summary). */
+export declare function presentToolCall(name: string, args: string): {
+    title: string;
+    summary: string;
+    command?: string;
+    cwd?: string;
+    diff?: ToolDiffHunk[];
+};
+/** Validate a tool/result meta payload's structured diff, mirroring the web card. */
+export declare function diffMetaDiffs(meta: unknown): ToolDiffHunk[] | null;
+/** Split one diff side into content lines (trailing newline is a terminator). */
+export declare function diffContentLines(text: string): string[];
+/** One rendered diff body line with its display role. */
+export interface DiffDisplayLine {
+    kind: DisplayKind;
+    text: string;
+}
+/** Cap one flat diff/body row list to `maxLines` while preserving the final line. */
+export declare function capDisplayLines(lines: readonly DiffDisplayLine[], maxLines: number): DiffDisplayLine[];
+/** Running / ok / error → ANSI color for the status dot and status word only. */
+export declare function toolStateColor(status: 'running' | 'ok' | 'error' | undefined): '33' | '32' | '31';
+export declare function toolStateLabel(status: 'running' | 'ok' | 'error' | undefined): string;
+/** Header + SGR spans: default title, dim operand, colored ●. `[ok]` is omitted — the green dot is enough. */
+export declare function buildToolHeader(input: {
+    focused: boolean;
+    expanded: boolean;
+    title: string;
+    summary: string;
+    status?: 'running' | 'ok' | 'error';
+    command?: string;
+    signal?: string;
+    exitCode?: number;
+    spinner?: string;
+    flipping?: boolean;
+    diffStat?: {
+        add: number;
+        del: number;
+    };
+}): {
+    plain: string;
+    segments: TextSegment[];
+};
+/** How many terminal rows a tool body occupies after wrapping. */
+export declare function wrappedToolBodyLineCount(lines: readonly {
+    text: string;
+}[], width: number): number;
+/**
+ * True when the full tool body plus a one-line header fits in the workspace
+ * (the rows between the title bar and the input chrome). Oversized bodies
+ * open a dedicated inspect overlay instead of dumping into the transcript.
+ */
+export declare function toolBodyFitsWorkspace(bodyLines: number, workspaceRows: number): boolean;
+/** Flatten hunks into git-style `-`/`+` lines plus the web-compatible footer. */
+export declare function renderToolDiff(diffs: ToolDiffHunk[], maxLines: number): DiffDisplayLine[];
+/** Convert any parsed JSON value into readable indented display lines. */
+export declare function friendlyJsonLines(value: unknown, depth?: number): string[];
+/** Minimal tool-row shape the expanded-body renderer reads. */
+export interface ToolBodySource {
+    name?: string;
+    diff?: ToolDiffHunk[];
+    command?: string;
+    status?: 'running' | 'ok' | 'error';
+    output: string;
+    args: string;
+}
+/** Try to parse a result body as one JSON document, when it looks like one. */
+export declare function parseJsonBody(text: string): unknown | null;
+/**
+ * The expanded body of one tool card: diffs and shell output keep their
+ * dedicated views; every other tool's JSON arguments and JSON result are
+ * converted into readable indented content instead of raw JSON text.
+ */
+export declare function toolBodyLines(row: ToolBodySource, maxLines: number): DiffDisplayLine[];
+export interface NamedToolBodySource extends ToolBodySource {
+    name?: string;
+}
+export declare function specializedToolBody(row: NamedToolBodySource, maxLines?: number): DiffDisplayLine[] | null;
+/** Recover the shell tools' exit marker, mirroring @deepseek-ai/dsh-shell/render. */
+export declare function parseExitStatus(text: string): {
+    body: string;
+    exitCode?: number;
+    signal?: string;
+};

package/lib/types/transcript-types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Shared transcript row shapes used by plan / tool presentation helpers.
+ * Kept free of the SshTui class so leaf modules can import them.
+ */
+export type DisconnectPolicyName = 'pause' | 'continue';
+export type SubagentLogKind = 'user' | 'assistant' | 'tool' | 'result' | 'turn' | 'approval' | 'team' | 'system';
+/** One child-session event folded into a parent-side subagent card. */
+export interface SubagentLogEntry {
+    kind: SubagentLogKind;
+    text: string;
+}
+/** One todo-list item as the plan card renders it. */
+export interface PlanTodoItem {
+    content: string;
+    status: 'pending' | 'in_progress' | 'completed';
+}
+export type Row = {
+    kind: 'user';
+    text: string;
+} | {
+    kind: 'assistant';
+    text: string;
+} | {
+    kind: 'reasoning';
+    text: string;
+    expanded: boolean;
+} | {
+    kind: 'brand';
+    text: string;
+} | {
+    kind: 'brand-logo';
+} | {
+    kind: 'tool';
+    callId: string;
+    name: string;
+    args: string;
+    status?: 'running' | 'ok' | 'error';
+    output: string;
+    title: string;
+    summary: string;
+    command?: string;
+    cwd?: string;
+    diff?: ToolDiffHunk[];
+    exitCode?: number;
+    signal?: string;
+    expanded: boolean;
+    /** Consecutive same-path reads/edits folded into this card. */
+    repeats?: number;
+    /** Call ids folded into this card; results still match after merge. */
+    mergedCallIds?: string[];
+    /** Sum of output characters across folded reads. */
+    totalChars?: number;
+    /** Sum of output lines across folded reads. */
+    totalLines?: number;
+    /** Flip-card animation until this timestamp (ms since epoch). */
+    flipUntil?: number;
+} | {
+    kind: 'subagent';
+    sessionId: string;
+    runId: string;
+    provider: string;
+    local: boolean;
+    label: string;
+    status: 'running' | 'ok' | 'error' | 'aborted';
+    startedAt: number;
+    endedAt?: number;
+    stopReason?: string;
+    lastActivity: string;
+    logs: SubagentLogEntry[];
+    expanded: boolean;
+} | {
+    kind: 'plan';
+    active: boolean;
+    pending: boolean;
+    todos: PlanTodoItem[];
+    planMarkdown?: string;
+    expanded: boolean;
+    /** When true the plan stays in the scrolling transcript, not the dock. */
+    archived?: boolean;
+    /**
+     * Display-only: the last turn ended while todos were still open.
+     * Does not rewrite the session log.
+     */
+    turnLeftOpen?: boolean;
+} | {
+    kind: 'question';
+    questionId: string;
+    title: string;
+    header?: string;
+    detail?: string;
+    intent: 'ask' | 'plan-review';
+    status: 'waiting' | 'answered' | 'cancelled';
+    summary: string;
+    expanded: boolean;
+} | {
+    kind: 'goal';
+    objective: string;
+    phase: 'active' | 'paused' | 'blocked' | 'complete' | 'cleared';
+    blockedReason?: string;
+    expanded: boolean;
+} | {
+    kind: 'compaction';
+    compactionId: string;
+    status: 'running' | 'ok' | 'error';
+    startedAt: number;
+    endedAt?: number;
+    pruneCount: number;
+    prunedTokens: number;
+    summary?: string;
+    error?: string;
+    expanded: boolean;
+} | {
+    kind: 'prompt';
+    sources: string[];
+    text: string;
+    plugin?: string;
+    expanded: boolean;
+} | {
+    kind: 'system';
+    text: string;
+} | {
+    kind: 'error';
+    text: string;
+};
+/** A reasoning/tool/subagent/plan row or the live streaming-reasoning block. */
+export type CollapsibleBlock = Extract<Row, {
+    kind: 'reasoning';
+} | {
+    kind: 'tool';
+} | {
+    kind: 'subagent';
+} | {
+    kind: 'plan';
+} | {
+    kind: 'question';
+} | {
+    kind: 'goal';
+} | {
+    kind: 'compaction';
+} | {
+    kind: 'prompt';
+}> | {
+    kind: 'streaming-reasoning';
+    expanded: boolean;
+};
+export type DisplayKind = Row['kind'] | 'tool-result' | 'diff-add' | 'diff-del' | 'diff-path' | 'todo-done' | 'todo-active' | 'todo-pending' | 'plan-dock';
+/** One file's change, matching the web diff-card contract (`card: 'diff'`). */
+export interface ToolDiffHunk {
+    path: string;
+    oldText: string | null;
+    newText: string;
+}