dsh-remote-vs 0.9.3 → 0.11.0

package/src/client/scm/ScmPanel.tsx

@@ -9,8 +9,9 @@
  * and the change list never disagree.
  */
 import { Fragment, useCallback, useEffect, useMemo, useRef, useState, type MouseEvent as ReactMouseEvent, type ReactNode } from 'react'
-import type { GitBranch, GitRemote, GitStash } from '../../protocol.ts'
+import type { GitBranch, GitRemote, GitStash, RemoteExecResult } from '../../protocol.ts'
 import { gitReadSettleMs, useExplorer } from '../store.tsx'
+import { RemoteApiError, gitTimeoutMs } from '../api.ts'
 import {
   branchOp,
   commitAll,
@@ -20,10 +21,14 @@ import {
   loadRemotes,
   loadStashes,
   lastCommitMessage,
+  pushWithRefspec,
   remoteOp,
   stashOp,
+  streamNetworkVerb,
   syncRepo,
 } from './actions.ts'
+import { appendExecOutput, formatElapsed, networkBudgetMs, type PushTarget } from '../exec-output.ts'
+import { ExecPanel, type ExecPanelState } from './ExecPanel.tsx'
 import type { ChangeEntry } from './status-map.ts'
 import { rowVerb } from './status-map.ts'
 import { ReadQueue } from './read-queue.ts'
@@ -56,6 +61,25 @@ import {
 } from '../vsc/kit.tsx'
 
 const MSG_KEY = 'dsh-remote-vs.commitMsg'
+/** Remembered custom push refspec (Gerrit shape); absent = never customized. */
+const PUSH_REFSPEC_KEY = 'dsh-remote-vs.pushRefspec'
+
+function readPushRefspec(): string {
+  try {
+    return localStorage.getItem(PUSH_REFSPEC_KEY) ?? ''
+  } catch {
+    return ''
+  }
+}
+
+function writePushRefspec(value: string): void {
+  try {
+    if (value === '') localStorage.removeItem(PUSH_REFSPEC_KEY)
+    else localStorage.setItem(PUSH_REFSPEC_KEY, value)
+  } catch {
+    // Ignore: a blocked localStorage must not break the push flow.
+  }
+}
 
 /**
  * One extras read per repository at a time.
@@ -81,6 +105,16 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
   const store = useExplorer()
   const { t, lang, buckets, head, alias, repoRoot } = store
   const [folded, setFolded] = useState<Record<string, boolean>>({})
+  /** Live log of the running network verb (undefined = panel closed). */
+  const [execPanel, setExecPanel] = useState<ExecPanelState | undefined>(undefined)
+  const execAbort = useRef<AbortController | undefined>(undefined)
+  const execLog = useRef('')
+  /** The live-log repaint interval (kept out of render state on purpose). */
+  const execTimer = useRef<ReturnType<typeof setInterval> | undefined>(undefined)
+  // Leaving the panel mid-push must not leave a 250 ms setState loop running.
+  useEffect(() => () => {
+    if (execTimer.current !== undefined) clearInterval(execTimer.current)
+  }, [])
   const [message, setMessage] = useState<string>(() => {
     try {
       return localStorage.getItem(MSG_KEY) ?? ''
@@ -391,20 +425,216 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
     }, 'status')
   }
 
+  /**
+   * The remote a push goes to: the current branch's upstream remote, else
+   * `origin`. A refspec names no remote, so the panel has to pick one.
+   */
+  const pushRemote = (): string => {
+    const current = branches.find(item => item.head) ?? branches.find(item => item.name === head?.branch)
+    const upstream = current?.upstream ?? ''
+    const slash = upstream.indexOf('/')
+    return slash > 0 ? upstream.slice(0, slash) : 'origin'
+  }
+
   const doSync = async (kind: 'fetch' | 'pull' | 'push' | 'sync'): Promise<void> => {
     if (repoRoot === undefined) return
-    if (kind === 'push' || kind === 'sync') {
+    /** Empty = the plain `git push` (upstream) this action used to run. */
+    let refspec = ''
+    let remote = 'origin'
+    if (kind === 'push') {
+      // Gerrit-style review needs a destination refspec (`refs/for/<branch>`);
+      // a bare `git push` can never produce one. The prompt is the confirmation
+      // AND the destination field, with the last custom value remembered.
+      const current = branches.find(item => item.head) ?? branches.find(item => item.name === head?.branch)
+      const branchName = head?.detached === true || head === undefined
+        ? (current?.name ?? 'master')
+        : head.branch
+      remote = pushRemote()
+      const remembered = readPushRefspec()
+      const answer = await promptDialog({
+        title: t('scm.pushTitle'),
+        text: t('scm.pushText'),
+        initial: remembered !== '' ? remembered : `HEAD:refs/for/${branchName}`,
+        placeholder: t('scm.pushRefspecPlaceholder'),
+        okText: t('scm.push'),
+      })
+      if (answer === undefined) return
+      refspec = answer.trim()
+      writePushRefspec(refspec)
+    } else if (kind === 'sync') {
       const ok = await confirmDialog({
-        title: kind === 'push' ? t('scm.pushTitle') : t('scm.syncTitle'),
-        text: kind === 'push' ? t('scm.pushText') : t('scm.syncText'),
-        okText: kind === 'push' ? t('scm.push') : t('scm.sync'),
+        title: t('scm.syncTitle'),
+        text: t('scm.syncText'),
+        okText: t('scm.sync'),
       })
       if (!ok) return
     }
-    await guard(kind, async () => {
-      const output = await syncRepo(alias, repoRoot, kind)
-      toast(`${t('scm.syncDone')} ${output.split('\n').slice(-1)[0] ?? ''}`.trim())
-    })
+    const baseTitle = kind === 'push'
+      ? t('scm.pushTitle')
+      : kind === 'sync'
+        ? t('scm.syncTitle')
+        : kind === 'fetch'
+          ? t('scm.fetch')
+          : t('scm.pull')
+    // The destination belongs in the panel title: "push" alone hides whether
+    // Gerrit review or a plain branch push is running.
+    const title = kind === 'push' ? `${baseTitle} · ${refspec === '' ? 'git push' : refspec}` : baseTitle
+    await runNetwork(kind, title, { refspec, remote })
+  }
+
+  /**
+   * Stop the running network verb: confirm first.
+   *
+   * The stop button kills the remote process group, so `sync` can end with the
+   * pull applied and the push never attempted, and `pull` can leave a
+   * half-merged tree. One confirmation is the honest price of that.
+   */
+  const cancelNetwork = (): void => {
+    void (async () => {
+      const ok = await confirmDialog({
+        title: t('exec.cancel'),
+        text: t('exec.cancelHint'),
+        danger: true,
+        okText: t('exec.cancel'),
+      })
+      if (ok) execAbort.current?.abort()
+    })()
+  }
+
+  /**
+   * Run one network verb with its live output on screen.
+   *
+   * `streamNetworkVerb` speaks the SSE route; an older Host that has no such
+   * route falls back to the unary verb and shows the complete result in the same
+   * panel. The timer and the log are painted on their own 250 ms cadence — a
+   * per-chunk setState would re-render the whole SCM panel for every line git
+   * prints.
+   */
+  const runNetwork = async (
+    kind: 'fetch' | 'pull' | 'push' | 'sync',
+    title: string,
+    target: PushTarget,
+  ): Promise<void> => {
+    if (repoRoot === undefined) return
+    const startedAt = Date.now()
+    const controller = new AbortController()
+    execAbort.current = controller
+    execLog.current = ''
+    setExecPanel({ title, output: '', status: 'running', startedAt, elapsedMs: 0 })
+    setBusy(kind)
+    let painted = ''
+    const timer = setInterval(() => {
+      if (execLog.current !== painted) {
+        painted = execLog.current
+        setExecPanel(prev => (prev === undefined || prev.status !== 'running'
+          ? prev
+          : { ...prev, output: painted, elapsedMs: Date.now() - startedAt }))
+        return
+      }
+      setExecPanel(prev => (prev === undefined || prev.status !== 'running'
+        ? prev
+        : { ...prev, elapsedMs: Date.now() - startedAt }))
+    }, 250)
+    execTimer.current = timer
+    /** True when the unary fallback answered (no exit code was observed then). */
+    let fallbackUsed = false
+    /** Cancel: no refresh storm while the user is just stopping a run. */
+    let cancelledByUser = false
+    try {
+      let result: RemoteExecResult
+      let output = ''
+      try {
+        const streamed = await streamNetworkVerb(alias, repoRoot, kind, target, {
+          signal: controller.signal,
+          onData: (_stream, text) => {
+            execLog.current = appendExecOutput(execLog.current, text)
+          },
+        })
+        result = streamed.result
+        output = streamed.output
+        execLog.current = output
+      } catch (error) {
+        if (controller.signal.aborted) throw error
+        // Fall back ONLY when the route itself is absent (older Host: 404/405
+        // before any output). A stream that broke AFTER the push started must
+        // not be retried unary — that would run `git push` a second time.
+        const routeMissing = error instanceof RemoteApiError
+          && (error.status === 404 || error.status === 405)
+          && execLog.current === ''
+        if (!routeMissing) throw error
+        fallbackUsed = true
+        output = kind === 'push' && target.refspec !== ''
+          ? await pushWithRefspec(alias, repoRoot, target.remote, target.refspec)
+          : await syncRepo(alias, repoRoot, kind)
+        execLog.current = appendExecOutput('', output)
+        result = {
+          success: true,
+          // No stream → no observed exit code. Claiming 0 in the footer would be
+          // a lie; the footer wording below drops the code for this path.
+          exitCode: null,
+          timedOut: false,
+          stdout: output,
+          stderr: '',
+          durationMs: Date.now() - startedAt,
+        }
+      }
+      const budgetMin = Math.round(networkBudgetMs(gitTimeoutMs()) / 60_000)
+      // Keep the verb-specific success wording in the panel footer (the toast
+      // that used to carry it would cover this very footer).
+      const doneLabel = result.success
+        ? kind === 'sync'
+          ? t('scm.syncDone')
+          : kind === 'push' && target.refspec !== ''
+            ? t('scm.pushRefspecDone').replace('{refspec}', target.refspec)
+            : ''
+        : ''
+      const exitText = fallbackUsed
+        ? `${t('exec.unaryResult')} · ${formatElapsed(result.durationMs)}`
+        : result.timedOut
+          ? `${t('exec.timedOut')} · ${budgetMin} min`
+          : `${doneLabel === '' ? '' : `${doneLabel} · `}${t('exec.exitCode')} ${result.exitCode ?? '?'} · ${formatElapsed(result.durationMs)}${
+            result.error === undefined ? '' : ` · ${result.error}`
+          }`
+      setExecPanel(prev => (prev === undefined
+        ? prev
+        : {
+          ...prev,
+          output: execLog.current,
+          elapsedMs: Date.now() - startedAt,
+          status: result.success ? 'done' : 'error',
+          exitText,
+        }))
+      // The panel IS the feedback now: a toast would land exactly on the panel's
+      // exit-code footer (toast z-index 100001 vs panel 45) — only failures
+      // still raise one.
+      if (!result.success) toast(result.timedOut ? t('exec.timedOut') : t('exec.failed'), true)
+    } catch (error) {
+      if (controller.signal.aborted) {
+        cancelledByUser = true
+        setExecPanel(prev => (prev === undefined
+          ? prev
+          : { ...prev, output: execLog.current, status: 'cancelled', elapsedMs: Date.now() - startedAt }))
+        return
+      }
+      setExecPanel(prev => (prev === undefined
+        ? prev
+        : {
+          ...prev,
+          output: execLog.current,
+          status: 'error',
+          elapsedMs: Date.now() - startedAt,
+          exitText: `${t('exec.unknownResult')} · ${messageOf(error)}`,
+        }))
+      toast(t('exec.unknownResult'), true)
+    } finally {
+      clearInterval(timer)
+      execTimer.current = undefined
+      execAbort.current = undefined
+      setBusy(undefined)
+      // A cancel already stopped the command; a full status+extras refresh would
+      // only pile three more remote git runs onto the user's intent.
+      if (!cancelledByUser) await refreshAll()
+    }
   }
 
   const saveStash = async (): Promise<void> => {
@@ -540,6 +770,14 @@ export function ScmPanel(props: { onOpenHistory: () => void; visible: boolean })
 
   return (
     <div className="rvs-pane grow">
+      {execPanel !== undefined && (
+        <ExecPanel
+          state={execPanel}
+          onCancel={cancelNetwork}
+          onClose={() => { setExecPanel(undefined) }}
+          t={t}
+        />
+      )}
       <div className="rvs-header">
         <span className="rvs-title">{t('scm.title')}</span>
         {store.gitBusy && <MiniSpinner />}

package/src/client/scm/actions.ts

@@ -9,7 +9,7 @@
  */
 import { REMOTE_API } from '../../protocol.ts'
 import type { GitBranch, GitCommitFile, GitRemote, GitStash, GitStatusDetail, RemoteExecResult, RemoteRead } from '../../protocol.ts'
-import { assertRef, shQuote } from '../../git-format.ts'
+import { assertRef, messageCommand, parseMessage, shQuote } from '../../git-format.ts'
 import {
   addRemoteCommand,
   allBranchesCommand,
@@ -18,13 +18,16 @@ import {
   checkoutCommand,
   cleanUntrackedCommand,
   commitCommand,
+  commitFileDiffCommand,
   commitFilesCommand,
+  commitPatchCommand,
   createBranchCommand,
   deleteBranchCommand,
   diffCommand,
   fetchCommand,
   fileAtRevCommand,
   gitErrorHint,
+  GIT_CAP,
   headMessageCommand,
   mergeCommand,
   parseAllBranches,
@@ -37,6 +40,7 @@ import {
   pullCommand,
   publishBranchCommand,
   pushCommand,
+  pushRefspecCommand,
   remotesCommand,
   removeRemoteCommand,
   renameBranchCommand,
@@ -58,7 +62,8 @@ import {
   unstageCommand,
 } from '../../git-ops.ts'
 import { api, gitTimeoutMs } from '../api.ts'
-import { DEFAULT_GIT_TIMEOUT_MS, MAX_TIMEOUT_MS, timeoutSeconds } from '../../timeouts.ts'
+import { appendExecOutput, networkBudgetMs, networkCommands, type PushTarget } from '../exec-output.ts'
+import { timeoutSeconds } from '../../timeouts.ts'
 
 /** Error carrying a message already fit for the UI. */
 export class GitOpError extends Error {}
@@ -76,12 +81,15 @@ export function joinRemote(dir: string, rel: string): string {
  * These were fixed (120 s normal / 300 s network) and were the reason a large
  * remote repository reported "git timed out" while git was still working: the
  * explorer's own client deadline cut in even earlier. Both now follow the
- * configured `gitTimeoutMs` (default 300 s), and the network verbs get double
- * that (capped by the Host route's ceiling), because fetch/pull/push on a big
- * tree legitimately outlast a status read.
+ * configured `gitTimeoutMs` (default 300 s), and the network verbs get at least
+ * `DEFAULT_NETWORK_TIMEOUT_MS` (20 min) — or double the configured budget when
+ * that is larger — capped by the Host route's 30-minute ceiling. A push waits
+ * for the far end's hooks and pack transfer, so the old 10-minute cap killed
+ * healthy Gerrit pushes.
  */
 const normalTimeoutMs = (): number => gitTimeoutMs()
-const longTimeoutMs = (): number => Math.min(MAX_TIMEOUT_MS, Math.max(DEFAULT_GIT_TIMEOUT_MS, gitTimeoutMs() * 2))
+/** One formula for the network verbs, shared with the streamed path. */
+const longTimeoutMs = (): number => networkBudgetMs(gitTimeoutMs())
 
 /** The readable error for a failed exec result (`run` and the strict probe share it). */
 function failureOf(result: RemoteExecResult, timeoutMs: number): GitOpError {
@@ -271,10 +279,18 @@ export async function loadCommitFiles(alias: string, root: string, hash: string)
   return parseCommitFiles(out.stdout)
 }
 
-/** Diff of one path inside a commit (used by the history file drill-down). */
-export async function loadCommitFileDiff(alias: string, root: string, hash: string, path: string): Promise<DiffPayload> {
-  const out = await run(alias, diffCommand(root, { ref: `${hash}^`, path }), 90_000)
-  const oldText = await tryRun(alias, fileAtRevCommand(root, `${hash}^`, path))
+/**
+ * Diff of one path inside a commit (the editor drill-down).
+ *
+ * `origPath` is the rename source: `git show -M -- <old> <new>` needs BOTH
+ * paths or git cannot pair them and a 100% rename renders as a fully-added
+ * file. A root commit has no `^` revision — `git show <hash>` already diffs
+ * against the empty tree, and the failed old-side read degrades to ''.
+ */
+export async function loadCommitFileDiff(alias: string, root: string, hash: string, path: string, origPath?: string): Promise<DiffPayload> {
+  const paths = origPath !== undefined && origPath !== path ? [origPath, path] : [path]
+  const out = await run(alias, commitFileDiffCommand(root, hash, paths), 90_000)
+  const oldText = await tryRun(alias, fileAtRevCommand(root, `${hash}^`, origPath ?? path))
   const newText = await tryRun(alias, fileAtRevCommand(root, hash, path))
   return {
     diff: out.stdout,
@@ -284,6 +300,28 @@ export async function loadCommitFileDiff(alias: string, root: string, hash: stri
   }
 }
 
+/** Raw message of one commit, split into its subject line and the body. */
+export async function loadCommitMessage(alias: string, root: string, hash: string): Promise<{ subject: string; body: string }> {
+  const out = await run(alias, messageCommand(root, hash), 60_000)
+  return parseMessage(out.stdout)
+}
+
+/**
+ * Whole patch of one commit (the commit header is stripped: starts at
+ * `diff --git`).
+ *
+ * `truncated` answers whether the read hit `commitPatchCommand`'s BYTE cap.
+ * The cap is applied with `head -c` (bytes) while the string length counts
+ * UTF-16 code units, so the comparison must measure BYTES too — a CJK-heavy
+ * patch capped at 2,000,000 bytes is only ~667k characters, and a char-length
+ * check silently reported "complete" for a cut patch.
+ */
+export async function loadCommitPatch(alias: string, root: string, hash: string): Promise<{ text: string; truncated: boolean }> {
+  const out = await run(alias, commitPatchCommand(root, hash), 90_000)
+  const bytes = typeof TextEncoder === 'undefined' ? out.stdout.length : new TextEncoder().encode(out.stdout).length
+  return { text: out.stdout, truncated: bytes >= GIT_CAP }
+}
+
 /** Local + remote-tracking branches. */
 export async function loadBranches(alias: string, root: string, current: string): Promise<GitBranch[]> {
   const out = await run(alias, allBranchesCommand(root), 60_000)
@@ -374,6 +412,51 @@ export async function syncRepo(alias: string, root: string, kind: 'fetch' | 'pul
   return `${pulled}\n${pushed}`.trim()
 }
 
+/**
+ * Push to an explicit remote with an explicit refspec (Gerrit review flow:
+ * `HEAD:refs/for/<branch>`). Same timeout budget as the other network verbs.
+ */
+export async function pushWithRefspec(alias: string, root: string, remote: string, refspec: string): Promise<string> {
+  const out = await run(alias, pushRefspecCommand(root, remote, refspec), longTimeoutMs())
+  return `${out.stdout}\n${out.stderr}`.trim()
+}
+
+export interface NetworkStreamHandlers {
+  onData?: (stream: 'out' | 'err', text: string) => void
+  signal?: AbortSignal
+}
+
+/**
+ * Run one network verb over the STREAMING exec route and accumulate its log.
+ *
+ * Stops at the first failing step (a sync whose pull failed must not push a
+ * half-merged tree). The caller owns the live panel; this returns only once the
+ * whole verb has settled, with `output` capped to its tail.
+ */
+export async function streamNetworkVerb(
+  alias: string,
+  root: string,
+  kind: 'fetch' | 'pull' | 'push' | 'sync',
+  push: PushTarget,
+  handlers: NetworkStreamHandlers = {},
+): Promise<{ result: RemoteExecResult; output: string }> {
+  const timeoutMs = networkBudgetMs(gitTimeoutMs())
+  let output = ''
+  let result: RemoteExecResult | undefined
+  for (const command of networkCommands(root, kind, push)) {
+    result = await api.execStream(alias, command, timeoutMs, {
+      ...(handlers.signal === undefined ? {} : { signal: handlers.signal }),
+      onData: (stream, text) => {
+        output = appendExecOutput(output, text)
+        handlers.onData?.(stream, text)
+      },
+    })
+    if (!result.success) break
+    if (kind === 'sync') output = appendExecOutput(output, '\n')
+  }
+  return { result: result as RemoteExecResult, output }
+}
+
 /** Branch verbs. */
 export async function branchOp(
   alias: string,