dsh-vscode-workbench 0.1.12 → 0.2.0

package/src/lsp.ts

@@ -0,0 +1,170 @@
+/** Host-side registry and process bridge for language servers exposed to the workbench editor. */
+import { spawn, type ChildProcess } from 'node:child_process'
+import { access, mkdir, rm } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { WorkbenchError } from './wire.ts'
+
+export type LspInstall = { kind: 'npm'; package: string; bin: string } | { kind: 'system'; command: string; hint: string }
+
+export interface LspDefinition {
+  id: string
+  name: string
+  /** Monaco language ids this server answers for. */
+  languages: string[]
+  install: LspInstall
+  args: string[]
+}
+
+/** The strongest maintained server for each language, installable where the ecosystem allows it. */
+export const LSP_SERVERS: readonly LspDefinition[] = [
+  { id: 'python', name: 'Python · Pyright', languages: ['python'], install: { kind: 'npm', package: 'pyright', bin: 'pyright-langserver' }, args: ['--stdio'] },
+  { id: 'php', name: 'PHP · Intelephense', languages: ['php'], install: { kind: 'npm', package: 'intelephense', bin: 'intelephense' }, args: ['--stdio'] },
+  { id: 'shell', name: 'Shell · Bash Language Server', languages: ['shell'], install: { kind: 'npm', package: 'bash-language-server', bin: 'bash-language-server' }, args: ['start'] },
+  { id: 'yaml', name: 'YAML · YAML Language Server', languages: ['yaml'], install: { kind: 'npm', package: 'yaml-language-server', bin: 'yaml-language-server' }, args: ['--stdio'] },
+  { id: 'json', name: 'JSON · VS Code JSON', languages: ['json'], install: { kind: 'npm', package: 'vscode-langservers-extracted', bin: 'vscode-json-language-server' }, args: ['--stdio'] },
+  { id: 'css', name: 'CSS / SCSS / Less · VS Code CSS', languages: ['css', 'scss', 'less'], install: { kind: 'npm', package: 'vscode-langservers-extracted', bin: 'vscode-css-language-server' }, args: ['--stdio'] },
+  { id: 'html', name: 'HTML · VS Code HTML', languages: ['html'], install: { kind: 'npm', package: 'vscode-langservers-extracted', bin: 'vscode-html-language-server' }, args: ['--stdio'] },
+  { id: 'dockerfile', name: 'Dockerfile · Docker LS', languages: ['dockerfile'], install: { kind: 'npm', package: 'dockerfile-language-server-nodejs', bin: 'dockerfile-language-server-nodejs' }, args: ['--stdio'] },
+  { id: 'go', name: 'Go · gopls', languages: ['go'], install: { kind: 'system', command: 'gopls', hint: '在终端运行：go install golang.org/x/tools/gopls@latest（需要 Go 工具链）' }, args: ['serve'] },
+  { id: 'rust', name: 'Rust · rust-analyzer', languages: ['rust'], install: { kind: 'system', command: 'rust-analyzer', hint: '运行：rustup component add rust-analyzer' }, args: [] },
+  { id: 'cpp', name: 'C / C++ · clangd', languages: ['c', 'cpp', 'objective-c'], install: { kind: 'system', command: 'clangd', hint: '安装 LLVM（Windows：winget install LLVM.LLVM），并确保 clangd 在 PATH 中' }, args: [] },
+  { id: 'java', name: 'Java · Eclipse JDT LS', languages: ['java'], install: { kind: 'system', command: 'jdtls', hint: '下载 eclipse.jdt.ls 并让 jdtls 启动脚本在 PATH 中' }, args: [] },
+  { id: 'csharp', name: 'C# · csharp-ls', languages: ['csharp'], install: { kind: 'system', command: 'csharp-ls', hint: '运行：dotnet tool install --global csharp-ls（需要 .NET SDK）' }, args: [] },
+  { id: 'lua', name: 'Lua · Lua Language Server', languages: ['lua'], install: { kind: 'system', command: 'lua-language-server', hint: '从 github.com/LuaLS/lua-language-server/releases 下载，并把 lua-language-server 加入 PATH' }, args: [] },
+] as const
+
+export interface LspStatus {
+  id: string
+  name: string
+  languages: string[]
+  installable: boolean
+  installed: boolean
+  hint?: string
+}
+
+/** Private install root so language servers never touch the user's global npm state. */
+export function lspRoot(): string { return join(homedir(), '.dsh', 'dsh-vscode-workbench', 'lsp') }
+
+function npmBinPath(id: string, bin: string): string {
+  const path = join(lspRoot(), id, 'node_modules', '.bin', bin)
+  return process.platform === 'win32' ? `${path}.cmd` : path
+}
+
+async function exists(path: string): Promise<boolean> { return access(path).then(() => true, () => false) }
+
+function which(command: string): Promise<string | undefined> {
+  return new Promise(resolve => {
+    const child = spawn(process.platform === 'win32' ? 'where' : 'which', [command], { windowsHide: true })
+    let output = ''
+    child.stdout.on('data', chunk => { output += String(chunk) })
+    child.on('error', () => resolve(undefined))
+    child.on('close', code => resolve(code === 0 ? output.split(/\r?\n/).map(line => line.trim()).find(Boolean) : undefined))
+  })
+}
+
+function definition(id: string): LspDefinition {
+  const found = LSP_SERVERS.find(server => server.id === id)
+  if (found === undefined) throw new WorkbenchError('lsp-unknown', `unknown language server: ${id}`, 404)
+  return found
+}
+
+async function commandFor(server: LspDefinition): Promise<{ command: string; shell: boolean } | undefined> {
+  if (server.install.kind === 'npm') {
+    const command = npmBinPath(server.id, server.install.bin)
+    return await exists(command) ? { command, shell: process.platform === 'win32' } : undefined
+  }
+  const command = await which(server.install.command)
+  return command === undefined ? undefined : { command, shell: process.platform === 'win32' }
+}
+
+export async function lspStatuses(): Promise<LspStatus[]> {
+  return Promise.all(LSP_SERVERS.map(async server => {
+    const resolved = await commandFor(server)
+    return {
+      id: server.id,
+      name: server.name,
+      languages: server.languages,
+      installable: server.install.kind === 'npm',
+      installed: resolved !== undefined,
+      ...(server.install.kind === 'system' ? { hint: server.install.hint } : {}),
+    }
+  }))
+}
+
+/** Install an npm-distributed server into the plugin's private directory. */
+export async function installLsp(id: string): Promise<void> {
+  const server = definition(id)
+  if (server.install.kind !== 'npm') throw new WorkbenchError('lsp-manual', server.install.hint, 409)
+  const directory = join(lspRoot(), id)
+  await mkdir(directory, { recursive: true })
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn('npm', ['install', '--prefix', directory, '--no-save', '--no-audit', '--no-fund', '--loglevel=error', server.install.kind === 'npm' ? server.install.package : ''], {
+      cwd: directory, shell: process.platform === 'win32', windowsHide: true,
+    })
+    let error = ''
+    child.stderr.on('data', chunk => { error = (error + String(chunk)).slice(-4000) })
+    const timer = setTimeout(() => { child.kill(); reject(new WorkbenchError('lsp-timeout', '语言服务器安装超时', 504)) }, 10 * 60 * 1000)
+    child.on('error', cause => { clearTimeout(timer); reject(new WorkbenchError('lsp-install', String(cause), 500)) })
+    child.on('close', code => {
+      clearTimeout(timer)
+      if (code === 0) resolve()
+      else reject(new WorkbenchError('lsp-install', error.trim() || `npm exited with ${code}`, 500))
+    })
+  })
+}
+
+export async function uninstallLsp(id: string): Promise<void> {
+  const server = definition(id)
+  if (server.install.kind !== 'npm') return
+  await rm(join(lspRoot(), id), { recursive: true, force: true })
+}
+
+/** Resolve the spawn command for a running server, or explain what the user must install. */
+export async function resolveLsp(id: string): Promise<{ command: string; shell: boolean; args: string[] }> {
+  const server = definition(id)
+  const resolved = await commandFor(server)
+  if (resolved === undefined) {
+    throw new WorkbenchError('lsp-missing', server.install.kind === 'system' ? server.install.hint : '语言服务器尚未安装', 409)
+  }
+  return { ...resolved, args: server.args }
+}
+
+/** Serialize a JSON-RPC message using the Language Server Protocol base framing. */
+export function frameLsp(message: unknown): string {
+  const body = JSON.stringify(message)
+  return `Content-Length: ${Buffer.byteLength(body, 'utf8')}\r\n\r\n${body}`
+}
+
+/** Incremental decoder for LSP frames arriving in arbitrary chunks. */
+export function lspFrameParser(onMessage: (message: unknown) => void): (chunk: Buffer) => void {
+  let buffer = Buffer.alloc(0)
+  return chunk => {
+    buffer = Buffer.concat([buffer, chunk])
+    for (;;) {
+      const headerEnd = buffer.indexOf('\r\n\r\n')
+      if (headerEnd < 0) return
+      const header = buffer.subarray(0, headerEnd).toString('ascii')
+      const length = /content-length:\s*(\d+)/i.exec(header)?.[1]
+      if (length === undefined) { buffer = buffer.subarray(headerEnd + 4); continue }
+      const size = Number(length)
+      if (buffer.length < headerEnd + 4 + size) return
+      const body = buffer.subarray(headerEnd + 4, headerEnd + 4 + size).toString('utf8')
+      buffer = buffer.subarray(headerEnd + 4 + size)
+      try { onMessage(JSON.parse(body)) } catch { /* ignore malformed frames from a misbehaving server */ }
+    }
+  }
+}
+
+/** Wire a spawned language server's stdio to JSON-RPC frames in both directions. */
+export function pipeLanguageServer(child: ChildProcess, handlers: { onMessage(message: unknown): void; onStderr?(text: string): void; onExit?(code: number | null): void }): { write(text: string): void; kill(): void } {
+  const parse = lspFrameParser(message => handlers.onMessage(message))
+  child.stdout?.on('data', chunk => parse(chunk as Buffer))
+  child.stderr?.on('data', chunk => handlers.onStderr?.(String(chunk)))
+  child.stdin?.on('error', () => undefined)
+  child.on('exit', code => handlers.onExit?.(code))
+  return {
+    write(text) { try { child.stdin?.write(frameLsp(JSON.parse(text))) } catch { /* ignore incomplete client frames */ } },
+    kill() { child.kill() },
+  }
+}

package/src/office.ts

@@ -0,0 +1,95 @@
+/** Convert Word and PowerPoint documents to PDF with a locally installed LibreOffice, like DSH's own preview. */
+import { execFile, spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { access, mkdir, rename, rm, stat } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { basename, extname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { promisify } from 'node:util'
+import { workspacePath } from './host.ts'
+import { WorkbenchError } from './wire.ts'
+
+const CONVERTIBLE = new Set(['.doc', '.docx', '.ppt', '.pptx', '.odt', '.odp', '.rtf'])
+
+/** True for extensions the Office preview routes through a PDF conversion. */
+export function isOfficeDocumentPath(path: string): boolean { return CONVERTIBLE.has(extname(path).toLowerCase()) }
+
+/** Whether a path is a document that can only be shown through the converter. */
+export function needsOfficeConversion(path: string): boolean {
+  const extension = extname(path).toLowerCase()
+  return extension === '.doc' || extension === '.docx' || extension === '.ppt' || extension === '.pptx' || extension === '.odt' || extension === '.odp' || extension === '.rtf'
+}
+
+/** Install guidance mirrors DSH: the preview never downloads an engine itself. */
+export const OFFICE_HINT = '未检测到 LibreOffice。安装 LibreOffice 后可像 DSH 官方预览一样把 Word / PowerPoint 转成 PDF 查看。'
+
+function candidates(): string[] {
+  const list = [process.env.DVW_SOFFICE]
+  if (process.platform === 'win32') {
+    list.push('soffice', 'C:\\Program Files\\LibreOffice\\program\\soffice.exe', 'C:\\Program Files (x86)\\LibreOffice\\program\\soffice.exe')
+  } else if (process.platform === 'darwin') {
+    list.push('soffice', '/Applications/LibreOffice.app/Contents/MacOS/soffice')
+  } else {
+    list.push('soffice', 'libreoffice', '/usr/bin/soffice', '/usr/bin/libreoffice', '/snap/bin/libreoffice')
+  }
+  return list.filter((value): value is string => typeof value === 'string' && value !== '')
+}
+
+function which(command: string): Promise<string | undefined> {
+  return new Promise(resolve => {
+    const child = spawn(process.platform === 'win32' ? 'where' : 'which', [command], { windowsHide: true })
+    let output = ''
+    child.stdout.on('data', chunk => { output += String(chunk) })
+    child.on('error', () => resolve(undefined))
+    child.on('close', code => resolve(code === 0 ? output.split(/\r?\n/).map(line => line.trim()).find(Boolean) : undefined))
+  })
+}
+
+async function exists(path: string): Promise<boolean> { return access(path).then(() => true, () => false) }
+
+let detected: { path?: string; checked: number } | undefined
+
+/** Locate LibreOffice without repeatedly probing the system for every open tab. */
+export async function findOfficeConverter(): Promise<string | undefined> {
+  if (detected !== undefined && Date.now() - detected.checked < 60_000) return detected.path
+  let found: string | undefined
+  for (const candidate of candidates()) {
+    if ((candidate.includes('/') || candidate.includes('\\')) && await exists(candidate)) { found = candidate; break }
+    const resolved = await which(candidate)
+    if (resolved !== undefined) { found = resolved; break }
+  }
+  detected = { path: found, checked: Date.now() }
+  return found
+}
+
+/** Availability payload for the settings and preview UI. */
+export async function officeStatus(): Promise<{ available: boolean; hint?: string }> {
+  const converter = await findOfficeConverter()
+  return converter === undefined ? { available: false, hint: OFFICE_HINT } : { available: true }
+}
+
+/** Convert one workspace document to a cached PDF and return its absolute path. */
+export async function officePdf(cwd: string, path: string): Promise<{ path: string }> {
+  if (!needsOfficeConversion(path)) throw new WorkbenchError('unsupported-media', 'file is not a Word or PowerPoint document', 415)
+  const source = await workspacePath(cwd, path)
+  const converter = await findOfficeConverter()
+  if (converter === undefined) throw new WorkbenchError('converter-missing', OFFICE_HINT, 503)
+  const info = await stat(source.absolute)
+  const root = join(tmpdir(), 'dsh-vscode-workbench-office')
+  const key = createHash('sha1').update(`${source.absolute}:${info.size}:${info.mtimeMs}`).digest('hex').slice(0, 20)
+  const target = join(root, `${key}.pdf`)
+  if (await exists(target)) return { path: target }
+  await mkdir(root, { recursive: true })
+  const output = join(root, `out-${key}`)
+  await mkdir(output, { recursive: true })
+  const profile = pathToFileURL(join(root, `profile-${key}-${process.pid}-${Date.now()}`)).href
+  try {
+    await promisify(execFile)(converter, ['--headless', '--norestore', '--invisible', '--convert-to', 'pdf', '--outdir', output, `-env:UserInstallation=${profile}`, source.absolute], { timeout: 120_000, windowsHide: true, maxBuffer: 4 * 1024 * 1024 })
+    const produced = join(output, `${basename(source.absolute, extname(source.absolute))}.pdf`)
+    if (!await exists(produced)) throw new WorkbenchError('converter-failed', 'LibreOffice 未能生成 PDF', 500)
+    await rename(produced, target)
+    return { path: target }
+  } finally {
+    await rm(output, { recursive: true, force: true }).catch(() => undefined)
+  }
+}

package/src/types.ts

@@ -8,6 +8,8 @@ export interface SearchMatch { path: string; line: number; column: number; previ
 export interface SearchRequest { query: string; caseSensitive?: boolean; wholeWord?: boolean; regex?: boolean; include?: string; exclude?: string }
 /** One working tree change. */
 export interface GitChange { path: string; originalPath?: string; index: string; worktree: string; staged: boolean; untracked: boolean }
+/** One local branch and the linked worktree that has it checked out. */
+export interface GitBranch { name: string; worktree?: string }
 /** Local repository state. */
 export interface GitStatus { repository: string; branch: string; ahead: number; behind: number; changes: GitChange[] }
 /** One commit displayed by the source-control graph. */

package/src/watch-ignore.ts

@@ -0,0 +1,84 @@
+/** Exclusion rules for the recursive workspace file watcher. */
+import { readFile } from 'node:fs/promises'
+import { isAbsolute, join, relative, sep } from 'node:path'
+
+/** Directory names skipped by default; large dependency and build trees exhaust inotify watches. */
+export const DEFAULT_WATCH_IGNORES = [
+  '.git', '.hg', '.svn',
+  'node_modules', 'bower_components', '.pnpm-store', '.yarn',
+  '.next', '.nuxt', '.turbo', '.vite', '.cache', 'coverage',
+  'vendor', 'third_party', 'third-party', 'third_part', 'third-part',
+  'build', 'dist', 'out', 'target',
+  '.venv', 'venv', '__pycache__', '.mypy_cache', '.pytest_cache', '.ruff_cache',
+  '.gradle', '.idea', '.vs', 'Pods',
+] as const
+
+function normalize(entry: string): string {
+  return entry.trim().replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '')
+}
+
+function segmentsOf(entry: string): string[] {
+  return normalize(entry).split('/').filter(part => part !== '' && part !== '.')
+}
+
+/** Parse a newline- or comma-separated exclusion list, dropping blanks, comments and unsafe paths. */
+export function parseWatchIgnores(value: string | null | undefined): string[] {
+  if (value === null || value === undefined) return []
+  const entries = new Set<string>()
+  for (const raw of value.split(/[\n,]+/)) {
+    const entry = normalize(raw)
+    const parts = segmentsOf(entry)
+    if (parts.length === 0 || parts.includes('..') || entry.startsWith('#')) continue
+    entries.add(parts.slice(0, 8).join('/').slice(0, 200))
+    if (entries.size >= 200) break
+  }
+  return [...entries]
+}
+
+/** Return true when a workspace-relative path contains one of the excluded segment sequences. */
+export function isIgnoredPath(relativePath: string, patterns: readonly string[]): boolean {
+  const segments = relativePath.split(/[\\/]+/).filter(Boolean).map(segment => segment.toLowerCase())
+  if (segments.length === 0) return false
+  for (const pattern of patterns) {
+    const parts = segmentsOf(pattern).map(part => part.toLowerCase())
+    if (parts.length === 0 || parts.includes('..')) continue
+    if (parts.length === 1) {
+      if (segments.includes(parts[0]!)) return true
+      continue
+    }
+    for (let index = 0; index + parts.length <= segments.length; index++) {
+      if (parts.every((part, offset) => segments[index + offset] === part)) return true
+    }
+  }
+  return false
+}
+
+/** Literal directory/path rules from a .gitignore; glob and negation rules are left to git itself. */
+export function parseGitIgnore(text: string): string[] {
+  const entries = new Set<string>()
+  for (const raw of text.split(/\r?\n/)) {
+    const line = raw.trim()
+    if (line === '' || line.startsWith('#') || line.startsWith('!') || /[*?[\]{}]/.test(line)) continue
+    const parts = segmentsOf(normalize(line).replace(/^\//, ''))
+    if (parts.length === 0 || parts.includes('..')) continue
+    entries.add(parts.slice(0, 8).join('/').slice(0, 200))
+    if (entries.size >= 200) break
+  }
+  return [...entries]
+}
+
+/** Ignore patterns derived from the workspace's root .gitignore, without asking the user to type exclusions. */
+export async function workspaceWatchIgnores(workspace: string): Promise<string[]> {
+  const text = await readFile(join(workspace, '.gitignore'), 'utf8').catch(() => '')
+  return parseGitIgnore(text)
+}
+
+/** Build a chokidar `ignored` predicate for one workspace and the user's extra exclusions. */
+export function watchIgnore(workspace: string, extra: readonly string[]): (path: string) => boolean {
+  const patterns = [...DEFAULT_WATCH_IGNORES, ...extra]
+  return (path: string) => {
+    const path_ = relative(workspace, path)
+    if (path_ === '' || path_.startsWith('..') || isAbsolute(path_)) return false
+    return isIgnoredPath(path_.split(sep).join('/'), patterns)
+  }
+}