dsh-remote-vs 0.8.8 → 0.9.0

package/src/client/SearchView.tsx

@@ -20,9 +20,10 @@ import {
   type ContentHit,
 } from '../search-ops.ts'
 import { searchFiles, type SearchHit } from './scm/actions.ts'
-import { useExplorer } from './store.tsx'
+import { repoRelative, useExplorer } from './store.tsx'
 import { api } from './api.ts'
 import {
+  ContextMenu,
   FileIcon,
   IconCase,
   IconContentSearch,
@@ -33,6 +34,9 @@ import {
   MiniSpinner,
   Segmented,
   baseName,
+  copyText,
+  toast,
+  useContextMenu,
 } from './vsc/kit.tsx'
 
 type Mode = 'name' | 'content'
@@ -77,7 +81,7 @@ function relativeTo(root: string, full: string): string {
 
 export function SearchView(): ReactNode {
   const store = useExplorer()
-  const { t, alias, root } = store
+  const { t, alias, root, repoRoot } = store
   const [mode, setModeState] = useState<Mode>(readMode)
   const [query, setQuery] = useState('')
   /** Absolute remote directory the search runs in ('' = workspace root). */
@@ -93,6 +97,7 @@ export function SearchView(): ReactNode {
   const [ran, setRan] = useState(false)
   const [error, setError] = useState<string | undefined>(undefined)
   const seq = useRef(0)
+  const menu = useContextMenu()
 
   const effectiveScope = scope === '' ? root : scope
   const scopeLabel = useMemo(() => {
@@ -224,6 +229,44 @@ export function SearchView(): ReactNode {
     store.openFile(path, line === undefined ? undefined : { line })
   }
 
+  /** Absolute path of one NAME hit, plus the DIRECTORY a menu action should use. */
+  const nameHitPaths = (hit: SearchHit): { abs: string; dir: string } => {
+    const base = effectiveScope.replace(/\/+$/, '')
+    const abs = `${base}/${hit.path}`
+    // A directory hit (only the `find` fallback reports those) is its own
+    // folder; a file hit's actions target the folder it lives in.
+    const dir = hit.isDir ? abs : (abs.slice(0, abs.lastIndexOf('/')) || '/')
+    return { abs, dir }
+  }
+
+  /**
+   * Right-click on a name result: what one does with a found path.
+   *
+   * "Relative" is relative to the REPOSITORY when the workspace sits inside one
+   * (the same relative form the tree's own menu copies), else absolute — which
+   * is what makes the copied value paste straight into a shell that already ran
+   * `cd` into the repo. Directories only get the copy/reveal/terminal entries:
+   * there is no file to open in the editor.
+   */
+  const openHitMenu = (event: React.MouseEvent, hit: SearchHit): void => {
+    event.preventDefault()
+    event.stopPropagation()
+    const { abs, dir } = nameHitPaths(hit)
+    const rel = repoRelative(repoRoot, abs) || abs
+    menu.open(event.clientX, event.clientY, [
+      { label: t('files.copyAbs'), onSelect: () => { void copyText(abs); toast(t('files.copiedClipboard')) } },
+      { label: t('files.copyRel'), onSelect: () => { void copyText(rel); toast(t('files.copiedClipboard')) } },
+      {
+        label: t('files.openInFloat'),
+        onSelect: () => { store.openInFloatEditor(abs) },
+        disabled: !store.floatAvailable || hit.isDir,
+        separated: true,
+      },
+      { label: t('search.revealInExplorer'), onSelect: () => { store.revealInExplorer(dir) } },
+      { label: t('search.openInTerminal'), onSelect: () => { store.openTerminalAt(dir) } },
+    ])
+  }
+
   const groups = useMemo(() => groupHits(contentHits), [contentHits])
 
   /**
@@ -351,6 +394,7 @@ export function SearchView(): ReactNode {
                 className="rvs-hit"
                 title={hit.path}
                 onClick={() => openHit(`${(effectiveScope === '' ? root : effectiveScope).replace(/\/+$/, '')}/${hit.path}`)}
+                onContextMenu={(event) => { openHitMenu(event, hit) }}
               >
                 <span className="rvs-node-icon">
                   {hit.isDir ? <span style={{ color: 'var(--rvs-fg3)' }}>▸</span> : <FileIcon path={hit.path} size={14} />}
@@ -404,6 +448,9 @@ export function SearchView(): ReactNode {
           </>
         )}
       </div>
+      {menu.menu !== undefined && (
+        <ContextMenu x={menu.menu.x} y={menu.menu.y} entries={menu.menu.entries} onClose={menu.close} />
+      )}
     </div>
   )
 }

package/src/client/TerminalView.tsx

@@ -11,6 +11,8 @@ import { useCallback, useEffect, useRef, useState, type ReactNode } from 'react'
 import type { RemoteHostSummary } from '../protocol.ts'
 import { RemoteApiError, api } from './api.ts'
 import { XTerm } from './XTerm.tsx'
+import { cdCommand } from './shell.ts'
+import type { TerminalRequest } from './store.tsx'
 import { optionStyle } from './ui.tsx'
 import {
   IconButton,
@@ -32,6 +34,8 @@ interface TermTab {
   /** Bumped to force a fresh connection (connect / reconnect). */
   nonce: number
   connected: boolean
+  /** Command typed once the shell reports ready (a menu entry's `cd`). */
+  initialCommand?: string
   /** Human-readable reason the tab is not connected. */
   note?: string
 }
@@ -84,10 +88,21 @@ function newId(): string {
   return `t${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`
 }
 
+/**
+ * The last "open a terminal here" request this page already acted on.
+ *
+ * Module scope, not a component ref: the panel is normally kept mounted, but a
+ * remount would reset a ref and re-open a tab for the SAME old request. A new
+ * request always carries a larger id, so one counter serves both goals.
+ */
+let openedTerminalRequest = 0
+
 export function TerminalView(props: {
   t: (key: string) => string
   hosts: RemoteHostSummary[]
   visible: boolean
+  /** A pending "open a terminal here" request from the search results' menu. */
+  request?: TerminalRequest
 }): ReactNode {
   const t = props.t
   const [alias, setAlias] = useState<string>(readAlias)
@@ -126,13 +141,48 @@ export function TerminalView(props: {
     setTabs(prev => prev.map(tab => (tab.id === id ? { ...tab, ...next } : tab)))
   }, [])
 
-  const openTab = useCallback((host: string): void => {
+  const openTab = useCallback((host: string, initialCommand?: string): void => {
     if (host === '') return
-    const tab: TermTab = { id: newId(), alias: host, nonce: 0, connected: true }
+    const tab: TermTab = {
+      id: newId(),
+      alias: host,
+      nonce: 0,
+      connected: true,
+      ...(initialCommand === undefined ? {} : { initialCommand }),
+    }
     setTabs(prev => [...prev, tab])
     setActiveId(tab.id)
   }, [])
 
+  /**
+   * "Open a terminal here" (a search result's menu): open one tab whose shell
+   * lands in that folder, on the host the folder BELONGS to.
+   *
+   * The alias must come from the request, not from `effectiveAlias`: the panel
+   * remembers whatever host the user last ran a shell on, so a menu action on a
+   * workspace bound elsewhere used to open the shell on the wrong machine and
+   * the `cd` failed with "No such file or directory" for a path that is fine on
+   * its own host.
+   *
+   * The folder is reached by TYPING `cd` once the PTY reports ready (see
+   * `XTerm`'s `initialInput`) — the host's terminal route has no "start in this
+   * directory" parameter, and inventing one would mean a host-side change for a
+   * display feature. The request id makes a repeat for the same folder still
+   * open a second tab.
+   */
+  useEffect(() => {
+    const request = props.request
+    if (request === undefined || request.id === openedTerminalRequest) return
+    openedTerminalRequest = request.id
+    const target = request.alias !== '' && props.hosts.some(host => host.alias === request.alias)
+      ? request.alias
+      : effectiveAlias
+    // Keep the header picker in step with the tab that just opened, so the next
+    // "+" continues on the same host.
+    if (target !== alias) setAlias(target)
+    openTab(target, cdCommand(request.dir))
+  }, [props.request, props.hosts, effectiveAlias, alias, openTab])
+
   const closeTab = useCallback(async (tab: TermTab): Promise<void> => {
     const ok = await confirmDialog({
       title: t('term.closeTitle'),
@@ -276,6 +326,7 @@ export function TerminalView(props: {
                   rows: 24,
                 })}
                 visible={props.visible && tab.id === active?.id}
+                {...(tab.initialCommand === undefined ? {} : { initialInput: tab.initialCommand })}
                 onReady={(id) => patchTab(tab.id, { session: id, connected: true, note: undefined })}
                 onExit={(code, message) => {
                   if (message === 'terminal session expired') {

package/src/client/XTerm.tsx

@@ -106,6 +106,12 @@ export function XTerm(props: {
   fontFamily?: string
   /** When the parent sub-tab hides/shows this view without unmounting. */
   visible?: boolean
+  /**
+   * Line typed into the fresh shell once its PTY reports ready (a menu entry's
+   * `cd`). Sent ONCE per mount: a reconnect is a new mount and thus a new shell,
+   * which correctly re-runs the line.
+   */
+  initialInput?: string
 }): ReactNode {
   const hostRef = useRef<HTMLDivElement>(null)
   const propsRef = useRef(props)
@@ -143,6 +149,8 @@ export function XTerm(props: {
 
     const ws = new WebSocket(propsRef.current.wsUrl)
     let opened = false
+    /** The seeded line is typed at most once per mount (a reconnect re-mounts). */
+    let seeded = false
     let exitReported = false
     const reportExit = (code: number | null, message?: string): void => {
       if (exitReported) return
@@ -208,6 +216,13 @@ export function XTerm(props: {
       }
       if (frame.t === 'ready') {
         propsRef.current.onReady(frame.id)
+        // The shell exists now: type the seeded line (a menu entry's `cd`), as a
+        // normal input line so the shell echoes it and redraws its prompt.
+        const seed = propsRef.current.initialInput
+        if (!seeded && seed !== undefined && seed !== '') {
+          seeded = true
+          send(ws, { t: 'in', d: `${seed}\n` })
+        }
       } else if (frame.t === 'out') {
         term.write(frame.d)
       } else if (frame.t === 'exit') {

package/src/client/float-editor.ts

@@ -0,0 +1,271 @@
+/**
+ * Pure geometry and surface rules for the floating editor.
+ *
+ * Kept free of React and of the DOM on purpose: the drag / resize / zoom maths
+ * is the part that is easy to get subtly wrong (negative sizes, a window that
+ * escapes the viewport, a stale stored rect from a larger screen), and this
+ * module is what `scripts/check-float-editor.mjs` drives directly. The window
+ * component is then only wiring.
+ *
+ * The SURFACE rule lives here too: the plugin has exactly one live editor, and
+ * which mount owns it is a three-way decision (centre conversation view,
+ * sidebar fallback, floating window). Encoding it as a pure function keeps the
+ * invariant testable and out of three separate `=== 'center'` comparisons.
+ */
+
+/** Where the editor pane is mounted right now. */
+export type EditorSurface = 'center' | 'sidebar' | 'float'
+
+/** The persisted layout of the floating window, in viewport pixels. */
+export interface FloatRect {
+  x: number
+  y: number
+  width: number
+  height: number
+}
+
+/** Viewport size the geometry is clamped to. */
+export interface FloatViewport {
+  width: number
+  height: number
+}
+
+/** A resize grip: the compass directions of the eight handles. */
+export type FloatResizeHandle = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw'
+
+/** Smallest window the editor can be squeezed into and stay usable. */
+export const FLOAT_MIN_WIDTH = 360
+export const FLOAT_MIN_HEIGHT = 220
+/** Height of the title bar; a minimized window keeps exactly this much. */
+export const FLOAT_TITLEBAR_HEIGHT = 34
+/** Gap a maximized window keeps from the viewport edges. */
+export const FLOAT_VIEWPORT_EDGE = 8
+
+/** Editor font-size range for Ctrl+wheel zoom (px). */
+export const FLOAT_FONT_MIN = 9
+export const FLOAT_FONT_MAX = 28
+export const FLOAT_FONT_DEFAULT = 13
+
+/** Diameter of the minimized ball, in pixels. */
+export const FLOAT_BALL_SIZE = 44
+/**
+ * How far a pointer may travel and still count as a CLICK: the minimized window
+ * is a single 44px ball, so "click restores / drag moves" has to be decided
+ * from one pointer gesture.
+ */
+export const FLOAT_BALL_CLICK_SLOP = 4
+
+/** A point in viewport coordinates (the minimized ball's origin). */
+export interface FloatPoint {
+  x: number
+  y: number
+}
+
+function clamp(value: number, min: number, max: number): number {
+  return Math.min(max, Math.max(min, value))
+}
+
+/** True when the stored value is a usable finite number (not NaN/Infinity). */
+function finite(value: unknown): value is number {
+  return typeof value === 'number' && Number.isFinite(value)
+}
+
+/** The effective editor surface: floating wins, otherwise the base mount. */
+export function effectiveEditorSurface(base: 'center' | 'sidebar', floatOpen: boolean): EditorSurface {
+  return floatOpen ? 'float' : base
+}
+
+/**
+ * The rect a fresh floating window opens at: about two thirds of the frame,
+ * centred, with a hard size cap so a 4K monitor does not produce a 2600px
+ * editor for a 40-column file.
+ */
+export function defaultFloatRect(viewport: FloatViewport): FloatRect {
+  const maxWidth = Math.max(FLOAT_MIN_WIDTH, viewport.width - FLOAT_VIEWPORT_EDGE * 2)
+  const maxHeight = Math.max(FLOAT_MIN_HEIGHT, viewport.height - FLOAT_VIEWPORT_EDGE * 2)
+  const width = Math.min(maxWidth, Math.max(FLOAT_MIN_WIDTH, Math.round(viewport.width * 0.62)), 1180)
+  const height = Math.min(maxHeight, Math.max(FLOAT_MIN_HEIGHT, Math.round(viewport.height * 0.7)), 860)
+  const x = Math.round((viewport.width - width) / 2)
+  const y = Math.round((viewport.height - height) / 2) - 12
+  return clampFloatRect({ x, y, width, height }, viewport)
+}
+
+/**
+ * Bring a rect back inside the viewport and to a legal size.
+ *
+ * Used on every drag step, on restore, and whenever the browser window is
+ * resized: a rect persisted on a 2560px screen must not open a window whose
+ * title bar is off-screen on a 1366px laptop.
+ */
+export function clampFloatRect(rect: FloatRect, viewport: FloatViewport): FloatRect {
+  const width = clamp(rect.width, FLOAT_MIN_WIDTH, Math.max(FLOAT_MIN_WIDTH, viewport.width))
+  const height = clamp(rect.height, FLOAT_MIN_HEIGHT, Math.max(FLOAT_MIN_HEIGHT, viewport.height))
+  const x = clamp(rect.x, 0, Math.max(0, viewport.width - width))
+  const y = clamp(rect.y, 0, Math.max(0, viewport.height - height))
+  return { x: Math.round(x), y: Math.round(y), width: Math.round(width), height: Math.round(height) }
+}
+
+/** Move the window by a pointer delta, staying inside the viewport. */
+export function dragFloatRect(start: FloatRect, dx: number, dy: number, viewport: FloatViewport): FloatRect {
+  return clampFloatRect({ ...start, x: start.x + dx, y: start.y + dy }, viewport)
+}
+
+/**
+ * Resize from one grip.
+ *
+ * Each axis is adjusted from the edge that MOVED (west/north resize changes the
+ * origin too), then clamped: the minimum size is anchored at the opposite edge
+ * (so dragging the north grip past the bottom stops instead of flipping the
+ * rect) and no edge may leave the viewport.
+ */
+export function resizeFloatRect(
+  start: FloatRect,
+  handle: FloatResizeHandle,
+  dx: number,
+  dy: number,
+  viewport: FloatViewport,
+): FloatRect {
+  let left = start.x
+  let top = start.y
+  let right = start.x + start.width
+  let bottom = start.y + start.height
+  if (handle.includes('e')) right += dx
+  if (handle.includes('w')) left += dx
+  if (handle.includes('s')) bottom += dy
+  if (handle.includes('n')) top += dy
+
+  // Minimum size, anchored at the edge that did NOT move.
+  if (right - left < FLOAT_MIN_WIDTH) {
+    if (handle.includes('w')) left = right - FLOAT_MIN_WIDTH
+    else right = left + FLOAT_MIN_WIDTH
+  }
+  if (bottom - top < FLOAT_MIN_HEIGHT) {
+    if (handle.includes('n')) top = bottom - FLOAT_MIN_HEIGHT
+    else bottom = top + FLOAT_MIN_HEIGHT
+  }
+
+  // Viewport clamp: keep the rect (and every edge) on screen.
+  left = clamp(left, 0, Math.max(0, viewport.width - FLOAT_MIN_WIDTH))
+  top = clamp(top, 0, Math.max(0, viewport.height - FLOAT_MIN_HEIGHT))
+  right = clamp(right, left + FLOAT_MIN_WIDTH, viewport.width)
+  bottom = clamp(bottom, top + FLOAT_MIN_HEIGHT, viewport.height)
+  return {
+    x: Math.round(left),
+    y: Math.round(top),
+    width: Math.round(right - left),
+    height: Math.round(bottom - top),
+  }
+}
+
+/** The rect a maximized window occupies: the frame minus a small margin. */
+export function maximizeFloatRect(viewport: FloatViewport): FloatRect {
+  const edge = FLOAT_VIEWPORT_EDGE
+  return {
+    x: edge,
+    y: edge,
+    width: Math.max(FLOAT_MIN_WIDTH, viewport.width - edge * 2),
+    height: Math.max(FLOAT_MIN_HEIGHT, viewport.height - edge * 2),
+  }
+}
+
+/**
+ * Parse a persisted rect.
+ *
+ * Anything malformed is discarded rather than repaired into a guess: the
+ * caller then opens the default rect. Values that are merely STALE (a rect from
+ * another screen) are legal input and get clamped.
+ */
+export function parseFloatRect(raw: string | null | undefined, viewport: FloatViewport): FloatRect | undefined {
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const candidate = parsed as Record<string, unknown>
+  if (!finite(candidate.x) || !finite(candidate.y) || !finite(candidate.width) || !finite(candidate.height)) {
+    return undefined
+  }
+  return clampFloatRect(
+    { x: candidate.x, y: candidate.y, width: candidate.width, height: candidate.height },
+    viewport,
+  )
+}
+
+/** Serialize a rect for localStorage. */
+export function serializeFloatRect(rect: FloatRect): string {
+  return JSON.stringify({ x: rect.x, y: rect.y, width: rect.width, height: rect.height })
+}
+
+/**
+ * One Ctrl+wheel step: up (negative deltaY) grows the text, down shrinks it.
+ * Values are whole pixels so the stored size stays stable across sessions.
+ */
+export function stepFloatZoom(current: number, deltaY: number): number {
+  if (!finite(current)) return FLOAT_FONT_DEFAULT
+  if (deltaY === 0) return clamp(Math.round(current), FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+  const direction = deltaY < 0 ? 1 : -1
+  return clamp(Math.round(current) + direction, FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+}
+
+/** Parse the persisted editor font size (fallback = the default 13px). */
+export function parseFloatFontSize(raw: string | null | undefined): number {
+  if (typeof raw !== 'string') return FLOAT_FONT_DEFAULT
+  const value = Number(raw)
+  if (!finite(value)) return FLOAT_FONT_DEFAULT
+  return clamp(Math.round(value), FLOAT_FONT_MIN, FLOAT_FONT_MAX)
+}
+
+/**
+ * Where the minimized ball may sit: fully on screen, whatever position was
+ * asked for (a ball restored on a smaller monitor must stay clickable).
+ */
+export function clampBallPosition(pos: FloatPoint, viewport: FloatViewport): FloatPoint {
+  const maxX = Math.max(0, viewport.width - FLOAT_BALL_SIZE)
+  const maxY = Math.max(0, viewport.height - FLOAT_BALL_SIZE)
+  const x = finite(pos.x) ? pos.x : 0
+  const y = finite(pos.y) ? pos.y : 0
+  return { x: Math.round(clamp(x, 0, maxX)), y: Math.round(clamp(y, 0, maxY)) }
+}
+
+/**
+ * The ball's default spot when a window is minimized: its own top-left corner,
+ * so the ball appears where the window was instead of jumping to a corner.
+ */
+export function ballFromRect(rect: FloatRect, viewport: FloatViewport): FloatPoint {
+  return clampBallPosition({ x: rect.x, y: rect.y }, viewport)
+}
+
+/**
+ * Whether a finished gesture was a CLICK rather than a drag.
+ *
+ * The minimized window is one small target with two actions on the same
+ * pointer: a press that never really moved restores the window, a real drag
+ * moves the ball. Without this distinction every move-by-3px would also
+ * restore, and every click would be a zero-distance drag.
+ */
+export function isBallClick(dx: number, dy: number): boolean {
+  return Math.abs(dx) <= FLOAT_BALL_CLICK_SLOP && Math.abs(dy) <= FLOAT_BALL_CLICK_SLOP
+}
+
+/** Parse a persisted ball position (stale geometry is clamped, garbage dropped). */
+export function parseBallPosition(raw: string | null | undefined, viewport: FloatViewport): FloatPoint | undefined {
+  if (typeof raw !== 'string' || raw.trim() === '') return undefined
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return undefined
+  }
+  if (typeof parsed !== 'object' || parsed === null) return undefined
+  const candidate = parsed as Record<string, unknown>
+  if (!finite(candidate.x) || !finite(candidate.y)) return undefined
+  return clampBallPosition({ x: candidate.x, y: candidate.y }, viewport)
+}
+
+/** Serialize a ball position for localStorage. */
+export function serializeBallPosition(pos: FloatPoint): string {
+  return JSON.stringify({ x: pos.x, y: pos.y })
+}

package/src/client/float-tab-trigger.ts

@@ -0,0 +1,51 @@
+/**
+ * Double-click on the shell's 「远程编辑器」 tab floats the editor.
+ *
+ * That tab belongs to the host's conversation-view header, not to us: the plugin
+ * registers a VIEW into the shell's tab strip and never sees the tab row's DOM.
+ * There is no public service for "the user double-clicked my tab" either, so the
+ * only way to honour the gesture is a document-level `dblclick` listener that
+ * recognises the tab the same way `reveal.ts` does for clicks — by its label,
+ * skipping our own surfaces.
+ *
+ * Fail-safe by construction: a miss (another host build, a renamed tab, a
+ * double-click somewhere else) simply does nothing. It never prevents the
+ * default action, never throws, and does not steal double-clicks from the
+ * plugin's own UI (`.rvs-root`) or from dialogs.
+ */
+
+/** Elements that behave like the shell's view tabs. */
+const TAB_SELECTOR = 'button, [role="tab"], [role="button"]'
+
+/**
+ * Install the double-click trigger.
+ *
+ * @param label - the tab's visible label (the same localized string the view
+ *   registered with); matched against the tab's trimmed text.
+ * @param onTrigger - called once per recognised double-click.
+ * @returns disposer removing the listener.
+ */
+export function installFloatTabTrigger(label: string, onTrigger: () => void): () => void {
+  if (typeof document === 'undefined' || label === '') return () => {}
+  const handler = (event: MouseEvent): void => {
+    if (event.button !== 0) return
+    const target = event.target
+    if (!(target instanceof Element)) return
+    // Our own surfaces (editor tabs, menus, the floating window) own their
+    // double-clicks — the window's title bar uses one to maximize.
+    if (target.closest('.rvs-root') !== null) return
+    const tab = target.closest<HTMLElement>(TAB_SELECTOR)
+    if (tab === null) return
+    if ((tab.textContent ?? '').trim() !== label) return
+    // A second click while the shell is mid-transition is harmless: the action
+    // is idempotent (an already-floating editor is left alone).
+    try {
+      onTrigger()
+    } catch {
+      // Never let a listener break the shell's own double-click handling.
+    }
+  }
+  // Capture phase: the shell's tab may stop propagation on its own handlers.
+  document.addEventListener('dblclick', handler, true)
+  return () => document.removeEventListener('dblclick', handler, true)
+}

package/src/client/i18n.ts

@@ -158,6 +158,20 @@ const zh: Record<string, string> = {
   'files.deleteConfirm': '确定删除 {target} 吗？此操作在远端不可撤销。',
   'files.open': '打开',
   'files.openAsText': '以文本打开',
+  'files.openInFloat': '在悬浮编辑器中打开',
+  // -- floating editor window
+  'float.title': '悬浮编辑器',
+  'float.dragHint': '拖动标题栏移动窗口；拖动边缘缩放；双击标题栏最大化或还原',
+  'float.minimize': '最小化',
+  'float.ballHint': '点击恢复悬浮编辑器，拖动可移动',
+  'float.dockViewHint': '双击「远程编辑器」标签可浮出编辑器',
+  'float.maximize': '最大化',
+  'float.restore': '还原窗口',
+  'float.dock': '停靠回主界面',
+  'float.placeholder': '远程编辑器正在悬浮窗口中',
+  'float.placeholderHint': '编辑器只有一份实例，已浮出到窗口中央；关闭悬浮窗或点「停靠」后回到这里。',
+  'float.dockBack': '停靠回主界面',
+  'float.unavailable': '当前宿主没有全帧悬浮层（shell.overlay），悬浮编辑器不可用。',
   'files.rename': '重命名',
   'files.copy': '复制',
   'files.cut': '剪切',
@@ -197,6 +211,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': '更改',
@@ -494,6 +510,20 @@ const en: Record<string, string> = {
   'files.deleteConfirm': 'Delete {target}? This cannot be undone on the remote host.',
   'files.open': 'Open',
   'files.openAsText': 'Open as text',
+  'files.openInFloat': 'Open in floating editor',
+  // -- floating editor window
+  'float.title': 'Floating editor',
+  'float.dragHint': 'Drag the title bar to move; drag an edge to resize; double-click the title bar to maximize or restore',
+  'float.minimize': 'Minimize',
+  'float.ballHint': 'Click to restore the floating editor, drag to move it',
+  'float.dockViewHint': 'Double-click the "remote editor" tab to float the editor',
+  'float.maximize': 'Maximize',
+  'float.restore': 'Restore window',
+  'float.dock': 'Dock back into the main layout',
+  'float.placeholder': 'The remote editor is floating over the app',
+  'float.placeholderHint': 'There is only one editor instance and it is out in the floating window; close that window or press Dock to bring it back here.',
+  'float.dockBack': 'Dock back',
+  'float.unavailable': 'This host has no frame-wide overlay slot (shell.overlay); the floating editor is unavailable.',
   'files.rename': 'Rename',
   'files.copy': 'Copy',
   'files.cut': 'Cut',
@@ -533,6 +563,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',

package/src/client/index.tsx

@@ -19,13 +19,15 @@ import type {} from '@deepseek-ai/dsh-client-ui-settings/client'
 import type {} from '@deepseek-ai/dsh-client-ui-workspace/client'
 import './vsc/vsc.css'
 import { RemoteDirectoryFlow } from './DirectoryFlow.tsx'
+import { FloatingEditorWindow } from './FloatingEditorWindow.tsx'
+import { installFloatTabTrigger } from './float-tab-trigger.ts'
 import { registerNativeExplorer } from './NativeExplorer.tsx'
 import { installRemoteFileOpen } from './remote-file-open.ts'
 import { RemoteEditorView } from './RemoteEditorView.tsx'
 import { RemoteRoot } from './RemoteRoot.tsx'
 import { ChangesDock, type ChangesDockProps } from './changes/ChangesDock.tsx'
 import { SettingsHostsSection, SettingsWorkspacesSection } from './SettingsHosts.tsx'
-import { setEditorSurface } from './store.tsx'
+import { openFloatingEditor, setEditorSurface } from './store.tsx'
 import { detectLang, makeT } from './i18n.ts'
 import { setIconService, type IconServiceLike } from './vsc/kit.tsx'
 
@@ -283,4 +285,49 @@ export function apply(ctx: Context): void {
       }
     }
   }, 'dsh-remote-vs: conversation view (editor + diff)')
+  // Double-click on the shell's 「远程编辑器」 tab floats the editor. The tab row
+  // belongs to the host's header (we only contribute a view), so the gesture is
+  // recognised by label — the same lookup `reveal.ts` already uses for clicks —
+  // and a miss is a silent no-op.
+  ctx.effect(
+    () => installFloatTabTrigger(viewT('view.editor'), () => { openFloatingEditor() }),
+    'dsh-remote-vs: float on tab double-click',
+  )
+  // The floating editor window: hosted by the host's FRAME-WIDE overlay slot,
+  // which is the only seat that survives every sidebar tab and conversation
+  // view being unmounted. Registering from a narrower surface (the explorer
+  // tab, the editor view) would take the window away with that surface — and
+  // the editor's live buffer with it.
+  //
+  // The slot is looked up behind a try/catch: an older host without
+  // `shell.overlay` simply keeps the floating feature off. Availability is NOT
+  // assumed here — `FloatingEditorWindow` reports it once it really mounts, so
+  // the menu entry can never point at a window that cannot paint.
+  ctx.effect(() => {
+    let dispose: (() => void) | undefined
+    try {
+      const slots = ctx.slots as unknown as {
+        inject(slot: string, register: () => () => void): () => void
+        register(
+          options: { name: string; id: string; order: number },
+          component: () => ReactNode,
+        ): () => void
+      }
+      dispose = slots.inject('shell.overlay', () => slots.register({
+        name: 'shell.overlay',
+        id: 'remote-vs:floating-editor',
+        order: 40,
+      }, () => <FloatingEditorWindow ctx={ctx} />))
+    } catch (error) {
+      console.warn('[dsh-remote-vs] shell.overlay registration failed (floating editor unavailable):', error)
+      return () => {}
+    }
+    return () => {
+      try {
+        dispose?.()
+      } catch {
+        // Ignore.
+      }
+    }
+  }, 'dsh-remote-vs: floating editor window')
 }