@shawnstack/quickforge 1.7.1 → 1.7.3

package/server/network-proxy.mjs

@@ -0,0 +1,384 @@
+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'])
+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}`
+}
+
+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()
+  }
+}
+
+async function createNetworkDispatcher(config) {
+  if (config.mode === 'manual') return new ProxyAgent(config.proxyUrl)
+  if (config.mode === 'system') return new SystemProxyDispatcher(await getNativeResolver())
+  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 (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',
+        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, 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
+  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)
+
+  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/loader.mjs

@@ -1,3 +1,5 @@
+import { promises as fs } from 'node:fs'
+import { createHash } from 'node:crypto'
 import { pathToFileURL } from 'node:url'
 
 function isPlainObject(value) {
@@ -19,7 +21,9 @@ function contentToText(result) {
 
 export async function loadPlugin(manifest, context = {}) {
   const mainPath = new URL(manifest.main, pathToFileURL(`${manifest.dir}/`))
-  const moduleUrl = `${mainPath.href}?quickforgePluginReload=${Date.now()}`
+  const source = await fs.readFile(mainPath)
+  const reloadToken = createHash('sha256').update(source).digest('hex')
+  const moduleUrl = `${mainPath.href}?quickforgePluginReload=${reloadToken}`
   const module = await import(moduleUrl)
   const factory = module.createPlugin || module.default
   if (typeof factory !== 'function') {
@@ -41,6 +45,7 @@ export async function loadPlugin(manifest, context = {}) {
   }
 
   const tools = isPlainObject(plugin.tools) ? plugin.tools : {}
+  const dispose = typeof plugin.dispose === 'function' ? plugin.dispose.bind(plugin) : null
   return {
     async callTool(toolName, params = {}, toolContext = {}) {
       const handler = tools[toolName]
@@ -52,5 +57,8 @@ export async function loadPlugin(manifest, context = {}) {
         isError: Boolean(result?.isError),
       }
     },
+    async dispose() {
+      if (dispose) await dispose()
+    },
   }
 }

package/server/plugins/registry.mjs

@@ -18,6 +18,7 @@ const globalPluginDir = path.join(dataDir, 'plugins')
 const legacyGlobalPluginDir = path.join(os.homedir(), '.agents', 'plugins')
 let cachedCatalog = null
 let cachedCatalogKey = null
+let catalogDirty = false
 let refreshPromise = null
 
 function catalogKey(projectContext = null) {
@@ -96,7 +97,7 @@ async function discoverManifests(projectContext) {
   return { manifests, errors, roots }
 }
 
-async function loadEnabledPlugins(projectContext) {
+async function loadEnabledPlugins(projectContext, previousCatalog = null) {
   const store = await readPluginStore()
   const { manifests, errors, roots } = await discoverManifests(projectContext)
   const plugins = []
@@ -126,8 +127,16 @@ async function loadEnabledPlugins(projectContext) {
         handlers.set(manifest.name, loaded)
       } catch (error) {
         logger.error(`Failed to load plugin ${manifest.name}:`, error)
-        entry.status = 'error'
-        entry.error = error?.message || 'Failed to load plugin'
+        const previousPlugin = previousCatalog?.plugins?.find((plugin) => plugin.name === manifest.name)
+        const previousHandler = previousCatalog?.handlers?.get(manifest.name)
+        if (previousPlugin?.enabled && previousPlugin.status === 'loaded' && previousHandler) {
+          handlers.set(manifest.name, previousHandler)
+          entry.status = 'loaded'
+          entry.error = error?.message || 'Failed to reload plugin; using previous instance'
+        } else {
+          entry.status = 'error'
+          entry.error = error?.message || 'Failed to load plugin'
+        }
       }
     }
 
@@ -138,12 +147,27 @@ async function loadEnabledPlugins(projectContext) {
   return { plugins, handlers, errors, roots }
 }
 
+async function disposeHandlers(catalog, retainedHandlers = new Set()) {
+  if (!catalog?.handlers) return
+  await Promise.allSettled(Array.from(catalog.handlers.entries(), async ([name, handler]) => {
+    if (retainedHandlers.has(handler) || typeof handler?.dispose !== 'function') return
+    try {
+      await handler.dispose()
+    } catch (error) {
+      logger.warn(`Failed to dispose plugin ${name}:`, error)
+    }
+  }))
+}
+
 export async function refreshPlugins(projectContext = null) {
   const key = catalogKey(projectContext)
   if (!refreshPromise) {
-    refreshPromise = loadEnabledPlugins(projectContext).then((catalog) => {
+    const previousCatalog = cachedCatalogKey === key ? cachedCatalog : null
+    refreshPromise = loadEnabledPlugins(projectContext, previousCatalog).then(async (catalog) => {
       cachedCatalog = catalog
       cachedCatalogKey = key
+      catalogDirty = false
+      await disposeHandlers(previousCatalog, new Set(catalog.handlers.values()))
       return catalog
     }).finally(() => {
       refreshPromise = null
@@ -154,7 +178,7 @@ export async function refreshPlugins(projectContext = null) {
 
 async function getCatalog(projectContext = null) {
   const key = catalogKey(projectContext)
-  if (!cachedCatalog || cachedCatalogKey !== key) return refreshPlugins(projectContext)
+  if (!cachedCatalog || cachedCatalogKey !== key || catalogDirty) return refreshPlugins(projectContext)
   return cachedCatalog
 }
 
@@ -183,7 +207,7 @@ export async function getEnabledPluginCommandSources(projectContext = null) {
 }
 
 export async function getPluginStatus(projectContext = null) {
-  const catalog = await refreshPlugins(projectContext)
+  const catalog = await getCatalog(projectContext)
   return {
     searchPaths: catalog.roots,
     errors: catalog.errors,
@@ -221,8 +245,7 @@ export async function setPluginEnabled(name, enabled) {
     next.enabled[name] = enabled === true
     return next
   })
-  cachedCatalog = null
-  cachedCatalogKey = null
+  catalogDirty = true
 }
 
 export async function setPluginConfig(name, config) {
@@ -231,8 +254,7 @@ export async function setPluginConfig(name, config) {
     next.config[name] = isPlainObject(config) ? config : {}
     return next
   })
-  cachedCatalog = null
-  cachedCatalogKey = null
+  catalogDirty = true
 }
 
 export async function createPluginToolDefinitions(projectContext = null) {

package/server/public-api.mjs

@@ -140,6 +140,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)

package/server/routes/agent-profiles.mjs

@@ -1,4 +1,5 @@
 import { streamSimple } from '@earendil-works/pi-ai/compat'
+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'
@@ -101,6 +102,7 @@ Rules:
         maxTokens: 1600,
         temperature: 0,
         reasoning: thinkingLevel === 'off' ? undefined : thinkingLevel,
+        maxRetries: DEFAULT_AI_MAX_RETRIES,
         maxRetryDelayMs: 60000,
       },
     )

package/server/routes/mcp.mjs

@@ -49,11 +49,6 @@ export async function handleMcpApi(req, res, url) {
     return
   }
 
-  if (req.method === 'POST' && url.pathname === '/api/mcp/reconnect') {
-    sendJson(res, 200, await refreshMcpAndAgentTools())
-    return
-  }
-
   if (req.method === 'POST' && parts[0] === 'api' && parts[1] === 'mcp' && parts[2] === 'reconnect' && parts[3]) {
     await reconnectMcpServer(decodeURIComponent(parts[3]))
     sendJson(res, 200, await refreshMcpAndAgentTools())

package/server/routes/models.mjs

@@ -35,6 +35,7 @@ async function probeModelConnection(model, apiKeyOverride) {
       temperature: 0,
       // Keep reasoning off so thinking-capable models don't require extra tokens.
       reasoning: undefined,
+      maxRetries: 0,
       maxRetryDelayMs: 30000,
     },
   )