@shawnstack/quickforge 1.7.0 → 1.7.2

package/server/routes/backup.mjs

@@ -7,18 +7,14 @@ import {
   readStore,
   writeStore,
   readProjectConfigData,
-  writeProjectConfigData,
   storageDir,
 } from '../storage.mjs'
-import { initializeActiveProject } from '../project-config.mjs'
-import { setActiveWorkspaceRootForFilesystem } from './filesystem.mjs'
-import { getWorkspaceRoot } from '../utils/workspace.mjs'
 
 const BACKUP_VERSION = 1
 const BACKUP_APP = 'quickforge'
 const IMPORT_UPLOAD_MAX_BYTES = Number(process.env.QUICKFORGE_IMPORT_UPLOAD_MAX_BYTES || 1024 * 1024 * 1024)
 const backupScopes = new Set(['all', 'config', 'sessions'])
-const settingsSectionIds = ['settings', 'mcp', 'providerKeys', 'customProviders', 'projects', 'scheduledTasks']
+const settingsSectionIds = ['settings', 'mcp', 'providerKeys', 'customProviders', 'scheduledTasks']
 const exportSectionIds = new Set(settingsSectionIds)
 const restoreSectionIds = new Set([...settingsSectionIds, 'conversations'])
 const restoreModes = new Set(['replace', 'merge'])
@@ -138,21 +134,6 @@ function assertObjectSection(value, name) {
   return value
 }
 
-function assertProjectConfig(value) {
-  const projectConfig = assertObjectSection(value, 'projects')
-  if (projectConfig === undefined) return undefined
-  if (!Array.isArray(projectConfig.projects)) {
-    const error = new Error('Invalid backup section: projects.projects must be an array')
-    error.statusCode = 400
-    throw error
-  }
-  return {
-    activeProjectId: typeof projectConfig.activeProjectId === 'string' ? projectConfig.activeProjectId : null,
-    globalSkills: Array.isArray(projectConfig.globalSkills) ? projectConfig.globalSkills : [],
-    projects: projectConfig.projects,
-  }
-}
-
 function filterSessionsByMetadata(sessions, metadata) {
   if (!sessions || !metadata) return sessions
   const metadataIds = new Set(Object.keys(metadata))
@@ -226,8 +207,8 @@ async function buildBackup(scope = 'all', options = {}) {
       shouldInclude('mcp') ? readStore('mcp').then((value) => ['mcp', value]) : null,
       shouldInclude('providerKeys') ? readStore('provider-keys').then((value) => ['providerKeys', value]) : null,
       shouldInclude('customProviders') ? readStore('custom-providers').then((value) => ['customProviders', value]) : null,
-      shouldInclude('projects') ? readProjectConfigData().then((value) => ['projects', value]) : null,
       shouldInclude('scheduledTasks') ? readStore('scheduled-tasks').then((value) => ['scheduledTasks', value]) : null,
+      options.includeLocalProjects ? readProjectConfigData().then((value) => ['projects', value]) : null,
     ])
     for (const entry of entries) {
       if (entry) data[entry[0]] = entry[1]
@@ -264,7 +245,14 @@ function normalizeBackupPayload(payload) {
     throw error
   }
 
-  const data = backup.data && typeof backup.data === 'object' && !Array.isArray(backup.data)
+  const hasEnvelope = backup.data && typeof backup.data === 'object' && !Array.isArray(backup.data)
+  if (hasEnvelope && Number.isInteger(backup.version) && backup.version > BACKUP_VERSION) {
+    const error = new Error(`Unsupported backup version: ${backup.version}`)
+    error.statusCode = 400
+    throw error
+  }
+
+  const data = hasEnvelope
     ? backup.data
     : backup
 
@@ -310,14 +298,13 @@ function validateSettingsImportBackup(payload) {
   const normalized = normalizeBackupPayload(payload)
   const validSections = {}
   const invalidSections = {}
+  const ignoredProjects = normalized.sections.projects !== undefined
 
   for (const id of settingsSectionIds) {
     const value = normalized.sections[id]
     if (value === undefined) continue
     try {
-      validSections[id] = id === 'projects'
-        ? assertProjectConfig(value)
-        : assertObjectSection(value, id)
+      validSections[id] = assertObjectSection(value, id)
     } catch (error) {
       invalidSections[id] = error instanceof Error ? error.message : `Invalid backup section: ${id}`
     }
@@ -339,6 +326,7 @@ function validateSettingsImportBackup(payload) {
       data: validSections,
     },
     invalidSections,
+    ignoredProjects,
   }
 }
 
@@ -351,18 +339,25 @@ function validateBackupPayload(payload) {
     ? normalizeSessionMetadata(sessions, sections.sessionsMetadata)
     : assertObjectSection(sections.sessionsMetadata, 'sessionsMetadata')
 
+  const validatedSections = {
+    settings: assertObjectSection(sections.settings, 'settings'),
+    mcp: assertObjectSection(sections.mcp, 'mcp'),
+    providerKeys: assertObjectSection(sections.providerKeys, 'providerKeys'),
+    customProviders: assertObjectSection(sections.customProviders, 'customProviders'),
+    scheduledTasks: assertObjectSection(sections.scheduledTasks, 'scheduledTasks'),
+    sessions,
+    sessionsMetadata,
+  }
+
+  if (Object.values(validatedSections).every((value) => value === undefined)) {
+    const error = new Error('Backup does not contain any restorable sections')
+    error.statusCode = 400
+    throw error
+  }
+
   return {
     ...backup,
-    sections: {
-      settings: assertObjectSection(sections.settings, 'settings'),
-      mcp: assertObjectSection(sections.mcp, 'mcp'),
-      providerKeys: assertObjectSection(sections.providerKeys, 'providerKeys'),
-      customProviders: assertObjectSection(sections.customProviders, 'customProviders'),
-      projects: assertProjectConfig(sections.projects),
-      scheduledTasks: assertObjectSection(sections.scheduledTasks, 'scheduledTasks'),
-      sessions,
-      sessionsMetadata,
-    },
+    sections: validatedSections,
   }
 }
 
@@ -411,7 +406,6 @@ function filterRestoreSections(sections, selected) {
     mcp: selected.has('mcp') ? sections.mcp : undefined,
     providerKeys: selected.has('providerKeys') ? sections.providerKeys : undefined,
     customProviders: selected.has('customProviders') ? sections.customProviders : undefined,
-    projects: selected.has('projects') ? sections.projects : undefined,
     scheduledTasks: selected.has('scheduledTasks') ? sections.scheduledTasks : undefined,
     sessions: selected.has('conversations') ? sections.sessions : undefined,
     sessionsMetadata: selected.has('conversations') ? sections.sessionsMetadata : undefined,
@@ -444,29 +438,67 @@ function countKeys(value) {
   return value && typeof value === 'object' && !Array.isArray(value) ? Object.keys(value).length : 0
 }
 
+async function localProjectIds() {
+  const config = await readProjectConfigData()
+  return new Set(
+    (Array.isArray(config?.projects) ? config.projects : [])
+      .map((project) => project?.id)
+      .filter((id) => typeof id === 'string'),
+  )
+}
+
+function scheduledTasksWithMissingProjects(tasks, projectIds) {
+  if (!tasks || typeof tasks !== 'object' || Array.isArray(tasks)) return []
+  return Object.values(tasks).filter((task) => (
+    task && typeof task === 'object' && !Array.isArray(task) &&
+    typeof task.projectId === 'string' && task.projectId && !projectIds.has(task.projectId)
+  ))
+}
+
+function pauseScheduledTasksWithMissingProjects(tasks, projectIds) {
+  if (!tasks || typeof tasks !== 'object' || Array.isArray(tasks)) return tasks
+  return Object.fromEntries(Object.entries(tasks).map(([id, task]) => {
+    if (
+      task && typeof task === 'object' && !Array.isArray(task) &&
+      typeof task.projectId === 'string' && task.projectId && !projectIds.has(task.projectId)
+    ) {
+      return [id, { ...task, status: 'paused' }]
+    }
+    return [id, task]
+  }))
+}
+
 function buildSummary(sections) {
   const summary = {}
   if (sections.settings !== undefined) summary.settings = countKeys(sections.settings)
   if (sections.mcp !== undefined) summary.mcp = Array.isArray(sections.mcp?.mcpServers) ? sections.mcp.mcpServers.length : countKeys(sections.mcp)
   if (sections.providerKeys !== undefined) summary.providerKeys = countKeys(sections.providerKeys)
   if (sections.customProviders !== undefined) summary.customProviders = countKeys(sections.customProviders)
-  if (sections.projects !== undefined) summary.projects = sections.projects.projects.length
   if (sections.scheduledTasks !== undefined) summary.scheduledTasks = countKeys(sections.scheduledTasks)
   if (sections.sessions !== undefined) summary.sessions = countKeys(filterSessionsByMetadata(sections.sessions, sections.sessionsMetadata))
   if (sections.sessionsMetadata !== undefined) summary.sessionsMetadata = countKeys(sections.sessionsMetadata)
   return summary
 }
 
-function inspectBackup(payload) {
+async function inspectBackup(payload) {
+  const normalized = normalizeBackupPayload(payload)
+  const ignoredProjects = normalized.sections.projects !== undefined
   const backup = validateBackupPayload(payload)
   const summary = buildSummary(backup.sections)
   const warnings = []
   const containsSecrets = countKeys(backup.sections.providerKeys) > 0
+  const missingProjectTasks = backup.sections.scheduledTasks === undefined
+    ? []
+    : scheduledTasksWithMissingProjects(backup.sections.scheduledTasks, await localProjectIds())
 
   if (containsSecrets) warnings.push('Backup contains API keys.')
+  if (ignoredProjects) warnings.push('Project lists and project-specific settings are local machine data and will not be imported.')
   if (backup.sections.sessions !== undefined || backup.sections.sessionsMetadata !== undefined) {
     warnings.push('Importing conversations will replace local conversation data.')
   }
+  if (missingProjectTasks.length > 0) {
+    warnings.push(`${missingProjectTasks.length} scheduled task(s) reference projects that are not registered locally and will be paused after import.`)
+  }
 
   return {
     ok: true,
@@ -481,7 +513,7 @@ function inspectBackup(payload) {
 }
 
 async function writeSafetyBackup(scope = 'config') {
-  const backup = await buildBackup(scope, { includeSecrets: true })
+  const backup = await buildBackup(scope, { includeSecrets: true, includeLocalProjects: true })
   const dir = path.join(storageDir, 'backups')
   await fs.mkdir(dir, { recursive: true })
   const file = path.join(dir, `quickforge-before-restore-${backupTimestamp()}.json`)
@@ -495,26 +527,6 @@ function mergeRecordStore(localValue, backupValue) {
   return { ...(localValue && typeof localValue === 'object' ? localValue : {}), ...backupValue }
 }
 
-// Merge projects config: dedupe the projects array by id (backup wins on
-// collision, local-only entries preserved), take activeProjectId / globalSkills
-// from backup.
-function mergeProjectConfig(localConfig, backupConfig) {
-  const localProjects = Array.isArray(localConfig?.projects) ? localConfig.projects : []
-  const backupProjects = Array.isArray(backupConfig.projects) ? backupConfig.projects : []
-  const merged = new Map()
-  for (const project of localProjects) {
-    if (project && typeof project.id === 'string') merged.set(project.id, project)
-  }
-  for (const project of backupProjects) {
-    if (project && typeof project.id === 'string') merged.set(project.id, project)
-  }
-  return {
-    activeProjectId: typeof backupConfig.activeProjectId === 'string' ? backupConfig.activeProjectId : (localConfig?.activeProjectId ?? null),
-    globalSkills: Array.isArray(backupConfig.globalSkills) ? backupConfig.globalSkills : (Array.isArray(localConfig?.globalSkills) ? localConfig.globalSkills : []),
-    projects: [...merged.values()],
-  }
-}
-
 async function restoreValidatedBackup(backup, mode = 'replace') {
   const merge = mode === 'merge'
   const { sections } = backup
@@ -544,16 +556,10 @@ async function restoreValidatedBackup(backup, mode = 'replace') {
     summary.customProviders = countKeys(value)
   }
 
-  if (sections.projects !== undefined) {
-    const value = merge ? mergeProjectConfig(await readProjectConfigData(), sections.projects) : sections.projects
-    await writeProjectConfigData(value)
-    await initializeActiveProject()
-    setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())
-    summary.projects = value.projects.length
-  }
-
   if (sections.scheduledTasks !== undefined) {
-    const value = merge ? mergeRecordStore(await readStore('scheduled-tasks'), sections.scheduledTasks) : sections.scheduledTasks
+    const projectIds = await localProjectIds()
+    const safeTasks = pauseScheduledTasksWithMissingProjects(sections.scheduledTasks, projectIds)
+    const value = merge ? mergeRecordStore(await readStore('scheduled-tasks'), safeTasks) : safeTasks
     await writeStore('scheduled-tasks', value)
     summary.scheduledTasks = countKeys(value)
   }
@@ -587,7 +593,7 @@ export async function handleBackupApi(req, res, url) {
   if (req.method === 'POST' && url.pathname === '/api/backup/inspect') {
     await ensureStorage()
     const body = await readJsonBody(req)
-    sendJson(res, 200, inspectBackup(body))
+    sendJson(res, 200, await inspectBackup(body))
     return
   }
 
@@ -595,10 +601,11 @@ export async function handleBackupApi(req, res, url) {
     await ensureStorage()
     const text = await readTextBody(req)
     const { backup, ignoredConversations } = extractSettingsBackupFromText(text)
-    const { backup: validBackup, invalidSections } = validateSettingsImportBackup(backup)
-    const inspect = inspectBackup(validBackup)
+    const { backup: validBackup, invalidSections, ignoredProjects } = validateSettingsImportBackup(backup)
+    const inspect = await inspectBackup(validBackup)
+    if (ignoredProjects) inspect.warnings.push('Project lists and project-specific settings are local machine data and will not be imported.')
     const token = await writePendingImportBackup(validBackup)
-    sendJson(res, 200, { ...inspect, invalidSections, ignoredConversations, importToken: token })
+    sendJson(res, 200, { ...inspect, invalidSections, ignoredConversations, ignoredProjects, importToken: token })
     return
   }
 

package/server/routes/mcp.mjs

@@ -49,11 +49,6 @@ export async function handleMcpApi(req, res, url) {
     return
   }
 
-  if (req.method === 'POST' && url.pathname === '/api/mcp/reconnect') {
-    sendJson(res, 200, await refreshMcpAndAgentTools())
-    return
-  }
-
   if (req.method === 'POST' && parts[0] === 'api' && parts[1] === 'mcp' && parts[2] === 'reconnect' && parts[3]) {
     await reconnectMcpServer(decodeURIComponent(parts[3]))
     sendJson(res, 200, await refreshMcpAndAgentTools())

package/server/routes/scheduled-tasks.mjs

@@ -1,7 +1,7 @@
 import { streamSimple } from '@earendil-works/pi-ai/compat'
 import { readJsonBody, sendJson, decodeSegment } from '../utils/response.mjs'
 import { readStore, atomicUpdate } from '../storage.mjs'
-import { createAgent, getSessionEventBus, agentEvents, persistSessionState } from '../agent-manager.mjs'
+import { createAgent, getSessionEventBus, agentEvents, persistSessionState, abortRun } from '../agent-manager.mjs'
 import { agentProfileSnapshot, getAgentProfile } from '../agent-profiles.mjs'
 import { projectContextFromId, readProjectConfig } from '../project-config.mjs'
 import { logger } from '../utils/logger.mjs'
@@ -436,21 +436,30 @@ async function updateTask(taskId, updater) {
   return updated
 }
 
+function recurringTaskStatusRepair(task, now) {
+  if (task?.status !== 'completed' || !isRecurringTask(task)) return null
+  const nextRunAt = task.nextRunAt && new Date(task.nextRunAt).getTime() > now.getTime()
+    ? task.nextRunAt
+    : calculateNextRun(task, now)
+  if (!nextRunAt) return null
+  return {
+    ...task,
+    status: 'enabled',
+    nextRunAt,
+    scheduleRule: scheduleRuleFor({ ...task, nextRunAt }),
+    updatedAt: now.toISOString(),
+  }
+}
+
 async function repairRecurringTaskStatuses() {
+  const now = new Date()
+  const snapshot = await readStore(STORE)
+  if (!Object.values(snapshot).some((task) => recurringTaskStatusRepair(task, now))) return
+
   await atomicUpdate(STORE, (data) => {
     for (const [taskId, task] of Object.entries(data)) {
-      if (task?.status !== 'completed' || !isRecurringTask(task)) continue
-      const nextRunAt = task.nextRunAt && new Date(task.nextRunAt).getTime() > Date.now()
-        ? task.nextRunAt
-        : calculateNextRun(task)
-      if (!nextRunAt) continue
-      data[taskId] = {
-        ...task,
-        status: 'enabled',
-        nextRunAt,
-        scheduleRule: scheduleRuleFor({ ...task, nextRunAt }),
-        updatedAt: new Date().toISOString(),
-      }
+      const repaired = recurringTaskStatusRepair(task, now)
+      if (repaired) data[taskId] = repaired
     }
     return data
   })
@@ -566,14 +575,15 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
     onStarted?.({ taskId: task.id, runId, sessionId })
 
     const eventBus = getSessionEventBus(sessionId)
+    const runtimeLimitMs = Math.max(1000, Math.min(Number(executionAgent?.maxRuntimeMs || 30 * 60 * 1000), 30 * 60 * 1000))
+    let timeout = null
+    let handler = null
+    let timedOut = false
+    let resolveFinished
     const finished = new Promise((resolve) => {
-      const cleanup = (handler, timeout) => {
-        clearTimeout(timeout)
-        eventBus?.removeListener('agent_event', handler)
-      }
-      const handler = (event) => {
+      resolveFinished = resolve
+      handler = (event) => {
         if (event.type !== 'agent_end') return
-        cleanup(handler, timeout)
         const errorMessage = event.errorMessage || session.agent.state.errorMessage
         const aborted = session.status === 'aborted' || session.agent.state.messages.some((message) => message?.role === 'assistant' && message?.stopReason === 'aborted')
         resolve({
@@ -583,24 +593,54 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
           messages: event.messages ?? session.agent.state.messages,
         })
       }
-      const timeout = setTimeout(() => {
-        cleanup(handler, timeout)
-        resolve({ ok: false, aborted: false, error: '执行超时', messages: session.agent.state.messages })
-      }, Math.max(1000, Math.min(Number(executionAgent?.maxRuntimeMs || 30 * 60 * 1000), 30 * 60 * 1000)))
       eventBus?.on('agent_event', handler)
     })
 
+    const runPromise = (async () => {
+      try {
+        await session.agent.continue()
+      } catch (continueError) {
+        if (continueError?.message !== 'Request was aborted' && continueError?.message !== 'Scheduled task aborted') {
+          throw continueError
+        }
+      }
+      return finished
+    })()
+    const timeoutPromise = new Promise((resolve) => {
+      timeout = setTimeout(() => resolve({ timedOut: true }), runtimeLimitMs)
+    })
+
+    let result
     try {
-      await session.agent.continue()
-    } catch (continueError) {
-      if (continueError?.message === 'Request was aborted' || continueError?.message === 'Scheduled task aborted') {
-        settled = true
+      const outcome = await Promise.race([
+        runPromise.then((value) => ({ result: value })),
+        timeoutPromise,
+      ])
+      if (outcome.timedOut) {
+        timedOut = true
+        const abortPromise = Promise.resolve()
+          .then(() => abortRun(sessionId))
+          .catch((error) => {
+            logger.warn(`Failed to abort timed out scheduled task ${task.id}:`, error)
+          })
+        await Promise.race([
+          abortPromise,
+          new Promise((resolve) => setTimeout(resolve, 1000)),
+        ])
+        await Promise.race([
+          runPromise.catch(() => undefined),
+          new Promise((resolve) => setTimeout(resolve, 1000)),
+        ])
+        result = { ok: false, aborted: true, error: '执行超时', messages: session.agent.state.messages }
       } else {
-        throw continueError
+        result = outcome.result
       }
+    } finally {
+      clearTimeout(timeout)
+      eventBus?.removeListener('agent_event', handler)
+      if (timedOut) resolveFinished?.({ ok: false, aborted: true, error: '执行超时', messages: session.agent.state.messages })
     }
-    const result = await finished
-    if (result.aborted) settled = true
+    settled = true
     const finishedAt = new Date().toISOString()
     const durationMs = new Date(finishedAt).getTime() - new Date(startedAt).getTime()
     const aiResult = result.ok ? latestAssistantText(result.messages) : ''
@@ -634,7 +674,7 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
         inputContent: run.inputContent ?? latestTask.instruction,
         aiResult: result.ok ? aiResult : undefined,
         result: result.ok ? (aiResult || `已完成，结果保存在会话 ${sessionId}`) : undefined,
-        errorMessage: result.aborted ? '已暂停执行' : result.error,
+        errorMessage: result.error,
         sessionId,
         agentId: executionAgent?.id || latestTask.agentId || null,
         agentLabel: executionAgent?.label || null,
@@ -651,7 +691,7 @@ async function executeTask(task, trigger = 'schedule', onStarted) {
       sessionId,
       status: result.aborted ? 'failed' : (result.ok ? 'success' : 'failed'),
       result: aiResult,
-      errorMessage: result.aborted ? '已暂停执行' : result.error,
+      errorMessage: result.error,
     })
   } catch (error) {
     const finishedAt = new Date().toISOString()