@xortex/xcode 3.0.0

package/utils/crossProjectResume.ts

@@ -0,0 +1,75 @@
+import { sep } from 'path'
+import { getOriginalCwd } from '../bootstrap/state.js'
+import type { LogOption } from '../types/logs.js'
+import { quote } from './bash/shellQuote.js'
+import { getSessionIdFromLog } from './sessionStorage.js'
+
+export type CrossProjectResumeResult =
+  | {
+      isCrossProject: false
+    }
+  | {
+      isCrossProject: true
+      isSameRepoWorktree: true
+      projectPath: string
+    }
+  | {
+      isCrossProject: true
+      isSameRepoWorktree: false
+      command: string
+      projectPath: string
+    }
+
+/**
+ * Check if a log is from a different project directory and determine
+ * whether it's a related worktree or a completely different project.
+ *
+ * For same-repo worktrees, we can resume directly without requiring cd.
+ * For different projects, we generate the cd command.
+ */
+export function checkCrossProjectResume(
+  log: LogOption,
+  showAllProjects: boolean,
+  worktreePaths: string[],
+): CrossProjectResumeResult {
+  const currentCwd = getOriginalCwd()
+
+  if (!showAllProjects || !log.projectPath || log.projectPath === currentCwd) {
+    return { isCrossProject: false }
+  }
+
+  // Gate worktree detection to ants only for staged rollout
+  if (process.env.USER_TYPE !== 'ant') {
+    const sessionId = getSessionIdFromLog(log)
+    const command = `cd ${quote([log.projectPath])} && claude --resume ${sessionId}`
+    return {
+      isCrossProject: true,
+      isSameRepoWorktree: false,
+      command,
+      projectPath: log.projectPath,
+    }
+  }
+
+  // Check if log.projectPath is under a worktree of the same repo
+  const isSameRepo = worktreePaths.some(
+    wt => log.projectPath === wt || log.projectPath!.startsWith(wt + sep),
+  )
+
+  if (isSameRepo) {
+    return {
+      isCrossProject: true,
+      isSameRepoWorktree: true,
+      projectPath: log.projectPath,
+    }
+  }
+
+  // Different repo - generate cd command
+  const sessionId = getSessionIdFromLog(log)
+  const command = `cd ${quote([log.projectPath])} && claude --resume ${sessionId}`
+  return {
+    isCrossProject: true,
+    isSameRepoWorktree: false,
+    command,
+    projectPath: log.projectPath,
+  }
+}

package/utils/crypto.ts

@@ -0,0 +1,13 @@
+// Indirection point for the package.json "browser" field. When bun builds
+// browser-sdk.js with --target browser, this file is swapped for
+// crypto.browser.ts — avoiding a ~500KB crypto-browserify polyfill that Bun
+// would otherwise inline for `import ... from 'crypto'`. Node/bun builds use
+// this file unchanged.
+//
+// NOTE: `export { randomUUID } from 'crypto'` (re-export syntax) breaks under
+// bun-internal's bytecode compilation — the generated bytecode shows the
+// import but the binding doesn't link (`ReferenceError: randomUUID is not
+// defined`). The explicit import-then-export below produces a correct live
+// binding. See integration-tests-ant-native failure on PR #20957/#21178.
+import { randomUUID } from 'crypto'
+export { randomUUID }

package/utils/cwd.ts

@@ -0,0 +1,32 @@
+import { AsyncLocalStorage } from 'async_hooks'
+import { getCwdState, getOriginalCwd } from '../bootstrap/state.js'
+
+const cwdOverrideStorage = new AsyncLocalStorage<string>()
+
+/**
+ * Run a function with an overridden working directory for the current async context.
+ * All calls to pwd()/getCwd() within the function (and its async descendants) will
+ * return the overridden cwd instead of the global one. This enables concurrent
+ * agents to each see their own working directory without affecting each other.
+ */
+export function runWithCwdOverride<T>(cwd: string, fn: () => T): T {
+  return cwdOverrideStorage.run(cwd, fn)
+}
+
+/**
+ * Get the current working directory
+ */
+export function pwd(): string {
+  return cwdOverrideStorage.getStore() ?? getCwdState()
+}
+
+/**
+ * Get the current working directory or the original working directory if the current one is not available
+ */
+export function getCwd(): string {
+  try {
+    return pwd()
+  } catch {
+    return getOriginalCwd()
+  }
+}

package/utils/debug.ts

@@ -0,0 +1,268 @@
+import { appendFile, mkdir, symlink, unlink } from 'fs/promises'
+import memoize from 'lodash-es/memoize.js'
+import { dirname, join } from 'path'
+import { getSessionId } from 'src/bootstrap/state.js'
+
+import { type BufferedWriter, createBufferedWriter } from './bufferedWriter.js'
+import { registerCleanup } from './cleanupRegistry.js'
+import {
+  type DebugFilter,
+  parseDebugFilter,
+  shouldShowDebugMessage,
+} from './debugFilter.js'
+import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js'
+import { getFsImplementation } from './fsOperations.js'
+import { writeToStderr } from './process.js'
+import { jsonStringify } from './slowOperations.js'
+
+export type DebugLogLevel = 'verbose' | 'debug' | 'info' | 'warn' | 'error'
+
+const LEVEL_ORDER: Record<DebugLogLevel, number> = {
+  verbose: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4,
+}
+
+/**
+ * Minimum log level to include in debug output. Defaults to 'debug', which
+ * filters out 'verbose' messages. Set CLAUDE_CODE_DEBUG_LOG_LEVEL=verbose to
+ * include high-volume diagnostics (e.g. full statusLine command, shell, cwd,
+ * stdout/stderr) that would otherwise drown out useful debug output.
+ */
+export const getMinDebugLogLevel = memoize((): DebugLogLevel => {
+  const raw = process.env.CLAUDE_CODE_DEBUG_LOG_LEVEL?.toLowerCase().trim()
+  if (raw && Object.hasOwn(LEVEL_ORDER, raw)) {
+    return raw as DebugLogLevel
+  }
+  return 'debug'
+})
+
+let runtimeDebugEnabled = false
+
+export const isDebugMode = memoize((): boolean => {
+  return (
+    runtimeDebugEnabled ||
+    isEnvTruthy(process.env.DEBUG) ||
+    isEnvTruthy(process.env.DEBUG_SDK) ||
+    process.argv.includes('--debug') ||
+    process.argv.includes('-d') ||
+    isDebugToStdErr() ||
+    // Also check for --debug=pattern syntax
+    process.argv.some(arg => arg.startsWith('--debug=')) ||
+    // --debug-file implicitly enables debug mode
+    getDebugFilePath() !== null
+  )
+})
+
+/**
+ * Enables debug logging mid-session (e.g. via /debug). Non-ants don't write
+ * debug logs by default, so this lets them start capturing without restarting
+ * with --debug. Returns true if logging was already active.
+ */
+export function enableDebugLogging(): boolean {
+  const wasActive = isDebugMode() || process.env.USER_TYPE === 'ant'
+  runtimeDebugEnabled = true
+  isDebugMode.cache.clear?.()
+  return wasActive
+}
+
+// Extract and parse debug filter from command line arguments
+// Exported for testing purposes
+export const getDebugFilter = memoize((): DebugFilter | null => {
+  // Look for --debug=pattern in argv
+  const debugArg = process.argv.find(arg => arg.startsWith('--debug='))
+  if (!debugArg) {
+    return null
+  }
+
+  // Extract the pattern after the equals sign
+  const filterPattern = debugArg.substring('--debug='.length)
+  return parseDebugFilter(filterPattern)
+})
+
+export const isDebugToStdErr = memoize((): boolean => {
+  return (
+    process.argv.includes('--debug-to-stderr') || process.argv.includes('-d2e')
+  )
+})
+
+export const getDebugFilePath = memoize((): string | null => {
+  for (let i = 0; i < process.argv.length; i++) {
+    const arg = process.argv[i]!
+    if (arg.startsWith('--debug-file=')) {
+      return arg.substring('--debug-file='.length)
+    }
+    if (arg === '--debug-file' && i + 1 < process.argv.length) {
+      return process.argv[i + 1]!
+    }
+  }
+  return null
+})
+
+function shouldLogDebugMessage(message: string): boolean {
+  if (process.env.NODE_ENV === 'test' && !isDebugToStdErr()) {
+    return false
+  }
+
+  // Non-ants only write debug logs when debug mode is active (via --debug at
+  // startup or /debug mid-session). Ants always log for /share, bug reports.
+  if (process.env.USER_TYPE !== 'ant' && !isDebugMode()) {
+    return false
+  }
+
+  if (
+    typeof process === 'undefined' ||
+    typeof process.versions === 'undefined' ||
+    typeof process.versions.node === 'undefined'
+  ) {
+    return false
+  }
+
+  const filter = getDebugFilter()
+  return shouldShowDebugMessage(message, filter)
+}
+
+let hasFormattedOutput = false
+export function setHasFormattedOutput(value: boolean): void {
+  hasFormattedOutput = value
+}
+export function getHasFormattedOutput(): boolean {
+  return hasFormattedOutput
+}
+
+let debugWriter: BufferedWriter | null = null
+let pendingWrite: Promise<void> = Promise.resolve()
+
+// Module-level so .bind captures only its explicit args, not the
+// writeFn closure's parent scope (Jarred, #22257).
+async function appendAsync(
+  needMkdir: boolean,
+  dir: string,
+  path: string,
+  content: string,
+): Promise<void> {
+  if (needMkdir) {
+    await mkdir(dir, { recursive: true }).catch(() => {})
+  }
+  await appendFile(path, content)
+  void updateLatestDebugLogSymlink()
+}
+
+function noop(): void {}
+
+function getDebugWriter(): BufferedWriter {
+  if (!debugWriter) {
+    let ensuredDir: string | null = null
+    debugWriter = createBufferedWriter({
+      writeFn: content => {
+        const path = getDebugLogPath()
+        const dir = dirname(path)
+        const needMkdir = ensuredDir !== dir
+        ensuredDir = dir
+        if (isDebugMode()) {
+          // immediateMode: must stay sync. Async writes are lost on direct
+          // process.exit() and keep the event loop alive in beforeExit
+          // handlers (infinite loop with Perfetto tracing). See #22257.
+          if (needMkdir) {
+            try {
+              getFsImplementation().mkdirSync(dir)
+            } catch {
+              // Directory already exists
+            }
+          }
+          getFsImplementation().appendFileSync(path, content)
+          void updateLatestDebugLogSymlink()
+          return
+        }
+        // Buffered path (ants without --debug): flushes ~1/sec so chain
+        // depth stays ~1. .bind over a closure so only the bound args are
+        // retained, not this scope.
+        pendingWrite = pendingWrite
+          .then(appendAsync.bind(null, needMkdir, dir, path, content))
+          .catch(noop)
+      },
+      flushIntervalMs: 1000,
+      maxBufferSize: 100,
+      immediateMode: isDebugMode(),
+    })
+    registerCleanup(async () => {
+      debugWriter?.dispose()
+      await pendingWrite
+    })
+  }
+  return debugWriter
+}
+
+export async function flushDebugLogs(): Promise<void> {
+  debugWriter?.flush()
+  await pendingWrite
+}
+
+export function logForDebugging(
+  message: string,
+  { level }: { level: DebugLogLevel } = {
+    level: 'debug',
+  },
+): void {
+  if (LEVEL_ORDER[level] < LEVEL_ORDER[getMinDebugLogLevel()]) {
+    return
+  }
+  if (!shouldLogDebugMessage(message)) {
+    return
+  }
+
+  // Multiline messages break the jsonl output format, so make any multiline messages JSON.
+  if (hasFormattedOutput && message.includes('\n')) {
+    message = jsonStringify(message)
+  }
+  const timestamp = new Date().toISOString()
+  const output = `${timestamp} [${level.toUpperCase()}] ${message.trim()}\n`
+  if (isDebugToStdErr()) {
+    writeToStderr(output)
+    return
+  }
+
+  getDebugWriter().write(output)
+}
+
+export function getDebugLogPath(): string {
+  return (
+    getDebugFilePath() ??
+    process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ??
+    join(getClaudeConfigHomeDir(), 'debug', `${getSessionId()}.txt`)
+  )
+}
+
+/**
+ * Updates the latest debug log symlink to point to the current debug log file.
+ * Creates or updates a symlink at ~/.claude/debug/latest
+ */
+const updateLatestDebugLogSymlink = memoize(async (): Promise<void> => {
+  try {
+    const debugLogPath = getDebugLogPath()
+    const debugLogsDir = dirname(debugLogPath)
+    const latestSymlinkPath = join(debugLogsDir, 'latest')
+
+    await unlink(latestSymlinkPath).catch(() => {})
+    await symlink(debugLogPath, latestSymlinkPath)
+  } catch {
+    // Silently fail if symlink creation fails
+  }
+})
+
+/**
+ * Logs errors for Ants only, always visible in production.
+ */
+export function logAntError(context: string, error: unknown): void {
+  if (process.env.USER_TYPE !== 'ant') {
+    return
+  }
+
+  if (error instanceof Error && error.stack) {
+    logForDebugging(`[ANT-ONLY] ${context} stack trace:\n${error.stack}`, {
+      level: 'error',
+    })
+  }
+}

package/utils/debugFilter.ts

@@ -0,0 +1,157 @@
+import memoize from 'lodash-es/memoize.js'
+
+export type DebugFilter = {
+  include: string[]
+  exclude: string[]
+  isExclusive: boolean
+}
+
+/**
+ * Parse debug filter string into a filter configuration
+ * Examples:
+ * - "api,hooks" -> include only api and hooks categories
+ * - "!1p,!file" -> exclude logging and file categories
+ * - undefined/empty -> no filtering (show all)
+ */
+export const parseDebugFilter = memoize(
+  (filterString?: string): DebugFilter | null => {
+    if (!filterString || filterString.trim() === '') {
+      return null
+    }
+
+    const filters = filterString
+      .split(',')
+      .map(f => f.trim())
+      .filter(Boolean)
+
+    // If no valid filters remain, return null
+    if (filters.length === 0) {
+      return null
+    }
+
+    // Check for mixed inclusive/exclusive filters
+    const hasExclusive = filters.some(f => f.startsWith('!'))
+    const hasInclusive = filters.some(f => !f.startsWith('!'))
+
+    if (hasExclusive && hasInclusive) {
+      // For now, we'll treat this as an error case and show all messages
+      // Log error using logForDebugging to avoid console.error lint rule
+      // We'll import and use it later when the circular dependency is resolved
+      // For now, just return null silently
+      return null
+    }
+
+    // Clean up filters (remove ! prefix) and normalize
+    const cleanFilters = filters.map(f => f.replace(/^!/, '').toLowerCase())
+
+    return {
+      include: hasExclusive ? [] : cleanFilters,
+      exclude: hasExclusive ? cleanFilters : [],
+      isExclusive: hasExclusive,
+    }
+  },
+)
+
+/**
+ * Extract debug categories from a message
+ * Supports multiple patterns:
+ * - "category: message" -> ["category"]
+ * - "[CATEGORY] message" -> ["category"]
+ * - "MCP server \"name\": message" -> ["mcp", "name"]
+ * - "[ANT-ONLY] 1P event: tengu_timer" -> ["ant-only", "1p"]
+ *
+ * Returns lowercase categories for case-insensitive matching
+ */
+export function extractDebugCategories(message: string): string[] {
+  const categories: string[] = []
+
+  // Pattern 3: MCP server "servername" - Check this first to avoid false positives
+  const mcpMatch = message.match(/^MCP server ["']([^"']+)["']/)
+  if (mcpMatch && mcpMatch[1]) {
+    categories.push('mcp')
+    categories.push(mcpMatch[1].toLowerCase())
+  } else {
+    // Pattern 1: "category: message" (simple prefix) - only if not MCP pattern
+    const prefixMatch = message.match(/^([^:[]+):/)
+    if (prefixMatch && prefixMatch[1]) {
+      categories.push(prefixMatch[1].trim().toLowerCase())
+    }
+  }
+
+  // Pattern 2: [CATEGORY] at the start
+  const bracketMatch = message.match(/^\[([^\]]+)]/)
+  if (bracketMatch && bracketMatch[1]) {
+    categories.push(bracketMatch[1].trim().toLowerCase())
+  }
+
+  // Pattern 4: Check for additional categories in the message
+  // e.g., "[ANT-ONLY] 1P event: tengu_timer" should match both "ant-only" and "1p"
+  if (message.toLowerCase().includes('1p event:')) {
+    categories.push('1p')
+  }
+
+  // Pattern 5: Look for secondary categories after the first pattern
+  // e.g., "AutoUpdaterWrapper: Installation type: development"
+  const secondaryMatch = message.match(
+    /:\s*([^:]+?)(?:\s+(?:type|mode|status|event))?:/,
+  )
+  if (secondaryMatch && secondaryMatch[1]) {
+    const secondary = secondaryMatch[1].trim().toLowerCase()
+    // Only add if it's a reasonable category name (not too long, no spaces)
+    if (secondary.length < 30 && !secondary.includes(' ')) {
+      categories.push(secondary)
+    }
+  }
+
+  // If no categories found, return empty array (uncategorized)
+  return Array.from(new Set(categories)) // Remove duplicates
+}
+
+/**
+ * Check if debug message should be shown based on filter
+ * @param categories - Categories extracted from the message
+ * @param filter - Parsed filter configuration
+ * @returns true if message should be shown
+ */
+export function shouldShowDebugCategories(
+  categories: string[],
+  filter: DebugFilter | null,
+): boolean {
+  // No filter means show everything
+  if (!filter) {
+    return true
+  }
+
+  // If no categories found, handle based on filter mode
+  if (categories.length === 0) {
+    // In exclusive mode, uncategorized messages are excluded by default for security
+    // In inclusive mode, uncategorized messages are excluded (must match a category)
+    return false
+  }
+
+  if (filter.isExclusive) {
+    // Exclusive mode: show if none of the categories are in the exclude list
+    return !categories.some(cat => filter.exclude.includes(cat))
+  } else {
+    // Inclusive mode: show if any of the categories are in the include list
+    return categories.some(cat => filter.include.includes(cat))
+  }
+}
+
+/**
+ * Main function to check if a debug message should be shown
+ * Combines extraction and filtering
+ */
+export function shouldShowDebugMessage(
+  message: string,
+  filter: DebugFilter | null,
+): boolean {
+  // Fast path: no filter means show everything
+  if (!filter) {
+    return true
+  }
+
+  // Only extract categories if we have a filter
+  const categories = extractDebugCategories(message)
+  return shouldShowDebugCategories(categories, filter)
+}

package/utils/deepLink/banner.ts

@@ -0,0 +1,123 @@
+/**
+ * Deep Link Origin Banner
+ *
+ * Builds the warning text shown when a session was opened by an external
+ * claude-cli:// deep link. Linux xdg-open and browsers with "always allow"
+ * set dispatch the link with no OS-level confirmation, so the application
+ * provides its own provenance signal — mirroring claude.ai's security
+ * interstitial for external-source prefills.
+ *
+ * The user must press Enter to submit; this banner primes them to read the
+ * prompt (which may use homoglyphs or padding to hide instructions) and
+ * notice which directory — and therefore which CLAUDE.md — was loaded.
+ */
+
+import { stat } from 'fs/promises'
+import { homedir } from 'os'
+import { join, sep } from 'path'
+import { formatNumber, formatRelativeTimeAgo } from '../format.js'
+import { getCommonDir } from '../git/gitFilesystem.js'
+import { getGitDir } from '../git.js'
+
+const STALE_FETCH_WARN_MS = 7 * 24 * 60 * 60 * 1000
+
+/**
+ * Above this length, a pre-filled prompt no longer fits on one screen
+ * (~12-15 lines on an 80-col terminal). The banner switches from "review
+ * carefully" to an explicit "scroll to review the entire prompt" so a
+ * malicious tail buried past line 60 isn't silently off-screen.
+ */
+const LONG_PREFILL_THRESHOLD = 1000
+
+export type DeepLinkBannerInfo = {
+  /** Resolved working directory the session launched in. */
+  cwd: string
+  /** Length of the ?q= prompt pre-filled in the input box. Undefined = no prefill. */
+  prefillLength?: number
+  /** The ?repo= slug if the cwd was resolved from the githubRepoPaths MRU. */
+  repo?: string
+  /** Last-fetch timestamp for the repo (FETCH_HEAD mtime). Undefined = never fetched or not a git repo. */
+  lastFetch?: Date
+}
+
+/**
+ * Build the multi-line warning banner for a deep-link-originated session.
+ *
+ * Always shows the working directory so the user can see which CLAUDE.md
+ * will load. When the link pre-filled a prompt, adds a second line prompting
+ * the user to review it — the prompt itself is visible in the input box.
+ *
+ * When the cwd was resolved from a ?repo= slug, also shows the slug and the
+ * clone's last-fetch age so the user knows which local clone was selected
+ * and whether its CLAUDE.md may be stale relative to upstream.
+ */
+export function buildDeepLinkBanner(info: DeepLinkBannerInfo): string {
+  const lines = [
+    `This session was opened by an external deep link in ${tildify(info.cwd)}`,
+  ]
+  if (info.repo) {
+    const age = info.lastFetch ? formatRelativeTimeAgo(info.lastFetch) : 'never'
+    const stale =
+      !info.lastFetch ||
+      Date.now() - info.lastFetch.getTime() > STALE_FETCH_WARN_MS
+    lines.push(
+      `Resolved ${info.repo} from local clones · last fetched ${age}${stale ? ' — CLAUDE.md may be stale' : ''}`,
+    )
+  }
+  if (info.prefillLength) {
+    lines.push(
+      info.prefillLength > LONG_PREFILL_THRESHOLD
+        ? `The prompt below (${formatNumber(info.prefillLength)} chars) was supplied by the link — scroll to review the entire prompt before pressing Enter.`
+        : 'The prompt below was supplied by the link — review carefully before pressing Enter.',
+    )
+  }
+  return lines.join('\n')
+}
+
+/**
+ * Read the mtime of .git/FETCH_HEAD, which git updates on every fetch or
+ * pull. Returns undefined if the directory is not a git repo or has never
+ * been fetched.
+ *
+ * FETCH_HEAD is per-worktree — fetching from the main worktree does not
+ * touch a sibling worktree's FETCH_HEAD. When cwd is a worktree, we check
+ * both and return whichever is newer so a recently-fetched main repo
+ * doesn't read as "never fetched" just because the deep link landed in
+ * a worktree.
+ */
+export async function readLastFetchTime(
+  cwd: string,
+): Promise<Date | undefined> {
+  const gitDir = await getGitDir(cwd)
+  if (!gitDir) return undefined
+  const commonDir = await getCommonDir(gitDir)
+  const [local, common] = await Promise.all([
+    mtimeOrUndefined(join(gitDir, 'FETCH_HEAD')),
+    commonDir
+      ? mtimeOrUndefined(join(commonDir, 'FETCH_HEAD'))
+      : Promise.resolve(undefined),
+  ])
+  if (local && common) return local > common ? local : common
+  return local ?? common
+}
+
+async function mtimeOrUndefined(p: string): Promise<Date | undefined> {
+  try {
+    const { mtime } = await stat(p)
+    return mtime
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Shorten home-dir-prefixed paths to ~ notation for the banner.
+ * Not using getDisplayPath() because cwd is the current working directory,
+ * so the relative-path branch would collapse it to the empty string.
+ */
+function tildify(p: string): string {
+  const home = homedir()
+  if (p === home) return '~'
+  if (p.startsWith(home + sep)) return '~' + p.slice(home.length)
+  return p
+}