@xortex/xcode 3.0.0

package/utils/log.ts

@@ -0,0 +1,362 @@
+import { feature } from 'bun:bundle'
+import type { BetaMessageStreamParams } from '@anthropic-ai/sdk/resources/beta/messages/messages.mjs'
+import { readdir, readFile, stat } from 'fs/promises'
+import memoize from 'lodash-es/memoize.js'
+import { join } from 'path'
+import type { QuerySource } from 'src/constants/querySource.js'
+import {
+  setLastAPIRequest,
+  setLastAPIRequestMessages,
+} from '../bootstrap/state.js'
+import { TICK_TAG } from '../constants/xml.js'
+import {
+  type LogOption,
+  type SerializedMessage,
+  sortLogs,
+} from '../types/logs.js'
+import { CACHE_PATHS } from './cachePaths.js'
+import { stripDisplayTags, stripDisplayTagsAllowEmpty } from './displayTags.js'
+import { isEnvTruthy } from './envUtils.js'
+import { toError } from './errors.js'
+import { isEssentialTrafficOnly } from './privacyLevel.js'
+import { jsonParse } from './slowOperations.js'
+
+/**
+ * Gets the display title for a log/session with fallback logic.
+ * Skips firstPrompt if it starts with a tick/goal tag (autonomous mode auto-prompt).
+ * Strips display-unfriendly tags (like <ide_opened_file>) from the result.
+ * Falls back to a truncated session ID when no other title is available.
+ */
+export function getLogDisplayTitle(
+  log: LogOption,
+  defaultTitle?: string,
+): string {
+  // Skip firstPrompt if it's a tick/goal message (autonomous mode auto-prompt)
+  const isAutonomousPrompt = log.firstPrompt?.startsWith(`<${TICK_TAG}>`)
+  // Strip display-unfriendly tags (command-name, ide_opened_file, etc.) early
+  // so that command-only prompts (e.g. /clear) become empty and fall through
+  // to the next fallback instead of showing raw XML tags.
+  // Note: stripDisplayTags returns the original when stripping yields empty,
+  // so we call stripDisplayTagsAllowEmpty to detect command-only prompts.
+  const strippedFirstPrompt = log.firstPrompt
+    ? stripDisplayTagsAllowEmpty(log.firstPrompt)
+    : ''
+  const useFirstPrompt = strippedFirstPrompt && !isAutonomousPrompt
+  const title =
+    log.agentName ||
+    log.customTitle ||
+    log.summary ||
+    (useFirstPrompt ? strippedFirstPrompt : undefined) ||
+    defaultTitle ||
+    // For autonomous sessions without other context, show a meaningful label
+    (isAutonomousPrompt ? 'Autonomous session' : undefined) ||
+    // Fall back to truncated session ID for lite logs with no metadata
+    (log.sessionId ? log.sessionId.slice(0, 8) : '') ||
+    ''
+  // Strip display-unfriendly tags (like <ide_opened_file>) for cleaner titles
+  return stripDisplayTags(title).trim()
+}
+
+export function dateToFilename(date: Date): string {
+  return date.toISOString().replace(/[:.]/g, '-')
+}
+
+// In-memory error log for recent errors
+// Moved from bootstrap/state.ts to break import cycle
+const MAX_IN_MEMORY_ERRORS = 100
+let inMemoryErrorLog: Array<{ error: string; timestamp: string }> = []
+
+function addToInMemoryErrorLog(errorInfo: {
+  error: string
+  timestamp: string
+}): void {
+  if (inMemoryErrorLog.length >= MAX_IN_MEMORY_ERRORS) {
+    inMemoryErrorLog.shift() // Remove oldest error
+  }
+  inMemoryErrorLog.push(errorInfo)
+}
+
+/**
+ * Sink interface for the error logging backend
+ */
+export type ErrorLogSink = {
+  logError: (error: Error) => void
+  logMCPError: (serverName: string, error: unknown) => void
+  logMCPDebug: (serverName: string, message: string) => void
+  getErrorsPath: () => string
+  getMCPLogsPath: (serverName: string) => string
+}
+
+// Queued events for events logged before sink is attached
+type QueuedErrorEvent =
+  | { type: 'error'; error: Error }
+  | { type: 'mcpError'; serverName: string; error: unknown }
+  | { type: 'mcpDebug'; serverName: string; message: string }
+
+const errorQueue: QueuedErrorEvent[] = []
+
+// Sink - initialized during app startup
+let errorLogSink: ErrorLogSink | null = null
+
+/**
+ * Attach the error log sink that will receive all error events.
+ * Queued events are drained immediately to ensure no errors are lost.
+ *
+ * Idempotent: if a sink is already attached, this is a no-op. This allows
+ * calling from both the preAction hook (for subcommands) and setup() (for
+ * the default command) without coordination.
+ */
+export function attachErrorLogSink(newSink: ErrorLogSink): void {
+  if (errorLogSink !== null) {
+    return
+  }
+  errorLogSink = newSink
+
+  // Drain the queue immediately - errors should not be delayed
+  if (errorQueue.length > 0) {
+    const queuedEvents = [...errorQueue]
+    errorQueue.length = 0
+
+    for (const event of queuedEvents) {
+      switch (event.type) {
+        case 'error':
+          errorLogSink.logError(event.error)
+          break
+        case 'mcpError':
+          errorLogSink.logMCPError(event.serverName, event.error)
+          break
+        case 'mcpDebug':
+          errorLogSink.logMCPDebug(event.serverName, event.message)
+          break
+      }
+    }
+  }
+}
+
+/**
+ * Logs an error to multiple destinations for debugging and monitoring.
+ *
+ * This function logs errors to:
+ * - Debug logs (visible via `claude --debug` or `tail -f ~/.claude/debug/latest`)
+ * - In-memory error log (accessible via `getInMemoryErrors()`, useful for including
+ *   in bug reports or displaying recent errors to users)
+ * - Persistent error log file (only for internal 'ant' users, stored in ~/.claude/errors/)
+ *
+ * Usage:
+ * ```ts
+ * logError(new Error('Failed to connect'))
+ * ```
+ *
+ * To view errors:
+ * - Debug: Run `claude --debug` or `tail -f ~/.claude/debug/latest`
+ * - In-memory: Call `getInMemoryErrors()` to get recent errors for the current session
+ */
+const isHardFailMode = memoize((): boolean => {
+  return process.argv.includes('--hard-fail')
+})
+
+export function logError(error: unknown): void {
+  const err = toError(error)
+  if (feature('HARD_FAIL') && isHardFailMode()) {
+    // biome-ignore lint/suspicious/noConsole:: intentional crash output
+    console.error('[HARD FAIL] logError called with:', err.stack || err.message)
+    // eslint-disable-next-line custom-rules/no-process-exit
+    process.exit(1)
+  }
+  try {
+    // Check if error reporting should be disabled
+    if (
+      // Cloud providers (Bedrock/Vertex/Foundry) always disable features
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_BEDROCK) ||
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_VERTEX) ||
+      isEnvTruthy(process.env.CLAUDE_CODE_USE_FOUNDRY) ||
+      process.env.DISABLE_ERROR_REPORTING ||
+      isEssentialTrafficOnly()
+    ) {
+      return
+    }
+
+    const errorStr = err.stack || err.message
+
+    const errorInfo = {
+      error: errorStr,
+      timestamp: new Date().toISOString(),
+    }
+
+    // Always add to in-memory log (no dependencies needed)
+    addToInMemoryErrorLog(errorInfo)
+
+    // If sink not attached, queue the event
+    if (errorLogSink === null) {
+      errorQueue.push({ type: 'error', error: err })
+      return
+    }
+
+    errorLogSink.logError(err)
+  } catch {
+    // pass
+  }
+}
+
+export function getInMemoryErrors(): { error: string; timestamp: string }[] {
+  return [...inMemoryErrorLog]
+}
+
+/**
+ * Loads the list of error logs
+ * @returns List of error logs sorted by date
+ */
+export function loadErrorLogs(): Promise<LogOption[]> {
+  return loadLogList(CACHE_PATHS.errors())
+}
+
+/**
+ * Gets an error log by its index
+ * @param index Index in the sorted list of logs (0-based)
+ * @returns Log data or null if not found
+ */
+export async function getErrorLogByIndex(
+  index: number,
+): Promise<LogOption | null> {
+  const logs = await loadErrorLogs()
+  return logs[index] || null
+}
+
+/**
+ * Internal function to load and process logs from a specified path
+ * @param path Directory containing logs
+ * @returns Array of logs sorted by date
+ * @private
+ */
+async function loadLogList(path: string): Promise<LogOption[]> {
+  let files: Awaited<ReturnType<typeof readdir>>
+  try {
+    files = await readdir(path, { withFileTypes: true })
+  } catch {
+    logError(new Error(`No logs found at ${path}`))
+    return []
+  }
+  const logData = await Promise.all(
+    files.map(async (file, i) => {
+      const fullPath = join(path, file.name)
+      const content = await readFile(fullPath, { encoding: 'utf8' })
+      const messages = jsonParse(content) as SerializedMessage[]
+      const firstMessage = messages[0]
+      const lastMessage = messages[messages.length - 1]
+      const firstPrompt =
+        firstMessage?.type === 'user' &&
+        typeof firstMessage?.message?.content === 'string'
+          ? firstMessage?.message?.content
+          : 'No prompt'
+
+      // For new random filenames, we'll get stats from the file itself
+      const fileStats = await stat(fullPath)
+
+      // Check if it's a sidechain by looking at filename
+      const isSidechain = fullPath.includes('sidechain')
+
+      // For new files, use the file modified time as date
+      const date = dateToFilename(fileStats.mtime)
+
+      return {
+        date,
+        fullPath,
+        messages,
+        value: i, // hack: overwritten after sorting, right below this
+        created: parseISOString(firstMessage?.timestamp || date),
+        modified: lastMessage?.timestamp
+          ? parseISOString(lastMessage.timestamp)
+          : parseISOString(date),
+        firstPrompt:
+          firstPrompt.split('\n')[0]?.slice(0, 50) +
+            (firstPrompt.length > 50 ? '…' : '') || 'No prompt',
+        messageCount: messages.length,
+        isSidechain,
+      }
+    }),
+  )
+
+  return sortLogs(logData.filter(_ => _ !== null)).map((_, i) => ({
+    ..._,
+    value: i,
+  }))
+}
+
+function parseISOString(s: string): Date {
+  const b = s.split(/\D+/)
+  return new Date(
+    Date.UTC(
+      parseInt(b[0]!, 10),
+      parseInt(b[1]!, 10) - 1,
+      parseInt(b[2]!, 10),
+      parseInt(b[3]!, 10),
+      parseInt(b[4]!, 10),
+      parseInt(b[5]!, 10),
+      parseInt(b[6]!, 10),
+    ),
+  )
+}
+
+export function logMCPError(serverName: string, error: unknown): void {
+  try {
+    // If sink not attached, queue the event
+    if (errorLogSink === null) {
+      errorQueue.push({ type: 'mcpError', serverName, error })
+      return
+    }
+
+    errorLogSink.logMCPError(serverName, error)
+  } catch {
+    // Silently fail
+  }
+}
+
+export function logMCPDebug(serverName: string, message: string): void {
+  try {
+    // If sink not attached, queue the event
+    if (errorLogSink === null) {
+      errorQueue.push({ type: 'mcpDebug', serverName, message })
+      return
+    }
+
+    errorLogSink.logMCPDebug(serverName, message)
+  } catch {
+    // Silently fail
+  }
+}
+
+/**
+ * Captures the last API request for inclusion in bug reports.
+ */
+export function captureAPIRequest(
+  params: BetaMessageStreamParams,
+  querySource?: QuerySource,
+): void {
+  // startsWith, not exact match — users with non-default output styles get
+  // variants like 'repl_main_thread:outputStyle:Explanatory' (querySource.ts).
+  if (!querySource || !querySource.startsWith('repl_main_thread')) {
+    return
+  }
+
+  // Store params WITHOUT messages to avoid retaining the entire conversation
+  // for all users. Messages are already persisted to the transcript file and
+  // available via React state.
+  const { messages, ...paramsWithoutMessages } = params
+  setLastAPIRequest(paramsWithoutMessages)
+  // For ant users only: also keep a reference to the final messages array so
+  // /share's serialized_conversation.json captures the exact post-compaction,
+  // CLAUDE.md-injected payload the API received. Overwritten each turn;
+  // dumpPrompts.ts already holds 5 full request bodies for ants, so this is
+  // not a new retention class.
+  setLastAPIRequestMessages(process.env.USER_TYPE === 'ant' ? messages : null)
+}
+
+/**
+ * Reset error log state for testing purposes only.
+ * @internal
+ */
+export function _resetErrorLogForTesting(): void {
+  errorLogSink = null
+  errorQueue.length = 0
+  inMemoryErrorLog = []
+}

package/utils/logoV2Utils.ts

@@ -0,0 +1,347 @@
+import { getDirectConnectServerUrl, getSessionId } from '../bootstrap/state.js'
+import { stringWidth } from '../ink/stringWidth.js'
+import type { LogOption } from '../types/logs.js'
+import { getSubscriptionName, isClaudeAISubscriber } from './auth.js'
+import { getCwd } from './cwd.js'
+import { getDisplayPath } from './file.js'
+import {
+  truncate,
+  truncateToWidth,
+  truncateToWidthNoEllipsis,
+} from './format.js'
+import { getStoredChangelogFromMemory, parseChangelog } from './releaseNotes.js'
+import { gt } from './semver.js'
+import { loadMessageLogs } from './sessionStorage.js'
+import { getInitialSettings } from './settings/settings.js'
+
+// Layout constants
+const MAX_LEFT_WIDTH = 50
+const MAX_USERNAME_LENGTH = 20
+const BORDER_PADDING = 4
+const DIVIDER_WIDTH = 1
+const CONTENT_PADDING = 2
+
+export type LayoutMode = 'horizontal' | 'compact'
+
+export type LayoutDimensions = {
+  leftWidth: number
+  rightWidth: number
+  totalWidth: number
+}
+
+/**
+ * Determines the layout mode based on terminal width
+ */
+export function getLayoutMode(columns: number): LayoutMode {
+  if (columns >= 70) return 'horizontal'
+  return 'compact'
+}
+
+/**
+ * Calculates layout dimensions for the LogoV2 component
+ */
+export function calculateLayoutDimensions(
+  columns: number,
+  layoutMode: LayoutMode,
+  optimalLeftWidth: number,
+): LayoutDimensions {
+  if (layoutMode === 'horizontal') {
+    const leftWidth = optimalLeftWidth
+    const usedSpace =
+      BORDER_PADDING + CONTENT_PADDING + DIVIDER_WIDTH + leftWidth
+    const availableForRight = columns - usedSpace
+
+    let rightWidth = Math.max(30, availableForRight)
+    const totalWidth = Math.min(
+      leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING,
+      columns - BORDER_PADDING,
+    )
+
+    // Recalculate right width if we had to cap the total
+    if (totalWidth < leftWidth + rightWidth + DIVIDER_WIDTH + CONTENT_PADDING) {
+      rightWidth = totalWidth - leftWidth - DIVIDER_WIDTH - CONTENT_PADDING
+    }
+
+    return { leftWidth, rightWidth, totalWidth }
+  }
+
+  // Vertical mode
+  const totalWidth = Math.min(columns - BORDER_PADDING, MAX_LEFT_WIDTH + 20)
+  return {
+    leftWidth: totalWidth,
+    rightWidth: totalWidth,
+    totalWidth,
+  }
+}
+
+/**
+ * Calculates optimal left panel width based on content
+ */
+export function calculateOptimalLeftWidth(
+  welcomeMessage: string,
+  truncatedCwd: string,
+  modelLine: string,
+): number {
+  const contentWidth = Math.max(
+    stringWidth(welcomeMessage),
+    stringWidth(truncatedCwd),
+    stringWidth(modelLine),
+    20, // Minimum for clawd art
+  )
+  return Math.min(contentWidth + 4, MAX_LEFT_WIDTH) // +4 for padding
+}
+
+/**
+ * Formats the welcome message based on username
+ */
+export function formatWelcomeMessage(username: string | null): string {
+  return 'Welcome to Xcode now you have persistent memory.';
+}
+
+/**
+ * Truncates a path in the middle if it's too long.
+ * Width-aware: uses stringWidth() for correct CJK/emoji measurement.
+ */
+export function truncatePath(path: string, maxLength: number): string {
+  if (stringWidth(path) <= maxLength) return path
+
+  const separator = '/'
+  const ellipsis = '…'
+  const ellipsisWidth = 1 // '…' is always 1 column
+  const separatorWidth = 1
+
+  const parts = path.split(separator)
+  const first = parts[0] || ''
+  const last = parts[parts.length - 1] || ''
+  const firstWidth = stringWidth(first)
+  const lastWidth = stringWidth(last)
+
+  // Only one part, so show as much of it as we can
+  if (parts.length === 1) {
+    return truncateToWidth(path, maxLength)
+  }
+
+  // We don't have enough space to show the last part, so truncate it
+  // But since firstPart is empty (unix) we don't want the extra ellipsis
+  if (first === '' && ellipsisWidth + separatorWidth + lastWidth >= maxLength) {
+    return `${separator}${truncateToWidth(last, Math.max(1, maxLength - separatorWidth))}`
+  }
+
+  // We have a first part so let's show the ellipsis and truncate last part
+  if (
+    first !== '' &&
+    ellipsisWidth * 2 + separatorWidth + lastWidth >= maxLength
+  ) {
+    return `${ellipsis}${separator}${truncateToWidth(last, Math.max(1, maxLength - ellipsisWidth - separatorWidth))}`
+  }
+
+  // Truncate first and leave last
+  if (parts.length === 2) {
+    const availableForFirst =
+      maxLength - ellipsisWidth - separatorWidth - lastWidth
+    return `${truncateToWidthNoEllipsis(first, availableForFirst)}${ellipsis}${separator}${last}`
+  }
+
+  // Now we start removing middle parts
+
+  let available =
+    maxLength - firstWidth - lastWidth - ellipsisWidth - 2 * separatorWidth
+
+  // Just the first and last are too long, so truncate first
+  if (available <= 0) {
+    const availableForFirst = Math.max(
+      0,
+      maxLength - lastWidth - ellipsisWidth - 2 * separatorWidth,
+    )
+    const truncatedFirst = truncateToWidthNoEllipsis(first, availableForFirst)
+    return `${truncatedFirst}${separator}${ellipsis}${separator}${last}`
+  }
+
+  // Try to keep as many middle parts as possible
+  const middleParts = []
+  for (let i = parts.length - 2; i > 0; i--) {
+    const part = parts[i]
+    if (part && stringWidth(part) + separatorWidth <= available) {
+      middleParts.unshift(part)
+      available -= stringWidth(part) + separatorWidth
+    } else {
+      break
+    }
+  }
+
+  if (middleParts.length === 0) {
+    return `${first}${separator}${ellipsis}${separator}${last}`
+  }
+
+  return `${first}${separator}${ellipsis}${separator}${middleParts.join(separator)}${separator}${last}`
+}
+
+// Simple cache for preloaded activity
+let cachedActivity: LogOption[] = []
+let cachePromise: Promise<LogOption[]> | null = null
+
+/**
+ * Preloads recent conversations for display in Logo v2
+ */
+export async function getRecentActivity(): Promise<LogOption[]> {
+  // Return existing promise if already loading
+  if (cachePromise) {
+    return cachePromise
+  }
+
+  const currentSessionId = getSessionId()
+  cachePromise = loadMessageLogs(10)
+    .then(logs => {
+      cachedActivity = logs
+        .filter(log => {
+          if (log.isSidechain) return false
+          if (log.sessionId === currentSessionId) return false
+          if (log.summary?.includes('I apologize')) return false
+
+          // Filter out sessions where both summary and firstPrompt are "No prompt" or missing
+          const hasSummary = log.summary && log.summary !== 'No prompt'
+          const hasFirstPrompt =
+            log.firstPrompt && log.firstPrompt !== 'No prompt'
+          return hasSummary || hasFirstPrompt
+        })
+        .slice(0, 3)
+      return cachedActivity
+    })
+    .catch(() => {
+      cachedActivity = []
+      return cachedActivity
+    })
+
+  return cachePromise
+}
+
+/**
+ * Gets cached activity synchronously
+ */
+export function getRecentActivitySync(): LogOption[] {
+  return cachedActivity
+}
+
+/**
+ * Formats release notes for display, with smart truncation
+ */
+export function formatReleaseNoteForDisplay(
+  note: string,
+  maxWidth: number,
+): string {
+  // Simply truncate at the max width, same as Recent Activity descriptions
+  return truncate(note, maxWidth)
+}
+
+/**
+ * Gets the common logo display data used by both LogoV2 and CondensedLogo
+ */
+export function getLogoDisplayData(): {
+  version: string
+  cwd: string
+  billingType: string
+  agentName: string | undefined
+} {
+  const version = process.env.DEMO_VERSION ?? '3.0.0'
+  const serverUrl = getDirectConnectServerUrl()
+  const displayPath = process.env.DEMO_VERSION
+    ? '/code/claude'
+    : getDisplayPath(getCwd())
+  const cwd = serverUrl
+    ? `${displayPath} in ${serverUrl.replace(/^https?:\/\//, '')}`
+    : displayPath
+  const billingType = isClaudeAISubscriber()
+    ? getSubscriptionName()
+    : 'API Usage Billing'
+  const agentName = getInitialSettings().agent
+
+  return {
+    version,
+    cwd,
+    billingType,
+    agentName,
+  }
+}
+
+/**
+ * Determines how to display model and billing information based on available width
+ */
+export function formatModelAndBilling(
+  modelName: string,
+  billingType: string,
+  availableWidth: number,
+): {
+  shouldSplit: boolean
+  truncatedModel: string
+  truncatedBilling: string
+} {
+  const separator = ' · '
+  const combinedWidth =
+    stringWidth(modelName) + separator.length + stringWidth(billingType)
+  const shouldSplit = combinedWidth > availableWidth
+
+  if (shouldSplit) {
+    return {
+      shouldSplit: true,
+      truncatedModel: truncate(modelName, availableWidth),
+      truncatedBilling: truncate(billingType, availableWidth),
+    }
+  }
+
+  return {
+    shouldSplit: false,
+    truncatedModel: truncate(
+      modelName,
+      Math.max(
+        availableWidth - stringWidth(billingType) - separator.length,
+        10,
+      ),
+    ),
+    truncatedBilling: billingType,
+  }
+}
+
+/**
+ * Gets recent release notes for Logo v2 display
+ * For ants, uses commits bundled at build time
+ * For external users, uses public changelog
+ */
+export function getRecentReleaseNotesSync(maxItems: number): string[] {
+  // For ants, use bundled changelog
+  if (process.env.USER_TYPE === 'ant') {
+    const changelog = MACRO.VERSION_CHANGELOG
+    if (changelog) {
+      const commits = changelog.trim().split('\n').filter(Boolean)
+      return commits.slice(0, maxItems)
+    }
+    return []
+  }
+
+  const changelog = getStoredChangelogFromMemory()
+  if (!changelog) {
+    return []
+  }
+
+  let parsed
+  try {
+    parsed = parseChangelog(changelog)
+  } catch {
+    return []
+  }
+
+  // Get notes from recent versions
+  const allNotes: string[] = []
+  const versions = Object.keys(parsed)
+    .sort((a, b) => (gt(a, b) ? -1 : 1))
+    .slice(0, 3) // Look at top 3 recent versions
+
+  for (const version of versions) {
+    const notes = parsed[version]
+    if (notes) {
+      allNotes.push(...notes)
+    }
+  }
+
+  // Return raw notes without filtering or premature truncation
+  return allNotes.slice(0, maxItems)
+}