@shawnstack/quickforge 1.1.0 → 1.2.1

package/server/routes/agent.mjs

@@ -0,0 +1,323 @@
+import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import {
+  createAgent,
+  runPrompt,
+  abortRun,
+  steerAgent,
+  followUpAgent,
+  getSessionState,
+  getSessionEventBus,
+  tryAcquireSse,
+  releaseSse,
+  isSseConnected,
+  destroyAgent,
+  restoreAgent,
+  touchSession,
+  listSessions,
+  updateSessionModel,
+  updateSessionThinkingLevel,
+  agentEvents,
+} from '../agent-manager.mjs'
+
+export async function handleAgentApi(req, res, url) {
+  const pathname = url.pathname
+  const parts = pathname.split('/').filter(Boolean)
+
+  // GET /api/agents — list active sessions
+  if (req.method === 'GET' && pathname === '/api/agents') {
+    sendJson(res, 200, { sessions: listSessions() })
+    return
+  }
+
+  // GET /api/agents/events — global SSE event stream for all sessions
+  if (req.method === 'GET' && pathname === '/api/agents/events') {
+    handleGlobalStream(req, res)
+    return
+  }
+
+  // All other routes need a session ID: /api/agents/:sessionId/...
+  if (parts.length < 3 || parts[1] !== 'agents') {
+    const error = new Error('Not found')
+    error.statusCode = 404
+    throw error
+  }
+
+  const sessionId = decodeSegment(parts[2])
+  if (!sessionId) {
+    const error = new Error('Missing session ID')
+    error.statusCode = 400
+    throw error
+  }
+
+  const subPath = parts.slice(3).join('/')
+
+  // GET /api/agents/:sessionId/stream — SSE event stream
+  // HEAD /api/agents/:sessionId/stream — check if SSE is available (200) or taken (409)
+  if (subPath === 'stream') {
+    if (req.method === 'GET') {
+      await handleStream(req, res, sessionId)
+      return
+    }
+    if (req.method === 'HEAD') {
+      await handleStreamHead(req, res, sessionId)
+      return
+    }
+  }
+
+  // POST /api/agents/:sessionId/prompt — send user message
+  if (req.method === 'POST' && subPath === 'prompt') {
+    const body = await readJsonBody(req)
+    const message = body?.message
+    if (!message) {
+      const error = new Error('Missing message in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = await runPrompt(sessionId, message)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/abort — abort current run
+  if (req.method === 'POST' && subPath === 'abort') {
+    const result = abortRun(sessionId)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // GET /api/agents/:sessionId/state — get session state
+  if (req.method === 'GET' && subPath === 'state') {
+    const state = getSessionState(sessionId)
+    if (!state) {
+      const error = new Error('Session not found')
+      error.statusCode = 404
+      throw error
+    }
+    sendJson(res, 200, state)
+    return
+  }
+
+  // POST /api/agents/:sessionId — create/ensure agent
+  if (req.method === 'POST' && parts.length === 3) {
+    const body = await readJsonBody(req)
+    const session = await createAgent(sessionId, body)
+    sendJson(res, 200, {
+      sessionId: session.sessionId,
+      status: session.status,
+      scope: session.scope,
+      title: session.title,
+    })
+    return
+  }
+
+  // DELETE /api/agents/:sessionId — destroy agent
+  if (req.method === 'DELETE' && parts.length === 3) {
+    await destroyAgent(sessionId)
+    sendJson(res, 200, { ok: true })
+    return
+  }
+
+  // POST /api/agents/:sessionId/model — update session model
+  if (req.method === 'POST' && subPath === 'model') {
+    const body = await readJsonBody(req)
+    const model = body?.model
+    if (!model) {
+      const error = new Error('Missing model in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = updateSessionModel(sessionId, model)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/thinking-level — update session thinking level
+  if (req.method === 'POST' && subPath === 'thinking-level') {
+    const body = await readJsonBody(req)
+    const thinkingLevel = body?.thinkingLevel
+    if (!thinkingLevel) {
+      const error = new Error('Missing thinkingLevel in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = updateSessionThinkingLevel(sessionId, thinkingLevel)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/steer — queue steering message
+  if (req.method === 'POST' && subPath === 'steer') {
+    const body = await readJsonBody(req)
+    const message = body?.message
+    if (!message) {
+      const error = new Error('Missing message in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = steerAgent(sessionId, message)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/follow-up — queue follow-up message
+  if (req.method === 'POST' && subPath === 'follow-up') {
+    const body = await readJsonBody(req)
+    const message = body?.message
+    if (!message) {
+      const error = new Error('Missing message in request body')
+      error.statusCode = 400
+      throw error
+    }
+    const result = followUpAgent(sessionId, message)
+    sendJson(res, 200, result)
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}
+
+/**
+ * HEAD request to check whether the SSE stream for a session is available.
+ * Returns 200 if available, 409 if already connected, 404 if session not found.
+ */
+async function handleStreamHead(req, res, sessionId) {
+  // Ensure session exists (restore from storage if needed)
+  if (!getSessionEventBus(sessionId)) {
+    const restored = await restoreAgent(sessionId)
+    if (!restored) {
+      sendJson(res, 404, { error: 'Session not found' })
+      return
+    }
+  }
+
+  if (isSseConnected(sessionId)) {
+    sendJson(res, 409, { error: 'Session is already active in another tab' })
+    return
+  }
+
+  res.writeHead(200, { 'content-length': '0' })
+  res.end()
+}
+
+function handleGlobalStream(req, res) {
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache, no-transform',
+    'connection': 'keep-alive',
+    'x-accel-buffering': 'no',
+  })
+
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(': ping\n\n')
+    } catch {
+      cleanup()
+    }
+  }, 15000)
+
+  const onAgentEvent = (event) => {
+    try {
+      writeSseEvent(res, event.type || 'agent_event', event)
+    } catch {
+      cleanup()
+    }
+  }
+
+  const cleanup = () => {
+    clearInterval(keepAlive)
+    agentEvents.removeListener('agent_event', onAgentEvent)
+    if (!res.writableEnded) {
+      res.end()
+    }
+  }
+
+  agentEvents.on('agent_event', onAgentEvent)
+
+  req.on('close', cleanup)
+  req.on('error', cleanup)
+  res.on('error', cleanup)
+}
+
+async function handleStream(req, res, sessionId) {
+  // Restore from storage if not already in memory
+  let eventBus = getSessionEventBus(sessionId)
+  if (!eventBus) {
+    const restored = await restoreAgent(sessionId)
+    if (restored) {
+      eventBus = restored.eventBus
+    } else {
+      sendJson(res, 404, { error: 'Session not found' })
+      return
+    }
+  }
+
+  // Only one SSE connection per session — reject with 409 so the client can fall back
+  if (!tryAcquireSse(sessionId)) {
+    sendJson(res, 409, { error: 'Session is already active in another tab' })
+    return
+  }
+
+  // Reset idle timer — active SSE connection keeps session alive
+  touchSession(sessionId)
+
+  // Set SSE headers
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache, no-transform',
+    'connection': 'keep-alive',
+    'x-accel-buffering': 'no',
+  })
+
+  // Send initial state
+  const state = getSessionState(sessionId)
+  if (state) {
+    writeSseEvent(res, 'state', state)
+  }
+
+  // Keep-alive ping every 15 seconds — also resets idle timer
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(': ping\n\n')
+      touchSession(sessionId)
+    } catch {
+      cleanup()
+    }
+  }, 15000)
+
+  // Handle agent events
+  const onAgentEvent = (event) => {
+    try {
+      writeSseEvent(res, event.type, event)
+    } catch {
+      cleanup()
+    }
+  }
+
+  const cleanup = () => {
+    clearInterval(keepAlive)
+    eventBus.removeListener('agent_event', onAgentEvent)
+    releaseSse(sessionId)
+    if (!res.writableEnded) {
+      res.end()
+    }
+  }
+
+  eventBus.on('agent_event', onAgentEvent)
+
+  req.on('close', cleanup)
+  req.on('error', cleanup)
+  res.on('error', cleanup)
+}
+
+function writeSseEvent(res, event, data) {
+  const payload = typeof data === 'string' ? data : JSON.stringify(data)
+  // Split multi-line payloads
+  const lines = payload.split('\n')
+  res.write(`event: ${event}\n`)
+  for (const line of lines) {
+    res.write(`data: ${line}\n`)
+  }
+  res.write('\n')
+}

package/server/routes/backup.mjs

@@ -0,0 +1,250 @@
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { sendJson, readJsonBody } from '../utils/response.mjs'
+import {
+  ensureStorage,
+  readStore,
+  writeStore,
+  readProjectConfigData,
+  writeProjectConfigData,
+  storageDir,
+} from '../storage.mjs'
+import { initializeActiveProject } from '../project-config.mjs'
+import { setActiveWorkspaceRootForFilesystem } from './filesystem.mjs'
+import { getWorkspaceRoot } from '../utils/workspace.mjs'
+
+const BACKUP_VERSION = 1
+const BACKUP_APP = 'quickforge'
+const backupScopes = new Set(['all', 'config', 'sessions'])
+
+function normalizeScope(value) {
+  const scope = String(value || 'all')
+  return backupScopes.has(scope) ? scope : 'all'
+}
+
+function backupTimestamp(date = new Date()) {
+  return date.toISOString().replace(/[:.]/g, '-')
+}
+
+function section(data, key, legacyKey) {
+  if (!data || typeof data !== 'object') return undefined
+  if (Object.prototype.hasOwnProperty.call(data, key)) return data[key]
+  if (legacyKey && Object.prototype.hasOwnProperty.call(data, legacyKey)) return data[legacyKey]
+  return undefined
+}
+
+function assertObjectSection(value, name) {
+  if (value === undefined) return undefined
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    const error = new Error(`Invalid backup section: ${name}`)
+    error.statusCode = 400
+    throw error
+  }
+  return value
+}
+
+function assertProjectConfig(value) {
+  const projectConfig = assertObjectSection(value, 'projects')
+  if (projectConfig === undefined) return undefined
+  if (!Array.isArray(projectConfig.projects)) {
+    const error = new Error('Invalid backup section: projects.projects must be an array')
+    error.statusCode = 400
+    throw error
+  }
+  return {
+    activeProjectId: typeof projectConfig.activeProjectId === 'string' ? projectConfig.activeProjectId : null,
+    projects: projectConfig.projects,
+  }
+}
+
+function filterSessionsByMetadata(sessions, metadata) {
+  if (!sessions || !metadata) return sessions
+  const metadataIds = new Set(Object.keys(metadata))
+  return Object.fromEntries(Object.entries(sessions).filter(([sessionId]) => metadataIds.has(sessionId)))
+}
+
+function normalizeSessionMetadata(sessions, metadata) {
+  if (!sessions) return metadata
+  const sessionsObject = assertObjectSection(sessions, 'sessions')
+  const metadataObject = metadata === undefined ? {} : assertObjectSection(metadata, 'sessionsMetadata')
+  const nextMetadata = {}
+  const now = new Date().toISOString()
+
+  for (const [sessionId, session] of Object.entries(sessionsObject)) {
+    if (!session || typeof session !== 'object' || Array.isArray(session)) continue
+    const existing = metadataObject?.[sessionId]
+    nextMetadata[sessionId] = existing && typeof existing === 'object' && !Array.isArray(existing)
+      ? existing
+      : {
+          id: sessionId,
+          title: typeof session.title === 'string' ? session.title : 'New chat',
+          createdAt: typeof session.createdAt === 'string' ? session.createdAt : now,
+          lastModified: typeof session.lastModified === 'string' ? session.lastModified : now,
+          messageCount: Array.isArray(session.messages) ? session.messages.length : 0,
+          thinkingLevel: typeof session.thinkingLevel === 'string' ? session.thinkingLevel : 'off',
+          preview: '',
+          scope: session.scope === 'project' ? 'project' : 'global',
+          projectId: session.scope === 'project' && session.projectId ? String(session.projectId) : undefined,
+          taskStatus: session.taskStatus || 'idle',
+          taskStartedAt: session.taskStartedAt ?? null,
+          taskFinishedAt: session.taskFinishedAt ?? null,
+        }
+  }
+
+  return nextMetadata
+}
+
+async function buildBackup(scope = 'all') {
+  const normalizedScope = normalizeScope(scope)
+  const includeConfig = normalizedScope === 'all' || normalizedScope === 'config'
+  const includeSessions = normalizedScope === 'all' || normalizedScope === 'sessions'
+  const data = {}
+
+  if (includeConfig) {
+    const [settings, providerKeys, customProviders, projects, scheduledTasks] = await Promise.all([
+      readStore('settings'),
+      readStore('provider-keys'),
+      readStore('custom-providers'),
+      readProjectConfigData(),
+      readStore('scheduled-tasks'),
+    ])
+    Object.assign(data, {
+      settings,
+      providerKeys,
+      customProviders,
+      projects,
+      scheduledTasks,
+    })
+  }
+
+  if (includeSessions) {
+    const [sessions, sessionsMetadata] = await Promise.all([
+      readStore('sessions'),
+      readStore('sessions-metadata'),
+    ])
+    Object.assign(data, {
+      sessions,
+      sessionsMetadata,
+    })
+  }
+
+  return {
+    app: BACKUP_APP,
+    version: BACKUP_VERSION,
+    exportedAt: new Date().toISOString(),
+    scope: normalizedScope,
+    data,
+  }
+}
+
+function normalizeBackupPayload(payload) {
+  const backup = payload?.backup && typeof payload.backup === 'object' ? payload.backup : payload
+  if (!backup || typeof backup !== 'object' || Array.isArray(backup)) {
+    const error = new Error('Invalid backup file')
+    error.statusCode = 400
+    throw error
+  }
+
+  const data = backup.data && typeof backup.data === 'object' && !Array.isArray(backup.data)
+    ? backup.data
+    : backup
+
+  const normalized = {
+    settings: section(data, 'settings'),
+    providerKeys: section(data, 'providerKeys', 'provider-keys'),
+    customProviders: section(data, 'customProviders', 'custom-providers'),
+    projects: section(data, 'projects'),
+    scheduledTasks: section(data, 'scheduledTasks', 'scheduled-tasks'),
+    sessions: section(data, 'sessions'),
+    sessionsMetadata: section(data, 'sessionsMetadata', 'sessions-metadata'),
+  }
+
+  if (Object.values(normalized).every((value) => value === undefined)) {
+    const error = new Error('Backup does not contain any restorable sections')
+    error.statusCode = 400
+    throw error
+  }
+
+  return normalized
+}
+
+async function writeSafetyBackup() {
+  const backup = await buildBackup('all')
+  const dir = path.join(storageDir, 'backups')
+  await fs.mkdir(dir, { recursive: true })
+  const file = path.join(dir, `quickforge-before-restore-${backupTimestamp()}.json`)
+  await fs.writeFile(file, `${JSON.stringify(backup, null, 2)}\n`, 'utf8')
+  return file
+}
+
+async function restoreBackup(payload) {
+  const backup = normalizeBackupPayload(payload)
+  const summary = {}
+
+  const settings = assertObjectSection(backup.settings, 'settings')
+  if (settings !== undefined) {
+    await writeStore('settings', settings)
+    summary.settings = Object.keys(settings).length
+  }
+
+  const providerKeys = assertObjectSection(backup.providerKeys, 'providerKeys')
+  if (providerKeys !== undefined) {
+    await writeStore('provider-keys', providerKeys)
+    summary.providerKeys = Object.keys(providerKeys).length
+  }
+
+  const customProviders = assertObjectSection(backup.customProviders, 'customProviders')
+  if (customProviders !== undefined) {
+    await writeStore('custom-providers', customProviders)
+    summary.customProviders = Object.keys(customProviders).length
+  }
+
+  const projects = assertProjectConfig(backup.projects)
+  if (projects !== undefined) {
+    await writeProjectConfigData(projects)
+    await initializeActiveProject()
+    setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())
+    summary.projects = projects.projects.length
+  }
+
+  const scheduledTasks = assertObjectSection(backup.scheduledTasks, 'scheduledTasks')
+  if (scheduledTasks !== undefined) {
+    await writeStore('scheduled-tasks', scheduledTasks)
+    summary.scheduledTasks = Object.keys(scheduledTasks).length
+  }
+
+  const sessions = assertObjectSection(backup.sessions, 'sessions')
+  const sessionsMetadata = normalizeSessionMetadata(sessions, backup.sessionsMetadata)
+  if (sessions !== undefined) {
+    await writeStore('sessions', filterSessionsByMetadata(sessions, sessionsMetadata))
+    summary.sessions = Object.keys(sessions).length
+  }
+
+  if (sessionsMetadata !== undefined) {
+    await writeStore('sessions-metadata', sessionsMetadata)
+    summary.sessionsMetadata = Object.keys(sessionsMetadata).length
+  }
+
+  return summary
+}
+
+export async function handleBackupApi(req, res, url) {
+  if (req.method === 'GET' && url.pathname === '/api/backup/export') {
+    await ensureStorage()
+    sendJson(res, 200, await buildBackup(url.searchParams.get('scope')))
+    return
+  }
+
+  if (req.method === 'POST' && url.pathname === '/api/backup/import') {
+    await ensureStorage()
+    const body = await readJsonBody(req)
+    const safetyBackupPath = await writeSafetyBackup()
+    const summary = await restoreBackup(body)
+    sendJson(res, 200, { ok: true, safetyBackupPath, summary })
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}

package/server/routes/instructions.mjs

@@ -1,7 +1,6 @@
-import path from 'node:path'
 import { sendJson } from '../utils/response.mjs'
-import { readInstructionsFile, projectContextFromId } from '../project-config.mjs'
-import { dataDir } from '../storage.mjs'
+import { buildInstructionsPayload } from '../project-config.mjs'
+import { BASE_SYSTEM_PROMPT, composeSystemPrompt } from '../system-prompt.mjs'
 
 export async function handleInstructionsApi(req, res, url) {
   if (req.method !== 'GET') {
@@ -11,21 +10,11 @@ export async function handleInstructionsApi(req, res, url) {
   }
 
   const projectId = url.searchParams.get('projectId')
-  let projectInstructions = null
-
-  if (projectId) {
-    try {
-      const { workspaceRoot } = await projectContextFromId(projectId)
-      projectInstructions = await readInstructionsFile(path.join(workspaceRoot, 'AGENTS.md'))
-    } catch {
-      // project not found or inaccessible — leave projectInstructions null
-    }
-  }
-
-  const globalInstructions = await readInstructionsFile(path.join(dataDir, 'AGENTS.md'))
+  const instructions = await buildInstructionsPayload(projectId)
 
   sendJson(res, 200, {
-    global: globalInstructions,
-    project: projectInstructions,
+    base: BASE_SYSTEM_PROMPT,
+    systemPrompt: composeSystemPrompt(instructions),
+    ...instructions,
   })
 }

package/server/routes/project.mjs

@@ -1,7 +1,9 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
-import { getActiveProject, setActiveProjectPath, readProjectConfig, writeProjectConfig } from '../project-config.mjs'
+import { getActiveProject, setActiveProjectPath, readProjectConfig } from '../project-config.mjs'
+import { listProjectCommands } from '../custom-commands.mjs'
+import { atomicProjectConfigUpdate } from '../storage.mjs'
 import { getWorkspaceRoot, setWorkspaceRoot } from '../utils/workspace.mjs'
-import { selectDirectoryDialog } from '../utils/platform.mjs'
+import { selectDirectoryDialog, openPathInFileManager } from '../utils/platform.mjs'
 import path from 'node:path'
 
 export async function handleProjectApi(req, res, url) {
@@ -12,6 +14,25 @@ export async function handleProjectApi(req, res, url) {
     return
   }
 
+  if (req.method === 'GET' && url.pathname === '/api/project/commands') {
+    const projectId = url.searchParams.get('projectId')
+    const project = projectId
+      ? config.projects.find((item) => item.id === projectId)
+      : getActiveProject(config)
+    const commands = project?.path ? await listProjectCommands(project.path) : []
+    sendJson(res, 200, {
+      commands: commands.map((command) => ({
+        name: command.name,
+        description: command.description,
+        argumentHint: command.argumentHint,
+        allowEdit: command.allowEdit,
+        allowCommands: command.allowCommands,
+        relativePath: command.relativePath,
+      })),
+    })
+    return
+  }
+
   if (req.method === 'POST' && url.pathname === '/api/project/select-directory') {
     console.log('[project] Opening directory picker dialog...')
     const selectedPath = await selectDirectoryDialog()
@@ -45,22 +66,37 @@ export async function handleProjectApi(req, res, url) {
     return
   }
 
-  if (req.method === 'DELETE' && url.pathname.startsWith('/api/project/')) {
+  if (req.method === 'POST' && url.pathname.startsWith('/api/project/') && url.pathname.endsWith('/open-in-explorer')) {
     const id = decodeSegment(url.pathname.split('/').filter(Boolean)[2])
-    const nextProjects = config.projects.filter((project) => project.id !== id)
-    if (nextProjects.length === config.projects.length) {
+    const selected = config.projects.find((project) => project.id === id)
+    if (!selected) {
       const error = new Error('Unknown project')
       error.statusCode = 404
       throw error
     }
-    config.projects = nextProjects
-    if (config.activeProjectId === id) config.activeProjectId = config.projects[0]?.id ?? null
-    await writeProjectConfig(config)
-    const active = getActiveProject(config)
+    await openPathInFileManager(selected.path)
+    sendJson(res, 200, { ok: true })
+    return
+  }
+
+  if (req.method === 'DELETE' && url.pathname.startsWith('/api/project/')) {
+    const id = decodeSegment(url.pathname.split('/').filter(Boolean)[2])
+    const updated = await atomicProjectConfigUpdate((cfg) => {
+      const nextProjects = cfg.projects.filter((project) => project.id !== id)
+      if (nextProjects.length === cfg.projects.length) {
+        const error = new Error('Unknown project')
+        error.statusCode = 404
+        throw error
+      }
+      cfg.projects = nextProjects
+      if (cfg.activeProjectId === id) cfg.activeProjectId = cfg.projects[0]?.id ?? null
+      return cfg
+    })
+    const active = getActiveProject(updated)
     if (active?.path) {
       setWorkspaceRoot(path.resolve(active.path))
     }
-    sendJson(res, 200, { project: active ?? null, projects: config.projects, workspaceRoot: getWorkspaceRoot() })
+    sendJson(res, 200, { project: active ?? null, projects: updated.projects, workspaceRoot: getWorkspaceRoot() })
     return
   }