src/interactiveHelpers.tsx

import { 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 { getConfiguredAuthProvider } from './utils/auth.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;
  
  // Check if user is logged in
  const authProvider = getConfiguredAuthProvider();
  
  // Write debug info to file
  try {
    const fs = require('fs');
    const debugInfo = {
      hasCompletedOnboarding: config.hasCompletedOnboarding,
      authProvider: authProvider,
      hasTheme: !!config.theme,
      timestamp: new Date().toISOString()
    };
    fs.writeFileSync('/tmp/cli-debug.json', JSON.stringify(debugInfo, null, 2));
  } catch (e) {
    // Ignore errors
  }
  
  // If user has completed onboarding but is not logged in, show theme picker then login
  if (config.hasCompletedOnboarding && !authProvider) {
    onboardingShown = true;
    const { LoginOnboarding } = await import('./components/LoginOnboarding.js');
    await showSetupDialog(root, done => <LoginOnboarding onDone={() => {
      void done();
    }} />, {
      onChangeAppState
    });
  } else 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":[]}