dsh-coding-sidebar 1.0.0

package/src/client/open-with-settings.tsx

@@ -0,0 +1,135 @@
+/**
+ * The editor tab's custom settings panel ("打开方式"): the file tree's
+ * "open with" configuration — the optional SSH host marking the workspace as
+ * remote, and the user-defined editors (name + URL template with `{path}` +
+ * whether they speak the VSCode URL dialect). Persisted as the editor
+ * blob's `openWith` key through the settings popup's `updatePluginSetting`.
+ *
+ * The popup renders the declarative rows (the editorExplorer picker) ABOVE
+ * this panel — SettingsBody renders the custom panel after the row list, so
+ * this component owns only its own section.
+ */
+import { useState } from 'react'
+import { IconCloseOutline16 } from '@deepseek-ai/dsh-client-ui-primitives'
+import {
+  isValidCustomEditor,
+  newCustomEditorId,
+  parseOpenWithConfig,
+  type CustomEditor,
+  type OpenWithConfig,
+} from './open-with.ts'
+import { t } from './locales.ts'
+import css from './SideCardSection.module.css'
+
+export function OpenWithSettings(props: {
+  pluginSettings: Record<string, unknown>
+  updatePluginSetting: (key: string, value: unknown) => void
+}) {
+  const { pluginSettings, updatePluginSetting } = props
+  // Local draft seeded from the persisted blob (each commit re-renders the
+  // popup with the round-tripped prefs; the local state stays authoritative
+  // while the popup is open, so typing never fights an in-flight write).
+  const [draft, setDraft] = useState<OpenWithConfig>(() => parseOpenWithConfig(pluginSettings.openWith))
+
+  const commit = (next: OpenWithConfig): void => {
+    setDraft(next)
+    updatePluginSetting('openWith', next)
+  }
+
+  const setSshHost = (sshHost: string): void => commit({ ...draft, sshHost })
+
+  const patchCustom = (id: string, patch: Partial<CustomEditor>): void => {
+    commit({
+      ...draft,
+      customEditors: draft.customEditors.map(editor => editor.id === id ? { ...editor, ...patch } : editor),
+    })
+  }
+
+  const removeCustom = (id: string): void => {
+    commit({
+      ...draft,
+      customEditors: draft.customEditors.filter(editor => editor.id !== id),
+      // A removed editor can never stay pinned (the menu prunes unknown ids
+      // anyway; this keeps the blob clean).
+      pinned: draft.pinned.filter(pinnedId => pinnedId !== `custom:${id}`),
+    })
+  }
+
+  const addCustom = (): void => {
+    commit({
+      ...draft,
+      customEditors: [...draft.customEditors, { id: newCustomEditorId(), name: '', urlTemplate: '', isVscodeFamily: false }],
+    })
+  }
+
+  const hasInvalid = draft.customEditors.some(editor => !isValidCustomEditor(editor))
+
+  return (
+    <div className={css.popupRows}>
+      <div className={css.popupRow}>
+        <span className={css.rowText}>
+          <span className={css.title}>{t('openWithSettingsSshTitle')}</span>
+          <span className={css.desc}>{t('openWithSettingsSshDesc')}</span>
+        </span>
+        <input
+          className={css.typedInput}
+          value={draft.sshHost}
+          placeholder={t('openWithSettingsSshPlaceholder')}
+          spellCheck={false}
+          onChange={(event) => { setSshHost(event.target.value) }}
+        />
+      </div>
+      <div className={css.popupRow}>
+        <span className={css.rowText}>
+          <span className={css.title}>{t('openWithSettingsCustomTitle')}</span>
+          <span className={css.desc}>{t('openWithSettingsCustomDesc')}</span>
+        </span>
+        <span className={css.control}>
+          <button type="button" className={css.done} onClick={addCustom}>
+            {t('openWithSettingsAdd')}
+          </button>
+        </span>
+      </div>
+      {draft.customEditors.map(editor => (
+        <div key={editor.id} className={css.openWithEditorRow}>
+          <input
+            className={css.openWithEditorInput}
+            value={editor.name}
+            placeholder={t('openWithSettingsName')}
+            spellCheck={false}
+            onChange={(event) => { patchCustom(editor.id, { name: event.target.value }) }}
+          />
+          <input
+            className={css.openWithEditorTemplate}
+            value={editor.urlTemplate}
+            placeholder={t('openWithSettingsTemplate')}
+            spellCheck={false}
+            onChange={(event) => { patchCustom(editor.id, { urlTemplate: event.target.value }) }}
+          />
+          <label className={css.openWithFamily} title={t('openWithSettingsFamilyDesc')}>
+            <input
+              type="checkbox"
+              checked={editor.isVscodeFamily}
+              onChange={(event) => { patchCustom(editor.id, { isVscodeFamily: event.currentTarget.checked }) }}
+            />
+            <span>{t('openWithSettingsFamily')}</span>
+          </label>
+          <button
+            type="button"
+            className={css.openWithRemove}
+            aria-label={t('openWithSettingsRemove')}
+            title={t('openWithSettingsRemove')}
+            onClick={() => { removeCustom(editor.id) }}
+          >
+            <IconCloseOutline16 size={14} />
+          </button>
+        </div>
+      ))}
+      {hasInvalid && (
+        <div className={css.openWithHint} role="note">
+          {t('openWithSettingsInvalidHint')}
+        </div>
+      )}
+    </div>
+  )
+}

package/src/client/open-with.ts

@@ -0,0 +1,221 @@
+/**
+ * The file tree's "open with" vocabulary: which external editors / file
+ * managers the context menu can hand a row's path to, how the per-user
+ * configuration (custom editors, SSH host, pinned ids) is parsed out of the
+ * persisted blob, and how the external URL is built (local `file` URLs and
+ * VSCode-family SSH-remote URLs).
+ *
+ * Pure by design (no React / no `api`), so the whole surface is unit-testable
+ * without a DOM or a host route. The menu and the settings panel only consume
+ * the exported types and functions.
+ */
+import type { CopyKey } from './locales.ts'
+
+/** One user-configured editor (persisted in `pluginSettings['editor'].openWith`). */
+export interface CustomEditor {
+  id: string
+  /** Human label shown in the menu (e.g. "Windsurf"). */
+  name: string
+  /** URL template with a `{path}` placeholder (e.g. `cursor://file/{path}`). */
+  urlTemplate: string
+  /** Whether the editor speaks the VSCode URL dialect — the only editors
+   *  with an SSH-remote form (`<scheme>://vscode-remote/ssh-remote+<host>/…`). */
+  isVscodeFamily: boolean
+}
+
+/** The per-user "open with" configuration (one key of the editor blob). */
+export interface OpenWithConfig {
+  /** SSH host (user@host or an ~/.ssh/config alias); '' = local workspace. */
+  sshHost: string
+  /** User-defined editors, appended after the built-ins. */
+  customEditors: CustomEditor[]
+  /** Ids of open-with targets pinned to the menu's top level
+   *  ('explorer' | 'vscode' | 'cursor' | 'zed' | 'custom:<id>'). */
+  pinned: string[]
+}
+
+/** One menu-visible open target (built-in or custom, SSH-filtered). */
+export interface OpenWithTarget {
+  /** Stable id (`explorer` / `vscode` / `cursor` / `zed` / `custom:<id>`). */
+  id: string
+  /** Locale key of a built-in label (custom editors carry `name` instead). */
+  nameKey?: CopyKey
+  /** User-defined label (custom editors only; '' for built-ins). */
+  name: string
+  /** 'reveal' = show in the OS file manager; 'url' = open a URL. */
+  kind: 'reveal' | 'url'
+  /** URL template with `{path}`; undefined for reveal targets. */
+  urlTemplate?: string
+  /** Whether the editor talks the VSCode URL dialect. */
+  isVscodeFamily: boolean
+  /** Hidden in SSH mode (a host-local opener cannot reach a remote path). */
+  localOnly: boolean
+}
+
+/** The default open-with configuration (fresh documents). */
+export const OPEN_WITH_DEFAULTS: OpenWithConfig = {
+  sshHost: '',
+  customEditors: [],
+  pinned: [],
+}
+
+/** The built-in open targets, in menu order. */
+export const OPEN_WITH_BUILTINS: readonly OpenWithTarget[] = [
+  {
+    id: 'explorer',
+    nameKey: 'openWithExplorer',
+    name: '',
+    kind: 'reveal',
+    isVscodeFamily: false,
+    localOnly: true,
+  },
+  {
+    id: 'vscode',
+    nameKey: 'openWithVscode',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'vscode://file/{path}',
+    isVscodeFamily: true,
+    localOnly: false,
+  },
+  {
+    id: 'cursor',
+    nameKey: 'openWithCursor',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'cursor://file/{path}',
+    isVscodeFamily: true,
+    localOnly: false,
+  },
+  {
+    id: 'zed',
+    nameKey: 'openWithZed',
+    name: '',
+    kind: 'url',
+    urlTemplate: 'zed://file/{path}',
+    isVscodeFamily: false,
+    localOnly: true,
+  },
+]
+
+/** Whether a persisted value makes a structurally valid custom-editor row.
+ *  Name/template may be empty — the settings panel edits rows in place and
+ *  an in-progress row must survive the round-trip; the MENU hides rows that
+ *  fail the stricter {@link isValidCustomEditor} check. */
+function isCustomEditor(value: unknown): value is CustomEditor {
+  if (value === null || typeof value !== 'object' || Array.isArray(value)) return false
+  const record = value as Record<string, unknown>
+  return typeof record.id === 'string' && record.id !== ''
+    && typeof record.name === 'string'
+    && typeof record.urlTemplate === 'string'
+    && typeof record.isVscodeFamily === 'boolean'
+}
+
+/**
+ * Parse the persisted `openWith` blob (tolerant): malformed fields fall back
+ * to the defaults, malformed custom-editor rows are dropped, and pinned ids
+ * are kept verbatim (unknown ids are pruned when the targets are resolved —
+ * the menu is the only consumer of the resolved list).
+ */
+export function parseOpenWithConfig(raw: unknown): OpenWithConfig {
+  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return { ...OPEN_WITH_DEFAULTS }
+  const record = raw as Record<string, unknown>
+  const sshHost = typeof record.sshHost === 'string' ? record.sshHost : ''
+  const customEditors = Array.isArray(record.customEditors)
+    ? record.customEditors.filter(isCustomEditor)
+    : []
+  const pinned = Array.isArray(record.pinned)
+    ? record.pinned.filter((id): id is string => typeof id === 'string' && id !== '')
+    : []
+  return { sshHost, customEditors, pinned }
+}
+
+/** Whether a custom editor id belongs to this config (id prefix match). */
+function customIdOf(id: string): string {
+  return `custom:${id}`
+}
+
+/**
+ * The menu-visible open targets, in order (built-ins then custom editors).
+ * In SSH mode the local-only targets (the OS file manager, Zed, custom
+ * editors without the VSCode dialect) are dropped — they cannot reach a
+ * remote path. Unknown pinned ids are pruned here too.
+ */
+export function resolveOpenWithTargets(config: OpenWithConfig): OpenWithTarget[] {
+  const ssh = config.sshHost.trim() !== ''
+  const targets: OpenWithTarget[] = [
+    ...OPEN_WITH_BUILTINS,
+    ...config.customEditors
+      .filter(isValidCustomEditor)
+      .map((editor): OpenWithTarget => ({
+        id: customIdOf(editor.id),
+        name: editor.name,
+        kind: 'url',
+        urlTemplate: editor.urlTemplate,
+        isVscodeFamily: editor.isVscodeFamily,
+        localOnly: !editor.isVscodeFamily,
+      })),
+  ]
+  return targets.filter(target => !(ssh && target.localOnly))
+}
+
+/** The SSH hint appended to a target's label in remote mode. */
+export function openWithSshActive(config: OpenWithConfig): boolean {
+  return config.sshHost.trim() !== ''
+}
+
+/**
+ * The URL to open for one resolved target, or undefined when the target has
+ * no URL form (reveal) or the template is malformed. The path is inserted
+ * RAW into the template (browsers percent-encode as needed; VSCode-family
+ * URL parsers consume the absolute path with its leading slash, e.g.
+ * `vscode://file//home/u/f.ts` or `vscode://file/C:/Users/u/f.ts`).
+ */
+export function openWithUrl(target: OpenWithTarget, path: string, config: OpenWithConfig): string | undefined {
+  if (target.kind !== 'url' || target.urlTemplate === undefined) return undefined
+  const normalized = normalizeUrlPath(path)
+  const ssh = openWithSshActive(config)
+  if (ssh && target.isVscodeFamily) {
+    const scheme = schemeOf(target.urlTemplate)
+    if (scheme === undefined) return undefined
+    // `ssh-remote+<host>` owns NO slash of its own: the path keeps its
+    // leading slash, so `/home/u/f.ts` lands as `…+host/home/u/f.ts`.
+    return `${scheme}://vscode-remote/ssh-remote+${config.sshHost.trim()}${normalized}`
+  }
+  if (!target.urlTemplate.includes('{path}') || !hasUrlScheme(target.urlTemplate)) return undefined
+  return target.urlTemplate.replace('{path}', normalized)
+}
+
+/** Whether a template starts with a `scheme://` prefix (the only shape the
+ *  host's external opener accepts and the settings panel suggests). */
+function hasUrlScheme(template: string): boolean {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(template)
+}
+
+/** The scheme of a URL template (the part before the first ':'), or undefined. */
+function schemeOf(template: string): string | undefined {
+  const at = template.indexOf(':')
+  if (at <= 0) return undefined
+  const scheme = template.slice(0, at)
+  return /^[a-z][a-z0-9+.-]*$/i.test(scheme) ? scheme : undefined
+}
+
+/** Normalize a filesystem path for embedding in a URL (backslashes → '/'). */
+export function normalizeUrlPath(path: string): string {
+  return path.replace(/\\/g, '/')
+}
+
+/** A fresh custom-editor id (uuid when available, time-based fallback). */
+export function newCustomEditorId(): string {
+  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
+    return crypto.randomUUID()
+  }
+  return `${Date.now().toString(36)}${Math.random().toString(36).slice(2)}`
+}
+
+/** Validate one custom-editor row before the settings panel accepts it. */
+export function isValidCustomEditor(row: { name: string; urlTemplate: string }): boolean {
+  return row.name.trim() !== ''
+    && row.urlTemplate.includes('{path}')
+    && /^[a-z][a-z0-9+.-]*:\/\//i.test(row.urlTemplate.trim())
+}

package/src/client/openpath-intercept.ts

@@ -0,0 +1,143 @@
+/**
+ * Interception of the chat's file-open funnel. Two doors have carried every
+ * chat-side file open (tool-row path links, the produced-files row, and prose
+ * file mentions alike):
+ *
+ * - `ctx.workspaces.openPath` — the pre-0.1.2 funnel; ui-chat's apply.ts was
+ *   its only production caller. Wrapped by {@link wrapOpenPath}.
+ * - `ctx.remote.session.openWorkspacePath` — the 0.1.2-alpha.1 funnel (the
+ *   unary Remote-namespace migration rewired apply.ts to call the RPC
+ *   directly and stopped calling `workspaces.openPath` altogether, leaving
+ *   that door dead). Wrapped by {@link wrapRemoteOpenPath}.
+ *
+ * Both wrappers reroute opens into the sidebar editor instead of the Host
+ * OS — no DSH modification needed. They are installed together: each door is
+ * wrapped only when it exists on the runtime, so one build covers baselines
+ * on either side of the migration (and a baseline that still routes through
+ * the old door stays intercepted).
+ *
+ * The wrappers are dependency-free by design (no React / ui-primitives), so
+ * the takeover logic is unit-testable and the file stays importable from the
+ * test runtime.
+ */
+
+/** The one service method the wrapper replaces (mirror of the runtime IWorkspaces). */
+export interface OpenPathService {
+  openPath(path: string): Promise<void>
+}
+
+/** Per-call decisions the wrapper needs (wired to the store + ctx in the client half). */
+export interface OpenPathInterceptDeps {
+  /**
+   * Whether to take over this call: the `interceptOpenPath` pref AND the
+   * editor tab's own enable switch must both be on (an editor that cannot
+   * open must not swallow opens — they fall through to the Host).
+   */
+  takeoverEnabled(): boolean
+  /** The session whose scope the sidebar editor loads the file in (current session). */
+  currentSessionId(): string | undefined
+  /** Route the open into the sidebar editor (the established openSidebarFile). */
+  openInSidebar(path: string, sessionId: string): void
+  /** Route a folder-reveal gesture ("Show in folder" passes '.') into the sidebar explorer. */
+  revealInExplorer(path: string, sessionId: string): void
+}
+
+/** The Remote session namespace face the new funnel is wrapped through. */
+export interface RemoteSessionStub {
+  openWorkspacePath(request: { path: string }): Promise<unknown>
+}
+
+/**
+ * The success envelope ui-chat's openFile expects from the RPC
+ * (`if (!result.ok) throw` on the ClientResult); an intercepted open must
+ * resolve as success so the chat view does not surface a failure toast.
+ */
+const REMOTE_OPEN_RESULT: unknown = { ok: true, value: { opened: true } }
+
+/**
+ * Whether a path is the "Show in folder" folder-reveal gesture. The stock
+ * ui-deliverables row passes `'.'` (the session workspace root, resolved by
+ * the chat view to `"<cwd>/."`); any path whose final segment is `.` is the
+ * same gesture. A directory has no editor content, so these opens must reach
+ * the explorer instead of an editor tab.
+ */
+export function isFolderRevealPath(path: string): boolean {
+  if (path === '.' || path === './') return true
+  const trimmed = path.replace(/[\\/]+$/, '')
+  return trimmed === '.' || /[\\/]\.$/.test(trimmed)
+}
+
+/**
+ * Wrap `workspaces.openPath`: intercepted calls open the file in the sidebar
+ * editor instead of the Host OS and resolve as success (the original's
+ * callers ignore the result); anything that declines falls through to the
+ * original method untouched. The one exception is the folder-reveal gesture,
+ * which is routed to {@link OpenPathInterceptDeps.revealInExplorer} instead.
+ * @param workspaces - the client workspaces service to wrap.
+ * @param deps - per-call takeover decisions.
+ * @returns the disposer restoring the original method (HMR-safe).
+ */
+export function wrapOpenPath(workspaces: OpenPathService, deps: OpenPathInterceptDeps): () => void {
+  // The RAW method reference (never a bound copy): restore must put back the
+  // exact original so a chain of wrappers (other plugins wrapping the same
+  // method) keeps working across disposals in any order.
+  const original = workspaces.openPath
+  workspaces.openPath = (path: string): Promise<void> => {
+    if (deps.takeoverEnabled()) {
+      const sessionId = deps.currentSessionId()
+      if (sessionId !== undefined) {
+        if (isFolderRevealPath(path)) deps.revealInExplorer(path, sessionId)
+        else deps.openInSidebar(path, sessionId)
+        return Promise.resolve()
+      }
+    }
+    return original.call(workspaces, path)
+  }
+  return () => {
+    workspaces.openPath = original
+  }
+}
+
+/**
+ * Wrap `session.openWorkspacePath` — the post-migration funnel — to the same
+ * takeover semantics as {@link wrapOpenPath}: intercepted opens land in the
+ * sidebar editor (folder reveals in the explorer) and resolve with the RPC
+ * success envelope, declined opens reach the untouched original.
+ *
+ * The namespace service installs each method as a configurable getter (the
+ * upstream gateway re-reads its method table on every access), so the raw
+ * property descriptor is captured and re-defined rather than assigned: the
+ * wrapped getter re-reads the ORIGINAL descriptor each call, meaning a
+ * remount that swaps the underlying method is picked up transparently, and
+ * the disposer restores the exact original descriptor (a chain of wrappers
+ * from other plugins keeps working across disposals in any order).
+ * @param session - the Remote session namespace to wrap.
+ * @param deps - per-call takeover decisions (same face as the old door).
+ * @returns the disposer restoring the original descriptor (HMR-safe); a
+ *   no-op when the method is absent (pre-carrier baseline).
+ */
+export function wrapRemoteOpenPath(session: RemoteSessionStub, deps: OpenPathInterceptDeps): () => void {
+  const desc = Object.getOwnPropertyDescriptor(session, 'openWorkspacePath')
+  if (desc?.get === undefined) return () => {}
+  Object.defineProperty(session, 'openWorkspacePath', {
+    configurable: true,
+    enumerable: desc.enumerable,
+    get: function (this: RemoteSessionStub): (request: { path: string }) => Promise<unknown> {
+      const original = desc.get!.call(this)
+      return (request: { path: string }) => {
+        if (deps.takeoverEnabled()) {
+          const sessionId = deps.currentSessionId()
+          if (sessionId !== undefined) {
+            if (isFolderRevealPath(request.path)) deps.revealInExplorer(request.path, sessionId)
+            else deps.openInSidebar(request.path, sessionId)
+            return Promise.resolve(REMOTE_OPEN_RESULT)
+          }
+        }
+        return original(request)
+      }
+    },
+  })
+  return () => {
+    Object.defineProperty(session, 'openWorkspacePath', desc)
+  }
+}

package/src/client/paths.ts

@@ -0,0 +1,63 @@
+/**
+ * Path projection helpers shared by the explorer rows: a path relative to
+ * the session cwd (for the @-reference button and "copy relative path").
+ * The fs-tree joins with '/' even on Windows, so both separators normalize
+ * to '/' before comparison.
+ *
+ * This module is dependency-free (no node:path in the client bundle): the
+ * host is the authority for path semantics, so this mirror deliberately
+ * accepts a SUPERSET of absolute forms — anything a Windows host would emit
+ * (drive letters, UNC) plus POSIX roots. A form the host would reject
+ * (e.g. a backslash UNC path on a POSIX host) passes through here and then
+ * fails loudly in the host's requireAbsolute instead of being silently
+ * joined onto the cwd.
+ */
+
+/**
+ * Mirror of the host's absolute-path notion (see fs-tree.requireAbsolute):
+ * POSIX roots, Windows drive letters, and Windows UNC network shares in
+ * both backslash (`\\server\share\...`) and forward-slash
+ * (`//server/share/...`) form. Deliberately a superset — see the module
+ * comment — so a produced UNC path is never joined onto the cwd.
+ */
+export function isAbsolutePath(path: string): boolean {
+  return path.startsWith('/') || /^[A-Za-z]:[\\/]/.test(path) || /^[\\/]{2}[^\\/]/.test(path)
+}
+
+/**
+ * The path relative to the session's working directory.
+ * @param cwd - the explorer root (absolute).
+ * @param path - an absolute entry path from the fs-tree.
+ * @returns the relative path with '/' separators ('.' for the cwd itself),
+ * or `path` unchanged when it lies outside the cwd.
+ *
+ * The prefix test is case-insensitive: Windows paths (and macOS's
+ * case-insensitive volumes) may arrive with different casing than the cwd
+ * row, and the containment decision must not depend on it. The returned
+ * relative text keeps the caller's own casing.
+ */
+export function relativeTo(cwd: string, path: string): string {
+  const base = cwd.replace(/[\\/]+$/, '')
+  const norm = (value: string): string => value.replace(/\\/g, '/')
+  const nBase = norm(base)
+  const nPath = norm(path)
+  if (nPath === nBase) return '.'
+  if (nPath.toLowerCase().startsWith(`${nBase.toLowerCase()}/`)) return nPath.slice(nBase.length + 1)
+  return path
+}
+
+/**
+ * Whether `target` lies under `base` (or equals it), tolerant of separator
+ * style and — on Windows-style drive paths — of letter case. A client-side
+ * mirror of the host's `isWithin` (fs-tree.ts) used to decide whether a
+ * git-derived path can be opened in the editor (a linked worktree outside
+ * the session workspace cannot: the host's workspace fence would reject it).
+ */
+export function isWithinWorkspace(base: string, target: string): boolean {
+  const norm = (value: string): string => value.replace(/[\\/]+/g, '/').replace(/\/$/, '')
+  const b = norm(base)
+  const t = norm(target)
+  const lb = b.toLowerCase()
+  const lt = t.toLowerCase()
+  return lt === lb || lt.startsWith(`${lb}/`)
+}

package/src/client/pdf-types.ts

@@ -0,0 +1,4 @@
+/** Pure PDF extension dispatch, separate from React for unit testing. */
+export function isPdfExt(ext: string): boolean {
+  return ext === '.pdf'
+}