@shawnstack/quickforge 1.3.7 → 1.3.9

package/server/routes/workspace.mjs

@@ -0,0 +1,296 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { spawn } from 'node:child_process'
+import { sendJson } from '../utils/response.mjs'
+import { projectContextFromId } from '../project-config.mjs'
+import {
+  assertSafeWorkspacePath,
+  isSensitiveWorkspacePath,
+  resolveWorkspacePath,
+  shouldSearchFile,
+  toWorkspaceRelative,
+} from '../utils/workspace.mjs'
+
+const MAX_PREVIEW_BYTES = 1024 * 1024
+const MAX_TREE_NODES = 5000
+const SKIP_DIRS = new Set(['.git', 'node_modules', 'dist', 'dist-ssr', 'package-dist', 'package-offline', '.vite', 'coverage'])
+
+const extensionLanguageMap = new Map([
+  ['ts', 'typescript'], ['tsx', 'typescript'], ['js', 'javascript'], ['jsx', 'javascript'],
+  ['mjs', 'javascript'], ['cjs', 'javascript'], ['json', 'json'], ['jsonc', 'json'],
+  ['css', 'css'], ['scss', 'scss'], ['less', 'less'], ['html', 'html'], ['htm', 'html'],
+  ['md', 'markdown'], ['markdown', 'markdown'], ['py', 'python'], ['rb', 'ruby'], ['go', 'go'],
+  ['rs', 'rust'], ['java', 'java'], ['c', 'c'], ['h', 'c'], ['cpp', 'cpp'], ['cc', 'cpp'],
+  ['cxx', 'cpp'], ['hpp', 'cpp'], ['cs', 'csharp'], ['php', 'php'], ['swift', 'swift'],
+  ['kt', 'kotlin'], ['kts', 'kotlin'], ['sh', 'shell'], ['bash', 'shell'], ['zsh', 'shell'],
+  ['ps1', 'powershell'], ['yml', 'yaml'], ['yaml', 'yaml'], ['xml', 'xml'], ['sql', 'sql'],
+  ['toml', 'toml'], ['ini', 'ini'], ['env', 'ini'],
+])
+
+function languageFromPath(filePath) {
+  const fileName = path.basename(filePath).toLowerCase()
+  if (fileName === 'dockerfile' || fileName.endsWith('.dockerfile')) return 'dockerfile'
+  const extension = fileName.includes('.') ? fileName.split('.').pop() : fileName
+  return extensionLanguageMap.get(extension) || 'plaintext'
+}
+
+function isBinaryBuffer(buffer) {
+  const length = Math.min(buffer.length, 8000)
+  for (let index = 0; index < length; index += 1) {
+    if (buffer[index] === 0) return true
+  }
+  return false
+}
+
+async function projectContextFromUrl(url) {
+  const projectId = url.searchParams.get('projectId')
+  if (!projectId) {
+    const error = new Error('projectId is required')
+    error.statusCode = 400
+    throw error
+  }
+  return projectContextFromId(projectId)
+}
+
+function git(args, cwd, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn('git', args, {
+      cwd,
+      shell: false,
+      windowsHide: true,
+      env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+    })
+    const stdout = []
+    const stderr = []
+    child.stdout.on('data', (chunk) => stdout.push(chunk))
+    child.stderr.on('data', (chunk) => stderr.push(chunk))
+    child.once('error', reject)
+    child.once('close', (code) => {
+      const out = Buffer.concat(stdout)
+      const err = Buffer.concat(stderr).toString('utf8').trim()
+      if (code === 0 || options.allowFailure) {
+        resolve({ code, stdout: out, stderr: err })
+      } else {
+        const error = new Error(err || `git ${args.join(' ')} failed`)
+        error.statusCode = 400
+        reject(error)
+      }
+    })
+  })
+}
+
+async function isGitRepository(workspaceRoot) {
+  const result = await git(['rev-parse', '--is-inside-work-tree'], workspaceRoot, { allowFailure: true })
+  return result.code === 0 && result.stdout.toString('utf8').trim() === 'true'
+}
+
+function classifyStatus(x, y) {
+  if (x === '?' && y === '?') return 'untracked'
+  if (x === 'R' || y === 'R') return 'renamed'
+  if (x === 'A' || y === 'A') return 'added'
+  if (x === 'D' || y === 'D') return 'deleted'
+  return 'modified'
+}
+
+function parseGitStatus(buffer) {
+  const entries = buffer.toString('utf8').split('\0').filter(Boolean)
+  const files = []
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]
+    const x = entry[0] || ' '
+    const y = entry[1] || ' '
+    const status = classifyStatus(x, y)
+    const file = {
+      path: entry.slice(3).replace(/\\/g, '/'),
+      status,
+      staged: x !== ' ' && x !== '?',
+      unstaged: y !== ' ' && y !== '?',
+    }
+    if (status === 'renamed') {
+      const oldPath = entries[index + 1]
+      if (oldPath) {
+        file.oldPath = oldPath.replace(/\\/g, '/')
+        index += 1
+      }
+    }
+    files.push(file)
+  }
+  return files.sort((left, right) => left.path.localeCompare(right.path, undefined, { sensitivity: 'base' }))
+}
+
+async function listGitStatus(context) {
+  if (!(await isGitRepository(context.workspaceRoot))) return { isGitRepository: false, files: [] }
+  const result = await git(['status', '--porcelain=v1', '-z'], context.workspaceRoot)
+  return { isGitRepository: true, files: parseGitStatus(result.stdout) }
+}
+
+async function readGitFile(workspaceRoot, ref, relativePath) {
+  const result = await git(['show', `${ref}:${relativePath}`], workspaceRoot, { allowFailure: true })
+  return result.code === 0 ? result.stdout.toString('utf8') : ''
+}
+
+async function readWorkspaceTextFile(context, relativePath) {
+  const file = resolveWorkspacePath(relativePath, context)
+  await assertSafeWorkspacePath(file, context)
+  const stat = await fs.stat(file)
+  if (!stat.isFile()) {
+    const error = new Error('Path is not a file')
+    error.statusCode = 400
+    throw error
+  }
+  if (stat.size > MAX_PREVIEW_BYTES) {
+    const error = new Error('File is too large to preview')
+    error.statusCode = 413
+    throw error
+  }
+  const buffer = await fs.readFile(file)
+  if (isBinaryBuffer(buffer)) {
+    const error = new Error('Binary file cannot be previewed')
+    error.statusCode = 415
+    throw error
+  }
+  return { content: buffer.toString('utf8'), size: stat.size, path: toWorkspaceRelative(file, context) }
+}
+
+async function buildTreeForDirectory(dir, context, counter) {
+  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
+  const nodes = []
+  const sortedEntries = entries.sort((left, right) => {
+    if (left.isDirectory() !== right.isDirectory()) return left.isDirectory() ? -1 : 1
+    return left.name.localeCompare(right.name, undefined, { sensitivity: 'base' })
+  })
+
+  for (const entry of sortedEntries) {
+    if (counter.count >= MAX_TREE_NODES) break
+    const fullPath = path.join(dir, entry.name)
+    const relativePath = toWorkspaceRelative(fullPath, context)
+    if (entry.isDirectory()) {
+      if (SKIP_DIRS.has(entry.name) || isSensitiveWorkspacePath(fullPath, context)) continue
+      try {
+        await assertSafeWorkspacePath(fullPath, context)
+        counter.count += 1
+        nodes.push({
+          name: entry.name,
+          path: relativePath,
+          type: 'directory',
+          children: await buildTreeForDirectory(fullPath, context, counter),
+        })
+      } catch {
+        // Skip directories that cannot be safely resolved.
+      }
+    } else if (entry.isFile()) {
+      if (!shouldSearchFile(entry.name) || isSensitiveWorkspacePath(fullPath, context)) continue
+      try {
+        await assertSafeWorkspacePath(fullPath, context)
+        counter.count += 1
+        nodes.push({ name: entry.name, path: relativePath, type: 'file' })
+      } catch {
+        // Skip files that cannot be safely resolved.
+      }
+    }
+  }
+  return nodes
+}
+
+async function handleWorkspaceTree(req, res, url) {
+  const context = await projectContextFromUrl(url)
+  const tree = await buildTreeForDirectory(context.workspaceRoot, context, { count: 0 })
+  sendJson(res, 200, { root: context.project.name, tree })
+}
+
+async function handleWorkspaceFile(req, res, url) {
+  const context = await projectContextFromUrl(url)
+  const relativePath = url.searchParams.get('path') || ''
+  if (!relativePath) {
+    const error = new Error('path is required')
+    error.statusCode = 400
+    throw error
+  }
+  const file = await readWorkspaceTextFile(context, relativePath)
+  sendJson(res, 200, {
+    ...file,
+    language: languageFromPath(file.path),
+    readonly: true,
+  })
+}
+
+async function handleGitStatus(req, res, url) {
+  const context = await projectContextFromUrl(url)
+  sendJson(res, 200, await listGitStatus(context))
+}
+
+async function handleGitFileDiff(req, res, url) {
+  const context = await projectContextFromUrl(url)
+  const relativePath = url.searchParams.get('path') || ''
+  if (!relativePath) {
+    const error = new Error('path is required')
+    error.statusCode = 400
+    throw error
+  }
+
+  const statusPayload = await listGitStatus(context)
+  if (!statusPayload.isGitRepository) {
+    const error = new Error('This project is not a Git repository')
+    error.statusCode = 400
+    throw error
+  }
+  const changedFile = statusPayload.files.find((file) => file.path === relativePath)
+  if (!changedFile) {
+    const error = new Error('File has no working tree changes')
+    error.statusCode = 404
+    throw error
+  }
+
+  const newRelativePath = changedFile.path
+  const oldRelativePath = changedFile.oldPath || changedFile.path
+  let oldContent = ''
+  let newContent = ''
+
+  if (changedFile.status !== 'added' && changedFile.status !== 'untracked') {
+    const oldFile = resolveWorkspacePath(oldRelativePath, context)
+    await assertSafeWorkspacePath(oldFile, context, { ignoreMissing: true })
+    oldContent = await readGitFile(context.workspaceRoot, 'HEAD', oldRelativePath)
+  }
+  if (changedFile.status !== 'deleted') {
+    newContent = (await readWorkspaceTextFile(context, newRelativePath)).content
+  }
+
+  sendJson(res, 200, {
+    path: newRelativePath,
+    oldPath: changedFile.oldPath,
+    status: changedFile.status,
+    oldContent,
+    newContent,
+    language: languageFromPath(newRelativePath),
+  })
+}
+
+export async function handleWorkspaceApi(req, res, url) {
+  if (req.method === 'GET' && url.pathname === '/api/workspace/tree') {
+    await handleWorkspaceTree(req, res, url)
+    return
+  }
+  if (req.method === 'GET' && url.pathname === '/api/workspace/file') {
+    await handleWorkspaceFile(req, res, url)
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}
+
+export async function handleGitApi(req, res, url) {
+  if (req.method === 'GET' && url.pathname === '/api/git/status') {
+    await handleGitStatus(req, res, url)
+    return
+  }
+  if (req.method === 'GET' && url.pathname === '/api/git/file-diff') {
+    await handleGitFileDiff(req, res, url)
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}

package/server/terminal/terminal-manager.mjs

@@ -0,0 +1,256 @@
+import os from 'node:os'
+import { randomUUID } from 'node:crypto'
+import { spawnSync } from 'node:child_process'
+import { createRequire } from 'node:module'
+import { logger } from '../utils/logger.mjs'
+
+const require = createRequire(import.meta.url)
+const MAX_SESSIONS = Math.max(1, Number(process.env.QUICKFORGE_MAX_TERMINALS || 6))
+const TERMINAL_DISABLED = process.env.QUICKFORGE_TERMINAL === '0'
+const RECONNECT_GRACE_MS = Number(process.env.QUICKFORGE_TERMINAL_RECONNECT_MS || 5 * 60 * 1000)
+const IDLE_TIMEOUT_MS = Number(process.env.QUICKFORGE_TERMINAL_IDLE_MS || 30 * 60 * 1000)
+
+const sessions = new Map()
+let cleanupTimer = null
+let pty = null
+let ptyLoadError = null
+
+function loadPty() {
+  if (pty) return pty
+  if (ptyLoadError) throw ptyLoadError
+
+  try {
+    pty = require('node-pty')
+    return pty
+  } catch (error) {
+    ptyLoadError = createError('Terminal requires node-pty. Install optional terminal dependencies to enable it.', 503)
+    ptyLoadError.cause = error
+    throw ptyLoadError
+  }
+}
+
+function isWindows() {
+  return process.platform === 'win32'
+}
+
+function commandExists(command) {
+  const probe = isWindows() ? 'where' : 'command'
+  const args = isWindows() ? [command] : ['-v', command]
+  const result = spawnSync(probe, args, { shell: !isWindows(), stdio: 'ignore', windowsHide: true })
+  return result.status === 0
+}
+
+function detectShell() {
+  if (process.env.QUICKFORGE_TERMINAL_SHELL) return process.env.QUICKFORGE_TERMINAL_SHELL
+  if (isWindows()) {
+    if (commandExists('pwsh.exe')) return 'pwsh.exe'
+    if (commandExists('powershell.exe')) return 'powershell.exe'
+    return 'cmd.exe'
+  }
+  return process.env.SHELL || (commandExists('/bin/bash') ? '/bin/bash' : '/bin/sh')
+}
+
+function createError(message, statusCode = 500) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+function serializeSession(session) {
+  return {
+    id: session.id,
+    name: session.name,
+    projectId: session.projectId,
+    cwd: session.cwd,
+    shell: session.shell,
+    createdAt: session.createdAt,
+    updatedAt: session.updatedAt,
+    exited: session.exited,
+    exitCode: session.exitCode,
+    signal: session.signal,
+  }
+}
+
+function send(client, message) {
+  if (client.readyState === client.OPEN) {
+    client.send(JSON.stringify(message))
+  }
+}
+
+function broadcast(session, message) {
+  for (const client of session.clients) send(client, message)
+}
+
+function scheduleCleanup() {
+  if (cleanupTimer) return
+  cleanupTimer = setInterval(() => {
+    const now = Date.now()
+    for (const session of sessions.values()) {
+      const disconnectedTooLong = session.clients.size === 0 && now - session.disconnectedAt > RECONNECT_GRACE_MS
+      const idleTooLong = now - session.touchedAt > IDLE_TIMEOUT_MS
+      if (session.exited || disconnectedTooLong || idleTooLong) {
+        destroyTerminalSession(session.id)
+      }
+    }
+    if (sessions.size === 0) {
+      clearInterval(cleanupTimer)
+      cleanupTimer = null
+    }
+  }, 60 * 1000)
+  cleanupTimer.unref?.()
+}
+
+export function terminalCapabilities() {
+  const shell = detectShell()
+  const terminalAvailable = !TERMINAL_DISABLED && (() => {
+    try {
+      loadPty()
+      return true
+    } catch {
+      return false
+    }
+  })()
+
+  return {
+    enabled: terminalAvailable,
+    localOnly: true,
+    maxSessions: MAX_SESSIONS,
+    shell: terminalAvailable ? shell : null,
+    reason: TERMINAL_DISABLED
+      ? 'Terminal is disabled by QUICKFORGE_TERMINAL=0.'
+      : (terminalAvailable ? null : 'Terminal requires node-pty. Install optional terminal dependencies to enable it.'),
+  }
+}
+
+export function listTerminalSessions(projectId) {
+  return [...sessions.values()]
+    .filter((session) => !projectId || session.projectId === projectId)
+    .map(serializeSession)
+}
+
+export function createTerminalSession({ cwd, projectId = null, name, cols = 120, rows = 30 }) {
+  if (TERMINAL_DISABLED) throw createError('Terminal is disabled', 403)
+  if (sessions.size >= MAX_SESSIONS) throw createError(`Maximum terminal sessions reached (${MAX_SESSIONS})`, 429)
+
+  const shell = detectShell()
+  const ptyModule = loadPty()
+  const id = randomUUID()
+  const now = new Date().toISOString()
+  const ptyProcess = ptyModule.spawn(shell, [], {
+    name: 'xterm-256color',
+    cols: Math.max(20, Number(cols) || 120),
+    rows: Math.max(8, Number(rows) || 30),
+    cwd,
+    env: {
+      ...process.env,
+      TERM: 'xterm-256color',
+      COLORTERM: 'truecolor',
+      QUICKFORGE_TERMINAL: '1',
+    },
+  })
+
+  const session = {
+    id,
+    name: String(name || `Terminal ${sessions.size + 1}`),
+    projectId,
+    cwd,
+    shell,
+    pty: ptyProcess,
+    clients: new Set(),
+    cols: Math.max(20, Number(cols) || 120),
+    rows: Math.max(8, Number(rows) || 30),
+    createdAt: now,
+    updatedAt: now,
+    touchedAt: Date.now(),
+    disconnectedAt: Date.now(),
+    exited: false,
+    exitCode: null,
+    signal: null,
+  }
+
+  ptyProcess.onData((data) => {
+    session.touchedAt = Date.now()
+    session.updatedAt = new Date().toISOString()
+    broadcast(session, { type: 'output', data })
+  })
+
+  ptyProcess.onExit(({ exitCode, signal }) => {
+    session.exited = true
+    session.exitCode = exitCode
+    session.signal = signal
+    session.updatedAt = new Date().toISOString()
+    broadcast(session, { type: 'exit', exitCode, signal })
+  })
+
+  sessions.set(id, session)
+  scheduleCleanup()
+  return serializeSession(session)
+}
+
+export function attachTerminalClient(sessionId, client) {
+  const session = sessions.get(sessionId)
+  if (!session) throw createError('Terminal session not found', 404)
+
+  session.clients.add(client)
+  session.touchedAt = Date.now()
+  session.updatedAt = new Date().toISOString()
+  send(client, { type: 'ready', session: serializeSession(session) })
+
+  client.on('message', (raw) => {
+    try {
+      const message = JSON.parse(raw.toString('utf8'))
+      session.touchedAt = Date.now()
+      session.updatedAt = new Date().toISOString()
+
+      if (message.type === 'input' && typeof message.data === 'string' && !session.exited) {
+        session.pty.write(message.data)
+      } else if (message.type === 'resize' && !session.exited) {
+        const cols = Math.max(20, Number(message.cols) || session.cols)
+        const rows = Math.max(8, Number(message.rows) || session.rows)
+        session.cols = cols
+        session.rows = rows
+        session.pty.resize(cols, rows)
+      } else if (message.type === 'ping') {
+        send(client, { type: 'pong' })
+      }
+    } catch (error) {
+      send(client, { type: 'error', message: error instanceof Error ? error.message : 'Invalid terminal message' })
+    }
+  })
+
+  client.on('close', () => {
+    session.clients.delete(client)
+    session.disconnectedAt = Date.now()
+  })
+
+  if (session.exited) {
+    send(client, { type: 'exit', exitCode: session.exitCode, signal: session.signal })
+  }
+}
+
+export function destroyTerminalSession(sessionId) {
+  const session = sessions.get(sessionId)
+  if (!session) return false
+  sessions.delete(sessionId)
+  for (const client of session.clients) {
+    try { client.close() } catch { /* ignore */ }
+  }
+  try {
+    if (!session.exited) session.pty.kill()
+  } catch (error) {
+    logger.warn('Failed to kill terminal session', { sessionId, error: error?.message })
+  }
+  return true
+}
+
+export function shutdownTerminalSessions() {
+  if (cleanupTimer) {
+    clearInterval(cleanupTimer)
+    cleanupTimer = null
+  }
+  for (const sessionId of [...sessions.keys()]) destroyTerminalSession(sessionId)
+}
+
+export function platformInfo() {
+  return { platform: os.platform(), shell: detectShell() }
+}