@xortex/xcode 3.0.0

package/utils/horizontalScroll.ts

@@ -0,0 +1,137 @@
+export type HorizontalScrollWindow = {
+  startIndex: number
+  endIndex: number
+  showLeftArrow: boolean
+  showRightArrow: boolean
+}
+
+/**
+ * Calculate the visible window of items that fit within available width,
+ * ensuring the selected item is always visible. Uses edge-based scrolling:
+ * the window only scrolls when the selected item would be outside the visible
+ * range, and positions the selected item at the edge (not centered).
+ *
+ * @param itemWidths - Array of item widths (each width should include separator if applicable)
+ * @param availableWidth - Total available width for items
+ * @param arrowWidth - Width of scroll indicator arrow (including space)
+ * @param selectedIdx - Index of selected item (must stay visible)
+ * @param firstItemHasSeparator - Whether first item's width includes a separator that should be ignored
+ * @returns Visible window bounds and whether to show scroll arrows
+ */
+export function calculateHorizontalScrollWindow(
+  itemWidths: number[],
+  availableWidth: number,
+  arrowWidth: number,
+  selectedIdx: number,
+  firstItemHasSeparator = true,
+): HorizontalScrollWindow {
+  const totalItems = itemWidths.length
+
+  if (totalItems === 0) {
+    return {
+      startIndex: 0,
+      endIndex: 0,
+      showLeftArrow: false,
+      showRightArrow: false,
+    }
+  }
+
+  // Clamp selectedIdx to valid range
+  const clampedSelected = Math.max(0, Math.min(selectedIdx, totalItems - 1))
+
+  // If all items fit, show them all
+  const totalWidth = itemWidths.reduce((sum, w) => sum + w, 0)
+  if (totalWidth <= availableWidth) {
+    return {
+      startIndex: 0,
+      endIndex: totalItems,
+      showLeftArrow: false,
+      showRightArrow: false,
+    }
+  }
+
+  // Calculate cumulative widths for efficient range calculations
+  const cumulativeWidths: number[] = [0]
+  for (let i = 0; i < totalItems; i++) {
+    cumulativeWidths.push(cumulativeWidths[i]! + itemWidths[i]!)
+  }
+
+  // Helper to get width of range [start, end)
+  function rangeWidth(start: number, end: number): number {
+    const baseWidth = cumulativeWidths[end]! - cumulativeWidths[start]!
+    // When starting after index 0 and first item has separator baked in,
+    // subtract 1 because we don't render leading separator on first visible item
+    if (firstItemHasSeparator && start > 0) {
+      return baseWidth - 1
+    }
+    return baseWidth
+  }
+
+  // Calculate effective available width based on whether we'll show arrows
+  function getEffectiveWidth(start: number, end: number): number {
+    let width = availableWidth
+    if (start > 0) width -= arrowWidth // left arrow
+    if (end < totalItems) width -= arrowWidth // right arrow
+    return width
+  }
+
+  // Edge-based scrolling: Start from the beginning and only scroll when necessary
+  // First, calculate how many items fit starting from index 0
+  let startIndex = 0
+  let endIndex = 1
+
+  // Expand from start as much as possible
+  while (
+    endIndex < totalItems &&
+    rangeWidth(startIndex, endIndex + 1) <=
+      getEffectiveWidth(startIndex, endIndex + 1)
+  ) {
+    endIndex++
+  }
+
+  // If selected is within visible range, we're done
+  if (clampedSelected >= startIndex && clampedSelected < endIndex) {
+    return {
+      startIndex,
+      endIndex,
+      showLeftArrow: startIndex > 0,
+      showRightArrow: endIndex < totalItems,
+    }
+  }
+
+  // Selected is outside visible range - need to scroll
+  if (clampedSelected >= endIndex) {
+    // Selected is to the right - scroll so selected is at the right edge
+    endIndex = clampedSelected + 1
+    startIndex = clampedSelected
+
+    // Expand left as much as possible (selected stays at right edge)
+    while (
+      startIndex > 0 &&
+      rangeWidth(startIndex - 1, endIndex) <=
+        getEffectiveWidth(startIndex - 1, endIndex)
+    ) {
+      startIndex--
+    }
+  } else {
+    // Selected is to the left - scroll so selected is at the left edge
+    startIndex = clampedSelected
+    endIndex = clampedSelected + 1
+
+    // Expand right as much as possible (selected stays at left edge)
+    while (
+      endIndex < totalItems &&
+      rangeWidth(startIndex, endIndex + 1) <=
+        getEffectiveWidth(startIndex, endIndex + 1)
+    ) {
+      endIndex++
+    }
+  }
+
+  return {
+    startIndex,
+    endIndex,
+    showLeftArrow: startIndex > 0,
+    showRightArrow: endIndex < totalItems,
+  }
+}

package/utils/http.ts

@@ -0,0 +1,136 @@
+/**
+ * HTTP utility constants and helpers
+ */
+
+import axios from 'src/utils/axios.js'
+import { OAUTH_BETA_HEADER } from '../constants/oauth.js'
+import {
+  getAnthropicApiKey,
+  getClaudeAIOAuthTokens,
+  handleOAuth401Error,
+  isClaudeAISubscriber,
+} from './auth.js'
+import { getClaudeCodeUserAgent } from './userAgent.js'
+import { getWorkload } from './workloadContext.js'
+
+// WARNING: We rely on `claude-cli` in the user agent for log filtering.
+// Please do NOT change this without making sure that logging also gets updated!
+export function getUserAgent(): string {
+  const agentSdkVersion = process.env.CLAUDE_AGENT_SDK_VERSION
+    ? `, agent-sdk/${process.env.CLAUDE_AGENT_SDK_VERSION}`
+    : ''
+  // SDK consumers can identify their app/library via CLAUDE_AGENT_SDK_CLIENT_APP
+  // e.g., "my-app/1.0.0" or "my-library/2.1"
+  const clientApp = process.env.CLAUDE_AGENT_SDK_CLIENT_APP
+    ? `, client-app/${process.env.CLAUDE_AGENT_SDK_CLIENT_APP}`
+    : ''
+  // Turn-/process-scoped workload tag for cron-initiated requests. 1P-only
+  // observability — proxies strip HTTP headers; QoS routing uses cc_workload
+  // in the billing-header attribution block instead (see constants/system.ts).
+  // getAnthropicClient (client.ts:98) calls this per-request inside withRetry,
+  // so the read picks up the same setWorkload() value as getAttributionHeader.
+  const workload = getWorkload()
+  const workloadSuffix = workload ? `, workload/${workload}` : ''
+  return `claude-cli/${MACRO.VERSION} (${process.env.USER_TYPE}, ${process.env.CLAUDE_CODE_ENTRYPOINT ?? 'cli'}${agentSdkVersion}${clientApp}${workloadSuffix})`
+}
+
+export function getMCPUserAgent(): string {
+  const parts: string[] = []
+  if (process.env.CLAUDE_CODE_ENTRYPOINT) {
+    parts.push(process.env.CLAUDE_CODE_ENTRYPOINT)
+  }
+  if (process.env.CLAUDE_AGENT_SDK_VERSION) {
+    parts.push(`agent-sdk/${process.env.CLAUDE_AGENT_SDK_VERSION}`)
+  }
+  if (process.env.CLAUDE_AGENT_SDK_CLIENT_APP) {
+    parts.push(`client-app/${process.env.CLAUDE_AGENT_SDK_CLIENT_APP}`)
+  }
+  const suffix = parts.length > 0 ? ` (${parts.join(', ')})` : ''
+  return `claude-code/${MACRO.VERSION}${suffix}`
+}
+
+// User-Agent for WebFetch requests to arbitrary sites. `Claude-User` is
+// Anthropic's publicly documented agent for user-initiated fetches (what site
+// operators match in robots.txt); the claude-code suffix lets them distinguish
+// local CLI traffic from claude.ai server-side fetches.
+export function getWebFetchUserAgent(): string {
+  return `Claude-User (${getClaudeCodeUserAgent()}; +https://support.anthropic.com/)`
+}
+
+export type AuthHeaders = {
+  headers: Record<string, string>
+  error?: string
+}
+
+/**
+ * Get authentication headers for API requests
+ * Returns either OAuth headers for Max/Pro users or API key headers for regular users
+ */
+export function getAuthHeaders(): AuthHeaders {
+  if (isClaudeAISubscriber()) {
+    const oauthTokens = getClaudeAIOAuthTokens()
+    if (!oauthTokens?.accessToken) {
+      return {
+        headers: {},
+        error: 'No OAuth token available',
+      }
+    }
+    return {
+      headers: {
+        Authorization: `Bearer ${oauthTokens.accessToken}`,
+        'anthropic-beta': OAUTH_BETA_HEADER,
+      },
+    }
+  }
+  // TODO: this will fail if the API key is being set to an LLM Gateway key
+  // should we try to query keychain / credentials for a valid Anthropic key?
+  const apiKey = getAnthropicApiKey()
+  if (!apiKey) {
+    return {
+      headers: {},
+      error: 'No API key available',
+    }
+  }
+  return {
+    headers: {
+      'x-api-key': apiKey,
+    },
+  }
+}
+
+/**
+ * Wrapper that handles OAuth 401 errors by force-refreshing the token and
+ * retrying once. Addresses clock drift scenarios where the local expiration
+ * check disagrees with the server.
+ *
+ * The request closure is called again on retry, so it should re-read auth
+ * (e.g., via getAuthHeaders()) to pick up the refreshed token.
+ *
+ * Note: bridgeApi.ts has its own DI-injected version — handleOAuth401Error
+ * transitively pulls in config.ts (~1300 modules), which breaks the SDK bundle.
+ *
+ * @param opts.also403Revoked - Also retry on 403 with "OAuth token has been
+ *   revoked" body (some endpoints signal revocation this way instead of 401).
+ */
+export async function withOAuth401Retry<T>(
+  request: () => Promise<T>,
+  opts?: { also403Revoked?: boolean },
+): Promise<T> {
+  try {
+    return await request()
+  } catch (err) {
+    if (!axios.isAxiosError(err)) throw err
+    const status = err.response?.status
+    const isAuthError =
+      status === 401 ||
+      (opts?.also403Revoked &&
+        status === 403 &&
+        typeof err.response?.data === 'string' &&
+        err.response.data.includes('OAuth token has been revoked'))
+    if (!isAuthError) throw err
+    const failedAccessToken = getClaudeAIOAuthTokens()?.accessToken
+    if (!failedAccessToken) throw err
+    await handleOAuth401Error(failedAccessToken)
+    return await request()
+  }
+}

package/utils/hyperlink.ts

@@ -0,0 +1,39 @@
+import chalk from 'chalk'
+import { supportsHyperlinks } from '../ink/supports-hyperlinks.js'
+
+// OSC 8 hyperlink escape sequences
+// Format: \e]8;;URL\e\\TEXT\e]8;;\e\\
+// Using \x07 (BEL) as terminator which is more widely supported
+export const OSC8_START = '\x1b]8;;'
+export const OSC8_END = '\x07'
+
+type HyperlinkOptions = {
+  supportsHyperlinks?: boolean
+}
+
+/**
+ * Create a clickable hyperlink using OSC 8 escape sequences.
+ * Falls back to plain text if the terminal doesn't support hyperlinks.
+ *
+ * @param url - The URL to link to
+ * @param content - Optional content to display as the link text (only when hyperlinks are supported).
+ *                  If provided and hyperlinks are supported, this text is shown as a clickable link.
+ *                  If hyperlinks are not supported, content is ignored and only the URL is shown.
+ * @param options - Optional overrides for testing (supportsHyperlinks)
+ */
+export function createHyperlink(
+  url: string,
+  content?: string,
+  options?: HyperlinkOptions,
+): string {
+  const hasSupport = options?.supportsHyperlinks ?? supportsHyperlinks()
+  if (!hasSupport) {
+    return url
+  }
+
+  // Apply basic ANSI blue color - wrap-ansi preserves this across line breaks
+  // RGB colors (like theme colors) are NOT preserved by wrap-ansi with OSC 8
+  const displayText = content ?? url
+  const coloredText = chalk.blue(displayText)
+  return `${OSC8_START}${url}${OSC8_END}${coloredText}${OSC8_START}${OSC8_END}`
+}

package/utils/iTermBackup.ts

@@ -0,0 +1,73 @@
+import { copyFile, stat } from 'fs/promises'
+import { homedir } from 'os'
+import { join } from 'path'
+import { getGlobalConfig, saveGlobalConfig } from './config.js'
+import { logError } from './log.js'
+
+export function markITerm2SetupComplete(): void {
+  saveGlobalConfig(current => ({
+    ...current,
+    iterm2SetupInProgress: false,
+  }))
+}
+
+function getIterm2RecoveryInfo(): {
+  inProgress: boolean
+  backupPath: string | null
+} {
+  const config = getGlobalConfig()
+  return {
+    inProgress: config.iterm2SetupInProgress ?? false,
+    backupPath: config.iterm2BackupPath || null,
+  }
+}
+
+function getITerm2PlistPath(): string {
+  return join(
+    homedir(),
+    'Library',
+    'Preferences',
+    'com.googlecode.iterm2.plist',
+  )
+}
+
+type RestoreResult =
+  | {
+      status: 'restored' | 'no_backup'
+    }
+  | {
+      status: 'failed'
+      backupPath: string
+    }
+
+export async function checkAndRestoreITerm2Backup(): Promise<RestoreResult> {
+  const { inProgress, backupPath } = getIterm2RecoveryInfo()
+  if (!inProgress) {
+    return { status: 'no_backup' }
+  }
+
+  if (!backupPath) {
+    markITerm2SetupComplete()
+    return { status: 'no_backup' }
+  }
+
+  try {
+    await stat(backupPath)
+  } catch {
+    markITerm2SetupComplete()
+    return { status: 'no_backup' }
+  }
+
+  try {
+    await copyFile(backupPath, getITerm2PlistPath())
+
+    markITerm2SetupComplete()
+    return { status: 'restored' }
+  } catch (restoreError) {
+    logError(
+      new Error(`Failed to restore iTerm2 settings with: ${restoreError}`),
+    )
+    markITerm2SetupComplete()
+    return { status: 'failed', backupPath }
+  }
+}