@shawnstack/quickforge 1.4.1 → 1.5.0

package/server/agent-profiles.mjs

@@ -2,6 +2,8 @@ import { randomUUID } from 'node:crypto'
 import { readStore, atomicUpdate } from './storage.mjs'
 import { subagentDefinitions } from './subagents.mjs'
 import { workspaceTools } from './tools/definitions.mjs'
+import { defaultGlobalWorkspaceContext, projectContextFromId } from './project-config.mjs'
+import { loadFileAgentProfiles } from './agent-profile-files.mjs'
 
 const STORE = 'custom-agents'
 const RESERVED_NAMES = new Set(subagentDefinitions.map((definition) => definition.name))
@@ -56,6 +58,9 @@ function builtinProfileFromSubagent(definition) {
     maxToolCalls: definition.maxToolCalls || DEFAULT_MAX_TOOL_CALLS,
     enabledAsSubagent: true,
     builtin: true,
+    source: 'builtin',
+    readonly: true,
+    allowFileMutations: definition.allowFileMutations === true,
     createdAt: 'builtin',
     updatedAt: 'builtin',
   }
@@ -92,6 +97,9 @@ function normalizeProfileInput(input, existing = null, { creating = false } = {}
     maxToolCalls: normalizeOptionalPositiveInteger(input?.maxToolCalls ?? existing?.maxToolCalls, DEFAULT_MAX_TOOL_CALLS, 300),
     enabledAsSubagent: input?.enabledAsSubagent === undefined ? Boolean(existing?.enabledAsSubagent ?? true) : input.enabledAsSubagent === true,
     builtin: false,
+    source: 'store',
+    readonly: false,
+    allowFileMutations: allowedTools.some((toolName) => toolName === 'write_file' || toolName === 'edit_file'),
     createdAt: existing?.createdAt || now,
     updatedAt: now,
   }
@@ -102,20 +110,61 @@ async function readCustomAgentMap() {
   return data && typeof data === 'object' ? data : {}
 }
 
+async function resolveWorkspaceRoot(options = {}) {
+  if (options.workspaceRoot) return options.workspaceRoot
+  if (options.projectId) {
+    try {
+      return (await projectContextFromId(options.projectId))?.workspaceRoot || null
+    } catch {
+      return null
+    }
+  }
+  return defaultGlobalWorkspaceContext()?.workspaceRoot || null
+}
+
+function mergeProfiles({ builtin = [], file = [], custom = [] }) {
+  const reservedNames = new Set(builtin.map((profile) => profile.name))
+  const byName = new Map()
+
+  for (const profile of builtin) {
+    byName.set(profile.name, profile)
+  }
+  for (const profile of file) {
+    if (!profile?.name || reservedNames.has(profile.name)) continue
+    byName.set(profile.name, profile)
+  }
+  for (const profile of custom) {
+    if (!profile?.id) continue
+    if (!reservedNames.has(profile.name) && !byName.has(profile.name)) byName.set(profile.name, profile)
+  }
+
+  return [...byName.values()].sort((a, b) => {
+    if (a.builtin && !b.builtin) return -1
+    if (!a.builtin && b.builtin) return 1
+    return a.name.localeCompare(b.name)
+  })
+}
+
 export async function listAgentProfiles(options = {}) {
   const custom = Object.values(await readCustomAgentMap())
-  const profiles = [...listBuiltinAgentProfiles(), ...custom]
+  const workspaceRoot = await resolveWorkspaceRoot(options)
+  const file = await loadFileAgentProfiles(workspaceRoot, { reservedNames: RESERVED_NAMES })
+  const profiles = mergeProfiles({ builtin: listBuiltinAgentProfiles(), file, custom })
   return options.includeDisabled ? profiles : profiles.filter((profile) => profile.enabledAsSubagent || profile.builtin || profile.enabledAsSubagent === false)
 }
 
-export async function listSubagentProfiles() {
-  return (await listAgentProfiles({ includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
+export async function listSubagentProfiles(options = {}) {
+  return (await listAgentProfiles({ ...options, includeDisabled: true })).filter((profile) => profile.enabledAsSubagent)
 }
 
-export async function getAgentProfile(idOrName) {
+export async function getAgentProfile(idOrName, options = {}) {
   const key = String(idOrName || '').trim().toLowerCase()
   if (!key) return null
-  return (await listAgentProfiles({ includeDisabled: true })).find((profile) => profile.id === key || profile.name === key) || null
+  const profiles = await listAgentProfiles({ ...options, includeDisabled: true })
+  const byName = profiles.find((profile) => profile.name === key)
+  if (byName) return byName
+  const custom = Object.values(await readCustomAgentMap())
+  return custom.find((profile) => profile?.id === key) || profiles.find((profile) => profile.id === key) || null
 }
 
 export async function createCustomAgentProfile(input) {
@@ -167,7 +216,12 @@ export function agentProfileSnapshot(profile) {
     allowedTools: [...profile.allowedTools],
     maxRuntimeMs: profile.maxRuntimeMs,
     maxToolCalls: profile.maxToolCalls,
+    enabledAsSubagent: profile.enabledAsSubagent === true,
     builtin: profile.builtin === true,
+    source: profile.source || (profile.builtin ? 'builtin' : 'store'),
+    readonly: profile.readonly === true || profile.builtin === true,
+    filePath: profile.filePath,
+    relativePath: profile.relativePath,
   }
 }
 

package/server/auto-compaction.mjs

@@ -151,6 +151,76 @@ export function buildAutoCompactLoopMessages(session, messages) {
   return [summaryMessage, ...source.slice(compactedUpToIndex)]
 }
 
+export async function compactSessionInPlace({
+  session,
+  messages,
+  keepRecentTurns = DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns,
+  minSourceChars = DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars,
+  usage,
+  thresholdPercent,
+  emitSessionEvent,
+  persistSession,
+  reason = 'manual_compact',
+  summaryIntro = 'The previous conversation has been compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+  onBeforePersist,
+}) {
+  const source = Array.isArray(messages) ? messages : []
+  const normalizedKeepRecentTurns = clampNumber(keepRecentTurns, DEFAULT_AUTO_COMPACT_SETTINGS.keepRecentTurns, 1, 20)
+  const normalizedMinSourceChars = clampNumber(minSourceChars, DEFAULT_AUTO_COMPACT_SETTINGS.minSourceChars, 0, 200000)
+  const tailStart = tailStartForRecentTurns(source, normalizedKeepRecentTurns)
+  const sourceMessages = buildCompactionSourceMessages(session, source, tailStart)
+  if (sourceMessages.length < 2 || estimateMessagesChars(sourceMessages) < normalizedMinSourceChars) {
+    return { compacted: false, usage, reason: 'not_enough_history' }
+  }
+
+  const result = await compactConversation({
+    messages: sourceMessages,
+    model: session.model,
+    thinkingLevel: session.thinkingLevel,
+    getApiKey: session.getApiKey,
+    keepTurns: 0,
+  })
+
+  if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
+
+  await saveCompactBackup(session.sessionId, sourceMessages)
+  const summaryMessage = userTextMessage([
+    summaryIntro,
+    '',
+    '<compact_summary>',
+    result.summary,
+    '</compact_summary>',
+  ].join('\n'))
+  session.contextCompaction = {
+    summaryMessage,
+    compactedUpToIndex: tailStart,
+    compactedAt: new Date().toISOString(),
+    keepRecentTurns: normalizedKeepRecentTurns,
+    sourceMessageCount: source.length,
+    usageBefore: usage,
+    thresholdPercent,
+  }
+  onBeforePersist?.({ result, sourceMessages, tailStart, summaryMessage })
+  await persistSession?.(session)
+  const contextUsage = estimateSessionContextUsage(session, source)
+  emitSessionEvent?.(session, {
+    type: 'auto_compact_completed',
+    reason,
+    usage,
+    thresholdPercent,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  emitSessionEvent?.(session, {
+    type: 'messages_replaced',
+    reason,
+    messages: source,
+    contextCompaction: session.contextCompaction,
+    contextUsage,
+  })
+  return { compacted: true, usage, result, sourceMessages, tailStart }
+}
+
 export function estimateSessionContextUsage(session, messages = session?.agent?.state?.messages ?? []) {
   if (!session?.agent?.state) return null
   const sourceMessages = Array.isArray(messages) ? messages : []
@@ -274,50 +344,23 @@ export async function maybeAutoCompactSession({ session, messages, signal, emitS
 
   session.autoCompacting = true
   try {
-    const result = await compactConversation({
-      messages: sourceMessages,
-      model: session.model,
-      thinkingLevel: session.thinkingLevel,
-      getApiKey: session.getApiKey,
-      keepTurns: 0,
-    })
-
-    if (result.skipped) return { compacted: false, usage, reason: result.reason || 'skipped' }
-
-    await saveCompactBackup(session.sessionId, sourceMessages)
-    const summaryMessage = userTextMessage([
-      'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
-      '',
-      '<compact_summary>',
-      result.summary,
-      '</compact_summary>',
-    ].join('\n'))
-    session.contextCompaction = {
-      summaryMessage,
-      compactedUpToIndex: tailStart,
-      compactedAt: new Date().toISOString(),
+    const result = await compactSessionInPlace({
+      session,
+      messages,
       keepRecentTurns: settings.keepRecentTurns,
-      sourceMessageCount: messages.length,
-      usageBefore: usage,
-      thresholdPercent: settings.thresholdPercent,
-    }
-    clearAutoCompactRejected(session)
-    session.lastAutoCompactAt = now
-    await persistSession(session)
-    emitSessionEvent(session, {
-      type: 'auto_compact_completed',
+      minSourceChars: settings.minSourceChars,
       usage,
       thresholdPercent: settings.thresholdPercent,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
-    })
-    emitSessionEvent(session, {
-      type: 'messages_replaced',
+      emitSessionEvent,
+      persistSession,
       reason: 'auto_compact',
-      messages,
-      contextCompaction: session.contextCompaction,
-      contextUsage: estimateSessionContextUsage(session, messages),
+      summaryIntro: 'The previous conversation has been automatically compacted. Treat the following summary as the authoritative replacement for earlier history. If information is missing, ask for clarification instead of guessing.',
+      onBeforePersist: () => {
+        clearAutoCompactRejected(session)
+        session.lastAutoCompactAt = now
+      },
     })
+    if (!result.compacted) return result
     return { compacted: true, usage }
   } catch (error) {
     logger?.warn?.(`Auto compact failed for session ${session.sessionId}:`, error?.message || error, { sessionId: session.sessionId })

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
+  }
+}