dsh-remote-vs 0.10.0 → 0.11.0

package/lib/types/client/scm/commit-model.d.ts

@@ -0,0 +1,119 @@
+import type { GitCommitFile } from '../../protocol.ts';
+/** The pane's three views, in strip order. */
+export declare const HISTORY_TABS: readonly ["details", "content", "diff"];
+export type HistoryTab = (typeof HISTORY_TABS)[number];
+/** Guard for persisted values (`localStorage` may hold anything). */
+export declare function isHistoryTab(value: unknown): value is HistoryTab;
+/**
+ * Keyboard navigation for the pane's tab strip: arrows cycle (wrapping, so the
+ * last tab's → returns to the first), Home/End jump to the ends. `undefined`
+ * means "not a navigation key" and the caller leaves the event alone.
+ */
+export declare function stepHistoryTab(current: HistoryTab, key: string): HistoryTab | undefined;
+/** The state the 差异 tab's lazy read keeps for one commit. */
+export interface PatchLoadState {
+    key: string;
+    text?: string;
+    truncated?: boolean;
+    error?: string;
+}
+/**
+ * Whether the 差异 tab still has to read the patch for `key`.
+ *
+ * The subtle case is a SUPERSEDED read: switching the tab or the commit while
+ * a read is in flight used to leave the key marker behind with no data, and an
+ * equality-only guard (`state.key === key`) then treated that marker as
+ * "already loaded" forever — the reported "点击文件后差异一直说没有改动" bug.
+ * A marker without text/error therefore means RETRY, never "done".
+ */
+export declare function needsPatchLoad(state: PatchLoadState, key: string, tab: HistoryTab): boolean;
+/** One rendered patch line. */
+export interface PatchRow {
+    kind: 'context' | 'add' | 'del' | 'skip';
+    /** Old-revision line number; null on added lines and skip markers. */
+    oldLine: number | null;
+    /** New-revision line number; null on deleted lines and skip markers. */
+    newLine: number | null;
+    /** Line content without the leading ` ` / `+` / `-` marker. */
+    text: string;
+}
+/** One file block of a commit patch. */
+export interface CommitPatchFile {
+    /** Destination path (the source for deletions). */
+    path: string;
+    /** Source path when the block is a rename/copy (equals `path` otherwise). */
+    oldPath: string;
+    status: string;
+    binary: boolean;
+    added: number;
+    deleted: number;
+    rows: PatchRow[];
+    /** True when the global row cap kept this block's rows (partly) out. */
+    truncated: boolean;
+}
+export interface CommitPatchModel {
+    files: CommitPatchFile[];
+    added: number;
+    deleted: number;
+    /** True when the row cap cut the model (later blocks may have no rows). */
+    truncated: boolean;
+}
+/**
+ * Rendered-row ceiling for one commit patch.
+ *
+ * A commit that rewrites a generated file can carry hundreds of thousands of
+ * lines; painting them all freezes the sidebar on a click. The header counts
+ * stay exact (they come from the parsed hunks, not from the rendered rows), so
+ * the truncation notice only claims what is actually missing: the paint.
+ */
+export declare const PATCH_ROW_CAP = 6000;
+/** Build the render model for one commit's `git show --patch` text. */
+export declare function buildCommitPatch(text: string, rowCap?: number): CommitPatchModel;
+/** The file block a path selects in the diff view (rename-aware). */
+export declare function blockForPath(model: CommitPatchModel, path: string): string | undefined;
+/**
+ * Split one commit patch into its per-file raw texts, in the SAME order
+ * `buildCommitPatch` reports the files.
+ *
+ * Used by "copy this file's patch": the view still holds the original text, so
+ * the exact bytes git produced are what lands on the clipboard — no
+ * re-serialization from rows, which would drop headers a future git adds.
+ */
+export declare function splitCommitPatch(text: string): string[];
+/** One directory of the 内容 tree ('' = repository root). */
+export interface CommitFileGroup {
+    dir: string;
+    files: GitCommitFile[];
+}
+/**
+ * Group one commit's files by directory for the 内容 tree: a commit touching
+ * 40 files in 6 folders is a wall of paths as a flat list, and the folder row
+ * is also what lets a reader collapse the part they do not care about.
+ * Root-level files come first; every level keeps git's own order by path.
+ */
+export declare function groupCommitFiles(files: readonly GitCommitFile[]): CommitFileGroup[];
+/**
+ * The next path in `paths` from `current` (wrapping at both ends), the diff
+ * toolbar's prev/next-file math. `current` unknown → the first/last path, so a
+ * fresh pane steps into the list instead of doing nothing.
+ */
+export declare function stepPath(paths: readonly string[], current: string | undefined, direction: 1 | -1): string | undefined;
+/**
+ * Default folding for the 差异 tab: keep the first `rowBudget` rendered rows
+ * open, fold every file after that.
+ *
+ * A 40-file commit painting up to `PATCH_ROW_CAP` rows in a pane that may be
+ * 80px tall is a scroll wall where the reader sees none of the topology; the
+ * reference opens a curated subset for the same reason. Folding the TAIL (not
+ * per-file size) keeps the reading order intact: the files you scrolled to are
+ * still in the same place, just collapsed, and one click opens any of them.
+ */
+export declare function autoFoldCommitPatch(model: CommitPatchModel, rowBudget?: number): string[];
+/**
+ * Ref badge decoration for one `%D` entry (shared by the graph rows and the
+ * commit card). Split for the same reason the history panel split them: the
+ * CSS modifier and the display text are different jobs.
+ */
+export declare function refBadgeClass(ref: string): string;
+/** Display text of one `%D` entry (`HEAD -> main` → `main`, `tag: v1` → `v1`). */
+export declare function refBadgeLabel(ref: string): string;

package/lib/types/client/store.d.ts

@@ -240,7 +240,7 @@ export interface ExplorerValue {
     /** 停靠回主界面（底层的中心视图或侧栏表面）。 */
     dockFloatingEditor: () => void;
     openDiff: (rel: string, staged: boolean, untracked?: boolean) => void;
-    openCommitFile: (hash: string, rel: string) => void;
+    openCommitFile: (hash: string, rel: string, origPath?: string) => void;
     activateTab: (id: string) => void;
     closeTab: (id: string) => void;
     updateTab: (id: string, patch: Partial<EditorTab>) => void;
@@ -547,8 +547,14 @@ export declare function openRemoteFileInBinding(bindingId: string, remotePath: s
 export declare function isEditorTakeoverActive(): boolean;
 /** Open (or focus) a working-tree diff of one repository path. */
 export declare function openDiff(rel: string, staged: boolean, untracked?: boolean): void;
-/** Open (or focus) one file of one commit (`ref^` against `ref`). */
-export declare function openCommitFile(hash: string, rel: string): void;
+/**
+ * Open (or focus) one file of one commit (`ref^` against `ref`).
+ *
+ * `origPath` is the rename source from the commit's file row / patch header:
+ * the two-sided view must diff the OLD path against the NEW one, or git sees
+ * two unrelated paths and paints the rename as a whole-file addition.
+ */
+export declare function openCommitFile(hash: string, rel: string, origPath?: string): void;
 export declare function activateTab(id: string): void;
 export declare function closeTab(id: string): void;
 export declare function updateTab(id: string, next: Partial<EditorTab>): void;

package/lib/types/client/vsc/kit.d.ts

@@ -17,6 +17,14 @@ type IconProps = {
     className?: string;
 };
 export declare function IconChevronRight(props: IconProps): ReactNode;
+/** Mirror of {@link IconChevronRight}, for the commit pane's "previous file". */
+export declare function IconChevronLeft(props: IconProps): ReactNode;
+/** Expand: two arrows pushing the corners apart (the pane's full-height toggle). */
+export declare function IconExpand(props: IconProps): ReactNode;
+/** Restore: the same two arrows pulling the corners back in. */
+export declare function IconCollapse(props: IconProps): ReactNode;
+/** Wrap long lines: a line turning back on itself instead of running off. */
+export declare function IconWrap(props: IconProps): ReactNode;
 export declare function IconChevronDown(props: IconProps): ReactNode;
 /** Mirror of `IconChevronDown`, for the diff's "previous change" button. */
 export declare function IconChevronUp(props: IconProps): ReactNode;
@@ -29,6 +37,14 @@ export declare function IconPlus(props: IconProps): ReactNode;
 export declare function IconNewFolder(props: IconProps): ReactNode;
 export declare function IconTrash(props: IconProps): ReactNode;
 export declare function IconClose(props: IconProps): ReactNode;
+/** Stop: a filled square — the universal "kill this run" mark. */
+export declare function IconStop(props: IconProps): ReactNode;
+/** Copy glyph: two offset sheets, the front one the clipboard's payload. */
+export declare function IconCopy(props: IconProps): ReactNode;
+/** Author glyph for the commit pane's metadata rows. */
+export declare function IconUser(props: IconProps): ReactNode;
+/** Date glyph, the pair of {@link IconUser} in the commit pane's metadata. */
+export declare function IconClock(props: IconProps): ReactNode;
 export declare function IconSearch(props: IconProps): ReactNode;
 /**
  * "Search file NAMES": a page with a magnifier tucked into its lower-right

package/lib/types/git-format.d.ts

@@ -30,5 +30,10 @@ export declare function parseStatus(stdout: string): GitStatus;
 export declare function parseLog(stdout: string): GitCommit[];
 /** Parse for-each-ref branch lines. */
 export declare function parseBranches(stdout: string, current: string): GitBranch[];
+/** Split a raw `%B` message into its subject line and the body below it. */
+export declare function parseMessage(text: string): {
+    subject: string;
+    body: string;
+};
 /** Assemble commit detail from message + stat outputs. */
 export declare function parseShow(hash: string, message: string, stat: string): GitShow;

package/lib/types/git-ops.d.ts

@@ -13,6 +13,15 @@ export declare function assertBranchName(name: string): string;
 export declare function assertRemoteName(name: string): string;
 /** Assert a remote URL (anything printable without control characters). */
 export declare function assertRemoteUrl(url: string): string;
+/**
+ * Assert a push refspec (`HEAD:refs/for/master`, `+refs/heads/x:refs/heads/y`).
+ *
+ * The charset is the union git accepts on the two sides of the optional colon,
+ * plus the force marker and the `{}`/`~`/`^`/`*` revision syntax. `assertRef`
+ * cannot be reused: it deliberately rejects `:`, and the whole point of a
+ * custom refspec is the destination side (Gerrit's `refs/for/<branch>`).
+ */
+export declare function assertPushRefspec(refspec: string): string;
 /** Resolve the enclosing repository root (fails outside a work tree). */
 export declare function repoProbeCommand(workdir: string): string;
 /**
@@ -97,8 +106,35 @@ export interface DiffRequest {
 }
 /** Unified diff (or a diffstat) for one side of the working tree. */
 export declare function diffCommand(workdir: string, request?: DiffRequest): string;
-/** Files touched by one commit (`--name-status`, no patch body). */
+/**
+ * Files touched by one commit (`--name-status`, no patch body).
+ *
+ * `--first-parent` is what makes a MERGE commit show anything: plain
+ * `git show --name-status <merge>` prints no file rows at all (measured), so
+ * the pane said "这个提交没有改动文件" for every merge. With it, the diff is
+ * against the first parent — the merge's own contribution — and non-merge
+ * commits are byte-for-byte unchanged.
+ */
 export declare function commitFilesCommand(workdir: string, ref: string): string;
+/**
+ * Whole patch of one commit, with the commit header stripped (`--format=`), so
+ * the output starts at the first `diff --git` line and parses as a plain
+ * unified diff. Capped like every read-only builder: a commit that rewrites a
+ * generated file would otherwise ship megabytes for one sidebar pane.
+ * `--first-parent` makes merge commits readable (see `commitFilesCommand`).
+ */
+export declare function commitPatchCommand(workdir: string, ref: string): string;
+/**
+ * One changed file's patch inside a commit, with rename detection
+ * (`-M`) across BOTH sides of the path.
+ *
+ * The plain `git diff <hash>^ -- <newPath>` the editor drill-down used to run
+ * is wrong for a rename: the old path never matches, so a 100% rename renders
+ * as an all-added file. Passing both paths to `git show -M` lets git report
+ * the rename the commit actually recorded. Restricted to `paths` so a giant
+ * commit still ships one file.
+ */
+export declare function commitFileDiffCommand(workdir: string, ref: string, paths: readonly string[]): string;
 /** One file's content at a revision (`rev` may also be `:0` for the index). */
 export declare function fileAtRevCommand(workdir: string, rev: string, path: string): string;
 /** Local + remote-tracking branches with their upstream and tip. */
@@ -137,12 +173,31 @@ export declare function renameBranchCommand(workdir: string, from: string, to: s
 export declare function mergeCommand(workdir: string, ref: string): string;
 /** Publish a branch to a remote and set its upstream. */
 export declare function publishBranchCommand(workdir: string, branch: string, remote: string): string;
-/** Fetch every remote, pruning deleted tracking refs. */
+/**
+ * Fetch every remote, pruning deleted tracking refs.
+ *
+ * NOTE: the four NETWORK verbs deliberately do NOT use `statusOk()`. That
+ * wrapper buffers git's output in temp files and cats them back only after the
+ * command exits, which made the live-output panel sit on "waiting…" for the
+ * whole run and then dump everything at once (measured: a 59 s push produced
+ * 0.2 s of output after completion). No pipe is involved here, so the shell
+ * returns git's own exit status directly, and `--progress` forces the progress
+ * lines even though the remote side is not a TTY.
+ */
 export declare function fetchCommand(workdir: string): string;
 /** Pull the current branch (merge, no editor prompt). */
 export declare function pullCommand(workdir: string): string;
 /** Push the current branch. */
 export declare function pushCommand(workdir: string): string;
+/**
+ * Push to an explicit remote with an explicit refspec.
+ *
+ * This is the Gerrit shape (`git push origin HEAD:refs/for/master`): the plain
+ * `git push` above only ever talks to the branch's upstream, so a review
+ * workflow had to drop into a terminal. The remote is explicit because a
+ * refspec says nothing about which remote it belongs to.
+ */
+export declare function pushRefspecCommand(workdir: string, remote: string, refspec: string): string;
 /** Stash the working tree (optionally including untracked files). */
 export declare function stashSaveCommand(workdir: string, message: string, includeUntracked: boolean): string;
 /** Apply (and keep) a stash entry. */

package/lib/types/pool.d.ts

@@ -3,6 +3,15 @@ import type { RemoteStore } from './store.ts';
 import type { RemoteExecResult } from './protocol.ts';
 export interface ExecOptions {
     timeoutMs?: number;
+    /**
+     * Live sink for the command's output (the streaming network verbs). Called
+     * with already-decoded text so a multi-byte character split across ssh2
+     * chunks is never mangled; the accumulated `stdout`/`stderr` on the result
+     * keep the same bytes.
+     */
+    onData?: (stream: 'out' | 'err', text: string) => void;
+    /** Receives the cancel handle once the run is under way (see `cancel`). */
+    onCancel?: (cancel: () => void) => void;
     /**
      * Internal: send the line exactly as given — no session wrapper, and no group
      * kill when it times out. Only the two commands the pool sends on its own

package/lib/types/protocol.d.ts

@@ -9,6 +9,8 @@ export declare const REMOTE_API: {
     readonly test: "/api/dsh-remote/test";
     readonly keygen: "/api/dsh-remote/keygen";
     readonly exec: "/api/dsh-remote/exec";
+    /** Streaming exec (server-sent events) for the long network verbs. */
+    readonly execStream: "/api/dsh-remote/exec-stream";
     readonly files: "/api/dsh-remote/files";
     /** Streaming binary upload: raw request body, host and path in the query. */
     readonly upload: "/api/dsh-remote/upload";
@@ -212,6 +214,27 @@ export interface RemoteExecResult {
     /** Connection error message when the command never ran. */
     error?: string | undefined;
 }
+/**
+ * One server-sent event of the streaming exec route.
+ *
+ * Used by the long network verbs (fetch / pull / push / sync) so the live git
+ * output can be shown while the command is still running; the unary exec route
+ * keeps serving everything that only needs the result.
+ */
+export type ExecStreamEvent = {
+    t: 'out';
+    d: string;
+} | {
+    t: 'err';
+    d: string;
+} | {
+    t: 'exit';
+    success: boolean;
+    exitCode: number | null;
+    timedOut: boolean;
+    durationMs: number;
+    error?: string;
+};
 /** Client -> server terminal frames (JSON text). */
 export type TerminalClientFrame = {
     t: 'in';

package/lib/types/timeouts.d.ts

@@ -19,8 +19,14 @@
 import type { RemoteTimeouts } from './protocol.ts';
 /** Smallest accepted timeout: below this, local work would start failing. */
 export declare const MIN_TIMEOUT_MS = 1000;
-/** Largest accepted timeout — the exec route clamps to the same ceiling. */
-export declare const MAX_TIMEOUT_MS = 600000;
+/**
+ * Largest accepted timeout — the exec route clamps to the same ceiling.
+ *
+ * Raised from 10 to 30 minutes when the SCM push gained a live output panel:
+ * a Gerrit push on a large repo waits for server-side hooks and can outlast
+ * the old ceiling with nothing wrong on either side.
+ */
+export declare const MAX_TIMEOUT_MS = 1800000;
 /**
  * Default for one git command (status/log/branches/diff over exec).
  *
@@ -30,6 +36,15 @@ export declare const MAX_TIMEOUT_MS = 600000;
  * plausible cold index walk.
  */
 export declare const DEFAULT_GIT_TIMEOUT_MS = 300000;
+/**
+ * Floor for the NETWORK verbs (fetch / pull / push / sync).
+ *
+ * These wait on the far end's hooks and pack transfer, not on this machine, so
+ * their budget starts at 20 minutes and grows with `gitTimeoutMs × 2` up to
+ * `MAX_TIMEOUT_MS`. The old formula started at 5 minutes and capped at 10, which
+ * killed healthy Gerrit pushes.
+ */
+export declare const DEFAULT_NETWORK_TIMEOUT_MS = 1200000;
 /** Default for one SFTP file read (editor, diff sides, document preview). */
 export declare const DEFAULT_READ_TIMEOUT_MS = 120000;
 /** The pair every half starts from before any Host answer arrives. */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-remote-vs",
   "description": "VSCode-style remote development for DSH: SSH host manager (key/password), helper deploy pipeline with version check, remote file explorer + editor + terminal in dsh-better-sidebar.",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "icon": "icon.svg",
   "keywords": [
     "dsh",

package/src/client/api.ts

@@ -3,6 +3,7 @@
  */
 import {
   REMOTE_API,
+  type ExecStreamEvent,
   type GitBranch,
   type GitCommit,
   type GitShow,
@@ -23,6 +24,7 @@ import {
   type RemoteWorkspaceBinding,
 } from '../protocol.ts'
 import { DEFAULT_TIMEOUTS, normalizeTimeouts, timeoutSeconds } from '../timeouts.ts'
+import { parseSseFrame, takeSseFrames } from './exec-output.ts'
 import {
   branchesCommand,
   gitFailed,
@@ -230,6 +232,65 @@ export const api = {
   // -- exec
   exec: (alias: string, command: string, timeoutMs?: number) =>
     post<RemoteExecResult>(REMOTE_API.exec, timeoutMs === undefined ? { alias, command } : { alias, command, timeoutMs }),
+  /**
+   * Streaming exec: the network verbs' live log.
+   *
+   * The route answers as SSE frames; `onData` receives decoded text while the
+   * command runs, and the promise settles on the `exit` frame. An aborted
+   * `signal` cancels the remote process group on the host side (the route acts
+   * on the closed response), so a cancel button can actually stop a push.
+   */
+  execStream: async (
+    alias: string,
+    command: string,
+    timeoutMs: number,
+    handlers: { onData?: (stream: 'out' | 'err', text: string) => void; signal?: AbortSignal },
+  ): Promise<RemoteExecResult> => {
+    const response = await fetch(REMOTE_API.execStream, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ alias, command, timeoutMs }),
+      ...(handlers.signal === undefined ? {} : { signal: handlers.signal }),
+    })
+    if (!response.ok || response.body === null) {
+      let message = `request failed: HTTP ${response.status}`
+      try {
+        const data = await response.json() as { error?: unknown }
+        if (typeof data.error === 'string') message = data.error
+      } catch {
+        // Keep the status-based message.
+      }
+      throw new RemoteApiError(response.status, message)
+    }
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    let exit: Extract<ExecStreamEvent, { t: 'exit' }> | undefined
+    for (;;) {
+      const { done, value } = await reader.read()
+      if (done) break
+      buffer += decoder.decode(value, { stream: true })
+      const { frames, rest } = takeSseFrames(buffer)
+      buffer = rest
+      for (const frame of frames) {
+        const payload = parseSseFrame(frame)
+        if (payload === null || typeof payload !== 'object') continue
+        const event = payload as ExecStreamEvent
+        if (event.t === 'out' || event.t === 'err') handlers.onData?.(event.t, event.d)
+        else if (event.t === 'exit') exit = event
+      }
+    }
+    if (exit === undefined) throw new RemoteApiError(502, 'stream ended without an exit frame')
+    return {
+      success: exit.success,
+      exitCode: exit.exitCode,
+      timedOut: exit.timedOut,
+      stdout: '',
+      stderr: '',
+      durationMs: exit.durationMs,
+      ...(exit.error === undefined ? {} : { error: exit.error }),
+    }
+  },
   // -- workspaces
   getWorkspaces: () => call<{ workspaces: RemoteWorkspaceBinding[] } & RemoteRoutingStatus & RemotePluginMeta>(REMOTE_API.workspaces),
   createWorkspace: (payload: { name: string; alias: string; remotePath: string }) =>

package/src/client/exec-output.ts

@@ -0,0 +1,129 @@
+/**
+ * Pure helpers behind the streaming exec surface (the network verbs' live log).
+ *
+ * The host route answers as server-sent events so a 20-minute push can show its
+ * progress (`remote: …`, hook output, pack lines) while it runs, instead of one
+ * line after the fact. Everything here is pure so the local self-check can pin
+ * the frame splitting (a chunk boundary may fall anywhere) and the output cap
+ * without a browser or a host.
+ */
+import { DEFAULT_NETWORK_TIMEOUT_MS, MAX_TIMEOUT_MS } from '../timeouts.ts'
+import { fetchCommand, pullCommand, pushCommand, pushRefspecCommand } from '../git-ops.ts'
+
+/** What a streamed push should do: remembered refspec ('' = plain) + remote. */
+export interface PushTarget {
+  refspec: string
+  remote: string
+}
+
+/**
+ * The commands one network verb runs, in order.
+ *
+ * Pure so the gate can pin the sequence: sync is pull-then-push (the historical
+ * order), and a push with a refspec must not fall back to the bare form.
+ */
+export function networkCommands(root: string, kind: 'fetch' | 'pull' | 'push' | 'sync', push: PushTarget): string[] {
+  if (kind === 'fetch') return [fetchCommand(root)]
+  if (kind === 'pull') return [pullCommand(root)]
+  const pushCmd = push.refspec === '' ? pushCommand(root) : pushRefspecCommand(root, push.remote, push.refspec)
+  if (kind === 'push') return [pushCmd]
+  // Sync keeps its historical order, and honours a refspec when one is given
+  // (the UI currently passes '' for sync, but the API must not quietly drop it).
+  return [pullCommand(root), pushCmd]
+}
+
+/** Live-log cap: keep the TAIL, because the head of a long push is never the point. */
+export const EXEC_OUTPUT_CAP = 200_000
+
+/**
+ * Fold carriage-return progress rewrites for DISPLAY.
+ *
+ * git's progress lines are written as `Counting: 1%\rCounting: 2%\r…` and a
+ * `<pre>` would render every rewrite as its own line (hundreds of them for one
+ * push). Only the content after the last `\r` of a line survives.
+ *
+ * Fold at RENDER time, over the complete accumulated text — not inside
+ * `appendExecOutput`. A chunk can end mid-rewrite (git writes bare `\r`s at
+ * arbitrary boundaries), and folding a fragment loses the state that the next
+ * fragment continues: measured against real `git push --progress` stderr, the
+ * per-chunk fold glued `Counting: 1%Counting: 2%…` into one long line.
+ */
+export function foldExecOutput(text: string): string {
+  if (!text.includes('\r')) return text
+  return text
+    .split('\n')
+    .map(line => {
+      if (!line.includes('\r')) return line
+      // A trailing `\r` (progress finished, then newline) does not erase what
+      // was drawn before it: the visible text is the last NON-EMPTY rewrite.
+      const parts = line.split('\r')
+      for (let index = parts.length - 1; index >= 0; index -= 1) {
+        const part = parts[index] as string
+        if (part !== '') return part
+      }
+      return ''
+    })
+    .join('\n')
+}
+
+/**
+ * Append one decoded chunk, keeping the TAIL.
+ *
+ * The raw `\r` bytes are preserved on purpose: the view folds them once, over
+ * the whole accumulated log, so a rewrite split across two chunks still folds
+ * correctly (`foldExecOutput`).
+ */
+export function appendExecOutput(previous: string, chunk: string, cap = EXEC_OUTPUT_CAP): string {
+  if (chunk === '') return previous
+  const combined = previous + chunk
+  if (combined.length <= cap) return combined
+  return combined.slice(combined.length - cap)
+}
+
+/**
+ * Split an SSE buffer into complete frames and the incomplete tail.
+ *
+ * A chunk can end in the middle of `data: {...}` or between the two newlines
+ * that terminate a frame, so the caller must carry `rest` into the next read.
+ */
+export function takeSseFrames(buffer: string): { frames: string[]; rest: string } {
+  const parts = buffer.split('\n\n')
+  const rest = parts.pop() ?? ''
+  return { frames: parts.filter(frame => frame.trim() !== ''), rest }
+}
+
+/**
+ * One SSE frame's JSON payload; `undefined` for comments (heartbeats), empty
+ * frames and malformed JSON — a broken heartbeat must not kill the stream.
+ */
+export function parseSseFrame(frame: string): unknown | undefined {
+  const data = frame
+    .split('\n')
+    .filter(line => line.startsWith('data:'))
+    .map(line => line.slice(5).trimStart())
+    .join('\n')
+  if (data === '') return undefined
+  try {
+    return JSON.parse(data) as unknown
+  } catch {
+    return undefined
+  }
+}
+
+/** `m:ss` (or `h:mm:ss`) for the running timer. */
+export function formatElapsed(ms: number): string {
+  const total = Math.max(0, Math.floor(ms / 1000))
+  const seconds = total % 60
+  const minutes = Math.floor(total / 60) % 60
+  const hours = Math.floor(total / 3600)
+  const pad = (value: number): string => String(value).padStart(2, '0')
+  return hours > 0 ? `${hours}:${pad(minutes)}:${pad(seconds)}` : `${minutes}:${pad(seconds)}`
+}
+
+/**
+ * The network verbs' budget: at least 20 minutes, or twice the configured git
+ * budget when that is larger, never past the host's 30-minute ceiling.
+ */
+export function networkBudgetMs(gitTimeoutMs: number): number {
+  return Math.min(MAX_TIMEOUT_MS, Math.max(DEFAULT_NETWORK_TIMEOUT_MS, gitTimeoutMs * 2))
+}