Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
claude-code interactiveHelpers.tsx
57 kB · 366 lines
TSX
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366import { feature } from 'bun:bundle';import { appendFileSync } from 'fs';import React from 'react';import { logEvent } from 'src/services/analytics/index.js';import { gracefulShutdown, gracefulShutdownSync } from 'src/utils/gracefulShutdown.js';import { type ChannelEntry, getAllowedChannels, setAllowedChannels, setHasDevChannels, setSessionTrustAccepted, setStatsStore } from './bootstrap/state.js';import type { Command } from './commands.js';import { createStatsStore, type StatsStore } from './context/stats.js';import { getSystemContext } from './context.js';import { initializeTelemetryAfterTrust } from './entrypoints/init.js';import { isSynchronizedOutputSupported } from './ink/terminal.js';import type { RenderOptions, Root, TextProps } from './ink.js';import { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js';import { startDeferredPrefetches } from './main.js';import { checkGate_CACHED_OR_BLOCKING, initializeGrowthBook, resetGrowthBook } from './services/analytics/growthbook.js';import { isQualifiedForGrove } from './services/api/grove.js';import { handleMcpjsonServerApprovals } from './services/mcpServerApproval.js';import { AppStateProvider } from './state/AppState.js';import { onChangeAppState } from './state/onChangeAppState.js';import { normalizeApiKeyForConfig } from './utils/authPortable.js';import { getExternalClaudeMdIncludes, getMemoryFiles, shouldShowClaudeMdExternalIncludesWarning } from './utils/claudemd.js';import { checkHasTrustDialogAccepted, getCustomApiKeyStatus, getGlobalConfig, saveGlobalConfig } from './utils/config.js';import { updateDeepLinkTerminalPreference } from './utils/deepLink/terminalPreference.js';import { isEnvTruthy, isRunningOnHomespace } from './utils/envUtils.js';import { type FpsMetrics, FpsTracker } from './utils/fpsTracker.js';import { updateGithubRepoPathMapping } from './utils/githubRepoPathMapping.js';import { applyConfigEnvironmentVariables } from './utils/managedEnv.js';import type { PermissionMode } from './utils/permissions/PermissionMode.js';import { getBaseRenderOptions } from './utils/renderOptions.js';import { getSettingsWithAllErrors } from './utils/settings/allErrors.js';import { hasAutoModeOptIn, hasSkipDangerousModePermissionPrompt } from './utils/settings/settings.js';export function completeOnboarding(): void { saveGlobalConfig(current => ({ ...current, hasCompletedOnboarding: true, lastOnboardingVersion: MACRO.VERSION }));}export function showDialog<T = void>(root: Root, renderer: (done: (result: T) => void) => React.ReactNode): Promise<T> { return new Promise<T>(resolve => { const done = (result: T): void => void resolve(result); root.render(renderer(done)); });}
/** * Render an error message through Ink, then unmount and exit. * Use this for fatal errors after the Ink root has been created — * console.error is swallowed by Ink's patchConsole, so we render * through the React tree instead. */export async function exitWithError(root: Root, message: string, beforeExit?: () => Promise<void>): Promise<never> { return exitWithMessage(root, message, { color: 'error', beforeExit });}
/** * Render a message through Ink, then unmount and exit. * Use this for messages after the Ink root has been created — * console output is swallowed by Ink's patchConsole, so we render * through the React tree instead. */export async function exitWithMessage(root: Root, message: string, options?: { color?: TextProps['color']; exitCode?: number; beforeExit?: () => Promise<void>;}): Promise<never> { const { Text } = await import('./ink.js'); const color = options?.color; const exitCode = options?.exitCode ?? 1; root.render(color ? <Text color={color}>{message}</Text> : <Text>{message}</Text>); root.unmount(); await options?.beforeExit?.(); // eslint-disable-next-line custom-rules/no-process-exit -- exit after Ink unmount process.exit(exitCode);}
/** * Show a setup dialog wrapped in AppStateProvider + KeybindingSetup. * Reduces boilerplate in showSetupScreens() where every dialog needs these wrappers. */export function showSetupDialog<T = void>(root: Root, renderer: (done: (result: T) => void) => React.ReactNode, options?: { onChangeAppState?: typeof onChangeAppState;}): Promise<T> { return showDialog<T>(root, done => <AppStateProvider onChangeAppState={options?.onChangeAppState}> <KeybindingSetup>{renderer(done)}</KeybindingSetup> </AppStateProvider>);}
/** * Render the main UI into the root and wait for it to exit. * Handles the common epilogue: start deferred prefetches, wait for exit, graceful shutdown. */export async function renderAndRun(root: Root, element: React.ReactNode): Promise<void> { root.render(element); startDeferredPrefetches(); await root.waitUntilExit(); await gracefulShutdown(0);}export async function showSetupScreens(root: Root, permissionMode: PermissionMode, allowDangerouslySkipPermissions: boolean, commands?: Command[], claudeInChrome?: boolean, devChannels?: ChannelEntry[]): Promise<boolean> { if ("production" === 'test' || isEnvTruthy(false) || process.env.IS_DEMO // Skip onboarding in demo mode ) { return false; } const config = getGlobalConfig(); let onboardingShown = false; if (!config.theme || !config.hasCompletedOnboarding // always show onboarding at least once ) { onboardingShown = true; const { Onboarding } = await import('./components/Onboarding.js'); await showSetupDialog(root, done => <Onboarding onDone={() => { completeOnboarding(); void done(); }} />, { onChangeAppState }); }
// Always show the trust dialog in interactive sessions, regardless of permission mode. // The trust dialog is the workspace trust boundary — it warns about untrusted repos // and checks CLAUDE.md external includes. bypassPermissions mode // only affects tool execution permissions, not workspace trust. // Note: non-interactive sessions (CI/CD with -p) never reach showSetupScreens at all. // Skip permission checks in claubbit if (!isEnvTruthy(process.env.CLAUBBIT)) { // Fast-path: skip TrustDialog import+render when CWD is already trusted. // If it returns true, the TrustDialog would auto-resolve regardless of // security features, so we can skip the dynamic import and render cycle. if (!checkHasTrustDialogAccepted()) { const { TrustDialog } = await import('./components/TrustDialog/TrustDialog.js'); await showSetupDialog(root, done => <TrustDialog commands={commands} onDone={done} />); }
// Signal that trust has been verified for this session. // GrowthBook checks this to decide whether to include auth headers. setSessionTrustAccepted(true);
// Reset and reinitialize GrowthBook after trust is established. // Defense for login/logout: clears any prior client so the next init // picks up fresh auth headers. resetGrowthBook(); void initializeGrowthBook();
// Now that trust is established, prefetch system context if it wasn't already void getSystemContext();
// If settings are valid, check for any mcp.json servers that need approval const { errors: allErrors } = getSettingsWithAllErrors(); if (allErrors.length === 0) { await handleMcpjsonServerApprovals(root); }
// Check for claude.md includes that need approval if (await shouldShowClaudeMdExternalIncludesWarning()) { const externalIncludes = getExternalClaudeMdIncludes(await getMemoryFiles(true)); const { ClaudeMdExternalIncludesDialog } = await import('./components/ClaudeMdExternalIncludesDialog.js'); await showSetupDialog(root, done => <ClaudeMdExternalIncludesDialog onDone={done} isStandaloneDialog externalIncludes={externalIncludes} />); } }
// Track current repo path for teleport directory switching (fire-and-forget) // This must happen AFTER trust to prevent untrusted directories from poisoning the mapping void updateGithubRepoPathMapping(); if (feature('LODESTONE')) { updateDeepLinkTerminalPreference(); }
// Apply full environment variables after trust dialog is accepted OR in bypass mode // In bypass mode (CI/CD, automation), we trust the environment so apply all variables // In normal mode, this happens after the trust dialog is accepted // This includes potentially dangerous environment variables from untrusted sources applyConfigEnvironmentVariables();
// Initialize telemetry after env vars are applied so OTEL endpoint env vars and // otelHeadersHelper (which requires trust to execute) are available. // Defer to next tick so the OTel dynamic import resolves after first render // instead of during the pre-render microtask queue. setImmediate(() => initializeTelemetryAfterTrust()); if (await isQualifiedForGrove()) { const { GroveDialog } = await import('src/components/grove/Grove.js'); const decision = await showSetupDialog<string>(root, done => <GroveDialog showIfAlreadyViewed={false} location={onboardingShown ? 'onboarding' : 'policy_update_modal'} onDone={done} />); if (decision === 'escape') { logEvent('tengu_grove_policy_exited', {}); gracefulShutdownSync(0); return false; } }
// Check for custom API key // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child // processes but ignored by Claude Code itself (see auth.ts). if (process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace()) { const customApiKeyTruncated = normalizeApiKeyForConfig(process.env.ANTHROPIC_API_KEY); const keyStatus = getCustomApiKeyStatus(customApiKeyTruncated); if (keyStatus === 'new') { const { ApproveApiKey } = await import('./components/ApproveApiKey.js'); await showSetupDialog<boolean>(root, done => <ApproveApiKey customApiKeyTruncated={customApiKeyTruncated} onDone={done} />, { onChangeAppState }); } } if ((permissionMode === 'bypassPermissions' || allowDangerouslySkipPermissions) && !hasSkipDangerousModePermissionPrompt()) { const { BypassPermissionsModeDialog } = await import('./components/BypassPermissionsModeDialog.js'); await showSetupDialog(root, done => <BypassPermissionsModeDialog onAccept={done} />); } if (feature('TRANSCRIPT_CLASSIFIER')) { // Only show the opt-in dialog if auto mode actually resolved — if the // gate denied it (org not allowlisted, settings disabled), showing // consent for an unavailable feature is pointless. The // verifyAutoModeGateAccess notification will explain why instead. if (permissionMode === 'auto' && !hasAutoModeOptIn()) { const { AutoModeOptInDialog } = await import('./components/AutoModeOptInDialog.js'); await showSetupDialog(root, done => <AutoModeOptInDialog onAccept={done} onDecline={() => gracefulShutdownSync(1)} declineExits />); } }
// --dangerously-load-development-channels confirmation. On accept, append // dev channels to any --channels list already set in main.tsx. Org policy // is NOT bypassed — gateChannelServer() still runs; this flag only exists // to sidestep the --channels approved-server allowlist. if (feature('KAIROS') || feature('KAIROS_CHANNELS')) { // gateChannelServer and ChannelsNotice read tengu_harbor after this // function returns. A cold disk cache (fresh install, or first run after // the flag was added server-side) defaults to false and silently drops // channel notifications for the whole session — gh#37026. // checkGate_CACHED_OR_BLOCKING returns immediately if disk already says // true; only blocks on a cold/stale-false cache (awaits the same memoized // initializeGrowthBook promise fired earlier). Also warms the // isChannelsEnabled() check in the dev-channels dialog below. if (getAllowedChannels().length > 0 || (devChannels?.length ?? 0) > 0) { await checkGate_CACHED_OR_BLOCKING('tengu_harbor'); } if (devChannels && devChannels.length > 0) { const [{ isChannelsEnabled }, { getClaudeAIOAuthTokens }] = await Promise.all([import('./services/mcp/channelAllowlist.js'), import('./utils/auth.js')]); // Skip the dialog when channels are blocked (tengu_harbor off or no // OAuth) — accepting then immediately seeing "not available" in // ChannelsNotice is worse than no dialog. Append entries anyway so // ChannelsNotice renders the blocked branch with the dev entries // named. dev:true here is for the flag label in ChannelsNotice // (hasNonDev check); the allowlist bypass it also grants is moot // since the gate blocks upstream. if (!isChannelsEnabled() || !getClaudeAIOAuthTokens()?.accessToken) { setAllowedChannels([...getAllowedChannels(), ...devChannels.map(c => ({ ...c, dev: true }))]); setHasDevChannels(true); } else { const { DevChannelsDialog } = await import('./components/DevChannelsDialog.js'); await showSetupDialog(root, done => <DevChannelsDialog channels={devChannels} onAccept={() => { // Mark dev entries per-entry so the allowlist bypass doesn't leak // to --channels entries when both flags are passed. setAllowedChannels([...getAllowedChannels(), ...devChannels.map(c => ({ ...c, dev: true }))]); setHasDevChannels(true); void done(); }} />); } } }
// Show Chrome onboarding for first-time Claude in Chrome users if (claudeInChrome && !getGlobalConfig().hasCompletedClaudeInChromeOnboarding) { const { ClaudeInChromeOnboarding } = await import('./components/ClaudeInChromeOnboarding.js'); await showSetupDialog(root, done => <ClaudeInChromeOnboarding onDone={done} />); } return onboardingShown;}export function getRenderContext(exitOnCtrlC: boolean): { renderOptions: RenderOptions; getFpsMetrics: () => FpsMetrics | undefined; stats: StatsStore;} { let lastFlickerTime = 0; const baseOptions = getBaseRenderOptions(exitOnCtrlC);
// Log analytics event when stdin override is active if (baseOptions.stdin) { logEvent('tengu_stdin_interactive', {}); } const fpsTracker = new FpsTracker(); const stats = createStatsStore(); setStatsStore(stats);
// Bench mode: when set, append per-frame phase timings as JSONL for // offline analysis by bench/repl-scroll.ts. Captures the full TUI // render pipeline (yoga → screen buffer → diff → optimize → stdout) // so perf work on any phase can be validated against real user flows. const frameTimingLogPath = process.env.CLAUDE_CODE_FRAME_TIMING_LOG; return { getFpsMetrics: () => fpsTracker.getMetrics(), stats, renderOptions: { ...baseOptions, onFrame: event => { fpsTracker.record(event.durationMs); stats.observe('frame_duration_ms', event.durationMs); if (frameTimingLogPath && event.phases) { // Bench-only env-var-gated path: sync write so no frames dropped // on abrupt exit. ~100 bytes at ≤60fps is negligible. rss/cpu are // single syscalls; cpu is cumulative — bench side computes delta. const line = // eslint-disable-next-line custom-rules/no-direct-json-operations -- tiny object, hot bench path JSON.stringify({ total: event.durationMs, ...event.phases, rss: process.memoryUsage.rss(), cpu: process.cpuUsage() }) + '\n'; // eslint-disable-next-line custom-rules/no-sync-fs -- bench-only, sync so no frames dropped on exit appendFileSync(frameTimingLogPath, line); } // Skip flicker reporting for terminals with synchronized output — // DEC 2026 buffers between BSU/ESU so clear+redraw is atomic. if (isSynchronizedOutputSupported()) { return; } for (const flicker of event.flickers) { if (flicker.reason === 'resize') { continue; } const now = Date.now(); if (now - lastFlickerTime < 1000) { logEvent('tengu_flicker', { desiredHeight: flicker.desiredHeight, actualHeight: flicker.availableHeight, reason: flicker.reason } as unknown as Record<string, boolean | number | undefined>); } lastFlickerTime = now; } } } };}//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["feature","appendFileSync","React","logEvent","gracefulShutdown","gracefulShutdownSync","ChannelEntry","getAllowedChannels","setAllowedChannels","setHasDevChannels","setSessionTrustAccepted","setStatsStore","Command","createStatsStore","StatsStore","getSystemContext","initializeTelemetryAfterTrust","isSynchronizedOutputSupported","RenderOptions","Root","TextProps","KeybindingSetup","startDeferredPrefetches","checkGate_CACHED_OR_BLOCKING","initializeGrowthBook","resetGrowthBook","isQualifiedForGrove","handleMcpjsonServerApprovals","AppStateProvider","onChangeAppState","normalizeApiKeyForConfig","getExternalClaudeMdIncludes","getMemoryFiles","shouldShowClaudeMdExternalIncludesWarning","checkHasTrustDialogAccepted","getCustomApiKeyStatus","getGlobalConfig","saveGlobalConfig","updateDeepLinkTerminalPreference","isEnvTruthy","isRunningOnHomespace","FpsMetrics","FpsTracker","updateGithubRepoPathMapping","applyConfigEnvironmentVariables","PermissionMode","getBaseRenderOptions","getSettingsWithAllErrors","hasAutoModeOptIn","hasSkipDangerousModePermissionPrompt","completeOnboarding","current","hasCompletedOnboarding","lastOnboardingVersion","MACRO","VERSION","showDialog","root","renderer","done","result","T","ReactNode","Promise","resolve","render","exitWithError","message","beforeExit","exitWithMessage","color","options","exitCode","Text","unmount","process","exit","showSetupDialog","renderAndRun","element","waitUntilExit","showSetupScreens","permissionMode","allowDangerouslySkipPermissions","commands","claudeInChrome","devChannels","env","IS_DEMO","config","onboardingShown","theme","Onboarding","CLAUBBIT","TrustDialog","errors","allErrors","length","externalIncludes","ClaudeMdExternalIncludesDialog","setImmediate","GroveDialog","decision","ANTHROPIC_API_KEY","customApiKeyTruncated","keyStatus","ApproveApiKey","BypassPermissionsModeDialog","AutoModeOptInDialog","isChannelsEnabled","getClaudeAIOAuthTokens","all","accessToken","map","c","dev","DevChannelsDialog","hasCompletedClaudeInChromeOnboarding","ClaudeInChromeOnboarding","getRenderContext","exitOnCtrlC","renderOptions","getFpsMetrics","stats","lastFlickerTime","baseOptions","stdin","fpsTracker","frameTimingLogPath","CLAUDE_CODE_FRAME_TIMING_LOG","getMetrics","onFrame","event","record","durationMs","observe","phases","line","JSON","stringify","total","rss","memoryUsage","cpu","cpuUsage","flicker","flickers","reason","now","Date","desiredHeight","actualHeight","availableHeight","Record"],"sources":["interactiveHelpers.tsx"],"sourcesContent":["import { feature } from 'bun:bundle'\nimport { appendFileSync } from 'fs'\nimport React from 'react'\nimport { logEvent } from 'src/services/analytics/index.js'\nimport {\n  gracefulShutdown,\n  gracefulShutdownSync,\n} from 'src/utils/gracefulShutdown.js'\nimport {\n  type ChannelEntry,\n  getAllowedChannels,\n  setAllowedChannels,\n  setHasDevChannels,\n  setSessionTrustAccepted,\n  setStatsStore,\n} from './bootstrap/state.js'\nimport type { Command } from './commands.js'\nimport { createStatsStore, type StatsStore } from './context/stats.js'\nimport { getSystemContext } from './context.js'\nimport { initializeTelemetryAfterTrust } from './entrypoints/init.js'\nimport { isSynchronizedOutputSupported } from './ink/terminal.js'\nimport type { RenderOptions, Root, TextProps } from './ink.js'\nimport { KeybindingSetup } from './keybindings/KeybindingProviderSetup.js'\nimport { startDeferredPrefetches } from './main.js'\nimport {\n  checkGate_CACHED_OR_BLOCKING,\n  initializeGrowthBook,\n  resetGrowthBook,\n} from './services/analytics/growthbook.js'\nimport { isQualifiedForGrove } from './services/api/grove.js'\nimport { handleMcpjsonServerApprovals } from './services/mcpServerApproval.js'\nimport { AppStateProvider } from './state/AppState.js'\nimport { onChangeAppState } from './state/onChangeAppState.js'\nimport { normalizeApiKeyForConfig } from './utils/authPortable.js'\nimport {\n  getExternalClaudeMdIncludes,\n  getMemoryFiles,\n  shouldShowClaudeMdExternalIncludesWarning,\n} from './utils/claudemd.js'\nimport {\n  checkHasTrustDialogAccepted,\n  getCustomApiKeyStatus,\n  getGlobalConfig,\n  saveGlobalConfig,\n} from './utils/config.js'\nimport { updateDeepLinkTerminalPreference } from './utils/deepLink/terminalPreference.js'\nimport { isEnvTruthy, isRunningOnHomespace } from './utils/envUtils.js'\nimport { type FpsMetrics, FpsTracker } from './utils/fpsTracker.js'\nimport { updateGithubRepoPathMapping } from './utils/githubRepoPathMapping.js'\nimport { applyConfigEnvironmentVariables } from './utils/managedEnv.js'\nimport type { PermissionMode } from './utils/permissions/PermissionMode.js'\nimport { getBaseRenderOptions } from './utils/renderOptions.js'\nimport { getSettingsWithAllErrors } from './utils/settings/allErrors.js'\nimport {\n  hasAutoModeOptIn,\n  hasSkipDangerousModePermissionPrompt,\n} from './utils/settings/settings.js'\n\nexport function completeOnboarding(): void {\n  saveGlobalConfig(current => ({\n    ...current,\n    hasCompletedOnboarding: true,\n    lastOnboardingVersion: MACRO.VERSION,\n  }))\n}\nexport function showDialog<T = void>(\n  root: Root,\n  renderer: (done: (result: T) => void) => React.ReactNode,\n): Promise<T> {\n  return new Promise<T>(resolve => {\n    const done = (result: T): void => void resolve(result)\n    root.render(renderer(done))\n  })\n}\n\n/**\n * Render an error message through Ink, then unmount and exit.\n * Use this for fatal errors after the Ink root has been created —\n * console.error is swallowed by Ink's patchConsole, so we render\n * through the React tree instead.\n */\nexport async function exitWithError(\n  root: Root,\n  message: string,\n  beforeExit?: () => Promise<void>,\n): Promise<never> {\n  return exitWithMessage(root, message, { color: 'error', beforeExit })\n}\n\n/**\n * Render a message through Ink, then unmount and exit.\n * Use this for messages after the Ink root has been created —\n * console output is swallowed by Ink's patchConsole, so we render\n * through the React tree instead.\n */\nexport async function exitWithMessage(\n  root: Root,\n  message: string,\n  options?: {\n    color?: TextProps['color']\n    exitCode?: number\n    beforeExit?: () => Promise<void>\n  },\n): Promise<never> {\n  const { Text } = await import('./ink.js')\n  const color = options?.color\n  const exitCode = options?.exitCode ?? 1\n  root.render(\n    color ? <Text color={color}>{message}</Text> : <Text>{message}</Text>,\n  )\n  root.unmount()\n  await options?.beforeExit?.()\n  // eslint-disable-next-line custom-rules/no-process-exit -- exit after Ink unmount\n  process.exit(exitCode)\n}\n\n/**\n * Show a setup dialog wrapped in AppStateProvider + KeybindingSetup.\n * Reduces boilerplate in showSetupScreens() where every dialog needs these wrappers.\n */\nexport function showSetupDialog<T = void>(\n  root: Root,\n  renderer: (done: (result: T) => void) => React.ReactNode,\n  options?: { onChangeAppState?: typeof onChangeAppState },\n): Promise<T> {\n  return showDialog<T>(root, done => (\n    <AppStateProvider onChangeAppState={options?.onChangeAppState}>\n      <KeybindingSetup>{renderer(done)}</KeybindingSetup>\n    </AppStateProvider>\n  ))\n}\n\n/**\n * Render the main UI into the root and wait for it to exit.\n * Handles the common epilogue: start deferred prefetches, wait for exit, graceful shutdown.\n */\nexport async function renderAndRun(\n  root: Root,\n  element: React.ReactNode,\n): Promise<void> {\n  root.render(element)\n  startDeferredPrefetches()\n  await root.waitUntilExit()\n  await gracefulShutdown(0)\n}\n\nexport async function showSetupScreens(\n  root: Root,\n  permissionMode: PermissionMode,\n  allowDangerouslySkipPermissions: boolean,\n  commands?: Command[],\n  claudeInChrome?: boolean,\n  devChannels?: ChannelEntry[],\n): Promise<boolean> {\n  if (\n    \"production\" === 'test' ||\n    isEnvTruthy(false) ||\n    process.env.IS_DEMO // Skip onboarding in demo mode\n  ) {\n    return false\n  }\n\n  const config = getGlobalConfig()\n  let onboardingShown = false\n  if (\n    !config.theme ||\n    !config.hasCompletedOnboarding // always show onboarding at least once\n  ) {\n    onboardingShown = true\n    const { Onboarding } = await import('./components/Onboarding.js')\n    await showSetupDialog(\n      root,\n      done => (\n        <Onboarding\n          onDone={() => {\n            completeOnboarding()\n            void done()\n          }}\n        />\n      ),\n      { onChangeAppState },\n    )\n  }\n\n  // Always show the trust dialog in interactive sessions, regardless of permission mode.\n  // The trust dialog is the workspace trust boundary — it warns about untrusted repos\n  // and checks CLAUDE.md external includes. bypassPermissions mode\n  // only affects tool execution permissions, not workspace trust.\n  // Note: non-interactive sessions (CI/CD with -p) never reach showSetupScreens at all.\n  // Skip permission checks in claubbit\n  if (!isEnvTruthy(process.env.CLAUBBIT)) {\n    // Fast-path: skip TrustDialog import+render when CWD is already trusted.\n    // If it returns true, the TrustDialog would auto-resolve regardless of\n    // security features, so we can skip the dynamic import and render cycle.\n    if (!checkHasTrustDialogAccepted()) {\n      const { TrustDialog } = await import(\n        './components/TrustDialog/TrustDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <TrustDialog commands={commands} onDone={done} />\n      ))\n    }\n\n    // Signal that trust has been verified for this session.\n    // GrowthBook checks this to decide whether to include auth headers.\n    setSessionTrustAccepted(true)\n\n    // Reset and reinitialize GrowthBook after trust is established.\n    // Defense for login/logout: clears any prior client so the next init\n    // picks up fresh auth headers.\n    resetGrowthBook()\n    void initializeGrowthBook()\n\n    // Now that trust is established, prefetch system context if it wasn't already\n    void getSystemContext()\n\n    // If settings are valid, check for any mcp.json servers that need approval\n    const { errors: allErrors } = getSettingsWithAllErrors()\n    if (allErrors.length === 0) {\n      await handleMcpjsonServerApprovals(root)\n    }\n\n    // Check for claude.md includes that need approval\n    if (await shouldShowClaudeMdExternalIncludesWarning()) {\n      const externalIncludes = getExternalClaudeMdIncludes(\n        await getMemoryFiles(true),\n      )\n      const { ClaudeMdExternalIncludesDialog } = await import(\n        './components/ClaudeMdExternalIncludesDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <ClaudeMdExternalIncludesDialog\n          onDone={done}\n          isStandaloneDialog\n          externalIncludes={externalIncludes}\n        />\n      ))\n    }\n  }\n\n  // Track current repo path for teleport directory switching (fire-and-forget)\n  // This must happen AFTER trust to prevent untrusted directories from poisoning the mapping\n  void updateGithubRepoPathMapping()\n  if (feature('LODESTONE')) {\n    updateDeepLinkTerminalPreference()\n  }\n\n  // Apply full environment variables after trust dialog is accepted OR in bypass mode\n  // In bypass mode (CI/CD, automation), we trust the environment so apply all variables\n  // In normal mode, this happens after the trust dialog is accepted\n  // This includes potentially dangerous environment variables from untrusted sources\n  applyConfigEnvironmentVariables()\n\n  // Initialize telemetry after env vars are applied so OTEL endpoint env vars and\n  // otelHeadersHelper (which requires trust to execute) are available.\n  // Defer to next tick so the OTel dynamic import resolves after first render\n  // instead of during the pre-render microtask queue.\n  setImmediate(() => initializeTelemetryAfterTrust())\n\n  if (await isQualifiedForGrove()) {\n    const { GroveDialog } = await import('src/components/grove/Grove.js')\n    const decision = await showSetupDialog<string>(root, done => (\n      <GroveDialog\n        showIfAlreadyViewed={false}\n        location={onboardingShown ? 'onboarding' : 'policy_update_modal'}\n        onDone={done}\n      />\n    ))\n    if (decision === 'escape') {\n      logEvent('tengu_grove_policy_exited', {})\n      gracefulShutdownSync(0)\n      return false\n    }\n  }\n\n  // Check for custom API key\n  // On homespace, ANTHROPIC_API_KEY is preserved in process.env for child\n  // processes but ignored by Claude Code itself (see auth.ts).\n  if (process.env.ANTHROPIC_API_KEY && !isRunningOnHomespace()) {\n    const customApiKeyTruncated = normalizeApiKeyForConfig(\n      process.env.ANTHROPIC_API_KEY,\n    )\n    const keyStatus = getCustomApiKeyStatus(customApiKeyTruncated)\n    if (keyStatus === 'new') {\n      const { ApproveApiKey } = await import('./components/ApproveApiKey.js')\n      await showSetupDialog<boolean>(\n        root,\n        done => (\n          <ApproveApiKey\n            customApiKeyTruncated={customApiKeyTruncated}\n            onDone={done}\n          />\n        ),\n        { onChangeAppState },\n      )\n    }\n  }\n\n  if (\n    (permissionMode === 'bypassPermissions' ||\n      allowDangerouslySkipPermissions) &&\n    !hasSkipDangerousModePermissionPrompt()\n  ) {\n    const { BypassPermissionsModeDialog } = await import(\n      './components/BypassPermissionsModeDialog.js'\n    )\n    await showSetupDialog(root, done => (\n      <BypassPermissionsModeDialog onAccept={done} />\n    ))\n  }\n\n  if (feature('TRANSCRIPT_CLASSIFIER')) {\n    // Only show the opt-in dialog if auto mode actually resolved — if the\n    // gate denied it (org not allowlisted, settings disabled), showing\n    // consent for an unavailable feature is pointless. The\n    // verifyAutoModeGateAccess notification will explain why instead.\n    if (permissionMode === 'auto' && !hasAutoModeOptIn()) {\n      const { AutoModeOptInDialog } = await import(\n        './components/AutoModeOptInDialog.js'\n      )\n      await showSetupDialog(root, done => (\n        <AutoModeOptInDialog\n          onAccept={done}\n          onDecline={() => gracefulShutdownSync(1)}\n          declineExits\n        />\n      ))\n    }\n  }\n\n  // --dangerously-load-development-channels confirmation. On accept, append\n  // dev channels to any --channels list already set in main.tsx. Org policy\n  // is NOT bypassed — gateChannelServer() still runs; this flag only exists\n  // to sidestep the --channels approved-server allowlist.\n  if (feature('KAIROS') || feature('KAIROS_CHANNELS')) {\n    // gateChannelServer and ChannelsNotice read tengu_harbor after this\n    // function returns. A cold disk cache (fresh install, or first run after\n    // the flag was added server-side) defaults to false and silently drops\n    // channel notifications for the whole session — gh#37026.\n    // checkGate_CACHED_OR_BLOCKING returns immediately if disk already says\n    // true; only blocks on a cold/stale-false cache (awaits the same memoized\n    // initializeGrowthBook promise fired earlier). Also warms the\n    // isChannelsEnabled() check in the dev-channels dialog below.\n    if (getAllowedChannels().length > 0 || (devChannels?.length ?? 0) > 0) {\n      await checkGate_CACHED_OR_BLOCKING('tengu_harbor')\n    }\n\n    if (devChannels && devChannels.length > 0) {\n      const [{ isChannelsEnabled }, { getClaudeAIOAuthTokens }] =\n        await Promise.all([\n          import('./services/mcp/channelAllowlist.js'),\n          import('./utils/auth.js'),\n        ])\n      // Skip the dialog when channels are blocked (tengu_harbor off or no\n      // OAuth) — accepting then immediately seeing \"not available\" in\n      // ChannelsNotice is worse than no dialog. Append entries anyway so\n      // ChannelsNotice renders the blocked branch with the dev entries\n      // named. dev:true here is for the flag label in ChannelsNotice\n      // (hasNonDev check); the allowlist bypass it also grants is moot\n      // since the gate blocks upstream.\n      if (!isChannelsEnabled() || !getClaudeAIOAuthTokens()?.accessToken) {\n        setAllowedChannels([\n          ...getAllowedChannels(),\n          ...devChannels.map(c => ({ ...c, dev: true })),\n        ])\n        setHasDevChannels(true)\n      } else {\n        const { DevChannelsDialog } = await import(\n          './components/DevChannelsDialog.js'\n        )\n        await showSetupDialog(root, done => (\n          <DevChannelsDialog\n            channels={devChannels}\n            onAccept={() => {\n              // Mark dev entries per-entry so the allowlist bypass doesn't leak\n              // to --channels entries when both flags are passed.\n              setAllowedChannels([\n                ...getAllowedChannels(),\n                ...devChannels.map(c => ({ ...c, dev: true })),\n              ])\n              setHasDevChannels(true)\n              void done()\n            }}\n          />\n        ))\n      }\n    }\n  }\n\n  // Show Chrome onboarding for first-time Claude in Chrome users\n  if (\n    claudeInChrome &&\n    !getGlobalConfig().hasCompletedClaudeInChromeOnboarding\n  ) {\n    const { ClaudeInChromeOnboarding } = await import(\n      './components/ClaudeInChromeOnboarding.js'\n    )\n    await showSetupDialog(root, done => (\n      <ClaudeInChromeOnboarding onDone={done} />\n    ))\n  }\n\n  return onboardingShown\n}\n\nexport function getRenderContext(exitOnCtrlC: boolean): {\n  renderOptions: RenderOptions\n  getFpsMetrics: () => FpsMetrics | undefined\n  stats: StatsStore\n} {\n  let lastFlickerTime = 0\n  const baseOptions = getBaseRenderOptions(exitOnCtrlC)\n\n  // Log analytics event when stdin override is active\n  if (baseOptions.stdin) {\n    logEvent('tengu_stdin_interactive', {})\n  }\n\n  const fpsTracker = new FpsTracker()\n  const stats = createStatsStore()\n  setStatsStore(stats)\n\n  // Bench mode: when set, append per-frame phase timings as JSONL for\n  // offline analysis by bench/repl-scroll.ts. Captures the full TUI\n  // render pipeline (yoga → screen buffer → diff → optimize → stdout)\n  // so perf work on any phase can be validated against real user flows.\n  const frameTimingLogPath = process.env.CLAUDE_CODE_FRAME_TIMING_LOG\n  return {\n    getFpsMetrics: () => fpsTracker.getMetrics(),\n    stats,\n    renderOptions: {\n      ...baseOptions,\n      onFrame: event => {\n        fpsTracker.record(event.durationMs)\n        stats.observe('frame_duration_ms', event.durationMs)\n        if (frameTimingLogPath && event.phases) {\n          // Bench-only env-var-gated path: sync write so no frames dropped\n          // on abrupt exit. ~100 bytes at ≤60fps is negligible. rss/cpu are\n          // single syscalls; cpu is cumulative — bench side computes delta.\n          const line =\n            // eslint-disable-next-line custom-rules/no-direct-json-operations -- tiny object, hot bench path\n            JSON.stringify({\n              total: event.durationMs,\n              ...event.phases,\n              rss: process.memoryUsage.rss(),\n              cpu: process.cpuUsage(),\n            }) + '\\n'\n          // eslint-disable-next-line custom-rules/no-sync-fs -- bench-only, sync so no frames dropped on exit\n          appendFileSync(frameTimingLogPath, line)\n        }\n        // Skip flicker reporting for terminals with synchronized output —\n        // DEC 2026 buffers between BSU/ESU so clear+redraw is atomic.\n        if (isSynchronizedOutputSupported()) {\n          return\n        }\n        for (const flicker of event.flickers) {\n          if (flicker.reason === 'resize') {\n            continue\n          }\n          const now = Date.now()\n          if (now - lastFlickerTime < 1000) {\n            logEvent('tengu_flicker', {\n              desiredHeight: flicker.desiredHeight,\n              actualHeight: flicker.availableHeight,\n              reason: flicker.reason,\n            } as unknown as Record<string, boolean | number | undefined>)\n          }\n          lastFlickerTime = now\n        }\n      },\n    },\n  }\n}\n"],"mappings":"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","ignoreList":[]}