dsh-plugin-workbench 0.0.5 → 0.0.7

package/src/client/locales.ts

@@ -11,22 +11,43 @@ export const zh = {
   'action.saveHint': 'Ctrl+S 保存',
   'action.wrapOn': '开启自动换行（显示层换行，不改文件）',
   'action.wrapOff': '关闭自动换行（长行横向滚动）',
+  'action.mdRender': '渲染预览（Markdown）',
+  'action.mdSource': '查看 Markdown 源码',
   'tab.close': '关闭标签页',
   'tab.collapse': '收起文件详情',
   'tab.expand': '弹出文件详情',
+  'tab.diskChanged': '文件已在磁盘上被修改，点击重新加载（会放弃未保存的编辑）',
   'menu.open': '打开预览',
   'menu.newFile': '新建文件',
   'menu.newFolder': '新建文件夹',
   'menu.rename': '重命名',
   'menu.delete': '删除',
   'menu.copyPath': '复制路径',
+  'menu.copy': '复制',
+  'menu.cut': '剪切',
+  'menu.paste': '粘贴',
   'menu.refresh': '刷新',
   'menu.openSystem': '在系统中打开',
+  'menu.revealInExplorer': '在资源管理器打开',
+  'menu.deleteSelected': '删除选中的 {count} 项',
+  'action.undo': '撤销（Ctrl+Z）',
+  'undo.copy': '复制「{name}」',
+  'undo.move': '移动「{name}」',
+  'undo.rename': '重命名「{name}」',
+  'undo.create': '新建「{name}」',
+  'undo.delete': '删除「{name}」',
+  'error.reveal': '在资源管理器打开失败',
   'prompt.newFileName': '新文件名',
   'prompt.newFolderName': '新文件夹名',
   'prompt.renameTo': '重命名为',
-  'confirm.deleteFile': '确定删除文件「{name}」吗？',
-  'confirm.deleteDir': '确定删除文件夹「{name}」及其全部内容吗？',
+  'confirm.deleteFile': '确定删除文件「{name}」吗？（可撤销）',
+  'confirm.deleteDir': '确定删除文件夹「{name}」及其全部内容吗？（可撤销）',
+  'confirm.deleteSelected': '确定删除选中的 {count} 项吗？{names}（可撤销）',
+  'confirm.overwrite': '「{name}」已存在，是否覆盖？',
+  'clipboard.copied': '已复制 {count} 项',
+  'clipboard.cut': '已剪切 {count} 项',
+  'clipboard.pasteHint': ' · Ctrl+V 粘贴到当前目录',
+  'clipboard.clear': '清除剪贴板',
   'preview.loading': '加载中…',
   'preview.binary': '二进制文件，无法预览',
   'preview.imageFailed': '图片加载失败',
@@ -34,6 +55,7 @@ export const zh = {
   'preview.emptyDir': '空目录',
   'preview.error': '加载失败',
   'preview.highlightOff': '大文件：已关闭语法高亮（仍可编辑）',
+  'preview.mdRenderOff': '大文件：已切换为源码视图（仍可编辑）',
 } as const
 
 export type FilesKey = keyof typeof zh
@@ -47,22 +69,43 @@ export const en: Record<FilesKey, string> = {
   'action.saveHint': 'Ctrl+S to save',
   'action.wrapOn': 'Enable word wrap (display only, file unchanged)',
   'action.wrapOff': 'Disable word wrap (long lines scroll horizontally)',
+  'action.mdRender': 'Rendered preview',
+  'action.mdSource': 'Show markdown source',
   'tab.close': 'Close tab',
   'tab.collapse': 'Collapse file details',
   'tab.expand': 'Expand file details',
+  'tab.diskChanged': 'File changed on disk — click to reload (discards unsaved edits)',
   'menu.open': 'Open preview',
   'menu.newFile': 'New File',
   'menu.newFolder': 'New Folder',
   'menu.rename': 'Rename',
   'menu.delete': 'Delete',
   'menu.copyPath': 'Copy Path',
+  'menu.copy': 'Copy',
+  'menu.cut': 'Cut',
+  'menu.paste': 'Paste',
   'menu.refresh': 'Refresh',
   'menu.openSystem': 'Open in System',
+  'menu.revealInExplorer': 'Reveal in Explorer',
+  'menu.deleteSelected': 'Delete {count} selected item(s)',
+  'action.undo': 'Undo (Ctrl+Z)',
+  'undo.copy': 'Copy "{name}"',
+  'undo.move': 'Move "{name}"',
+  'undo.rename': 'Rename "{name}"',
+  'undo.create': 'Create "{name}"',
+  'undo.delete': 'Delete "{name}"',
+  'error.reveal': 'Failed to reveal in Explorer',
   'prompt.newFileName': 'New file name',
   'prompt.newFolderName': 'New folder name',
   'prompt.renameTo': 'Rename to',
-  'confirm.deleteFile': 'Delete file "{name}"?',
-  'confirm.deleteDir': 'Delete folder "{name}" and all its contents?',
+  'confirm.deleteFile': 'Delete file "{name}"? (undoable)',
+  'confirm.deleteDir': 'Delete folder "{name}" and all its contents? (undoable)',
+  'confirm.deleteSelected': 'Delete {count} selected item(s)? {names} (undoable)',
+  'confirm.overwrite': '"{name}" already exists. Overwrite?',
+  'clipboard.copied': '{count} item(s) copied',
+  'clipboard.cut': '{count} item(s) cut',
+  'clipboard.pasteHint': ' · Ctrl+V to paste here',
+  'clipboard.clear': 'Clear clipboard',
   'preview.loading': 'Loading…',
   'preview.binary': 'Binary file, cannot preview',
   'preview.imageFailed': 'Failed to load image',
@@ -70,4 +113,5 @@ export const en: Record<FilesKey, string> = {
   'preview.emptyDir': 'Empty directory',
   'preview.error': 'Load failed',
   'preview.highlightOff': 'Large file: syntax highlighting off (still editable)',
+  'preview.mdRenderOff': 'Large file: source view (still editable)',
 }

package/src/client/markdown.ts

@@ -0,0 +1,69 @@
+/**
+ * Markdown rendering for the file preview.
+ *
+ * markdown-it with raw HTML disabled (escaped, never executed — same
+ * no-unsafe-HTML stance as every other preview in this plugin), linkified
+ * text, and fenced code blocks highlighted through the highlight.js languages
+ * registered in ./highlight. Relative image srcs are rewritten onto the
+ * plugin's raw-bytes route (the same one image tabs use), resolved against the
+ * markdown file's own directory, so README images render next to their file.
+ */
+import MarkdownIt from 'markdown-it'
+import { canHighlight, highlightFence } from './highlight'
+
+/** Same-origin raw-bytes route registered by the host half (see src/index.ts). */
+const RAW_PREFIX = '/dsh-plugin-files/raw'
+
+/** srcs that pass through unchanged: scheme URLs, anchors, protocol-relative. */
+const ABSOLUTE_SRC = /^(?:[a-z][a-z0-9+.-]*:|#|\/\/)/i
+
+const md = new MarkdownIt({
+  // Raw HTML in the source is escaped, never rendered (XSS containment).
+  html: false,
+  linkify: true,
+  typographer: true,
+  highlight: (code: string, lang: string): string => {
+    // Empty return lets markdown-it apply its own default escaping.
+    if (!canHighlight(lang)) return ''
+    return `<pre class="hljs"><code>${highlightFence(code, lang)}</code></pre>`
+  },
+})
+
+// Relative image srcs resolve against the md file's directory and are served
+// through the raw-bytes route; absolute URLs / data URIs pass through.
+const defaultImage = md.renderer.rules.image
+md.renderer.rules.image = (tokens, idx, options, env, self) => {
+  const token = tokens[idx]
+  const src = String(token.attrGet('src') ?? '')
+  const base = typeof env === 'object' && env !== null && typeof (env as { base?: unknown }).base === 'string'
+    ? (env as { base: string }).base
+    : ''
+  if (src !== '' && !ABSOLUTE_SRC.test(src) && base !== '') {
+    const resolved = base.endsWith('/') || base.endsWith('\\') ? base + src : `${base}/${src}`
+    token.attrSet('src', `${RAW_PREFIX}/${encodeURIComponent(resolved)}`)
+  }
+  return defaultImage(tokens, idx, options, env, self)
+}
+
+// markdown-it does not sanitize link protocols: a hostile .md file could carry
+// `[x](javascript:…)`. Follow markdown-it's default policy — reject the
+// vbscript/javascript/file/data schemes (data:image/* stays allowed so data-URI
+// images keep working); relative URLs pass through unchanged, and rejected
+// links render as inert text. Raw HTML is escaped above (html: false), so no
+// script/iframe can pass through either.
+const BAD_LINK_PROTOCOL = /^(?:vbscript|javascript|file|data):/i
+const GOOD_DATA_IMAGE = /^data:image\/(?:gif|png|jpeg|webp);/i
+md.validateLink = (url: string): boolean => {
+  const trimmed = url.trim()
+  return !BAD_LINK_PROTOCOL.test(trimmed) || GOOD_DATA_IMAGE.test(trimmed)
+}
+
+/**
+ * Render markdown content to safe HTML.
+ * @param content - raw markdown text.
+ * @param baseDir - directory of the source file, used to resolve relative
+ *   image paths ('' when there is none).
+ */
+export function renderMarkdown(content: string, baseDir: string): string {
+  return md.render(content, { base: baseDir })
+}

package/src/client/store.ts

@@ -10,10 +10,37 @@ import { useSyncExternalStore } from 'react'
 
 export type FeTheme = 'light' | 'dark'
 
+// ---------------------------------------------------------------------------
+// Undo history (Copy / Move / Rename / New / Delete)
+//
+// One stack PER WORKSPACE, mirroring the tabs: undoing in workspace B never
+// touches workspace A's file operations. Delete is reversible by design —
+// deleting RENAMES the item into a hidden `.dsh-trash` folder next to it, and
+// undo renames it back (no bytes are ever copied). When a stack overflows the
+// oldest entry is evicted; the caller permanently purges evicted delete
+// entries' trash items so the trash folder stays bounded.
+// ---------------------------------------------------------------------------
+
+/** How many operations each workspace remembers (older ones are dropped). */
+export const UNDO_LIMIT = 30
+
+export type UndoEntry =
+  /** copy/paste (duplicate) — undo removes the copy. */
+  | { kind: 'copy'; label: string; from: string; to: string; parent: string }
+  /** cut-paste or drag-move — undo renames the item back. */
+  | { kind: 'move'; label: string; from: string; to: string; parent: string }
+  /** rename — undo renames back. */
+  | { kind: 'rename'; label: string; from: string; to: string; parent: string }
+  /** new file / new folder — undo trashes it. */
+  | { kind: 'create'; label: string; path: string; parent: string }
+  /** delete (moved into .dsh-trash) — undo renames it back. */
+  | { kind: 'delete'; label: string; path: string; trash: string; parent: string }
+
 interface PerWorkspace {
   tabs: string[]
   active: string | undefined
   collapsed: boolean
+  undo: UndoEntry[]
 }
 
 export interface TabsStateView {
@@ -24,10 +51,13 @@ export interface TabsStateView {
   wrap: boolean
   theme: FeTheme
   cwd: string | undefined
+  /** Undoable file operations, most recent last. */
+  undo: UndoEntry[]
 }
 
 const EMPTY_TABS: string[] = []
-const EMPTY_WORKSPACE: PerWorkspace = { tabs: EMPTY_TABS, active: undefined, collapsed: false }
+const EMPTY_UNDO: UndoEntry[] = []
+const EMPTY_WORKSPACE: PerWorkspace = { tabs: EMPTY_TABS, active: undefined, collapsed: false, undo: EMPTY_UNDO }
 
 const WRAP_KEY = 'dsh-plugin-workbench:wrap'
 
@@ -51,7 +81,7 @@ interface StoreState {
 
 const initialWrap = storedWrap()
 let state: StoreState = { currentCwd: undefined, workspaces: {}, theme: 'dark', wrap: initialWrap }
-let view: TabsStateView = { tabs: EMPTY_TABS, active: undefined, collapsed: false, wrap: initialWrap, theme: 'dark', cwd: undefined }
+let view: TabsStateView = { tabs: EMPTY_TABS, active: undefined, collapsed: false, wrap: initialWrap, theme: 'dark', cwd: undefined, undo: EMPTY_UNDO }
 const listeners = new Set<() => void>()
 
 function workspaceOf(cwd: string | undefined): PerWorkspace {
@@ -83,6 +113,7 @@ function commit(next: StoreState): void {
     wrap: state.wrap,
     theme: state.theme,
     cwd: state.currentCwd,
+    undo: ws.undo,
   }
   if (
     nextView.tabs === view.tabs
@@ -91,6 +122,7 @@ function commit(next: StoreState): void {
     && nextView.wrap === view.wrap
     && nextView.theme === view.theme
     && nextView.cwd === view.cwd
+    && nextView.undo === view.undo
   ) return
   view = nextView
   for (const listener of [...listeners]) listener()
@@ -204,3 +236,101 @@ export function toggleWrap(): void {
   }
   commit({ ...state, wrap })
 }
+
+// ---------------------------------------------------------------------------
+// File clipboard (Copy / Cut + Paste)
+//
+// Lives OUTSIDE the per-workspace records on purpose: copying in workspace A
+// and pasting into workspace B is the whole point, so the clipboard survives
+// workspace switches. Cut keeps the sources alive until a paste moves them
+// (or Escape downgrades the cut back to a copy), mirroring the OS explorer.
+// ---------------------------------------------------------------------------
+
+export type ClipboardMode = 'copy' | 'cut'
+
+export interface ClipboardItem {
+  path: string
+  name: string
+  kind: 'file' | 'dir' | 'other'
+}
+
+export interface ClipboardView {
+  items: ClipboardItem[]
+  mode: ClipboardMode
+}
+
+const EMPTY_CLIPBOARD: ClipboardView = { items: [], mode: 'copy' }
+
+let clipboard: ClipboardView = EMPTY_CLIPBOARD
+const clipboardListeners = new Set<() => void>()
+
+export function getClipboard(): ClipboardView {
+  return clipboard
+}
+
+export function subscribeClipboard(listener: () => void): () => void {
+  clipboardListeners.add(listener)
+  return () => {
+    clipboardListeners.delete(listener)
+  }
+}
+
+/** Clipboard contents shared across every workspace (Explorer semantics). */
+export function useClipboard(): ClipboardView {
+  return useSyncExternalStore(subscribeClipboard, getClipboard)
+}
+
+function commitClipboard(next: ClipboardView): void {
+  if (next === clipboard) return
+  clipboard = next
+  for (const listener of [...clipboardListeners]) listener()
+}
+
+/** Put entries on the clipboard, replacing whatever was there. */
+export function copyToClipboard(items: ClipboardItem[], mode: ClipboardMode): void {
+  if (items.length === 0) return
+  commitClipboard({ items, mode })
+}
+
+/** Drop the clipboard contents (after a cut-paste, or via the clear button). */
+export function clearClipboard(): void {
+  if (clipboard === EMPTY_CLIPBOARD) return
+  commitClipboard(EMPTY_CLIPBOARD)
+}
+
+/** Escape in the source workspace: cancel an armed cut without dropping the items. */
+export function cancelCut(): void {
+  if (clipboard.mode === 'cut') commitClipboard({ ...clipboard, mode: 'copy' })
+}
+
+// ---------------------------------------------------------------------------
+// Undo stack (see the types at the top of this file)
+// ---------------------------------------------------------------------------
+
+/**
+ * Append an operation to the current workspace's undo stack, capped at
+ * UNDO_LIMIT entries. Returns the evicted oldest entry (the caller purges its
+ * trash item when it was a delete), or undefined when nothing was evicted.
+ */
+export function pushUndo(entry: UndoEntry): UndoEntry | undefined {
+  const cwd = state.currentCwd
+  if (cwd === undefined) return undefined
+  const prev = state.workspaces[cwd] ?? EMPTY_WORKSPACE
+  const undo = [...prev.undo, entry]
+  let evicted: UndoEntry | undefined
+  if (undo.length > UNDO_LIMIT) evicted = undo.shift()
+  commit({ ...state, workspaces: { ...state.workspaces, [cwd]: { ...prev, undo } } })
+  return evicted
+}
+
+/** Remove and return the current workspace's most recent operation (or undefined). */
+export function popUndo(): UndoEntry | undefined {
+  const cwd = state.currentCwd
+  if (cwd === undefined) return undefined
+  const prev = state.workspaces[cwd] ?? EMPTY_WORKSPACE
+  if (prev.undo.length === 0) return undefined
+  const undo = [...prev.undo]
+  const entry = undo.pop()
+  commit({ ...state, workspaces: { ...state.workspaces, [cwd]: { ...prev, undo } } })
+  return entry
+}