@xortex/xcode 3.0.0

package/utils/proxy.ts

@@ -0,0 +1,426 @@
+// @aws-sdk/credential-provider-node and @smithy/node-http-handler are imported
+// dynamically in getAWSClientProxyConfig() to defer ~929KB of AWS SDK.
+// undici is lazy-required inside getProxyAgent/configureGlobalAgents to defer
+// ~1.5MB when no HTTPS_PROXY/mTLS env vars are set (the common case).
+import axios, { type AxiosInstance } from 'src/utils/axios.js'
+import type { LookupOptions } from 'dns'
+import type { Agent } from 'http'
+import { HttpsProxyAgent, type HttpsProxyAgentOptions } from 'https-proxy-agent'
+import memoize from 'lodash-es/memoize.js'
+import type * as undici from 'undici'
+import { getCACertificates } from './caCerts.js'
+import { logForDebugging } from './debug.js'
+import { isEnvTruthy } from './envUtils.js'
+import {
+  getMTLSAgent,
+  getMTLSConfig,
+  getTLSFetchOptions,
+  type TLSConfig,
+} from './mtls.js'
+
+// Disable fetch keep-alive after a stale-pool ECONNRESET so retries open a
+// fresh TCP connection instead of reusing the dead pooled socket. Sticky for
+// the process lifetime — once the pool is known-bad, don't trust it again.
+// Works under Bun (native fetch respects keepalive:false for pooling).
+// Under Node/undici, keepalive is a no-op for pooling, but undici
+// naturally evicts dead sockets from the pool on ECONNRESET.
+let keepAliveDisabled = false
+
+export function disableKeepAlive(): void {
+  keepAliveDisabled = true
+}
+
+export function _resetKeepAliveForTesting(): void {
+  keepAliveDisabled = false
+}
+
+/**
+ * Convert dns.LookupOptions.family to a numeric address family value
+ * Handles: 0 | 4 | 6 | 'IPv4' | 'IPv6' | undefined
+ */
+export function getAddressFamily(options: LookupOptions): 0 | 4 | 6 {
+  switch (options.family) {
+    case 0:
+    case 4:
+    case 6:
+      return options.family
+    case 'IPv6':
+      return 6
+    case 'IPv4':
+    case undefined:
+      return 4
+    default:
+      throw new Error(`Unsupported address family: ${options.family}`)
+  }
+}
+
+type EnvLike = Record<string, string | undefined>
+
+/**
+ * Get the active proxy URL if one is configured
+ * Prefers lowercase variants over uppercase (https_proxy > HTTPS_PROXY > http_proxy > HTTP_PROXY)
+ * @param env Environment variables to check (defaults to process.env for production use)
+ */
+export function getProxyUrl(env: EnvLike = process.env): string | undefined {
+  return env.https_proxy || env.HTTPS_PROXY || env.http_proxy || env.HTTP_PROXY
+}
+
+/**
+ * Get the NO_PROXY environment variable value
+ * Prefers lowercase over uppercase (no_proxy > NO_PROXY)
+ * @param env Environment variables to check (defaults to process.env for production use)
+ */
+export function getNoProxy(env: EnvLike = process.env): string | undefined {
+  return env.no_proxy || env.NO_PROXY
+}
+
+/**
+ * Check if a URL should bypass the proxy based on NO_PROXY environment variable
+ * Supports:
+ * - Exact hostname matches (e.g., "localhost")
+ * - Domain suffix matches with leading dot (e.g., ".example.com")
+ * - Wildcard "*" to bypass all
+ * - Port-specific matches (e.g., "example.com:8080")
+ * - IP addresses (e.g., "127.0.0.1")
+ * @param urlString URL to check
+ * @param noProxy NO_PROXY value (defaults to getNoProxy() for production use)
+ */
+export function shouldBypassProxy(
+  urlString: string,
+  noProxy: string | undefined = getNoProxy(),
+): boolean {
+  if (!noProxy) return false
+
+  // Handle wildcard
+  if (noProxy === '*') return true
+
+  try {
+    const url = new URL(urlString)
+    const hostname = url.hostname.toLowerCase()
+    const port = url.port || (url.protocol === 'https:' ? '443' : '80')
+    const hostWithPort = `${hostname}:${port}`
+
+    // Split by comma or space and trim each entry
+    const noProxyList = noProxy.split(/[,\s]+/).filter(Boolean)
+
+    return noProxyList.some(pattern => {
+      pattern = pattern.toLowerCase().trim()
+
+      // Check for port-specific match
+      if (pattern.includes(':')) {
+        return hostWithPort === pattern
+      }
+
+      // Check for domain suffix match (with or without leading dot)
+      if (pattern.startsWith('.')) {
+        // Pattern ".example.com" should match "sub.example.com" and "example.com"
+        // but NOT "notexample.com"
+        const suffix = pattern
+        return hostname === pattern.substring(1) || hostname.endsWith(suffix)
+      }
+
+      // Check for exact hostname match or IP address
+      return hostname === pattern
+    })
+  } catch {
+    // If URL parsing fails, don't bypass proxy
+    return false
+  }
+}
+
+/**
+ * Create an HttpsProxyAgent with optional mTLS configuration
+ * Skips local DNS resolution to let the proxy handle it
+ */
+function createHttpsProxyAgent(
+  proxyUrl: string,
+  extra: HttpsProxyAgentOptions<string> = {},
+): HttpsProxyAgent<string> {
+  const mtlsConfig = getMTLSConfig()
+  const caCerts = getCACertificates()
+
+  const agentOptions: HttpsProxyAgentOptions<string> = {
+    ...(mtlsConfig && {
+      cert: mtlsConfig.cert,
+      key: mtlsConfig.key,
+      passphrase: mtlsConfig.passphrase,
+    }),
+    ...(caCerts && { ca: caCerts }),
+  }
+
+  if (isEnvTruthy(process.env.CLAUDE_CODE_PROXY_RESOLVES_HOSTS)) {
+    // Skip local DNS resolution - let the proxy resolve hostnames
+    // This is needed for environments where DNS is not configured locally
+    // and instead handled by the proxy (as in sandboxes)
+    agentOptions.lookup = (hostname, options, callback) => {
+      callback(null, hostname, getAddressFamily(options))
+    }
+  }
+
+  return new HttpsProxyAgent(proxyUrl, { ...agentOptions, ...extra })
+}
+
+/**
+ * Axios instance with its own proxy agent. Same NO_PROXY/mTLS/CA
+ * resolution as the global interceptor, but agent options stay
+ * scoped to this instance.
+ */
+export function createAxiosInstance(
+  extra: HttpsProxyAgentOptions<string> = {},
+): AxiosInstance {
+  const proxyUrl = getProxyUrl()
+  const mtlsAgent = getMTLSAgent()
+  const instance = axios.create({ proxy: false })
+
+  if (!proxyUrl) {
+    if (mtlsAgent) instance.defaults.httpsAgent = mtlsAgent
+    return instance
+  }
+
+  const proxyAgent = createHttpsProxyAgent(proxyUrl, extra)
+  instance.interceptors.request.use(config => {
+    if (config.url && shouldBypassProxy(config.url)) {
+      config.httpsAgent = mtlsAgent
+      config.httpAgent = mtlsAgent
+    } else {
+      config.httpsAgent = proxyAgent
+      config.httpAgent = proxyAgent
+    }
+    return config
+  })
+  return instance
+}
+
+/**
+ * Get or create a memoized proxy agent for the given URI
+ * Now respects NO_PROXY environment variable
+ */
+export const getProxyAgent = memoize((uri: string): undici.Dispatcher => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const undiciMod = require('undici') as typeof undici
+  const mtlsConfig = getMTLSConfig()
+  const caCerts = getCACertificates()
+
+  // Use EnvHttpProxyAgent to respect NO_PROXY
+  // This agent automatically checks NO_PROXY for each request
+  const proxyOptions: undici.EnvHttpProxyAgent.Options & {
+    requestTls?: {
+      cert?: string | Buffer
+      key?: string | Buffer
+      passphrase?: string
+      ca?: string | string[] | Buffer
+    }
+  } = {
+    // Override both HTTP and HTTPS proxy with the provided URI
+    httpProxy: uri,
+    httpsProxy: uri,
+    noProxy: process.env.NO_PROXY || process.env.no_proxy,
+  }
+
+  // Set both connect and requestTls so TLS options apply to both paths:
+  // - requestTls: used by ProxyAgent for the TLS connection through CONNECT tunnels
+  // - connect: used by Agent for direct (no-proxy) connections
+  if (mtlsConfig || caCerts) {
+    const tlsOpts = {
+      ...(mtlsConfig && {
+        cert: mtlsConfig.cert,
+        key: mtlsConfig.key,
+        passphrase: mtlsConfig.passphrase,
+      }),
+      ...(caCerts && { ca: caCerts }),
+    }
+    proxyOptions.connect = tlsOpts
+    proxyOptions.requestTls = tlsOpts
+  }
+
+  return new undiciMod.EnvHttpProxyAgent(proxyOptions)
+})
+
+/**
+ * Get an HTTP agent configured for WebSocket proxy support
+ * Returns undefined if no proxy is configured or URL should bypass proxy
+ */
+export function getWebSocketProxyAgent(url: string): Agent | undefined {
+  const proxyUrl = getProxyUrl()
+
+  if (!proxyUrl) {
+    return undefined
+  }
+
+  // Check if URL should bypass proxy
+  if (shouldBypassProxy(url)) {
+    return undefined
+  }
+
+  return createHttpsProxyAgent(proxyUrl)
+}
+
+/**
+ * Get the proxy URL for WebSocket connections under Bun.
+ * Bun's native WebSocket supports a `proxy` string option instead of Node's `agent`.
+ * Returns undefined if no proxy is configured or URL should bypass proxy.
+ */
+export function getWebSocketProxyUrl(url: string): string | undefined {
+  const proxyUrl = getProxyUrl()
+
+  if (!proxyUrl) {
+    return undefined
+  }
+
+  if (shouldBypassProxy(url)) {
+    return undefined
+  }
+
+  return proxyUrl
+}
+
+/**
+ * Get fetch options for the Anthropic SDK with proxy and mTLS configuration
+ * Returns fetch options with appropriate dispatcher for proxy and/or mTLS
+ *
+ * @param opts.forAnthropicAPI - Enables ANTHROPIC_UNIX_SOCKET tunneling. This
+ *   env var is set by `claude ssh` on the remote CLI to route API calls through
+ *   an ssh -R forwarded unix socket to a local auth proxy. It MUST NOT leak
+ *   into non-Anthropic-API fetch paths (MCP HTTP/SSE transports, etc.) or those
+ *   requests get misrouted to api.anthropic.com. Only the Anthropic SDK client
+ *   should pass `true` here.
+ */
+export function getProxyFetchOptions(opts?: { forAnthropicAPI?: boolean }): {
+  tls?: TLSConfig
+  dispatcher?: undici.Dispatcher
+  proxy?: string
+  unix?: string
+  keepalive?: false
+} {
+  const base = keepAliveDisabled ? ({ keepalive: false } as const) : {}
+
+  // ANTHROPIC_UNIX_SOCKET tunnels through the `claude ssh` auth proxy, which
+  // hardcodes the upstream to the Anthropic API. Scope to the Anthropic API
+  // client so MCP/SSE/other callers don't get their requests misrouted.
+  if (opts?.forAnthropicAPI) {
+    const unixSocket = process.env.ANTHROPIC_UNIX_SOCKET
+    if (unixSocket && typeof Bun !== 'undefined') {
+      return { ...base, unix: unixSocket }
+    }
+  }
+
+  const proxyUrl = getProxyUrl()
+
+  // If we have a proxy, use the proxy agent (which includes mTLS config)
+  if (proxyUrl) {
+    if (typeof Bun !== 'undefined') {
+      return { ...base, proxy: proxyUrl, ...getTLSFetchOptions() }
+    }
+    return { ...base, dispatcher: getProxyAgent(proxyUrl) }
+  }
+
+  // Otherwise, use TLS options directly if available
+  return { ...base, ...getTLSFetchOptions() }
+}
+
+/**
+ * Configure global HTTP agents for both axios and undici
+ * This ensures all HTTP requests use the proxy and/or mTLS if configured
+ */
+let proxyInterceptorId: number | undefined
+
+export function configureGlobalAgents(): void {
+  const proxyUrl = getProxyUrl()
+  const mtlsAgent = getMTLSAgent()
+
+  // Eject previous interceptor to avoid stacking on repeated calls
+  if (proxyInterceptorId !== undefined) {
+    axios.interceptors.request.eject(proxyInterceptorId)
+    proxyInterceptorId = undefined
+  }
+
+  // Reset proxy-related defaults so reconfiguration is clean
+  axios.defaults.proxy = undefined
+  axios.defaults.httpAgent = undefined
+  axios.defaults.httpsAgent = undefined
+
+  if (proxyUrl) {
+    // workaround for https://github.com/axios/axios/issues/4531
+    axios.defaults.proxy = false
+
+    // Create proxy agent with mTLS options if available
+    const proxyAgent = createHttpsProxyAgent(proxyUrl)
+
+    // Add axios request interceptor to handle NO_PROXY
+    proxyInterceptorId = axios.interceptors.request.use(config => {
+      // Check if URL should bypass proxy based on NO_PROXY
+      if (config.url && shouldBypassProxy(config.url)) {
+        // Bypass proxy - use mTLS agent if configured, otherwise undefined
+        if (mtlsAgent) {
+          config.httpsAgent = mtlsAgent
+          config.httpAgent = mtlsAgent
+        } else {
+          // Remove any proxy agents to use direct connection
+          delete config.httpsAgent
+          delete config.httpAgent
+        }
+      } else {
+        // Use proxy agent
+        config.httpsAgent = proxyAgent
+        config.httpAgent = proxyAgent
+      }
+      return config
+    })
+
+    // Set global dispatcher that now respects NO_PROXY via EnvHttpProxyAgent
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    ;(require('undici') as typeof undici).setGlobalDispatcher(
+      getProxyAgent(proxyUrl),
+    )
+  } else if (mtlsAgent) {
+    // No proxy but mTLS is configured
+    axios.defaults.httpsAgent = mtlsAgent
+
+    // Set undici global dispatcher with mTLS
+    const mtlsOptions = getTLSFetchOptions()
+    if (mtlsOptions.dispatcher) {
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      ;(require('undici') as typeof undici).setGlobalDispatcher(
+        mtlsOptions.dispatcher,
+      )
+    }
+  }
+}
+
+/**
+ * Get AWS SDK client configuration with proxy support
+ * Returns configuration object that can be spread into AWS service client constructors
+ */
+export async function getAWSClientProxyConfig(): Promise<object> {
+  const proxyUrl = getProxyUrl()
+
+  if (!proxyUrl) {
+    return {}
+  }
+
+  const [{ NodeHttpHandler }, { defaultProvider }] = await Promise.all([
+    import('@smithy/node-http-handler'),
+    import('@aws-sdk/credential-provider-node'),
+  ])
+
+  const agent = createHttpsProxyAgent(proxyUrl)
+  const requestHandler = new NodeHttpHandler({
+    httpAgent: agent,
+    httpsAgent: agent,
+  })
+
+  return {
+    requestHandler,
+    credentials: defaultProvider({
+      clientConfig: { requestHandler },
+    }),
+  }
+}
+
+/**
+ * Clear proxy agent cache.
+ */
+export function clearProxyCache(): void {
+  getProxyAgent.cache.clear?.()
+  logForDebugging('Cleared proxy agent cache')
+}

package/utils/queryContext.ts

@@ -0,0 +1,179 @@
+/**
+ * Shared helpers for building the API cache-key prefix (systemPrompt,
+ * userContext, systemContext) for query() calls.
+ *
+ * Lives in its own file because it imports from context.ts and
+ * constants/prompts.ts, which are high in the dependency graph. Putting
+ * these imports in systemPrompt.ts or sideQuestion.ts (both reachable
+ * from commands.ts) would create cycles. Only entrypoint-layer files
+ * import from here (QueryEngine.ts, cli/print.ts).
+ */
+
+import type { Command } from '../commands.js'
+import { getSystemPrompt } from '../constants/prompts.js'
+import { getSystemContext, getUserContext } from '../context.js'
+import type { MCPServerConnection } from '../services/mcp/types.js'
+import type { AppState } from '../state/AppStateStore.js'
+import type { Tools, ToolUseContext } from '../Tool.js'
+import type { AgentDefinition } from '../tools/AgentTool/loadAgentsDir.js'
+import type { Message } from '../types/message.js'
+import { createAbortController } from './abortController.js'
+import type { FileStateCache } from './fileStateCache.js'
+import type { CacheSafeParams } from './forkedAgent.js'
+import { getMainLoopModel } from './model/model.js'
+import { asSystemPrompt } from './systemPromptType.js'
+import {
+  shouldEnableThinkingByDefault,
+  type ThinkingConfig,
+} from './thinking.js'
+
+/**
+ * Fetch the three context pieces that form the API cache-key prefix:
+ * systemPrompt parts, userContext, systemContext.
+ *
+ * When customSystemPrompt is set, the default getSystemPrompt build and
+ * getSystemContext are skipped — the custom prompt replaces the default
+ * entirely, and systemContext would be appended to a default that isn't
+ * being used.
+ *
+ * Callers assemble the final systemPrompt from defaultSystemPrompt (or
+ * customSystemPrompt) + optional extras + appendSystemPrompt. QueryEngine
+ * injects coordinator userContext and memory-mechanics prompt on top;
+ * sideQuestion's fallback uses the base result directly.
+ */
+export async function fetchSystemPromptParts({
+  tools,
+  mainLoopModel,
+  additionalWorkingDirectories,
+  mcpClients,
+  customSystemPrompt,
+}: {
+  tools: Tools
+  mainLoopModel: string
+  additionalWorkingDirectories: string[]
+  mcpClients: MCPServerConnection[]
+  customSystemPrompt: string | undefined
+}): Promise<{
+  defaultSystemPrompt: string[]
+  userContext: { [k: string]: string }
+  systemContext: { [k: string]: string }
+}> {
+  const [defaultSystemPrompt, userContext, systemContext] = await Promise.all([
+    customSystemPrompt !== undefined
+      ? Promise.resolve([])
+      : getSystemPrompt(
+          tools,
+          mainLoopModel,
+          additionalWorkingDirectories,
+          mcpClients,
+        ),
+    getUserContext(),
+    customSystemPrompt !== undefined ? Promise.resolve({}) : getSystemContext(),
+  ])
+  return { defaultSystemPrompt, userContext, systemContext }
+}
+
+/**
+ * Build CacheSafeParams from raw inputs when getLastCacheSafeParams() is null.
+ *
+ * Used by the SDK side_question handler (print.ts) on resume before a turn
+ * completes — there's no stopHooks snapshot yet. Mirrors the system prompt
+ * assembly in QueryEngine.ts:ask() so the rebuilt prefix matches what the
+ * main loop will send, preserving the cache hit in the common case.
+ *
+ * May still miss the cache if the main loop applies extras this path doesn't
+ * know about (coordinator mode, memory-mechanics prompt). That's acceptable —
+ * the alternative is returning null and failing the side question entirely.
+ */
+export async function buildSideQuestionFallbackParams({
+  tools,
+  commands,
+  mcpClients,
+  messages,
+  readFileState,
+  getAppState,
+  setAppState,
+  customSystemPrompt,
+  appendSystemPrompt,
+  thinkingConfig,
+  agents,
+}: {
+  tools: Tools
+  commands: Command[]
+  mcpClients: MCPServerConnection[]
+  messages: Message[]
+  readFileState: FileStateCache
+  getAppState: () => AppState
+  setAppState: (f: (prev: AppState) => AppState) => void
+  customSystemPrompt: string | undefined
+  appendSystemPrompt: string | undefined
+  thinkingConfig: ThinkingConfig | undefined
+  agents: AgentDefinition[]
+}): Promise<CacheSafeParams> {
+  const mainLoopModel = getMainLoopModel()
+  const appState = getAppState()
+
+  const { defaultSystemPrompt, userContext, systemContext } =
+    await fetchSystemPromptParts({
+      tools,
+      mainLoopModel,
+      additionalWorkingDirectories: Array.from(
+        appState.toolPermissionContext.additionalWorkingDirectories.keys(),
+      ),
+      mcpClients,
+      customSystemPrompt,
+    })
+
+  const systemPrompt = asSystemPrompt([
+    ...(customSystemPrompt !== undefined
+      ? [customSystemPrompt]
+      : defaultSystemPrompt),
+    ...(appendSystemPrompt ? [appendSystemPrompt] : []),
+  ])
+
+  // Strip in-progress assistant message (stop_reason === null) — same guard
+  // as btw.tsx. The SDK can fire side_question mid-turn.
+  const last = messages.at(-1)
+  const forkContextMessages =
+    last?.type === 'assistant' && last.message.stop_reason === null
+      ? messages.slice(0, -1)
+      : messages
+
+  const toolUseContext: ToolUseContext = {
+    options: {
+      commands,
+      debug: false,
+      mainLoopModel,
+      tools,
+      verbose: false,
+      thinkingConfig:
+        thinkingConfig ??
+        (shouldEnableThinkingByDefault() !== false
+          ? { type: 'adaptive' }
+          : { type: 'disabled' }),
+      mcpClients,
+      mcpResources: {},
+      isNonInteractiveSession: true,
+      agentDefinitions: { activeAgents: agents, allAgents: [] },
+      customSystemPrompt,
+      appendSystemPrompt,
+    },
+    abortController: createAbortController(),
+    readFileState,
+    getAppState,
+    setAppState,
+    messages: forkContextMessages,
+    setInProgressToolUseIDs: () => {},
+    setResponseLength: () => {},
+    updateFileHistoryState: () => {},
+    updateAttributionState: () => {},
+  }
+
+  return {
+    systemPrompt,
+    userContext,
+    systemContext,
+    toolUseContext,
+    forkContextMessages,
+  }
+}