@shawnstack/quickforge 1.4.1 → 1.5.0

package/server/channels/providers/wechat.mjs

@@ -0,0 +1,271 @@
+import { spawn } from 'node:child_process'
+import { promises as fs } from 'node:fs'
+import path from 'node:path'
+import { ProcessChannelProvider } from '../process-channel.mjs'
+import { getDefaultWorkspaceRoot, readProjectConfig } from '../../project-config.mjs'
+
+const WEIXIN_ACP_PACKAGE = 'weixin-acp'
+const MIN_NODE_MAJOR = 22
+const ACTION_TIMEOUT_MS = 120_000
+const DEFAULT_WORKSPACE_ID = 'default'
+
+function npxCommand() {
+  return process.platform === 'win32' ? 'npx.cmd' : 'npx'
+}
+
+function shouldUseShellForNpx() {
+  return process.platform === 'win32'
+}
+
+function nodeMajor() {
+  return Number(process.versions.node.split('.')[0] || 0)
+}
+
+function qfAcpCommand(projectRoot) {
+  const nodeCommand = process.platform === 'win32' ? 'node' : process.execPath
+  return [nodeCommand, path.join(projectRoot, 'bin', 'quickforge.mjs'), 'acp']
+}
+
+function workspaceSummary(id, name, workspacePath, kind) {
+  return {
+    id,
+    name,
+    path: workspacePath,
+    kind,
+  }
+}
+
+async function assertDirectoryExists(workspacePath) {
+  try {
+    const stat = await fs.stat(workspacePath)
+    if (stat.isDirectory()) return
+  } catch {
+    // Report a clear channel action error below.
+  }
+  const error = new Error(`Workspace is not a directory: ${workspacePath}`)
+  error.statusCode = 400
+  throw error
+}
+
+async function resolveLaunchWorkspace(options = {}) {
+  const requestedId = typeof options.projectId === 'string' ? options.projectId : DEFAULT_WORKSPACE_ID
+  if (!requestedId || requestedId === DEFAULT_WORKSPACE_ID) {
+    const workspacePath = getDefaultWorkspaceRoot()
+    await assertDirectoryExists(workspacePath)
+    return workspaceSummary(DEFAULT_WORKSPACE_ID, 'workspace', workspacePath, 'default')
+  }
+
+  const config = await readProjectConfig()
+  const project = config.projects.find((item) => item.id === requestedId)
+  if (!project) {
+    const error = new Error(`Unknown project: ${requestedId}`)
+    error.statusCode = 404
+    throw error
+  }
+  await assertDirectoryExists(project.path)
+  return workspaceSummary(project.id, project.name, project.path, 'project')
+}
+
+function extractUrl(text) {
+  const matches = String(text).match(/https?:\/\/[^\s\u001b]+/g)
+  if (!matches?.length) return null
+  return matches[matches.length - 1].replace(/[),，。]+$/u, '')
+}
+
+function looksLikeTerminalQr(text) {
+  return /[█▀▄]{6,}/u.test(text) || /[▄▀]{6,}/u.test(text)
+}
+
+function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env || process.env,
+      windowsHide: true,
+      shell: options.shell === true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+    let stdout = ''
+    let stderr = ''
+    let settled = false
+    const timer = setTimeout(() => {
+      if (settled) return
+      child.kill('SIGTERM')
+      settled = true
+      const error = new Error(`Command timed out after ${options.timeoutMs || ACTION_TIMEOUT_MS}ms`)
+      error.stdout = stdout
+      error.stderr = stderr
+      reject(error)
+    }, options.timeoutMs || ACTION_TIMEOUT_MS)
+
+    child.stdout?.on('data', (chunk) => {
+      const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk)
+      stdout += text
+      options.onStdout?.(text)
+    })
+    child.stderr?.on('data', (chunk) => {
+      const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk)
+      stderr += text
+      options.onStderr?.(text)
+    })
+    child.once('error', (error) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      reject(error)
+    })
+    child.once('exit', (code, signal) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (code === 0) {
+        resolve({ stdout, stderr, code, signal })
+      } else {
+        const error = new Error(`Command exited with code ${code ?? 'null'}${signal ? ` signal ${signal}` : ''}`)
+        error.stdout = stdout
+        error.stderr = stderr
+        error.code = code
+        error.signal = signal
+        reject(error)
+      }
+    })
+  })
+}
+
+export class WechatChannelProvider extends ProcessChannelProvider {
+  constructor({ projectRoot }) {
+    super({
+      id: 'wechat',
+      name: '微信',
+      description: '通过 weixin-acp 将微信消息接入 QuickForge ACP Agent。',
+      kind: 'process',
+      provider: 'weixin-acp',
+      icon: 'wechat',
+      commandLabel: 'npx weixin-acp start -- qf acp',
+      supportsWorkspaceSelection: true,
+      actions: [
+        { id: 'logout', label: '退出登录', destructive: true },
+        { id: 'relogin', label: '重新登录' },
+      ],
+      requirements: [`Node.js >= ${MIN_NODE_MAJOR}`, 'npm/npx 可用', '首次启动需要微信扫码登录'],
+    })
+    this.projectRoot = projectRoot
+    this.launchWorkspace = null
+  }
+
+  snapshot() {
+    return {
+      ...super.snapshot(),
+      launchWorkspace: this.launchWorkspace,
+    }
+  }
+
+  async beforeStart(options = {}) {
+    if (nodeMajor() < MIN_NODE_MAJOR) {
+      const message = `微信渠道需要 Node.js >= ${MIN_NODE_MAJOR}，当前版本是 ${process.versions.node}。请升级 Node 后重试。`
+      this.error = message
+      this.setStatus('error', { error: message })
+      const error = new Error(message)
+      error.statusCode = 409
+      throw error
+    }
+    this.launchWorkspace = await resolveLaunchWorkspace(options)
+  }
+
+  buildStartCommand() {
+    const [acpCommand, ...acpArgs] = qfAcpCommand(this.projectRoot)
+    return {
+      command: npxCommand(),
+      args: ['-y', WEIXIN_ACP_PACKAGE, 'start', '--', acpCommand, ...acpArgs],
+      cwd: this.launchWorkspace?.path || getDefaultWorkspaceRoot() || this.projectRoot,
+      env: process.env,
+      shell: shouldUseShellForNpx(),
+    }
+  }
+
+  inspectOutput(text) {
+    const url = extractUrl(text)
+    if (url) {
+      this.qrCodeUrl = url
+      if (this.status === 'starting') this.setStatus('waiting_scan')
+      this.emitEvent('qrcode', { qrCodeUrl: this.qrCodeUrl, qrCodeText: this.qrCodeText, snapshot: this.snapshot() })
+    }
+
+    if (looksLikeTerminalQr(text)) {
+      const nextText = `${this.qrCodeText}\n${text}`.trim()
+      this.qrCodeText = nextText.length > 8000 ? nextText.slice(-8000) : nextText
+      if (this.status === 'starting') this.setStatus('waiting_scan')
+      this.emitEvent('qrcode', { qrCodeUrl: this.qrCodeUrl, qrCodeText: this.qrCodeText, snapshot: this.snapshot() })
+    }
+
+    if (/扫码|二维码|等待扫码|scan/i.test(text) && this.status === 'starting') {
+      this.setStatus('waiting_scan')
+    }
+
+    if (/与微信连接成功|启动 bot|\[weixin\] 启动 bot|connected|login success/i.test(text)) {
+      this.qrCodeText = ''
+      this.setStatus('running')
+    }
+  }
+
+  inspectOutputLine(line) {
+    if (/与微信连接成功|启动 bot|\[weixin\] 启动 bot|connected|login success/i.test(line)) {
+      this.qrCodeText = ''
+      this.setStatus('running')
+    }
+  }
+
+  async runAction(action, options = {}) {
+    if (action === 'logout') return this.logout()
+    if (action === 'relogin') return this.relogin(options)
+    return super.runAction(action, options)
+  }
+
+  async logout({ preserveActiveAction = false } = {}) {
+    if (this.activeAction && !preserveActiveAction) return this.snapshot()
+    if (!preserveActiveAction) this.activeAction = 'logout'
+    this.emitEvent('status', { status: this.status, snapshot: this.snapshot() })
+    try {
+      if (this.process) await this.stop()
+      this.addLog('system', 'Running: npx weixin-acp logout')
+      await runCommand(npxCommand(), ['-y', WEIXIN_ACP_PACKAGE, 'logout'], {
+        cwd: this.projectRoot,
+        env: process.env,
+        shell: shouldUseShellForNpx(),
+        onStdout: (text) => this.addProcessText('stdout', text),
+        onStderr: (text) => this.addProcessText('stderr', text),
+      })
+      this.qrCodeUrl = null
+      this.qrCodeText = ''
+      this.error = null
+      this.setStatus('stopped')
+      return this.snapshot()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      this.error = message
+      this.addLog('stderr', message)
+      this.setStatus('error', { error: message })
+      throw error
+    } finally {
+      if (!preserveActiveAction) this.activeAction = null
+      this.emitEvent('status', { status: this.status, snapshot: this.snapshot() })
+    }
+  }
+
+  async relogin(options = {}) {
+    if (this.activeAction) return this.snapshot()
+    this.activeAction = 'relogin'
+    this.emitEvent('status', { status: this.status, snapshot: this.snapshot() })
+    try {
+      await this.logout({ preserveActiveAction: true })
+      return await this.start({ projectId: options.projectId || this.launchWorkspace?.id || DEFAULT_WORKSPACE_ID })
+    } finally {
+      this.activeAction = null
+      this.emitEvent('status', { status: this.status, snapshot: this.snapshot() })
+    }
+  }
+}
+
+export function createWechatChannelProvider(options) {
+  return new WechatChannelProvider(options)
+}

package/server/channels/registry.mjs

@@ -0,0 +1,58 @@
+import { EventEmitter } from 'node:events'
+import { createWechatChannelProvider } from './providers/wechat.mjs'
+
+export const channelEvents = new EventEmitter()
+
+const providers = new Map()
+let initialized = false
+
+function attachProvider(provider) {
+  providers.set(provider.definition.id, provider)
+  provider.on('event', (event) => {
+    channelEvents.emit('channel_event', event)
+  })
+}
+
+export function initializeChannels(options = {}) {
+  if (initialized) return
+  initialized = true
+  attachProvider(createWechatChannelProvider({ projectRoot: options.projectRoot }))
+}
+
+function requireProvider(id) {
+  const provider = providers.get(id)
+  if (!provider) {
+    const error = new Error(`Unknown channel: ${id}`)
+    error.statusCode = 404
+    throw error
+  }
+  return provider
+}
+
+export function listChannels() {
+  return Array.from(providers.values()).map((provider) => provider.snapshot())
+}
+
+export function getChannelStatus(id) {
+  return requireProvider(id).snapshot()
+}
+
+export async function startChannel(id, options = {}) {
+  return requireProvider(id).start(options)
+}
+
+export async function stopChannel(id) {
+  return requireProvider(id).stop()
+}
+
+export async function restartChannel(id, options = {}) {
+  return requireProvider(id).restart(options)
+}
+
+export async function runChannelAction(id, action, options = {}) {
+  return requireProvider(id).runAction(action, options)
+}
+
+export async function shutdownChannels() {
+  await Promise.allSettled(Array.from(providers.values()).map((provider) => provider.stop()))
+}

package/server/custom-commands.mjs

@@ -26,9 +26,14 @@ const builtinCommandCatalog = [
     argumentHint: '[scope]',
     permissionNote: 'no edits',
   },
+  {
+    name: 'summary',
+    description: 'Create a new chat with this conversation summarized to reduce context usage.',
+    argumentHint: '',
+  },
   {
     name: 'compact',
-    description: 'Create a new chat with this conversation compacted to reduce context usage.',
+    description: 'Compact this conversation context in place using the same rolling summary as auto-compaction.',
     argumentHint: '',
   },
   {
@@ -373,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])
@@ -389,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 }

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)