dsh-plugin-workbench 0.0.1

package/src/client/store.ts

@@ -0,0 +1,151 @@
+/**
+ * Module-local store shared by the explorer tree (FileExplorer) and the split
+ * preview (FilePreview). Tabs, active file, and collapsed state are kept
+ * PER WORKSPACE (keyed by the session cwd): switching workspaces swaps to that
+ * workspace's own set, and coming back restores it. Both components live in
+ * the same client bundle, so this store is a single instance across the two
+ * slot registrations.
+ */
+import { useSyncExternalStore } from 'react'
+
+export type FeTheme = 'light' | 'dark'
+
+interface PerWorkspace {
+  tabs: string[]
+  active: string | undefined
+  collapsed: boolean
+}
+
+export interface TabsStateView {
+  tabs: string[]
+  active: string | undefined
+  collapsed: boolean
+  theme: FeTheme
+  cwd: string | undefined
+}
+
+const EMPTY_TABS: string[] = []
+const EMPTY_WORKSPACE: PerWorkspace = { tabs: EMPTY_TABS, active: undefined, collapsed: false }
+
+interface StoreState {
+  currentCwd: string | undefined
+  workspaces: Record<string, PerWorkspace>
+  theme: FeTheme
+}
+
+let state: StoreState = { currentCwd: undefined, workspaces: {}, theme: 'dark' }
+let view: TabsStateView = { tabs: EMPTY_TABS, active: undefined, collapsed: false, theme: 'dark', cwd: undefined }
+const listeners = new Set<() => void>()
+
+function workspaceOf(cwd: string | undefined): PerWorkspace {
+  return cwd !== undefined ? state.workspaces[cwd] ?? EMPTY_WORKSPACE : EMPTY_WORKSPACE
+}
+
+export function getTabsState(): TabsStateView {
+  return view
+}
+
+export function subscribeTabs(listener: () => void): () => void {
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+  }
+}
+
+export function useTabsState(): TabsStateView {
+  return useSyncExternalStore(subscribeTabs, getTabsState)
+}
+
+function commit(next: StoreState): void {
+  state = next
+  const ws = workspaceOf(state.currentCwd)
+  const nextView: TabsStateView = {
+    tabs: ws.tabs,
+    active: ws.active,
+    collapsed: ws.collapsed,
+    theme: state.theme,
+    cwd: state.currentCwd,
+  }
+  if (
+    nextView.tabs === view.tabs
+    && nextView.active === view.active
+    && nextView.collapsed === view.collapsed
+    && nextView.theme === view.theme
+    && nextView.cwd === view.cwd
+  ) return
+  view = nextView
+  for (const listener of [...listeners]) listener()
+}
+
+/** Update the current workspace's record; no-op without a current workspace. */
+function updateCurrent(updater: (ws: PerWorkspace) => PerWorkspace): void {
+  const cwd = state.currentCwd
+  if (cwd === undefined) return
+  const prev = state.workspaces[cwd] ?? EMPTY_WORKSPACE
+  const next = updater(prev)
+  if (next === prev) return
+  commit({ ...state, workspaces: { ...state.workspaces, [cwd]: next } })
+}
+
+/** Point the store at a workspace (called when the session's cwd changes). */
+export function setCwd(cwd: string | undefined): void {
+  if (state.currentCwd === cwd) return
+  commit({ ...state, currentCwd: cwd })
+}
+
+/** Open a file in the current workspace's tabs (or activate it); pops the pane out. */
+export function openFile(path: string): void {
+  updateCurrent((ws) => {
+    if (ws.tabs.includes(path)) {
+      if (ws.active === path && !ws.collapsed) return ws
+      return { ...ws, active: path, collapsed: false }
+    }
+    return { ...ws, tabs: [...ws.tabs, path], active: path, collapsed: false }
+  })
+}
+
+/** Close one tab; if it was active, activate its neighbor. */
+export function closeFile(path: string): void {
+  updateCurrent((ws) => {
+    const index = ws.tabs.indexOf(path)
+    if (index < 0) return ws
+    const tabs = ws.tabs.filter((t) => t !== path)
+    let active = ws.active
+    if (active === path) active = tabs[Math.min(index, tabs.length - 1)]
+    return { ...ws, tabs, active }
+  })
+}
+
+/** Switch the active tab without re-reading. */
+export function activateFile(path: string): void {
+  updateCurrent((ws) => (ws.active === path || !ws.tabs.includes(path) ? ws : { ...ws, active: path }))
+}
+
+/** Move a tab before another tab (drag-to-reorder). */
+export function moveTab(dragged: string, target: string): void {
+  updateCurrent((ws) => {
+    if (dragged === target) return ws
+    const from = ws.tabs.indexOf(dragged)
+    const to = ws.tabs.indexOf(target)
+    if (from < 0 || to < 0) return ws
+    const tabs = [...ws.tabs]
+    tabs.splice(from, 1)
+    tabs.splice(to, 0, dragged)
+    return { ...ws, tabs }
+  })
+}
+
+/** Tuck the preview pane away, keeping all open tabs and their content. */
+export function collapsePreview(): void {
+  updateCurrent((ws) => (ws.collapsed ? ws : { ...ws, collapsed: true }))
+}
+
+/** Pop the preview pane back out, restoring the tabs as they were. */
+export function expandPreview(): void {
+  updateCurrent((ws) => (ws.collapsed ? { ...ws, collapsed: false } : ws))
+}
+
+/** Toggle the file-browser light/dark theme (applies to every workspace). */
+export function toggleTheme(): void {
+  commit({ ...state, theme: state.theme === 'dark' ? 'light' : 'dark' })
+}

package/src/dsh.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Local minimal type declarations for the members of the dsh runtime this
+ * plugin touches. tsdown does NOT type-check, so these are DX-only aids: the
+ * running service is the authority. Augmenting `@deepseek-ai/cordis`'s Context
+ * keeps the host/client sources free of the runtime's whole `.ts`-suffixed
+ * d.ts chain.
+ */
+
+declare module '@deepseek-ai/cordis' {
+  interface RpcOkShape {
+    ok: true
+    value: unknown
+  }
+  interface RpcErrShape {
+    ok: false
+    error: {
+      code: string
+      message: string
+      details: Record<string, unknown>
+    }
+  }
+  type RpcShape = RpcOkShape | RpcErrShape
+  type RpcHandler = (endpoint: string, payload: unknown, signal: AbortSignal) => Promise<RpcShape>
+
+  interface Context {
+    /** Register a lifecycle effect; the callback may return a disposer. */
+    effect(callback: () => void | (() => void), name?: string): void
+    connection: {
+      rpc: {
+        /** Browser-side unary call over a registered logical channel. */
+        call(channel: string, endpoint: string, payload: unknown, signal?: AbortSignal): Promise<RpcShape>
+        /** Host-side channel registration; returns an async disposer. */
+        handle(channel: string, handler: RpcHandler, options: { authority: 'loopback' | 'trusted-host' }): () => Promise<void>
+      }
+    }
+    slots: {
+      register(options: {
+        name?: string
+        locale?: string
+        children?: Record<string, unknown>
+        store?: unknown
+        inject?: (...args: unknown[]) => Record<string, unknown>
+        [key: string]: unknown
+      }, component: unknown): () => void
+      inject(key: string, callback: () => (() => void) | Iterable<() => void>): () => void
+    }
+    locale: {
+      register(ns: string, dicts: Record<string, Record<string, string>>): () => void
+    }
+    workspaces: {
+      openPath(path: string): Promise<void>
+    }
+    fs: {
+      resolve(path: string, opts?: { cwd?: string; signal?: AbortSignal }): Promise<{ targetKey: unknown; displayPath: string }>
+      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>
+      writeText(target: unknown, content: string, version?: unknown, signal?: AbortSignal, options?: { mode?: string; workspaceRoot?: string }): Promise<void>
+      processPath(target: unknown): string
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,203 @@
+/**
+ * Host half of the workbench plugin.
+ *
+ * Registers one loopback-only generic RPC channel (`/dsh-plugin-files`) with
+ * two endpoints, both implemented over `ctx.fs` (the sandboxed filesystem
+ * service). Reads pass through untouched in every sandbox mode, so this
+ * plugin only ever lists and reads — it never mutates the workspace.
+ */
+import type { Context } from '@deepseek-ai/cordis'
+
+export const name = 'dsh-plugin-workbench'
+export const inject = ['fs', 'connection']
+
+/** Loopback-only logical RPC channel. */
+export const CHANNEL = '/dsh-plugin-files'
+
+/** Files larger than this are never read for preview (client shows size + hint). */
+export const MAX_PREVIEW_BYTES = 512 * 1024
+
+export type FsKind = 'dir' | 'file' | 'other'
+
+export interface FsListEntry {
+  name: string
+  path: string
+  kind: FsKind
+  size?: number
+}
+
+export interface FsListResult {
+  root: string
+  entries: FsListEntry[]
+}
+
+export interface FsReadResult {
+  path: string
+  content: string
+  size: number
+  binary: boolean
+  truncated: boolean
+}
+
+export interface FsWriteResult {
+  path: string
+  size: number
+}
+
+export type FilesRpcOk = { ok: true; value: FsListResult | FsReadResult | FsWriteResult }
+export type FilesRpcErr = { ok: false; error: { code: 'internal'; message: string; details: Record<string, never> } }
+export type FilesRpcResult = FilesRpcOk | FilesRpcErr
+
+/**
+ * Raw `ctx.fs.listDir` row shape (loose — the real service is authoritative at
+ * runtime; these types only document the contract and keep the pure helpers
+ * testable without importing the whole runtime d.ts chain).
+ */
+export interface RawDirEntry {
+  name: string
+  type: 'file' | 'directory' | 'other'
+  target: unknown
+  size?: number
+}
+
+/** Map an fs entry type onto the wire `kind` union. */
+export function kindOf(type: string): FsKind {
+  if (type === 'directory') return 'dir'
+  if (type === 'file') return 'file'
+  return 'other'
+}
+
+/** Project a raw fs dir entry onto the wire-safe row shape. */
+export function mapDirEntry(entry: RawDirEntry, processPath: (target: unknown) => string): FsListEntry {
+  const kind = kindOf(entry.type)
+  return {
+    name: entry.name,
+    path: processPath(entry.target),
+    kind,
+    ...(kind === 'file' && entry.size !== undefined ? { size: entry.size } : {}),
+  }
+}
+
+/** Directories first, then case-insensitive name sort (numeric-aware). */
+export function sortEntries(entries: FsListEntry[]): FsListEntry[] {
+  return [...entries].sort((a, b) => {
+    const ad = a.kind === 'dir' ? 0 : 1
+    const bd = b.kind === 'dir' ? 0 : 1
+    if (ad !== bd) return ad - bd
+    return a.name.localeCompare(b.name, undefined, { sensitivity: 'base', numeric: true })
+  })
+}
+
+const FS_ERROR_MESSAGES: Record<string, string> = {
+  FS_NOT_FOUND: 'path does not exist',
+  FS_NOT_DIRECTORY: 'not a directory',
+  FS_NOT_REGULAR_FILE: 'not a regular file',
+  FS_NOT_TEXT: 'binary file',
+  FS_TOO_LARGE: 'file too large',
+  FS_PERMISSION_DENIED: 'permission denied',
+  FS_SANDBOX_DENIED: 'sandbox denied',
+  FS_ABORTED: 'aborted',
+  FS_IO_ERROR: 'io error',
+}
+
+/** Human-readable message for a thrown value, honoring the fs error code taxonomy. */
+export function mapError(error: unknown): string {
+  if (error instanceof Error) {
+    const code = (error as { code?: unknown }).code
+    if (typeof code === 'string' && FS_ERROR_MESSAGES[code] !== undefined) return FS_ERROR_MESSAGES[code]
+    return error.message
+  }
+  return String(error)
+}
+
+function isFsErrorCode(error: unknown, code: string): boolean {
+  return error instanceof Error && (error as { code?: unknown }).code === code
+}
+
+function fail(message: string): FilesRpcErr {
+  return { ok: false, error: { code: 'internal', message, details: {} } }
+}
+
+function pathOf(payload: unknown): string | undefined {
+  if (typeof payload === 'object' && payload !== null) {
+    const path = (payload as { path?: unknown }).path
+    if (typeof path === 'string' && path.trim().length > 0) return path
+  }
+  return undefined
+}
+
+/**
+ * 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 {
+  const handler = async (endpoint: string, payload: unknown, signal: AbortSignal): Promise<FilesRpcResult> => {
+    if (endpoint === 'list') return listDir(ctx, payload, signal)
+    if (endpoint === 'read') return readFile(ctx, payload, signal)
+    if (endpoint === 'write') return writeFile(ctx, payload, signal)
+    return fail(`unknown endpoint: ${endpoint}`)
+  }
+  ctx.connection.rpc.handle(CHANNEL, handler, { authority: 'loopback' })
+}
+
+async function listDir(ctx: Context, payload: unknown, signal: AbortSignal): Promise<FilesRpcResult> {
+  const path = pathOf(payload)
+  if (path === undefined) return fail('list: payload.path must be a non-empty string')
+  try {
+    const target = await ctx.fs.resolve(path, { signal })
+    const info = await ctx.fs.stat(target, signal)
+    if (info === undefined) return fail(`path not found: ${path}`)
+    if (info.type !== 'directory') return fail(`not a directory: ${path}`)
+    const raw = await ctx.fs.listDir(target, signal)
+    const entries = sortEntries(raw.map((entry) => mapDirEntry(entry, (t) => ctx.fs.processPath(t))))
+    return { ok: true, value: { root: ctx.fs.processPath(target), entries } }
+  } catch (error) {
+    return fail(mapError(error))
+  }
+}
+
+async function readFile(ctx: Context, payload: unknown, signal: AbortSignal): Promise<FilesRpcResult> {
+  const path = pathOf(payload)
+  if (path === undefined) return fail('read: payload.path must be a non-empty string')
+  try {
+    const target = await ctx.fs.resolve(path, { signal })
+    const info = await ctx.fs.stat(target, signal)
+    if (info === undefined) return fail(`path not found: ${path}`)
+    if (info.type !== 'file') return fail(`not a regular file: ${path}`)
+    const resolvedPath = ctx.fs.processPath(target)
+    const size = info.size ?? 0
+    if (size > MAX_PREVIEW_BYTES) {
+      return { ok: true, value: { path: resolvedPath, content: '', size, binary: false, truncated: true } }
+    }
+    try {
+      const content = await ctx.fs.readText(target, signal)
+      return { ok: true, value: { path: resolvedPath, content, size, binary: false, truncated: false } }
+    } catch (error) {
+      if (isFsErrorCode(error, 'FS_NOT_TEXT')) {
+        return { ok: true, value: { path: resolvedPath, content: '', size, binary: true, truncated: false } }
+      }
+      throw error
+    }
+  } catch (error) {
+    return fail(mapError(error))
+  }
+}
+
+async function writeFile(ctx: Context, payload: unknown, signal: AbortSignal): Promise<FilesRpcResult> {
+  const path = pathOf(payload)
+  const content = typeof payload === 'object' && payload !== null ? (payload as { content?: unknown }).content : undefined
+  if (path === undefined) return fail('write: payload.path must be a non-empty string')
+  if (typeof content !== 'string') return fail('write: payload.content must be a string')
+  try {
+    const target = await ctx.fs.resolve(path, { signal })
+    // Editing is an explicit user action over the loopback-only channel; run
+    // it unfenced (mirrors the /api write tools under danger-full-access).
+    await ctx.fs.writeText(target, content, undefined, signal, {
+      mode: 'danger-full-access',
+      workspaceRoot: ctx.fs.processPath(target),
+    })
+    return { ok: true, value: { path: ctx.fs.processPath(target), size: content.length } }
+  } catch (error) {
+    return fail(mapError(error))
+  }
+}