@civilization/dsh-workspace-files 0.2.0

package/src/files.ts

@@ -0,0 +1,126 @@
+import { promises as fs } from 'node:fs'
+import { join, relative, resolve } from 'node:path'
+
+export interface FileItem {
+  name: string
+  path: string          // relative to workspace root, e.g. "src/client/index.tsx"
+  isDirectory: boolean
+  size?: number
+  mtime?: number
+  children?: FileItem[]
+}
+
+export interface WorkspaceFilesResult {
+  root: string
+  items: FileItem[]
+  totalFiles: number
+  totalDirs: number
+}
+
+const DEFAULT_IGNORED_DIRS = new Set([
+  '.git',
+  '.svn',
+  '.hg',
+  'node_modules',
+  '.turbo',
+  '.next',
+  'dist',
+  'build',
+  '.pnpm-store',
+])
+
+function isWithin(parent: string, child: string): boolean {
+  const rel = relative(parent, child)
+  return !rel.startsWith('..') && !rel.includes(':')
+}
+
+export async function scanWorkspaceTree(
+  cwd: string,
+  options: { maxDepth?: number; showHidden?: boolean; showIgnored?: boolean } = {},
+): Promise<WorkspaceFilesResult> {
+  const root = resolve(cwd)
+  const maxDepth = options.maxDepth ?? 8
+  const showHidden = options.showHidden ?? false
+  const showIgnored = options.showIgnored ?? false
+
+  let totalFiles = 0
+  let totalDirs = 0
+
+  async function walk(dirPath: string, currentDepth: number): Promise<FileItem[]> {
+    if (currentDepth > maxDepth) return []
+
+    let dirents: import('node:fs').Dirent[]
+    try {
+      dirents = await fs.readdir(dirPath, { withFileTypes: true })
+    } catch {
+      return []
+    }
+
+    // Sort: directories first, then files alphabetically
+    dirents.sort((a, b) => {
+      if (a.isDirectory() && !b.isDirectory()) return -1
+      if (!a.isDirectory() && b.isDirectory()) return 1
+      return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: 'base' })
+    })
+
+    const items: FileItem[] = []
+
+    for (const ent of dirents) {
+      const name = ent.name
+
+      // Hidden file filter (starts with .)
+      if (!showHidden && name.startsWith('.') && name !== '.gitignore' && name !== '.env') {
+        if (!showIgnored) continue
+      }
+
+      // Ignored directory filter
+      if (!showIgnored && ent.isDirectory() && DEFAULT_IGNORED_DIRS.has(name)) {
+        continue
+      }
+
+      const fullPath = join(dirPath, name)
+      if (!isWithin(root, fullPath)) continue
+
+      const relPath = relative(root, fullPath).replace(/\\/g, '/')
+
+      if (ent.isDirectory()) {
+        totalDirs += 1
+        const children = await walk(fullPath, currentDepth + 1)
+        items.push({
+          name,
+          path: relPath,
+          isDirectory: true,
+          children,
+        })
+      } else {
+        totalFiles += 1
+        let size: number | undefined
+        let mtime: number | undefined
+        try {
+          const st = await fs.stat(fullPath)
+          size = st.size
+          mtime = st.mtimeMs
+        } catch {}
+
+        items.push({
+          name,
+          path: relPath,
+          isDirectory: false,
+          size,
+          mtime,
+        })
+      }
+    }
+
+    return items
+  }
+
+  const items = await walk(root, 1)
+
+  return {
+    root,
+    items,
+    totalFiles,
+    totalDirs,
+  }
+}

package/src/index.ts

@@ -0,0 +1,121 @@
+import type { Context } from '@deepseek-ai/cordis'
+import { scanWorkspaceTree } from './files.js'
+
+export const name = '@civilization/dsh-workspace-files'
+export const inject = ['webServer']
+
+async function readJsonBody(req: any): Promise<Record<string, any>> {
+  if (req.body && typeof req.body === 'object') {
+    return req.body
+  }
+  if (typeof req.body === 'string' && req.body.trim()) {
+    try {
+      return JSON.parse(req.body)
+    } catch {}
+  }
+  if (req.readableEnded || req.complete) {
+    return {}
+  }
+
+  return new Promise((resolve, reject) => {
+    let raw = ''
+    let timer: any = null
+
+    const cleanup = () => {
+      if (timer) clearTimeout(timer)
+      req.off?.('data', onData)
+      req.off?.('end', onEnd)
+      req.off?.('error', onError)
+    }
+
+    const onData = (chunk: Buffer) => { raw += chunk.toString('utf8') }
+    const onEnd = () => {
+      cleanup()
+      try {
+        resolve(raw ? JSON.parse(raw) : {})
+      } catch (err) {
+        reject(err)
+      }
+    }
+    const onError = (err: any) => {
+      cleanup()
+      reject(err)
+    }
+
+    req.on('data', onData)
+    req.on('end', onEnd)
+    req.on('error', onError)
+
+    timer = setTimeout(() => {
+      cleanup()
+      try {
+        resolve(raw ? JSON.parse(raw) : {})
+      } catch {
+        resolve({})
+      }
+    }, 1500)
+  })
+}
+
+function writeJson(res: any, status: number, body: any): void {
+  const data = JSON.stringify(body)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(data),
+  })
+  res.end(data)
+}
+
+function resolveCwd(ctx: Context, body: Record<string, any>): string {
+  if (body.cwd?.trim()) return body.cwd.trim()
+  if (body.root?.trim()) return body.root.trim()
+  if (body.sessionId) {
+    try {
+      const sessions = ctx.get('sessions' as any) as any
+      const session = sessions?.byId?.[body.sessionId]
+      if (session?.cwd) return session.cwd
+    } catch {}
+  }
+  return process.cwd()
+}
+
+export function apply(ctx: Context): void {
+  const webServer = (ctx as any).webServer
+  if (!webServer) return
+
+  const handleRpc = async (req: any, res: any, prefix: string) => {
+    if (req.method !== 'POST') {
+      writeJson(res, 405, { ok: false, error: { message: 'Method Not Allowed' } })
+      return
+    }
+
+    const pathname = new URL(req.url ?? '/', 'http://dsh.internal').pathname
+    const method = pathname.startsWith(prefix) ? pathname.slice(prefix.length) : undefined
+
+    if (method !== 'files.tree') {
+      writeJson(res, 404, { ok: false, error: { message: `Unknown method: ${method}` } })
+      return
+    }
+
+    try {
+      const body = await readJsonBody(req)
+      const cwd = resolveCwd(ctx, body)
+      const result = await scanWorkspaceTree(cwd, {
+        showHidden: Boolean(body.showHidden),
+        showIgnored: Boolean(body.showIgnored),
+        maxDepth: typeof body.maxDepth === 'number' ? body.maxDepth : 8,
+      })
+      writeJson(res, 200, { ok: true, value: result })
+    } catch (err: any) {
+      writeJson(res, 500, { ok: false, error: { message: err?.message || String(err) } })
+    }
+  }
+
+  // 注册 /dsh-workspace-files/api/ 前缀
+  ctx.effect(() => webServer.register({
+    kind: 'prefix',
+    path: '/dsh-workspace-files/api',
+    handler: (req: any, res: any) => handleRpc(req, res, '/dsh-workspace-files/api/'),
+  }), 'dsh-workspace-files: /dsh-workspace-files/api routes')
+}
+