@shawnstack/quickforge 1.5.1 → 1.5.3

package/server/routes/scheduled-tasks.mjs

@@ -5,14 +5,24 @@ import { createAgent, getSessionEventBus, agentEvents, persistSessionState } fro
 import { agentProfileSnapshot, getAgentProfile } from '../agent-profiles.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 import { logger } from '../utils/logger.mjs'
+import {
+  dayMs,
+  formatLocalDateTime,
+  hourMs,
+  minuteMs,
+  nextCronRun,
+  nextDailyRun,
+  nextMonthlyRun,
+  nextWeeklyRun,
+  normalizeExecutionMode,
+  parseExecuteTime,
+  timeFromDate,
+} from '../utils/scheduled-tasks.mjs'
 
 const STORE = 'scheduled-tasks'
 const RUN_CHECK_INTERVAL_MS = 30 * 1000
 const MAX_RUN_HISTORY_PER_TASK = 200
 const cronRegex = /^(\*|\d{1,2}|\d{1,2}-\d{1,2}|\d{1,2}\/\d{1,2}|\*\/\d{1,2})(\s+(\*|\d{1,2}|\d{1,2}-\d{1,2}|\d{1,2}\/\d{1,2}|\*\/\d{1,2})){4}$/
-const minuteMs = 60 * 1000
-const hourMs = 60 * minuteMs
-const dayMs = 24 * hourMs
 const editableScheduleTypes = new Set(['once', 'daily', 'weekly', 'monthly'])
 const weekDayNames = ['周日', '周一', '周二', '周三', '周四', '周五', '周六']
 
@@ -24,13 +34,6 @@ function executionModeFor(task) {
   return task?.executionMode === 'parallel' ? 'parallel' : 'serial'
 }
 
-function normalizeExecutionMode(value) {
-  if (value === undefined || value === null || value === '') return 'serial'
-  const mode = String(value)
-  if (mode === 'serial' || mode === 'parallel') return mode
-  throw requestError('executionMode must be serial or parallel')
-}
-
 function currentRunIdsFor(task) {
   const ids = []
   if (Array.isArray(task?.currentRunIds)) ids.push(...task.currentRunIds.filter(Boolean))
@@ -72,20 +75,6 @@ function createId() {
   return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`
 }
 
-function pad(value) {
-  return String(value).padStart(2, '0')
-}
-
-function formatLocalDateTime(date) {
-  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`
-}
-
-function timeFromDate(value) {
-  const date = value ? new Date(value) : null
-  if (!date || Number.isNaN(date.getTime())) return undefined
-  return `${pad(date.getHours())}:${pad(date.getMinutes())}`
-}
-
 function requestError(message, statusCode = 400) {
   const error = new Error(message)
   error.statusCode = statusCode
@@ -98,67 +87,12 @@ function nonEmptyString(value, fieldName) {
   return text
 }
 
-function parseExecuteTime(value) {
-  const text = String(value ?? '').trim()
-  const match = text.match(/^(\d{1,2}):(\d{2})$/)
-  if (!match) throw requestError('executeTime must use HH:mm format')
-  const hours = Number(match[1])
-  const minutes = Number(match[2])
-  if (hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
-    throw requestError('executeTime is out of range')
-  }
-  return `${pad(hours)}:${pad(minutes)}`
-}
-
-function dateWithTime(base, executeTime) {
-  const [hours, minutes] = parseExecuteTime(executeTime).split(':').map(Number)
-  const date = new Date(base)
-  date.setHours(hours, minutes, 0, 0)
-  return date
-}
-
 function parseDateTime(value, fieldName) {
   const date = new Date(value)
   if (Number.isNaN(date.getTime())) throw requestError(`${fieldName} is invalid`)
   return date
 }
 
-function nextDailyRun(executeTime, base = new Date()) {
-  const next = dateWithTime(base, executeTime)
-  if (next.getTime() <= base.getTime()) next.setDate(next.getDate() + 1)
-  return next
-}
-
-function nextWeeklyRun(weekDay, executeTime, base = new Date()) {
-  const targetDay = Number(weekDay)
-  if (!Number.isInteger(targetDay) || targetDay < 0 || targetDay > 6) {
-    throw requestError('weekDay must be between 0 and 6')
-  }
-  const next = dateWithTime(base, executeTime)
-  let daysToAdd = (targetDay - next.getDay() + 7) % 7
-  if (daysToAdd === 0 && next.getTime() <= base.getTime()) daysToAdd = 7
-  next.setDate(next.getDate() + daysToAdd)
-  return next
-}
-
-function monthlyCandidate(year, month, monthDay, executeTime) {
-  const targetDay = Number(monthDay)
-  if (!Number.isInteger(targetDay) || targetDay < 1 || targetDay > 31) {
-    throw requestError('monthDay must be between 1 and 31')
-  }
-  const [hours, minutes] = parseExecuteTime(executeTime).split(':').map(Number)
-  const lastDay = new Date(year, month + 1, 0).getDate()
-  return new Date(year, month, Math.min(targetDay, lastDay), hours, minutes, 0, 0)
-}
-
-function nextMonthlyRun(monthDay, executeTime, base = new Date()) {
-  let next = monthlyCandidate(base.getFullYear(), base.getMonth(), monthDay, executeTime)
-  if (next.getTime() <= base.getTime()) {
-    next = monthlyCandidate(base.getFullYear(), base.getMonth() + 1, monthDay, executeTime)
-  }
-  return next
-}
-
 function scheduleRuleFor(task) {
   if (task.scheduleType === 'once') return `单次 ${formatLocalDateTime(new Date(task.executeAt ?? task.nextRunAt))}`
   if (task.scheduleType === 'daily') return `每天 ${task.executeTime}`
@@ -167,48 +101,6 @@ function scheduleRuleFor(task) {
   return task.scheduleRule || task.cronExpression || '定时执行'
 }
 
-function parseCronField(field, min, max) {
-  if (field === '*') return { any: true, values: [] }
-  const values = new Set()
-  for (const part of field.split(',')) {
-    if (/^\*\/\d+$/.test(part)) {
-      const step = Number(part.slice(2))
-      for (let value = min; value <= max; value += step) values.add(value)
-    } else if (/^\d+-\d+$/.test(part)) {
-      const [start, end] = part.split('-').map(Number)
-      for (let value = Math.max(start, min); value <= Math.min(end, max); value += 1) values.add(value)
-    } else if (/^\d+$/.test(part)) {
-      const value = Number(part)
-      if (value >= min && value <= max) values.add(value)
-    }
-  }
-  return { any: false, values: [...values] }
-}
-
-function cronMatches(date, cronExpression) {
-  const fields = String(cronExpression || '').trim().split(/\s+/)
-  if (fields.length !== 5) return false
-  const checks = [
-    [date.getMinutes(), parseCronField(fields[0], 0, 59)],
-    [date.getHours(), parseCronField(fields[1], 0, 23)],
-    [date.getDate(), parseCronField(fields[2], 1, 31)],
-    [date.getMonth() + 1, parseCronField(fields[3], 1, 12)],
-    [date.getDay(), parseCronField(fields[4], 0, 6)],
-  ]
-  return checks.every(([value, rule]) => rule.any || rule.values.includes(value))
-}
-
-function nextCronRun(cronExpression, base = new Date()) {
-  const cursor = new Date(base.getTime() + minuteMs)
-  cursor.setSeconds(0, 0)
-  const maxChecks = 366 * 24 * 60
-  for (let index = 0; index < maxChecks; index += 1) {
-    if (cronMatches(cursor, cronExpression)) return cursor
-    cursor.setMinutes(cursor.getMinutes() + 1)
-  }
-  return null
-}
-
 function normalizeAiJson(text) {
   const raw = String(text || '').trim()
   const fenced = raw.match(/```(?:json)?\s*([\s\S]*?)```/i)

package/server/routes/static.mjs

@@ -48,7 +48,7 @@ function shouldFallbackToIndex(url, pathname) {
 export async function serveStatic(req, res, url) {
   const distDir = path.join(projectRoot, 'dist')
   const requested = decodeURIComponent(requestPathname(url))
-  const normalized = path.normalize(requested).replace(/^([.][.][\/])+/, '').replace(/^[/\\]+/, '')
+  const normalized = path.normalize(requested).replace(/^([.][.][/])+/, '').replace(/^[/\\]+/, '')
   let filePath = path.resolve(distDir, normalized)
 
   const relative = path.relative(distDir, filePath)

package/server/routes/storage.mjs

@@ -1,4 +1,3 @@
-import path from 'node:path'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore, writeStore, atomicUpdate, getComparable, getStoreRevision, readSessionStoreScoped, readSessionValue, writeSessionValue, deleteSessionValue, ensureStorage, dataDir, configDir, storageDir, cacheDir, logsDir } from '../storage.mjs'
 import { directorySize } from '../utils/workspace.mjs'
@@ -7,8 +6,8 @@ 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 })
+function metadataIndexCacheKey({ scope, projectId, indexName, direction, archived }) {
+  return JSON.stringify({ scope: scope || '', projectId: projectId || '', indexName, direction, archived: archived || '' })
 }
 
 function sortIndexedValues(values, store, indexName, direction) {
@@ -34,7 +33,7 @@ function sortIndexedValues(values, store, indexName, direction) {
   return values
 }
 
-async function readIndexedValues(store, indexName, direction, scope, projectId) {
+async function readIndexedValues(store, indexName, direction, scope, projectId, archived) {
   if (store !== 'sessions-metadata') {
     let data
     if (scope && store === 'sessions') {
@@ -46,7 +45,7 @@ async function readIndexedValues(store, indexName, direction, scope, projectId)
   }
 
   const revision = getStoreRevision(store)
-  const key = metadataIndexCacheKey({ scope, projectId, indexName, direction })
+  const key = metadataIndexCacheKey({ scope, projectId, indexName, direction, archived })
   const cached = metadataIndexCache.get(key)
   const now = Date.now()
   if (cached && cached.revision === revision && now - cached.cachedAt < METADATA_INDEX_CACHE_TTL_MS) return cached.values
@@ -55,7 +54,13 @@ async function readIndexedValues(store, indexName, direction, scope, projectId)
     ? await readSessionStoreScoped(store, scope, scope === 'project' ? projectId : undefined)
     : await readStore(store)
   const values = sortIndexedValues(
-    Object.values(data).filter((value) => value?.messageCount !== 0),
+    Object.values(data)
+      .filter((value) => value?.messageCount !== 0)
+      .filter((value) => {
+        if (archived === 'only') return Boolean(value?.archivedAt)
+        if (archived === 'include') return true
+        return !value?.archivedAt
+      }),
     store,
     indexName,
     direction,
@@ -107,10 +112,11 @@ export async function handleStorageApi(req, res, url) {
     const projectId = url.searchParams.get('projectId')
     const limitParam = url.searchParams.get('limit')
     const offsetParam = url.searchParams.get('offset')
+    const archived = url.searchParams.get('archived')
 
     await ensureStorage()
 
-    const values = await readIndexedValues(store, indexName, direction, scope, projectId)
+    const values = await readIndexedValues(store, indexName, direction, scope, projectId, archived)
 
     const total = values.length
     const limit = limitParam ? parseInt(limitParam, 10) : undefined

package/server/session-utils.mjs

@@ -2,6 +2,7 @@ import { streamSimple } from '@earendil-works/pi-ai'
 import { buildInstructionsPayload, projectContextFromId } from './project-config.mjs'
 import { composeSystemPrompt } from './system-prompt.mjs'
 import { listSubagentProfiles } from './agent-profiles.mjs'
+import { logger } from './utils/logger.mjs'
 
 // ---------------------------------------------------------------------------
 // System prompt
@@ -109,7 +110,7 @@ export async function generateAiTitle(messages, model, thinkingLevel, getApiKey)
     const title = normalizeAiTitle(titleText)
     return title || null
   } catch (error) {
-    console.warn('Failed to generate AI title:', error.message || error)
+    logger.warn('Failed to generate AI title:', error.message || error)
     return null
   }
 }

package/server/skills.mjs

@@ -3,6 +3,7 @@ import os from 'node:os'
 import path from 'node:path'
 import { dataDir } from './storage.mjs'
 import { getEnabledPluginSkillSources } from './plugins/registry.mjs'
+import { logger } from './utils/logger.mjs'
 
 const userSkillsDir = path.join(dataDir, 'skills')
 const sharedUserSkillsDir = path.join(os.homedir(), '.agents', 'skills')
@@ -347,7 +348,7 @@ async function loadSkillsFromSources(sources) {
         if (skillsByName.has(skill.name)) skillsByName.delete(skill.name)
         skillsByName.set(skill.name, skill)
       } catch (error) {
-        console.warn(`Failed to load skill from ${skillDir}:`, error.message || error)
+        logger.warn(`Failed to load skill from ${skillDir}:`, error.message || error)
       }
     }
   }
@@ -371,7 +372,7 @@ async function loadSkillsFromExplicitSources(sources) {
         if (skillsByName.has(skill.name)) skillsByName.delete(skill.name)
         skillsByName.set(skill.name, skill)
       } catch (error) {
-        console.warn(`Failed to load skill from ${skillDir}:`, error.message || error)
+        logger.warn(`Failed to load skill from ${skillDir}:`, error.message || error)
       }
     }
   }

package/server/storage.mjs

@@ -46,6 +46,7 @@ export async function cleanOldLogs() {
 
 export const stores = new Set([
   'settings',
+  'mcp',
   'provider-keys',
   'custom-providers',
   'plugins',
@@ -74,14 +75,102 @@ export function getStoreRevision(storeName) {
   return storeRevisions.get(storeName) || 0
 }
 
-const configStores = new Set(['settings', 'provider-keys', 'custom-providers', 'plugins'])
-const sessionStores = new Set(['sessions', 'sessions-metadata'])
+// Each configuration store is persisted to its own file under config/.
+// "Solo" stores own a file whose root object *is* the store data.
+// "Shared" stores share one file (providers.json) keyed by section, so that
+// strongly-coupled provider definitions and their API keys stay in sync under
+// a single write queue.
+const soloConfigStores = {
+  settings: 'settings.json',
+  mcp: 'mcp-servers.json',
+  plugins: 'plugins.json',
+}
+
+const sharedConfigGroups = {
+  'providers.json': {
+    queue: 'providers',
+    sections: {
+      'provider-keys': 'providerKeys',
+      'custom-providers': 'customProviders',
+    },
+  },
+}
+
+// Reverse index: storeName -> { file, queue, sectionKey|null }
+const configStoreLocations = (() => {
+  const map = {}
+  for (const [store, file] of Object.entries(soloConfigStores)) {
+    map[store] = { file, queue: store, sectionKey: null }
+  }
+  for (const [file, group] of Object.entries(sharedConfigGroups)) {
+    for (const [store, sectionKey] of Object.entries(group.sections)) {
+      map[store] = { file, queue: group.queue, sectionKey }
+    }
+  }
+  return map
+})()
+
+function isConfigStore(storeName) {
+  return Boolean(configStoreLocations[storeName])
+}
+
+function configStoreFilePath(storeName) {
+  return path.join(configDir, configStoreLocations[storeName].file)
+}
+
+// Coerce a value into a plain object record (the shape every config store holds).
+function asRecord(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+}
 
-const configStoreSections = {
-  settings: ['app', 'settings'],
-  'provider-keys': ['credentials', 'providerKeys'],
-  'custom-providers': ['providers', 'customProviders'],
-  plugins: ['extensions', 'plugins'],
+// Where each config store lived in the legacy unified config.json, used only as
+// a read fallback (D6 read-side safety net).  Note: `mcp` was lifted out of
+// `settings.mcpServers` — its legacy source is nested, not a direct section.
+const legacyConfigSectionReaders = {
+  settings: (config) => asRecord(config.app?.settings),
+  mcp: (config) => ({ mcpServers: Array.isArray(config.app?.settings?.mcpServers) ? config.app.settings.mcpServers : [] }),
+  plugins: (config) => asRecord(config.extensions?.plugins),
+  'provider-keys': (config) => asRecord(config.credentials?.providerKeys),
+  'custom-providers': (config) => asRecord(config.providers?.customProviders),
+}
+
+// Read a single config store from its (possibly shared) file, with a fallback
+// to the legacy unified config.json section when the split file is absent and
+// the split migration has not completed yet (D6 read-side safety net, so an
+// interrupted or partially-completed migration can never surface empty data).
+async function readConfigStore(storeName) {
+  const loc = configStoreLocations[storeName]
+  const file = configStoreFilePath(storeName)
+
+  if (existsSync(file)) {
+    const content = await readJsonFile(file, {})
+    if (loc.sectionKey) return asRecord(content?.[loc.sectionKey])
+    return asRecord(content)
+  }
+
+  // Split file missing: only fall back to the legacy section while the split
+  // migration is still pending. Once `.split-migrated` exists the split files
+  // are authoritative, so a genuinely missing file means an empty store.
+  if (!existsSync(splitMigrationMarkerFile)) {
+    const reader = legacyConfigSectionReaders[storeName]
+    if (reader) return reader(await readConfigFile())
+  }
+
+  return {}
+}
+
+// Write a single config store back to its (possibly shared) file.  For shared
+// files the sibling sections are preserved.  Must run inside the store's queue.
+async function writeConfigStore(storeName, data) {
+  const loc = configStoreLocations[storeName]
+  const file = configStoreFilePath(storeName)
+  if (loc.sectionKey) {
+    const content = await readJsonFile(file, {})
+    content[loc.sectionKey] = data && typeof data === 'object' && !Array.isArray(data) ? data : {}
+    await writeJsonAtomic(file, content)
+    return
+  }
+  await writeJsonAtomic(file, data && typeof data === 'object' && !Array.isArray(data) ? data : {})
 }
 
 export function getDataDir() {
@@ -98,18 +187,16 @@ export const userCommandsDir = path.join(dataDir, 'commands')
 
 const quickForgeConfigFile = path.join(configDir, 'config.json')
 const configMigrationMarkerFile = path.join(configDir, '.layout-migrated')
+const splitMigrationMarkerFile = path.join(configDir, '.split-migrated')
+const projectsConfigFile = path.join(configDir, 'projects.json')
 const legacyStorageMigrationMarkerFile = path.join(storageDir, '.layout-migrated')
 
 export function storeFile(storeName) {
   assertStore(storeName)
-  if (configStores.has(storeName)) return quickForgeConfigFile
+  if (isConfigStore(storeName)) return configStoreFilePath(storeName)
   return sessionStoreFile(storeName, { scope: 'global' })
 }
 
-export function configFile() {
-  return quickForgeConfigFile
-}
-
 function legacyFlatStoreFile(storeName) {
   return path.join(storageDir, `${storeName}.json`)
 }
@@ -229,17 +316,6 @@ function normalizeConfig(value) {
   }
 }
 
-function configSection(config, storeName) {
-  const [section, key] = configStoreSections[storeName]
-  return config?.[section]?.[key] && typeof config[section][key] === 'object' ? config[section][key] : {}
-}
-
-function setConfigSection(config, storeName, data) {
-  const [section, key] = configStoreSections[storeName]
-  config[section] = config[section] && typeof config[section] === 'object' ? config[section] : {}
-  config[section][key] = data && typeof data === 'object' ? data : {}
-}
-
 function sessionBucket(value) {
   if (value?.scope === 'project' && value?.projectId) {
     return { scope: 'project', projectId: String(value.projectId) }
@@ -323,6 +399,10 @@ async function readConfigFile() {
   return normalizeConfig(await readJsonFile(quickForgeConfigFile, defaultConfig()))
 }
 
+// Used only within the migration chain (migrateUnifiedConfig). It persists the
+// unified (pre-split) layout at layoutVersion 1 as an intermediate step; the
+// subsequent migrateSplitConfig() then demotes config.json to metadata-only
+// (layoutVersion 2). Do not use for normal runtime config writes.
 async function writeConfigFile(config) {
   const next = normalizeConfig(config)
   next.layoutVersion = 1
@@ -652,6 +732,68 @@ async function migrateUnifiedConfig() {
   await fs.writeFile(configMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
 }
 
+// Split the legacy unified config.json into per-store files under config/.
+// Each target file is only written when it does not already exist, so a
+// partially-completed migration can safely resume.  config.json is demoted to
+// metadata only after the split succeeds.
+async function migrateSplitConfig() {
+  if (existsSync(splitMigrationMarkerFile)) return
+
+  // Fresh installs have no unified config.json to split — just record marker.
+  if (!existsSync(quickForgeConfigFile)) {
+    await fs.writeFile(splitMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
+    return
+  }
+
+  const config = await readConfigFile()
+
+  // settings.json — mcpServers is stripped out (moved to its own store below)
+  if (!existsSync(path.join(configDir, 'settings.json'))) {
+    const oldSettings = config.app?.settings && typeof config.app.settings === 'object'
+      ? { ...config.app.settings }
+      : {}
+    delete oldSettings.mcpServers
+    await writeJsonAtomic(path.join(configDir, 'settings.json'), oldSettings)
+  }
+
+  // mcp-servers.json — lifted out of settings.mcpServers
+  if (!existsSync(path.join(configDir, 'mcp-servers.json'))) {
+    const mcpServers = config.app?.settings?.mcpServers
+    await writeJsonAtomic(path.join(configDir, 'mcp-servers.json'), {
+      mcpServers: Array.isArray(mcpServers) ? mcpServers : [],
+    })
+  }
+
+  // providers.json — customProviders + providerKeys kept together (coupled)
+  if (!existsSync(path.join(configDir, 'providers.json'))) {
+    const customProviders = config.providers?.customProviders && typeof config.providers.customProviders === 'object'
+      ? config.providers.customProviders
+      : {}
+    const providerKeys = config.credentials?.providerKeys && typeof config.credentials.providerKeys === 'object'
+      ? config.credentials.providerKeys
+      : {}
+    await writeJsonAtomic(path.join(configDir, 'providers.json'), { customProviders, providerKeys })
+  }
+
+  // plugins.json
+  if (!existsSync(path.join(configDir, 'plugins.json'))) {
+    const plugins = config.extensions?.plugins && typeof config.extensions.plugins === 'object'
+      ? config.extensions.plugins
+      : {}
+    await writeJsonAtomic(path.join(configDir, 'plugins.json'), plugins)
+  }
+
+  // projects.json
+  if (!existsSync(projectsConfigFile)) {
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(config.projects))
+  }
+
+  // Demote config.json to metadata only.
+  await writeJsonAtomic(quickForgeConfigFile, { layoutVersion: 2, migratedAt: new Date().toISOString() })
+
+  await fs.writeFile(splitMigrationMarkerFile, `${new Date().toISOString()}\n`, 'utf8')
+}
+
 const writeQueues = new Map()
 
 function enqueueWrite(queueName, operation) {
@@ -674,15 +816,13 @@ function enqueueWrite(queueName, operation) {
  */
 export async function atomicUpdate(storeName, updateFn) {
   assertStore(storeName)
-  const queueName = configStores.has(storeName) ? 'config' : storeName
+  const queueName = isConfigStore(storeName) ? configStoreLocations[storeName].queue : storeName
   return enqueueWrite(queueName, async () => {
     await ensureStorage()
-    if (configStores.has(storeName)) {
-      const config = await readConfigFile()
-      const data = configSection(config, storeName)
+    if (isConfigStore(storeName)) {
+      const data = await readConfigStore(storeName)
       const updated = updateFn(data)
-      setConfigSection(config, storeName, updated)
-      await writeConfigFile(config)
+      await writeConfigStore(storeName, updated)
       return updated
     }
     const data = await readSessionStore(storeName)
@@ -719,13 +859,11 @@ export async function atomicSessionMetadataUpdate(scope, projectId, updateFn) {
  * Atomically read-modify-write the project config within the config queue.
  */
 export async function atomicProjectConfigUpdate(updateFn) {
-  return enqueueWrite('config', async () => {
+  return enqueueWrite('projects', async () => {
     await ensureStorage()
-    const config = await readConfigFile()
-    const projectConfig = normalizeProjectConfig(config.projects)
+    const projectConfig = normalizeProjectConfig(await readJsonFile(projectsConfigFile, defaultProjectConfig()))
     const updated = updateFn(projectConfig)
-    config.projects = normalizeProjectConfig(updated)
-    await writeConfigFile(config)
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(updated))
     return updated
   })
 }
@@ -756,9 +894,10 @@ export function ensureStorage() {
     ])
 
     await migrateUnifiedConfig()
+    await migrateSplitConfig()
 
     await Promise.all([
-      ensureJsonFile(quickForgeConfigFile, defaultConfig()),
+      ensureJsonFile(quickForgeConfigFile, { layoutVersion: 2 }),
       ensureJsonFile(sessionStoreFile('sessions-metadata', { scope: 'global' })),
     ])
   })()
@@ -771,9 +910,8 @@ export async function readStore(storeName) {
   assertStore(storeName)
   await ensureStorage()
 
-  if (configStores.has(storeName)) {
-    const config = await readConfigFile()
-    return configSection(config, storeName)
+  if (isConfigStore(storeName)) {
+    return readConfigStore(storeName)
   }
 
   return readSessionStore(storeName)
@@ -781,15 +919,13 @@ export async function readStore(storeName) {
 
 export async function writeStore(storeName, data) {
   assertStore(storeName)
-  const queueName = configStores.has(storeName) ? 'config' : storeName
+  const queueName = isConfigStore(storeName) ? configStoreLocations[storeName].queue : storeName
 
   return enqueueWrite(queueName, async () => {
     await ensureStorage()
 
-    if (configStores.has(storeName)) {
-      const config = await readConfigFile()
-      setConfigSection(config, storeName, data)
-      await writeConfigFile(config)
+    if (isConfigStore(storeName)) {
+      await writeConfigStore(storeName, data)
       return
     }
 
@@ -799,16 +935,13 @@ export async function writeStore(storeName, data) {
 
 export async function readProjectConfigData() {
   await ensureStorage()
-  const config = await readConfigFile()
-  return normalizeProjectConfig(config.projects)
+  return normalizeProjectConfig(await readJsonFile(projectsConfigFile, defaultProjectConfig()))
 }
 
 export async function writeProjectConfigData(projectConfig) {
-  return enqueueWrite('config', async () => {
+  return enqueueWrite('projects', async () => {
     await ensureStorage()
-    const config = await readConfigFile()
-    config.projects = normalizeProjectConfig(projectConfig)
-    await writeConfigFile(config)
+    await writeJsonAtomic(projectsConfigFile, normalizeProjectConfig(projectConfig))
   })
 }
 

package/server/utils/logger.mjs

@@ -4,7 +4,6 @@ import { logsDir } from '../storage.mjs'
 
 // --- Level control ---
 const LEVELS = { ERROR: 0, WARN: 1, INFO: 2, DEBUG: 3 }
-const levelNames = Object.keys(LEVELS)
 
 const envLevel = (process.env.QUICKFORGE_LOG_LEVEL || '').toUpperCase()
 const minLevel = LEVELS[envLevel] ?? LEVELS.INFO

package/server/utils/package-update.mjs

@@ -27,7 +27,7 @@ export async function getPackageInfo(projectRoot) {
       bugsUrl: typeof pkg.bugs === 'string' ? pkg.bugs : pkg.bugs?.url || '',
     }
   } catch (error) {
-    throw new Error(`Unable to read package metadata: ${error.message}`)
+    throw new Error(`Unable to read package metadata: ${error.message}`, { cause: error })
   }
 }
 
@@ -109,7 +109,7 @@ export async function fetchLatestVersion(packageName) {
     if (!latest || typeof latest !== 'string') throw new Error('latest version not found in registry response')
     return latest
   } catch (error) {
-    if (error.name === 'AbortError') throw new Error('request timeout')
+    if (error.name === 'AbortError') throw new Error('request timeout', { cause: error })
     throw error
   } finally {
     clearTimeout(timeout)