dsh-remote-vs 0.8.7 → 0.8.9

package/src/client/i18n.ts

@@ -197,6 +197,8 @@ const zh: Record<string, string> = {
   'editor.tokenCount': '语法着色 token 数（0 = 没有语法包或加载的是旧 bundle）',
   'search.empty': '没有匹配的文件。',
   'search.truncated': '结果过多，仅显示前一批。',
+  'search.revealInExplorer': '打开文件所在位置',
+  'search.openInTerminal': '在终端中打开',
   'scm.title': '源代码管理',
   'scm.refresh': '刷新',
   'scm.changes': '更改',
@@ -298,6 +300,9 @@ const zh: Record<string, string> = {
   'scm.stagedReadonly': '已暂存（只读）',
   'scm.reloadDiff': '重新载入差异',
   'scm.hScrollHint': '有比窗口更宽的行 —— 拖动这里左右滚动（或按住 Shift 滚滚轮）',
+  'scm.prevHunk': '上一处改动',
+  'scm.nextHunk': '下一处改动',
+  'scm.hunkNavHint': '在改动之间跳转（显示第 n 处 / 共 N 处）',
   'scm.stageHunk': '暂存该块',
   'scm.unstageHunk': '取消暂存该块',
   'scm.revertHunk': '还原该块',
@@ -530,6 +535,8 @@ const en: Record<string, string> = {
   'editor.tokenCount': 'Colored syntax tokens (0 = no grammar, or a stale client bundle)',
   'search.empty': 'No matching files.',
   'search.truncated': 'Too many hits; showing the first batch.',
+  'search.revealInExplorer': 'Open containing folder',
+  'search.openInTerminal': 'Open in terminal',
   'scm.title': 'Source control',
   'scm.refresh': 'Refresh',
   'scm.changes': 'Changes',
@@ -631,6 +638,9 @@ const en: Record<string, string> = {
   'scm.stagedReadonly': 'staged (read-only)',
   'scm.reloadDiff': 'Reload diff',
   'scm.hScrollHint': 'A line is wider than the view — drag here to scroll sideways (or hold Shift and wheel)',
+  'scm.prevHunk': 'Previous change',
+  'scm.nextHunk': 'Next change',
+  'scm.hunkNavHint': 'Jump between changes (shows change n of N)',
   'scm.stageHunk': 'Stage this hunk',
   'scm.unstageHunk': 'Unstage this hunk',
   'scm.revertHunk': 'Revert this hunk',

package/src/client/remote-file-open-target.ts

@@ -20,6 +20,7 @@
  *  - anything that does not name a known binding answers `undefined`, so the
  *    native preview keeps handling local sessions and unknown addresses.
  */
+import { shellQuote } from './shell.ts'
 
 /** One remote binding as the client store exposes it. */
 export interface RemoteOpenBinding {
@@ -429,11 +430,6 @@ export function bindingForSessionCwd(
   return bindingForHostPath(table, path)
 }
 
-/** POSIX single-quote a word for a remote `bash -c` style command line. */
-function shellQuote(value: string): string {
-  return `'${value.replace(/'/g, `'\\''`)}'`
-}
-
 /**
  * Bounded remote search for a clicked path that no candidate resolved.
  *

package/src/client/scm/DiffView.tsx

@@ -20,7 +20,7 @@ import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, typ
 import type { EditorTab } from '../store.tsx'
 import { useExplorer } from '../store.tsx'
 import { applyHunk, GitOpError } from './actions.ts'
-import { diffCounts } from './diff-model.ts'
+import { diffCounts, hunkAtRow, stepHunk } from './diff-model.ts'
 import type { DiffRow } from '../../protocol.ts'
 import { api } from '../api.ts'
 import { CodeEditor, type CodeEditorHandle } from '../CodeEditor.tsx'
@@ -29,6 +29,8 @@ import { useRemoteChatTarget } from '../use-remote-chat-target.ts'
 import { langFromPath, tokenizeDocument, type Token } from '../vsc/tokenize.ts'
 import {
   IconButton,
+  IconChevronDown,
+  IconChevronUp,
   IconRefresh,
   IconSave,
   MiniSpinner,
@@ -283,6 +285,43 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
   const [hscroll, setHscroll] = useState({ content: 0, viewport: 0 })
   const rowsInView = useRowWindow(tab.model?.rows ?? [])
 
+  /** First row of every change, ascending — the prev/next jump targets. */
+  const hunkRows = useMemo(() => (tab.model === undefined ? [] : tab.model.hunks.map(hunk => hunk.startRow).sort((a, b) => a - b)), [tab.model])
+  /**
+   * The change the toolbar's `n / N` reports.
+   *
+   * A jump sets it explicitly instead of re-deriving it from `scrollTop`: near
+   * the bottom of a file the browser CLAMPS the offset, so re-deriving would
+   * report the change above the one the button just went to and the next click
+   * would refuse to advance. A manual scroll does re-derive it (`hunkAtRow`),
+   * which is what keeps the counter honest when the user drags instead of
+   * clicking. `-1` = nothing jumped yet / the viewport is above the first
+   * change.
+   */
+  const [hunkCursor, setHunkCursor] = useState(-1)
+  /** The `scrollTop` a jump just wrote, so its own scroll event is not read as a manual scroll. */
+  const jumpedTopRef = useRef(-1)
+
+  /** Scroll to the next (1) or previous (-1) change, wrapping at both ends. */
+  const jumpHunk = (direction: 1 | -1): void => {
+    const grid = gridRef.current
+    if (grid === null) return
+    const target = stepHunk(hunkRows.length, hunkCursor, direction)
+    if (target < 0) return
+    const top = (hunkRows[target] as number) * ROW_HEIGHT
+    jumpedTopRef.current = top
+    grid.scrollTop = top
+    setHunkCursor(target)
+  }
+
+  /** Keep `n / N` in step with the viewport while the user scrolls by hand. */
+  const syncHunkCursor = (grid: HTMLDivElement): void => {
+    if (hunkRows.length === 0) return
+    if (Math.abs(grid.scrollTop - jumpedTopRef.current) < 1) return
+    const next = hunkAtRow(hunkRows, grid.scrollTop / ROW_HEIGHT)
+    setHunkCursor(previous => (previous === next ? previous : next))
+  }
+
   /**
    * Measure the widest pane and the grid's own width. Runs after every model
    * change, on container resizes (a pane that is empty until its fonts settle
@@ -435,6 +474,19 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
         <span style={{ color: 'var(--rvs-git-d)' }}>-{counts.removed}</span>
         {tab.staged && <span className="rvs-pill">{t('scm.stagedReadonly')}</span>}
         <span className="rvs-einfo-spacer" />
+        {/* Prev/next change: only the split view is windowed, so only it has a
+            row offset to jump to. The counter doubles as the "where am I" cue. */}
+        {mode === 'split' && hunkRows.length > 0 && (
+          <span className="rvs-hunknav" title={t('scm.hunkNavHint')}>
+            <IconButton title={t('scm.prevHunk')} onClick={() => jumpHunk(-1)}>
+              <IconChevronUp size={13} />
+            </IconButton>
+            <span className="rvs-hunknav-pos">{hunkCursor < 0 ? `-/${hunkRows.length}` : `${hunkCursor + 1}/${hunkRows.length}`}</span>
+            <IconButton title={t('scm.nextHunk')} onClick={() => jumpHunk(1)}>
+              <IconChevronDown size={13} />
+            </IconButton>
+          </span>
+        )}
         {busy && <MiniSpinner />}
         <IconButton title={t('scm.reloadDiff')} onClick={() => { void reload() }} disabled={busy}>
           <IconRefresh size={13} />
@@ -460,7 +512,10 @@ export function DiffView(props: { tab: EditorTab; visible: boolean }): ReactNode
               rowsInView.attachGrid(element)
               gridRef.current = element
             }}
-            onScroll={rowsInView.onScroll}
+            onScroll={(event) => {
+              rowsInView.onScroll(event)
+              syncHunkCursor(event.currentTarget)
+            }}
           >
             <div className="rvs-diff-cols">
               {/* Left pane: fixed 50% (see .rvs-diff-col) with its own hidden

package/src/client/scm/diff-model.ts

@@ -204,3 +204,47 @@ export function diffCounts(model: DiffModel): { added: number; removed: number }
   }
   return { added, removed }
 }
+
+/**
+ * Where a prev/next jump lands, as an index into the ordered hunk list.
+ *
+ * Wraps at both ends (the last change's "next" is the first change, and the
+ * first one's "previous" is the last), because a diff toolbar button that does
+ * nothing at the end reads as broken. `cursor < 0` means "nothing jumped yet":
+ * the first `next` lands on the first hunk and the first `previous` on the last.
+ *
+ * Pure, so `scripts/check-diff-ui.mjs` can pin the wrapping without a browser.
+ *
+ * @param count - how many hunks the model has (0 → -1, i.e. nothing to jump to).
+ * @param cursor - the hunk the toolbar currently reports, or -1.
+ * @param direction - 1 for "next change", -1 for "previous change".
+ * @returns the hunk index to scroll to, or -1 when the model has no hunks.
+ */
+export function stepHunk(count: number, cursor: number, direction: 1 | -1): number {
+  if (count <= 0) return -1
+  if (cursor < 0 || cursor >= count) return direction === 1 ? 0 : count - 1
+  return (cursor + direction + count) % count
+}
+
+/**
+ * The hunk the viewport is sitting in, derived from the top visible row.
+ *
+ * "Sitting in" = the last change whose first row is at or ABOVE the top row, so
+ * scrolling into the middle of a change keeps reporting that change (and
+ * scrolling above the first one reports -1). This is what keeps the toolbar's
+ * `n / N` honest when the user scrolls by hand instead of using the buttons —
+ * the jump math alone would report the last button press, not the screen.
+ *
+ * @param startRows - first row index of each hunk, ASCENDING.
+ * @param topRow - the row index at the top of the viewport (may be fractional).
+ * @returns the hunk index, or -1 when the viewport is above the first hunk.
+ */
+export function hunkAtRow(startRows: readonly number[], topRow: number): number {
+  let found = -1
+  for (let index = 0; index < startRows.length; index += 1) {
+    const start = startRows[index] as number
+    if (start > topRow) break
+    found = index
+  }
+  return found
+}

package/src/client/shell.ts

@@ -0,0 +1,35 @@
+/**
+ * Shell quoting for the lines this plugin types into a remote terminal.
+ *
+ * One rule, one place: the client builds POSIX shell text in three spots (the
+ * `cd` typed into a fresh terminal, the bounded suffix search for an unresolved
+ * click target, and the terminal command a menu entry sends), and a second copy
+ * of the quoting rule is how an injection bug reappears after it was fixed once.
+ *
+ * Single quotes are the only form that is safe for arbitrary paths — double
+ * quotes still expand `$`, backticks and `\` — and the closing quote is the one
+ * character they cannot carry, so it is spliced in as `'\''`.
+ */
+
+/**
+ * Quote one value for a POSIX shell, as a single word.
+ *
+ * @param value - the raw path or word.
+ * @returns `'value'` with every embedded `'` spliced as `'\''`.
+ */
+export function shellQuote(value: string): string {
+  return `'${value.replace(/'/g, `'\\''`)}'`
+}
+
+/**
+ * The command typed into a fresh remote terminal to land in one directory.
+ *
+ * A trailing newline is NOT included: the caller writes the line and the
+ * terminal's Enter, which keeps the same string reusable for display.
+ *
+ * @param dir - absolute remote directory.
+ * @returns `cd '<dir>'`.
+ */
+export function cdCommand(dir: string): string {
+  return `cd ${shellQuote(dir)}`
+}

package/src/client/store.tsx

@@ -131,6 +131,10 @@ interface State {
   view: RailView
   /** A pending search request raised by the explorer's context menu. */
   searchRequest: SearchRequest | undefined
+  /** A pending "show this folder in the tree" request (search-result menu). */
+  revealRequest: RevealRequest | undefined
+  /** A pending "open a terminal in this folder" request (search-result menu). */
+  terminalRequest: TerminalRequest | undefined
   /**
    * Expanded untracked DIRECTORY rows (`-u normal` collapses a directory into
    * one row, so the panel asks for its contents on demand — see
@@ -154,6 +158,32 @@ export interface SearchRequest {
   scope: string
 }
 
+/** One "show this folder in the explorer tree" request. */
+export interface RevealRequest {
+  /** Monotonic id so asking for the same folder twice still re-triggers. */
+  id: number
+  /** Absolute remote DIRECTORY to expand and scroll to. */
+  path: string
+}
+
+/** One "open a terminal here" request. */
+export interface TerminalRequest {
+  /** Monotonic id so the same folder can be opened twice. */
+  id: number
+  /**
+   * Host alias the directory lives on.
+   *
+   * Carried explicitly, and NOT taken from the terminal panel's own last-used
+   * host: the panel remembers whatever host the user ran a shell on last, so a
+   * menu action on a workspace bound elsewhere opened the shell on the WRONG
+   * machine — the `cd` then failed with "No such file or directory" for a path
+   * that exists perfectly well on its own host.
+   */
+  alias: string
+  /** Absolute remote directory the fresh shell should `cd` into. */
+  dir: string
+}
+
 const WS_KEY = 'dsh-remote-vs.files.ws'
 const VIEW_KEY = 'dsh-remote-vs.view'
 /** Per-workspace repository sub-directory, keyed by workspace id. */
@@ -295,6 +325,8 @@ const state: State = {
   editorSurface: 'sidebar',
   view: readStoredView(),
   searchRequest: undefined,
+  revealRequest: undefined,
+  terminalRequest: undefined,
   untrackedDirs: new Map(),
 }
 
@@ -337,10 +369,25 @@ export interface ExplorerValue {
   editorSurface: 'center' | 'sidebar'
   view: RailView
   searchRequest: SearchRequest | undefined
+  /** Pending "show this folder in the tree" request (consumed by the explorer). */
+  revealRequest: RevealRequest | undefined
+  /** Pending "open a terminal here" request (consumed by the terminal panel). */
+  terminalRequest: TerminalRequest | undefined
   setView: (view: RailView) => void
   /** Switch to the search panel (optionally scoped to a folder) — the tree's
       "find in folder" entry point. */
   requestSearch: (request: { mode: 'name' | 'content'; query?: string; scope: string }) => void
+  /**
+   * Show one remote directory in the explorer: switch to it, expand the folder
+   * and its ancestors, then scroll its row into view. Raised by the search
+   * results' "open containing folder" entry.
+   */
+  revealInExplorer: (dir: string) => void
+  /**
+   * Open a fresh terminal tab whose shell `cd`s into `dir`. Raised by the
+   * search results' "open in terminal" entry.
+   */
+  openTerminalAt: (dir: string) => void
   /**
    * The USER's pick — the workspace dropdowns and the wizard's "open files".
    *
@@ -463,8 +510,12 @@ function build(): ExplorerValue {
     editorSurface: state.editorSurface,
     view: state.view,
     searchRequest: state.searchRequest,
+    revealRequest: state.revealRequest,
+    terminalRequest: state.terminalRequest,
     setView,
     requestSearch,
+    revealInExplorer,
+    openTerminalAt,
     selectWorkspace,
     setRepoSubdir,
     discoverRepos,
@@ -622,6 +673,48 @@ export function requestSearch(request: { mode: 'name' | 'content'; query?: strin
   setView('search')
 }
 
+/** Monotonic ticket for "show this folder" requests (0 = none yet). */
+let revealSeq = 0
+
+/**
+ * Show one remote directory in the explorer.
+ *
+ * Two stages, because the tree is lazily loaded: this raises the request and
+ * switches the panel, and the explorer itself expands the ancestors (loading
+ * each level) and scrolls the row into view — it is the only place that knows
+ * which directories are currently expanded.
+ *
+ * @param dir - absolute remote DIRECTORY (a file's parent for a file hit).
+ */
+export function revealInExplorer(dir: string): void {
+  revealSeq += 1
+  patch({ revealRequest: { id: revealSeq, path: dir } })
+  setView('explorer')
+}
+
+/** Monotonic ticket for "open a terminal here" requests. */
+let terminalSeq = 0
+
+/**
+ * Open a fresh terminal tab whose shell lands in `dir` — on the CURRENT
+ * workspace's host.
+ *
+ * The terminal panel consumes the request (it owns the tabs) and the shell gets
+ * a quoted `cd` once its PTY reports ready — the host's terminal route has no
+ * "start in this directory" parameter, so a typed command is the honest way.
+ *
+ * The alias travels IN the request. The panel otherwise opens new tabs on the
+ * host it last used, which put the shell on a different machine than the path
+ * belongs to and made the `cd` fail with "No such file or directory".
+ *
+ * @param dir - absolute remote directory.
+ */
+export function openTerminalAt(dir: string): void {
+  terminalSeq += 1
+  patch({ terminalRequest: { id: terminalSeq, alias: currentWorkspace()?.alias ?? '', dir } })
+  setView('terminal')
+}
+
 /**
  * Select the binding every view works against — the USER's choice.
  *

package/src/client/vsc/kit.tsx

@@ -55,6 +55,11 @@ export function IconChevronDown(props: IconProps): ReactNode {
   return svg(props.size ?? 14, <path d="M3.5 6 L8 10.5 L12.5 6" />, props.className)
 }
 
+/** Mirror of `IconChevronDown`, for the diff's "previous change" button. */
+export function IconChevronUp(props: IconProps): ReactNode {
+  return svg(props.size ?? 14, <path d="M3.5 10 L8 5.5 L12.5 10" />, props.className)
+}
+
 export function IconFolder(props: IconProps & { open?: boolean }): ReactNode {
   return props.open === true
     ? svg(props.size ?? 16, <path d="M1.8 12.6V4.2a1 1 0 0 1 1-1h3l1.4 1.6h6a1 1 0 0 1 1 1v1H2.6l1 5.8a1 1 0 0 0 1 .8h7.6" />, props.className)

package/src/client/vsc/vsc.css

@@ -1073,6 +1073,29 @@ body[data-ds-dark-theme] .rvs-root {
   color: var(--rvs-fg3);
 }
 
+/**
+ * Prev/next change, in the toolbar's free space.
+ *
+ * Two chevrons around a tabular counter: the pair then reads as "jump to change
+ * n of N" instead of two anonymous arrows, and the counter doubles as the "where
+ * am I" cue while scrolling by hand.
+ */
+.rvs-hunknav {
+  display: inline-flex;
+  align-items: center;
+  gap: 1px;
+  margin-right: 2px;
+}
+
+.rvs-hunknav-pos {
+  min-width: 30px;
+  text-align: center;
+  font-size: 11px;
+  font-variant-numeric: tabular-nums;
+  color: var(--rvs-fg3);
+  user-select: none;
+}
+
 .rvs-seg {
   display: inline-flex;
   border: 1px solid var(--rvs-border2);

package/src/p2/worlds.ts

@@ -23,6 +23,7 @@ import { aliasRoot } from '../paths.ts'
 import type { RemoteHostEntry, RemoteWorkspaceBinding } from '../protocol.ts'
 import { RpcConnection } from './helper-rpc.ts'
 import { SshProcRuntime } from './ssh-proc.ts'
+import { legacyWorkspaceTitle, workspaceTitle } from '../workspace-title.ts'
 
 export type RoutingMode = 'off' | 'shadow' | 'enforce'
 
@@ -395,10 +396,23 @@ export class RemoteWorlds {
       }
       if (registry === undefined) continue
       try {
-        const existing = await registry.resolveByPath(aliasPath)
-        if (existing !== undefined) continue
-        const base = binding.remotePath.split('/').filter(Boolean).pop() ?? binding.remotePath
-        await registry.create(aliasPath, `${binding.alias} > ${base}`)
+        const existing = await registry.resolveByPath(aliasPath) as
+          | { title?: string; setTitle?: (title: string) => Promise<unknown> }
+          | undefined
+        const desired = workspaceTitle(binding)
+        if (existing !== undefined) {
+          // DISPLAY ONLY: the registry resolves workspaces by canonical PATH
+          // (`resolveByPath`) and its own docs call the title "used only when a
+          // new record is created", so nothing here can move a route. The
+          // retitle is additionally gated on the current title still being
+          // EXACTLY what the old code produced (`alias > <last path segment>`),
+          // so a title the user renamed by hand is never overwritten.
+          if (desired !== existing.title && existing.title === legacyWorkspaceTitle(binding) && typeof existing.setTitle === 'function') {
+            await existing.setTitle(desired)
+          }
+          continue
+        }
+        await registry.create(aliasPath, desired)
       } catch (error) {
         try {
           this.ctx.logger.warn(`[remote-vs] workspace registration failed for ${aliasPath}: ${error instanceof Error ? error.message : String(error)}`)

package/src/workspace-title.ts

@@ -0,0 +1,58 @@
+/**
+ * The title one remote binding gets in DSH's own workspace sidebar.
+ *
+ * The sidebar (and the session grouping under it) is rendered by the shell from
+ * the workspace REGISTRY, so this string is the only label the user ever sees
+ * there. It used to be built from the remote PATH's last segment, which threw
+ * away the one name the user had chosen: a workspace created as
+ * "P710_userdebug" showed up as `… > P710`, and two bindings that differ only
+ * deeper down (`…/userdebug/P710` and `…/userdebug/P710_fac`) became
+ * indistinguishable.
+ *
+ * The alias stays in front: it is what tells two hosts apart, and the part after
+ * it is what takes the workspace name.
+ *
+ * DISPLAY ONLY. The registry resolves a workspace by its canonical PATH
+ * (`resolveByPath`) and its own documentation says the title is "used only when
+ * a new record is created" and that different paths may share one — so a title
+ * never decides routing, and none of the plugin's routing reads it.
+ *
+ * Pure and dependency-free, so `scripts/check-diff-ui.mjs` can pin it without a
+ * host (the host half imports cordis and cannot load outside DSH).
+ */
+
+/** Last path segment of an absolute remote path ('' when the path is `/`). */
+function pathBase(remotePath: string): string {
+  const parts = remotePath.split('/').filter(part => part !== '')
+  return parts.pop() ?? remotePath
+}
+
+/** The alias part of a title, with a readable fallback. */
+function aliasOf(alias: string): string {
+  return alias.trim() === '' ? 'remote' : alias.trim()
+}
+
+/**
+ * The title this binding SHOULD have: `alias > workspace name`.
+ *
+ * @param binding - alias, the name the user typed, and the remote path.
+ * @returns `alias > name`, falling back to the path's last segment when no name
+ *   was given (bindings created before names existed, or an empty field).
+ */
+export function workspaceTitle(binding: { alias: string; name?: string; remotePath: string }): string {
+  const named = (binding.name ?? '').trim()
+  return `${aliasOf(binding.alias)} > ${named !== '' ? named : pathBase(binding.remotePath)}`
+}
+
+/**
+ * The title the OLD code produced: `alias > <last path segment>`, name ignored.
+ *
+ * Kept so an existing registration can be retitled ONLY when its current title
+ * is still exactly this. That is what keeps the upgrade from ever touching a
+ * title the user renamed by hand in the shell's workspace settings.
+ *
+ * @param binding - alias and remote path; the name is deliberately unused.
+ */
+export function legacyWorkspaceTitle(binding: { alias: string; remotePath: string }): string {
+  return `${aliasOf(binding.alias)} > ${pathBase(binding.remotePath)}`
+}