dsh-plugin-workbench 0.0.8 → 0.0.10

package/src/client/mentions.ts

@@ -0,0 +1,207 @@
+/**
+ * @-mention linkifier for the conversation.
+ *
+ * The workbench inserts `@<relative-workspace-path>` into the composer (menu
+ * gesture "在消息中引用"), and this module makes the mention VISIBLE as a
+ * hyperlink once the message is rendered: any `@` followed by a token that
+ * matches the mention grammar is wrapped in an anchor, and clicking it opens
+ * the file in the workbench preview.
+ *
+ * Grammar (anything else stays plain text with no special meaning):
+ *   - `@` must sit at a token boundary (start of text, whitespace, or
+ *     punctuation like `（(` `，,` `。.` quotes and brackets) — so `user@x`,
+ *     `a.b@c` and URLs never match;
+ *   - the token is the longest run of non-whitespace, non-`@` characters,
+ *     with trailing sentence punctuation trimmed (`.。 ,， ;； :： !！ ?？ )）`…);
+ *   - the remaining token must be a RELATIVE path (never drive-absolute or
+ *     leading-slash), and path-shaped: either contains a `/` or `\` directory
+ *     separator, or is a single segment ending in a file extension.
+ *
+ * Scanning mirrors the table-zoom enhancer: a MutationObserver on
+ * `document.body`, rAF-coalesced, walks the text nodes of every
+ * `[data-conversation-scroll]` subtree and skips protected containers
+ * (code blocks, existing links, aria-hidden overlays like the composer
+ * mirror/backdrop, the composer seat, popups, and the workbench column).
+ */
+import { openMention } from './composer'
+
+/** Mention pattern: `@` + token (no whitespace, no embedded `@`). */
+const MENTION_RE = /@([^\s@]+)/g
+
+/** Trailing characters trimmed from a mention token before validation. */
+const TRAILING = new Set(['.', ',', ';', ':', '!', '?', '。', '，', '；', '：', '！', '？', ')', '）', ']', '】', '}', '》', '」', '』', '"', "'"])
+
+/** Characters that may legally precede `@` in a mention (start/whitespace/punctuation). */
+function isBoundaryBefore(ch: string | undefined): boolean {
+  if (ch === undefined) return true
+  // NOTE: `]` is escaped — an unescaped `]` inside a character class ends it
+  // early and silently turns the rest into required literal matches.
+  return /[\s(（[【「『"'`、，。；：！？,.!?:;>\])}）]/.test(ch)
+}
+
+/** Whether `token` (already trailing-trimmed) matches the relative-path grammar. */
+export function isMentionToken(token: string): boolean {
+  if (token.length === 0) return false
+  // Sentence punctuation inside the token means following text bled into the
+  // mention (e.g. "@src/index.ts。谢谢"): that is plain text, not a path.
+  // Sentence punctuation at the END is trimmed before this check.
+  if (/[。，、；：！？（）、【】「」『』《》]/.test(token)) return false
+  // Relative only: no drive prefix, no leading separator, no leading dot-dot.
+  if (/^[A-Za-z]:[\\/]/.test(token)) return false
+  if (token.startsWith('/') || token.startsWith('\\')) return false
+  if (token.startsWith('..')) return false
+  // Path-shaped: a directory separator anywhere, or a single file segment
+  // with an extension.
+  if (token.includes('/') || token.includes('\\')) return true
+  return /^[^\\/]+\.[A-Za-z0-9_][A-Za-z0-9._~+-]*$/.test(token)
+}
+
+/** Trim trailing sentence punctuation from a raw mention token. */
+export function trimMentionToken(raw: string): string {
+  let token = raw
+  while (token.length > 0 && TRAILING.has(token[token.length - 1])) {
+    token = token.slice(0, -1)
+  }
+  return token
+}
+
+/**
+ * Extract every valid mention from `text` as [start, end, mention] ranges.
+ * `end` covers `@` + the TRIMMED token (trailing punctuation stays outside the
+ * link). Pure and testable: the DOM walk uses it and then splits the text node.
+ */
+export function findMentions(text: string): Array<{ start: number; end: number; mention: string }> {
+  const hits: Array<{ start: number; end: number; mention: string }> = []
+  MENTION_RE.lastIndex = 0
+  let match: RegExpExecArray | null
+  while ((match = MENTION_RE.exec(text)) !== null) {
+    const at = match.index
+    const raw = match[1]
+    if (!isBoundaryBefore(at > 0 ? text[at - 1] : undefined)) continue
+    const token = trimMentionToken(raw)
+    if (!isMentionToken(token)) continue
+    hits.push({ start: at, end: at + 1 + token.length, mention: token })
+  }
+  return hits
+}
+
+/** Containers whose text is never linkified (code, existing links, overlays). */
+const SKIP_SELECTOR = [
+  'code',
+  'pre',
+  'a',
+  'script',
+  'style',
+  'textarea',
+  '[data-composer-seat]',
+  '[data-input-mirror]',
+  '[data-input-backdrop]',
+  '[data-pane="explorer"]',
+  '[aria-hidden="true"]',
+  '.dstz-popup',
+  '.dshpick-lightbox',
+  '[data-wb-mention]',
+].join(',')
+
+/** Walk the text nodes of one conversation scroll container and linkify. */
+function linkifyRoot(root: HTMLElement): void {
+  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT)
+  const toCheck: Text[] = []
+  let node: Node | null = walker.nextNode()
+  while (node !== null) {
+    if (node.parentElement !== null && node.parentElement.closest(SKIP_SELECTOR) === null) {
+      toCheck.push(node as Text)
+    }
+    node = walker.nextNode()
+  }
+  for (const textNode of toCheck) {
+    linkifyTextNode(textNode)
+  }
+}
+
+/** Wrap every mention in one text node; returns true when anything changed. */
+function linkifyTextNode(node: Text): boolean {
+  const text = node.data
+  const hits = findMentions(text)
+  if (hits.length === 0) return false
+  const frag = document.createDocumentFragment()
+  let cursor = 0
+  for (const hit of hits) {
+    if (hit.start > cursor) frag.appendChild(document.createTextNode(text.slice(cursor, hit.start)))
+    const anchor = document.createElement('a')
+    anchor.className = 'dswb-mention'
+    anchor.dataset.wbMention = hit.mention
+    anchor.textContent = text.slice(hit.start, hit.end)
+    anchor.title = `@${hit.mention}`
+    frag.appendChild(anchor)
+    cursor = hit.end
+  }
+  if (cursor < text.length) frag.appendChild(document.createTextNode(text.slice(cursor)))
+  node.parentNode?.replaceChild(frag, node)
+  return true
+}
+
+/** Style tag guard (the bundle may re-apply on HMR). */
+let styleInstalled = false
+
+const MENTION_CSS = [
+  '.dswb-mention{color:var(--dsw-alias-state-business-primary);text-decoration:underline;text-underline-offset:2px;cursor:pointer;border-radius:4px;padding:0 1px}',
+  '.dswb-mention:hover{background:var(--dsw-alias-interactive-bg-hover)}',
+].join('')
+
+function installStyle(): void {
+  if (styleInstalled || typeof document === 'undefined') return
+  styleInstalled = true
+  const tagId = 'dsh-plugin-workbench/mention.module.css'
+  if (document.querySelector(`style[data-plugin-css=${JSON.stringify(tagId)}]`) === null) {
+    const tag = document.createElement('style')
+    tag.dataset.plugin = 'dsh-plugin-workbench'
+    tag.dataset.pluginCss = tagId
+    tag.textContent = MENTION_CSS
+    document.head.appendChild(tag)
+  }
+}
+
+/** Click handler: open the mentioned file in the workbench preview. */
+function onDocumentClick(e: MouseEvent): void {
+  const target = e.target
+  if (!(target instanceof Element)) return
+  const anchor = target.closest('a.dswb-mention')
+  if (anchor === null) return
+  const mention = anchor.getAttribute('data-wb-mention')
+  if (mention === null) return
+  e.preventDefault()
+  e.stopPropagation()
+  openMention(mention)
+}
+
+/** One-time install guard (HMR re-applies must not double-observe). */
+let linkifierInstalled = false
+
+/** Start the linkifier: initial scan + MutationObserver with rAF coalescing. */
+export function installMentionLinkifier(): () => void {
+  if (typeof document === 'undefined' || typeof MutationObserver === 'undefined') return () => undefined
+  if (linkifierInstalled) return () => undefined
+  linkifierInstalled = true
+  installStyle()
+  document.addEventListener('click', onDocumentClick)
+  let pending = false
+  const scan = (): void => {
+    pending = false
+    for (const root of document.querySelectorAll<HTMLElement>('[data-conversation-scroll]')) {
+      linkifyRoot(root)
+    }
+  }
+  const observer = new MutationObserver(() => {
+    if (pending) return
+    pending = true
+    requestAnimationFrame(scan)
+  })
+  observer.observe(document.body, { childList: true, subtree: true, characterData: true })
+  scan()
+  return () => {
+    observer.disconnect()
+    document.removeEventListener('click', onDocumentClick)
+    linkifierInstalled = false
+  }
+}

package/src/index.ts

@@ -27,10 +27,12 @@
  */
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { spawn } from 'node:child_process'
-import { watch as watchFs } from 'node:fs'
+import { existsSync, readFileSync, watch as watchFs } from 'node:fs'
 import type { FSWatcher } from 'node:fs'
-import { basename, dirname } from 'node:path'
+import { basename, dirname, join } from 'node:path'
 import { mkdir, rename as renameFs, rm, cp, writeFile as writeFileNode } from 'node:fs/promises'
+import { fileURLToPath } from 'node:url'
+import { homedir } from 'node:os'
 import type { Context } from '@deepseek-ai/cordis'
 
 export const name = 'dsh-plugin-workbench'
@@ -252,11 +254,89 @@ function pathOf(payload: unknown): string | undefined {
   return undefined
 }
 
+/**
+ * The explorer-column patch markers that scripts/patch-layout.mjs injects into
+ * the compiled dsh-client-ui-layout client bundle. A dsh upgrade (or a
+ * `pnpm install` that refreshes the ui-layout package) silently reverts that
+ * bundle, which makes the workbench column vanish even though this plugin is
+ * fine — this is the exact failure this auto-heal guards against.
+ */
+const LAYOUT_PATCH_MARKERS = [
+  '"explorerCol": "',
+  'setExplorer: (d, px) => {',
+  'renderSlot("explorer"',
+  'conversationSeat',
+] as const
+
+/** Resolve the installed dsh-client-ui-layout client bundle (profile node_modules junction). */
+function layoutClientPath(): string {
+  const dshHome = process.env.DSH_HOME ?? join(homedir(), '.dsh')
+  return join(dshHome, 'profiles', 'node_modules', '@deepseek-ai', 'dsh-client-ui-layout', 'lib', 'client.js')
+}
+
+/**
+ * True when the ui-layout bundle already carries the explorer-column patch.
+ * A missing bundle (non-standard install) is treated as "nothing to patch" so
+ * the check never blocks a boot; an unreadable file likewise bails out to the
+ * caller rather than throwing.
+ */
+function layoutIsPatched(): boolean {
+  try {
+    const target = layoutClientPath()
+    if (!existsSync(target)) return true
+    const text = readFileSync(target, 'utf8')
+    return LAYOUT_PATCH_MARKERS.every((marker) => text.includes(marker))
+  } catch {
+    return true
+  }
+}
+
+/** Module-level guard so a HMR/re-apply burst never spawns the patch twice concurrently. */
+let layoutPatchScheduled = false
+
+/**
+ * Re-apply the ui-layout explorer-column patch when it is missing.
+ *
+ * The workbench column renders into a fourth `explorer` slot that is added to
+ * the compiled dsh-client-ui-layout bundle by scripts/patch-layout.mjs. A dsh
+ * upgrade silently reverts that bundle, so this re-runs the same
+ * version-checked script: anchors that no longer match abort the script
+ * WITHOUT writing, so an incompatible dsh version never corrupts the bundle —
+ * it only logs a warning and the plugin still boots. Idempotent and
+ * non-blocking (spawned fire-and-forget), so it never delays a boot.
+ */
+function ensureLayoutPatch(): void {
+  if (layoutPatchScheduled) return
+  layoutPatchScheduled = true
+  try {
+    if (layoutIsPatched()) return
+    const script = join(dirname(dirname(fileURLToPath(import.meta.url))), 'scripts', 'patch-layout.mjs')
+    const child = spawn(process.execPath, [script], { stdio: 'inherit', windowsHide: true })
+    child.on('error', (err) => {
+      console.warn('[dsh-plugin-workbench] re-applying ui-layout explorer patch failed:', err.message)
+      layoutPatchScheduled = false
+    })
+    child.on('close', (code) => {
+      if (code === 0) {
+        console.log('[dsh-plugin-workbench] re-applied the missing dsh-client-ui-layout explorer patch (likely reverted by a dsh upgrade).')
+      } else {
+        console.warn(`[dsh-plugin-workbench] ui-layout patch exited ${code}; the dsh version may have changed — run scripts/patch-layout.mjs manually.`)
+        layoutPatchScheduled = false
+      }
+    })
+  } catch (err) {
+    console.warn('[dsh-plugin-workbench] ui-layout patch check failed:', err)
+    layoutPatchScheduled = false
+  }
+}
+
 /**
  * One filesystem-backed RPC endpoint pair. Reads never mutate; `signal`
  * cancels the underlying fs call (or aborts between steps).
  */
 export function apply(ctx: Context): void {
+  // Re-apply the ui-layout explorer-column patch when a dsh upgrade reverted it.
+  ensureLayoutPatch()
   // Per-apply watch state: created here (not module-level) so disable/reload
   // cycles never leak watchers or SSE clients across applies.
   const watchState: WatchState = {
@@ -772,10 +852,22 @@ async function copyEntry(ctx: Context, payload: unknown, signal: AbortSignal): P
 // "open in system" gesture (`ctx.workspaces.openPath`).
 // ---------------------------------------------------------------------------
 
-/** Spawn one short-lived desktop command; resolves once the process launched. */
-function runDesktop(command: string, args: string[]): Promise<void> {
+/**
+ * Spawn one short-lived desktop command; resolves once the process launched.
+ *
+ * `windowsHide` defaults to true (no console flash for console-subsystem
+ * helpers). EXPLORER.EXE IS THE ONE EXCEPTION: spawning it with
+ * `windowsHide: true` sets CREATE_NO_WINDOW, and the new shell folder window
+ * is then created HIDDEN — the folder opens on screen but stays invisible, so
+ * the user sees "nothing happened". (Verified empirically: the CabinetWClass
+ * window exists with `visible=False`; dropping the flag makes it visible.)
+ * explorer.exe is a GUI-subsystem app, so `windowsHide: false` never flashes
+ * a console — pass false on every Windows explorer.exe spawn.
+ * @param args - argv (never a shell string).
+ */
+function runDesktop(command: string, args: string[], windowsHide = true): Promise<void> {
   return new Promise((resolve, reject) => {
-    const child = spawn(command, args, { detached: true, stdio: 'ignore', windowsHide: true })
+    const child = spawn(command, args, { detached: true, stdio: 'ignore', windowsHide })
     child.once('error', reject)
     child.once('spawn', () => {
       // The window stays after the harness exits; nothing to wait for.
@@ -808,8 +900,9 @@ async function revealNative(osPath: string, isDir: boolean, signal: AbortSignal)
   if (platform === 'win32') {
     // explorer returns exit code 1 when it opens a NEW window, so exit codes
     // carry no meaning; a clean spawn is success. Files are selected in their
-    // folder; folders are opened directly.
-    await runDesktop('explorer.exe', isDir ? [osPath] : ['/select,', osPath])
+    // folder; folders are opened directly. windowsHide MUST stay false for
+    // explorer.exe (see runDesktop doc: CREATE_NO_WINDOW hides the new window).
+    await runDesktop('explorer.exe', isDir ? [osPath] : ['/select,', osPath], false)
     return
   }
   if (platform === 'darwin') {
@@ -823,7 +916,7 @@ async function revealNative(osPath: string, isDir: boolean, signal: AbortSignal)
     if (env.WSL_DISTRO_NAME !== undefined || env.WSL_INTEROP !== undefined) {
       const windowsPath = (await execCapture('wslpath', ['-w', osPath])).replace(/[\r\n]+$/, '')
       if (windowsPath === '') throw new Error('wslpath returned no Windows path')
-      await runDesktop('explorer.exe', isDir ? [windowsPath] : ['/select,', windowsPath])
+      await runDesktop('explorer.exe', isDir ? [windowsPath] : ['/select,', windowsPath], false)
       return
     }
     // Desktop Linux: the default file manager opens folders; files open in