@xortex/xcode 3.0.0

package/utils/user.ts

@@ -0,0 +1,194 @@
+import { execa } from 'execa'
+import memoize from 'lodash-es/memoize.js'
+import { getSessionId } from '../bootstrap/state.js'
+import {
+  getOauthAccountInfo,
+  getRateLimitTier,
+  getSubscriptionType,
+} from './auth.js'
+import { getGlobalConfig, getOrCreateUserID } from './config.js'
+import { getCwd } from './cwd.js'
+import { type env, getHostPlatformForAnalytics } from './env.js'
+import { isEnvTruthy } from './envUtils.js'
+
+// Cache for email fetched asynchronously at startup
+let cachedEmail: string | undefined | null = null // null means not fetched yet
+let emailFetchPromise: Promise<string | undefined> | null = null
+
+/**
+ * GitHub Actions metadata when running in CI
+ */
+export type GitHubActionsMetadata = {
+  actor?: string
+  actorId?: string
+  repository?: string
+  repositoryId?: string
+  repositoryOwner?: string
+  repositoryOwnerId?: string
+}
+
+/**
+ * Core user data used as base for all analytics providers.
+ * This is also the format used by GrowthBook.
+ */
+export type CoreUserData = {
+  deviceId: string
+  sessionId: string
+  email?: string
+  appVersion: string
+  platform: typeof env.platform
+  organizationUuid?: string
+  accountUuid?: string
+  userType?: string
+  subscriptionType?: string
+  rateLimitTier?: string
+  firstTokenTime?: number
+  githubActionsMetadata?: GitHubActionsMetadata
+}
+
+/**
+ * Initialize user data asynchronously. Should be called early in startup.
+ * This pre-fetches the email so getUser() can remain synchronous.
+ */
+export async function initUser(): Promise<void> {
+  if (cachedEmail === null && !emailFetchPromise) {
+    emailFetchPromise = getEmailAsync()
+    cachedEmail = await emailFetchPromise
+    emailFetchPromise = null
+    // Clear memoization cache so next call picks up the email
+    getCoreUserData.cache.clear?.()
+  }
+}
+
+/**
+ * Reset all user data caches. Call on auth changes (login/logout/account switch)
+ * so the next getCoreUserData() call picks up fresh credentials and email.
+ */
+export function resetUserCache(): void {
+  cachedEmail = null
+  emailFetchPromise = null
+  getCoreUserData.cache.clear?.()
+  getGitEmail.cache.clear?.()
+}
+
+/**
+ * Get core user data.
+ * This is the base representation that gets transformed for different analytics providers.
+ */
+export const getCoreUserData = memoize(
+  (includeAnalyticsMetadata?: boolean): CoreUserData => {
+    const deviceId = getOrCreateUserID()
+    const config = getGlobalConfig()
+
+    let subscriptionType: string | undefined
+    let rateLimitTier: string | undefined
+    let firstTokenTime: number | undefined
+    if (includeAnalyticsMetadata) {
+      subscriptionType = getSubscriptionType() ?? undefined
+      rateLimitTier = getRateLimitTier() ?? undefined
+      if (subscriptionType && config.claudeCodeFirstTokenDate) {
+        const configFirstTokenTime = new Date(
+          config.claudeCodeFirstTokenDate,
+        ).getTime()
+        if (!isNaN(configFirstTokenTime)) {
+          firstTokenTime = configFirstTokenTime
+        }
+      }
+    }
+
+    // Only include OAuth account data when actively using OAuth authentication
+    const oauthAccount = getOauthAccountInfo()
+    const organizationUuid = oauthAccount?.organizationUuid
+    const accountUuid = oauthAccount?.accountUuid
+
+    return {
+      deviceId,
+      sessionId: getSessionId(),
+      email: getEmail(),
+      appVersion: MACRO.VERSION,
+      platform: getHostPlatformForAnalytics(),
+      organizationUuid,
+      accountUuid,
+      userType: process.env.USER_TYPE,
+      subscriptionType,
+      rateLimitTier,
+      firstTokenTime,
+      ...(isEnvTruthy(process.env.GITHUB_ACTIONS) && {
+        githubActionsMetadata: {
+          actor: process.env.GITHUB_ACTOR,
+          actorId: process.env.GITHUB_ACTOR_ID,
+          repository: process.env.GITHUB_REPOSITORY,
+          repositoryId: process.env.GITHUB_REPOSITORY_ID,
+          repositoryOwner: process.env.GITHUB_REPOSITORY_OWNER,
+          repositoryOwnerId: process.env.GITHUB_REPOSITORY_OWNER_ID,
+        },
+      }),
+    }
+  },
+)
+
+/**
+ * Get user data for GrowthBook (same as core data with analytics metadata).
+ */
+export function getUserForGrowthBook(): CoreUserData {
+  return getCoreUserData(true)
+}
+
+function getEmail(): string | undefined {
+  // Return cached email if available (from async initialization)
+  if (cachedEmail !== null) {
+    return cachedEmail
+  }
+
+  // Only include OAuth email when actively using OAuth authentication
+  const oauthAccount = getOauthAccountInfo()
+  if (oauthAccount?.emailAddress) {
+    return oauthAccount.emailAddress
+  }
+
+  // Ant-only fallbacks below (no execSync)
+  if (process.env.USER_TYPE !== 'ant') {
+    return undefined
+  }
+
+  if (process.env.COO_CREATOR) {
+    return `${process.env.COO_CREATOR}@anthropic.com`
+  }
+
+  // If initUser() wasn't called, we return undefined instead of blocking
+  return undefined
+}
+
+async function getEmailAsync(): Promise<string | undefined> {
+  // Only include OAuth email when actively using OAuth authentication
+  const oauthAccount = getOauthAccountInfo()
+  if (oauthAccount?.emailAddress) {
+    return oauthAccount.emailAddress
+  }
+
+  // Ant-only fallbacks below
+  if (process.env.USER_TYPE !== 'ant') {
+    return undefined
+  }
+
+  if (process.env.COO_CREATOR) {
+    return `${process.env.COO_CREATOR}@anthropic.com`
+  }
+
+  return getGitEmail()
+}
+
+/**
+ * Get the user's git email from `git config user.email`.
+ * Memoized so the subprocess only spawns once per process.
+ */
+export const getGitEmail = memoize(async (): Promise<string | undefined> => {
+  const result = await execa('git config --get user.email', {
+    shell: true,
+    reject: false,
+    cwd: getCwd(),
+  })
+  return result.exitCode === 0 && result.stdout
+    ? result.stdout.trim()
+    : undefined
+})

package/utils/userAgent.ts

@@ -0,0 +1,10 @@
+/**
+ * User-Agent string helpers.
+ *
+ * Kept dependency-free so SDK-bundled code (bridge, cli/transports) can
+ * import without pulling in auth.ts and its transitive dependency tree.
+ */
+
+export function getClaudeCodeUserAgent(): string {
+  return `claude-code/${MACRO.VERSION}`
+}

package/utils/userPromptKeywords.ts

@@ -0,0 +1,27 @@
+/**
+ * Checks if input matches negative keyword patterns
+ */
+export function matchesNegativeKeyword(input: string): boolean {
+  const lowerInput = input.toLowerCase()
+
+  const negativePattern =
+    /\b(wtf|wth|ffs|omfg|shit(ty|tiest)?|dumbass|horrible|awful|piss(ed|ing)? off|piece of (shit|crap|junk)|what the (fuck|hell)|fucking? (broken|useless|terrible|awful|horrible)|fuck you|screw (this|you)|so frustrating|this sucks|damn it)\b/
+
+  return negativePattern.test(lowerInput)
+}
+
+/**
+ * Checks if input matches keep going/continuation patterns
+ */
+export function matchesKeepGoingKeyword(input: string): boolean {
+  const lowerInput = input.toLowerCase().trim()
+
+  // Match "continue" only if it's the entire prompt
+  if (lowerInput === 'continue') {
+    return true
+  }
+
+  // Match "keep going" or "go on" anywhere in the input
+  const keepGoingPattern = /\b(keep going|go on)\b/
+  return keepGoingPattern.test(lowerInput)
+}

package/utils/uuid.ts

@@ -0,0 +1,27 @@
+import { randomBytes, type UUID } from 'crypto'
+import type { AgentId } from 'src/types/ids.js'
+
+const uuidRegex =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+/**
+ * Validate uuid
+ * @param maybeUUID The value to be checked if it is a uuid
+ * @returns string as UUID or null if it is not valid
+ */
+export function validateUuid(maybeUuid: unknown): UUID | null {
+  // UUID format: 8-4-4-4-12 hex digits
+  if (typeof maybeUuid !== 'string') return null
+
+  return uuidRegex.test(maybeUuid) ? (maybeUuid as UUID) : null
+}
+
+/**
+ * Generate a new agent ID with prefix for consistency with task IDs.
+ * Format: a{label-}{16 hex chars}
+ * Example: aa3f2c1b4d5e6f7a8, acompact-a3f2c1b4d5e6f7a8
+ */
+export function createAgentId(label?: string): AgentId {
+  const suffix = randomBytes(8).toString('hex')
+  return (label ? `a${label}-${suffix}` : `a${suffix}`) as AgentId
+}

package/utils/warningHandler.ts

@@ -0,0 +1,121 @@
+import { posix, win32 } from 'path'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from 'src/services/analytics/index.js'
+import { logForDebugging } from './debug.js'
+import { isEnvTruthy } from './envUtils.js'
+import { getPlatform } from './platform.js'
+
+// Track warnings to avoid spam — bounded to prevent unbounded memory growth
+export const MAX_WARNING_KEYS = 1000
+const warningCounts = new Map<string, number>()
+
+// Check if running from a build directory (development mode)
+// This is a sync version of the logic in getCurrentInstallationType()
+function isRunningFromBuildDirectory(): boolean {
+  let invokedPath = process.argv[1] || ''
+  let execPath = process.execPath || process.argv[0] || ''
+
+  // On Windows, convert backslashes to forward slashes for consistent path matching
+  if (getPlatform() === 'windows') {
+    invokedPath = invokedPath.split(win32.sep).join(posix.sep)
+    execPath = execPath.split(win32.sep).join(posix.sep)
+  }
+
+  const pathsToCheck = [invokedPath, execPath]
+  const buildDirs = [
+    '/build-ant/',
+    '/build-external/',
+    '/build-external-native/',
+    '/build-ant-native/',
+  ]
+
+  return pathsToCheck.some(path => buildDirs.some(dir => path.includes(dir)))
+}
+
+// Warnings we know about and want to suppress from users
+const INTERNAL_WARNINGS = [
+  /MaxListenersExceededWarning.*AbortSignal/,
+  /MaxListenersExceededWarning.*EventTarget/,
+]
+
+function isInternalWarning(warning: Error): boolean {
+  const warningStr = `${warning.name}: ${warning.message}`
+  return INTERNAL_WARNINGS.some(pattern => pattern.test(warningStr))
+}
+
+// Store reference to our warning handler so we can detect if it's already installed
+let warningHandler: ((warning: Error) => void) | null = null
+
+// For testing only - allows resetting the warning handler state
+export function resetWarningHandler(): void {
+  if (warningHandler) {
+    process.removeListener('warning', warningHandler)
+  }
+  warningHandler = null
+  warningCounts.clear()
+}
+
+export function initializeWarningHandler(): void {
+  // Only set up handler once - check if our handler is already installed
+  const currentListeners = process.listeners('warning')
+  if (warningHandler && currentListeners.includes(warningHandler)) {
+    return
+  }
+
+  // For external users, remove default Node.js handler to suppress stderr output
+  // For internal users, only keep default warnings for development builds
+  // Check development mode directly to avoid async call in init
+  // This preserves the same logic as getCurrentInstallationType() without async
+  const isDevelopment =
+    process.env.NODE_ENV === 'development' || isRunningFromBuildDirectory()
+  if (!isDevelopment) {
+    process.removeAllListeners('warning')
+  }
+
+  // Create and store our warning handler
+  warningHandler = (warning: Error) => {
+    try {
+      const warningKey = `${warning.name}: ${warning.message.slice(0, 50)}`
+      const count = warningCounts.get(warningKey) || 0
+
+      // Bound the map to prevent unbounded memory growth from unique warning keys.
+      // Once the cap is reached, new unique keys are not tracked — their
+      // occurrence_count will always be reported as 1 in analytics.
+      if (
+        warningCounts.has(warningKey) ||
+        warningCounts.size < MAX_WARNING_KEYS
+      ) {
+        warningCounts.set(warningKey, count + 1)
+      }
+
+      const isInternal = isInternalWarning(warning)
+
+      // Always log to Statsig for monitoring
+      // Include full details for ant users only, since they may contain code or filepaths
+      logEvent('tengu_node_warning', {
+        is_internal: isInternal ? 1 : 0,
+        occurrence_count: count + 1,
+        classname:
+          warning.name as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        ...(process.env.USER_TYPE === 'ant' && {
+          message:
+            warning.message as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        }),
+      })
+
+      // In debug mode, show all warnings with context
+      if (isEnvTruthy(process.env.CLAUDE_DEBUG)) {
+        const prefix = isInternal ? '[Internal Warning]' : '[Warning]'
+        logForDebugging(`${prefix} ${warning.toString()}`, { level: 'warn' })
+      }
+      // Hide all warnings from users - they are only logged to Statsig for monitoring
+    } catch {
+      // Fail silently - we don't want the warning handler to cause issues
+    }
+  }
+
+  // Install the warning handler
+  process.on('warning', warningHandler)
+}

package/utils/which.ts

@@ -0,0 +1,82 @@
+import { execa } from 'execa'
+import { execSync_DEPRECATED } from './execSyncWrapper.js'
+
+async function whichNodeAsync(command: string): Promise<string | null> {
+  if (process.platform === 'win32') {
+    // On Windows, use where.exe and return the first result
+    const result = await execa(`where.exe ${command}`, {
+      shell: true,
+      stderr: 'ignore',
+      reject: false,
+    })
+    if (result.exitCode !== 0 || !result.stdout) {
+      return null
+    }
+    // where.exe returns multiple paths separated by newlines, return the first
+    return result.stdout.trim().split(/\r?\n/)[0] || null
+  }
+
+  // On POSIX systems (macOS, Linux, WSL), use which
+  // Cross-platform safe: Windows is handled above
+  // eslint-disable-next-line custom-rules/no-cross-platform-process-issues
+  const result = await execa(`which ${command}`, {
+    shell: true,
+    stderr: 'ignore',
+    reject: false,
+  })
+  if (result.exitCode !== 0 || !result.stdout) {
+    return null
+  }
+  return result.stdout.trim()
+}
+
+function whichNodeSync(command: string): string | null {
+  if (process.platform === 'win32') {
+    try {
+      const result = execSync_DEPRECATED(`where.exe ${command}`, {
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      })
+      const output = result.toString().trim()
+      return output.split(/\r?\n/)[0] || null
+    } catch {
+      return null
+    }
+  }
+
+  try {
+    const result = execSync_DEPRECATED(`which ${command}`, {
+      encoding: 'utf-8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    })
+    return result.toString().trim() || null
+  } catch {
+    return null
+  }
+}
+
+const bunWhich =
+  typeof Bun !== 'undefined' && typeof Bun.which === 'function'
+    ? Bun.which
+    : null
+
+/**
+ * Finds the full path to a command executable.
+ * Uses Bun.which when running in Bun (fast, no process spawn),
+ * otherwise spawns the platform-appropriate command.
+ *
+ * @param command - The command name to look up
+ * @returns The full path to the command, or null if not found
+ */
+export const which: (command: string) => Promise<string | null> = bunWhich
+  ? async command => bunWhich(command)
+  : whichNodeAsync
+
+/**
+ * Synchronous version of `which`.
+ *
+ * @param command - The command name to look up
+ * @returns The full path to the command, or null if not found
+ */
+export const whichSync: (command: string) => string | null =
+  bunWhich ?? whichNodeSync

package/utils/windowsPaths.ts

@@ -0,0 +1,173 @@
+import memoize from 'lodash-es/memoize.js'
+import * as path from 'path'
+import * as pathWin32 from 'path/win32'
+import { getCwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+import { execSync_DEPRECATED } from './execSyncWrapper.js'
+import { memoizeWithLRU } from './memoize.js'
+import { getPlatform } from './platform.js'
+
+/**
+ * Check if a file or directory exists on Windows using the dir command
+ * @param path - The path to check
+ * @returns true if the path exists, false otherwise
+ */
+function checkPathExists(path: string): boolean {
+  try {
+    execSync_DEPRECATED(`dir "${path}"`, { stdio: 'pipe' })
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Find an executable using where.exe on Windows
+ * @param executable - The name of the executable to find
+ * @returns The path to the executable or null if not found
+ */
+function findExecutable(executable: string): string | null {
+  // For git, check common installation locations first
+  if (executable === 'git') {
+    const defaultLocations = [
+      // check 64 bit before 32 bit
+      'C:\\Program Files\\Git\\cmd\\git.exe',
+      'C:\\Program Files (x86)\\Git\\cmd\\git.exe',
+      // intentionally don't look for C:\Program Files\Git\mingw64\bin\git.exe
+      // because that directory is the "raw" tools with no environment setup
+    ]
+
+    for (const location of defaultLocations) {
+      if (checkPathExists(location)) {
+        return location
+      }
+    }
+  }
+
+  // Fall back to where.exe
+  try {
+    const result = execSync_DEPRECATED(`where.exe ${executable}`, {
+      stdio: 'pipe',
+      encoding: 'utf8',
+    }).trim()
+
+    // SECURITY: Filter out any results from the current directory
+    // to prevent executing malicious git.bat/cmd/exe files
+    const paths = result.split('\r\n').filter(Boolean)
+    const cwd = getCwd().toLowerCase()
+
+    for (const candidatePath of paths) {
+      // Normalize and compare paths to ensure we're not in current directory
+      const normalizedPath = path.resolve(candidatePath).toLowerCase()
+      const pathDir = path.dirname(normalizedPath).toLowerCase()
+
+      // Skip if the executable is in the current working directory
+      if (pathDir === cwd || normalizedPath.startsWith(cwd + path.sep)) {
+        logForDebugging(
+          `Skipping potentially malicious executable in current directory: ${candidatePath}`,
+        )
+        continue
+      }
+
+      // Return the first valid path that's not in the current directory
+      return candidatePath
+    }
+
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * If Windows, set the SHELL environment variable to git-bash path.
+ * This is used by BashTool and Shell.ts for user shell commands.
+ * COMSPEC is left unchanged for system process execution.
+ */
+export function setShellIfWindows(): void {
+  if (getPlatform() === 'windows') {
+    const gitBashPath = findGitBashPath()
+    process.env.SHELL = gitBashPath
+    logForDebugging(`Using bash path: "${gitBashPath}"`)
+  }
+}
+
+/**
+ * Find the path where `bash.exe` included with git-bash exists, exiting the process if not found.
+ */
+export const findGitBashPath = memoize((): string => {
+  if (process.env.CLAUDE_CODE_GIT_BASH_PATH) {
+    if (checkPathExists(process.env.CLAUDE_CODE_GIT_BASH_PATH)) {
+      return process.env.CLAUDE_CODE_GIT_BASH_PATH
+    }
+    // biome-ignore lint/suspicious/noConsole:: intentional console output
+    console.error(
+      `Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"`,
+    )
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(1)
+  }
+
+  const gitPath = findExecutable('git')
+  if (gitPath) {
+    const bashPath = pathWin32.join(gitPath, '..', '..', 'bin', 'bash.exe')
+    if (checkPathExists(bashPath)) {
+      return bashPath
+    }
+  }
+
+  // biome-ignore lint/suspicious/noConsole:: intentional console output
+  console.error(
+    'Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe',
+  )
+  // eslint-disable-next-line custom-rules/no-process-exit
+  process.exit(1)
+})
+
+/** Convert a Windows path to a POSIX path using pure JS. */
+export const windowsPathToPosixPath = memoizeWithLRU(
+  (windowsPath: string): string => {
+    // Handle UNC paths: \\server\share -> //server/share
+    if (windowsPath.startsWith('\\\\')) {
+      return windowsPath.replace(/\\/g, '/')
+    }
+    // Handle drive letter paths: C:\Users\foo -> /c/Users/foo
+    const match = windowsPath.match(/^([A-Za-z]):[/\\]/)
+    if (match) {
+      const driveLetter = match[1]!.toLowerCase()
+      return '/' + driveLetter + windowsPath.slice(2).replace(/\\/g, '/')
+    }
+    // Already POSIX or relative — just flip slashes
+    return windowsPath.replace(/\\/g, '/')
+  },
+  (p: string) => p,
+  500,
+)
+
+/** Convert a POSIX path to a Windows path using pure JS. */
+export const posixPathToWindowsPath = memoizeWithLRU(
+  (posixPath: string): string => {
+    // Handle UNC paths: //server/share -> \\server\share
+    if (posixPath.startsWith('//')) {
+      return posixPath.replace(/\//g, '\\')
+    }
+    // Handle /cygdrive/c/... format
+    const cygdriveMatch = posixPath.match(/^\/cygdrive\/([A-Za-z])(\/|$)/)
+    if (cygdriveMatch) {
+      const driveLetter = cygdriveMatch[1]!.toUpperCase()
+      const rest = posixPath.slice(('/cygdrive/' + cygdriveMatch[1]).length)
+      return driveLetter + ':' + (rest || '\\').replace(/\//g, '\\')
+    }
+    // Handle /c/... format (MSYS2/Git Bash)
+    const driveMatch = posixPath.match(/^\/([A-Za-z])(\/|$)/)
+    if (driveMatch) {
+      const driveLetter = driveMatch[1]!.toUpperCase()
+      const rest = posixPath.slice(2)
+      return driveLetter + ':' + (rest || '\\').replace(/\//g, '\\')
+    }
+    // Already Windows or relative — just flip slashes
+    return posixPath.replace(/\//g, '\\')
+  },
+  (p: string) => p,
+  500,
+)

package/utils/withResolvers.ts

@@ -0,0 +1,13 @@
+/**
+ * Polyfill for Promise.withResolvers() (ES2024, Node 22+).
+ * package.json declares "engines": { "node": ">=18.0.0" } so we can't use the native one.
+ */
+export function withResolvers<T>(): PromiseWithResolvers<T> {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason?: unknown) => void
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res
+    reject = rej
+  })
+  return { promise, resolve, reject }
+}