@shawnstack/quickforge 1.4.1 → 1.5.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
   }
 

package/server/routes/scheduled-tasks.mjs

@@ -585,11 +585,7 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
   let sessionId = `scheduled-${task.id}-${Date.now().toString(36)}`
   let executionAgent = null
   let agentWarning = null
-  if (task.agentId) {
-    executionAgent = await getAgentProfile(task.agentId)
-    if (!executionAgent) agentWarning = `Configured agent not found: ${task.agentId}`
-  }
-  const agentSnapshot = executionAgent ? agentProfileSnapshot(executionAgent) : null
+  let agentSnapshot = null
 
   let started = false
   await updateTask(task.id, (current) => {
@@ -630,6 +626,11 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
 
   try {
     const executionProject = await resolveExecutionProject(task)
+    if (task.agentId) {
+      executionAgent = await getAgentProfile(task.agentId, { projectId: executionProject?.id || null, workspaceRoot: executionProject?.path })
+      if (!executionAgent) agentWarning = `Configured agent not found: ${task.agentId}`
+    }
+    agentSnapshot = executionAgent ? agentProfileSnapshot(executionAgent) : null
     const settings = await readStore('settings')
     const yoloMode = settings?.['yolo-mode'] === true || settings?.['yolo-mode'] === 'true'
 

package/server/routes/storage.mjs

@@ -5,6 +5,7 @@ import { directorySize } from '../utils/workspace.mjs'
 
 const metadataIndexCache = new Map()
 const MAX_METADATA_INDEX_CACHE_ENTRIES = 50
+const METADATA_INDEX_CACHE_TTL_MS = 1000
 
 function metadataIndexCacheKey({ scope, projectId, indexName, direction }) {
   return JSON.stringify({ scope: scope || '', projectId: projectId || '', indexName, direction })
@@ -47,7 +48,8 @@ async function readIndexedValues(store, indexName, direction, scope, projectId)
   const revision = getStoreRevision(store)
   const key = metadataIndexCacheKey({ scope, projectId, indexName, direction })
   const cached = metadataIndexCache.get(key)
-  if (cached && cached.revision === revision) return cached.values
+  const now = Date.now()
+  if (cached && cached.revision === revision && now - cached.cachedAt < METADATA_INDEX_CACHE_TTL_MS) return cached.values
 
   const data = scope
     ? await readSessionStoreScoped(store, scope, scope === 'project' ? projectId : undefined)
@@ -59,7 +61,7 @@ async function readIndexedValues(store, indexName, direction, scope, projectId)
     direction,
   )
 
-  metadataIndexCache.set(key, { revision, values })
+  metadataIndexCache.set(key, { revision, values, cachedAt: now })
   if (metadataIndexCache.size > MAX_METADATA_INDEX_CACHE_ENTRIES) {
     const firstKey = metadataIndexCache.keys().next().value
     if (firstKey) metadataIndexCache.delete(firstKey)

package/server/routes/system.mjs

@@ -2,6 +2,33 @@ import { sendJson, readJsonBody } from '../utils/response.mjs'
 import { getLanUrls } from '../utils/network.mjs'
 
 export async function handleSystemApi(req, res, url, context) {
+  if (req.method === 'GET' && url.pathname === '/api/system/about') {
+    sendJson(res, 200, await context.getPackageInfo())
+    return
+  }
+
+  if (req.method === 'GET' && url.pathname === '/api/system/update/check') {
+    sendJson(res, 200, await context.checkForUpdates())
+    return
+  }
+
+  if (req.method === 'POST' && url.pathname === '/api/system/update') {
+    if (!context.isLocalRequest) {
+      const error = new Error('Update is only allowed from this computer')
+      error.statusCode = 403
+      throw error
+    }
+
+    if (req.headers['x-quickforge-action'] !== 'update') {
+      const error = new Error('Forbidden action')
+      error.statusCode = 403
+      throw error
+    }
+
+    sendJson(res, 200, await context.updateQuickForge())
+    return
+  }
+
   if (req.method === 'POST' && url.pathname === '/api/system/restart') {
     if (req.headers['x-quickforge-action'] !== 'restart') {
       const error = new Error('Forbidden action')

package/server/routes/tools.mjs

@@ -4,6 +4,7 @@ import { toolHandlers, loadSkillToolContext } from '../tools/index.mjs'
 import { createSkillTools, workspaceTools } from '../tools/definitions.mjs'
 import { createMcpToolDefinitions } from '../mcp/registry.mjs'
 import { callPluginTool, createPluginToolDefinitions, isPluginToolName } from '../plugins/registry.mjs'
+import { safeReadTools } from '../approval-store.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 
 const directRouteDisabledTools = new Set(['run_subagent'])
@@ -26,13 +27,22 @@ export async function handleGetTools(_req, res) {
 
 const workspaceToolNames = new Set(workspaceTools.map((tool) => tool.name))
 
-async function assertYoloEnabledForTool(name) {
-  if (!workspaceToolNames.has(name)) return
+function normalizeAccessMode(value, fallback = 'default') {
+  if (value === 'default' || value === 'full-access') return value
+  if (value === true || value === 'true') return 'full-access'
+  if (value === false || value === 'false') return 'default'
+  if (fallback !== value) return normalizeAccessMode(fallback, 'default')
+  return 'default'
+}
+
+async function assertAccessModeAllowsDirectTool(name) {
+  const protectedTool = workspaceToolNames.has(name) || isPluginToolName(name)
+  if (!protectedTool || safeReadTools.has(name)) return
 
   const settings = await readStore('settings')
-  const yoloMode = settings?.['yolo-mode'] === true || settings?.['yolo-mode'] === 'true'
-  if (!yoloMode) {
-    const error = new Error('YOLO mode is disabled. Enable it to use this tool.')
+  const accessMode = normalizeAccessMode(settings?.['agent-access-mode'], settings?.['yolo-mode'])
+  if (accessMode !== 'full-access') {
+    const error = new Error('Full access permission is required to execute this tool directly.')
     error.statusCode = 403
     throw error
   }
@@ -74,6 +84,7 @@ export async function handleToolApi(req, res, url) {
   }
 
   if (isPluginToolName(name)) {
+    await assertAccessModeAllowsDirectTool(name)
     const params = await readJsonBody(req)
     const result = await callPluginTool(name, params || {}, context)
     sendJson(res, 200, result)
@@ -87,7 +98,7 @@ export async function handleToolApi(req, res, url) {
     throw error
   }
 
-  await assertYoloEnabledForTool(name)
+  await assertAccessModeAllowsDirectTool(name)
 
   const params = await readJsonBody(req)
   const result = await handler(params || {}, context)