@shawnstack/quickforge 1.0.0

package/server/utils/platform.mjs

@@ -0,0 +1,131 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import os from 'node:os'
+
+export function spawnCollect(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      windowsHide: options.windowsHide ?? true,
+      shell: false,
+    })
+    let stdout = ''
+    let stderr = ''
+    let timedOut = false
+    const timer = options.timeoutMs
+      ? setTimeout(() => {
+          timedOut = true
+          child.kill('SIGTERM')
+        }, options.timeoutMs)
+      : undefined
+    child.stdout.on('data', (chunk) => {
+      stdout += chunk.toString()
+    })
+    child.stderr.on('data', (chunk) => {
+      stderr += chunk.toString()
+    })
+    child.on('error', (error) => {
+      if (timer) clearTimeout(timer)
+      reject(error)
+    })
+    child.on('close', (code) => {
+      if (timer) clearTimeout(timer)
+      resolve({ code, stdout, stderr, timedOut })
+    })
+  })
+}
+
+export async function selectDirectoryDialog() {
+  if (process.platform === 'win32') {
+    const script = `
+$ErrorActionPreference = 'Stop'
+Add-Type -AssemblyName System.Windows.Forms
+Add-Type -AssemblyName System.Drawing
+
+$form = New-Object System.Windows.Forms.Form
+$form.Text = 'QuickForge'
+$form.StartPosition = 'CenterScreen'
+$form.Size = New-Object System.Drawing.Size(1, 1)
+$form.ShowInTaskbar = $false
+$form.TopMost = $true
+$form.Opacity = 0.01
+
+$dialog = New-Object System.Windows.Forms.FolderBrowserDialog
+$dialog.Description = 'Select QuickForge project folder'
+$dialog.ShowNewFolderButton = $true
+
+try {
+  [void]$form.Show()
+  [void]$form.Activate()
+  $result = $dialog.ShowDialog($form)
+  if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+    [Console]::Out.Write($dialog.SelectedPath)
+  }
+  exit 0
+} finally {
+  if ($dialog) { $dialog.Dispose() }
+  if ($form) { $form.Dispose() }
+}
+`
+    let result = await spawnCollect(
+      'powershell.exe',
+      ['-NoProfile', '-STA', '-ExecutionPolicy', 'Bypass', '-Command', script],
+      { windowsHide: false, timeoutMs: 10 * 60 * 1000 },
+    ).catch(() => null)
+    if (!result) {
+      result = await spawnCollect(
+        'pwsh.exe',
+        ['-NoProfile', '-STA', '-ExecutionPolicy', 'Bypass', '-Command', script],
+        { windowsHide: false, timeoutMs: 10 * 60 * 1000 },
+      ).catch(() => null)
+    }
+    if (!result) {
+      const error = new Error('PowerShell was not found. Please install PowerShell or enable Windows PowerShell.')
+      error.statusCode = 500
+      throw error
+    }
+    if (result.timedOut) {
+      const error = new Error('Folder picker timed out. It may have been blocked by Windows or opened on another desktop.')
+      error.statusCode = 504
+      throw error
+    }
+    if (result.code === 0) return result.stdout.trim()
+    const error = new Error(result.stderr.trim() || 'Failed to open folder picker')
+    error.statusCode = 500
+    throw error
+  }
+
+  if (process.platform === 'darwin') {
+    const result = await spawnCollect('osascript', ['-e', 'POSIX path of (choose folder with prompt "Select QuickForge project folder")'])
+    if (result.code === 0) return result.stdout.trim()
+    if (/User canceled/i.test(result.stderr)) return ''
+    const error = new Error(result.stderr.trim() || 'Failed to open folder picker')
+    error.statusCode = 500
+    throw error
+  }
+
+  const zenity = await spawnCollect('zenity', ['--file-selection', '--directory', '--title=Select QuickForge project folder']).catch(() => null)
+  if (zenity) {
+    if (zenity.code === 0) return zenity.stdout.trim()
+    if (zenity.code === 1) return ''
+  }
+
+  const kdialog = await spawnCollect('kdialog', ['--getexistingdirectory', os.homedir(), 'Select QuickForge project folder']).catch(() => null)
+  if (kdialog) {
+    if (kdialog.code === 0) return kdialog.stdout.trim()
+    if (kdialog.code === 1) return ''
+  }
+
+  const error = new Error('No supported folder picker found. Install zenity or kdialog on Linux.')
+  error.statusCode = 501
+  throw error
+}
+
+export function openBrowser(url) {
+  if (process.env.QUICKFORGE_NO_OPEN === '1' || process.env.FASTCODE_NO_OPEN === '1') return
+
+  const command = process.platform === 'win32' ? 'cmd' : process.platform === 'darwin' ? 'open' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['/c', 'start', '""', url] : [url]
+  const child = spawn(command, args, { detached: true, stdio: 'ignore', shell: false })
+  child.unref()
+}

package/server/utils/response.mjs

@@ -0,0 +1,35 @@
+const DEFAULT_MAX_BODY_BYTES = Number(process.env.QUICKFORGE_MAX_BODY_BYTES || process.env.FASTCODE_MAX_BODY_BYTES || 50 * 1024 * 1024)
+
+export function sendJson(res, status, value) {
+  const body = JSON.stringify(value)
+  res.writeHead(status, {
+    'content-type': 'application/json; charset=utf-8',
+    'cache-control': 'no-store',
+  })
+  res.end(body)
+}
+
+export function sendError(res, error) {
+  const status = error?.statusCode || 500
+  sendJson(res, status, { error: error?.message || 'Internal server error' })
+}
+
+export async function readJsonBody(req, maxBodyBytes = DEFAULT_MAX_BODY_BYTES) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of req) {
+    size += chunk.length
+    if (size > maxBodyBytes) {
+      const error = new Error('Request body is too large')
+      error.statusCode = 413
+      throw error
+    }
+    chunks.push(chunk)
+  }
+  const text = Buffer.concat(chunks).toString('utf8')
+  return text ? JSON.parse(text) : null
+}
+
+export function decodeSegment(value) {
+  return decodeURIComponent(value || '')
+}

package/server/utils/workspace.mjs

@@ -0,0 +1,135 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+
+let _workspaceRoot = ''
+
+export function setWorkspaceRoot(root) {
+  _workspaceRoot = path.resolve(root)
+}
+
+export function getWorkspaceRoot() {
+  return _workspaceRoot
+}
+
+export function getToolWorkspaceRoot(context) {
+  return context?.workspaceRoot || getWorkspaceRoot()
+}
+
+export function isInside(parent, child) {
+  const relative = path.relative(parent, child)
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+export function resolveWorkspacePath(input = '.', context) {
+  const workspaceRoot = getToolWorkspaceRoot(context)
+  const candidate = path.isAbsolute(input)
+    ? path.resolve(input)
+    : path.resolve(workspaceRoot, input)
+
+  if (!isInside(workspaceRoot, candidate)) {
+    const error = new Error(`Path is outside the selected project: ${input}`)
+    error.statusCode = 403
+    throw error
+  }
+
+  return candidate
+}
+
+export function toWorkspaceRelative(fullPath, context) {
+  return path.relative(getToolWorkspaceRoot(context), fullPath).replace(/\\/g, '/') || '.'
+}
+
+export function isSensitiveWorkspacePath(fullPath, context) {
+  const relative = toWorkspaceRelative(fullPath, context)
+  const parts = relative.split('/')
+  const name = parts.at(-1) || ''
+  return (
+    parts.includes('.git') ||
+    name === '.env' ||
+    name.startsWith('.env.') ||
+    name.endsWith('.pem') ||
+    name.endsWith('.key') ||
+    name.endsWith('.p12') ||
+    name.endsWith('.pfx') ||
+    name.endsWith('.crt') ||
+    name.endsWith('.cer') ||
+    name.endsWith('.token') ||
+    name === 'credentials.json' ||
+    name === 'secrets.json' ||
+    name === 'id_rsa' ||
+    name === 'id_ed25519'
+  )
+}
+
+export function assertSafeWorkspacePath(fullPath, context) {
+  if (isSensitiveWorkspacePath(fullPath, context)) {
+    const error = new Error(`Access to sensitive path is blocked: ${toWorkspaceRelative(fullPath, context)}`)
+    error.statusCode = 403
+    throw error
+  }
+}
+
+export function truncateText(text, maxChars = 50000) {
+  if (text.length <= maxChars) return text
+  return `${text.slice(0, maxChars)}\n\n[truncated ${text.length - maxChars} characters]`
+}
+
+export function splitLines(text) {
+  return text.split(/\r?\n/)
+}
+
+export async function pathExists(dir) {
+  try {
+    await fs.access(dir)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export async function assertDirectory(dir) {
+  const stat = await fs.stat(dir).catch(() => null)
+  if (!stat || !stat.isDirectory()) {
+    const error = new Error(`Project directory does not exist: ${dir}`)
+    error.statusCode = 400
+    throw error
+  }
+}
+
+export async function directorySize(dir) {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true })
+    const sizes = await Promise.all(entries.map(async (entry) => {
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) return directorySize(full)
+      const stat = await fs.stat(full)
+      return stat.size
+    }))
+    return sizes.reduce((sum, value) => sum + value, 0)
+  } catch {
+    return 0
+  }
+}
+
+export function shouldSkipSearchDir(name) {
+  return ['.git', 'node_modules', 'dist', 'dist-ssr', '.vite'].includes(name)
+}
+
+export function shouldSearchFile(name) {
+  const lower = name.toLowerCase()
+  const blocked = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.ico', '.pdf', '.zip', '.gz', '.7z', '.exe', '.dll', '.woff', '.woff2', '.ttf']
+  return !blocked.some((extension) => lower.endsWith(extension))
+}
+
+export async function walkFiles(root, files = [], context) {
+  const entries = await fs.readdir(root, { withFileTypes: true })
+  for (const entry of entries) {
+    const fullPath = path.join(root, entry.name)
+    if (entry.isDirectory()) {
+      if (!shouldSkipSearchDir(entry.name)) await walkFiles(fullPath, files, context)
+    } else if (entry.isFile() && shouldSearchFile(entry.name) && !isSensitiveWorkspacePath(fullPath, context)) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}