@shawnstack/quickforge 1.5.3 → 1.5.5

package/dist/sw.js

@@ -1,4 +1,4 @@
-const CACHE_NAME = 'quickforge-pwa-v1'
+const CACHE_NAME = 'quickforge-pwa-v2'
 const PRECACHE_URLS = [
   '/',
   '/favicon.svg',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shawnstack/quickforge",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "description": "AI chat application with Agent access modes for local workspace tools. React + Vite + Tailwind CSS frontend, local Node.js storage server.",
   "keywords": [
     "ai",
@@ -28,6 +28,7 @@
   },
   "homepage": "https://github.com/shawnstack/quickforge#readme",
   "type": "module",
+  "main": "./server/public-api.mjs",
   "bin": {
     "quickforge": "bin/quickforge.mjs",
     "qf": "bin/quickforge.mjs"

package/server/agent-manager.mjs

@@ -1551,13 +1551,20 @@ async function persistSession(session) {
   // Write to storage atomically (read-modify-write within queue)
   try {
     await writeSessionValue(sessionId, sessionData)
+    let archivedAt
     await atomicSessionMetadataUpdate(scope, projectId, (data) => {
+      const existingMetadata = data[sessionId]
+      archivedAt = existingMetadata?.archivedAt
       data[sessionId] = {
         ...metadata,
-        pinnedAt: data[sessionId]?.pinnedAt,
+        pinnedAt: existingMetadata?.pinnedAt,
+        ...(archivedAt ? { archivedAt } : {}),
       }
       return data
     })
+    if (archivedAt) {
+      await writeSessionValue(sessionId, { ...sessionData, archivedAt })
+    }
   } catch (err) {
     logger.error(`Failed to persist session ${sessionId}:`, err, { sessionId })
   }

package/server/index.mjs

@@ -31,7 +31,7 @@ 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 { getPackageInfo, checkForUpdates } 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'
@@ -46,6 +46,7 @@ const __dirname = path.dirname(__filename)
 const projectRoot = path.resolve(__dirname, '..')
 const serverScript = path.join(__dirname, 'index.mjs')
 const restartSupervisorScript = path.join(__dirname, 'restart-supervisor.mjs')
+const updateSupervisorScript = path.join(__dirname, 'update-supervisor.mjs')
 const bootId = randomUUID()
 const startedAt = new Date().toISOString()
 
@@ -175,6 +176,56 @@ async function requestRestart() {
   return { ok: true, restarting: true, bootId }
 }
 
+function updateLogFile() {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').replace('T', '_').replace('Z', '')
+  return path.join(logsDir, `update-${stamp}.log`)
+}
+
+function spawnUpdateSupervisor(update) {
+  const logFile = updateLogFile()
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [
+      updateSupervisorScript,
+      String(process.pid),
+      update.name,
+      update.latestVersion,
+      serverScript,
+      projectRoot,
+      logFile,
+      ...process.argv.slice(2),
+    ], {
+      cwd: dataDir,
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      shell: false,
+      env: {
+        ...process.env,
+        QUICKFORGE_NO_OPEN: '1',
+      },
+    })
+
+    child.once('error', reject)
+    child.once('spawn', () => {
+      child.unref()
+      resolve({ pid: child.pid, logFile })
+    })
+  })
+}
+
+async function shutdownForUpdate() {
+  logger.info('Shutting down QuickForge for external updater.')
+  stopScheduledTaskRunner()
+  stopVite()
+  await shutdownAgentManager()
+  await shutdownMcpConnections()
+  await shutdownChannels()
+  shutdownTerminalSessions()
+  await closeHttpServer()
+  flushLogger()
+  process.exit(0)
+}
+
 async function updateQuickForge() {
   if (updateInProgress) {
     const error = new Error('Update already in progress')
@@ -186,15 +237,34 @@ async function updateQuickForge() {
   try {
     const update = await checkForUpdates(projectRoot)
     if (!update.updateAvailable) {
+      updateInProgress = false
       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 {
+    logger.info(`Starting external QuickForge updater from ${update.currentVersion} to ${update.latestVersion}.`)
+    const supervisor = await spawnUpdateSupervisor(update)
+    logger.info(`Update supervisor started (PID ${supervisor.pid}). Log: ${supervisor.logFile}`)
+
+    setTimeout(() => {
+      void shutdownForUpdate().catch((error) => {
+        logger.error('Failed to shut down for QuickForge update:', error)
+        updateInProgress = false
+      })
+    }, 100)
+
+    return {
+      ...update,
+      ok: true,
+      updated: false,
+      updateStarted: true,
+      restarting: true,
+      updaterPid: supervisor.pid,
+      logFile: supervisor.logFile,
+      bootId,
+    }
+  } catch (error) {
     updateInProgress = false
+    throw error
   }
 }
 

package/server/public-api.mjs

@@ -0,0 +1,196 @@
+import { spawn } from 'node:child_process'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const projectRoot = path.resolve(__dirname, '..')
+const serverScript = path.join(__dirname, 'index.mjs')
+const serverScriptUrl = pathToFileURL(serverScript).href
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function normalizeHost(host) {
+  return host || '127.0.0.1'
+}
+
+function getProbeHost(host) {
+  if (host === '0.0.0.0' || host === '::') return '127.0.0.1'
+  return host || '127.0.0.1'
+}
+
+function getDisplayHost(host) {
+  if (host === '0.0.0.0') return '<LAN-IP>'
+  if (host === '::') return '<LAN-IP>'
+  return host || '127.0.0.1'
+}
+
+function getPort(port) {
+  return Number(port || 5176)
+}
+
+function buildEnv(options = {}) {
+  const host = normalizeHost(options.host)
+  const port = getPort(options.port)
+  const shareLan = options.shareLan === true
+  const env = {
+    ...process.env,
+    QUICKFORGE_HOST: host,
+    QUICKFORGE_PORT: String(port),
+    QUICKFORGE_SHARE_LAN: shareLan ? '1' : '0',
+    QUICKFORGE_NO_OPEN: options.openBrowser ? '0' : '1',
+  }
+
+  if (options.dataDir) env.QUICKFORGE_DATA_DIR = path.resolve(options.dataDir)
+  if (options.workspaceDir) env.QUICKFORGE_WORKSPACE_DIR = path.resolve(options.workspaceDir)
+  if (options.vitePort) env.QUICKFORGE_VITE_PORT = String(options.vitePort)
+  if (options.terminal === false) env.QUICKFORGE_TERMINAL = '0'
+  if (process.versions.electron) env.ELECTRON_RUN_AS_NODE = '1'
+  if (options.allowRemote || shareLan) env.QUICKFORGE_ALLOW_REMOTE = '1'
+
+  return env
+}
+
+export function getQuickForgeUrl(options = {}) {
+  const host = getDisplayHost(normalizeHost(options.host))
+  const port = getPort(options.port)
+  return `http://${host}:${port}`
+}
+
+export function getQuickForgeHealthUrl(options = {}) {
+  const host = getProbeHost(normalizeHost(options.host))
+  const port = getPort(options.port)
+  return `http://${host}:${port}/api/health`
+}
+
+export async function checkQuickForgeHealth(options = {}) {
+  const controller = new AbortController()
+  const timeout = setTimeout(() => controller.abort(), options.requestTimeoutMs || 800)
+  timeout.unref?.()
+
+  try {
+    const response = await fetch(getQuickForgeHealthUrl(options), {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    })
+    if (!response.ok) return null
+    const payload = await response.json()
+    if (!payload || payload.ok !== true || !payload.pid) return null
+    return payload
+  } catch {
+    return null
+  } finally {
+    clearTimeout(timeout)
+  }
+}
+
+async function waitForQuickForge(options = {}) {
+  const timeoutMs = options.timeoutMs || 15000
+  const deadline = Date.now() + timeoutMs
+
+  while (Date.now() < deadline) {
+    const health = await checkQuickForgeHealth(options)
+    if (health) return health
+    await sleep(options.pollIntervalMs || 300)
+  }
+
+  return null
+}
+
+export async function startQuickForge(options = {}) {
+  const existingHealth = options.reuseExisting === false ? null : await checkQuickForgeHealth(options)
+  const url = getQuickForgeUrl(options)
+  const healthUrl = getQuickForgeHealthUrl(options)
+
+  if (existingHealth) {
+    return {
+      url,
+      healthUrl,
+      health: existingHealth,
+      pid: existingHealth.pid,
+      child: null,
+      reused: true,
+      async stop() {
+        return false
+      },
+    }
+  }
+
+  if (options.inline === true) {
+    await import(serverScriptUrl)
+    const health = await waitForQuickForge(options)
+    if (!health) throw new Error('QuickForge failed to start: health check timed out')
+    return {
+      url,
+      healthUrl,
+      health,
+      pid: health.pid || process.pid,
+      child: null,
+      reused: false,
+      inline: true,
+      async stop() {
+        return false
+      },
+    }
+  }
+
+  const child = spawn(process.execPath, [serverScript], {
+    cwd: options.cwd ? path.resolve(options.cwd) : projectRoot,
+    detached: options.detached === true,
+    stdio: options.stdio || 'ignore',
+    windowsHide: true,
+    shell: false,
+    env: buildEnv(options),
+  })
+
+  let exitInfo = null
+  child.once('exit', (code, signal) => {
+    exitInfo = { code, signal }
+  })
+
+  await new Promise((resolve, reject) => {
+    child.once('spawn', resolve)
+    child.once('error', reject)
+  })
+
+  const health = await waitForQuickForge(options)
+  if (!health) {
+    if (!child.killed && exitInfo === null) {
+      try {
+        child.kill('SIGTERM')
+      } catch {
+        // ignore best-effort cleanup errors
+      }
+    }
+
+    const reason = exitInfo
+      ? `process exited early (code ${exitInfo.code ?? 'null'}, signal ${exitInfo.signal ?? 'null'})`
+      : 'health check timed out'
+    throw new Error(`QuickForge failed to start: ${reason}`)
+  }
+
+  if (options.detached === true) child.unref()
+
+  return {
+    url,
+    healthUrl,
+    health,
+    pid: health.pid || child.pid,
+    child,
+    reused: false,
+    async stop() {
+      if (child.killed) return false
+      child.kill('SIGTERM')
+      return true
+    },
+  }
+}
+
+export async function stopQuickForge(instance) {
+  if (!instance?.child || instance.reused) return false
+  if (instance.child.killed) return false
+  instance.child.kill('SIGTERM')
+  return true
+}

package/server/routes/system.mjs

@@ -25,7 +25,8 @@ export async function handleSystemApi(req, res, url, context) {
       throw error
     }
 
-    sendJson(res, 200, await context.updateQuickForge())
+    const result = await context.updateQuickForge()
+    sendJson(res, result.updateStarted ? 202 : 200, result)
     return
   }
 

package/server/update-supervisor.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+const [oldPidArg, packageName, latestVersion, serverScript, serverCwd, logFile, ...serverArgs] = process.argv.slice(2)
+const oldPid = Number(oldPidArg)
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+function isProcessRunning(pid) {
+  if (!pid) return false
+  try {
+    process.kill(pid, 0)
+    return true
+  } catch {
+    return false
+  }
+}
+
+function ensureLogDir(filePath) {
+  try { fs.mkdirSync(path.dirname(filePath), { recursive: true }) } catch { /* ignore */ }
+}
+
+function timestamp() {
+  return new Date().toISOString()
+}
+
+function getNpmCommand() {
+  return process.platform === 'win32' ? 'npm.cmd' : 'npm'
+}
+
+ensureLogDir(logFile)
+const logStream = fs.createWriteStream(logFile, { flags: 'a' })
+
+function log(message) {
+  logStream.write(`${timestamp()} ${message}\n`)
+}
+
+function pipeOutput(stream, prefix) {
+  stream?.on('data', (chunk) => {
+    const text = String(chunk)
+    for (const line of text.split(/\r?\n/)) {
+      if (line.trim()) log(`${prefix} ${line}`)
+    }
+  })
+}
+
+function spawnAndWait(command, args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, options)
+    pipeOutput(child.stdout, '[stdout]')
+    pipeOutput(child.stderr, '[stderr]')
+    child.once('error', reject)
+    child.once('exit', (code, signal) => resolve({ code, signal }))
+  })
+}
+
+async function main() {
+  const target = `${packageName}@latest`
+  log(`QuickForge external updater started. target=${target} latest=${latestVersion || 'unknown'} oldPid=${oldPid || 'unknown'}`)
+  log(`Updater cwd=${process.cwd()}`)
+  log(`Server script=${serverScript}`)
+
+  for (let i = 0; i < 600 && isProcessRunning(oldPid); i += 1) {
+    if (i === 0) log(`Waiting for old QuickForge process ${oldPid} to exit...`)
+    await sleep(100)
+  }
+
+  if (isProcessRunning(oldPid)) {
+    log(`Old QuickForge process ${oldPid} is still running after timeout; continuing with npm install.`)
+  } else {
+    log('Old QuickForge process has exited.')
+  }
+
+  const npmCommand = getNpmCommand()
+  const npmArgs = ['install', '-g', target]
+  log(`Running: ${npmCommand} ${npmArgs.join(' ')}`)
+  const installResult = await spawnAndWait(npmCommand, npmArgs, {
+    cwd: process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe'],
+    shell: process.platform === 'win32',
+    windowsHide: true,
+    env: process.env,
+  })
+
+  if (installResult.code !== 0) {
+    log(`npm install failed. code=${installResult.code} signal=${installResult.signal || ''}`)
+    process.exitCode = installResult.code || 1
+    return
+  }
+
+  log('npm install completed successfully.')
+  log(`Starting QuickForge server: ${process.execPath} ${[serverScript, ...serverArgs].join(' ')}`)
+  const child = spawn(process.execPath, [serverScript, ...serverArgs], {
+    cwd: serverCwd || undefined,
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    shell: false,
+    env: {
+      ...process.env,
+      QUICKFORGE_NO_OPEN: '1',
+      QUICKFORGE_RESTARTED_FROM_UPDATE: '1',
+    },
+  })
+
+  child.unref()
+  log(`QuickForge server spawned. pid=${child.pid || 'unknown'}`)
+}
+
+try {
+  await main()
+} catch (error) {
+  log(`Updater failed: ${error?.stack || error?.message || error}`)
+  process.exitCode = 1
+} finally {
+  await new Promise((resolve) => logStream.end(resolve))
+}