@shawnstack/quickforge 1.7.3 → 1.7.4

package/server/channels/providers/wechat.mjs

@@ -4,6 +4,7 @@ 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'
+import { createNodeProcessEnv } from '../../utils/process-env.mjs'
 
 const WEIXIN_ACP_PACKAGE = 'weixin-acp'
 const MIN_NODE_MAJOR = 22
@@ -134,7 +135,7 @@ function runCommand(command, args, options = {}) {
 }
 
 export class WechatChannelProvider extends ProcessChannelProvider {
-  constructor({ projectRoot }) {
+  constructor({ projectRoot, channelEventsUrl, logsDir }) {
     super({
       id: 'wechat',
       name: '微信',
@@ -149,8 +150,9 @@ export class WechatChannelProvider extends ProcessChannelProvider {
         { id: 'relogin', label: '重新登录' },
       ],
       requirements: [`Node.js >= ${MIN_NODE_MAJOR}`, 'npm/npx 可用', '首次启动需要微信扫码登录'],
-    })
+    }, { logsDir })
     this.projectRoot = projectRoot
+    this.channelEventsUrl = channelEventsUrl
     this.launchWorkspace = null
   }
 
@@ -179,7 +181,11 @@ export class WechatChannelProvider extends ProcessChannelProvider {
       command: npxCommand(),
       args: ['-y', WEIXIN_ACP_PACKAGE, 'start', '--', acpCommand, ...acpArgs],
       cwd: this.launchWorkspace?.path || getDefaultWorkspaceRoot() || this.projectRoot,
-      env: process.env,
+      env: createNodeProcessEnv(process.env, {
+        QUICKFORGE_ACP_CHANNEL_ID: this.definition.id,
+        QUICKFORGE_ACP_CHANNEL_NAME: this.definition.name,
+        ...(this.channelEventsUrl ? { QUICKFORGE_CHANNEL_EVENTS_URL: this.channelEventsUrl } : {}),
+      }),
       shell: shouldUseShellForNpx(),
     }
   }

package/server/channels/registry.mjs

@@ -16,7 +16,11 @@ function attachProvider(provider) {
 export function initializeChannels(options = {}) {
   if (initialized) return
   initialized = true
-  attachProvider(createWechatChannelProvider({ projectRoot: options.projectRoot }))
+  attachProvider(createWechatChannelProvider({
+    projectRoot: options.projectRoot,
+    channelEventsUrl: options.channelEventsUrl,
+    logsDir: options.logsDir,
+  }))
 }
 
 function requireProvider(id) {

package/server/index.mjs

@@ -5,7 +5,7 @@ import path from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 import { sendJson, sendError } from './utils/response.mjs'
-import { openBrowser } from './utils/platform.mjs'
+import { openBrowser, openPathInFileManager } from './utils/platform.mjs'
 import { ensureStorage, dataDir, configDir, storageDir, cacheDir, logsDir } from './storage.mjs'
 import { getNetworkProxyConfig, initializeNetworkProxy, refreshSystemProxy, updateNetworkProxyConfig } from './network-proxy.mjs'
 import { setDefaultWorkspaceRoot, initializeActiveProject, readProjectConfig, getActiveProject, readTerminalShellSetting, updateTerminalShellSetting, readTerminalShellConfig, updateTerminalShellConfig } from './project-config.mjs'
@@ -44,6 +44,7 @@ import { shutdown as shutdownAgentManager, resetStaleTaskStatuses } from './agen
 import { initializeChannels, shutdownChannels } from './channels/registry.mjs'
 import { shutdownMcpConnections } from './mcp/registry.mjs'
 import { shutdownTerminalSessions } from './terminal/terminal-manager.mjs'
+import { createNodeProcessEnv } from './utils/process-env.mjs'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -71,10 +72,11 @@ function getRestartSupport() {
   return { supported: true, reason: null }
 }
 
-async function getSystemStatus() {
+async function getSystemStatus({ isLocalRequest = true } = {}) {
   const config = await readProjectConfig()
   const restartSupport = getRestartSupport()
   const packageInfo = await getPackageInfo(projectRoot)
+  const restartSupported = isLocalRequest && restartSupport.supported
   return {
     ok: true,
     mode: isDev ? 'development' : 'production',
@@ -83,8 +85,14 @@ async function getSystemStatus() {
     startedAt,
     version: packageInfo.version,
     package: packageInfo,
-    restartSupported: restartSupport.supported,
-    restartUnsupportedReason: restartSupport.reason,
+    isLocalRequest,
+    capabilities: {
+      restart: restartSupported,
+      openLocalApps: isLocalRequest,
+      terminal: isLocalRequest,
+    },
+    restartSupported,
+    restartUnsupportedReason: isLocalRequest ? restartSupport.reason : 'Restart is only allowed from this computer',
     dataDir,
     configDir,
     storageDir,
@@ -113,10 +121,9 @@ function spawnRestartSupervisor() {
       stdio: 'ignore',
       windowsHide: true,
       shell: false,
-      env: {
-        ...process.env,
+      env: createNodeProcessEnv(process.env, {
         QUICKFORGE_NO_OPEN: '1',
-      },
+      }),
     })
 
     child.once('error', reject)
@@ -206,10 +213,9 @@ function spawnUpdateSupervisor(update) {
       stdio: 'ignore',
       windowsHide: true,
       shell: false,
-      env: {
-        ...process.env,
+      env: createNodeProcessEnv(process.env, {
         QUICKFORGE_NO_OPEN: '1',
-      },
+      }),
     })
 
     child.once('error', reject)
@@ -277,7 +283,7 @@ async function updateQuickForge() {
 }
 
 // --- Route dispatching ---
-async function handleApi(req, res, url) {
+async function handleApi(req, res, url, requestContext = {}) {
   const pathname = url.pathname
   const parts = pathname.split('/').filter(Boolean)
 
@@ -297,22 +303,22 @@ async function handleApi(req, res, url) {
     return
   }
 
-  if (pathname === '/api/lan-access/status' || pathname === '/api/lan-access/settings' || pathname === '/api/lan-access/unlock' || pathname === '/api/lan-access/logout' || pathname === '/api/lan-access/revoke-all') {
+  if (pathname.startsWith('/api/lan-access/')) {
     await handleLanAccessApi(req, res, url, {
       port,
-      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
+      isLocalRequest: requestContext.isLocalRequest === true,
     })
     return
   }
 
   // Health check
   if (req.method === 'GET' && pathname === '/api/health') {
-    sendJson(res, 200, await getSystemStatus())
+    sendJson(res, 200, await getSystemStatus(requestContext))
     return
   }
 
   if (req.method === 'GET' && pathname === '/api/project/commands') {
-    await handleProjectApi(req, res, url)
+    await handleProjectApi(req, res, url, requestContext)
     return
   }
 
@@ -355,7 +361,9 @@ async function handleApi(req, res, url) {
   // Channels
   if (pathname === '/api/channels' || pathname.startsWith('/api/channels/')) {
     await handleChannelsApi(req, res, url, {
-      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
+      isLocalRequest: requestContext.isLocalRequest === true,
+      logsDir,
+      openPathInFileManager,
     })
     return
   }
@@ -368,13 +376,13 @@ async function handleApi(req, res, url) {
 
   // Project routes
   if (pathname === '/api/project' || pathname.startsWith('/api/project/')) {
-    await handleProjectApi(req, res, url)
+    await handleProjectApi(req, res, url, requestContext)
     return
   }
 
   // Project workspace inspector routes
   if (pathname === '/api/workspace/tree' || pathname === '/api/workspace/file' || pathname === '/api/workspace/resolve-path' || pathname === '/api/workspace/open-external' || pathname.startsWith('/api/workspace/preview/')) {
-    await handleWorkspaceApi(req, res, url)
+    await handleWorkspaceApi(req, res, url, requestContext)
     return
   }
 
@@ -422,13 +430,13 @@ async function handleApi(req, res, url) {
   // System routes
   if (pathname === '/api/system/status' || pathname === '/api/system/restart' || pathname === '/api/system/network' || pathname === '/api/system/network-proxy' || pathname === '/api/system/network-proxy/refresh' || pathname === '/api/system/terminal-shell' || pathname === '/api/system/about' || pathname === '/api/system/update/check' || pathname === '/api/system/update/desktop' || pathname === '/api/system/update') {
     await handleSystemApi(req, res, url, {
-      getSystemStatus,
+      getSystemStatus: () => getSystemStatus(requestContext),
       requestRestart,
       getPackageInfo: () => getPackageInfo(projectRoot),
       checkForUpdates: () => checkForUpdates(projectRoot),
       checkDesktopRelease: () => checkDesktopRelease(projectRoot),
       updateQuickForge,
-      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
+      isLocalRequest: requestContext.isLocalRequest === true,
       getTerminalShellSetting: readTerminalShellSetting,
       updateTerminalShellSetting,
       getTerminalShellConfig: readTerminalShellConfig,
@@ -446,7 +454,7 @@ async function handleApi(req, res, url) {
   // Terminal routes (local-only; real shell access)
   if (pathname === '/api/terminal/capabilities' || pathname === '/api/terminal/sessions' || pathname.startsWith('/api/terminal/sessions/')) {
     await handleTerminalApi(req, res, url, {
-      isLocalRequest: isLoopbackAddress(req.socket.remoteAddress),
+      isLocalRequest: requestContext.isLocalRequest === true,
     })
     return
   }
@@ -532,6 +540,7 @@ function isLanAccessBootstrapPath(pathname) {
 
 function isStaticAssetPath(pathname) {
   return pathname.startsWith('/assets/')
+    || pathname.startsWith('/downloads/')
     || pathname === '/favicon.svg'
     || pathname === '/vite.svg'
     || pathname === '/manifest.webmanifest'
@@ -610,7 +619,7 @@ const server = createServer(async (req, res) => {
     }
 
     if (url.pathname.startsWith('/api/')) {
-      await handleApi(req, res, url)
+      await handleApi(req, res, url, { isLocalRequest: !isRemoteRequest })
       return
     }
 
@@ -674,7 +683,11 @@ server.on('upgrade', (req, socket, head) => {
 await ensureStorage()
 await initializeNetworkProxy()
 installAiHttpLogger()
-initializeChannels({ projectRoot })
+initializeChannels({
+  projectRoot,
+  channelEventsUrl: `http://127.0.0.1:${port}/api/channels/events`,
+  logsDir,
+})
 await resetStaleTaskStatuses()
 await initializeActiveProject()
 setActiveWorkspaceRootForFilesystem(getWorkspaceRoot())

package/server/lan-access-store.mjs

@@ -80,13 +80,41 @@ async function writeLanAccessFile(config) {
   await fs.writeFile(LAN_ACCESS_FILE, `${JSON.stringify(normalizeConfig(config), null, 2)}\n`, 'utf8')
 }
 
+function normalizeText(value, maxLength) {
+  if (typeof value !== 'string') return undefined
+  const text = value.trim()
+  return text ? text.slice(0, maxLength) : undefined
+}
+
+function normalizeRemoteAddress(value) {
+  const address = normalizeText(value, 128)
+  return address?.startsWith('::ffff:') ? address.slice(7) : address
+}
+
+function tokenRecordId(tokenRecord) {
+  const id = normalizeText(tokenRecord?.id, 128)
+  return id || `legacy_${sha256Base64Url(tokenRecord?.tokenHash || '').slice(0, 24)}`
+}
+
+function publicTokenRecord(tokenRecord) {
+  return {
+    id: tokenRecordId(tokenRecord),
+    address: normalizeRemoteAddress(tokenRecord.remoteAddress),
+    userAgent: normalizeText(tokenRecord.userAgent, 300),
+    issuedAt: tokenRecord.issuedAt,
+    expiresAt: tokenRecord.expiresAt,
+  }
+}
+
 function publicStatus(config) {
+  const activeTokens = pruneTokens(config.tokens)
   return {
     enabled: Boolean(config.enabled),
     hasPassword: Boolean(config.passwordHash),
     sessionTtlHours: config.sessionTtlHours,
     authVersion: config.authVersion || 1,
-    activeTokenCount: pruneTokens(config.tokens).length,
+    activeTokenCount: activeTokens.length,
+    activeDevices: activeTokens.map(publicTokenRecord),
     updatedAt: config.updatedAt,
   }
 }
@@ -98,6 +126,12 @@ function pruneTokens(tokens, now = Date.now()) {
       if (!tokenRecord.expiresAt) return true
       return Date.parse(tokenRecord.expiresAt) > now
     })
+    .map((tokenRecord) => ({
+      ...tokenRecord,
+      id: tokenRecordId(tokenRecord),
+      remoteAddress: normalizeRemoteAddress(tokenRecord.remoteAddress),
+      userAgent: normalizeText(tokenRecord.userAgent, 300),
+    }))
     .slice(-LAN_TOKEN_MAX_COUNT)
 }
 
@@ -162,11 +196,58 @@ export async function revokeLanAccessTokens() {
   })
 }
 
+export async function revokeLanAccessTokenById(id) {
+  const normalizedId = normalizeText(id, 128)
+  if (!normalizedId) {
+    const error = new Error('LAN access session id is required.')
+    error.statusCode = 400
+    throw error
+  }
+  return enqueueWrite(writeQueueName, async () => {
+    const current = await readLanAccessFile()
+    const tokens = pruneTokens(current.tokens)
+    const nextTokens = tokens.filter((tokenRecord) => tokenRecordId(tokenRecord) !== normalizedId)
+    if (nextTokens.length === tokens.length) {
+      const error = new Error('LAN access session not found.')
+      error.statusCode = 404
+      throw error
+    }
+    const next = normalizeConfig({
+      ...current,
+      tokens: nextTokens,
+      updatedAt: new Date().toISOString(),
+    })
+    await writeLanAccessFile(next)
+    return publicStatus(next)
+  })
+}
+
+export async function revokeLanAccessToken(token) {
+  if (!token || typeof token !== 'string') return false
+  const [versionText, secret] = token.split('.')
+  if (!secret) return false
+  const actualHash = sha256Base64Url(secret)
+  return enqueueWrite(writeQueueName, async () => {
+    const current = await readLanAccessFile()
+    if (Number(versionText) !== (current.authVersion || 1)) return false
+    const tokens = pruneTokens(current.tokens)
+    const nextTokens = tokens.filter((tokenRecord) => !safeHashEqual(tokenRecord.tokenHash, actualHash))
+    if (nextTokens.length === tokens.length) return false
+    const next = normalizeConfig({
+      ...current,
+      tokens: nextTokens,
+      updatedAt: new Date().toISOString(),
+    })
+    await writeLanAccessFile(next)
+    return true
+  })
+}
+
 export function lanAccessCookieName() {
   return 'qf_lan_access'
 }
 
-export async function issueLanAccessToken(password) {
+export async function issueLanAccessToken(password, metadata = {}) {
   return enqueueWrite(writeQueueName, async () => {
     const current = await readLanAccessFile()
     if (!current.enabled || !current.passwordHash) {
@@ -185,11 +266,20 @@ export async function issueLanAccessToken(password) {
     const issuedAt = new Date().toISOString()
     const ttlMs = normalizeSessionTtlHours(current.sessionTtlHours) * 60 * 60 * 1000
     const expiresAt = new Date(Date.now() + ttlMs).toISOString()
+    const tokenRecord = {
+      id: createRandomToken(18),
+      tokenHash,
+      issuedAt,
+      expiresAt,
+      authVersion: current.authVersion || 1,
+      remoteAddress: normalizeRemoteAddress(metadata.remoteAddress),
+      userAgent: normalizeText(metadata.userAgent, 300),
+    }
     const next = normalizeConfig({
       ...current,
       tokens: [
         ...pruneTokens(current.tokens),
-        { tokenHash, issuedAt, expiresAt, authVersion: current.authVersion || 1 },
+        tokenRecord,
       ].slice(-LAN_TOKEN_MAX_COUNT),
       updatedAt: issuedAt,
     })

package/server/network-proxy.mjs

@@ -4,7 +4,7 @@ import { SocksClient } from 'socks'
 import { atomicUpdate, readStore } from './storage.mjs'
 
 const SETTINGS_KEY = 'network-proxy'
-const VALID_MODES = new Set(['direct', 'system', 'manual'])
+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',
@@ -60,6 +60,40 @@ export function validateManualProxyUrl(value) {
   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 {
@@ -251,9 +285,27 @@ class SystemProxyDispatcher extends Dispatcher {
   }
 }
 
+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()
 }
 
@@ -291,6 +343,7 @@ async function persistConfig(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)
@@ -310,6 +363,7 @@ async function nativeStatus() {
       source,
       features: {
         pac: config.configuredPac?.state !== 'unsupported',
+        pacUrl: false,
         wpad: config.wpadDns?.state !== 'unsupported' || config.wpadDhcp?.state !== 'unsupported',
         httpProxy: true,
         httpsProxy: true,
@@ -320,7 +374,7 @@ async function nativeStatus() {
     return {
       supported: false,
       source: 'none',
-      features: { pac: false, wpad: false, httpProxy: false, httpsProxy: false, socks: false },
+      features: { pac: false, pacUrl: false, wpad: false, httpProxy: false, httpsProxy: false, socks: false },
       error: error instanceof Error ? error.message : String(error),
     }
   }
@@ -331,7 +385,9 @@ export async function getNetworkProxyStatus() {
     ? await hostRuntime.getStatus()
     : await nativeStatus()
   const configuredMode = currentConfig.mode
-  const modeSupported = configuredMode !== 'system' || runtimeStatus.supported
+  const modeSupported = configuredMode === 'system'
+    ? runtimeStatus.supported
+    : configuredMode !== 'pac' || runtimeStatus.features?.pacUrl === true
   return {
     configuredMode,
     effectiveMode: modeSupported ? configuredMode : 'unsupported',
@@ -361,6 +417,15 @@ export async function updateNetworkProxyConfig(value) {
   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 {

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))
 }
 
@@ -191,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,4 @@
-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'
@@ -90,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,