@shawnstack/quickforge 1.4.1 → 1.5.1

package/server/channels/process-channel.mjs

@@ -0,0 +1,278 @@
+import { spawn } from 'node:child_process'
+import { EventEmitter } from 'node:events'
+import { setTimeout as delay } from 'node:timers/promises'
+
+const DEFAULT_LOG_LIMIT = 300
+const STOP_TIMEOUT_MS = 5000
+
+function nowIso() {
+  return new Date().toISOString()
+}
+
+function normalizeChunk(chunk) {
+  return Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk)
+}
+
+function stripAnsi(value) {
+  return String(value).replace(/\u001b\[[0-9;?]*[ -/]*[@-~]/g, '')
+}
+
+function appendLineBuffer(buffer, text, onLine) {
+  const combined = buffer + text
+  const lines = combined.split(/\r?\n/)
+  const nextBuffer = lines.pop() || ''
+  for (const line of lines) onLine(line)
+  return nextBuffer
+}
+
+function runDetachedCommand(command, args) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, { windowsHide: true, stdio: 'ignore' })
+    child.once('error', () => resolve(false))
+    child.once('exit', (code) => resolve(code === 0))
+  })
+}
+
+async function terminateProcess(child, signal = 'SIGTERM') {
+  if (!child?.pid) return false
+  if (process.platform === 'win32') {
+    return runDetachedCommand('taskkill.exe', ['/PID', String(child.pid), '/T', signal === 'SIGKILL' ? '/F' : undefined].filter(Boolean))
+  }
+  try {
+    return process.kill(-child.pid, signal)
+  } catch {
+    try {
+      return child.kill(signal)
+    } catch {
+      return false
+    }
+  }
+}
+
+export class ProcessChannelProvider extends EventEmitter {
+  constructor(definition, options = {}) {
+    super()
+    this.definition = definition
+    this.logLimit = options.logLimit || DEFAULT_LOG_LIMIT
+    this.status = 'stopped'
+    this.process = null
+    this.pid = null
+    this.startedAt = null
+    this.stoppedAt = null
+    this.exitCode = null
+    this.exitSignal = null
+    this.error = null
+    this.logs = []
+    this.qrCodeUrl = null
+    this.qrCodeText = ''
+    this.activeAction = null
+    this.stopRequested = false
+    this.stdoutBuffer = ''
+    this.stderrBuffer = ''
+    this.startPromise = null
+    this.stopPromise = null
+  }
+
+  snapshot() {
+    return {
+      id: this.definition.id,
+      name: this.definition.name,
+      description: this.definition.description,
+      kind: this.definition.kind || 'process',
+      provider: this.definition.provider,
+      icon: this.definition.icon,
+      commandLabel: this.definition.commandLabel,
+      supportsWorkspaceSelection: this.definition.supportsWorkspaceSelection === true,
+      status: this.status,
+      pid: this.pid,
+      startedAt: this.startedAt,
+      stoppedAt: this.stoppedAt,
+      exitCode: this.exitCode,
+      exitSignal: this.exitSignal,
+      error: this.error,
+      logs: this.logs,
+      qrCodeUrl: this.qrCodeUrl,
+      qrCodeText: this.qrCodeText,
+      actions: this.definition.actions || [],
+      requirements: this.definition.requirements || [],
+      activeAction: this.activeAction,
+    }
+  }
+
+  emitEvent(type, payload = {}) {
+    const event = {
+      type,
+      channelId: this.definition.id,
+      timestamp: nowIso(),
+      ...payload,
+    }
+    this.emit('event', event)
+  }
+
+  setStatus(status, extra = {}) {
+    this.status = status
+    if (Object.prototype.hasOwnProperty.call(extra, 'error')) {
+      this.error = extra.error
+    }
+    this.emitEvent('status', { status, snapshot: this.snapshot() })
+  }
+
+  addLog(stream, text) {
+    if (!text) return
+    const entry = {
+      id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+      time: nowIso(),
+      stream,
+      text,
+    }
+    this.logs.push(entry)
+    if (this.logs.length > this.logLimit) {
+      this.logs.splice(0, this.logs.length - this.logLimit)
+    }
+    this.emitEvent('log', { log: entry })
+  }
+
+  addProcessText(stream, text) {
+    const cleanText = stripAnsi(text).replace(/\r/g, '\n')
+    if (!cleanText) return
+    this.addLog(stream, cleanText)
+    this.inspectOutput(cleanText, stream)
+
+    const lineHandler = (line) => this.inspectOutputLine(line, stream)
+    if (stream === 'stderr') {
+      this.stderrBuffer = appendLineBuffer(this.stderrBuffer, cleanText, lineHandler)
+    } else {
+      this.stdoutBuffer = appendLineBuffer(this.stdoutBuffer, cleanText, lineHandler)
+    }
+  }
+
+  inspectOutput(_text, _stream) {
+  }
+
+  inspectOutputLine(_line, _stream) {
+  }
+
+  buildStartCommand() {
+    throw new Error('buildStartCommand() is not implemented')
+  }
+
+  async beforeStart(_options = {}) {}
+
+  async start(options = {}) {
+    if (this.process) return this.snapshot()
+    if (this.startPromise) return this.startPromise
+    if (this.status === 'stopping') return this.snapshot()
+
+    this.startPromise = this.#startProcess(options)
+    try {
+      return await this.startPromise
+    } finally {
+      this.startPromise = null
+    }
+  }
+
+  async #startProcess(options = {}) {
+    this.stopRequested = false
+    this.exitCode = null
+    this.exitSignal = null
+    this.error = null
+    this.qrCodeUrl = null
+    this.qrCodeText = ''
+    this.stdoutBuffer = ''
+    this.stderrBuffer = ''
+    this.startedAt = nowIso()
+    this.stoppedAt = null
+    this.setStatus('starting')
+
+    await this.beforeStart(options)
+    if (this.process) return this.snapshot()
+
+    const commandSpec = this.buildStartCommand(options)
+
+    const child = spawn(commandSpec.command, commandSpec.args || [], {
+      cwd: commandSpec.cwd,
+      env: commandSpec.env || process.env,
+      windowsHide: true,
+      detached: process.platform !== 'win32',
+      shell: commandSpec.shell === true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    this.process = child
+    this.pid = child.pid || null
+    this.emitEvent('status', { status: this.status, snapshot: this.snapshot() })
+
+    child.stdout?.on('data', (chunk) => this.addProcessText('stdout', normalizeChunk(chunk)))
+    child.stderr?.on('data', (chunk) => this.addProcessText('stderr', normalizeChunk(chunk)))
+
+    child.once('error', (error) => {
+      this.error = error.message || String(error)
+      this.addLog('stderr', this.error)
+      this.process = null
+      this.pid = null
+      this.stoppedAt = nowIso()
+      this.setStatus('error', { error: this.error })
+    })
+
+    child.once('exit', (code, signal) => {
+      this.process = null
+      this.pid = null
+      this.exitCode = code
+      this.exitSignal = signal
+      this.stoppedAt = nowIso()
+      if (this.stopRequested || code === 0) {
+        this.setStatus('stopped')
+      } else {
+        const reason = `Channel process exited with code ${code ?? 'null'}${signal ? ` signal ${signal}` : ''}`
+        this.error = reason
+        this.setStatus('error', { error: reason })
+      }
+    })
+
+    return this.snapshot()
+  }
+
+  async stop() {
+    if (this.stopPromise) return this.stopPromise
+    this.stopPromise = this.#stopProcess()
+    try {
+      return await this.stopPromise
+    } finally {
+      this.stopPromise = null
+    }
+  }
+
+  async #stopProcess() {
+    if (!this.process) {
+      this.setStatus('stopped')
+      return this.snapshot()
+    }
+
+    this.stopRequested = true
+    this.setStatus('stopping')
+    const child = this.process
+    await terminateProcess(child, 'SIGTERM')
+
+    const exited = await Promise.race([
+      new Promise((resolve) => child.once('exit', () => resolve(true))),
+      delay(STOP_TIMEOUT_MS).then(() => false),
+    ])
+
+    if (!exited && this.process === child) {
+      await terminateProcess(child, 'SIGKILL')
+    }
+
+    return this.snapshot()
+  }
+
+  async restart(options = {}) {
+    await this.stop()
+    return this.start(options)
+  }
+
+  async runAction(_action, _options = {}) {
+    const error = new Error('Unsupported channel action')
+    error.statusCode = 404
+    throw error
+  }
+}

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 }