@shawnstack/quickforge 1.4.0 → 1.5.0

package/server/context-usage.mjs

@@ -0,0 +1,108 @@
+import {
+  estimateContextTokens,
+  estimateTokens,
+  shouldCompact,
+} from '@earendil-works/pi-agent-core'
+
+function safeJson(value) {
+  try {
+    return JSON.stringify(value)
+  } catch {
+    return ''
+  }
+}
+
+function normalizeMessageForTokenEstimate(message) {
+  if (!message || typeof message !== 'object') return message
+  if (message.role !== 'user-with-attachments') return message
+
+  const content = typeof message.content === 'string'
+    ? [{ type: 'text', text: message.content }]
+    : Array.isArray(message.content)
+      ? [...message.content]
+      : []
+
+  if (Array.isArray(message.attachments)) {
+    for (const attachment of message.attachments) {
+      if (attachment?.type === 'image' && attachment.content) {
+        content.push({ type: 'image', data: attachment.content, mimeType: attachment.mimeType })
+      } else if (attachment?.type === 'document' && attachment.extractedText) {
+        content.push({ type: 'text', text: `\n\n[Document: ${attachment.fileName || 'Untitled'}]\n${attachment.extractedText}` })
+      }
+    }
+  }
+
+  return { ...message, role: 'user', content }
+}
+
+function normalizeMessagesForTokenEstimate(messages) {
+  return (Array.isArray(messages) ? messages : []).map(normalizeMessageForTokenEstimate)
+}
+
+function textTokens(text) {
+  if (!text) return 0
+  return estimateTokens({ role: 'user', content: String(text), timestamp: 0 })
+}
+
+function localMessagesTokens(messages) {
+  return normalizeMessagesForTokenEstimate(messages).reduce((total, message) => total + estimateTokens(message), 0)
+}
+
+export function estimateContextUsage({ systemPrompt, messages, tools, model }) {
+  const contextWindow = Number(model?.contextWindow) || 0
+  const reservedOutputTokens = Math.max(0, Number(model?.maxTokens) || 4096)
+  const normalizedMessages = normalizeMessagesForTokenEstimate(messages)
+  const coreEstimate = estimateContextTokens(normalizedMessages)
+  const systemPromptTokens = textTokens(systemPrompt)
+  const toolsTokens = textTokens(safeJson(tools))
+  const messagesTokens = localMessagesTokens(normalizedMessages)
+  const estimatedInputTokens = systemPromptTokens + messagesTokens + toolsTokens
+  const providerBasedContextTokens = Math.max(0, Number(coreEstimate.usageTokens) || 0) > 0
+    ? Math.max(0, Number(coreEstimate.tokens) || 0)
+    : 0
+  const inputTokens = providerBasedContextTokens > 0
+    ? Math.max(estimatedInputTokens, providerBasedContextTokens)
+    : estimatedInputTokens
+  const totalTokens = inputTokens + reservedOutputTokens
+  const percent = contextWindow > 0 ? Math.round((totalTokens / contextWindow) * 1000) / 10 : 0
+  const inputTokenSource = providerBasedContextTokens > 0
+    ? providerBasedContextTokens >= estimatedInputTokens ? 'provider' : 'mixed'
+    : 'estimated'
+
+  return {
+    inputTokens,
+    estimatedInputTokens,
+    knownInputTokens: providerBasedContextTokens,
+    providerContextTokens: providerBasedContextTokens,
+    inputTokenSource,
+    reservedOutputTokens,
+    totalTokens,
+    contextWindow,
+    percent,
+    breakdown: {
+      systemPromptTokens,
+      messagesTokens,
+      toolsTokens,
+      reservedOutputTokens,
+      providerUsageTokens: Math.max(0, Number(coreEstimate.usageTokens) || 0),
+      trailingTokens: Math.max(0, Number(coreEstimate.trailingTokens) || 0),
+      lastUsageIndex: coreEstimate.lastUsageIndex,
+      localEstimatedContextTokens: estimatedInputTokens,
+    },
+  }
+}
+
+export function shouldCompactContextByPercent(usage, thresholdPercent) {
+  const contextWindow = Number(usage?.contextWindow) || 0
+  const totalTokens = Math.max(0, Number(usage?.totalTokens) || 0)
+  const threshold = Math.min(100, Math.max(0, Number(thresholdPercent) || 0))
+  if (!contextWindow) return false
+
+  const thresholdTokens = Math.ceil(contextWindow * threshold / 100)
+  const reserveTokens = Math.min(contextWindow, Math.max(0, contextWindow - thresholdTokens + 1))
+  return shouldCompact(totalTokens, contextWindow, {
+    enabled: true,
+    reserveTokens,
+    keepRecentTokens: 0,
+  })
+}

package/server/custom-commands.mjs

@@ -1,11 +1,64 @@
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
 import { getEnabledPluginCommandSources } from './plugins/registry.mjs'
+import { userCommandsDir } from './storage.mjs'
 
 const commandsRelativeDirs = ['.claude/commands', '.opencode/commands', '.ai/commands']
 const commandsRelativeDir = '.ai/commands'
 const commandNamePattern = /^(?!.*--)[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/
 
+/**
+ * Centralized metadata for all built-in slash commands.
+ * This is the single source of truth used by /help output.
+ * Front-end i18n descriptions (i18n.ts) should be kept in sync with the
+ * `description` values here.
+ */
+const builtinCommandCatalog = [
+  {
+    name: 'plan',
+    description: 'Create a plan first; this turn cannot edit files or run commands.',
+    argumentHint: '[task]',
+    permissionNote: 'read-only',
+  },
+  {
+    name: 'review',
+    description: 'Review pending code changes before commit; this turn cannot edit files.',
+    argumentHint: '[scope]',
+    permissionNote: 'no edits',
+  },
+  {
+    name: 'summary',
+    description: 'Create a new chat with this conversation summarized to reduce context usage.',
+    argumentHint: '',
+  },
+  {
+    name: 'compact',
+    description: 'Compact this conversation context in place using the same rolling summary as auto-compaction.',
+    argumentHint: '',
+  },
+  {
+    name: 'clear',
+    description: 'Clear the current chat history and context without calling the model.',
+    argumentHint: '',
+  },
+  {
+    name: 'commands',
+    description: 'List custom commands (project, user-level, and plugin).',
+    argumentHint: '',
+  },
+  {
+    name: 'command new',
+    description: 'Create a project custom command template.',
+    argumentHint: '<name>',
+  },
+  {
+    name: 'help',
+    aliases: ['?'],
+    description: 'Show available commands and their usage.',
+    argumentHint: '',
+  },
+]
+
 function normalizeCommandName(value) {
   const name = String(value || '').trim().toLowerCase()
   return commandNamePattern.test(name) ? name : null
@@ -103,7 +156,7 @@ function firstOptionalBoolean(...values) {
   return undefined
 }
 
-function commandFromFile(file, text, options = {}) {
+export function commandFromFile(file, text, options = {}) {
   const parsed = parseFrontmatter(text)
   if (!parsed.body) return null
 
@@ -229,13 +282,27 @@ async function listPluginCommands(workspaceRoot) {
   return commands
 }
 
+async function listUserCommands() {
+  return listCommandsFromDirectory(userCommandsDir, {
+    source: 'user',
+    relativeRoot: '~/.quickforge/commands',
+  })
+}
+
 export async function listProjectCommands(workspaceRoot, commandDir) {
   const byName = new Map()
 
+  // 1. Plugin commands (lowest priority)
   for (const command of (await listPluginCommands(workspaceRoot)).sort((a, b) => a.name.localeCompare(b.name))) {
     byName.set(command.name, command)
   }
 
+  // 2. User-level commands (~/.quickforge/commands/) — override plugins, overridden by project
+  for (const command of (await listUserCommands()).sort((a, b) => a.name.localeCompare(b.name))) {
+    byName.set(command.name, command)
+  }
+
+  // 3. Project directories: .claude → .opencode → .ai → configured (highest priority)
   for (const dir of commandDirectories(workspaceRoot, commandDir)) {
     const commands = await listCommandsFromDirectory(dir)
     for (const command of commands.sort((a, b) => a.name.localeCompare(b.name))) {
@@ -297,6 +364,7 @@ function escapeXml(value) {
 
 export function parseInternalCommandInvocation(message) {
   const text = textFromUserMessage(message).trim()
+  if (/^\/(?:help|\?)(?:\s+.*)?$/i.test(text)) return { type: 'help' }
   if (/^\/commands(?:\s+.*)?$/i.test(text)) return { type: 'list' }
   if (/^\/clear\s*$/i.test(text)) return { type: 'clear' }
   if (/^\/clear(?:\s+[\s\S]+)$/i.test(text)) return { type: 'invalid-clear-args' }
@@ -310,6 +378,9 @@ export function parseInternalCommandInvocation(message) {
   const compactMatch = text.match(/^\/compact(?:\s+([\s\S]*))?$/i)
   if (compactMatch) return { type: 'compact', args: (compactMatch[1] || '').trim() }
 
+  const summaryMatch = text.match(/^\/summary(?:\s+([\s\S]*))?$/i)
+  if (summaryMatch) return { type: 'summary', args: (summaryMatch[1] || '').trim() }
+
   const createMatch = text.match(/^\/command\s+new\s+([A-Za-z0-9][A-Za-z0-9-]*)\s*$/i)
   if (createMatch) {
     const name = normalizeCommandName(createMatch[1])
@@ -326,6 +397,10 @@ export async function handleInternalCommand(invocation, workspaceRoot, commandDi
     return { compact: true, args: invocation.args || '' }
   }
 
+  if (invocation.type === 'summary') {
+    return { summary: true, args: invocation.args || '' }
+  }
+
   if (invocation.type === 'plan') {
     if (!invocation.args) return 'Usage: /plan <task>'
     return { plan: true, args: invocation.args }
@@ -344,14 +419,19 @@ export async function handleInternalCommand(invocation, workspaceRoot, commandDi
     return 'Usage: /clear'
   }
 
-  if (!workspaceRoot) {
-    return 'Custom commands require an active project chat.'
+  if (invocation.type === 'help') {
+    return formatHelpText(await listProjectCommands(workspaceRoot, commandDir))
   }
 
+  // /commands and /help work without a project (user-level commands are global)
   if (invocation.type === 'list') {
     return formatCommandList(await listProjectCommands(workspaceRoot, commandDir))
   }
 
+  if (!workspaceRoot) {
+    return 'Custom commands require an active project chat.'
+  }
+
   if (invocation.type === 'new') {
     return createCommandTemplate(workspaceRoot, invocation.name)
   }
@@ -367,17 +447,17 @@ function formatPermission(value) {
   return value === false ? 'false' : 'true'
 }
 
-function formatCommandList(commands) {
+export function formatCommandList(commands) {
   if (commands.length === 0) {
     return [
-      'No project custom commands found.',
+      'No custom commands found.',
       '',
       'Create one with:',
       '```text',
       '/command new review',
       '```',
       '',
-      'Or add Markdown files under `.claude/commands/`, `.opencode/commands/`, or `.ai/commands/`, for example `.ai/commands/review.md`.',
+      'Or add Markdown files under `~/.quickforge/commands/` (user-level), or `.claude/commands/`, `.opencode/commands/`, `.ai/commands/` (project-level), for example `.ai/commands/review.md`.',
     ].join('\n')
   }
 
@@ -389,37 +469,59 @@ function formatCommandList(commands) {
   })
 
   return [
-    'Project custom commands:',
+    'Custom commands:',
     '',
     ...rows,
     '',
-    'Command files live in `.claude/commands/*.md`, `.opencode/commands/*.md`, `.ai/commands/*.md`, or configured directories. Use `$ARGUMENTS` inside a command file to insert invocation arguments.',
+    'Command files live in `~/.quickforge/commands/*.md` (user-level), `.claude/commands/*.md`, `.opencode/commands/*.md`, `.ai/commands/*.md`, or configured directories. Use `$ARGUMENTS` inside a command file to insert invocation arguments.',
   ].join('\n')
 }
 
-async function createCommandTemplate(workspaceRoot, name) {
-  const commandName = normalizeCommandName(name)
-  if (!commandName) {
-    return `Invalid command name: ${name}\n\nUse lowercase letters, numbers, and hyphens.`
-  }
+function formatBuiltinCommandRows() {
+  return builtinCommandCatalog.map((cmd) => {
+    const hint = cmd.argumentHint ? ` ${cmd.argumentHint}` : ''
+    const aliases = cmd.aliases?.length
+      ? ` (alias: ${cmd.aliases.map((alias) => `/${alias}`).join(', ')})`
+      : ''
+    const perm = cmd.permissionNote ? ` \[${cmd.permissionNote}\]` : ''
+    return `- \`/${cmd.name}${hint}\`${aliases} — ${cmd.description}${perm}`
+  })
+}
 
-  const dir = commandDirectory(workspaceRoot)
-  const file = path.join(dir, `${commandName}.md`)
-  try {
-    await fs.mkdir(dir, { recursive: true })
-    await fs.writeFile(file, commandTemplate(commandName), { encoding: 'utf8', flag: 'wx' })
-  } catch (error) {
-    if (error?.code === 'EEXIST') {
-      return `Custom command already exists: ${commandsRelativeDir}/${commandName}.md`
-    }
-    throw error
+export function formatHelpText(customCommands = []) {
+  const sections = [
+    'QuickForge command reference',
+    '',
+    'Built-in commands:',
+    '',
+    ...formatBuiltinCommandRows(),
+  ]
+
+  if (customCommands.length > 0) {
+    sections.push('', formatCommandList(customCommands))
+  } else {
+    sections.push(
+      '',
+      'No custom commands found. Add Markdown files under `~/.quickforge/commands/` (user-level) or `.claude/commands/`, `.opencode/commands/`, `.ai/commands/` (project-level).',
+    )
   }
 
-  return [
-    `Created custom command: ${commandsRelativeDir}/${commandName}.md`,
-    '',
-    `Run it with: /${commandName} your arguments`,
-  ].join('\n')
+  return sections.join('\n')
+}
+
+async function createCommandTemplate(workspaceRoot, name) {
+  const result = await createCommandFile(workspaceRoot, name)
+  if (result.ok) {
+    return [
+      `Created custom command: ${result.relativePath}`,
+      '',
+      `Run it with: /${result.name} your arguments`,
+    ].join('\n')
+  }
+  if (result.reason === 'exists') {
+    return `Custom command already exists: ${commandsRelativeDir}/${result.name}.md`
+  }
+  return `Invalid command name: ${name}\n\nUse lowercase letters, numbers, and hyphens.`
 }
 
 function commandTemplate(name) {
@@ -436,3 +538,30 @@ allow_commands: false
 $ARGUMENTS
 `
 }
+
+export async function createCommandFile(workspaceRoot, name) {
+  const commandName = normalizeCommandName(name)
+  if (!commandName) {
+    return { ok: false, reason: 'invalid' }
+  }
+  const dir = commandDirectory(workspaceRoot)
+  if (!dir) {
+    return { ok: false, reason: 'no-project' }
+  }
+  const file = path.join(dir, `${commandName}.md`)
+  try {
+    await fs.mkdir(dir, { recursive: true })
+    await fs.writeFile(file, commandTemplate(commandName), { encoding: 'utf8', flag: 'wx' })
+  } catch (error) {
+    if (error?.code === 'EEXIST') {
+      return { ok: false, reason: 'exists', name: commandName, filePath: file }
+    }
+    throw error
+  }
+  return {
+    ok: true,
+    name: commandName,
+    filePath: file,
+    relativePath: `${commandsRelativeDir}/${commandName}.md`,
+  }
+}

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)