dsh-remote-vs 0.8.7 → 0.8.9

package/lib/index.js

@@ -1,4 +1,4 @@
-import { a as pushPipeline, c as require_lib, d as ensurePrivateDir, f as keysDir, i as probe, l as aliasRoot, o as seedHelperCache, p as storePath, r as helperAvailability, s as RemoteFiles, t as RemoteWorlds, u as dshHome } from "./worlds-C6W225o9.js";
+import { a as pushPipeline, c as require_lib, d as ensurePrivateDir, f as keysDir, i as probe, l as aliasRoot, o as seedHelperCache, p as storePath, r as helperAvailability, s as RemoteFiles, t as RemoteWorlds, u as dshHome } from "./worlds-DnzpX3Hv.js";
 import z from "@deepseek-ai/schemastery";
 import { chmodSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, statSync, writeSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";

package/lib/p2-router-fs.js

@@ -1,4 +1,4 @@
-import { l as aliasRoot, n as isWindowsAbsolute } from "./worlds-C6W225o9.js";
+import { l as aliasRoot, n as isWindowsAbsolute } from "./worlds-DnzpX3Hv.js";
 import { FileSystem, FsError } from "@deepseek-ai/dsh-fs";
 //#region src/p2/router-fs.ts
 /**

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

@@ -9,8 +9,11 @@
  */
 import { type ReactNode } from 'react';
 import type { RemoteHostSummary } from '../protocol.ts';
+import type { TerminalRequest } from './store.tsx';
 export declare 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;

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

@@ -12,4 +12,10 @@ export declare 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;

package/lib/types/client/remote-file-open-target.d.ts

@@ -1,25 +1,3 @@
-/**
- * Where a clicked file reference should open when the owning session lives in
- * a remote workspace (pure — no React, no fetch, so the gate can drive it).
- *
- * DSH renders every file reference as a `dsh-resource://file/…` address and
- * opens it through its own right-sidebar preview. That preview resolves the
- * address path against the SESSION WORKSPACE ROOT. A model that quotes a path
- * relative to its CURRENT directory (e.g. `_xfer/reports/x.md` while working
- * in `<workspace>/<inner-repo>`) therefore misses by one segment, and a
- * remote session's workspace root only exists as an EMPTY local alias dir —
- * the click dies with the host-side ENOENT the user sees.
- *
- * This module answers "which binding, which remote paths to try" for the
- * client interceptor:
- *  - relative paths are tried against the workspace root first and the
- *    session's current working directory second (the model's usual writing
- *    base), which is what makes the one-segment miss heal;
- *  - absolute spellings (local alias, POSIX remote, drive-qualified alias)
- *    are folded back onto the binding;
- *  - anything that does not name a known binding answers `undefined`, so the
- *    native preview keeps handling local sessions and unknown addresses.
- */
 /** One remote binding as the client store exposes it. */
 export interface RemoteOpenBinding {
     id: string;

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

@@ -26,4 +26,34 @@ export declare function diffCounts(model: DiffModel): {
     added: number;
     removed: number;
 };
+/**
+ * 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 declare function stepHunk(count: number, cursor: number, direction: 1 | -1): number;
+/**
+ * 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 declare function hunkAtRow(startRows: readonly number[], topRow: number): number;
 export {};

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

@@ -0,0 +1,29 @@
+/**
+ * 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 declare function shellQuote(value: string): string;
+/**
+ * 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 declare function cdCommand(dir: string): string;

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

@@ -82,6 +82,30 @@ export interface SearchRequest {
     /** Absolute remote directory the search is scoped to. */
     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;
+}
 /** Stored repository sub-directory for one binding ('' = the workspace root). */
 export declare function readRepoSubdir(workspaceId: string): string;
 /** Everything a view can read, plus the actions. */
@@ -123,6 +147,10 @@ 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. */
@@ -131,6 +159,17 @@ export interface ExplorerValue {
         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".
      *
@@ -197,6 +236,32 @@ export declare function requestSearch(request: {
     query?: string;
     scope: string;
 }): void;
+/**
+ * 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 declare function revealInExplorer(dir: string): void;
+/**
+ * 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 declare function openTerminalAt(dir: string): void;
 /**
  * Select the binding every view works against — the USER's choice.
  *

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

@@ -18,6 +18,8 @@ type IconProps = {
 };
 export declare function IconChevronRight(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;
 export declare function IconFolder(props: IconProps & {
     open?: boolean;
 }): ReactNode;

package/lib/types/workspace-title.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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).
+ */
+/**
+ * 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 declare function workspaceTitle(binding: {
+    alias: string;
+    name?: string;
+    remotePath: string;
+}): string;
+/**
+ * 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 declare function legacyWorkspaceTitle(binding: {
+    alias: string;
+    remotePath: string;
+}): string;

package/lib/{worlds-C6W225o9.js → worlds-DnzpX3Hv.js}

@@ -18233,6 +18233,61 @@ var RpcConnection = class {
 	}
 };
 //#endregion
+//#region src/workspace-title.ts
+/**
+* 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) {
+	return remotePath.split("/").filter((part) => part !== "").pop() ?? remotePath;
+}
+/** The alias part of a title, with a readable fallback. */
+function aliasOf(alias) {
+	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).
+*/
+function workspaceTitle(binding) {
+	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.
+*/
+function legacyWorkspaceTitle(binding) {
+	return `${aliasOf(binding.alias)} > ${pathBase(binding.remotePath)}`;
+}
+//#endregion
 //#region src/p2/worlds.ts
 /**
 * Remote worlds: alias registry, tombstones, cwd-keyed routing decisions,
@@ -18522,9 +18577,13 @@ var RemoteWorlds = class {
 			}
 			if (registry === void 0) continue;
 			try {
-				if (await registry.resolveByPath(aliasPath) !== void 0) continue;
-				const base = binding.remotePath.split("/").filter(Boolean).pop() ?? binding.remotePath;
-				await registry.create(aliasPath, `${binding.alias} > ${base}`);
+				const existing = await registry.resolveByPath(aliasPath);
+				const desired = workspaceTitle(binding);
+				if (existing !== void 0) {
+					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/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.8.7",
+  "version": "0.8.9",
   "icon": "icon.svg",
   "keywords": [
     "dsh",

package/src/client/RemoteExplorer.tsx

@@ -265,6 +265,51 @@ export function RemoteExplorer(props: { showHidden: boolean; onToggleHidden: ()
     }
   }, [alias])
 
+  /**
+   * "Show this folder in the tree" — raised by a search result's menu.
+   *
+   * Two stages, because the tree is lazy: expand every level from the root down
+   * to the target (the listing of each level is fetched here) and then scroll
+   * its row into view. The scroll is retried rather than delayed once: over SFTP
+   * a deep level can take a moment, and the request carries a monotonic id so
+   * asking for the SAME folder again still re-scrolls.
+   */
+  useEffect(() => {
+    const request = store.revealRequest
+    if (request === undefined) return
+    const base = root.replace(/\/+$/, '')
+    const target = request.path.replace(/\/+$/, '')
+    if (target !== base && !target.startsWith(`${base}/`)) return
+    const chain: string[] = []
+    let walk = base
+    for (const part of target.slice(base.length).split('/')) {
+      if (part === '') continue
+      walk = `${walk}/${part}`
+      chain.push(walk)
+    }
+    for (const dir of chain) void loadDir(dir)
+    if (chain.length > 0) {
+      setExpanded((previous) => {
+        const next = new Set(previous)
+        for (const dir of chain) next.add(dir)
+        return next
+      })
+    }
+    let attempts = 0
+    const timer = window.setInterval(() => {
+      attempts += 1
+      const row = Array.from(document.querySelectorAll<HTMLElement>('[data-rvs-path]'))
+        .find((candidate) => candidate.dataset.rvsPath === target)
+      if (row !== undefined) {
+        window.clearInterval(timer)
+        row.scrollIntoView({ block: 'center' })
+        return
+      }
+      if (attempts > 20) window.clearInterval(timer)
+    }, 150)
+    return () => window.clearInterval(timer)
+  }, [store.revealRequest, root, loadDir])
+
   // Root listing + refresh on the shared revision bump (git writes, saves...).
   const revision = store.revision
   /**

package/src/client/RemoteRoot.tsx

@@ -246,7 +246,7 @@ function Shell(props: { ctx: Context; visible: boolean }): ReactNode {
       case 'terminal':
         // The terminal draws its own header + tab strip, so it takes the whole
         // slot (no extra padding wrapper).
-        return <TerminalView t={t} hosts={store.hosts} visible={panelLive('terminal')} />
+        return <TerminalView t={t} hosts={store.hosts} visible={panelLive('terminal')} request={store.terminalRequest} />
       case 'workspaces':
         return (
           <div className="rvs-viewpad" style={{ height: '100%' }}>

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,37 @@ 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: the four things 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.
+   */
+  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('search.revealInExplorer'), onSelect: () => { store.revealInExplorer(dir) }, separated: true },
+      { label: t('search.openInTerminal'), onSelect: () => { store.openTerminalAt(dir) } },
+    ])
+  }
+
   const groups = useMemo(() => groupHits(contentHits), [contentHits])
 
   /**
@@ -351,6 +387,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 +441,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') {