@xortex/xcode 3.0.0

package/utils/effort.ts

@@ -0,0 +1,329 @@
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { isUltrathinkEnabled } from './thinking.js'
+import { getInitialSettings } from './settings/settings.js'
+import { isProSubscriber, isMaxSubscriber, isTeamSubscriber } from './auth.js'
+import { getFeatureValue_CACHED_MAY_BE_STALE } from 'src/services/analytics/growthbook.js'
+import { getAPIProvider } from './model/providers.js'
+import { get3PModelCapabilityOverride } from './model/modelSupportOverrides.js'
+import { isEnvTruthy } from './envUtils.js'
+import type { EffortLevel } from 'src/entrypoints/sdk/runtimeTypes.js'
+
+export type { EffortLevel }
+
+export const EFFORT_LEVELS = [
+  'low',
+  'medium',
+  'high',
+  'max',
+] as const satisfies readonly EffortLevel[]
+
+export type EffortValue = EffortLevel | number
+
+// @[MODEL LAUNCH]: Add the new model to the allowlist if it supports the effort parameter.
+export function modelSupportsEffort(model: string): boolean {
+  const m = model.toLowerCase()
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ALWAYS_ENABLE_EFFORT)) {
+    return true
+  }
+  const supported3P = get3PModelCapabilityOverride(model, 'effort')
+  if (supported3P !== undefined) {
+    return supported3P
+  }
+  // Supported by a subset of Claude 4 models
+  if (m.includes('opus-4-6') || m.includes('sonnet-4-6')) {
+    return true
+  }
+  // Exclude any other known legacy models (haiku, older opus/sonnet variants)
+  if (m.includes('haiku') || m.includes('sonnet') || m.includes('opus')) {
+    return false
+  }
+
+  // IMPORTANT: Do not change the default effort support without notifying
+  // the model launch DRI and research. This is a sensitive setting that can
+  // greatly affect model quality and bashing.
+
+  // Default to true for unknown model strings on 1P.
+  // Do not default to true for 3P as they have different formats for their
+  // model strings (ex. anthropics/claude-code#30795)
+  return getAPIProvider() === 'firstParty'
+}
+
+// @[MODEL LAUNCH]: Add the new model to the allowlist if it supports 'max' effort.
+// Per API docs, 'max' is Opus 4.6 only for public models — other models return an error.
+export function modelSupportsMaxEffort(model: string): boolean {
+  const supported3P = get3PModelCapabilityOverride(model, 'max_effort')
+  if (supported3P !== undefined) {
+    return supported3P
+  }
+  if (model.toLowerCase().includes('opus-4-6')) {
+    return true
+  }
+  if (process.env.USER_TYPE === 'ant' && resolveAntModel(model)) {
+    return true
+  }
+  return false
+}
+
+export function isEffortLevel(value: string): value is EffortLevel {
+  return (EFFORT_LEVELS as readonly string[]).includes(value)
+}
+
+export function parseEffortValue(value: unknown): EffortValue | undefined {
+  if (value === undefined || value === null || value === '') {
+    return undefined
+  }
+  if (typeof value === 'number' && isValidNumericEffort(value)) {
+    return value
+  }
+  const str = String(value).toLowerCase()
+  if (isEffortLevel(str)) {
+    return str
+  }
+  const numericValue = parseInt(str, 10)
+  if (!isNaN(numericValue) && isValidNumericEffort(numericValue)) {
+    return numericValue
+  }
+  return undefined
+}
+
+/**
+ * Numeric values are model-default only and not persisted.
+ * 'max' is session-scoped for external users (ants can persist it).
+ * Write sites call this before saving to settings so the Zod schema
+ * (which only accepts string levels) never rejects a write.
+ */
+export function toPersistableEffort(
+  value: EffortValue | undefined,
+): EffortLevel | undefined {
+  if (value === 'low' || value === 'medium' || value === 'high') {
+    return value
+  }
+  if (value === 'max' && process.env.USER_TYPE === 'ant') {
+    return value
+  }
+  return undefined
+}
+
+export function getInitialEffortSetting(): EffortLevel | undefined {
+  // toPersistableEffort filters 'max' for non-ants on read, so a manually
+  // edited settings.json doesn't leak session-scoped max into a fresh session.
+  return toPersistableEffort(getInitialSettings().effortLevel)
+}
+
+/**
+ * Decide what effort level (if any) to persist when the user selects a model
+ * in ModelPicker. Keeps an explicit prior /effort choice sticky even when it
+ * matches the picked model's default, while letting purely-default and
+ * session-ephemeral effort (CLI --effort, EffortCallout default) fall through
+ * to undefined so it follows future model-default changes.
+ *
+ * priorPersisted must come from userSettings on disk
+ * (getSettingsForSource('userSettings')?.effortLevel), NOT merged settings
+ * (project/policy layers would leak into the user's global settings.json)
+ * and NOT AppState.effortValue (includes session-scoped sources that
+ * deliberately do not write to settings.json).
+ */
+export function resolvePickerEffortPersistence(
+  picked: EffortLevel | undefined,
+  modelDefault: EffortLevel,
+  priorPersisted: EffortLevel | undefined,
+  toggledInPicker: boolean,
+): EffortLevel | undefined {
+  const hadExplicit = priorPersisted !== undefined || toggledInPicker
+  return hadExplicit || picked !== modelDefault ? picked : undefined
+}
+
+export function getEffortEnvOverride(): EffortValue | null | undefined {
+  const envOverride = process.env.CLAUDE_CODE_EFFORT_LEVEL
+  return envOverride?.toLowerCase() === 'unset' ||
+    envOverride?.toLowerCase() === 'auto'
+    ? null
+    : parseEffortValue(envOverride)
+}
+
+/**
+ * Resolve the effort value that will actually be sent to the API for a given
+ * model, following the full precedence chain:
+ *   env CLAUDE_CODE_EFFORT_LEVEL → appState.effortValue → model default
+ *
+ * Returns undefined when no effort parameter should be sent (env set to
+ * 'unset', or no default exists for the model).
+ */
+export function resolveAppliedEffort(
+  model: string,
+  appStateEffortValue: EffortValue | undefined,
+): EffortValue | undefined {
+  const envOverride = getEffortEnvOverride()
+  if (envOverride === null) {
+    return undefined
+  }
+  const resolved =
+    envOverride ?? appStateEffortValue ?? getDefaultEffortForModel(model)
+  // API rejects 'max' on non-Opus-4.6 models — downgrade to 'high'.
+  if (resolved === 'max' && !modelSupportsMaxEffort(model)) {
+    return 'high'
+  }
+  return resolved
+}
+
+/**
+ * Resolve the effort level to show the user. Wraps resolveAppliedEffort
+ * with the 'high' fallback (what the API uses when no effort param is sent).
+ * Single source of truth for the status bar and /effort output (CC-1088).
+ */
+export function getDisplayedEffortLevel(
+  model: string,
+  appStateEffort: EffortValue | undefined,
+): EffortLevel {
+  const resolved = resolveAppliedEffort(model, appStateEffort) ?? 'high'
+  return convertEffortValueToLevel(resolved)
+}
+
+/**
+ * Build the ` with {level} effort` suffix shown in Logo/Spinner.
+ * Returns empty string if the user hasn't explicitly set an effort value.
+ * Delegates to resolveAppliedEffort() so the displayed level matches what
+ * the API actually receives (including max→high clamp for non-Opus models).
+ */
+export function getEffortSuffix(
+  model: string,
+  effortValue: EffortValue | undefined,
+): string {
+  if (effortValue === undefined) return ''
+  const resolved = resolveAppliedEffort(model, effortValue)
+  if (resolved === undefined) return ''
+  return ` with ${convertEffortValueToLevel(resolved)} effort`
+}
+
+export function isValidNumericEffort(value: number): boolean {
+  return Number.isInteger(value)
+}
+
+export function convertEffortValueToLevel(value: EffortValue): EffortLevel {
+  if (typeof value === 'string') {
+    // Runtime guard: value may come from remote config (GrowthBook) where
+    // TypeScript types can't help us. Coerce unknown strings to 'high'
+    // rather than passing them through unchecked.
+    return isEffortLevel(value) ? value : 'high'
+  }
+  if (process.env.USER_TYPE === 'ant' && typeof value === 'number') {
+    if (value <= 50) return 'low'
+    if (value <= 85) return 'medium'
+    if (value <= 100) return 'high'
+    return 'max'
+  }
+  return 'high'
+}
+
+/**
+ * Get user-facing description for effort levels
+ *
+ * @param level The effort level to describe
+ * @returns Human-readable description
+ */
+export function getEffortLevelDescription(level: EffortLevel): string {
+  switch (level) {
+    case 'low':
+      return 'Quick, straightforward implementation with minimal overhead'
+    case 'medium':
+      return 'Balanced approach with standard implementation and testing'
+    case 'high':
+      return 'Comprehensive implementation with extensive testing and documentation'
+    case 'max':
+      return 'Maximum capability with deepest reasoning (Opus 4.6 only)'
+  }
+}
+
+/**
+ * Get user-facing description for effort values (both string and numeric)
+ *
+ * @param value The effort value to describe
+ * @returns Human-readable description
+ */
+export function getEffortValueDescription(value: EffortValue): string {
+  if (process.env.USER_TYPE === 'ant' && typeof value === 'number') {
+    return `[ANT-ONLY] Numeric effort value of ${value}`
+  }
+
+  if (typeof value === 'string') {
+    return getEffortLevelDescription(value)
+  }
+  return 'Balanced approach with standard implementation and testing'
+}
+
+export type OpusDefaultEffortConfig = {
+  enabled: boolean
+  dialogTitle: string
+  dialogDescription: string
+}
+
+const OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT: OpusDefaultEffortConfig = {
+  enabled: true,
+  dialogTitle: 'We recommend medium effort for Opus',
+  dialogDescription:
+    'Effort determines how long Claude thinks for when completing your task. We recommend medium effort for most tasks to balance speed and intelligence and maximize rate limits. Use ultrathink to trigger high effort when needed.',
+}
+
+export function getOpusDefaultEffortConfig(): OpusDefaultEffortConfig {
+  const config = getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_grey_step2',
+    OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT,
+  )
+  return {
+    ...OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT,
+    ...config,
+  }
+}
+
+// @[MODEL LAUNCH]: Update the default effort levels for new models
+export function getDefaultEffortForModel(
+  model: string,
+): EffortValue | undefined {
+  if (process.env.USER_TYPE === 'ant') {
+    const config = getAntModelOverrideConfig()
+    const isDefaultModel =
+      config?.defaultModel !== undefined &&
+      model.toLowerCase() === config.defaultModel.toLowerCase()
+    if (isDefaultModel && config?.defaultModelEffortLevel) {
+      return config.defaultModelEffortLevel
+    }
+    const antModel = resolveAntModel(model)
+    if (antModel) {
+      if (antModel.defaultEffortLevel) {
+        return antModel.defaultEffortLevel
+      }
+      if (antModel.defaultEffortValue !== undefined) {
+        return antModel.defaultEffortValue
+      }
+    }
+    // Always default ants to undefined/high
+    return undefined
+  }
+
+  // IMPORTANT: Do not change the default effort level without notifying
+  // the model launch DRI and research. Default effort is a sensitive setting
+  // that can greatly affect model quality and bashing.
+
+  // Default effort on Opus 4.6 to medium for Pro.
+  // Max/Team also get medium when the tengu_grey_step2 config is enabled.
+  if (model.toLowerCase().includes('opus-4-6')) {
+    if (isProSubscriber()) {
+      return 'medium'
+    }
+    if (
+      getOpusDefaultEffortConfig().enabled &&
+      (isMaxSubscriber() || isTeamSubscriber())
+    ) {
+      return 'medium'
+    }
+  }
+
+  // When ultrathink feature is on, default effort to medium (ultrathink bumps to high)
+  if (isUltrathinkEnabled() && modelSupportsEffort(model)) {
+    return 'medium'
+  }
+
+  // Fallback to undefined, which means we don't set an effort level. This
+  // should resolve to high effort level in the API.
+  return undefined
+}

package/utils/embeddedTools.ts

@@ -0,0 +1,29 @@
+import { isEnvTruthy } from './envUtils.js'
+
+/**
+ * Whether this build has bfs/ugrep embedded in the bun binary (ant-native only).
+ *
+ * When true:
+ * - `find` and `grep` in Claude's Bash shell are shadowed by shell functions
+ *   that invoke the bun binary with argv0='bfs' / argv0='ugrep' (same trick
+ *   as embedded ripgrep)
+ * - The dedicated Glob/Grep tools are removed from the tool registry
+ * - Prompt guidance steering Claude away from find/grep is omitted
+ *
+ * Set as a build-time define in scripts/build-with-plugins.ts for ant-native builds.
+ */
+export function hasEmbeddedSearchTools(): boolean {
+  if (!isEnvTruthy(process.env.EMBEDDED_SEARCH_TOOLS)) return false
+  const e = process.env.CLAUDE_CODE_ENTRYPOINT
+  return (
+    e !== 'sdk-ts' && e !== 'sdk-py' && e !== 'sdk-cli' && e !== 'local-agent'
+  )
+}
+
+/**
+ * Path to the bun binary that contains the embedded search tools.
+ * Only meaningful when hasEmbeddedSearchTools() is true.
+ */
+export function embeddedSearchToolsBinaryPath(): string {
+  return process.execPath
+}

package/utils/env.ts

@@ -0,0 +1,347 @@
+import memoize from 'lodash-es/memoize.js'
+import { homedir } from 'os'
+import { join } from 'path'
+import { fileSuffixForOauthConfig } from '../constants/oauth.js'
+import { isRunningWithBun } from './bundledMode.js'
+import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js'
+import { findExecutable } from './findExecutable.js'
+import { getFsImplementation } from './fsOperations.js'
+import { which } from './which.js'
+
+type Platform = 'win32' | 'darwin' | 'linux'
+
+// Config and data paths
+export const getGlobalClaudeFile = memoize((): string => {
+  // Legacy fallback for backwards compatibility
+  if (
+    getFsImplementation().existsSync(
+      join(getClaudeConfigHomeDir(), '.config.json'),
+    )
+  ) {
+    return join(getClaudeConfigHomeDir(), '.config.json')
+  }
+
+  const filename = `.claude${fileSuffixForOauthConfig()}.json`
+  return join(process.env.CLAUDE_CONFIG_DIR || homedir(), filename)
+})
+
+const hasInternetAccess = memoize(async (): Promise<boolean> => {
+  try {
+    const { default: axiosClient } = await import('src/utils/axios.js')
+    await axiosClient.head('http://1.1.1.1', {
+      signal: AbortSignal.timeout(1000),
+    })
+    return true
+  } catch {
+    return false
+  }
+})
+
+async function isCommandAvailable(command: string): Promise<boolean> {
+  try {
+    // which does not execute the file.
+    return !!(await which(command))
+  } catch {
+    return false
+  }
+}
+
+const detectPackageManagers = memoize(async (): Promise<string[]> => {
+  const packageManagers = []
+
+  if (await isCommandAvailable('npm')) packageManagers.push('npm')
+  if (await isCommandAvailable('yarn')) packageManagers.push('yarn')
+  if (await isCommandAvailable('pnpm')) packageManagers.push('pnpm')
+
+  return packageManagers
+})
+
+const detectRuntimes = memoize(async (): Promise<string[]> => {
+  const runtimes = []
+
+  if (await isCommandAvailable('bun')) runtimes.push('bun')
+  if (await isCommandAvailable('deno')) runtimes.push('deno')
+  if (await isCommandAvailable('node')) runtimes.push('node')
+
+  return runtimes
+})
+
+/**
+ * Checks if we're running in a WSL environment
+ * @returns true if running in WSL, false otherwise
+ */
+const isWslEnvironment = memoize((): boolean => {
+  try {
+    // Check for WSLInterop file which is a reliable indicator of WSL
+    return getFsImplementation().existsSync(
+      '/proc/sys/fs/binfmt_misc/WSLInterop',
+    )
+  } catch (_error) {
+    // If there's an error checking, assume not WSL
+    return false
+  }
+})
+
+/**
+ * Checks if the npm executable is located in the Windows filesystem within WSL
+ * @returns true if npm is from Windows (starts with /mnt/c/), false otherwise
+ */
+const isNpmFromWindowsPath = memoize((): boolean => {
+  try {
+    // Only relevant in WSL environment
+    if (!isWslEnvironment()) {
+      return false
+    }
+
+    // Find the actual npm executable path
+    const { cmd } = findExecutable('npm', [])
+
+    // If npm is in Windows path, it will start with /mnt/c/
+    return cmd.startsWith('/mnt/c/')
+  } catch (_error) {
+    // If there's an error, assume it's not from Windows
+    return false
+  }
+})
+
+/**
+ * Checks if we're running via Conductor
+ * @returns true if running via Conductor, false otherwise
+ */
+function isConductor(): boolean {
+  return process.env.__CFBundleIdentifier === 'com.conductor.app'
+}
+
+export const JETBRAINS_IDES = [
+  'pycharm',
+  'intellij',
+  'webstorm',
+  'phpstorm',
+  'rubymine',
+  'clion',
+  'goland',
+  'rider',
+  'datagrip',
+  'appcode',
+  'dataspell',
+  'aqua',
+  'gateway',
+  'fleet',
+  'jetbrains',
+  'androidstudio',
+]
+
+// Detect terminal type with fallbacks for all platforms
+function detectTerminal(): string | null {
+  if (process.env.CURSOR_TRACE_ID) return 'cursor'
+  // Cursor and Windsurf under WSL have TERM_PROGRAM=vscode
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('cursor')) {
+    return 'cursor'
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('windsurf')) {
+    return 'windsurf'
+  }
+  if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('antigravity')) {
+    return 'antigravity'
+  }
+  const bundleId = process.env.__CFBundleIdentifier?.toLowerCase()
+  if (bundleId?.includes('vscodium')) return 'codium'
+  if (bundleId?.includes('windsurf')) return 'windsurf'
+  if (bundleId?.includes('com.google.android.studio')) return 'androidstudio'
+  // Check for JetBrains IDEs in bundle ID
+  if (bundleId) {
+    for (const ide of JETBRAINS_IDES) {
+      if (bundleId.includes(ide)) return ide
+    }
+  }
+
+  if (process.env.VisualStudioVersion) {
+    // This is desktop Visual Studio, not VS Code
+    return 'visualstudio'
+  }
+
+  // Check for JetBrains terminal on Linux/Windows
+  if (process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm') {
+    // For macOS, bundle ID detection above already handles JetBrains IDEs
+    if (process.platform === 'darwin') return 'pycharm'
+
+    // For finegrained detection on Linux/Windows use envDynamic.getTerminalWithJetBrainsDetection()
+    return 'pycharm'
+  }
+
+  // Check for specific terminals by TERM before TERM_PROGRAM
+  // This handles cases where TERM and TERM_PROGRAM might be inconsistent
+  if (process.env.TERM === 'xterm-ghostty') {
+    return 'ghostty'
+  }
+  if (process.env.TERM?.includes('kitty')) {
+    return 'kitty'
+  }
+
+  if (process.env.TERM_PROGRAM) {
+    return process.env.TERM_PROGRAM
+  }
+
+  if (process.env.TMUX) return 'tmux'
+  if (process.env.STY) return 'screen'
+
+  // Check for terminal-specific environment variables (common on Linux)
+  if (process.env.KONSOLE_VERSION) return 'konsole'
+  if (process.env.GNOME_TERMINAL_SERVICE) return 'gnome-terminal'
+  if (process.env.XTERM_VERSION) return 'xterm'
+  if (process.env.VTE_VERSION) return 'vte-based'
+  if (process.env.TERMINATOR_UUID) return 'terminator'
+  if (process.env.KITTY_WINDOW_ID) {
+    return 'kitty'
+  }
+  if (process.env.ALACRITTY_LOG) return 'alacritty'
+  if (process.env.TILIX_ID) return 'tilix'
+
+  // Windows-specific detection
+  if (process.env.WT_SESSION) return 'windows-terminal'
+  if (process.env.SESSIONNAME && process.env.TERM === 'cygwin') return 'cygwin'
+  if (process.env.MSYSTEM) return process.env.MSYSTEM.toLowerCase() // MINGW64, MSYS2, etc.
+  if (
+    process.env.ConEmuANSI ||
+    process.env.ConEmuPID ||
+    process.env.ConEmuTask
+  ) {
+    return 'conemu'
+  }
+
+  // WSL detection
+  if (process.env.WSL_DISTRO_NAME) return `wsl-${process.env.WSL_DISTRO_NAME}`
+
+  // SSH session detection
+  if (isSSHSession()) {
+    return 'ssh-session'
+  }
+
+  // Fall back to TERM which is more universally available
+  // Special case for common terminal identifiers in TERM
+  if (process.env.TERM) {
+    const term = process.env.TERM
+    if (term.includes('alacritty')) return 'alacritty'
+    if (term.includes('rxvt')) return 'rxvt'
+    if (term.includes('termite')) return 'termite'
+    return process.env.TERM
+  }
+
+  // Detect non-interactive environment
+  if (!process.stdout.isTTY) return 'non-interactive'
+
+  return null
+}
+
+/**
+ * Detects the deployment environment/platform based on environment variables
+ * @returns The deployment platform name, or 'unknown' if not detected
+ */
+export const detectDeploymentEnvironment = memoize((): string => {
+  // Cloud development environments
+  if (isEnvTruthy(process.env.CODESPACES)) return 'codespaces'
+  if (process.env.GITPOD_WORKSPACE_ID) return 'gitpod'
+  if (process.env.REPL_ID || process.env.REPL_SLUG) return 'replit'
+  if (process.env.PROJECT_DOMAIN) return 'glitch'
+
+  // Cloud platforms
+  if (isEnvTruthy(process.env.VERCEL)) return 'vercel'
+  if (
+    process.env.RAILWAY_ENVIRONMENT_NAME ||
+    process.env.RAILWAY_SERVICE_NAME
+  ) {
+    return 'railway'
+  }
+  if (isEnvTruthy(process.env.RENDER)) return 'render'
+  if (isEnvTruthy(process.env.NETLIFY)) return 'netlify'
+  if (process.env.DYNO) return 'heroku'
+  if (process.env.FLY_APP_NAME || process.env.FLY_MACHINE_ID) return 'fly.io'
+  if (isEnvTruthy(process.env.CF_PAGES)) return 'cloudflare-pages'
+  if (process.env.DENO_DEPLOYMENT_ID) return 'deno-deploy'
+  if (process.env.AWS_LAMBDA_FUNCTION_NAME) return 'aws-lambda'
+  if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_FARGATE') return 'aws-fargate'
+  if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_EC2') return 'aws-ecs'
+  // Check for EC2 via hypervisor UUID
+  try {
+    const uuid = getFsImplementation()
+      .readFileSync('/sys/hypervisor/uuid', { encoding: 'utf8' })
+      .trim()
+      .toLowerCase()
+    if (uuid.startsWith('ec2')) return 'aws-ec2'
+  } catch {
+    // Ignore errors reading hypervisor UUID (ENOENT on non-EC2, etc.)
+  }
+  if (process.env.K_SERVICE) return 'gcp-cloud-run'
+  if (process.env.GOOGLE_CLOUD_PROJECT) return 'gcp'
+  if (process.env.WEBSITE_SITE_NAME || process.env.WEBSITE_SKU)
+    return 'azure-app-service'
+  if (process.env.AZURE_FUNCTIONS_ENVIRONMENT) return 'azure-functions'
+  if (process.env.APP_URL?.includes('ondigitalocean.app')) {
+    return 'digitalocean-app-platform'
+  }
+  if (process.env.SPACE_CREATOR_USER_ID) return 'huggingface-spaces'
+
+  // CI/CD platforms
+  if (isEnvTruthy(process.env.GITHUB_ACTIONS)) return 'github-actions'
+  if (isEnvTruthy(process.env.GITLAB_CI)) return 'gitlab-ci'
+  if (process.env.CIRCLECI) return 'circleci'
+  if (process.env.BUILDKITE) return 'buildkite'
+  if (isEnvTruthy(process.env.CI)) return 'ci'
+
+  // Container orchestration
+  if (process.env.KUBERNETES_SERVICE_HOST) return 'kubernetes'
+  try {
+    if (getFsImplementation().existsSync('/.dockerenv')) return 'docker'
+  } catch {
+    // Ignore errors checking for Docker
+  }
+
+  // Platform-specific fallback for undetected environments
+  if (env.platform === 'darwin') return 'unknown-darwin'
+  if (env.platform === 'linux') return 'unknown-linux'
+  if (env.platform === 'win32') return 'unknown-win32'
+
+  return 'unknown'
+})
+
+// all of these should be immutable
+function isSSHSession(): boolean {
+  return !!(
+    process.env.SSH_CONNECTION ||
+    process.env.SSH_CLIENT ||
+    process.env.SSH_TTY
+  )
+}
+
+export const env = {
+  hasInternetAccess,
+  isCI: isEnvTruthy(process.env.CI),
+  platform: (['win32', 'darwin'].includes(process.platform)
+    ? process.platform
+    : 'linux') as Platform,
+  arch: process.arch,
+  nodeVersion: process.version,
+  terminal: detectTerminal(),
+  isSSH: isSSHSession,
+  getPackageManagers: detectPackageManagers,
+  getRuntimes: detectRuntimes,
+  isRunningWithBun: memoize(isRunningWithBun),
+  isWslEnvironment,
+  isNpmFromWindowsPath,
+  isConductor,
+  detectDeploymentEnvironment,
+}
+
+/**
+ * Returns the host platform for analytics reporting.
+ * If CLAUDE_CODE_HOST_PLATFORM is set to a valid platform value, that overrides
+ * the detected platform. This is useful for container/remote environments where
+ * process.platform reports the container OS but the actual host platform differs.
+ */
+export function getHostPlatformForAnalytics(): Platform {
+  const override = process.env.CLAUDE_CODE_HOST_PLATFORM
+  if (override === 'win32' || override === 'darwin' || override === 'linux') {
+    return override
+  }
+  return env.platform
+}