sillyspec 3.8.4 → 3.8.6

package/packages/dashboard/server/index.js

@@ -1,12 +1,11 @@
 import { createServer } from 'http'
 import { WebSocketServer } from 'ws'
-import { existsSync, readFileSync, readdirSync, realpathSync, watch } from 'fs'
-import { join, dirname, basename, sep, resolve } from 'path'
+import { existsSync, readFileSync } from 'fs'
+import { join, dirname } from 'path'
 import { fileURLToPath } from 'url'
-import { homedir } from 'os'
 import open from 'open'
-import { parseProjectState, parseDocsTree, parseProjectOverview, parseGitDetail, parseTechStackDetail, parseDocsList } from './parser.js'
-import { startWatcher, stopWatcher, addCustomScanPath, removeCustomScanPath, getCustomScanPaths, customScanPaths } from './watcher.js'
+import { parseProjectState } from './parser.js'
+import { startWatcher, stopWatcher } from './watcher.js'
 import { executeCommand } from './executor.js'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
@@ -15,44 +14,6 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 let wss = null
 const activeProcesses = new Map()
 
-// Progress file watchers: projectPath -> { watcher, timer, refCount }
-const progressWatchers = new Map()
-
-function startProgressWatch(projectPath) {
-  if (progressWatchers.has(projectPath)) {
-    progressWatchers.get(projectPath).refCount++
-    return
-  }
-  const progressFile = join(projectPath, '.sillyspec', '.runtime', 'progress.json')
-  if (!existsSync(progressFile)) return
-
-  let timer = null
-  try {
-    const watcher = watch(progressFile, (eventType) => {
-      if (timer) clearTimeout(timer)
-      timer = setTimeout(() => {
-        timer = null
-        try {
-          const state = parseProjectState(projectPath)
-          broadcast({ type: 'project:update', data: { path: projectPath, state } })
-        } catch {}
-      }, 200)
-    })
-    progressWatchers.set(projectPath, { watcher, timer, refCount: 1 })
-  } catch {}
-}
-
-function stopProgressWatch(projectPath) {
-  const entry = progressWatchers.get(projectPath)
-  if (!entry) return
-  entry.refCount--
-  if (entry.refCount <= 0) {
-    entry.watcher.close()
-    if (entry.timer) clearTimeout(entry.timer)
-    progressWatchers.delete(projectPath)
-  }
-}
-
 /**
  * Broadcast message to all connected WebSocket clients
  * @param {object} data - Data to broadcast
@@ -67,96 +28,83 @@ function broadcast(data) {
   })
 }
 
-// --- Shared scan logic (aligned with watcher.js) ---
-
-const excludeDirs = new Set([
-  '.Trash', '.cache', '.npm', '.local', '.vscode', 'Library',
-  '.git', 'node_modules', '.Trash-*', '.DS_Store', '.config',
-  '.cocoapods', '.gem', '.rvm', '.nvm', '.asdf', '.brew',
-  'AppData', 'Application Data', '.cargo', '.rustup',
-  '.nuget', '.android', '.gradle', '.m2', '.vscode-server'
-])
-
-function shouldExclude(name, cwd) {
-  if (excludeDirs.has(name)) return true
-  for (const pattern of excludeDirs) {
-    if (pattern.includes('*')) {
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$')
-      if (regex.test(name)) return true
-    }
-  }
-  const cwdName = cwd.split(sep).pop() || cwd.split('/').pop() || ''
-  if (name.startsWith('.') && name !== cwdName) return true
-  return false
-}
-
-function scanDirectory(baseDir, seen, maxDepth = 2, currentDepth = 0) {
-  const cwd = process.cwd()
-  const projects = []
-  try {
-    const entries = readdirSync(baseDir, { withFileTypes: true })
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-      if (shouldExclude(entry.name, cwd)) continue
-      const dirPath = join(baseDir, entry.name)
-      let realPath
-      try { realPath = realpathSync(dirPath) } catch { realPath = dirPath }
-      const normalizedPath = realPath.toLowerCase()
-      if (seen.has(normalizedPath)) continue
-      seen.add(normalizedPath)
-      if (existsSync(join(dirPath, '.sillyspec'))) {
-        projects.push({ name: entry.name, path: dirPath })
-      }
-      if (currentDepth < maxDepth) {
-        projects.push(...scanDirectory(dirPath, seen, maxDepth, currentDepth + 1))
-      }
-    }
-  } catch (err) {}
-  return projects
-}
-
 /**
  * Discover all SillySpec projects
  * @returns {Promise<Array>} Array of project objects
  */
 async function discoverProjects() {
+  const { homedir } = await import('os')
   const home = homedir()
   const cwd = process.cwd()
 
-  const scanDirs = new Set()
-  scanDirs.add(cwd)
-  scanDirs.add(dirname(cwd))
-  scanDirs.add(dirname(dirname(cwd)))
-  scanDirs.add(home)
+  // Directories to exclude (system junk, cache, etc.)
+  const excludeDirs = new Set([
+    '.Trash', '.cache', '.npm', '.local', '.vscode', 'Library',
+    '.git', 'node_modules', '.Trash-*', '.DS_Store', '.config',
+    '.cocoapods', '.gem', '.rvm', '.nvm', '.asdf', '.brew'
+  ])
+
+  // Helper to check if directory should be excluded
+  const shouldExclude = (name) => {
+    // Check exact matches
+    if (excludeDirs.has(name)) return true
+    // Check wildcard patterns (like .Trash-*)
+    for (const pattern of excludeDirs) {
+      if (pattern.includes('*')) {
+        const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$')
+        if (regex.test(name)) return true
+      }
+    }
+    // Exclude hidden directories (starting with .) unless it's the cwd basename
+    if (name.startsWith('.') && name !== cwd.split('/').pop()) {
+      return true
+    }
+    return false
+  }
 
-  const extraDirs = [
-    'Desktop', '桌面', 'Documents', '文档', 'Downloads', '下载',
-    'Projects', '项目', 'Work', '工作', 'Repos', 'Code', 'src', 'dev',
-    'workspace', '工作区'
-  ]
+  // Build scan directories: cwd + home subdirs + common project locations
+  const scanDirs = [cwd, home]
+  const extraDirs = ['Desktop', 'Documents', 'Projects', 'Work', 'Repos', 'Code', 'src', 'dev']
 
   for (const extra of extraDirs) {
     const extraPath = join(home, extra)
-    if (existsSync(extraPath)) scanDirs.add(extraPath)
-  }
-
-  for (const customPath of customScanPaths) {
-    if (existsSync(customPath)) scanDirs.add(customPath)
+    if (existsSync(extraPath)) {
+      scanDirs.push(extraPath)
+    }
   }
 
-  const seen = new Set()
   const projects = []
-
-  // Normalize cwd for dedup
-  let cwdReal
-  try { cwdReal = realpathSync(cwd) } catch { cwdReal = cwd }
-  seen.add(cwdReal.toLowerCase())
-  if (existsSync(join(cwd, '.sillyspec'))) {
-    projects.push({ name: basename(cwd), path: cwd })
-  }
+  const seen = new Set() // Dedupe by path
 
   for (const baseDir of scanDirs) {
-    projects.push(...scanDirectory(baseDir, seen, 2, 0))
+    try {
+      const { readdirSync } = await import('fs')
+      const entries = readdirSync(baseDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue
+        if (shouldExclude(entry.name)) continue
+
+        const dirPath = join(baseDir, entry.name)
+
+        // Skip if we've already seen this path (handles symlinks, dupes)
+        const realPath = dirPath // Could add realpath for true deduping
+        if (seen.has(realPath)) continue
+        seen.add(realPath)
+
+        const sillyspecPath = join(dirPath, '.sillyspec')
+
+        if (existsSync(sillyspecPath)) {
+          projects.push({
+            name: entry.name,
+            path: dirPath
+          })
+        }
+      }
+    } catch (err) {
+      // Skip directories we can't read
+      continue
+    }
   }
 
   return projects
@@ -178,6 +126,7 @@ function handleCliExecute(ws, data) {
     return
   }
 
+  // Find project
   discoverProjects().then(projects => {
     const project = projects.find(p => p.name === projectName)
     if (!project) {
@@ -188,29 +137,45 @@ function handleCliExecute(ws, data) {
       return
     }
 
+    // Kill existing process for this project if any
     const existingKill = activeProcesses.get(projectName)
-    if (existingKill) existingKill()
+    if (existingKill) {
+      existingKill()
+    }
 
+    // Execute command
     const kill = executeCommand(
       project.path,
       command,
       (output) => {
         broadcast({
           type: 'cli:output',
-          data: { projectName, output: output.data, outputType: output.type }
+          data: {
+            projectName,
+            output: output.data,
+            outputType: output.type
+          }
         })
       },
       (result) => {
         activeProcesses.delete(projectName)
         broadcast({
           type: 'cli:complete',
-          data: { projectName, exitCode: result.code, signal: result.signal }
+          data: {
+            projectName,
+            exitCode: result.code,
+            signal: result.signal
+          }
         })
       }
     )
 
     activeProcesses.set(projectName, kill)
-    broadcast({ type: 'cli:started', data: { projectName, command } })
+
+    broadcast({
+      type: 'cli:started',
+      data: { projectName, command }
+    })
   })
 }
 
@@ -221,6 +186,7 @@ function handleCliExecute(ws, data) {
  */
 function startServer({ port = 3456, open: openBrowser = true } = {}) {
   const server = createServer((req, res) => {
+    // CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*')
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
@@ -231,6 +197,7 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
       return
     }
 
+    // API: List all projects
     if (req.url === '/api/projects') {
       discoverProjects().then(projects => {
         res.setHeader('Content-Type', 'application/json')
@@ -243,44 +210,7 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
       return
     }
 
-    // Detail API
-    const detailMatch = req.url?.match(/^\/api\/projects\/(.+)\/detail(\?|$)/)
-    if (detailMatch) {
-      const projectPath = decodeURIComponent(detailMatch[1])
-      const url = new URL(req.url, `http://${req.headers.host}`)
-      const type = url.searchParams.get('type')
-      let data
-      try {
-        if (type === 'git') data = parseGitDetail(projectPath)
-        else if (type === 'tech') data = parseTechStackDetail(projectPath)
-        else if (type === 'docs') data = parseDocsList(projectPath)
-        else { res.writeHead(400); res.end(JSON.stringify({ error: 'Invalid type' })); return }
-        res.setHeader('Content-Type', 'application/json')
-        res.writeHead(200)
-        res.end(JSON.stringify(data))
-      } catch (err) {
-        res.writeHead(500)
-        res.end(JSON.stringify({ error: err.message }))
-      }
-      return
-    }
-
-    // Overview API
-    if (req.url?.startsWith('/api/projects/') && req.url.endsWith('/overview')) {
-      const parts = req.url.replace('/api/projects/', '').replace('/overview', '').split('/')
-      const projectPath = decodeURIComponent(parts.join('/'))
-      try {
-        const overview = parseProjectOverview(projectPath)
-        res.setHeader('Content-Type', 'application/json')
-        res.writeHead(200)
-        res.end(JSON.stringify(overview))
-      } catch (err) {
-        res.writeHead(500)
-        res.end(JSON.stringify({ error: err.message }))
-      }
-      return
-    }
-
+    // API: Get project details with state
     if (req.url?.startsWith('/api/project/')) {
       const projectName = decodeURIComponent(req.url.split('/').pop())
       discoverProjects().then(projects => {
@@ -289,7 +219,10 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
           const state = parseProjectState(project.path)
           res.setHeader('Content-Type', 'application/json')
           res.writeHead(200)
-          res.end(JSON.stringify({ ...project, state }))
+          res.end(JSON.stringify({
+            ...project,
+            state
+          }))
         } else {
           res.writeHead(404)
           res.end(JSON.stringify({ error: 'Project not found' }))
@@ -301,54 +234,6 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
       return
     }
 
-    // Docs API
-    if (req.url?.startsWith('/api/docs/content')) {
-      const url = new URL(req.url, `http://${req.headers.host}`)
-      const filePath = url.searchParams.get('path')
-      if (!filePath) {
-        res.writeHead(400)
-        res.end(JSON.stringify({ error: 'Missing path parameter' }))
-        return
-      }
-      // Security: only allow reading files under .sillyspec/docs/
-      const normalizedPath = resolve(filePath)
-      if (!normalizedPath.includes('.sillyspec' + sep + 'docs')) {
-        res.writeHead(403)
-        res.end(JSON.stringify({ error: 'Access denied' }))
-        return
-      }
-      if (existsSync(normalizedPath)) {
-        try {
-          const content = readFileSync(normalizedPath, 'utf-8')
-          res.setHeader('Content-Type', 'text/plain; charset=utf-8')
-          res.writeHead(200)
-          res.end(content)
-        } catch (err) {
-          res.writeHead(500)
-          res.end(JSON.stringify({ error: err.message }))
-        }
-      } else {
-        res.writeHead(404)
-        res.end(JSON.stringify({ error: 'File not found' }))
-      }
-      return
-    }
-
-    if (req.url?.startsWith('/api/docs')) {
-      const url = new URL(req.url, `http://${req.headers.host}`)
-      const projectPath = url.searchParams.get('project')
-      if (!projectPath) {
-        res.writeHead(400)
-        res.end(JSON.stringify({ error: 'Missing project parameter' }))
-        return
-      }
-      const docs = parseDocsTree(projectPath)
-      res.setHeader('Content-Type', 'application/json')
-      res.writeHead(200)
-      res.end(JSON.stringify(docs))
-      return
-    }
-
     // Serve static files (dist/)
     const distDir = join(__dirname, '../dist')
     const indexPath = join(distDir, 'index.html')
@@ -362,6 +247,7 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
         res.end(readFileSync(filePath))
         return
       }
+      // SPA fallback: serve index.html for unknown routes
       if (existsSync(indexPath)) {
         res.setHeader('Content-Type', 'text/html')
         res.writeHead(200)
@@ -370,10 +256,12 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
       }
     }
 
+    // 404
     res.writeHead(404)
     res.end('Not found')
   })
 
+  // WebSocket Server
   wss = new WebSocketServer({ server })
 
   wss.on('error', (err) => {
@@ -387,25 +275,13 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
     discoverProjects().then(projects => {
       const projectsWithState = projects.map(p => ({
         ...p,
-        state: parseProjectState(p.path),
-        overview: parseProjectOverview(p.path)
+        state: parseProjectState(p.path)
       }))
 
       ws.send(JSON.stringify({
         type: 'projects:init',
         data: projectsWithState
       }))
-
-      // Start watching progress files for all discovered projects
-      for (const p of projectsWithState) {
-        startProgressWatch(p.path)
-      }
-
-      // Send current scan paths
-      ws.send(JSON.stringify({
-        type: 'scan:paths',
-        data: getCustomScanPaths()
-      }))
     }).catch(err => {
       console.error('Error sending initial projects:', err)
     })
@@ -423,37 +299,12 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
             if (kill) {
               kill()
               activeProcesses.delete(data.data.projectName)
-              broadcast({ type: 'cli:killed', data: { projectName: data.data.projectName } })
-            }
-            break
-          case 'scan:add-path':
-            if (data.data?.path) {
-              addCustomScanPath(data.data.path)
-              broadcast({ type: 'scan:paths', data: getCustomScanPaths() })
-              // Resend projects after scan
-              discoverProjects().then(projects => {
-                broadcast({
-                  type: 'projects:updated',
-                  data: projects.map(p => ({ ...p, state: parseProjectState(p.path) }))
-                })
+              broadcast({
+                type: 'cli:killed',
+                data: { projectName: data.data.projectName }
               })
             }
             break
-          case 'scan:remove-path':
-            if (data.data?.path) {
-              removeCustomScanPath(data.data.path)
-              ws.send(JSON.stringify({ type: 'scan:paths', data: getCustomScanPaths() }))
-            }
-            break
-          case 'scan:get-paths':
-            ws.send(JSON.stringify({ type: 'scan:paths', data: getCustomScanPaths() }))
-            break
-          case 'docs:get':
-            if (data.data?.projectPath) {
-              const docs = parseDocsTree(data.data.projectPath)
-              ws.send(JSON.stringify({ type: 'docs:tree', data: docs }))
-            }
-            break
           default:
             console.log('Unknown message type:', data.type)
         }
@@ -464,12 +315,6 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
 
     ws.on('close', () => {
       console.log('WebSocket client disconnected')
-      // Decrement progress watchers — we track which projects this client was watching
-      // via the initial projects:init. For simplicity, stop all that we started.
-      // (Other clients will re-start via their connection if still active)
-      for (const [path] of progressWatchers) {
-        stopProgressWatch(path)
-      }
     })
 
     ws.on('error', (err) => {
@@ -477,9 +322,13 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
     })
   })
 
+  // Start file watcher (wrapped to avoid crashing server)
   try {
     startWatcher((projects) => {
-      broadcast({ type: 'projects:updated', data: projects })
+      broadcast({
+        type: 'projects:updated',
+        data: projects
+      })
     })
   } catch (err) {
     console.error('Failed to start file watcher:', err)
@@ -487,11 +336,13 @@ function startServer({ port = 3456, open: openBrowser = true } = {}) {
 
   server.listen(port, () => {
     console.log(`Dashboard server running on http://localhost:${port}`)
+
     if (openBrowser) {
       open(`http://localhost:${port}`)
     }
   })
 
+  // Handle shutdown
   const shutdown = () => {
     stopWatcher()
     activeProcesses.forEach(kill => kill())