Skip to content

Beautiful, AI-native markdown IDE and LLM wiki

23.7 KB
Raw Blame
// oxlint-disable ok/no-raw-error-toast -- pre-rule backlog: toasts here show raw error text; delete this line once the file maps each failure to written copy. See https://github.com/inkeep/open-knowledge/blob/main/lint-plugins/ok-rules/README.md#no-raw-error-toast
import { SHOW_INSTALL_SKILL } from '@inkeep/open-knowledge-core/constants/feature-flags';
import { mediaKindForSidebarAssetExtension } from '@inkeep/open-knowledge-core/constants/upload';
import {
  type CSSProperties,
  lazy,
  type ReactNode,
  Suspense,
  useEffect,
  useRef,
  useState,
} from 'react';
import { toast } from 'sonner';
import { CommentQueueShortcut } from '@/comments/CommentQueueShortcut';
import { APP_HEADER_HEIGHT, AppHeader } from '@/components/AppHeader';
import { BranchRecycleBanner } from '@/components/BranchRecycleBanner';
import { CommandPalette } from '@/components/CommandPalette';
import { ConnectingBanner } from '@/components/ConnectingBanner';
import { CornerCardStack } from '@/components/CornerCardStack';
import { CreateProjectMenuTrigger } from '@/components/CreateProjectMenuTrigger';
import { EditorPane } from '@/components/EditorPane';
import { FeedbackMenuTrigger } from '@/components/FeedbackMenuTrigger';
import { FileListHostProvider } from '@/components/FileListHost';
import { FileSidebar } from '@/components/FileSidebar';
import { defaultInitialDir } from '@/components/file-tree-utils';
import { ExternalHandoffGateProvider } from '@/components/handoff/ExternalHandoffGate';
import {
  type TerminalLaunchContextValue,
  TerminalLaunchProvider,
} from '@/components/handoff/TerminalLaunchContext';
import { requestTerminalLaunch } from '@/components/handoff/terminal-launch-events';
import { composeTerminalLaunchPrompt } from '@/components/handoff/useHandoffDispatch';
import { InstallInClaudeDesktopDialog } from '@/components/InstallInClaudeDesktopDialog';
import { McpConsentDialog } from '@/components/McpConsentDialog';
import { isNewItemShortcut, NewItemDialog } from '@/components/NewItemDialog';
import { NoteWindowMainActionReceiver } from '@/components/NoteWindowMainActionReceiver';
import {
  downgradeFolderIndexForHashNav,
  type ResolvedNavigationTarget,
  resolveNavigationTarget,
  withLargeFileOpenGuard,
} from '@/components/navigation-targets';
import { PageListProvider, usePageList } from '@/components/PageListContext';
import { ReportBugMenuTrigger } from '@/components/ReportBugMenuTrigger';
import { SkillTrackInGitDialog } from '@/components/SkillTrackInGitDialog';
import { SystemDocSubscriber } from '@/components/SystemDocSubscriber';
import { SidebarProvider } from '@/components/ui/sidebar';
import { ValidationFreshness } from '@/components/ValidationFreshness';
import { BackgroundThrottleReporter } from '@/editor/BackgroundThrottleReporter';
import {
  DocumentProvider,
  useDocumentContext,
  useDocumentTransition,
} from '@/editor/DocumentContext';
import { EditorLifecycleFlush } from '@/editor/EditorLifecycleFlush';
import { parseEditorTabId, tabIdForNavigationTarget } from '@/editor/editor-tabs';
import { previewOpenDisposition } from '@/editor/preview-open-disposition';
import { StaleTabReloadPrompt } from '@/editor/StaleTabReloadPrompt';
import { ConflictsProvider } from '@/hooks/use-conflicts';
import { DocNoticesProvider } from '@/hooks/use-doc-notices';
import { useFolderConfig } from '@/hooks/use-folder-config';
import { useInstalledClis } from '@/hooks/use-installed-clis';
import { useReconcileSkillTabs } from '@/hooks/use-reconcile-skill-tabs';
import { ConfigProvider, useConfigContext } from '@/lib/config-provider';
import { createPageRequest, nextUntitledDocName, openCreatedPage } from '@/lib/create-page-request';
import {
  assetPathFromHash,
  clearHashWithoutNavigation,
  docNameFromHash,
  hashFromDocName,
  isContentRootHash,
  isManagedHashHistoryState,
  markCurrentHashHistoryEntry,
  readManagedHashHistoryEntry,
  skillFileFromHash,
  skillPreviewFromHash,
  skillsFromHash,
} from '@/lib/doc-hash';
import { subscribeLocalMenuAction } from '@/lib/local-menu-action-bus';
import { isExplicitInitialDocumentNavigation } from '@/lib/narrow-workspace-session';
import { isNoteWindow } from '@/lib/note-window-mode';
import { isOverlayLayerOpen } from '@/lib/overlay-layers';
import { mark, ProfilerBoundary } from '@/lib/perf';
import { revealEditor } from '@/lib/reveal-editor';
import { SingleFileModeProvider, useSingleFileMode } from '@/lib/single-file-mode';
import { consumeHashNavigationSuppression } from '@/lib/tab-session-restore-suppression';
import { useServerKeepalive } from '@/lib/use-server-keepalive';
import { isSettingsHashOpen, isSettingsShortcut, openSettings } from '@/lib/use-settings-route';
import { cn } from '@/lib/utils';
import { consumeWorkspaceHashWrite } from '@/lib/workspace-hash-writes';

const ShareBranchSwitchDialog = lazy(() =>
  import('@/components/ShareBranchSwitchDialog').then((m) => ({
    default: m.ShareBranchSwitchDialog,
  })),
);

const ShareReceiveMissDialog = lazy(() =>
  import('@/components/ShareReceiveMissDialog').then((m) => ({
    default: m.ShareReceiveMissDialog,
  })),
);

const INSTALL_DIALOG_HASH = '#install-claude-desktop';
const MARKDOWN_EXTENSION_QUALIFIED_DOC_PATTERN = /\.(md|mdx)$/i;
function isAuxiliaryDialogHash(hash: string): boolean {
  return isSettingsHashOpen(hash) || hash === INSTALL_DIALOG_HASH;
}

function exactOpenMarkdownTabTarget(
  docName: string,
  openTabs: ReadonlyArray<string>,
): ResolvedNavigationTarget | null {
  if (!MARKDOWN_EXTENSION_QUALIFIED_DOC_PATTERN.test(docName)) return null;
  for (const tabId of openTabs) {
    const tab = parseEditorTabId(tabId);
    if (tab.kind === 'doc' && tab.docName === docName) {
      return { kind: 'doc', target: docName, docName };
    }
  }
  return null;
}

function selectedPathForNavigationTarget(target: ResolvedNavigationTarget): string | null {
  switch (target.kind) {
    case 'skill-file':
    case 'skill-preview':
      return target.path ?? null;
    case 'doc':
    case 'folder-index':
    case 'folder':
    case 'asset':
    case 'skills':
    case 'large-file':
    case 'missing':
      return null;
  }
}

function knownTargetsSignature(
  pages: ReadonlySet<string>,
  folderPaths: ReadonlySet<string>,
  assetPaths: ReadonlySet<string>,
  filePaths: ReadonlySet<string>,
): string {
  return [pages, folderPaths, assetPaths, filePaths]
    .map((values) => [...values].sort().join('\u0000'))
    .join('\u0001');
}

function NavigationHandler() {
  const {
    activeNewTabId,
    activeTabId,
    activeTarget,
    clearTarget,
    openTabs,
    syncOpenTabsWithKnownTargets,
    tabSessionLoaded,
  } = useDocumentContext();
  const { openTargetTransition } = useDocumentTransition();
  useReconcileSkillTabs();
  const {
    assetPaths,
    filePaths,
    folderPaths,
    loading,
    pageMeta,
    pages,
    pagesBySlug,
    pagesByBasename,
  } = usePageList();
  const { merged } = useConfigContext();
  const previewTabsEnabled = merged?.editor?.previewTabs ?? true;
  const lastSyncedTargetsSignatureRef = useRef<string | null>(null);
  const historyTraversalUrlRef = useRef<string | null>(null);
  const initialDocumentNavigationRef = useRef(isExplicitInitialDocumentNavigation());
  const lastResolvedSurfaceHashRef = useRef<string | null>(null);
  const targetsSignature = knownTargetsSignature(pages, folderPaths, assetPaths, filePaths);

  useEffect(() => {
    function revealEditorForDocumentLink(event: MouseEvent) {
      if (event.defaultPrevented || event.button !== 0) return;
      if (event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) return;
      if (!(event.target instanceof Element)) return;
      if (event.target.closest('a[href^="#/"]') != null) revealEditor();
    }
    document.addEventListener('click', revealEditorForDocumentLink);
    return () => document.removeEventListener('click', revealEditorForDocumentLink);
  }, []);

  useEffect(
    () =>
      subscribeLocalMenuAction((action) => {
        if (action === 'navigate-back') window.history.back();
        if (action === 'navigate-forward') window.history.forward();
      }),
    [],
  );

  useEffect(() => {
    if (
      loading ||
      !tabSessionLoaded ||
      lastSyncedTargetsSignatureRef.current === targetsSignature
    ) {
      return;
    }
    lastSyncedTargetsSignatureRef.current = targetsSignature;
    syncOpenTabsWithKnownTargets({ pages, folderPaths, assetPaths, filePaths });
  }, [
    assetPaths,
    filePaths,
    folderPaths,
    loading,
    pages,
    syncOpenTabsWithKnownTargets,
    tabSessionLoaded,
    targetsSignature,
  ]);

  useEffect(() => {
    if (
      consumeHashNavigationSuppression() &&
      window.location.hash !== '' &&
      !isAuxiliaryDialogHash(window.location.hash)
    ) {
      clearHashWithoutNavigation();
    }
  }, []);

  useEffect(() => {
    if (!tabSessionLoaded && window.okDesktop?.config.mode === 'editor') return;
    if (initialDocumentNavigationRef.current) {
      initialDocumentNavigationRef.current = false;
      revealEditor();
    }
    syncTargetFromHash(historyTraversalUrlRef.current, false);

    function onPopState(event: PopStateEvent) {
      historyTraversalUrlRef.current = isManagedHashHistoryState(event.state)
        ? window.location.href
        : null;
    }

    function onHashChange(event: HashChangeEvent) {
      const traversedUrl = historyTraversalUrlRef.current;
      const previousHash = event.oldURL === '' ? '' : new URL(event.oldURL).hash;
      const workspaceWrote = consumeWorkspaceHashWrite(window.location.hash);
      const returnedFromDialog =
        isAuxiliaryDialogHash(previousHash) && traversedUrl === window.location.href;
      syncTargetFromHash(traversedUrl, !workspaceWrote && !returnedFromDialog);
    }

    function syncTargetFromHash(traversedUrl: string | null, deliberate: boolean) {
      const isHistoryTraversal = traversedUrl === window.location.href;
      markCurrentHashHistoryEntry();
      const isSurfaceHashRepeat = lastResolvedSurfaceHashRef.current === window.location.hash;
      const latchSurfaceHash = () => {
        lastResolvedSurfaceHashRef.current = window.location.hash;
      };
      const clearSurfaceHash = () => {
        lastResolvedSurfaceHashRef.current = null;
      };
      const openHashTarget = (target: ResolvedNavigationTarget) => {
        clearSurfaceHash();
        if (
          tabIdForNavigationTarget(target) === activeTabId &&
          activeTarget?.kind === target.kind &&
          activeTarget.target === target.target &&
          selectedPathForNavigationTarget(activeTarget) === selectedPathForNavigationTarget(target)
        ) {
          if (deliberate) revealEditor();
          return;
        }
        openTargetTransition(target, {
          deliberate,
          disposition:
            isHistoryTraversal || !previewTabsEnabled
              ? previewOpenDisposition(previewTabsEnabled)
              : (readManagedHashHistoryEntry(window.history.state)?.disposition ?? 'permanent'),
          consumeActiveNewTab: true,
        });
      };

      if (isAuxiliaryDialogHash(window.location.hash)) {
        return;
      }
      const assetPath = assetPathFromHash(window.location.hash);
      if (assetPath) {
        const assetExt = assetPath.split('.').pop() ?? '';
        const mediaKind = mediaKindForSidebarAssetExtension(assetExt);
        if (mediaKind === 'excalidraw') {
          window.location.replace(hashFromDocName(assetPath));
          return;
        }
        mark('ok/nav/hash-change', { docName: null, kind: 'asset' });
        openHashTarget({
          kind: 'asset',
          target: assetPath,
          assetPath,
          mediaKind,
        });
        return;
      }
      const skillFile = skillFileFromHash(window.location.hash);
      if (skillFile) {
        mark('ok/nav/hash-change', { docName: null, kind: 'skill-file' });
        openHashTarget({
          kind: 'skill-file',
          target: `${skillFile.scope}/${skillFile.name}${skillFile.host ? `:${skillFile.host}` : ''}/${skillFile.path}`,
          scope: skillFile.scope,
          name: skillFile.name,
          path: skillFile.path,
          ...(skillFile.host ? { host: skillFile.host } : {}),
        });
        return;
      }
      if (skillsFromHash(window.location.hash)) {
        if (activeNewTabId !== null) {
          latchSurfaceHash();
          return;
        }
        if (isSurfaceHashRepeat) return;
        mark('ok/nav/hash-change', { docName: null, kind: 'skills' });
        openTargetTransition({ kind: 'skills', target: 'skills' }, { deliberate });
        return;
      }
      const skillPreview = skillPreviewFromHash(window.location.hash);
      if (skillPreview) {
        mark('ok/nav/hash-change', { docName: null, kind: 'skill-preview' });
        openHashTarget({
          kind: 'skill-preview',
          target: `${skillPreview.flavor}/${skillPreview.source}/${skillPreview.name}`,
          flavor: skillPreview.flavor,
          source: skillPreview.source,
          name: skillPreview.name,
          subtitle: skillPreview.subtitle,
          level: skillPreview.level,
          path: skillPreview.path,
        });
        return;
      }
      if (isContentRootHash(window.location.hash)) {
        mark('ok/nav/hash-change', { docName: null, kind: 'folder' });
        openHashTarget({ kind: 'folder', target: '', folderPath: '' });
        return;
      }
      const docName = docNameFromHash(window.location.hash);
      if (!docName) {
        if (activeNewTabId !== null) {
          latchSurfaceHash();
          return;
        }
        if (isSurfaceHashRepeat) return;
        mark('ok/nav/hash-change', { docName: null, kind: 'clear' });
        clearTarget();
        return;
      }
      if (loading) {
        mark('ok/nav/hash-change', { docName, kind: 'deferred-loading' });
        return;
      }
      const resolved =
        exactOpenMarkdownTabTarget(docName, openTabs) ??
        resolveNavigationTarget(docName, {
          pages,
          folderPaths,
          pagesBySlug,
          pagesByBasename,
        });
      if (resolved.kind === 'missing' && /\/+$/.test(docName.trim())) {
        mark('ok/nav/hash-change', { docName, kind: 'deferred-missing-folder' });
        return;
      }
      const target = withLargeFileOpenGuard(downgradeFolderIndexForHashNav(resolved), pageMeta);
      mark('ok/nav/hash-change', { docName, kind: target.kind });
      openHashTarget(target);
    }
    window.addEventListener('popstate', onPopState);
    window.addEventListener('hashchange', onHashChange);
    return () => {
      window.removeEventListener('popstate', onPopState);
      window.removeEventListener('hashchange', onHashChange);
    };
  }, [
    activeNewTabId,
    activeTabId,
    activeTarget,
    clearTarget,
    folderPaths,
    loading,
    openTargetTransition,
    openTabs,
    pageMeta,
    pages,
    pagesBySlug,
    pagesByBasename,
    previewTabsEnabled,
    tabSessionLoaded,
  ]);

  return null;
}

function InstallInClaudeDesktopTrigger() {
  const [open, setOpen] = useState(
    typeof window !== 'undefined' && window.location.hash === INSTALL_DIALOG_HASH,
  );

  useEffect(() => {
    function onHashChange() {
      if (window.location.hash === INSTALL_DIALOG_HASH) setOpen(true);
    }
    window.addEventListener('hashchange', onHashChange);
    return () => window.removeEventListener('hashchange', onHashChange);
  }, []);

  function handleOpenChange(next: boolean) {
    setOpen(next);
    if (!next && window.location.hash === INSTALL_DIALOG_HASH) {
      clearHashWithoutNavigation();
    }
  }

  return <InstallInClaudeDesktopDialog open={open} onOpenChange={handleOpenChange} />;
}

function SettingsShortcutHandler() {
  useEffect(() => {
    function onKeyDown(e: KeyboardEvent) {
      if (isOverlayLayerOpen()) return;
      const target = e.target as { tagName?: string; isContentEditable?: boolean } | null;
      if (
        isSettingsShortcut({
          target,
          metaKey: e.metaKey,
          ctrlKey: e.ctrlKey,
          altKey: e.altKey,
          key: e.key,
        })
      ) {
        e.preventDefault();
        openSettings();
      }
    }

    window.addEventListener('keydown', onKeyDown);
    return () => window.removeEventListener('keydown', onKeyDown);
  }, []);

  return null;
}

function ActiveTargetBridgePush() {
  const { activeTarget } = useDocumentContext();
  const bridge = typeof window !== 'undefined' ? (window.okDesktop ?? null) : null;

  const kind =
    activeTarget?.kind === 'doc' ||
    activeTarget?.kind === 'folder' ||
    activeTarget?.kind === 'asset'
      ? activeTarget.kind
      : null;
  const identifier =
    activeTarget?.kind === 'doc'
      ? activeTarget.docName
      : activeTarget?.kind === 'folder'
        ? activeTarget.folderPath
        : activeTarget?.kind === 'asset'
          ? activeTarget.assetPath
          : null;

  useEffect(() => {
    if (!bridge) return;
    if (kind === null) {
      bridge.editor.notifyActiveTargetChanged({ kind: null });
      return;
    }
    if (identifier === null) return;
    bridge.editor.notifyActiveTargetChanged({ kind, identifier });
  }, [bridge, kind, identifier]);

  return null;
}

function NewItemShortcutHandler() {
  const { activeDocName, activeTarget } = useDocumentContext();
  const { pages, addPage } = usePageList();
  const [dialogOpen, setDialogOpen] = useState(false);
  const initialDir =
    activeTarget?.kind === 'folder' ? activeTarget.folderPath : defaultInitialDir(activeDocName);
  const folderConfig = useFolderConfig(initialDir);
  const folderState = folderConfig.state;
  const createInFlightRef = useRef(false);

  useEffect(() => {
    function onKeyDown(e: KeyboardEvent) {
      if (isOverlayLayerOpen()) return;
      const target = e.target as { tagName?: string; isContentEditable?: boolean } | null;
      if (
        !isNewItemShortcut({
          target,
          metaKey: e.metaKey,
          ctrlKey: e.ctrlKey,
          altKey: e.altKey,
          shiftKey: e.shiftKey,
          key: e.key,
        })
      ) {
        return;
      }
      e.preventDefault();
      if (
        folderState.status !== 'ready' ||
        (folderState.data.folder.templates_available ?? []).length > 0
      ) {
        setDialogOpen(true);
        return;
      }
      if (createInFlightRef.current) return;
      createInFlightRef.current = true;
      const docName = nextUntitledDocName(initialDir, pages);
      void createPageRequest({ path: `${docName}.md`, kind: 'file' })
        .then((result) => {
          if (!result.ok) {
            toast.error(result.error);
            setDialogOpen(true);
            return;
          }
          openCreatedPage(result.docName, addPage);
        })
        .catch((err: unknown) => {
          console.warn('[NewItemShortcutHandler] create tail failed:', err);
          setDialogOpen(true);
        })
        .finally(() => {
          createInFlightRef.current = false;
        });
    }

    window.addEventListener('keydown', onKeyDown);
    return () => window.removeEventListener('keydown', onKeyDown);
  }, [folderState, initialDir, pages, addPage]);

  return (
    <NewItemDialog
      open={dialogOpen}
      onOpenChange={setDialogOpen}
      kind="file"
      initialDir={initialDir}
      folderConfig={folderConfig}
    />
  );
}

function ConfigProviderHost({ children }: { children: ReactNode }) {
  const { collabUrl, collabTerminal } = useDocumentContext();
  useServerKeepalive(collabUrl);
  return (
    <ConfigProvider collabUrl={collabUrl} collabTerminal={collabTerminal}>
      <EditorLifecycleFlush />
      <BackgroundThrottleReporter />
      <StaleTabReloadPrompt />
      <ExternalHandoffGateProvider>{children}</ExternalHandoffGateProvider>
    </ConfigProvider>
  );
}

function PreviewTabsSettingsBridge({ children }: { children: ReactNode }) {
  const { merged } = useConfigContext();
  const { promoteAllPreviewTabs } = useDocumentContext();

  useEffect(() => {
    if (merged?.editor?.previewTabs === false) promoteAllPreviewTabs();
  }, [merged?.editor?.previewTabs, promoteAllPreviewTabs]);

  return children;
}

export function App() {
  return (
    <ProfilerBoundary name="app">
      <DocumentProvider>
        <ConfigProviderHost>
          <ConflictsProvider>
            <DocNoticesProvider>
              <PreviewTabsSettingsBridge>
                <SingleFileModeProvider>
                  <AppBody />
                </SingleFileModeProvider>
              </PreviewTabsSettingsBridge>
            </DocNoticesProvider>
          </ConflictsProvider>
        </ConfigProviderHost>
      </DocumentProvider>
    </ProfilerBoundary>
  );
}

function AppBody() {
  const desktopBridge = typeof window !== 'undefined' ? (window.okDesktop ?? null) : null;
  const isElectronHost = typeof window !== 'undefined' && window.okDesktop != null;
  const [commandPaletteOpen, setCommandPaletteOpen] = useState(false);
  const singleFile = useSingleFileMode();
  const noteWindow = isNoteWindow();

  const showAppHeader = !noteWindow;
  const appHeaderStyle: CSSProperties | undefined = showAppHeader
    ? ({ '--ok-app-header-height': APP_HEADER_HEIGHT } as CSSProperties)
    : undefined;

  const installedClis = useInstalledClis();
  const terminalLaunch: TerminalLaunchContextValue | null =
    desktopBridge && desktopBridge.config.ptyAvailable === true
      ? {
          launchInTerminal: (input, cli) => {
            requestTerminalLaunch(composeTerminalLaunchPrompt(input, cli), cli);
          },
          installedClis,
        }
      : null;

  return (
    <div data-app-shell="" className="contents" style={appHeaderStyle}>
      <ConnectingBanner />
      <BranchRecycleBanner />
      <PageListProvider>
        <NoteWindowMainActionReceiver />
        {!noteWindow && <SystemDocSubscriber />}
        <ValidationFreshness />
        <SkillTrackInGitDialog />
        <NavigationHandler />
        <ActiveTargetBridgePush />
        <NewItemShortcutHandler />
        {!singleFile && !noteWindow && <SettingsShortcutHandler />}
        {SHOW_INSTALL_SKILL && <InstallInClaudeDesktopTrigger />}
        {desktopBridge ? <CreateProjectMenuTrigger bridge={desktopBridge} /> : null}
        {desktopBridge ? <ReportBugMenuTrigger /> : null}
        {desktopBridge ? <FeedbackMenuTrigger /> : null}
        <McpConsentDialog />
        {desktopBridge ? (
          <Suspense fallback={null}>
            <ShareBranchSwitchDialog bridge={desktopBridge} />
            <ShareReceiveMissDialog />
          </Suspense>
        ) : null}
        {!noteWindow && (
          <CommandPalette
            bridge={desktopBridge}
            open={commandPaletteOpen}
            onOpenChange={setCommandPaletteOpen}
          />
        )}
        {isElectronHost && !showAppHeader && (
          <div
            aria-hidden="true"
            data-testid="editor-window-chrome-drag-strip"
            data-electron-drag=""
            className="pointer-events-none fixed inset-x-0 top-0 z-50 h-2 [-webkit-app-region:drag]"
          />
        )}
        <TerminalLaunchProvider value={terminalLaunch}>
          <CommentQueueShortcut />
          {showAppHeader && <AppHeader onOpenSearch={() => setCommandPaletteOpen(true)} />}
          <SidebarProvider className="h-[calc(100vh-var(--ok-app-header-height,0px))] min-h-[calc(100svh-var(--ok-app-header-height,0px))]">
            <FileListHostProvider enabled={showAppHeader && !singleFile} fileList={<FileSidebar />}>
              <div
                data-app-main=""
                className={cn(
                  'relative flex w-full flex-1 flex-col',
                  showAppHeader
                    ? 'ps-2 pe-2 pb-2 h-[calc(100vh-var(--ok-app-header-height,0px))]'
                    : 'h-screen overflow-hidden bg-background',
                )}
              >
                <EditorPane />
              </div>
            </FileListHostProvider>
          </SidebarProvider>
        </TerminalLaunchProvider>
        {showAppHeader && !singleFile && <CornerCardStack />}
      </PageListProvider>
    </div>
  );
}