create-claudeportal 0.1.0

package/server/lib/terminal.js

@@ -0,0 +1,95 @@
+const path = require('path')
+const { getExpandedPath } = require('./detect-tools')
+
+let pty = null
+
+// Try to load node-pty — it requires native compilation and may not be available
+try {
+  pty = require('node-pty')
+} catch {
+  console.log('  ⚠ node-pty not available — embedded terminal disabled')
+  console.log('  Users can still open their native terminal')
+}
+
+function isPtyAvailable() {
+  return pty !== null
+}
+
+function createTerminal(cwd) {
+  if (!pty) {
+    throw new Error('node-pty is not available')
+  }
+
+  const shell = process.platform === 'win32'
+    ? 'powershell.exe'
+    : (process.env.SHELL || (process.platform === 'darwin' ? 'zsh' : 'bash'))
+
+  // Build a clean environment — remove CLAUDECODE so Claude Code
+  // doesn't think it's nested inside another session
+  const env = { ...process.env, TERM: 'xterm-256color', PATH: getExpandedPath() }
+  delete env.CLAUDECODE
+
+  const ptyProcess = pty.spawn(shell, [], {
+    name: 'xterm-256color',
+    cols: 80,
+    rows: 24,
+    cwd: cwd || process.env.HOME,
+    env,
+  })
+
+  return ptyProcess
+}
+
+function attachToWebSocket(ws, ptyProcess) {
+  let detached = false
+
+  // Terminal output → browser
+  const dataHandler = ptyProcess.onData((data) => {
+    try {
+      ws.send(JSON.stringify({ type: 'output', data }))
+    } catch {
+      // WebSocket might be closed
+    }
+  })
+
+  // Terminal exit → browser
+  const exitHandler = ptyProcess.onExit(({ exitCode }) => {
+    try {
+      ws.send(JSON.stringify({ type: 'exit', exitCode }))
+    } catch {
+      // WebSocket might be closed
+    }
+  })
+
+  // Browser input → terminal
+  ws.on('message', (msg) => {
+    if (detached) return
+    try {
+      const parsed = JSON.parse(msg.toString())
+      switch (parsed.type) {
+        case 'input':
+          ptyProcess.write(parsed.data)
+          break
+        case 'resize':
+          ptyProcess.resize(parsed.cols, parsed.rows)
+          break
+      }
+    } catch {
+      // Invalid message
+    }
+  })
+
+  ws.on('close', () => {
+    detached = true
+    dataHandler.dispose()
+    exitHandler.dispose()
+    // Only kill if this PTY hasn't already been replaced by a new connection
+    try { ptyProcess.kill() } catch {}
+  })
+
+  // Allow the server to detach this connection before ws closes
+  // (e.g. when a new connection replaces it)
+  return { detach() { detached = true; dataHandler.dispose(); exitHandler.dispose() } }
+}
+
+module.exports = { createTerminal, attachToWebSocket, isPtyAvailable }

package/server/lib/validate-folder-path.js

@@ -0,0 +1,17 @@
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+
+function validateFolderPath(folderPath) {
+  if (!folderPath || typeof folderPath !== 'string') return null
+  const resolved = path.resolve(folderPath)
+  if (!resolved.startsWith(os.homedir())) return null
+  if (!fs.existsSync(resolved)) return null
+  try {
+    const stat = fs.statSync(resolved)
+    if (!stat.isDirectory()) return null
+  } catch { return null }
+  return resolved
+}
+
+module.exports = { validateFolderPath }

package/server/lib/validate-path.js

@@ -0,0 +1,13 @@
+const os = require('os')
+const path = require('path')
+const fs = require('fs')
+
+function validateProjectPath(projectPath) {
+  if (!projectPath || typeof projectPath !== 'string') return null
+  const resolved = path.resolve(projectPath)
+  if (!resolved.startsWith(os.homedir())) return null
+  if (!fs.existsSync(resolved)) return null
+  return resolved
+}
+
+module.exports = { validateProjectPath }

package/server/routes/detect.js

@@ -0,0 +1,64 @@
+const express = require('express')
+const path = require('path')
+const fs = require('fs')
+const os = require('os')
+const { detectAll } = require('../lib/detect-tools')
+
+const router = express.Router()
+
+router.get('/detect', (req, res) => {
+  const results = detectAll()
+  results.drives = detectCloudDrives()
+  res.setHeader('Cache-Control', 'no-store')
+  res.json(results)
+})
+
+function detectCloudDrives() {
+  const home = os.homedir()
+  const drives = []
+
+  // iCloud Drive
+  const icloud = path.join(home, 'Library', 'Mobile Documents', 'com~apple~CloudDocs')
+  if (fs.existsSync(icloud)) {
+    drives.push({ id: 'icloud', name: 'iCloud Drive', path: icloud })
+  }
+
+  // Dropbox
+  const dropbox = path.join(home, 'Dropbox')
+  if (fs.existsSync(dropbox)) {
+    drives.push({ id: 'dropbox', name: 'Dropbox', path: dropbox })
+  }
+
+  // OneDrive — check CloudStorage variants
+  const cloudStorage = path.join(home, 'Library', 'CloudStorage')
+  if (fs.existsSync(cloudStorage)) {
+    try {
+      for (const entry of fs.readdirSync(cloudStorage)) {
+        const fullPath = path.join(cloudStorage, entry)
+        if (!fs.statSync(fullPath).isDirectory()) continue
+
+        if (entry.startsWith('GoogleDrive-')) {
+          drives.push({ id: 'gdrive', name: 'Google Drive', path: fullPath })
+        } else if (entry.startsWith('OneDrive-')) {
+          const label = entry.replace('OneDrive-', 'OneDrive — ')
+          drives.push({ id: 'onedrive', name: label, path: fullPath })
+        }
+      }
+    } catch {}
+  }
+
+  // ~/Documents and ~/Desktop as common project locations
+  const docs = path.join(home, 'Documents')
+  if (fs.existsSync(docs)) {
+    drives.push({ id: 'documents', name: 'Documents', path: docs })
+  }
+
+  const desktop = path.join(home, 'Desktop')
+  if (fs.existsSync(desktop)) {
+    drives.push({ id: 'desktop', name: 'Desktop', path: desktop })
+  }
+
+  return drives
+}
+
+module.exports = router

package/server/routes/doc-events.js

@@ -0,0 +1,94 @@
+const express = require('express')
+const fs = require('fs')
+const path = require('path')
+const { validateFolderPath } = require('../lib/validate-folder-path')
+
+const KEEP_ALIVE_INTERVAL = 30 * 1000  // 30 seconds
+const AUTO_CLOSE_TIMEOUT = 5 * 60 * 1000  // 5 minutes
+
+// Shared watcher instances, keyed by outputDir
+const watchers = new Map() // outputDir -> { watcher, refCount }
+
+function createDocEventsRouter(sseManager) {
+  const router = express.Router()
+
+  router.get('/doc-events', (req, res) => {
+    const folderPath = validateFolderPath(req.query.folderPath)
+    if (!folderPath) return res.status(400).end()
+
+    const outputDir = folderPath + '/output'
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    })
+    res.write('\n')
+
+    sseManager.addConnection(outputDir, res)
+
+    if (!fs.existsSync(outputDir)) {
+      fs.mkdirSync(outputDir, { recursive: true })
+    }
+
+    // Reuse existing watcher for this outputDir, or create a new one
+    if (watchers.has(outputDir)) {
+      watchers.get(outputDir).refCount++
+    } else {
+      const chokidar = require('chokidar')
+      const watcher = chokidar.watch(outputDir, { depth: 0, ignoreInitial: true })
+
+      const emitFile = (filePath) => {
+        const relative = path.relative(outputDir, filePath)
+        sseManager.send(outputDir, 'output-created', { file: relative, path: filePath })
+      }
+      watcher.on('add', emitFile)
+      watcher.on('change', emitFile)
+
+      watcher.on('ready', () => {
+        // Catch files created during watcher startup
+        try {
+          const existing = fs.readdirSync(outputDir).filter(f => !f.startsWith('.'))
+          for (const file of existing) {
+            const filePath = path.join(outputDir, file)
+            const stat = fs.statSync(filePath)
+            // Only emit for files created in the last 5 minutes (avoids old outputs)
+            if (Date.now() - stat.mtimeMs < 5 * 60 * 1000) {
+              sseManager.send(outputDir, 'output-created', { file, path: filePath })
+            }
+          }
+        } catch {}
+      })
+
+      watchers.set(outputDir, { watcher, refCount: 1 })
+    }
+
+    const keepAlive = setInterval(() => {
+      try { res.write(': ping\n\n') } catch {}
+    }, KEEP_ALIVE_INTERVAL)
+
+    const autoClose = setTimeout(() => {
+      res.end()
+    }, AUTO_CLOSE_TIMEOUT)
+
+    res.on('close', () => {
+      clearInterval(keepAlive)
+      clearTimeout(autoClose)
+      // Defer to ensure SSEManager's close handler removes the connection first
+      setTimeout(() => {
+        const entry = watchers.get(outputDir)
+        if (entry) {
+          entry.refCount--
+          if (entry.refCount <= 0 && !sseManager.hasConnections(outputDir)) {
+            entry.watcher.close()
+            watchers.delete(outputDir)
+          }
+        }
+      }, 0)
+    })
+  })
+
+  return router
+}
+
+module.exports = { createDocEventsRouter }

package/server/routes/events.js

@@ -0,0 +1,37 @@
+const express = require('express')
+const { validateProjectPath } = require('../lib/validate-path')
+
+function createEventsRouter(sseManager, fileWatcher) {
+  const router = express.Router()
+
+  router.get('/events', (req, res) => {
+    const projectPath = validateProjectPath(req.query.projectPath)
+    if (!projectPath) return res.status(400).end()
+
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    })
+    res.write('\n')
+
+    sseManager.addConnection(projectPath, res)
+    fileWatcher.watch(projectPath)
+
+    const keepAlive = setInterval(() => {
+      try { res.write(': ping\n\n') } catch {}
+    }, 30000)
+
+    res.on('close', () => {
+      clearInterval(keepAlive)
+      // Defer to ensure SSEManager's close handler removes the connection first
+      setTimeout(() => {
+        if (!sseManager.hasConnections(projectPath)) fileWatcher.unwatch(projectPath)
+      }, 0)
+    })
+  })
+
+  return router
+}
+
+module.exports = { createEventsRouter }

package/server/routes/folder.js

@@ -0,0 +1,195 @@
+const express = require('express')
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
+const { validateFolderPath } = require('../lib/validate-folder-path')
+const { scanFolder } = require('../lib/folder-scanner')
+
+const router = express.Router()
+
+const MAX_READ_SIZE = 10 * 1024 * 1024 // 10MB
+
+router.get('/folder-scan', (req, res) => {
+  const folderPath = validateFolderPath(req.query.folderPath)
+  if (!folderPath) return res.status(400).json({ error: 'Invalid folderPath' })
+
+  try {
+    const result = scanFolder(folderPath)
+    res.json(result)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+router.get('/read-output', (req, res) => {
+  const rawPath = req.query.path
+  if (!rawPath || typeof rawPath !== 'string') {
+    return res.status(400).json({ error: 'Missing path' })
+  }
+
+  const resolved = path.resolve(rawPath)
+  if (!resolved.startsWith(os.homedir())) {
+    return res.status(400).json({ error: 'Path outside home directory' })
+  }
+
+  if (!resolved.includes('/output/')) return res.status(403).json({ error: 'Can only read files from output directories' })
+
+  if (!fs.existsSync(resolved)) {
+    return res.status(404).json({ error: 'File not found' })
+  }
+
+  let stat
+  try {
+    stat = fs.statSync(resolved)
+  } catch (err) {
+    return res.status(500).json({ error: err.message })
+  }
+
+  if (stat.size > MAX_READ_SIZE) {
+    return res.status(413).json({ error: 'File too large (max 10MB)' })
+  }
+
+  try {
+    const content = fs.readFileSync(resolved, 'utf8')
+    res.json({
+      content,
+      path: resolved,
+      size: stat.size,
+      modified: stat.mtime.toISOString(),
+    })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+router.post('/ensure-output-dir', (req, res) => {
+  const folderPath = validateFolderPath(req.query.folderPath)
+  if (!folderPath) return res.status(400).json({ error: 'Invalid folderPath' })
+
+  const outputDir = path.join(folderPath, 'output')
+  try {
+    fs.mkdirSync(outputDir, { recursive: true })
+    res.json({ outputDir })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// Read any file under the home directory (for "Open a document" feature)
+router.get('/read-file', (req, res) => {
+  const rawPath = req.query.path
+  if (!rawPath || typeof rawPath !== 'string') {
+    return res.status(400).json({ error: 'path query parameter required' })
+  }
+
+  const resolved = path.resolve(rawPath)
+  if (!resolved.startsWith(os.homedir())) {
+    return res.status(403).json({ error: 'Path outside home directory' })
+  }
+
+  if (!fs.existsSync(resolved)) {
+    return res.status(404).json({ error: 'File not found' })
+  }
+
+  try {
+    const stat = fs.statSync(resolved)
+    if (stat.size > 10 * 1024 * 1024) {
+      return res.status(413).json({ error: 'File too large (max 10MB)' })
+    }
+    const content = fs.readFileSync(resolved, 'utf8')
+    res.json({ content, path: resolved, size: stat.size, modified: stat.mtime.toISOString() })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// Find the most recently modified file in the output directory
+router.get('/latest-output', (req, res) => {
+  const folderPath = validateFolderPath(req.query.folderPath)
+  if (!folderPath) return res.status(400).json({ error: 'Invalid folderPath' })
+
+  const outputDir = path.join(folderPath, 'output')
+  if (!fs.existsSync(outputDir)) return res.json({ path: null })
+
+  try {
+    const files = fs.readdirSync(outputDir)
+      .filter(f => !f.startsWith('.'))
+      .map(f => {
+        const fullPath = path.join(outputDir, f)
+        const stat = fs.statSync(fullPath)
+        return { name: f, path: fullPath, mtime: stat.mtimeMs }
+      })
+      .sort((a, b) => b.mtime - a.mtime)
+
+    if (files.length === 0) return res.json({ path: null })
+    res.json({ path: files[0].path, name: files[0].name })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// Open native folder picker (macOS: AppleScript, Linux: zenity)
+router.get('/pick-folder', (req, res) => {
+  const { execSync } = require('child_process')
+
+  try {
+    let selected
+    if (process.platform === 'darwin') {
+      selected = execSync(
+        `osascript -e 'POSIX path of (choose folder with prompt "Choose a folder")'`,
+        { encoding: 'utf8', timeout: 60000 }
+      ).trim()
+    } else if (process.platform === 'linux') {
+      selected = execSync(
+        'zenity --file-selection --directory --title="Choose a folder" 2>/dev/null',
+        { encoding: 'utf8', timeout: 60000 }
+      ).trim()
+    } else {
+      return res.status(501).json({ error: 'Folder picker not supported on this platform' })
+    }
+
+    if (!selected) return res.status(400).json({ error: 'No folder selected' })
+
+    // Remove trailing slash if present
+    const cleaned = selected.endsWith('/') ? selected.slice(0, -1) : selected
+    res.json({ path: cleaned })
+  } catch (err) {
+    // User cancelled the dialog
+    if (err.status === 1 || err.message?.includes('User canceled')) {
+      return res.json({ path: null })
+    }
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// Open native file picker (macOS: AppleScript, Linux: zenity)
+router.get('/pick-file', (req, res) => {
+  const { execSync } = require('child_process')
+
+  try {
+    let selected
+    if (process.platform === 'darwin') {
+      selected = execSync(
+        `osascript -e 'POSIX path of (choose file with prompt "Choose a document" of type {"md", "txt", "csv", "json", "html"})'`,
+        { encoding: 'utf8', timeout: 60000 }
+      ).trim()
+    } else if (process.platform === 'linux') {
+      selected = execSync(
+        'zenity --file-selection --title="Choose a document" --file-filter="Documents|*.md *.txt *.csv *.json *.html" 2>/dev/null',
+        { encoding: 'utf8', timeout: 60000 }
+      ).trim()
+    } else {
+      return res.status(501).json({ error: 'File picker not supported on this platform' })
+    }
+
+    if (!selected) return res.json({ path: null })
+    res.json({ path: selected })
+  } catch (err) {
+    if (err.status === 1 || err.message?.includes('User canceled')) {
+      return res.json({ path: null })
+    }
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/github.js

@@ -0,0 +1,21 @@
+const express = require('express')
+const { execSync } = require('child_process')
+const { getExpandedPath } = require('../lib/detect-tools')
+
+const router = express.Router()
+
+router.get('/github/repos', (req, res) => {
+  res.setHeader('Cache-Control', 'no-store')
+  try {
+    const output = execSync('gh repo list --json name,url --limit 20', {
+      encoding: 'utf8',
+      timeout: 10000,
+      env: { ...process.env, PATH: getExpandedPath() },
+    })
+    res.json({ repos: JSON.parse(output) })
+  } catch (err) {
+    res.json({ repos: [], error: 'Could not fetch repos. Is GitHub CLI authenticated?' })
+  }
+})
+
+module.exports = router

package/server/routes/health.js

@@ -0,0 +1,16 @@
+const express = require('express')
+const { scanProject } = require('../lib/file-scanner')
+const { validateProjectPath } = require('../lib/validate-path')
+const router = express.Router()
+
+router.get('/health-scan', (req, res) => {
+  const projectPath = validateProjectPath(req.query.projectPath)
+  if (!projectPath) return res.status(400).json({ error: 'Invalid or missing projectPath' })
+  try {
+    res.json({ checks: scanProject(projectPath) })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/install.js

@@ -0,0 +1,102 @@
+const express = require('express')
+const { installTool } = require('../lib/install-tools')
+const { fixNpmPrefix } = require('../lib/fix-npm-prefix')
+const { detectAll } = require('../lib/detect-tools')
+
+const router = express.Router()
+
+// Install a single tool
+router.post('/install/:toolId', async (req, res) => {
+  const { toolId } = req.params
+
+  res.setHeader('Content-Type', 'text/event-stream')
+  res.setHeader('Cache-Control', 'no-cache')
+  res.setHeader('Connection', 'keep-alive')
+  res.setHeader('X-Accel-Buffering', 'no')
+
+  const send = (data) => {
+    res.write(`data: ${JSON.stringify(data)}\n\n`)
+  }
+
+  send({ tool: toolId, status: 'installing', message: `Installing ${toolId}...` })
+
+  const result = await installTool(toolId, (message) => {
+    send({ tool: toolId, status: 'progress', message })
+  })
+
+  if (result.success) {
+    send({ tool: toolId, status: 'done' })
+  } else {
+    send({ tool: toolId, status: 'error', error: result.error })
+  }
+
+  send({ status: 'complete' })
+  res.end()
+})
+
+// Install all missing tools
+router.post('/install-all', async (req, res) => {
+  res.setHeader('Content-Type', 'text/event-stream')
+  res.setHeader('Cache-Control', 'no-cache')
+  res.setHeader('Connection', 'keep-alive')
+  res.setHeader('X-Accel-Buffering', 'no')
+
+  let clientDisconnected = false
+  req.on('close', () => { clientDisconnected = true })
+
+  const send = (data) => {
+    if (clientDisconnected) return
+    try { res.write(`data: ${JSON.stringify(data)}\n\n`) } catch {}
+  }
+
+  // Step 1: Fix npm prefix on Mac (avoid sudo)
+  send({ status: 'phase', message: 'Preparing npm...' })
+  const prefixResult = fixNpmPrefix()
+  if (prefixResult.fixed) {
+    send({ status: 'info', message: 'npm configured for global installs (no sudo needed)' })
+  }
+
+  // Step 2: Detect what's missing
+  const { tools } = detectAll()
+  const missing = tools.filter((t) => !t.installed && t.required)
+
+  if (missing.length === 0) {
+    send({ status: 'complete', message: 'All tools already installed!' })
+    res.end()
+    return
+  }
+
+  send({ status: 'info', message: `Installing ${missing.length} tool(s)...` })
+
+  // Step 3: Install each missing tool
+  const results = []
+  for (const tool of missing) {
+    if (clientDisconnected) break
+    send({ tool: tool.id, status: 'installing', message: `Installing ${tool.name}...` })
+
+    const result = await installTool(tool.id, (message) => {
+      send({ tool: tool.id, status: 'progress', message })
+    })
+
+    if (result.success) {
+      send({ tool: tool.id, status: 'done', message: `${tool.name} installed` })
+      results.push({ id: tool.id, success: true })
+    } else {
+      send({ tool: tool.id, status: 'error', error: result.error })
+      results.push({ id: tool.id, success: false, error: result.error })
+    }
+  }
+
+  // Step 4: Re-detect to confirm
+  const updated = detectAll()
+
+  send({
+    status: 'complete',
+    results,
+    tools: updated.tools,
+  })
+
+  res.end()
+})
+
+module.exports = router

package/server/routes/project.js

@@ -0,0 +1,18 @@
+const express = require('express')
+const { execSync } = require('child_process')
+const { validateProjectPath } = require('../lib/validate-path')
+const router = express.Router()
+
+router.get('/project-info', (req, res) => {
+  const projectPath = validateProjectPath(req.query.projectPath)
+  if (!projectPath) return res.status(400).json({ error: 'Invalid or missing projectPath' })
+
+  let gitBranch = null
+  let gitRemote = null
+  try { gitBranch = execSync('git rev-parse --abbrev-ref HEAD', { cwd: projectPath, encoding: 'utf8' }).trim() } catch {}
+  try { gitRemote = execSync('git remote get-url origin', { cwd: projectPath, encoding: 'utf8' }).trim() } catch {}
+
+  res.json({ path: projectPath, gitBranch, gitRemote })
+})
+
+module.exports = router