@keith9681/dsh-sidebar 0.15.2

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,62 @@
+/**
+ * Interception of the chat's file-open funnel. The client runtime's
+ * `ctx.workspaces.openPath` is the SINGLE door every chat-side file open goes
+ * through — ui-conversation's apply.ts resolves the path against the session
+ * cwd and calls it for tool-row path links, the produced-files row, and
+ * prose file mentions alike (verified against the DSH source:
+ * `packages/client/ui-conversation/src/client/apply.ts` is the only
+ * production caller). Wrapping that one method reroutes those opens into the
+ * sidebar editor instead of the Host OS — no DSH modification needed.
+ *
+ * The wrapper is 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
+}
+
+/**
+ * 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.
+ * @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) {
+        deps.openInSidebar(path, sessionId)
+        return Promise.resolve()
+      }
+    }
+    return original.call(workspaces, path)
+  }
+  return () => {
+    workspaces.openPath = original
+  }
+}

package/src/client/paths.ts

@@ -0,0 +1,47 @@
+/**
+ * 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
+}

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'
+}

package/src/client/plugin-settings.ts

@@ -0,0 +1,43 @@
+/**
+ * Pending-writes queue for the file tree's open-with config: pin toggles and
+ * (outside the settings popup) config edits land in the sidebar prefs as
+ * `pluginSettings['editor']`. Writes are serialized through one promise chain
+ * so a quick burst of pin clicks can never read a stale pluginSettings map
+ * and drop an earlier toggle; each write pushes the whole open map patch
+ * through the revision-free settings route and adopts the returned document.
+ *
+ * (The settings popup has its own serialized commit — SideCardSection's —
+ * so its rows and this helper rarely race; the shared route's last-write-wins
+ * semantics cover the uncommon overlap.)
+ */
+import { api } from './api.ts'
+import { parsePrefs } from './prefs.ts'
+import type { SidebarStore } from './state.ts'
+
+let queue: Promise<void> = Promise.resolve()
+
+/**
+ * Merge one plugin-owned settings blob of one descriptor and persist it.
+ * @param store - the sidebar store (its prefs are replaced by the write result).
+ * @param descriptorId - the descriptor whose blob is patched ('editor' here).
+ * @param updater - pure patch function; receives a shallow copy of the blob.
+ */
+export function updatePluginSettings(
+  store: SidebarStore,
+  descriptorId: string,
+  updater: (blob: Record<string, unknown>) => Record<string, unknown>,
+): void {
+  queue = queue.then(async () => {
+    const prefs = store.getPrefs()
+    const blob = prefs.pluginSettings[descriptorId] ?? {}
+    const next = updater({ ...blob })
+    const view = await api.settingsUpdate({
+      pluginSettings: { ...prefs.pluginSettings, [descriptorId]: next },
+    })
+    store.setPrefs(parsePrefs(view.value))
+  }).catch((error: unknown) => {
+    // The pin stays visually unchanged (no optimistic flip) and the menu
+    // keeps working — the write failure is logged, not surfaced.
+    console.error('open-with settings write failed', error)
+  })
+}

package/src/client/plugins-shared.ts

@@ -0,0 +1,29 @@
+/**
+ * Shared vocabulary of the recommended plugin catalogs: the entry shape and
+ * the GitHub topic URL. The two catalogs live in sibling modules —
+ * `plugins-tabs.ts` (tab registrations) and `plugins-viewers.ts` (file
+ * previewer registrations) — and are shown in the two "add plugin" modals
+ * (Side card settings → the dashed cards at the end of the 侧边栏内容 /
+ * 文件预览 grids).
+ */
+
+/** The GitHub topic page listing every repo tagged `dsh-better-sidebar`. */
+export const PLUGIN_TOPIC_URL = 'https://github.com/topics/dsh-better-sidebar'
+
+/** One curated plugin entry (name / url / description / install script). */
+export interface PluginEntry {
+  /** Unique id (the npm package name). */
+  id: string
+  /** Short display name. */
+  name: string
+  /** GitHub repository URL. */
+  url: string
+  /** One-line description (i18n friendly: string or () => string). */
+  description: string | (() => string)
+  /** Optional catalog group heading (i18n friendly); entries without one
+   *  render under the plain list (a flat catalog stays flat). */
+  category?: string | (() => string)
+  /** The full shell command pre-filled into the install terminal (not
+   *  executed until the user presses Enter). */
+  install: string
+}

package/src/client/plugins-tabs.ts

@@ -0,0 +1,87 @@
+/**
+ * The built-in catalog of TAB-registration plugins (sidebar pages),
+ * shown in the "add tab plugin" modal (Side card settings → 侧边栏内容 grid
+ * → the dashed card). Adding an entry: append one object here (unique
+ * `id` = npm package name, `url` = GitHub repo, `description` =
+ * i18n-friendly (add a `pluginXxxDesc` key in locales.ts), `install` = the
+ * full one-line install script — it starts with `cd ~/.dsh` so the install
+ * runs with the DSH home as the working directory). Data integrity is
+ * guarded by `tests/plugin-list.spec.ts`.
+ */
+import { t } from './locales.ts'
+import type { PluginEntry } from './plugins-shared.ts'
+
+/** Tab-registration plugins (alphabetical order). */
+export const builtinTabPlugins: readonly PluginEntry[] = [
+  {
+    id: '@dsh-external/dsh-sentinel',
+    name: 'dsh-sentinel 唤醒系统',
+    url: 'https://github.com/fuhefei/dsh-sentinel',
+    description: () => t('pluginSentinelDesc'),
+    // The official one-line bundle-channel install (git source, build
+    // artifacts committed — no build step needed). The `github:…` form is
+    // the upstream's documented command, `cd ~/.dsh` keeps the profile
+    // context consistent with the other entries.
+    install: 'cd ~/.dsh && dsh plugin --profile web add "github:fuhefei/dsh-sentinel#v0.7.0"',
+  },
+  {
+    id: 'dsh-docs-panel',
+    name: 'dsh-docs-panel 全局文档',
+    url: 'https://github.com/mlosun/dsh-docs-panel',
+    description: () => t('pluginDocsPanelDesc'),
+    // dsh-docs-panel hard-depends on dsh-better-sidebar (required peer), so
+    // the install line installs the prerequisite first, then the plugin.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add dsh-docs-panel',
+  },
+  {
+    id: 'dsh-flowglass',
+    name: 'dsh-flowglass 流镜',
+    url: 'https://github.com/Iwctwbh/dsh-flowglass',
+    description: () => t('pluginFlowglassDesc'),
+    // Flowglass keeps its standalone drawer as a fallback and registers the
+    // native tab automatically when better-sidebar is present.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add dsh-flowglass',
+  },
+  {
+    id: 'dsh-git-forge',
+    name: 'dsh-git-forge Git 凭据',
+    url: 'https://github.com/thirsty5034/dsh-git-forge',
+    description: () => t('pluginGitForgeDesc'),
+    // Peer-depends on dsh-better-sidebar (Git Forge tab). Install the
+    // prerequisite first; package is GitHub-sourced until npm publish.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add "dsh-git-forge@github:thirsty5034/dsh-git-forge"',
+  },
+  {
+    id: 'dsh-git-remotes',
+    name: 'dsh-git-remotes Git 远程',
+    url: 'https://github.com/yq04/dsh-git-remotes',
+    description: () => t('pluginGitRemotesDesc'),
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add git+https://github.com/yq04/dsh-git-remotes.git',
+  },
+  {
+    id: 'dsh-sidebar-qa',
+    name: 'dsh-sidebar-qa 划选追问',
+    url: 'https://github.com/ChenRuoT/dsh-sidebar-qa',
+    description: () => t('pluginSidebarQaDesc'),
+    // dsh-sidebar-qa hard-depends on dsh-better-sidebar (required peer), so
+    // the install line installs the prerequisite first, then the plugin.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add git+https://github.com/ChenRuoT/dsh-sidebar-qa.git',
+  },
+  {
+    id: 'dsh-ssh-tunnel',
+    name: 'dsh-ssh-tunnel SSH 隧道',
+    url: 'https://github.com/thirsty5034/dsh-ssh-tunnel',
+    description: () => t('pluginSshTunnelDesc'),
+    // Peer-depends on dsh-better-sidebar (SSH Tunnel tab + center terminal/SFTP).
+    // Install the prerequisite first; package is GitHub-sourced until npm publish.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add "dsh-ssh-tunnel@github:thirsty5034/dsh-ssh-tunnel"',
+  },
+  {
+    id: 'dsh-turn-review',
+    name: 'dsh-turn-review 本轮审查',
+    url: 'https://github.com/yq04/dsh-turn-review',
+    description: () => t('pluginTurnReviewDesc'),
+    // Needs dsh-better-sidebar (optional peer) for the tab; no model tools.
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-better-sidebar && dsh plugin --profile web add git+https://github.com/yq04/dsh-turn-review.git',
+  },
+]

package/src/client/plugins-viewers.ts

@@ -0,0 +1,30 @@
+/**
+ * The built-in catalog of FILE-PREVIEWER plugins (file-type previewers),
+ * shown in the "add preview plugin" modal (Side card settings → 文件预览
+ * grid → the dashed card). Adding an entry: append one object here (unique
+ * `id` = npm package name, `url` = GitHub repo, `description` =
+ * i18n-friendly, `install` = the full shell command pre-filled into the
+ * install terminal — it starts with `cd ~/.dsh` so the install runs with
+ * the DSH home as the working directory). Data integrity is guarded by
+ * `tests/plugin-list.spec.ts`.
+ */
+import { t } from './locales.ts'
+import type { PluginEntry } from './plugins-shared.ts'
+
+/** File-previewer plugins (alphabetical order). */
+export const builtinViewerPlugins: readonly PluginEntry[] = [
+  {
+    id: '@huanlin/dsh-plugin-better-sidebar-plugin-office',
+    name: 'Office 预览插件',
+    url: 'https://github.com/HuanLinOTO/dsh-plugin-better-sidebar-plugin-office',
+    description: () => t('pluginOfficeDesc'),
+    install: 'cd ~/.dsh && dsh plugin --profile web add @huanlin/dsh-plugin-better-sidebar-plugin-office',
+  },
+  {
+    id: 'dsh-video-preview',
+    name: '视频预览插件',
+    url: 'https://github.com/zemul/dsh-video-preview',
+    description: () => t('pluginVideoPreviewDesc'),
+    install: 'cd ~/.dsh && dsh plugin --profile web add dsh-video-preview',
+  },
+]