dsh-plugin-workbench 0.0.4 → 0.0.6

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()
@@ -140,6 +172,31 @@ export function activateFile(path: string): void {
   updateCurrent((ws) => (ws.active === path || !ws.tabs.includes(path) ? ws : { ...ws, active: path }))
 }
 
+/** Point any open tab at a new path after a rename (the disk path changed). */
+export function retargetFile(oldPath: string, newPath: string): void {
+  updateCurrent((ws) => {
+    if (!ws.tabs.includes(oldPath)) return ws
+    const tabs = ws.tabs.map((t) => (t === oldPath ? newPath : t))
+    return { ...ws, tabs, active: ws.active === oldPath ? newPath : ws.active }
+  })
+}
+
+/** Close every open tab at or under a path (used after deleting it). */
+export function closeFilesUnder(path: string): void {
+  updateCurrent((ws) => {
+    const sep = path.includes('\\') ? '\\' : '/'
+    const prefix = path.endsWith('\\') || path.endsWith('/') ? path : path + sep
+    const kept = ws.tabs.filter((t) => t !== path && !t.startsWith(prefix))
+    if (kept.length === ws.tabs.length) return ws
+    let active = ws.active
+    if (active !== undefined && (active === path || active.startsWith(prefix))) {
+      const index = ws.tabs.indexOf(active)
+      active = kept[Math.min(index, kept.length - 1)]
+    }
+    return { ...ws, tabs: kept, active }
+  })
+}
+
 /** Move a tab before another tab (drag-to-reorder). */
 export function moveTab(dragged: string, target: string): void {
   updateCurrent((ws) => {
@@ -179,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
+}

package/src/dsh.d.ts

@@ -55,8 +55,17 @@ declare module '@deepseek-ai/cordis' {
       stat(target: unknown, signal?: AbortSignal): Promise<{ version: unknown; type: 'file' | 'directory' | 'other'; size?: number } | undefined>
       listDir(target: unknown, signal?: AbortSignal): Promise<Array<{ name: string; type: 'file' | 'directory' | 'other'; target: unknown; version?: unknown; size?: number }>>
       readText(target: unknown, signal?: AbortSignal): Promise<string>
+      readBytes(target: unknown, signal: AbortSignal | undefined, maxBytes: number): Promise<Uint8Array>
       writeText(target: unknown, content: string, version?: unknown, signal?: AbortSignal, options?: { mode?: string; workspaceRoot?: string }): Promise<void>
       processPath(target: unknown): string
     }
+    webServer: {
+      /** Register a named HTTP route (exact path or prefix). Returns the disposer. */
+      register(route: {
+        kind: 'exact' | 'prefix'
+        path: string
+        handler: (req: import('node:http').IncomingMessage, res: import('node:http').ServerResponse) => void | Promise<void>
+      }): () => void
+    }
   }
 }