@shawnstack/quickforge 1.7.2 → 1.7.4

package/server/network-proxy.mjs

@@ -0,0 +1,449 @@
+import tls from 'node:tls'
+import { Agent, DecoratorHandler, Dispatcher, ProxyAgent } from 'undici'
+import { SocksClient } from 'socks'
+import { atomicUpdate, readStore } from './storage.mjs'
+
+const SETTINGS_KEY = 'network-proxy'
+const VALID_MODES = new Set(['direct', 'system', 'manual', 'pac'])
+const PROXY_ENV_KEYS = [
+  'HTTP_PROXY', 'HTTPS_PROXY', 'ALL_PROXY', 'NO_PROXY',
+  'http_proxy', 'https_proxy', 'all_proxy', 'no_proxy',
+]
+const ORIGINAL_FETCH = globalThis.fetch.bind(globalThis)
+const FETCH_PATCH_MARKER = Symbol.for('quickforge.networkProxy.fetchPatched')
+
+let currentConfig = { mode: 'direct', proxyUrl: '' }
+let hostRuntime = null
+let nativeResolver = null
+let nativeResolverError = null
+let networkDispatcher = null
+let initialized = false
+let lastAppliedAt = null
+
+export function normalizeNetworkProxyConfig(value) {
+  const mode = VALID_MODES.has(value?.mode) ? value.mode : 'direct'
+  const proxyUrl = typeof value?.proxyUrl === 'string' ? value.proxyUrl.trim() : ''
+  return { mode, proxyUrl }
+}
+
+export function validateManualProxyUrl(value) {
+  let url
+  try {
+    url = new URL(String(value || '').trim())
+  } catch {
+    const error = new Error('Proxy address must be a valid HTTP or HTTPS URL')
+    error.statusCode = 400
+    throw error
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    const error = new Error('Only HTTP and HTTPS proxy addresses are supported')
+    error.statusCode = 400
+    throw error
+  }
+  if (!url.hostname || !url.port) {
+    const error = new Error('Proxy address must include a host and port')
+    error.statusCode = 400
+    throw error
+  }
+  if (url.username || url.password) {
+    const error = new Error('Proxy credentials are not supported in the proxy address')
+    error.statusCode = 400
+    throw error
+  }
+  if ((url.pathname && url.pathname !== '/') || url.search || url.hash) {
+    const error = new Error('Proxy address cannot include a path, query, or fragment')
+    error.statusCode = 400
+    throw error
+  }
+
+  return `${url.protocol}//${url.host}`
+}
+
+export function validatePacUrl(value) {
+  let url
+  try {
+    url = new URL(String(value || '').trim())
+  } catch {
+    const error = new Error('PAC URL must be a valid HTTP or HTTPS URL')
+    error.statusCode = 400
+    throw error
+  }
+
+  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+    const error = new Error('Only HTTP and HTTPS PAC URLs are supported')
+    error.statusCode = 400
+    throw error
+  }
+  if (!url.hostname) {
+    const error = new Error('PAC URL must include a host')
+    error.statusCode = 400
+    throw error
+  }
+  if (url.username || url.password) {
+    const error = new Error('Credentials are not supported in the PAC URL')
+    error.statusCode = 400
+    throw error
+  }
+  if (url.hash) {
+    const error = new Error('PAC URL cannot include a fragment')
+    error.statusCode = 400
+    throw error
+  }
+
+  return url.href
+}
+
+function isLoopbackUrl(input) {
+  let url
+  try {
+    if (typeof Request !== 'undefined' && input instanceof Request) url = new URL(input.url)
+    else url = new URL(input instanceof URL ? input.href : String(input))
+  } catch {
+    return false
+  }
+  return ['localhost', '127.0.0.1', '::1', '::ffff:127.0.0.1'].includes(url.hostname)
+}
+
+function withoutProxyEnvironment(callback) {
+  const previous = new Map()
+  for (const key of PROXY_ENV_KEYS) {
+    previous.set(key, process.env[key])
+    delete process.env[key]
+  }
+  try {
+    return callback()
+  } finally {
+    for (const [key, value] of previous) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+  }
+}
+
+async function getNativeResolver() {
+  if (nativeResolver) return nativeResolver
+  if (nativeResolverError) throw nativeResolverError
+
+  try {
+    const { ProxyResolver } = await import('@vscode/os-proxy-resolver')
+    nativeResolver = withoutProxyEnvironment(() => new ProxyResolver())
+    return nativeResolver
+  } catch (error) {
+    nativeResolverError = error instanceof Error ? error : new Error(String(error))
+    throw nativeResolverError
+  }
+}
+
+function parseProxyHost(value) {
+  const raw = String(value || '').trim()
+  const url = new URL(raw.includes('://') ? raw : `http://${raw}`)
+  return {
+    host: url.hostname,
+    port: Number(url.port || (url.protocol === 'https:' ? 443 : 80)),
+    secure: url.protocol === 'https:',
+  }
+}
+
+function createSocksConnector(proxyHost) {
+  const proxy = parseProxyHost(proxyHost)
+  return (options, callback) => {
+    const destinationHost = options.hostname || options.host
+    const destinationPort = Number(options.port || (options.protocol === 'https:' ? 443 : 80))
+    let settled = false
+
+    const complete = (error, socket) => {
+      if (settled) return
+      settled = true
+      callback(error, socket)
+    }
+
+    SocksClient.createConnection({
+      proxy: {
+        host: proxy.host,
+        port: proxy.port,
+        type: 5,
+      },
+      command: 'connect',
+      destination: {
+        host: destinationHost,
+        port: destinationPort,
+      },
+      timeout: Number(options.timeout || 10000),
+    }).then(({ socket }) => {
+      if (options.protocol !== 'https:') {
+        complete(null, socket)
+        return
+      }
+      const secureSocket = tls.connect({
+        socket,
+        servername: options.servername || destinationHost,
+        ALPNProtocols: ['http/1.1'],
+      })
+      secureSocket.once('secureConnect', () => complete(null, secureSocket))
+      secureSocket.once('error', (error) => complete(error))
+    }).catch((error) => complete(error))
+
+    return () => {
+      settled = true
+    }
+  }
+}
+
+class RetryHandler extends DecoratorHandler {
+  constructor(dispatcher, options, handler, retry) {
+    super(handler)
+    this.dispatcher = dispatcher
+    this.options = options
+    this.retry = retry
+    this.receivedResponse = false
+  }
+
+  onResponseStart(controller, statusCode, headers, statusMessage) {
+    this.receivedResponse = true
+    return super.onResponseStart(controller, statusCode, headers, statusMessage)
+  }
+
+  onResponseError(controller, error) {
+    if (!this.receivedResponse) {
+      void this.retry(error)
+      return
+    }
+    return super.onResponseError(controller, error)
+  }
+}
+
+class SystemProxyDispatcher extends Dispatcher {
+  constructor(resolver) {
+    super()
+    this.resolver = resolver
+    this.directAgent = new Agent()
+    this.dispatchers = new Map()
+  }
+
+  dispatcherFor(route) {
+    if (!route || route.kind === 'direct') return this.directAgent
+    const key = `${route.kind}:${route.host}`
+    if (this.dispatchers.has(key)) return this.dispatchers.get(key)
+
+    let dispatcher
+    if (route.kind === 'http') {
+      const proxy = parseProxyHost(route.host)
+      dispatcher = new ProxyAgent({ uri: `${proxy.secure ? 'https' : 'http'}://${proxy.host}:${proxy.port}` })
+    } else if (route.kind === 'socks') {
+      dispatcher = new Agent({ connect: createSocksConnector(route.host) })
+    } else {
+      dispatcher = this.directAgent
+    }
+    this.dispatchers.set(key, dispatcher)
+    return dispatcher
+  }
+
+  dispatch(options, handler) {
+    const url = `${options.origin}${options.path}`
+    let routes = []
+    let index = 0
+
+    const tryNext = async (lastError) => {
+      if (index >= routes.length) {
+        handler.onResponseError?.(null, lastError || new Error('No usable system proxy route'))
+        return
+      }
+      const route = routes[index]
+      index += 1
+      const dispatcher = this.dispatcherFor(route)
+      const retryHandler = new RetryHandler(dispatcher, options, handler, async (error) => {
+        if (route?.kind !== 'direct') this.resolver.reportProxyFailed(route)
+        await tryNext(error)
+      })
+      try {
+        dispatcher.dispatch(options, retryHandler)
+      } catch (error) {
+        if (route?.kind !== 'direct') this.resolver.reportProxyFailed(route)
+        await tryNext(error)
+      }
+    }
+
+    void this.resolver.resolve(url).then((resolvedRoutes) => {
+      routes = Array.isArray(resolvedRoutes) && resolvedRoutes.length ? resolvedRoutes : [{ kind: 'direct' }]
+      return tryNext()
+    }).catch((error) => handler.onResponseError?.(null, error))
+
+    return true
+  }
+
+  async close() {
+    const dispatchers = [this.directAgent, ...this.dispatchers.values()]
+    await Promise.allSettled(dispatchers.map((dispatcher) => dispatcher.close()))
+    this.dispatchers.clear()
+  }
+
+  async destroy(error) {
+    const dispatchers = [this.directAgent, ...this.dispatchers.values()]
+    await Promise.allSettled(dispatchers.map((dispatcher) => dispatcher.destroy(error)))
+    this.dispatchers.clear()
+  }
+}
+
+class UnsupportedProxyDispatcher extends Dispatcher {
+  constructor(message) {
+    super()
+    this.error = new Error(message)
+    this.error.code = 'QUICKFORGE_PROXY_UNSUPPORTED'
+  }
+
+  dispatch(_options, handler) {
+    queueMicrotask(() => handler.onResponseError?.(null, this.error))
+    return true
+  }
+
+  async close() {}
+
+  async destroy() {}
+}
+
+async function createNetworkDispatcher(config) {
+  if (config.mode === 'manual') return new ProxyAgent(config.proxyUrl)
+  if (config.mode === 'system') return new SystemProxyDispatcher(await getNativeResolver())
+  if (config.mode === 'pac') return new UnsupportedProxyDispatcher('Custom PAC URLs are not supported by this runtime')
+  return new Agent()
+}
+
+async function replaceNetworkDispatcher(config) {
+  const previous = networkDispatcher
+  networkDispatcher = await createNetworkDispatcher(config)
+  if (previous) void previous.close().catch(() => {})
+}
+
+function installNetworkFetch() {
+  if (globalThis[FETCH_PATCH_MARKER]) return
+  globalThis.fetch = async (input, init = {}) => {
+    if (isLoopbackUrl(input)) return ORIGINAL_FETCH(input, init)
+    if (hostRuntime) {
+      if (currentConfig.mode === 'direct') return ORIGINAL_FETCH(input, init)
+      return hostRuntime.fetch(input, init)
+    }
+    if (!networkDispatcher) return ORIGINAL_FETCH(input, init)
+    return ORIGINAL_FETCH(input, { ...init, dispatcher: networkDispatcher })
+  }
+  globalThis[FETCH_PATCH_MARKER] = true
+}
+
+export function registerHostNetworkRuntime(runtime) {
+  hostRuntime = runtime || null
+}
+
+async function persistConfig(config) {
+  await atomicUpdate('settings', (settings) => ({
+    ...settings,
+    [SETTINGS_KEY]: config,
+  }))
+}
+
+async function applyConfig(config) {
+  const normalized = normalizeNetworkProxyConfig(config)
+  if (normalized.mode === 'manual') normalized.proxyUrl = validateManualProxyUrl(normalized.proxyUrl)
+  if (normalized.mode === 'pac') normalized.proxyUrl = validatePacUrl(normalized.proxyUrl)
+
+  if (hostRuntime) await hostRuntime.apply(normalized)
+  else await replaceNetworkDispatcher(normalized)
+
+  currentConfig = normalized
+  lastAppliedAt = new Date().toISOString()
+  return currentConfig
+}
+
+async function nativeStatus() {
+  try {
+    const resolver = await getNativeResolver()
+    const config = await resolver.readProxyConfig()
+    const source = config.platform?.kind || process.platform
+    return {
+      supported: true,
+      source,
+      features: {
+        pac: config.configuredPac?.state !== 'unsupported',
+        pacUrl: false,
+        wpad: config.wpadDns?.state !== 'unsupported' || config.wpadDhcp?.state !== 'unsupported',
+        httpProxy: true,
+        httpsProxy: true,
+        socks: true,
+      },
+    }
+  } catch (error) {
+    return {
+      supported: false,
+      source: 'none',
+      features: { pac: false, pacUrl: false, wpad: false, httpProxy: false, httpsProxy: false, socks: false },
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+export async function getNetworkProxyStatus() {
+  const runtimeStatus = hostRuntime
+    ? await hostRuntime.getStatus()
+    : await nativeStatus()
+  const configuredMode = currentConfig.mode
+  const modeSupported = configuredMode === 'system'
+    ? runtimeStatus.supported
+    : configuredMode !== 'pac' || runtimeStatus.features?.pacUrl === true
+  return {
+    configuredMode,
+    effectiveMode: modeSupported ? configuredMode : 'unsupported',
+    proxyUrl: currentConfig.proxyUrl,
+    runtimeKind: hostRuntime ? 'electron-inline' : (process.versions.electron ? 'electron-node' : 'node'),
+    lastAppliedAt,
+    ...runtimeStatus,
+  }
+}
+
+export async function initializeNetworkProxy() {
+  if (initialized) return { config: currentConfig, status: await getNetworkProxyStatus() }
+  installNetworkFetch()
+  const settings = await readStore('settings')
+  await applyConfig(settings?.[SETTINGS_KEY])
+  initialized = true
+  return { config: currentConfig, status: await getNetworkProxyStatus() }
+}
+
+export async function getNetworkProxyConfig() {
+  if (!initialized) await initializeNetworkProxy()
+  return { config: currentConfig, status: await getNetworkProxyStatus() }
+}
+
+export async function updateNetworkProxyConfig(value) {
+  if (!initialized) await initializeNetworkProxy()
+  const previous = currentConfig
+  const next = normalizeNetworkProxyConfig(value)
+  if (next.mode === 'manual') next.proxyUrl = validateManualProxyUrl(next.proxyUrl)
+  if (next.mode === 'pac') {
+    next.proxyUrl = validatePacUrl(next.proxyUrl)
+    const runtimeStatus = hostRuntime ? await hostRuntime.getStatus() : await nativeStatus()
+    if (runtimeStatus.features?.pacUrl !== true) {
+      const error = new Error('Custom PAC URLs are not supported by this runtime')
+      error.statusCode = 400
+      throw error
+    }
+  }
+
+  await applyConfig(next)
+  try {
+    await persistConfig(currentConfig)
+  } catch (error) {
+    await applyConfig(previous)
+    throw error
+  }
+  return { config: currentConfig, status: await getNetworkProxyStatus() }
+}
+
+export async function refreshSystemProxy() {
+  if (!initialized) await initializeNetworkProxy()
+  nativeResolver?.close?.()
+  nativeResolver = null
+  nativeResolverError = null
+  if (hostRuntime) await hostRuntime.refresh()
+  else await replaceNetworkDispatcher(currentConfig)
+  lastAppliedAt = new Date().toISOString()
+  return { config: currentConfig, status: await getNetworkProxyStatus() }
+}

package/server/plugins/registry.mjs

@@ -16,6 +16,7 @@ const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const bundledPluginDir = path.resolve(__dirname, '..', '..', 'plugins')
 const globalPluginDir = path.join(dataDir, 'plugins')
 const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
+export const DEFAULT_PLUGIN_TOOL_TIMEOUT_MS = 2 * 60 * 1000
 let cachedCatalog = null
 let cachedCatalogKey = null
 let catalogDirty = false
@@ -29,6 +30,56 @@ function isPlainObject(value) {
   return Boolean(value && typeof value === 'object' && !Array.isArray(value))
 }
 
+function withTimeout(promise, timeoutMs, message, onTimeout, signal) {
+  let timer
+  let timedOut = false
+  let abortHandler
+  const guardedPromise = promise.catch((error) => {
+    if (timedOut) return new Promise(() => {})
+    throw error
+  })
+  const timeoutPromise = new Promise((_, reject) => {
+    const rejectForAbort = () => {
+      timedOut = true
+      reject(new Error('Plugin tool call aborted'))
+    }
+    if (signal?.aborted) {
+      rejectForAbort()
+      return
+    }
+    if (signal) {
+      abortHandler = rejectForAbort
+      signal.addEventListener('abort', abortHandler, { once: true })
+    }
+    timer = setTimeout(() => {
+      timedOut = true
+      try {
+        onTimeout?.()
+      } finally {
+        reject(new Error(message))
+      }
+    }, timeoutMs)
+  })
+  return Promise.race([guardedPromise, timeoutPromise]).finally(() => {
+    clearTimeout(timer)
+    if (abortHandler) signal?.removeEventListener('abort', abortHandler)
+  })
+}
+
+function combineAbortSignals(parentSignal, timeoutSignal) {
+  if (!parentSignal) return timeoutSignal
+  if (typeof AbortSignal.any === 'function') return AbortSignal.any([parentSignal, timeoutSignal])
+
+  const controller = new AbortController()
+  const abort = () => controller.abort()
+  if (parentSignal.aborted || timeoutSignal.aborted) controller.abort()
+  else {
+    parentSignal.addEventListener('abort', abort, { once: true })
+    timeoutSignal.addEventListener('abort', abort, { once: true })
+  }
+  return controller.signal
+}
+
 async function exists(filePath) {
   try {
     await fs.access(filePath)
@@ -308,10 +359,19 @@ export async function callPluginTool(toolName, params = {}, toolContext = {}) {
     throw error
   }
 
-  const result = await handler.callTool(tool.name, params, {
-    ...toolContext,
-    plugin: { name: plugin.name, dir: plugin.dir, config: plugin.config },
-  })
+  const timeoutController = new AbortController()
+  const signal = combineAbortSignals(toolContext.signal, timeoutController.signal)
+  const result = await withTimeout(
+    Promise.resolve().then(() => handler.callTool(tool.name, params, {
+      ...toolContext,
+      signal,
+      plugin: { name: plugin.name, dir: plugin.dir, config: plugin.config },
+    })),
+    DEFAULT_PLUGIN_TOOL_TIMEOUT_MS,
+    `Plugin tool ${toolName} timed out after ${DEFAULT_PLUGIN_TOOL_TIMEOUT_MS}ms`,
+    () => timeoutController.abort(),
+    toolContext.signal,
+  )
 
   return {
     isError: Boolean(result.isError),

package/server/public-api.mjs

@@ -1,6 +1,7 @@
 import { spawn } from 'node:child_process'
 import path from 'node:path'
 import { fileURLToPath, pathToFileURL } from 'node:url'
+import { createNodeProcessEnv } from './utils/process-env.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -83,13 +84,16 @@ function buildEnv(options = {}) {
   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'
+  delete env.ELECTRON_RUN_AS_NODE
+  delete env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
 
   return env
 }
 
 export function prepareQuickForgeEnv(options = {}) {
+  delete process.env.ELECTRON_RUN_AS_NODE
+  delete process.env.ATOM_SHELL_INTERNAL_RUN_AS_NODE
   Object.assign(process.env, buildEnv(options))
 }
 
@@ -140,6 +144,10 @@ async function waitForQuickForge(options = {}) {
 }
 
 export async function startQuickForge(options = {}) {
+  if (options.networkRuntime) {
+    const { registerHostNetworkRuntime } = await import('./network-proxy.mjs')
+    registerHostNetworkRuntime(options.networkRuntime)
+  }
   const existingHealth = options.reuseExisting === false ? null : await checkQuickForgeHealth(options)
   const url = getQuickForgeUrl(options)
   const healthUrl = getQuickForgeHealthUrl(options)
@@ -187,7 +195,7 @@ export async function startQuickForge(options = {}) {
     stdio: options.stdio || 'ignore',
     windowsHide: true,
     shell: false,
-    env: buildEnv(options),
+    env: createNodeProcessEnv(buildEnv(options)),
   })
 
   let exitInfo = null

package/server/routes/agent-profiles.mjs

@@ -1,4 +1,5 @@
-import { streamSimple } from '@earendil-works/pi-ai/compat'
+import { streamSimpleWithAiHttpLogging } from '../ai-http-logger.mjs'
+import { DEFAULT_AI_MAX_RETRIES } from '../ai-provider-options.mjs'
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
 import { readStore } from '../storage.mjs'
 import { logger } from '../utils/logger.mjs'
@@ -89,7 +90,7 @@ Rules:
 - If the user requests Chinese, write label, description, and systemPrompt in Chinese; otherwise match the user's language.`
 
   try {
-    const stream = streamSimple(
+    const stream = streamSimpleWithAiHttpLogging(
       model,
       {
         systemPrompt,
@@ -101,6 +102,7 @@ Rules:
         maxTokens: 1600,
         temperature: 0,
         reasoning: thinkingLevel === 'off' ? undefined : thinkingLevel,
+        maxRetries: DEFAULT_AI_MAX_RETRIES,
         maxRetryDelayMs: 60000,
       },
     )

package/server/routes/agent.mjs

@@ -1,4 +1,5 @@
 import { sendJson, readJsonBody, decodeSegment } from '../utils/response.mjs'
+import { logger } from '../utils/logger.mjs'
 import {
   createAgent,
   runPrompt,
@@ -96,6 +97,30 @@ export async function handleAgentApi(req, res, url) {
     return
   }
 
+  // POST /api/agents/:sessionId/restore — restore once and return the authoritative state
+  if (req.method === 'POST' && subPath === 'restore') {
+    const startedAt = performance.now()
+    const session = await restoreAgent(sessionId)
+    if (!session) {
+      const error = new Error('Session not found')
+      error.statusCode = 404
+      throw error
+    }
+    const state = getSessionState(sessionId)
+    if (!state) {
+      const error = new Error('Session not found')
+      error.statusCode = 404
+      throw error
+    }
+    logger.debug(`Restored session ${sessionId} for client`, {
+      sessionId,
+      messageCount: state.messages?.length ?? 0,
+      durationMs: Math.round((performance.now() - startedAt) * 10) / 10,
+    })
+    sendJson(res, 200, state)
+    return
+  }
+
   // GET /api/agents/:sessionId/state — get session state
   if (req.method === 'GET' && subPath === 'state') {
     let state = getSessionState(sessionId)
@@ -141,6 +166,9 @@ export async function handleAgentApi(req, res, url) {
       status: session.status,
       scope: session.scope,
       title: session.title,
+      source: session.source || undefined,
+      channelId: session.channelId || undefined,
+      channelName: session.channelName || undefined,
       accessMode: session.accessMode,
       yoloMode: session.yoloMode,
     })