@xortex/xcode 3.0.0

package/utils/thinking.ts

@@ -0,0 +1,162 @@
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import type { Theme } from './theme.js'
+import { feature } from 'bun:bundle'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import { getCanonicalName } from './model/model.js'
+import { get3PModelCapabilityOverride } from './model/modelSupportOverrides.js'
+import { getAPIProvider } from './model/providers.js'
+import { getSettingsWithErrors } from './settings/settings.js'
+
+export type ThinkingConfig =
+  | { type: 'adaptive' }
+  | { type: 'enabled'; budgetTokens: number }
+  | { type: 'disabled' }
+
+/**
+ * Build-time gate (feature) + runtime gate (GrowthBook). The build flag
+ * controls code inclusion in external builds; the GB flag controls rollout.
+ */
+export function isUltrathinkEnabled(): boolean {
+  if (!feature('ULTRATHINK')) {
+    return false
+  }
+  return getFeatureValue_CACHED_MAY_BE_STALE('tengu_turtle_carbon', true)
+}
+
+/**
+ * Check if text contains the "ultrathink" keyword.
+ */
+export function hasUltrathinkKeyword(text: string): boolean {
+  return /\bultrathink\b/i.test(text)
+}
+
+/**
+ * Find positions of "ultrathink" keyword in text (for UI highlighting/notification)
+ */
+export function findThinkingTriggerPositions(text: string): Array<{
+  word: string
+  start: number
+  end: number
+}> {
+  const positions: Array<{ word: string; start: number; end: number }> = []
+  // Fresh /g literal each call — String.prototype.matchAll copies lastIndex
+  // from the source regex, so a shared instance would leak state from
+  // hasUltrathinkKeyword's .test() into this call on the next render.
+  const matches = text.matchAll(/\bultrathink\b/gi)
+
+  for (const match of matches) {
+    if (match.index !== undefined) {
+      positions.push({
+        word: match[0],
+        start: match.index,
+        end: match.index + match[0].length,
+      })
+    }
+  }
+
+  return positions
+}
+
+const RAINBOW_COLORS: Array<keyof Theme> = [
+  'rainbow_red',
+  'rainbow_orange',
+  'rainbow_yellow',
+  'rainbow_green',
+  'rainbow_blue',
+  'rainbow_indigo',
+  'rainbow_violet',
+]
+
+const RAINBOW_SHIMMER_COLORS: Array<keyof Theme> = [
+  'rainbow_red_shimmer',
+  'rainbow_orange_shimmer',
+  'rainbow_yellow_shimmer',
+  'rainbow_green_shimmer',
+  'rainbow_blue_shimmer',
+  'rainbow_indigo_shimmer',
+  'rainbow_violet_shimmer',
+]
+
+export function getRainbowColor(
+  charIndex: number,
+  shimmer: boolean = false,
+): keyof Theme {
+  const colors = shimmer ? RAINBOW_SHIMMER_COLORS : RAINBOW_COLORS
+  return colors[charIndex % colors.length]!
+}
+
+// TODO(inigo): add support for probing unknown models via API error detection
+// Provider-aware thinking support detection (aligns with modelSupportsISP in betas.ts)
+export function modelSupportsThinking(model: string): boolean {
+  const supported3P = get3PModelCapabilityOverride(model, 'thinking')
+  if (supported3P !== undefined) {
+    return supported3P
+  }
+  if (process.env.USER_TYPE === 'ant') {
+    if (resolveAntModel(model.toLowerCase())) {
+      return true
+    }
+  }
+  // IMPORTANT: Do not change thinking support without notifying the model
+  // launch DRI and research. This can greatly affect model quality and bashing.
+  const canonical = getCanonicalName(model)
+  const provider = getAPIProvider()
+  // 1P and Foundry: all Claude 4+ models (including Haiku 4.5)
+  if (provider === 'foundry' || provider === 'firstParty') {
+    return !canonical.includes('claude-3-')
+  }
+  // 3P (Bedrock/Vertex): only Opus 4+ and Sonnet 4+
+  return canonical.includes('sonnet-4') || canonical.includes('opus-4')
+}
+
+// @[MODEL LAUNCH]: Add the new model to the allowlist if it supports adaptive thinking.
+export function modelSupportsAdaptiveThinking(model: string): boolean {
+  const supported3P = get3PModelCapabilityOverride(model, 'adaptive_thinking')
+  if (supported3P !== undefined) {
+    return supported3P
+  }
+  const canonical = getCanonicalName(model)
+  // Supported by a subset of Claude 4 models
+  if (canonical.includes('opus-4-6') || canonical.includes('sonnet-4-6')) {
+    return true
+  }
+  // Exclude any other known legacy models (allowlist above catches 4-6 variants first)
+  if (
+    canonical.includes('opus') ||
+    canonical.includes('sonnet') ||
+    canonical.includes('haiku')
+  ) {
+    return false
+  }
+  // IMPORTANT: Do not change adaptive thinking support without notifying the
+  // model launch DRI and research. This can greatly affect model quality and
+  // bashing.
+
+  // Newer models (4.6+) are all trained on adaptive thinking and MUST have it
+  // enabled for model testing. DO NOT default to false for first party, otherwise
+  // we may silently degrade model quality.
+
+  // Default to true for unknown model strings on 1P and Foundry (because Foundry
+  // is a proxy). Do not default to true for other 3P as they have different formats
+  // for their model strings.
+  const provider = getAPIProvider()
+  return provider === 'firstParty' || provider === 'foundry'
+}
+
+export function shouldEnableThinkingByDefault(): boolean {
+  if (process.env.MAX_THINKING_TOKENS) {
+    return parseInt(process.env.MAX_THINKING_TOKENS, 10) > 0
+  }
+
+  const { settings } = getSettingsWithErrors()
+  if (settings.alwaysThinkingEnabled === false) {
+    return false
+  }
+
+  // IMPORTANT: Do not change default thinking enabled value without notifying
+  // the model launch DRI and research. This can greatly affect model quality and
+  // bashing.
+
+  // Enable thinking by default unless explicitly disabled.
+  return true
+}

package/utils/timeouts.ts

@@ -0,0 +1,39 @@
+// Constants for timeout values
+const DEFAULT_TIMEOUT_MS = 120_000 // 2 minutes
+const MAX_TIMEOUT_MS = 600_000 // 10 minutes
+
+type EnvLike = Record<string, string | undefined>
+
+/**
+ * Get the default timeout for bash operations in milliseconds
+ * Checks BASH_DEFAULT_TIMEOUT_MS environment variable or returns 2 minutes default
+ * @param env Environment variables to check (defaults to process.env for production use)
+ */
+export function getDefaultBashTimeoutMs(env: EnvLike = process.env): number {
+  const envValue = env.BASH_DEFAULT_TIMEOUT_MS
+  if (envValue) {
+    const parsed = parseInt(envValue, 10)
+    if (!isNaN(parsed) && parsed > 0) {
+      return parsed
+    }
+  }
+  return DEFAULT_TIMEOUT_MS
+}
+
+/**
+ * Get the maximum timeout for bash operations in milliseconds
+ * Checks BASH_MAX_TIMEOUT_MS environment variable or returns 10 minutes default
+ * @param env Environment variables to check (defaults to process.env for production use)
+ */
+export function getMaxBashTimeoutMs(env: EnvLike = process.env): number {
+  const envValue = env.BASH_MAX_TIMEOUT_MS
+  if (envValue) {
+    const parsed = parseInt(envValue, 10)
+    if (!isNaN(parsed) && parsed > 0) {
+      // Ensure max is at least as large as default
+      return Math.max(parsed, getDefaultBashTimeoutMs(env))
+    }
+  }
+  // Always ensure max is at least as large as default
+  return Math.max(MAX_TIMEOUT_MS, getDefaultBashTimeoutMs(env))
+}

package/utils/tmuxSocket.ts

@@ -0,0 +1,427 @@
+/**
+ * TMUX SOCKET ISOLATION
+ * =====================
+ * This module manages an isolated tmux socket for Claude's operations.
+ *
+ * WHY THIS EXISTS:
+ * Without isolation, Claude could accidentally affect the user's tmux sessions.
+ * For example, running `tmux kill-session` via the Bash tool would kill the
+ * user's current session if they started Claude from within tmux.
+ *
+ * HOW IT WORKS:
+ * 1. Claude creates its own tmux socket: `claude-<PID>` (e.g., `claude-12345`)
+ * 2. ALL Tmux tool commands use this socket via the `-L` flag
+ * 3. ALL Bash tool commands inherit TMUX env var pointing to this socket
+ *    (set in Shell.ts via getClaudeTmuxEnv())
+ *
+ * This means ANY tmux command run through Claude - whether via the Tmux tool
+ * directly or via Bash - will operate on Claude's isolated socket, NOT the
+ * user's tmux session.
+ *
+ * IMPORTANT: The user's original TMUX env var is NOT used. After socket
+ * initialization, getClaudeTmuxEnv() returns a value that overrides the
+ * user's TMUX in all child processes spawned by Shell.ts.
+ */
+
+import { posix } from 'path'
+import { registerCleanup } from './cleanupRegistry.js'
+import { logForDebugging } from './debug.js'
+import { toError } from './errors.js'
+import { execFileNoThrow } from './execFileNoThrow.js'
+import { logError } from './log.js'
+import { getPlatform } from './platform.js'
+
+// Constants for tmux socket management
+const TMUX_COMMAND = 'tmux'
+const CLAUDE_SOCKET_PREFIX = 'claude'
+
+/**
+ * Executes a tmux command, routing through WSL on Windows.
+ * On Windows, tmux only exists inside WSL — WSL interop lets the tmux session
+ * launch .exe files as native Win32 processes while stdin/stdout flow through
+ * the WSL pty.
+ */
+async function execTmux(
+  args: string[],
+  opts?: { useCwd?: boolean },
+): Promise<{ stdout: string; stderr: string; code: number }> {
+  if (getPlatform() === 'windows') {
+    // -e execs tmux directly without the login shell. Without it, wsl hands the
+    // command line to bash which eats `#` as a comment: `display-message -p
+    // #{socket_path},#{pid}` below becomes `display-message -p ` → exit 1 →
+    // we silently fall back to the guessed path and never learn the real
+    // server PID. Same root cause as TungstenTool/utils.ts:execTmuxCommand.
+    const result = await execFileNoThrow('wsl', ['-e', TMUX_COMMAND, ...args], {
+      env: { ...process.env, WSL_UTF8: '1' },
+      ...opts,
+    })
+    return {
+      stdout: result.stdout || '',
+      stderr: result.stderr || '',
+      code: result.code || 0,
+    }
+  }
+  const result = await execFileNoThrow(TMUX_COMMAND, args, opts)
+  return {
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    code: result.code || 0,
+  }
+}
+
+// Socket state - initialized lazily when Tmux tool is first used or a tmux command is run
+let socketName: string | null = null
+let socketPath: string | null = null
+let serverPid: number | null = null
+let isInitializing = false
+let initPromise: Promise<void> | null = null
+
+// tmux availability - checked once upfront
+let tmuxAvailabilityChecked = false
+let tmuxAvailable = false
+
+// Track whether the Tmux tool has been used at least once
+// Used to defer socket initialization until actually needed
+let tmuxToolUsed = false
+
+/**
+ * Gets the socket name for Claude's isolated tmux session.
+ * Format: claude-<PID>
+ */
+export function getClaudeSocketName(): string {
+  if (!socketName) {
+    socketName = `${CLAUDE_SOCKET_PREFIX}-${process.pid}`
+  }
+  return socketName
+}
+
+/**
+ * Gets the socket path if the socket has been initialized.
+ * Returns null if not yet initialized.
+ */
+export function getClaudeSocketPath(): string | null {
+  return socketPath
+}
+
+/**
+ * Sets socket info after initialization.
+ * Called after the tmux session is created.
+ */
+export function setClaudeSocketInfo(path: string, pid: number): void {
+  socketPath = path
+  serverPid = pid
+}
+
+/**
+ * Returns whether the socket has been initialized.
+ */
+export function isSocketInitialized(): boolean {
+  return socketPath !== null && serverPid !== null
+}
+
+/**
+ * Gets the TMUX environment variable value for Claude's isolated socket.
+ *
+ * CRITICAL: This value is used by Shell.ts to override the TMUX env var
+ * in ALL child processes. This ensures that any `tmux` command run via
+ * the Bash tool will operate on Claude's socket, NOT the user's session.
+ *
+ * Format: "socket_path,server_pid,pane_index" (matches tmux's TMUX env var)
+ * Example: "/tmp/tmux-501/claude-12345,54321,0"
+ *
+ * Returns null if socket is not yet initialized.
+ * When null, Shell.ts does not override TMUX, preserving user's environment.
+ */
+export function getClaudeTmuxEnv(): string | null {
+  if (!socketPath || serverPid === null) {
+    return null
+  }
+  return `${socketPath},${serverPid},0`
+}
+
+/**
+ * Checks if tmux is available on this system.
+ * This is checked once and cached for the lifetime of the process.
+ *
+ * When tmux is not available:
+ * - TungstenTool (Tmux) will not work
+ * - TeammateTool will not work (it uses tmux for pane management)
+ * - Bash commands will run without tmux isolation
+ */
+export async function checkTmuxAvailable(): Promise<boolean> {
+  if (!tmuxAvailabilityChecked) {
+    const result =
+      getPlatform() === 'windows'
+        ? await execFileNoThrow('wsl', ['-e', TMUX_COMMAND, '-V'], {
+            env: { ...process.env, WSL_UTF8: '1' },
+            useCwd: false,
+          })
+        : await execFileNoThrow('which', [TMUX_COMMAND], {
+            useCwd: false,
+          })
+    tmuxAvailable = result.code === 0
+    if (!tmuxAvailable) {
+      logForDebugging(
+        `[Socket] tmux is not installed. The Tmux tool and Teammate tool will not be available.`,
+      )
+    }
+    tmuxAvailabilityChecked = true
+  }
+  return tmuxAvailable
+}
+
+/**
+ * Returns the cached tmux availability status.
+ * Returns false if availability hasn't been checked yet.
+ * Use checkTmuxAvailable() to perform the check.
+ */
+export function isTmuxAvailable(): boolean {
+  return tmuxAvailabilityChecked && tmuxAvailable
+}
+
+/**
+ * Marks that the Tmux tool has been used at least once.
+ * Called by TungstenTool before initialization.
+ * After this is called, Shell.ts will initialize the socket for subsequent Bash commands.
+ */
+export function markTmuxToolUsed(): void {
+  tmuxToolUsed = true
+}
+
+/**
+ * Returns whether the Tmux tool has been used at least once.
+ * Used by Shell.ts to decide whether to initialize the socket.
+ */
+export function hasTmuxToolBeenUsed(): boolean {
+  return tmuxToolUsed
+}
+
+/**
+ * Ensures the socket is initialized with a tmux session.
+ * Called by Shell.ts when the Tmux tool has been used or the command includes "tmux".
+ * Safe to call multiple times; will only initialize once.
+ *
+ * If tmux is not installed, this function returns gracefully without
+ * initializing the socket. getClaudeTmuxEnv() will return null, and
+ * Bash commands will run without tmux isolation.
+ */
+export async function ensureSocketInitialized(): Promise<void> {
+  // Already initialized
+  if (isSocketInitialized()) {
+    return
+  }
+
+  // Check if tmux is available before trying to use it
+  const available = await checkTmuxAvailable()
+  if (!available) {
+    return
+  }
+
+  // Another call is already initializing - wait for it but don't propagate errors
+  // The original caller handles the error and sets up graceful degradation
+  if (isInitializing && initPromise) {
+    try {
+      await initPromise
+    } catch {
+      // Ignore - the original caller logs the error
+    }
+    return
+  }
+
+  isInitializing = true
+  initPromise = doInitialize()
+
+  try {
+    await initPromise
+  } catch (error) {
+    // Log error but don't throw - graceful degradation
+    const err = toError(error)
+    logError(err)
+    logForDebugging(
+      `[Socket] Failed to initialize tmux socket: ${err.message}. Tmux isolation will be disabled.`,
+    )
+  } finally {
+    isInitializing = false
+  }
+}
+
+/**
+ * Kills the tmux server for Claude's isolated socket.
+ * Called during graceful shutdown to clean up resources.
+ */
+async function killTmuxServer(): Promise<void> {
+  const socket = getClaudeSocketName()
+  logForDebugging(`[Socket] Killing tmux server for socket: ${socket}`)
+
+  const result = await execTmux(['-L', socket, 'kill-server'])
+
+  if (result.code === 0) {
+    logForDebugging(`[Socket] Successfully killed tmux server`)
+  } else {
+    // Server may already be dead, which is fine
+    logForDebugging(
+      `[Socket] Failed to kill tmux server (exit ${result.code}): ${result.stderr}`,
+    )
+  }
+}
+
+async function doInitialize(): Promise<void> {
+  const socket = getClaudeSocketName()
+
+  // Create a new session with our custom socket
+  // Pass CLAUDE_CODE_SKIP_PROMPT_HISTORY via -e so it's set in the initial shell environment
+  //
+  // On Windows, the tmux server inherits WSL_INTEROP from the short-lived
+  // wsl.exe that spawns it; once `new-session -d` detaches and wsl.exe exits,
+  // that socket stops servicing requests. Any cli.exe launched inside the pane
+  // then hits `UtilAcceptVsock: accept4 failed 110` (ETIMEDOUT). Observed on
+  // 2026-03-25: server PID 386 (started alongside /init at WSL boot) inherited
+  // /run/WSL/383_interop — init's own socket, which listens but doesn't handle
+  // interop. /run/WSL/1_interop is a stable symlink WSL maintains to the real
+  // handler; pin the server to it so interop survives the spawning wsl.exe.
+  const result = await execTmux([
+    '-L',
+    socket,
+    'new-session',
+    '-d',
+    '-s',
+    'base',
+    '-e',
+    'CLAUDE_CODE_SKIP_PROMPT_HISTORY=true',
+    ...(getPlatform() === 'windows'
+      ? ['-e', 'WSL_INTEROP=/run/WSL/1_interop']
+      : []),
+  ])
+
+  if (result.code !== 0) {
+    // Session might already exist from a previous run with same PID (unlikely but possible)
+    // Check if the session exists
+    const checkResult = await execTmux([
+      '-L',
+      socket,
+      'has-session',
+      '-t',
+      'base',
+    ])
+    if (checkResult.code !== 0) {
+      throw new Error(
+        `Failed to create tmux session on socket ${socket}: ${result.stderr}`,
+      )
+    }
+  }
+
+  // Register cleanup to kill the tmux server on exit
+  registerCleanup(killTmuxServer)
+
+  // Set CLAUDE_CODE_SKIP_PROMPT_HISTORY in the tmux GLOBAL environment (-g).
+  // Without -g this would only apply to the 'base' session, and new sessions
+  // created by TungstenTool (e.g. 'test', 'verify') would not inherit it.
+  // Any Claude Code instance spawned on this socket will inherit this env var,
+  // preventing test/verification sessions from polluting the user's real
+  // command history and --resume session list.
+  await execTmux([
+    '-L',
+    socket,
+    'set-environment',
+    '-g',
+    'CLAUDE_CODE_SKIP_PROMPT_HISTORY',
+    'true',
+  ])
+
+  // Same WSL_INTEROP pin as the new-session -e above, but in the GLOBAL env
+  // so sessions created by TungstenTool inherit it too. The -e on new-session
+  // only covers the base session's initial shell; a later `new-session -s cc`
+  // inherits the SERVER's env, which still holds the stale socket from the
+  // wsl.exe that spawned it.
+  if (getPlatform() === 'windows') {
+    await execTmux([
+      '-L',
+      socket,
+      'set-environment',
+      '-g',
+      'WSL_INTEROP',
+      '/run/WSL/1_interop',
+    ])
+  }
+
+  // Get the socket path and server PID
+  const infoResult = await execTmux([
+    '-L',
+    socket,
+    'display-message',
+    '-p',
+    '#{socket_path},#{pid}',
+  ])
+
+  if (infoResult.code === 0) {
+    const [path, pidStr] = infoResult.stdout.trim().split(',')
+    if (path && pidStr) {
+      const pid = parseInt(pidStr, 10)
+      if (!isNaN(pid)) {
+        setClaudeSocketInfo(path, pid)
+        return
+      }
+    }
+    // Parsing failed - log and fall through to fallback
+    logForDebugging(
+      `[Socket] Failed to parse socket info from tmux output: "${infoResult.stdout.trim()}". Using fallback path.`,
+    )
+  } else {
+    // Command failed - log and fall through to fallback
+    logForDebugging(
+      `[Socket] Failed to get socket info via display-message (exit ${infoResult.code}): ${infoResult.stderr}. Using fallback path.`,
+    )
+  }
+
+  // Fallback: construct the socket path from standard tmux location
+  // tmux sockets are typically at $TMPDIR/tmux-<UID>/<socket_name> (or /tmp/tmux-<UID>/ if TMPDIR is not set)
+  // On Windows this path is inside WSL, so always use POSIX separators.
+  // process.getuid() is undefined on Windows; WSL default user is root (uid 0) in CI.
+  const uid = process.getuid?.() ?? 0
+  const baseTmpDir = process.env.TMPDIR || '/tmp'
+  const fallbackPath = posix.join(baseTmpDir, `tmux-${uid}`, socket)
+
+  // Get server PID separately
+  const pidResult = await execTmux([
+    '-L',
+    socket,
+    'display-message',
+    '-p',
+    '#{pid}',
+  ])
+
+  if (pidResult.code === 0) {
+    const pid = parseInt(pidResult.stdout.trim(), 10)
+    if (!isNaN(pid)) {
+      logForDebugging(
+        `[Socket] Using fallback socket path: ${fallbackPath} (server PID: ${pid})`,
+      )
+      setClaudeSocketInfo(fallbackPath, pid)
+      return
+    }
+    // PID parsing failed
+    logForDebugging(
+      `[Socket] Failed to parse server PID from tmux output: "${pidResult.stdout.trim()}"`,
+    )
+  } else {
+    logForDebugging(
+      `[Socket] Failed to get server PID (exit ${pidResult.code}): ${pidResult.stderr}`,
+    )
+  }
+
+  throw new Error(
+    `Failed to get socket info for ${socket}: primary="${infoResult.stderr}", fallback="${pidResult.stderr}"`,
+  )
+}
+
+// For testing purposes
+export function resetSocketState(): void {
+  socketName = null
+  socketPath = null
+  serverPid = null
+  isInitializing = false
+  initPromise = null
+  tmuxAvailabilityChecked = false
+  tmuxAvailable = false
+  tmuxToolUsed = false
+}

package/utils/todo/types.ts

@@ -0,0 +1,18 @@
+import { z } from 'zod/v4'
+import { lazySchema } from '../lazySchema.js'
+
+const TodoStatusSchema = lazySchema(() =>
+  z.enum(['pending', 'in_progress', 'completed']),
+)
+
+export const TodoItemSchema = lazySchema(() =>
+  z.object({
+    content: z.string().min(1, 'Content cannot be empty'),
+    status: TodoStatusSchema(),
+    activeForm: z.string().min(1, 'Active form cannot be empty'),
+  }),
+)
+export type TodoItem = z.infer<ReturnType<typeof TodoItemSchema>>
+
+export const TodoListSchema = lazySchema(() => z.array(TodoItemSchema()))
+export type TodoList = z.infer<ReturnType<typeof TodoListSchema>>