@shawnstack/quickforge 1.4.1 → 1.5.1

package/server/frontmatter.mjs

@@ -0,0 +1,167 @@
+function leadingIndent(line) {
+  const match = String(line || '').match(/^\s*/)
+  return match ? match[0].length : 0
+}
+
+function stripInlineComment(value) {
+  const trimmed = String(value ?? '').trim()
+  if (trimmed.startsWith('"') || trimmed.startsWith("'")) return trimmed
+  const index = trimmed.indexOf(' #')
+  return index >= 0 ? trimmed.slice(0, index).trimEnd() : trimmed
+}
+
+export function parseYamlScalar(value, options = {}) {
+  const trimmed = stripInlineComment(value)
+  if (!trimmed) return ''
+  if (options.booleans !== false) {
+    const normalized = trimmed.toLowerCase()
+    if (normalized === 'true') return true
+    if (normalized === 'false') return false
+  }
+
+  if (
+    (trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+    (trimmed.startsWith("'") && trimmed.endsWith("'"))
+  ) {
+    return trimmed
+      .slice(1, -1)
+      .replace(/\\"/g, '"')
+      .replace(/\\'/g, "'")
+  }
+
+  return trimmed
+}
+
+function collectIndentedBlock(lines, startIndex, parentIndent) {
+  const block = []
+  let index = startIndex
+  while (index < lines.length) {
+    const line = lines[index]
+    if (!line.trim()) {
+      block.push(line)
+      index++
+      continue
+    }
+    if (leadingIndent(line) <= parentIndent) break
+    block.push(line)
+    index++
+  }
+  return { block, nextIndex: index }
+}
+
+function parseBlockScalar(lines, style) {
+  const nonEmpty = lines.filter((line) => line.trim())
+  const minIndent = nonEmpty.length
+    ? Math.min(...nonEmpty.map((line) => leadingIndent(line)))
+    : 0
+  const unindented = lines.map((line) => line.slice(Math.min(minIndent, line.length)))
+  return style === '>'
+    ? unindented.join(' ').replace(/\s+/g, ' ').trim()
+    : unindented.join('\n').trim()
+}
+
+export function parseSimpleYamlMap(text, options = {}) {
+  const result = {}
+  const lines = String(text || '').split(/\r?\n/)
+  let index = 0
+
+  while (index < lines.length) {
+    const line = lines[index]
+    const trimmed = line.trim()
+    if (!trimmed || trimmed.startsWith('#') || leadingIndent(line) > 0) {
+      index++
+      continue
+    }
+
+    const match = line.match(/^([A-Za-z0-9_.-]+):(?:\s*(.*))?$/)
+    if (!match) {
+      index++
+      continue
+    }
+
+    const [, key, rawValue = ''] = match
+    const value = rawValue.trim()
+
+    if (value === '|' || value === '>') {
+      const { block, nextIndex } = collectIndentedBlock(lines, index + 1, 0)
+      result[key] = parseBlockScalar(block, value)
+      index = nextIndex
+      continue
+    }
+
+    if (value) {
+      result[key] = parseYamlScalar(value, options)
+      index++
+      continue
+    }
+
+    const nested = {}
+    let nestedIndex = index + 1
+    while (nestedIndex < lines.length) {
+      const nestedLine = lines[nestedIndex]
+      const nestedTrimmed = nestedLine.trim()
+      if (!nestedTrimmed || nestedTrimmed.startsWith('#')) {
+        nestedIndex++
+        continue
+      }
+
+      const indent = leadingIndent(nestedLine)
+      if (indent <= 0) break
+
+      const nestedMatch = nestedLine.slice(indent).match(/^([A-Za-z0-9_.-]+):(?:\s*(.*))?$/)
+      if (!nestedMatch) {
+        nestedIndex++
+        continue
+      }
+
+      const [, nestedKey, nestedRawValue = ''] = nestedMatch
+      nested[nestedKey] = parseYamlScalar(nestedRawValue.trim(), options)
+      nestedIndex++
+    }
+
+    result[key] = Object.keys(nested).length ? nested : ''
+    index = Object.keys(nested).length ? nestedIndex : index + 1
+  }
+
+  return result
+}
+
+export function parseFrontmatter(text, options = {}) {
+  const normalized = String(text || '').replace(/^\uFEFF/, '')
+  const match = normalized.match(/^---[ \t]*\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)([\s\S]*)$/)
+  if (!match) {
+    return options.requireFrontmatter ? null : { metadata: {}, frontmatter: '', body: normalized.trim() }
+  }
+  return {
+    metadata: parseSimpleYamlMap(match[1], options),
+    frontmatter: match[1],
+    body: match[2].trim(),
+  }
+}
+
+export function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim()) return value.trim()
+  }
+  return undefined
+}
+
+export function firstOptionalBoolean(...values) {
+  for (const value of values) {
+    if (value === true || value === false) return value
+    if (typeof value === 'string') {
+      const normalized = value.trim().toLowerCase()
+      if (normalized === 'true') return true
+      if (normalized === 'false') return false
+    }
+  }
+  return undefined
+}
+
+export function splitDelimitedList(value) {
+  if (Array.isArray(value)) return value.map((item) => String(item || '').trim()).filter(Boolean)
+  return String(value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean)
+}

package/server/index.mjs

@@ -27,13 +27,17 @@ import { handleMcpApi } from './routes/mcp.mjs'
 import { handlePluginsApi } from './routes/plugins.mjs'
 import { handleWorkspaceApi, handleGitApi } from './routes/workspace.mjs'
 import { handleTerminalApi, handleTerminalUpgrade } from './routes/terminal.mjs'
+import { handleChannelsApi } from './routes/channels.mjs'
+import { handleModelsApi } from './routes/models.mjs'
 import { serveStatic } from './routes/static.mjs'
 import { logger, flushLogger } from './utils/logger.mjs'
+import { getPackageInfo, checkForUpdates, installLatestVersion } from './utils/package-update.mjs'
 import { installAiHttpLogger } from './ai-http-logger.mjs'
 import { isLoopbackAddress, getLanUrls } from './utils/network.mjs'
 import { parseCookies } from './share-store.mjs'
 import { lanAccessCookieName, verifyLanAccessToken } from './lan-access-store.mjs'
 import { shutdown as shutdownAgentManager, resetStaleTaskStatuses } from './agent-manager.mjs'
+import { initializeChannels, shutdownChannels } from './channels/registry.mjs'
 import { shutdownMcpConnections } from './mcp/registry.mjs'
 import { shutdownTerminalSessions } from './terminal/terminal-manager.mjs'
 
@@ -54,8 +58,9 @@ if (!['127.0.0.1', 'localhost'].includes(host) && process.env.QUICKFORGE_ALLOW_R
 const port = Number(process.env.QUICKFORGE_PORT || (isDev ? 32176 : 5176))
 const vitePort = Number(process.env.QUICKFORGE_VITE_PORT || 5176)
 let restartInProgress = false
+let updateInProgress = false
 
-setDefaultWorkspaceRoot(process.env.QUICKFORGE_WORKSPACE_DIR || projectRoot)
+setDefaultWorkspaceRoot(process.env.QUICKFORGE_WORKSPACE_DIR || path.join(dataDir, 'workspace'))
 installAiHttpLogger()
 
 function getRestartSupport() {
@@ -139,6 +144,7 @@ async function performRestart() {
   stopVite()
   await shutdownAgentManager()
   await shutdownMcpConnections()
+  await shutdownChannels()
   shutdownTerminalSessions()
   await closeHttpServer()
   process.exit(0)
@@ -169,6 +175,29 @@ async function requestRestart() {
   return { ok: true, restarting: true, bootId }
 }
 
+async function updateQuickForge() {
+  if (updateInProgress) {
+    const error = new Error('Update already in progress')
+    error.statusCode = 423
+    throw error
+  }
+
+  updateInProgress = true
+  try {
+    const update = await checkForUpdates(projectRoot)
+    if (!update.updateAvailable) {
+      return { ...update, ok: true, updated: false }
+    }
+
+    logger.info(`Updating QuickForge from ${update.currentVersion} to ${update.latestVersion}.`)
+    await installLatestVersion(update.name, { cwd: projectRoot })
+    logger.info('QuickForge update completed.')
+    return { ...update, ok: true, updated: true }
+  } finally {
+    updateInProgress = false
+  }
+}
+
 // --- Route dispatching ---
 async function handleApi(req, res, url) {
   const pathname = url.pathname
@@ -216,6 +245,12 @@ async function handleApi(req, res, url) {
     return
   }
 
+  // Custom model management (connection test)
+  if (pathname === '/api/models/test-connection') {
+    await handleModelsApi(req, res, url)
+    return
+  }
+
   // Skills
   if (pathname === '/api/skills' || pathname.startsWith('/api/skills/')) {
     await handleSkillsApi(req, res, url)
@@ -228,6 +263,14 @@ async function handleApi(req, res, url) {
     return
   }
 
+  // Channels
+  if (pathname === '/api/channels' || pathname.startsWith('/api/channels/')) {
+    await handleChannelsApi(req, res, url, {
+      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
+    })
+    return
+  }
+
   // Plugins
   if (pathname === '/api/plugins' || pathname.startsWith('/api/plugins/')) {
     await handlePluginsApi(req, res, url)
@@ -241,7 +284,7 @@ async function handleApi(req, res, url) {
   }
 
   // Project workspace inspector routes
-  if (pathname === '/api/workspace/tree' || pathname === '/api/workspace/file' || pathname === '/api/workspace/resolve-path') {
+  if (pathname === '/api/workspace/tree' || pathname === '/api/workspace/file' || pathname === '/api/workspace/resolve-path' || pathname.startsWith('/api/workspace/preview/')) {
     await handleWorkspaceApi(req, res, url)
     return
   }
@@ -288,10 +331,14 @@ async function handleApi(req, res, url) {
   }
 
   // System routes
-  if (pathname === '/api/system/status' || pathname === '/api/system/restart' || pathname === '/api/system/network' || pathname === '/api/system/terminal-shell') {
+  if (pathname === '/api/system/status' || pathname === '/api/system/restart' || pathname === '/api/system/network' || pathname === '/api/system/terminal-shell' || pathname === '/api/system/about' || pathname === '/api/system/update/check' || pathname === '/api/system/update') {
     await handleSystemApi(req, res, url, {
       getSystemStatus,
       requestRestart,
+      getPackageInfo: () => getPackageInfo(projectRoot),
+      checkForUpdates: () => checkForUpdates(projectRoot),
+      updateQuickForge,
+      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
       getTerminalShellSetting: readTerminalShellSetting,
       updateTerminalShellSetting,
       getTerminalShellConfig: readTerminalShellConfig,
@@ -532,6 +579,7 @@ server.on('upgrade', (req, socket, head) => {
 })
 
 await ensureStorage()
+initializeChannels({ projectRoot })
 await resetStaleTaskStatuses()
 await initializeActiveProject()
 setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())
@@ -577,6 +625,7 @@ async function gracefulShutdown(signal) {
   stopVite()
   await shutdownAgentManager()
   await shutdownMcpConnections()
+  await shutdownChannels()
   shutdownTerminalSessions()
   flushLogger()
   process.exit(0)

package/server/project-config.mjs

@@ -13,10 +13,44 @@ export function setDefaultWorkspaceRoot(root) {
   defaultWorkspaceRoot = path.resolve(root)
 }
 
+export function getDefaultWorkspaceRoot() {
+  return defaultWorkspaceRoot
+}
+
+// Synthetic workspace context for global conversations (no projectId).
+// Gives global chats the same file-tool capabilities as project chats, rooted
+// at the default workspace directory (~/.quickforge/workspace by default). The
+// synthetic `project` object (id 'default') lets workspace/git/terminal REST
+// endpoints and subagents keep working without a real registered project.
+export function defaultGlobalWorkspaceContext() {
+  return {
+    project: {
+      id: 'default',
+      name: 'workspace',
+      path: defaultWorkspaceRoot,
+      lastOpenedAt: '',
+      sortOrder: 0,
+      skills: [],
+      commandDir: '',
+    },
+    workspaceRoot: defaultWorkspaceRoot,
+  }
+}
+
 function projectNameFromPath(dir) {
   return path.basename(dir) || dir
 }
 
+// Compare two project paths for equality in a cross-platform way.
+// On Windows (and other case-insensitive filesystems) drive-letter casing and
+// path separators can differ while pointing at the same directory. Normalize
+// both sides to a resolved lowercase form so the same directory always matches
+// an existing project instead of being re-registered with a new id.
+export function sameProjectPath(a, b) {
+  if (!a || !b) return false
+  return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase()
+}
+
 function defaultProjectConfig() {
   return {
     activeProjectId: null,
@@ -222,7 +256,7 @@ export async function setActiveProjectPath(inputPath) {
   let project
 
   const updated = await atomicProjectConfigUpdate((config) => {
-    project = config.projects.find((item) => path.resolve(item.path) === resolved)
+    project = config.projects.find((item) => sameProjectPath(item.path, resolved))
     if (!project) {
       project = {
         id: randomUUID(),
@@ -264,16 +298,19 @@ export async function initializeActiveProject() {
     }
   }
 
-  // No project configured — leave workspace unset, user will be prompted to add one.
+  // No project configured — fall back to the default workspace root so global
+  // conversations still have a working directory and the filesystem browser works.
+  setWorkspaceRoot(defaultWorkspaceRoot)
 }
 
 export async function projectContextFromId(projectId) {
   const config = await readProjectConfig()
   const project = config.projects.find((item) => item.id === projectId)
   if (!project) {
-    const error = new Error('Unknown project')
-    error.statusCode = 404
-    throw error
+    // Unknown or removed project (e.g. a global conversation's synthetic id) —
+    // fall back to the default workspace so workspace/git REST endpoints keep
+    // working for global conversations.
+    return defaultGlobalWorkspaceContext()
   }
 
   await assertDirectory(project.path)
@@ -375,7 +412,7 @@ export async function buildInstructionsPayload(projectId) {
           name: project.name,
           root: project.path,
         }
-      : null,
+      : (defaultWorkspaceRoot ? { name: 'workspace', root: defaultWorkspaceRoot } : null),
     global: globalInstructions,
     project: projectInstructions,
     globalSources: globalInstructionSources,

package/server/routes/agent-profiles.mjs

@@ -3,6 +3,7 @@ import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'
 import {
+  agentProfileSnapshot,
   createCustomAgentProfile,
   deleteCustomAgentProfile,
   getAgentProfile,
@@ -120,7 +121,8 @@ export async function handleAgentProfilesApi(req, res, url) {
   const parts = url.pathname.split('/').filter(Boolean)
 
   if (req.method === 'GET' && url.pathname === '/api/agent-profiles') {
-    sendJson(res, 200, { agents: await listAgentProfiles({ includeDisabled: true }) })
+    const agents = await listAgentProfiles({ includeDisabled: true })
+    sendJson(res, 200, { agents: agents.map(agentProfileSnapshot) })
     return
   }
 
@@ -147,13 +149,14 @@ export async function handleAgentProfilesApi(req, res, url) {
     if (req.method === 'GET') {
       const agent = await getAgentProfile(id)
       if (!agent) throw requestError('Agent not found', 404)
-      sendJson(res, 200, { agent })
+      sendJson(res, 200, { agent: agentProfileSnapshot(agent) })
       return
     }
 
     if (req.method === 'PATCH' || req.method === 'PUT') {
       const current = await getAgentProfile(id)
       if (current?.builtin) throw requestError('Built-in agents cannot be modified', 403)
+      if (current?.readonly) throw requestError('File-based agents cannot be modified from the API', 403)
       const body = await readJsonBody(req)
       sendJson(res, 200, { agent: await updateCustomAgentProfile(id, body || {}) })
       return
@@ -162,6 +165,7 @@ export async function handleAgentProfilesApi(req, res, url) {
     if (req.method === 'DELETE') {
       const current = await getAgentProfile(id)
       if (current?.builtin) throw requestError('Built-in agents cannot be deleted', 403)
+      if (current?.readonly) throw requestError('File-based agents cannot be deleted from the API', 403)
       await deleteCustomAgentProfile(id)
       sendJson(res, 200, { ok: true })
       return

package/server/routes/agent.mjs

@@ -16,6 +16,7 @@ import {
   touchSession,
   listSessions,
   refreshAllSessionTools,
+  updateSessionAccessMode,
   updateSessionYoloMode,
   updateSessionModel,
   updateSessionThinkingLevel,
@@ -140,6 +141,8 @@ export async function handleAgentApi(req, res, url) {
       status: session.status,
       scope: session.scope,
       title: session.title,
+      accessMode: session.accessMode,
+      yoloMode: session.yoloMode,
     })
     return
   }
@@ -151,7 +154,15 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
-  // POST /api/agents/:sessionId/yolo-mode — update session YOLO mode
+  // POST /api/agents/:sessionId/access-mode — update session Agent access mode
+  if (req.method === 'POST' && subPath === 'access-mode') {
+    const body = await readJsonBody(req)
+    const result = await updateSessionAccessMode(sessionId, body?.accessMode)
+    sendJson(res, 200, result)
+    return
+  }
+
+  // POST /api/agents/:sessionId/yolo-mode — legacy compatibility for old clients
   if (req.method === 'POST' && subPath === 'yolo-mode') {
     const body = await readJsonBody(req)
     const result = await updateSessionYoloMode(sessionId, body?.yoloMode === true)

package/server/routes/channels.mjs

@@ -0,0 +1,145 @@
+import { sendJson, decodeSegment, readJsonBody } from '../utils/response.mjs'
+import {
+  channelEvents,
+  getChannelStatus,
+  listChannels,
+  restartChannel,
+  runChannelAction,
+  startChannel,
+  stopChannel,
+} from '../channels/registry.mjs'
+
+function assertLocal(context) {
+  if (!context.isLocalRequest) {
+    const error = new Error('Channel management is only allowed from this computer')
+    error.statusCode = 403
+    throw error
+  }
+}
+
+function assertActionHeader(req) {
+  if (req.headers['x-quickforge-action'] !== 'channel-action') {
+    const error = new Error('Forbidden action')
+    error.statusCode = 403
+    throw error
+  }
+}
+
+async function readActionOptions(req) {
+  if (!['POST', 'PUT', 'PATCH'].includes(req.method || '')) return {}
+  const contentType = String(req.headers['content-type'] || '')
+  if (!contentType.toLowerCase().includes('application/json')) return {}
+  return await readJsonBody(req, 64 * 1024) || {}
+}
+
+export async function handleChannelsApi(req, res, url, context = {}) {
+  const pathname = url.pathname
+  const parts = pathname.split('/').filter(Boolean)
+
+  if (req.method === 'GET' && pathname === '/api/channels') {
+    sendJson(res, 200, { channels: listChannels() })
+    return
+  }
+
+  if (req.method === 'GET' && pathname === '/api/channels/events') {
+    handleChannelEvents(req, res)
+    return
+  }
+
+  if (parts.length < 3 || parts[0] !== 'api' || parts[1] !== 'channels') {
+    const error = new Error('Not found')
+    error.statusCode = 404
+    throw error
+  }
+
+  const channelId = decodeSegment(parts[2])
+  const subPath = parts.slice(3).map(decodeSegment)
+
+  if (req.method === 'GET' && subPath.length === 0) {
+    sendJson(res, 200, getChannelStatus(channelId))
+    return
+  }
+
+  if (req.method === 'GET' && subPath[0] === 'status') {
+    sendJson(res, 200, getChannelStatus(channelId))
+    return
+  }
+
+  assertLocal(context)
+
+  if (req.method === 'POST' && subPath[0] === 'start') {
+    assertActionHeader(req)
+    sendJson(res, 202, await startChannel(channelId, await readActionOptions(req)))
+    return
+  }
+
+  if (req.method === 'POST' && subPath[0] === 'stop') {
+    assertActionHeader(req)
+    sendJson(res, 202, await stopChannel(channelId))
+    return
+  }
+
+  if (req.method === 'POST' && subPath[0] === 'restart') {
+    assertActionHeader(req)
+    sendJson(res, 202, await restartChannel(channelId, await readActionOptions(req)))
+    return
+  }
+
+  if (req.method === 'POST' && subPath[0] === 'actions' && subPath[1]) {
+    assertActionHeader(req)
+    sendJson(res, 202, await runChannelAction(channelId, subPath[1], await readActionOptions(req)))
+    return
+  }
+
+  const error = new Error('Not found')
+  error.statusCode = 404
+  throw error
+}
+
+function handleChannelEvents(req, res) {
+  res.writeHead(200, {
+    'content-type': 'text/event-stream',
+    'cache-control': 'no-cache, no-transform',
+    connection: 'keep-alive',
+    'x-accel-buffering': 'no',
+  })
+
+  writeSseEvent(res, 'snapshot', { type: 'snapshot', channels: listChannels(), timestamp: new Date().toISOString() })
+
+  const keepAlive = setInterval(() => {
+    try {
+      res.write(': ping\n\n')
+    } catch {
+      cleanup()
+    }
+  }, 15000)
+
+  const onChannelEvent = (event) => {
+    try {
+      writeSseEvent(res, event.type || 'channel_event', event)
+    } catch {
+      cleanup()
+    }
+  }
+
+  const cleanup = () => {
+    clearInterval(keepAlive)
+    channelEvents.removeListener('channel_event', onChannelEvent)
+    if (!res.writableEnded) res.end()
+  }
+
+  channelEvents.on('channel_event', onChannelEvent)
+  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)
+  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/models.mjs

@@ -0,0 +1,68 @@
+import { streamSimple } from '@earendil-works/pi-ai'
+import { sendJson, readJsonBody } from '../utils/response.mjs'
+import { readStore } from '../storage.mjs'
+import { logger } from '../utils/logger.mjs'
+
+function requestError(message, statusCode = 400) {
+  const error = new Error(message)
+  error.statusCode = statusCode
+  return error
+}
+
+async function getApiKey(provider) {
+  try {
+    const keys = await readStore('provider-keys')
+    return keys?.[provider] || undefined
+  } catch {
+    return undefined
+  }
+}
+
+// Send a minimal one-token request to verify the endpoint is reachable and the
+// API key is valid. Returns { ok: true } on success; throws on failure.
+async function probeModelConnection(model, apiKeyOverride) {
+  const apiKey = apiKeyOverride || (await getApiKey(model?.provider))
+  const stream = streamSimple(
+    model,
+    {
+      systemPrompt: 'You are a connectivity test. Reply with a single word.',
+      messages: [{ role: 'user', content: 'hi', timestamp: Date.now() }],
+      tools: [],
+    },
+    {
+      apiKey,
+      maxTokens: 16,
+      temperature: 0,
+      // Keep reasoning off so thinking-capable models don't require extra tokens.
+      reasoning: undefined,
+      maxRetryDelayMs: 30000,
+    },
+  )
+  await stream.result()
+  return { ok: true }
+}
+
+export async function handleModelsApi(req, res, url) {
+  if (req.method === 'POST' && url.pathname === '/api/models/test-connection') {
+    const body = await readJsonBody(req)
+    const model = body?.model
+    const apiKeyOverride =
+      typeof body?.apiKey === 'string' && body.apiKey.trim() ? body.apiKey.trim() : undefined
+
+    if (!model || !model.id || !model.baseUrl) {
+      throw requestError('model and baseUrl are required')
+    }
+
+    try {
+      const result = await probeModelConnection(model, apiKeyOverride)
+      sendJson(res, 200, result)
+    } catch (error) {
+      logger.warn('Model connection test failed:', error?.message || error)
+      // Return 200 with { ok:false } so the client can parse success/failure uniformly.
+      sendJson(res, 200, { ok: false, error: error?.message || String(error) })
+    }
+    return
+  }
+
+  throw requestError('Not found', 404)
+}

package/server/routes/project.mjs

@@ -1,5 +1,5 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
-import { getActiveProject, setActiveProjectPath, readProjectConfig } from '../project-config.mjs'
+import { getActiveProject, setActiveProjectPath, readProjectConfig, getDefaultWorkspaceRoot } from '../project-config.mjs'
 import { listProjectCommands, createCommandFile } from '../custom-commands.mjs'
 import { atomicProjectConfigUpdate } from '../storage.mjs'
 import { getWorkspaceRoot, setWorkspaceRoot } from '../utils/workspace.mjs'
@@ -11,7 +11,7 @@ export async function handleProjectApi(req, res, url) {
 
   if (req.method === 'GET' && url.pathname === '/api/project') {
     const sorted = [...config.projects].sort((a, b) => (a.sortOrder ?? 0) - (b.sortOrder ?? 0))
-    sendJson(res, 200, { project: getActiveProject(config), projects: sorted, workspaceRoot: getWorkspaceRoot() })
+    sendJson(res, 200, { project: getActiveProject(config), projects: sorted, workspaceRoot: getWorkspaceRoot(), defaultWorkspaceRoot: getDefaultWorkspaceRoot() })
     return
   }