dsh-vscode-workbench 0.1.12 → 0.2.0

package/src/client/typescriptProject.ts

@@ -0,0 +1,81 @@
+import { api } from './api.ts'
+
+type Monaco = typeof import('monaco-editor')
+
+/** Settings key for the TS/JS language support; nothing is indexed until the user installs it in settings. */
+export const TS_INTELLISENSE_KEY = 'dvw:lsp:typescript'
+
+export function tsIntellisenseEnabled(): boolean { try { return localStorage.getItem(TS_INTELLISENSE_KEY) === 'on' } catch { return false } }
+
+/** Model URI for a workspace file; must match MonacoEditor's `file:///<cwd>/<path>` tab URIs. */
+export function projectModelPath(cwd: string, path: string): string { return `file:///${`${cwd}/${path}`.replace(/\\/g, '/').replace(/^\/+/, '')}` }
+
+/** Workspace-relative path for a project model URI, or undefined when it lives outside `cwd`. */
+export function workspacePathFromModel(cwd: string, uri: string): string | undefined {
+  const prefix = projectModelPath(cwd, '')
+  const decoded = decodeURIComponent(uri)
+  const lower = (value: string) => value.toLowerCase()
+  if (!lower(decoded).startsWith(lower(prefix))) return undefined
+  const path = decoded.slice(prefix.length)
+  return path === '' ? undefined : path
+}
+
+const COMPILER = (monaco: Monaco) => ({
+  target: monaco.languages.typescript.ScriptTarget.ESNext,
+  module: monaco.languages.typescript.ModuleKind.ESNext,
+  moduleResolution: monaco.languages.typescript.ModuleResolutionKind.NodeJs,
+  jsx: monaco.languages.typescript.JsxEmit.ReactJSX,
+  allowJs: true, checkJs: false, allowNonTsExtensions: true, allowImportingTsExtensions: true,
+  esModuleInterop: true, resolveJsonModule: true, noEmit: true, skipLibCheck: true, strict: true,
+})
+
+let indexed: { cwd: string; uris: string[] } | undefined
+let request = 0
+
+/** Configure Monaco's TypeScript worker and load the workspace's TS/JS files so definitions, references, Peek and signature help resolve across files. */
+export async function indexTypeScriptProject(monaco: Monaco, sessionId: string, cwd: string): Promise<{ files: number; truncated: boolean }> {
+  const ts = monaco.languages.typescript
+  for (const defaults of [ts.typescriptDefaults, ts.javascriptDefaults]) {
+    defaults.setCompilerOptions(COMPILER(monaco))
+    defaults.setEagerModelSync(true)
+    // Unresolved package imports are expected without node_modules typings; keep only syntax errors.
+    defaults.setDiagnosticsOptions({ noSemanticValidation: true, noSyntaxValidation: false })
+  }
+  const id = ++request
+  const { files, truncated } = await api<{ files: { path: string; content: string }[]; truncated: boolean }>('project.sources', { sessionId })
+  if (id !== request) return { files: 0, truncated }
+  disposeTypeScriptProject(monaco)
+  const uris: string[] = []
+  for (const file of files) {
+    const uri = monaco.Uri.parse(projectModelPath(cwd, file.path))
+    // Open tabs own their model and draft; never overwrite them with the disk copy.
+    if (monaco.editor.getModel(uri) !== null) continue
+    monaco.editor.createModel(file.content, undefined, uri)
+    uris.push(uri.toString())
+  }
+  indexed = { cwd, uris }
+  return { files: files.length, truncated }
+}
+
+/** Drop the index models that no editor or tab is using. */
+export function disposeTypeScriptProject(monaco: Monaco): void {
+  if (indexed === undefined) return
+  for (const uri of indexed.uris) { const model = monaco.editor.getModel(monaco.Uri.parse(uri)); if (model !== null && !model.isAttachedToEditor()) model.dispose() }
+  indexed = undefined
+}
+
+/** True for models the project index created, which tab cleanup must keep. */
+export function isIndexedModel(uri: string): boolean { return indexed?.uris.includes(uri) ?? false }
+
+/** Refresh index models for files changed on disk, unless an editor is showing them. */
+export async function refreshIndexedFiles(monaco: Monaco, sessionId: string, cwd: string, paths: string[]): Promise<void> {
+  if (indexed === undefined || indexed.cwd !== cwd) return
+  for (const path of paths) {
+    const uri = monaco.Uri.parse(projectModelPath(cwd, path))
+    const model = monaco.editor.getModel(uri)
+    if (model === null || model.isAttachedToEditor() || !isIndexedModel(uri.toString())) continue
+    const document = await api<{ content: string }>('fs.read', { sessionId, path }).catch(() => undefined)
+    if (document === undefined) { model.dispose(); indexed.uris = indexed.uris.filter(value => value !== uri.toString()); continue }
+    if (model.getValue() !== document.content) model.setValue(document.content)
+  }
+}

package/src/context.ts

@@ -9,6 +9,14 @@ export interface WorkbenchWebServer {
 }
 export interface WorkbenchSessions { get(id: string): Session | undefined }
 export interface WorkbenchConnection { requestRejection(req: IncomingMessage): 401 | 403 | undefined }
+/** Minimal shape of DSH's host directory chooser; only the native capability is usable here. */
+export interface DirectoryPickerLike {
+  capability(): { kind: string; pick?(signal: AbortSignal): Promise<string | null> }
+}
+/** Minimal shape of DSH's durable workspace registry. */
+export interface WorkspaceRegistryLike {
+  create(path: string, title?: string): Promise<{ id: string; path: string; title: string }>
+}
 export type HostContext = CordisContext & {
   webServer: WorkbenchWebServer
   sessions: WorkbenchSessions

package/src/host.ts

@@ -1,11 +1,11 @@
 import { createHash, randomUUID } from 'node:crypto'
 import { spawn } from 'node:child_process'
 import { createRequire } from 'node:module'
-import { dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path'
+import { basename, dirname, extname, isAbsolute, join, normalize, relative, resolve, sep } from 'node:path'
 import { access, lstat, mkdir, open, readFile, readdir, realpath, rename, rm, stat } from 'node:fs/promises'
 import { constants } from 'node:fs'
 import type { HostContext } from './context.ts'
-import type { FileDocument, FileEntry, GitChange, GitCommit, GitCommitFile, GitDiff, GitStatus, SearchMatch, SearchRequest } from './types.ts'
+import type { FileDocument, FileEntry, GitBranch, GitChange, GitCommit, GitCommitFile, GitDiff, GitStatus, SearchMatch, SearchRequest } from './types.ts'
 import { WorkbenchError } from './wire.ts'
 
 const require = createRequire(import.meta.url)
@@ -50,6 +50,51 @@ function revision(content: Buffer, mtimeMs: number): string {
   return createHash('sha256').update(content).update(String(mtimeMs)).digest('hex')
 }
 
+const PROJECT_SOURCE = /\.(?:[cm]?[jt]sx?|d\.ts)$/i
+const PROJECT_CONFIG = new Set(['tsconfig.json', 'jsconfig.json', 'package.json'])
+const PROJECT_SKIP = new Set(['.git', 'node_modules', 'dist', 'build', 'out', 'coverage', '.next', '.nuxt', '.turbo', '.cache', 'vendor', 'third_party'])
+
+/** Add a folder picked in the OS chooser to DSH's workspace list, reusing an existing registration. */
+export async function openWorkspaceFromPicker(
+  picker: import('./context.ts').DirectoryPickerLike | undefined,
+  registry: import('./context.ts').WorkspaceRegistryLike | undefined,
+  signal: AbortSignal,
+): Promise<{ opened: boolean; workspace?: { id: string; path: string; title: string } }> {
+  if (picker === undefined) throw new WorkbenchError('picker-unavailable', '当前环境没有可用的文件夹选择器', 409)
+  const capability = picker.capability()
+  if (capability.kind !== 'native' || capability.pick === undefined) throw new WorkbenchError('picker-browse', '浏览器模式暂不支持从工作台选择文件夹，请使用 DSH 侧栏的「添加工作区」', 409)
+  const picked = await capability.pick(signal)
+  if (picked === null) return { opened: false }
+  if (registry === undefined) throw new WorkbenchError('workspace-unavailable', '工作区服务不可用', 503)
+  const workspace = await registry.create(picked)
+  return { opened: true, workspace: { id: workspace.id, path: workspace.path, title: workspace.title } }
+}
+
+/** TS/JS sources the editor's language service indexes, bounded so huge repos stay responsive. */
+export async function projectSources(cwd: string, limits: { files?: number; bytes?: number; fileBytes?: number } = {}): Promise<{ files: { path: string; content: string }[]; truncated: boolean }> {
+  const { files: maxFiles = 2000, bytes: maxBytes = 24 * 1024 * 1024, fileBytes = 512 * 1024 } = limits
+  const { root } = await workspacePath(cwd, '')
+  const files: { path: string; content: string }[] = []; let total = 0; let truncated = false
+  const queue = [root]
+  while (queue.length > 0) {
+    const directory = queue.shift()!
+    const entries = await readdir(directory, { withFileTypes: true }).catch(() => [])
+    entries.sort((a, b) => a.name.localeCompare(b.name))
+    for (const entry of entries) {
+      const full = join(directory, entry.name)
+      if (entry.isDirectory()) { if (!PROJECT_SKIP.has(entry.name) && !entry.name.startsWith('.')) queue.push(full); continue }
+      if (!entry.isFile() || !(PROJECT_SOURCE.test(entry.name) || PROJECT_CONFIG.has(entry.name))) continue
+      const info = await stat(full).catch(() => undefined)
+      if (info === undefined || info.size > fileBytes) continue
+      if (files.length >= maxFiles || total + info.size > maxBytes) { truncated = true; return { files, truncated } }
+      const content = await readFile(full, 'utf8').catch(() => undefined)
+      if (content === undefined) continue
+      total += info.size; files.push({ path: relativePath(root, full), content })
+    }
+  }
+  return { files, truncated }
+}
+
 export async function listFiles(cwd: string, path: string): Promise<FileEntry[]> {
   const { root, absolute } = await workspacePath(cwd, path)
   const values = await readdir(absolute, { withFileTypes: true })
@@ -154,12 +199,15 @@ export async function deleteEntry(cwd: string, path: string): Promise<void> {
 }
 
 const IMAGE_TYPES:Record<string,string>={'.avif':'image/avif','.bmp':'image/bmp','.gif':'image/gif','.ico':'image/x-icon','.jpeg':'image/jpeg','.jpg':'image/jpeg','.png':'image/png','.svg':'image/svg+xml','.webp':'image/webp'}
-const PREVIEW_TYPES:Record<string,string>={...IMAGE_TYPES,'.pdf':'application/pdf','.doc':'application/msword','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document','.odt':'application/vnd.oasis.opendocument.text'}
+const PREVIEW_TYPES:Record<string,string>={...IMAGE_TYPES,'.pdf':'application/pdf','.doc':'application/msword','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document','.odt':'application/vnd.oasis.opendocument.text','.xls':'application/vnd.ms-excel','.xlsx':'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet','.xlsm':'application/vnd.ms-excel.sheet.macroEnabled.12','.ods':'application/vnd.oasis.opendocument.spreadsheet','.pptx':'application/vnd.openxmlformats-officedocument.presentationml.presentation','.pptm':'application/vnd.ms-powerpoint.presentation.macroEnabled.12'}
 /** Resolve an image inside the workspace for protected browser preview. */
 export async function workspaceImage(cwd:string,path:string):Promise<{path:string;type:string}>{const resolved=await workspacePath(cwd,path);const type=IMAGE_TYPES[extname(resolved.absolute).toLowerCase()];if(type===undefined)throw new WorkbenchError('unsupported-media','file is not a supported image',415);return {path:resolved.absolute,type}}
 /** Resolve a supported preview file inside the workspace. */
 export async function workspacePreviewFile(cwd:string,path:string):Promise<{path:string;type:string}>{const resolved=await workspacePath(cwd,path);const type=PREVIEW_TYPES[extname(resolved.absolute).toLowerCase()];if(type===undefined)throw new WorkbenchError('unsupported-media','file is not a supported preview format',415);return {path:resolved.absolute,type}}
 
+/** Resolve a regular workspace file for drag-out downloads. */
+export async function workspaceDownloadFile(cwd:string,path:string):Promise<{path:string;name:string;size:number}>{const resolved=await workspacePath(cwd,path);const info=await stat(resolved.absolute);if(!info.isFile())throw new WorkbenchError('not-file','only files can be downloaded',400);return {path:resolved.absolute,name:basename(resolved.absolute),size:info.size}}
+
 /** Resolve the PDF.js worker shipped with this plugin's runtime dependency. */
 export function pdfWorkerAsset(): { path: string; type: string } {
   return { path: require.resolve('pdfjs-dist/legacy/build/pdf.worker.min.mjs'), type: 'text/javascript; charset=utf-8' }
@@ -199,7 +247,7 @@ export async function searchWorkspace(cwd: string, request: SearchRequest, signa
     const event = JSON.parse(line) as { type: string; data?: { path?: { text?: string }; lines?: { text?: string }; line_number?: number; submatches?: Array<{ start: number; end: number; match?: { text?: string } }> } }
     if (event.type !== 'match' || event.data?.path?.text === undefined || event.data.lines?.text === undefined) continue
     for (const hit of event.data.submatches ?? []) {
-      matches.push({ path: event.data.path.text.replace(/^\.\//, ''), line: event.data.line_number ?? 1, column: hit.start + 1, preview: event.data.lines.text.trimEnd(), match: hit.match?.text ?? '' })
+      matches.push({ path: event.data.path.text.replace(/\\/g, '/').replace(/^\.\//, ''), line: event.data.line_number ?? 1, column: hit.start + 1, preview: event.data.lines.text.trimEnd(), match: hit.match?.text ?? '' })
       if (matches.length >= 2000) return { matches, limited: true }
     }
   }
@@ -227,10 +275,14 @@ async function gitObject(repository: string, spec: string): Promise<string> {
   return result.code === 0 ? result.stdout : ''
 }
 
-async function commitFiles(repository: string, hash: string): Promise<GitCommitFile[]> {
+async function commitParent(repository: string, hash: string): Promise<string | undefined> {
   const parent=await run('git',['rev-parse','--verify',`${hash}^1`],repository)
-  const result = parent.code===0
-    ? await run('git',['diff','--name-status','-z','-M',parent.stdout.trim(),hash,'--'],repository)
+  return parent.code===0?parent.stdout.trim():undefined
+}
+
+async function commitFiles(repository: string, hash: string, parent: string | undefined): Promise<GitCommitFile[]> {
+  const result = parent!==undefined
+    ? await run('git',['diff','--name-status','-z','-M',parent,hash,'--'],repository)
     : await run('git', ['diff-tree', '--root', '--no-commit-id', '--name-status', '-r', '-z', '-M', hash], repository)
   if (result.code !== 0) throw new WorkbenchError('git-failed', result.stderr || result.stdout, 409)
   const tokens = result.stdout.split('\0').filter(Boolean); const files: GitCommitFile[] = []
@@ -291,6 +343,24 @@ export async function gitAction(cwd: string, action: string, path?: string, valu
     case 'commit': args = ['commit', '-m', value ?? '']; break
     case 'branch.create': args = ['switch', '-c', value ?? '']; break
     case 'branch.switch': args = ['switch', value ?? '']; break
+    case 'branch.list': {
+      const refs = await run('git', ['for-each-ref', '--format=%(refname:short)', 'refs/heads'], repository)
+      if (refs.code !== 0) throw new WorkbenchError('git-failed', refs.stderr, 500)
+      const worktrees = await run('git', ['worktree', 'list', '--porcelain'], repository)
+      const used = new Map<string, string>()
+      if (worktrees.code === 0) {
+        const same = (a: string, b: string) => normalize(a) === normalize(b) || process.platform === 'win32' && normalize(a).toLowerCase() === normalize(b).toLowerCase()
+        let worktree = ''
+        for (const line of worktrees.stdout.split('\n')) {
+          if (line.startsWith('worktree ')) worktree = line.slice('worktree '.length).trim()
+          else if (line.startsWith('branch refs/heads/')) {
+            const name = line.slice('branch refs/heads/'.length).trim()
+            if (name !== '' && !same(worktree, repository)) used.set(name, worktree)
+          }
+        }
+      }
+      return refs.stdout.split('\n').filter(Boolean).map(name => ({ name, ...(used.has(name) ? { worktree: used.get(name) } : {}) })) satisfies GitBranch[]
+    }
     case 'branches': {
       const result = await run('git', ['for-each-ref', '--format=%(refname:short)', 'refs/heads'], repository)
       if (result.code !== 0) throw new WorkbenchError('git-failed', result.stderr, 500)
@@ -312,17 +382,19 @@ export async function gitAction(cwd: string, action: string, path?: string, valu
       if (result.code !== 0) throw new WorkbenchError('git-failed', result.stderr || result.stdout, 409)
       return { diff: result.stdout, original: '', modified: result.stdout } satisfies GitDiff
     }
-    case 'commit.files': return commitFiles(repository, validateCommitHash(value))
+    case 'commit.files': { const hash=validateCommitHash(value); return commitFiles(repository, hash, await commitParent(repository, hash)) }
     case 'commit.file.diff': {
-      const hash=validateCommitHash(value);const target=validateGitPath(repository,path);const files=await commitFiles(repository,hash);const file=files.find(item=>item.path===target)
+      const hash=validateCommitHash(value);const target=validateGitPath(repository,path);const parent=await commitParent(repository,hash);const files=await commitFiles(repository,hash,parent);const file=files.find(item=>item.path===target)
       if (file===undefined) throw new WorkbenchError('not-found','file is not part of the commit',404)
-      const parent=await run('git',['rev-parse','--verify',`${hash}^1`],repository)
-      const shown=parent.code===0
-        ? await run('git',['diff','--no-ext-diff','--find-renames','--patch','--no-color',parent.stdout.trim(),hash,'--',file.previousPath??target,target],repository)
-        : await run('git',['show','--no-ext-diff','--find-renames','--format=','--patch','--no-color',hash,'--',file.previousPath??target,target],repository)
+      // Spawning git is slow on Windows, so the patch and both blobs are read concurrently.
+      const [shown,original,modified]=await Promise.all([
+        parent!==undefined
+          ? run('git',['diff','--no-ext-diff','--find-renames','--patch','--no-color',parent,hash,'--',file.previousPath??target,target],repository)
+          : run('git',['show','--no-ext-diff','--find-renames','--format=','--patch','--no-color',hash,'--',file.previousPath??target,target],repository),
+        file.status==='A'||parent===undefined?'':gitObject(repository,`${parent}:${file.previousPath??target}`),
+        file.status==='D'?'':gitObject(repository,`${hash}:${target}`),
+      ])
       if(shown.code!==0)throw new WorkbenchError('git-failed',shown.stderr||shown.stdout,409)
-      const original=file.status==='A'||parent.code!==0?'':await gitObject(repository,`${parent.stdout.trim()}:${file.previousPath??target}`)
-      const modified=file.status==='D'?'':await gitObject(repository,`${hash}:${target}`)
       return {diff:shown.stdout,original,modified} satisfies GitDiff
     }
     case 'diff': {
@@ -352,6 +424,12 @@ export function codiconAsset(): { path: string; type: string } {
   return { path: resolve(packageRoot, 'dist', 'codicon.ttf'), type: 'font/ttf' }
 }
 
+/** Browser build of SheetJS served as an asset so the client bundle stays free of Node builtins. */
+export function xlsxAsset(): { path: string; type: string } {
+  const packageRoot = dirname(require.resolve('xlsx/package.json'))
+  return { path: resolve(packageRoot, 'dist', 'xlsx.full.min.js'), type: 'text/javascript; charset=utf-8' }
+}
+
 export function monacoAsset(raw: string): { path: string; type: string } {
   const packageRoot = dirname(require.resolve('monaco-editor/package.json'))
   const path = resolve(packageRoot, 'min', raw)
@@ -360,3 +438,10 @@ export function monacoAsset(raw: string): { path: string; type: string } {
   const type = extname(path) === '.css' ? 'text/css' : extname(path) === '.js' ? 'text/javascript' : extname(path) === '.ttf' ? 'font/ttf' : 'application/octet-stream'
   return { path, type }
 }
+
+/** Resolve a vscode-icons SVG shipped by @vscode-icons/vscode-icons-api. */
+export function fileIconAsset(raw: string): { path: string; type: string } {
+  if (!/^[a-z0-9_-]+\.svg$/i.test(raw)) throw new WorkbenchError('asset-invalid', 'invalid file icon path', 403)
+  const packageRoot = dirname(require.resolve('@vscode-icons/vscode-icons-api/package.json'))
+  return { path: resolve(packageRoot, 'icons', raw), type: 'image/svg+xml' }
+}

package/src/index.ts

@@ -1,19 +1,28 @@
 /** DSH host plugin for the VS Code workbench. */
-import { readFile } from 'node:fs/promises'
+import { createReadStream } from 'node:fs'
+import { readFile, stat } from 'node:fs/promises'
 import type { IncomingMessage } from 'node:http'
 import { isAbsolute, relative, sep } from 'node:path'
 import type { Duplex } from 'node:stream'
+import { spawn } from 'node:child_process'
 import chokidar from 'chokidar'
 import { WebSocket, WebSocketServer } from 'ws'
 import type { HostContext } from './context.ts'
-import { codiconAsset, createEntry, cwdFor, deleteEntry, gitAction, gitStatus, listFiles, monacoAsset, pdfWorkerAsset, readDocument, renameEntry, saveDocument, searchWorkspace, uploadFile, workspacePreviewFile } from './host.ts'
+import { codiconAsset, createEntry, cwdFor, deleteEntry, fileIconAsset, gitAction, gitStatus, listFiles, monacoAsset, openWorkspaceFromPicker, pdfWorkerAsset, xlsxAsset, readDocument, projectSources, renameEntry, saveDocument, workspaceDownloadFile, searchWorkspace, uploadFile, workspacePreviewFile } from './host.ts'
+import { installLsp, lspStatuses, resolveLsp, uninstallLsp, pipeLanguageServer } from './lsp.ts'
+import { officePdf, officeStatus } from './office.ts'
 import { installTerminal } from './terminal.ts'
 import type { SearchRequest } from './types.ts'
+import { watchIgnore, workspaceWatchIgnores } from './watch-ignore.ts'
 import { readBinaryBody, readBody, send, sendError, stringField, authorize, WorkbenchError } from './wire.ts'
 
 export { WorkbenchError } from './wire.ts'
 export * from './types.ts'
 export const name = 'dsh-vscode-workbench'
+
+// DSH services used by the workbench when present; resolved through optional injection, never a hard dependency.
+let dshDirectoryPicker: import('./context.ts').DirectoryPickerLike | undefined
+let dshWorkspaceRegistry: import('./context.ts').WorkspaceRegistryLike | undefined
 export const inject = ['webServer', 'sessions', 'connection', 'workingDirectory']
 
 async function dispatch(ctx: HostContext, method: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
@@ -26,6 +35,12 @@ async function dispatch(ctx: HostContext, method: string, body: Record<string, u
     case 'fs.create': return createEntry(cwd, stringField(body, 'path'), body.kind === 'directory' ? 'directory' : 'file').then(() => ({ ok: true }))
     case 'fs.rename': return renameEntry(cwd, stringField(body, 'path'), stringField(body, 'nextPath')).then(() => ({ ok: true }))
     case 'fs.delete': return deleteEntry(cwd, stringField(body, 'path')).then(() => ({ ok: true }))
+    case 'project.sources': return projectSources(cwd)
+    case 'office.status': return officeStatus()
+    case 'workspace.open': return openWorkspaceFromPicker(dshDirectoryPicker, dshWorkspaceRegistry, AbortSignal.timeout(10 * 60 * 1000))
+    case 'lsp.status': return lspStatuses()
+    case 'lsp.install': await installLsp(stringField(body, 'id')); return lspStatuses()
+    case 'lsp.uninstall': await uninstallLsp(stringField(body, 'id')); return lspStatuses()
     case 'search': return searchWorkspace(cwd, body as unknown as SearchRequest, signal)
     case 'git.status': return gitStatus(cwd)
     case 'git.action': return gitAction(cwd, stringField(body, 'action'), typeof body.path === 'string' ? body.path : undefined, typeof body.value === 'string' ? body.value : undefined)
@@ -34,6 +49,17 @@ async function dispatch(ctx: HostContext, method: string, body: Record<string, u
 }
 
 export function apply(ctx: HostContext): void {
+  ctx.effect(() => {
+    if (typeof ctx.inject !== 'function') return
+    // Optional injection: the callback runs once both services are active, and never if a profile omits them.
+    const fiber = ctx.inject(['directoryPicker', 'workspaceRegistry'], (child) => {
+      const services = child as unknown as { directoryPicker: import('./context.ts').DirectoryPickerLike; workspaceRegistry: import('./context.ts').WorkspaceRegistryLike }
+      dshDirectoryPicker = services.directoryPicker
+      dshWorkspaceRegistry = services.workspaceRegistry
+      return () => { dshDirectoryPicker = undefined; dshWorkspaceRegistry = undefined }
+    })
+    return () => { void fiber.dispose?.() }
+  }, 'dsh-vscode-workbench: optional DSH services')
   installTerminal(ctx)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-vscode/codicons/codicon.ttf', handler: async (req, res) => {
@@ -46,6 +72,29 @@ export function apply(ctx: HostContext): void {
     },
   }), 'dsh-vscode-workbench: Codicon font')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact', path: '/dsh-vscode/xlsx.js', handler: async (req, res) => {
+      if (!authorize(req, res, ctx.connection)) return
+      try {
+        const asset = xlsxAsset()
+        res.writeHead(200, { 'content-type': asset.type, 'cache-control': 'public, max-age=31536000, immutable' })
+        res.end(await readFile(asset.path))
+      } catch (error) { sendError(res, error) }
+    },
+  }), 'dsh-vscode-workbench: SheetJS asset')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix', path: '/dsh-vscode/file-icons', handler: async (req, res) => {
+      if (!authorize(req, res, ctx.connection)) return
+      try {
+        const raw = decodeURIComponent(new URL(req.url ?? '/', 'http://dsh.local').pathname.slice('/dsh-vscode/file-icons/'.length))
+        const asset = fileIconAsset(raw)
+        res.writeHead(200, { 'content-type': asset.type, 'cache-control': 'public, max-age=31536000, immutable' })
+        res.end(await readFile(asset.path))
+      } catch (error) { sendError(res, error) }
+    },
+  }), 'dsh-vscode-workbench: file icons')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-vscode/pdfjs/worker.mjs', handler: async (req, res) => {
       if (!authorize(req, res, ctx.connection)) return
@@ -88,6 +137,26 @@ export function apply(ctx: HostContext): void {
     kind:'prefix',path:'/dsh-vscode/file',handler:async(req,res)=>{if(!authorize(req,res,ctx.connection))return;try{const url=new URL(req.url??'/','http://dsh.local');const sessionId=url.searchParams.get('sessionId');const path=url.searchParams.get('path');if(sessionId===null||path===null)throw new WorkbenchError('bad-request','sessionId and path are required');const asset=await workspacePreviewFile(cwdFor(ctx,sessionId),path);res.writeHead(200,{'content-type':asset.type,'x-content-type-options':'nosniff','cache-control':'no-store'});res.end(await readFile(asset.path))}catch(error){sendError(res,error)}}
   }), 'dsh-vscode-workbench: file preview')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind:'exact',path:'/dsh-vscode/download',handler:async(req,res)=>{if(!authorize(req,res,ctx.connection))return;try{const url=new URL(req.url??'/','http://dsh.local');const sessionId=url.searchParams.get('sessionId');const path=url.searchParams.get('path');if(sessionId===null||path===null)throw new WorkbenchError('bad-request','sessionId and path are required');const file=await workspaceDownloadFile(cwdFor(ctx,sessionId),path);res.writeHead(200,{'content-type':'application/octet-stream','content-length':file.size,'content-disposition':`attachment; filename*=UTF-8''${encodeURIComponent(file.name)}`,'x-content-type-options':'nosniff','cache-control':'no-store'});createReadStream(file.path).on('error',error=>res.destroy(error)).pipe(res)}catch(error){sendError(res,error)}}
+  }), 'dsh-vscode-workbench: file download')
+
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact', path: '/dsh-vscode/office', handler: async (req, res) => {
+      if (!authorize(req, res, ctx.connection)) return
+      try {
+        const url = new URL(req.url ?? '/', 'http://dsh.local')
+        const sessionId = url.searchParams.get('sessionId'); const path = url.searchParams.get('path')
+        if (sessionId === null || path === null) throw new WorkbenchError('bad-request', 'sessionId and path are required')
+        const pdf = await officePdf(cwdFor(ctx, sessionId), path)
+        const info = await stat(pdf.path)
+        res.writeHead(200, { 'content-type': 'application/pdf', 'content-length': info.size, 'x-content-type-options': 'nosniff', 'cache-control': 'no-store' })
+        createReadStream(pdf.path).on('error', error => res.destroy(error)).pipe(res)
+      } catch (error) { sendError(res, error) }
+    },
+  }), 'dsh-vscode-workbench: office preview')
+  
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix', path: '/dsh-vscode/monaco', handler: async (req, res) => {
       if (!authorize(req, res, ctx.connection)) return
@@ -105,23 +174,65 @@ export function apply(ctx: HostContext): void {
     path: '/dsh-vscode/ws/files', handler(req, socket, head) {
       if (ctx.connection.requestRejection(req) !== undefined) { socket.destroy(); return }
       wss.handleUpgrade(req as IncomingMessage, socket as Duplex, head, (ws) => {
-        const sessionId = new URL(req.url ?? '/', 'http://dsh.local').searchParams.get('sessionId')
+        const search = new URL(req.url ?? '/', 'http://dsh.local').searchParams
+        const sessionId = search.get('sessionId')
         if (sessionId === null) { ws.close(1008, 'sessionId required'); return }
         let workspace: string
         try { workspace = cwdFor(ctx, sessionId) }
         catch { ws.close(1008, 'session workspace unavailable'); return }
-        const watcher = chokidar.watch(workspace, { ignoreInitial: true, ignored: /(^|[/\\])(\.git|node_modules|\.next|\.nuxt|\.turbo|\.vite|coverage)([/\\]|$)/, awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 25 } })
-        let paths = new Set<string>(); let timer: ReturnType<typeof setTimeout> | undefined
-        watcher.on('all', (_event, path) => {
-          const changed = isAbsolute(path) ? relative(workspace, path) : path
-          paths.add(changed.split(sep).join('/')); clearTimeout(timer); timer = setTimeout(() => {
-            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'files.changed', paths: [...paths] }))
-            paths = new Set()
-          }, 150)
+        let watcher: ReturnType<typeof chokidar.watch> | undefined; let paths = new Set<string>(); let timer: ReturnType<typeof setTimeout> | undefined
+        // Exclusions come from the workspace's .gitignore plus the built-in dependency/build trees.
+        void workspaceWatchIgnores(workspace).then(extra => {
+          const instance = watcher = chokidar.watch(workspace, { ignoreInitial: true, ignored: watchIgnore(workspace, extra), awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 25 } })
+          instance.on('error', error => {
+            console.warn('[dsh-vscode-workbench] file watcher stopped:', error)
+            if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'files.watch-error', message: String(error) }))
+            void instance.close()
+          })
+          instance.on('all', (_event, path) => {
+            const changed = isAbsolute(path) ? relative(workspace, path) : path
+            paths.add(changed.split(sep).join('/')); clearTimeout(timer); timer = setTimeout(() => {
+              if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify({ type: 'files.changed', paths: [...paths] }))
+              paths = new Set()
+            }, 150)
+          })
         })
-        ws.on('close', () => { clearTimeout(timer); void watcher.close() })
+        ws.on('close', () => { clearTimeout(timer); void watcher?.close() })
       })
     },
   }), 'dsh-vscode-workbench: file watcher')
+
+  const lspWss = new WebSocketServer({ noServer: true })
+  ctx.effect(() => ctx.webServer.registerUpgrade({
+    path: '/dsh-vscode/ws/lsp', handler(req, socket, head) {
+      if (ctx.connection.requestRejection(req) !== undefined) { socket.destroy(); return }
+      lspWss.handleUpgrade(req as IncomingMessage, socket as Duplex, head, (ws) => {
+        const search = new URL(req.url ?? '/', 'http://dsh.local').searchParams
+        const sessionId = search.get('sessionId'); const serverId = search.get('server')
+        if (sessionId === null || serverId === null) { ws.close(1008, 'sessionId and server required'); return }
+        let workspace: string
+        try { workspace = cwdFor(ctx, sessionId) }
+        catch { ws.close(1008, 'session workspace unavailable'); return }
+        void (async () => {
+          try {
+            const server = await resolveLsp(serverId)
+            const child = spawn(server.command, server.args, { cwd: workspace, stdio: ['pipe', 'pipe', 'pipe'], shell: server.shell, windowsHide: true })
+            const bridge = pipeLanguageServer(child, {
+              onMessage: message => { if (ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message)) },
+              onStderr: text => console.warn('[dsh-vscode-workbench] lsp:', text.trim().slice(0, 500)),
+              onExit: code => { if (ws.readyState === WebSocket.OPEN) ws.close(1000, `server exited ${code ?? ''}`.trim()) },
+            })
+            ws.on('message', data => bridge.write(String(data)))
+            ws.on('close', () => bridge.kill())
+            ws.on('error', () => bridge.kill())
+            child.on('error', error => { if (ws.readyState === WebSocket.OPEN) ws.close(1011, String(error).slice(0, 120)) })
+          } catch (error) {
+            ws.close(1008, (error instanceof Error ? error.message : 'language server unavailable').slice(0, 120))
+          }
+        })()
+      })
+    },
+  }), 'dsh-vscode-workbench: language server bridge')
+  ctx.effect(() => () => { lspWss.close() }, 'dsh-vscode-workbench: language server teardown')
   ctx.effect(() => () => { wss.close() }, 'dsh-vscode-workbench: watcher teardown')
 }