@xortex/xcode 3.0.0

package/services/preventSleep.ts

@@ -0,0 +1,165 @@
+/**
+ * Prevents macOS from sleeping while Claude is working.
+ *
+ * Uses the built-in `caffeinate` command to create a power assertion that
+ * prevents idle sleep. This keeps the Mac awake during API requests and
+ * tool execution so long-running operations don't get interrupted.
+ *
+ * The caffeinate process is spawned with a timeout and periodically restarted.
+ * This provides self-healing behavior: if the Node process is killed with
+ * SIGKILL (which doesn't run cleanup handlers), the orphaned caffeinate will
+ * automatically exit after the timeout expires.
+ *
+ * Only runs on macOS - no-op on other platforms.
+ */
+import { type ChildProcess, spawn } from 'child_process'
+import { registerCleanup } from '../utils/cleanupRegistry.js'
+import { logForDebugging } from '../utils/debug.js'
+
+// Caffeinate timeout in seconds. Process auto-exits after this duration.
+// We restart it before expiry to maintain continuous sleep prevention.
+const CAFFEINATE_TIMEOUT_SECONDS = 300 // 5 minutes
+
+// Restart interval - restart caffeinate before it expires.
+// Use 4 minutes to give plenty of buffer before the 5 minute timeout.
+const RESTART_INTERVAL_MS = 4 * 60 * 1000
+
+let caffeinateProcess: ChildProcess | null = null
+let restartInterval: ReturnType<typeof setInterval> | null = null
+let refCount = 0
+let cleanupRegistered = false
+
+/**
+ * Increment the reference count and start preventing sleep if needed.
+ * Call this when starting work that should keep the Mac awake.
+ */
+export function startPreventSleep(): void {
+  refCount++
+
+  if (refCount === 1) {
+    spawnCaffeinate()
+    startRestartInterval()
+  }
+}
+
+/**
+ * Decrement the reference count and allow sleep if no more work is pending.
+ * Call this when work completes.
+ */
+export function stopPreventSleep(): void {
+  if (refCount > 0) {
+    refCount--
+  }
+
+  if (refCount === 0) {
+    stopRestartInterval()
+    killCaffeinate()
+  }
+}
+
+/**
+ * Force stop preventing sleep, regardless of reference count.
+ * Use this for cleanup on exit.
+ */
+export function forceStopPreventSleep(): void {
+  refCount = 0
+  stopRestartInterval()
+  killCaffeinate()
+}
+
+function startRestartInterval(): void {
+  // Only run on macOS
+  if (process.platform !== 'darwin') {
+    return
+  }
+
+  // Already running
+  if (restartInterval !== null) {
+    return
+  }
+
+  restartInterval = setInterval(() => {
+    // Only restart if we still need sleep prevention
+    if (refCount > 0) {
+      logForDebugging('Restarting caffeinate to maintain sleep prevention')
+      killCaffeinate()
+      spawnCaffeinate()
+    }
+  }, RESTART_INTERVAL_MS)
+
+  // Don't let the interval keep the Node process alive
+  restartInterval.unref()
+}
+
+function stopRestartInterval(): void {
+  if (restartInterval !== null) {
+    clearInterval(restartInterval)
+    restartInterval = null
+  }
+}
+
+function spawnCaffeinate(): void {
+  // Only run on macOS
+  if (process.platform !== 'darwin') {
+    return
+  }
+
+  // Already running
+  if (caffeinateProcess !== null) {
+    return
+  }
+
+  // Register cleanup on first use to ensure caffeinate is killed on exit
+  if (!cleanupRegistered) {
+    cleanupRegistered = true
+    registerCleanup(async () => {
+      forceStopPreventSleep()
+    })
+  }
+
+  try {
+    // -i: Create an assertion to prevent idle sleep
+    //     This is the least aggressive option - display can still sleep
+    // -t: Timeout in seconds - caffeinate exits automatically after this
+    //     This provides self-healing if Node is killed with SIGKILL
+    caffeinateProcess = spawn(
+      'caffeinate',
+      ['-i', '-t', String(CAFFEINATE_TIMEOUT_SECONDS)],
+      {
+        stdio: 'ignore',
+      },
+    )
+
+    // Don't let caffeinate keep the Node process alive
+    caffeinateProcess.unref()
+
+    const thisProc = caffeinateProcess
+    caffeinateProcess.on('error', err => {
+      logForDebugging(`caffeinate spawn error: ${err.message}`)
+      if (caffeinateProcess === thisProc) caffeinateProcess = null
+    })
+
+    caffeinateProcess.on('exit', () => {
+      if (caffeinateProcess === thisProc) caffeinateProcess = null
+    })
+
+    logForDebugging('Started caffeinate to prevent sleep')
+  } catch {
+    // Silently fail - caffeinate not available or spawn failed
+    caffeinateProcess = null
+  }
+}
+
+function killCaffeinate(): void {
+  if (caffeinateProcess !== null) {
+    const proc = caffeinateProcess
+    caffeinateProcess = null
+    try {
+      // SIGKILL for immediate termination - SIGTERM could be delayed
+      proc.kill('SIGKILL')
+      logForDebugging('Stopped caffeinate, allowing sleep')
+    } catch {
+      // Process may have already exited
+    }
+  }
+}

package/services/rateLimitMessages.ts

@@ -0,0 +1,344 @@
+/**
+ * Centralized rate limit message generation
+ * Single source of truth for all rate limit-related messages
+ */
+
+import {
+  getOauthAccountInfo,
+  getSubscriptionType,
+  isOverageProvisioningAllowed,
+} from '../utils/auth.js'
+import { hasClaudeAiBillingAccess } from '../utils/billing.js'
+import { formatResetTime } from '../utils/format.js'
+import type { ClaudeAILimits } from './claudeAiLimits.js'
+
+const FEEDBACK_CHANNEL_ANT = '#briarpatch-cc'
+
+/**
+ * All possible rate limit error message prefixes
+ * Export this to avoid fragile string matching in UI components
+ */
+export const RATE_LIMIT_ERROR_PREFIXES = [
+  "You've hit your",
+  "You've used",
+  "You're now using extra usage",
+  "You're close to",
+  "You're out of extra usage",
+] as const
+
+/**
+ * Check if a message is a rate limit error
+ */
+export function isRateLimitErrorMessage(text: string): boolean {
+  return RATE_LIMIT_ERROR_PREFIXES.some(prefix => text.startsWith(prefix))
+}
+
+export type RateLimitMessage = {
+  message: string
+  severity: 'error' | 'warning'
+}
+
+/**
+ * Get the appropriate rate limit message based on limit state
+ * Returns null if no message should be shown
+ */
+export function getRateLimitMessage(
+  limits: ClaudeAILimits,
+  model: string,
+): RateLimitMessage | null {
+  // Check overage scenarios first (when subscription is rejected but overage is available)
+  // getUsingOverageText is rendered separately from warning.
+  if (limits.isUsingOverage) {
+    // Show warning if approaching overage spending limit
+    if (limits.overageStatus === 'allowed_warning') {
+      return {
+        message: "You're close to your extra usage spending limit",
+        severity: 'warning',
+      }
+    }
+    return null
+  }
+
+  // ERROR STATES - when limits are rejected
+  if (limits.status === 'rejected') {
+    return { message: getLimitReachedText(limits, model), severity: 'error' }
+  }
+
+  // WARNING STATES - when approaching limits with early warning
+  if (limits.status === 'allowed_warning') {
+    // Only show warnings when utilization is above threshold (70%)
+    // This prevents false warnings after week reset when API may send
+    // allowed_warning with stale data at low usage levels
+    const WARNING_THRESHOLD = 0.7
+    if (
+      limits.utilization !== undefined &&
+      limits.utilization < WARNING_THRESHOLD
+    ) {
+      return null
+    }
+
+    // Don't warn non-billing Team/Enterprise users about approaching plan limits
+    // if overages are enabled - they'll seamlessly roll into overage
+    const subscriptionType = getSubscriptionType()
+    const isTeamOrEnterprise =
+      subscriptionType === 'team' || subscriptionType === 'enterprise'
+    const hasExtraUsageEnabled =
+      getOauthAccountInfo()?.hasExtraUsageEnabled === true
+
+    if (
+      isTeamOrEnterprise &&
+      hasExtraUsageEnabled &&
+      !hasClaudeAiBillingAccess()
+    ) {
+      return null
+    }
+
+    const text = getEarlyWarningText(limits)
+    if (text) {
+      return { message: text, severity: 'warning' }
+    }
+  }
+
+  // No message needed
+  return null
+}
+
+/**
+ * Get error message for API errors (used in errors.ts)
+ * Returns the message string or null if no error message should be shown
+ */
+export function getRateLimitErrorMessage(
+  limits: ClaudeAILimits,
+  model: string,
+): string | null {
+  const message = getRateLimitMessage(limits, model)
+
+  // Only return error messages, not warnings
+  if (message && message.severity === 'error') {
+    return message.message
+  }
+
+  return null
+}
+
+/**
+ * Get warning message for UI footer
+ * Returns the warning message string or null if no warning should be shown
+ */
+export function getRateLimitWarning(
+  limits: ClaudeAILimits,
+  model: string,
+): string | null {
+  const message = getRateLimitMessage(limits, model)
+
+  // Only return warnings for the footer - errors are shown in AssistantTextMessages
+  if (message && message.severity === 'warning') {
+    return message.message
+  }
+
+  // Don't show errors in the footer
+  return null
+}
+
+function getLimitReachedText(limits: ClaudeAILimits, model: string): string {
+  const resetsAt = limits.resetsAt
+  const resetTime = resetsAt ? formatResetTime(resetsAt, true) : undefined
+  const overageResetTime = limits.overageResetsAt
+    ? formatResetTime(limits.overageResetsAt, true)
+    : undefined
+  const resetMessage = resetTime ? ` · resets ${resetTime}` : ''
+
+  // if BOTH subscription (checked before this method) and overage are exhausted
+  if (limits.overageStatus === 'rejected') {
+    // Show the earliest reset time to indicate when user can resume
+    let overageResetMessage = ''
+    if (resetsAt && limits.overageResetsAt) {
+      // Both timestamps present - use the earlier one
+      if (resetsAt < limits.overageResetsAt) {
+        overageResetMessage = ` · resets ${resetTime}`
+      } else {
+        overageResetMessage = ` · resets ${overageResetTime}`
+      }
+    } else if (resetTime) {
+      overageResetMessage = ` · resets ${resetTime}`
+    } else if (overageResetTime) {
+      overageResetMessage = ` · resets ${overageResetTime}`
+    }
+
+    if (limits.overageDisabledReason === 'out_of_credits') {
+      return `You're out of extra usage${overageResetMessage}`
+    }
+
+    return formatLimitReachedText('limit', overageResetMessage, model)
+  }
+
+  if (limits.rateLimitType === 'seven_day_sonnet') {
+    const subscriptionType = getSubscriptionType()
+    const isProOrEnterprise =
+      subscriptionType === 'pro' || subscriptionType === 'enterprise'
+    // For pro and enterprise, Sonnet limit is the same as weekly
+    const limit = isProOrEnterprise ? 'weekly limit' : 'Sonnet limit'
+    return formatLimitReachedText(limit, resetMessage, model)
+  }
+
+  if (limits.rateLimitType === 'seven_day_opus') {
+    return formatLimitReachedText('Opus limit', resetMessage, model)
+  }
+
+  if (limits.rateLimitType === 'seven_day') {
+    return formatLimitReachedText('weekly limit', resetMessage, model)
+  }
+
+  if (limits.rateLimitType === 'five_hour') {
+    return formatLimitReachedText('session limit', resetMessage, model)
+  }
+
+  return formatLimitReachedText('usage limit', resetMessage, model)
+}
+
+function getEarlyWarningText(limits: ClaudeAILimits): string | null {
+  let limitName: string | null = null
+  switch (limits.rateLimitType) {
+    case 'seven_day':
+      limitName = 'weekly limit'
+      break
+    case 'five_hour':
+      limitName = 'session limit'
+      break
+    case 'seven_day_opus':
+      limitName = 'Opus limit'
+      break
+    case 'seven_day_sonnet':
+      limitName = 'Sonnet limit'
+      break
+    case 'overage':
+      limitName = 'extra usage'
+      break
+    case undefined:
+      return null
+  }
+
+  // utilization and resetsAt should be defined since early warning is calculated with them
+  const used = limits.utilization
+    ? Math.floor(limits.utilization * 100)
+    : undefined
+  const resetTime = limits.resetsAt
+    ? formatResetTime(limits.resetsAt, true)
+    : undefined
+
+  // Get upsell command based on subscription type and limit type
+  const upsell = getWarningUpsellText(limits.rateLimitType)
+
+  if (used && resetTime) {
+    const base = `You've used ${used}% of your ${limitName} · resets ${resetTime}`
+    return upsell ? `${base} · ${upsell}` : base
+  }
+
+  if (used) {
+    const base = `You've used ${used}% of your ${limitName}`
+    return upsell ? `${base} · ${upsell}` : base
+  }
+
+  if (limits.rateLimitType === 'overage') {
+    // For the "Approaching <x>" verbiage, "extra usage limit" makes more sense than "extra usage"
+    limitName += ' limit'
+  }
+
+  if (resetTime) {
+    const base = `Approaching ${limitName} · resets ${resetTime}`
+    return upsell ? `${base} · ${upsell}` : base
+  }
+
+  const base = `Approaching ${limitName}`
+  return upsell ? `${base} · ${upsell}` : base
+}
+
+/**
+ * Get the upsell command text for warning messages based on subscription and limit type.
+ * Returns null if no upsell should be shown.
+ * Only used for warnings because actual rate limit hits will see an interactive menu of options.
+ */
+function getWarningUpsellText(
+  rateLimitType: ClaudeAILimits['rateLimitType'],
+): string | null {
+  const subscriptionType = getSubscriptionType()
+  const hasExtraUsageEnabled =
+    getOauthAccountInfo()?.hasExtraUsageEnabled === true
+
+  // 5-hour session limit warning
+  if (rateLimitType === 'five_hour') {
+    // Teams/Enterprise with overages disabled: prompt to request extra usage
+    // Only show if overage provisioning is allowed for this org type (e.g., not AWS marketplace)
+    if (subscriptionType === 'team' || subscriptionType === 'enterprise') {
+      if (!hasExtraUsageEnabled && isOverageProvisioningAllowed()) {
+        return '/extra-usage to request more'
+      }
+      // Teams/Enterprise with overages enabled or unsupported billing type don't need upsell
+      return null
+    }
+
+    // Pro/Max users: prompt to upgrade
+    if (subscriptionType === 'pro' || subscriptionType === 'max') {
+      return '/upgrade to keep using Claude Code'
+    }
+  }
+
+  // Overage warning (approaching spending limit)
+  if (rateLimitType === 'overage') {
+    if (subscriptionType === 'team' || subscriptionType === 'enterprise') {
+      if (!hasExtraUsageEnabled && isOverageProvisioningAllowed()) {
+        return '/extra-usage to request more'
+      }
+    }
+  }
+
+  // Weekly limit warnings don't show upsell per spec
+  return null
+}
+
+/**
+ * Get notification text for overage mode transitions
+ * Used for transient notifications when entering overage mode
+ */
+export function getUsingOverageText(limits: ClaudeAILimits): string {
+  const resetTime = limits.resetsAt
+    ? formatResetTime(limits.resetsAt, true)
+    : ''
+
+  let limitName = ''
+  if (limits.rateLimitType === 'five_hour') {
+    limitName = 'session limit'
+  } else if (limits.rateLimitType === 'seven_day') {
+    limitName = 'weekly limit'
+  } else if (limits.rateLimitType === 'seven_day_opus') {
+    limitName = 'Opus limit'
+  } else if (limits.rateLimitType === 'seven_day_sonnet') {
+    const subscriptionType = getSubscriptionType()
+    const isProOrEnterprise =
+      subscriptionType === 'pro' || subscriptionType === 'enterprise'
+    // For pro and enterprise, Sonnet limit is the same as weekly
+    limitName = isProOrEnterprise ? 'weekly limit' : 'Sonnet limit'
+  }
+
+  if (!limitName) {
+    return 'Now using extra usage'
+  }
+
+  const resetMessage = resetTime
+    ? ` · Your ${limitName} resets ${resetTime}`
+    : ''
+  return `You're now using extra usage${resetMessage}`
+}
+
+function formatLimitReachedText(
+  limit: string,
+  resetMessage: string,
+  _model: string,
+): string {
+  // Enhanced messaging for Ant users
+  if (process.env.USER_TYPE === 'ant') {
+    return `You've hit your ${limit}${resetMessage}. If you have feedback about this limit, post in ${FEEDBACK_CHANNEL_ANT}. You can reset your limits with /reset-limits`
+  }
+
+  return `You've hit your ${limit}${resetMessage}`
+}

package/services/rateLimitMocking.ts

@@ -0,0 +1,144 @@
+/**
+ * Facade for rate limit header processing
+ * This isolates mock logic from production code
+ */
+
+import { APIError } from '@anthropic-ai/sdk'
+import {
+  applyMockHeaders,
+  checkMockFastModeRateLimit,
+  getMockHeaderless429Message,
+  getMockHeaders,
+  isMockFastModeRateLimitScenario,
+  shouldProcessMockLimits,
+} from './mockRateLimits.js'
+
+/**
+ * Process headers, applying mocks if /mock-limits command is active
+ */
+export function processRateLimitHeaders(
+  headers: globalThis.Headers,
+): globalThis.Headers {
+  // Only apply mocks for Ant employees using /mock-limits command
+  if (shouldProcessMockLimits()) {
+    return applyMockHeaders(headers)
+  }
+  return headers
+}
+
+/**
+ * Check if we should process rate limits (either real subscriber or /mock-limits command)
+ */
+export function shouldProcessRateLimits(isSubscriber: boolean): boolean {
+  return isSubscriber || shouldProcessMockLimits()
+}
+
+/**
+ * Check if mock rate limits should throw a 429 error
+ * Returns the error to throw, or null if no error should be thrown
+ * @param currentModel The model being used for the current request
+ * @param isFastModeActive Whether fast mode is currently active (for fast-mode-only mocks)
+ */
+export function checkMockRateLimitError(
+  currentModel: string,
+  isFastModeActive?: boolean,
+): APIError | null {
+  if (!shouldProcessMockLimits()) {
+    return null
+  }
+
+  const headerlessMessage = getMockHeaderless429Message()
+  if (headerlessMessage) {
+    return new APIError(
+      429,
+      { error: { type: 'rate_limit_error', message: headerlessMessage } },
+      headerlessMessage,
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      new globalThis.Headers(),
+    )
+  }
+
+  const mockHeaders = getMockHeaders()
+  if (!mockHeaders) {
+    return null
+  }
+
+  // Check if we should throw a 429 error
+  // Only throw if:
+  // 1. Status is rejected AND
+  // 2. Either no overage headers OR overage is also rejected
+  // 3. For Opus-specific limits, only throw if actually using an Opus model
+  const status = mockHeaders['anthropic-ratelimit-unified-status']
+  const overageStatus =
+    mockHeaders['anthropic-ratelimit-unified-overage-status']
+  const rateLimitType =
+    mockHeaders['anthropic-ratelimit-unified-representative-claim']
+
+  // Check if this is an Opus-specific rate limit
+  const isOpusLimit = rateLimitType === 'seven_day_opus'
+
+  // Check if current model is an Opus model (handles all variants including aliases)
+  const isUsingOpus = currentModel.includes('opus')
+
+  // For Opus limits, only throw 429 if actually using Opus
+  // This simulates the real API behavior where fallback to Sonnet succeeds
+  if (isOpusLimit && !isUsingOpus) {
+    return null
+  }
+
+  // Check for mock fast mode rate limits (handles expiry, countdown, etc.)
+  if (isMockFastModeRateLimitScenario()) {
+    const fastModeHeaders = checkMockFastModeRateLimit(isFastModeActive)
+    if (fastModeHeaders === null) {
+      return null
+    }
+    // Create a mock 429 error with the fast mode headers
+    const error = new APIError(
+      429,
+      { error: { type: 'rate_limit_error', message: 'Rate limit exceeded' } },
+      'Rate limit exceeded',
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      new globalThis.Headers(
+        Object.entries(fastModeHeaders).filter(([_, v]) => v !== undefined) as [
+          string,
+          string,
+        ][],
+      ),
+    )
+    return error
+  }
+
+  const shouldThrow429 =
+    status === 'rejected' && (!overageStatus || overageStatus === 'rejected')
+
+  if (shouldThrow429) {
+    // Create a mock 429 error with the appropriate headers
+    const error = new APIError(
+      429,
+      { error: { type: 'rate_limit_error', message: 'Rate limit exceeded' } },
+      'Rate limit exceeded',
+      // eslint-disable-next-line eslint-plugin-n/no-unsupported-features/node-builtins
+      new globalThis.Headers(
+        Object.entries(mockHeaders).filter(([_, v]) => v !== undefined) as [
+          string,
+          string,
+        ][],
+      ),
+    )
+    return error
+  }
+
+  return null
+}
+
+/**
+ * Check if this is a mock 429 error that shouldn't be retried
+ */
+export function isMockRateLimitError(error: APIError): boolean {
+  return shouldProcessMockLimits() && error.status === 429
+}
+
+/**
+ * Check if /mock-limits command is currently active (for UI purposes)
+ */
+export { shouldProcessMockLimits }