Lumotia/src/routes/+layout.svelte

<script lang="ts">
  // @ts-nocheck
  import "../app.css";
  import { onMount, onDestroy } from "svelte";
  import { invoke } from "@tauri-apps/api/core";
  import Sidebar from "$lib/Sidebar.svelte";
  import TaskSidebar from "$lib/components/TaskSidebar.svelte";
  import Titlebar from "$lib/components/Titlebar.svelte";
  import ToastViewport from "$lib/components/ToastViewport.svelte";
  import ResizeHandles from "$lib/components/ResizeHandles.svelte";
  import FocusTimer from "$lib/components/FocusTimer.svelte";
  import MorningTriageModal from "$lib/components/MorningTriageModal.svelte";
  import { hasTauriRuntime } from "$lib/utils/runtime.js";
  import { loadOsInfo, isLinux } from "$lib/utils/osInfo.js";
  import { page, settings, saveSettings } from "$lib/stores/page.svelte.js";
  import {
    getPreferences,
    updatePreferences,
    applyExternalPreferences,
    PREFERENCES_CHANGED_EVENT,
  } from "$lib/stores/preferences.svelte.js";
  import { profilesStore } from "$lib/stores/profiles.svelte.ts";
  import { getCurrentWindow } from "@tauri-apps/api/window";
  import { listen } from "@tauri-apps/api/event";
  import { toasts } from "$lib/stores/toasts.svelte.js";
  import { initI18n } from "$lib/i18n";
  import { refreshLlmStatus } from "$lib/stores/llmStatus.svelte.js";
  import { startNudgeBus, stopNudgeBus } from "$lib/stores/nudgeBus.svelte.ts";
  import {
    startImplementationIntentions,
    stopImplementationIntentions,
  } from "$lib/stores/implementationIntentions.svelte.ts";

  import { page as sveltePage } from "$app/stores";

  // Set up svelte-i18n once per app instance. Safe to call from every
  // window — initI18n guards itself against re-init.
  initI18n();

  let { children } = $props();

  const prefs = getPreferences();
  const tauriRuntimeAvailable = hasTauriRuntime();

  // On Linux Lumotia uses native KWin/Mutter decorations (see
  // src-tauri/tauri.linux.conf.json and windows.rs). Frameless custom
  // chrome stays for macOS and Windows. Default to false so Linux users
  // don't see a flash of custom titlebar before loadOsInfo resolves.
  let useCustomChrome = $state(false);


  // Detect secondary windows (float, viewer) — they use +layout@.svelte
  // but as a fallback, hide chrome if the URL matches
  let isSecondaryWindow = $derived(
    $sveltePage.url.pathname.startsWith("/float") ||
    $sveltePage.url.pathname.startsWith("/viewer")
  );

  // Theme — migrate from old class-based to new data-attribute system
  // The preferences store handles DOM application via data-theme attribute
  $effect(() => {
    // Sync legacy settings.theme → preferences store
    const legacyTheme = settings.theme;
    const mapped = legacyTheme === "Light" ? "light" : legacyTheme === "Dark" ? "dark" : "system";
    if (prefs.theme !== mapped) {
      updatePreferences({ theme: mapped });
    }
  });

  // Global hotkey registration — dual backend
  // Wayland: evdev via lumotia-hotkey crate (works without display server)
  // X11/macOS/Windows: tauri-plugin-global-shortcut (native)
  let registeredHotkey = null;
  let hotkeyBackend = $state("unknown"); // "evdev" | "tauri" | "unavailable"

  async function initHotkeyBackend() {
    if (!tauriRuntimeAvailable) {
      hotkeyBackend = "unavailable";
      return;
    }
    try {
      const isWayland = await invoke("is_wayland_session");
      if (isWayland) {
        // Try evdev backend first (Wayland-compatible)
        try {
          await invoke("check_hotkey_access");
          hotkeyBackend = "evdev";
          console.log("Hotkey backend: evdev (Wayland)");
        } catch (err) {
          console.warn("evdev hotkey access denied:", err);
          console.warn("Add your user to the 'input' group for global hotkeys on Wayland");
          hotkeyBackend = "unavailable";
        }
      } else {
        hotkeyBackend = "tauri";
        console.log("Hotkey backend: tauri-plugin-global-shortcut (X11)");
      }
    } catch {
      // Fallback to tauri plugin if detection fails
      hotkeyBackend = "tauri";
    }
  }

  async function registerGlobalHotkey(hotkey) {
    if (!tauriRuntimeAvailable) return;
    if (hotkeyBackend === "unknown") return; // not yet initialised

    // Only the main window owns the global shortcut. Secondary windows
    // (tasks-float, transcript-viewer, transcription-preview) inherit the
    // root layout via SvelteKit's `+layout@.svelte` break — they don't
    // mount this code, but cross-window settings sync via localStorage
    // can still re-fire `$effect(() => settings.globalHotkey)` callbacks
    // in webviews where this function happens to be in scope. Guard so
    // we don't trigger an ACL-denied register from a popout's webview.
    try {
      const label = (await import("@tauri-apps/api/window")).getCurrentWindow().label;
      if (label !== "main") return;
    } catch {
      // If the window-label probe fails, fall through — main is the
      // expected default and the ACL will catch a misuse.
    }

    try {
      if (hotkeyBackend === "evdev") {
        // evdev backend: start or update the Rust-side listener
        if (registeredHotkey) {
          await invoke("update_evdev_hotkey", { hotkey });
        } else {
          await invoke("start_evdev_hotkey", { hotkey });
        }
        registeredHotkey = hotkey;
      } else if (hotkeyBackend === "tauri") {
        // Tauri plugin backend (X11/macOS/Windows)
        const mod = await import("@tauri-apps/plugin-global-shortcut");
        if (registeredHotkey) {
          await mod.unregister(registeredHotkey).catch(() => {});
        }
        await mod.register(hotkey, () => {
          if (page.current !== "dictation") page.current = "dictation";
          requestAnimationFrame(() => {
            window.dispatchEvent(new CustomEvent("lumotia:toggle-recording"));
          });
        });
        registeredHotkey = hotkey;
      }
    } catch (err) {
      console.error("Hotkey registration failed:", err);
      const msg = err instanceof Error ? err.message : String(err);
      toasts.error(
        "Hotkey not registered",
        `${hotkey}. ${msg}. Reverted to ${registeredHotkey ?? "previous value"}.`,
      );
      // Revert the in-memory setting to the last successfully-registered hotkey
      // so the UI does not lie about what is actually bound.
      if (registeredHotkey && registeredHotkey !== hotkey) {
        settings.globalHotkey = registeredHotkey;
        saveSettings();
      }
    }
  }

  // Listen for evdev hotkey events from the Rust backend.
  //
  // Debounce window: evdev autorepeat, a sticky-key compositor quirk,
  // or a user's nervous double-tap can all deliver the same press
  // twice within ~100 ms — which, without debouncing, toggles the
  // recording into and out of the same frame and loses the capture.
  // Matches Handy #1143 ('first press records nothing, second works').
  // This is the UX side of brief item #4; the audio-stream warm-up
  // side is owned by Workstream A.
  const HOTKEY_DEBOUNCE_MS = 120;
  let lastHotkeyAtMs = 0;
  let unlistenEvdev = null;
  async function setupEvdevListener() {
    if (!tauriRuntimeAvailable) return;
    const { listen } = await import("@tauri-apps/api/event");
    unlistenEvdev = await listen("lumotia:hotkey-pressed", () => {
      const now = Date.now();
      if (now - lastHotkeyAtMs < HOTKEY_DEBOUNCE_MS) return;
      lastHotkeyAtMs = now;
      if (page.current !== "dictation") page.current = "dictation";
      requestAnimationFrame(() => {
        window.dispatchEvent(new CustomEvent("lumotia:toggle-recording"));
      });
    });
  }

  $effect(() => {
    if (hotkeyBackend === "evdev" && !unlistenEvdev) {
      setupEvdevListener();
    }
  });

  $effect(() => {
    if (hotkeyBackend !== "unknown") {
      registerGlobalHotkey(settings.globalHotkey);
    }
  });

  // Apply font size setting as CSS variable (legacy, kept for backwards compat).
  // Scoped to <body> rather than documentElement so the write only invalidates
  // styles on the body subtree (transcript surfaces inherit from body anyway).
  $effect(() => {
    document.body.style.setProperty("--font-size-transcript", `${settings.fontSize}px`);
  });

  // Custom widgets that should swallow single-letter shortcuts so they don't
  // accidentally trigger global hotkeys while focused.
  const CUSTOM_WIDGET_SELECTOR =
    '[role="combobox"], [role="listbox"], [role="radio"], [role="switch"], [role="menuitem"], [role="tab"]';

  // Check whether the keydown originates from a text input or custom widget
  // (avoid triggering shortcuts while typing or while focus sits in a
  // SegmentedButton, ZonePicker, or similar ARIA-roled control).
  function isInputFocused(e) {
    const tag = e.target?.tagName;
    if (tag === "INPUT" || tag === "TEXTAREA" || e.target?.isContentEditable) {
      return true;
    }
    const active = document.activeElement;
    if (active && typeof active.closest === "function" && active.closest(CUSTOM_WIDGET_SELECTOR)) {
      return true;
    }
    return false;
  }

  function handleKeydown(e) {
    if (e.key === "Escape" && page.taskSidebarOpen) {
      page.taskSidebarOpen = false;
      return;
    }
    if (e.key === "[" && !isInputFocused(e)) {
      settings.sidebarCollapsed = !settings.sidebarCollapsed;
      saveSettings();
    }
  }

  function handleResize() {
    if (window.innerWidth < 900 && !settings.sidebarCollapsed) {
      settings.sidebarCollapsed = true;
      saveSettings();
    }
  }

  // Phase 5: tray menu routes "Evening wind-down" here so the page
  // opens on whichever window the user clicks from. Unlisten on
  // destroy like every other subscription in this file.
  let unlistenWindDown = null;
  async function setupWindDownListener() {
    if (!tauriRuntimeAvailable) return;
    unlistenWindDown = await listen("lumotia:open-wind-down", () => {
      page.current = "shutdown";
    });
  }

  // Cross-window preference sync: apply updates broadcast by any other
  // window (float, viewer) while skipping our own echoes.
  let unlistenPrefs = null;
  async function setupPreferencesSync() {
    if (!tauriRuntimeAvailable) return;
    let ownLabel = null;
    try { ownLabel = getCurrentWindow().label; } catch {}
    unlistenPrefs = await listen(PREFERENCES_CHANGED_EVENT, (event) => {
      const payload = event?.payload;
      if (!payload || payload.source === ownLabel) return;
      applyExternalPreferences(payload.prefs);
    });
  }

  // Capture global frontend errors and forward to the Rust error_log via
  // log_frontend_error. Best-effort: never let the error handler itself
  // throw, never crash the app over a logging failure.
  // (Diagnostics layer 1 — local only, never transmitted)
  let onWindowError = null;
  let onUnhandledRejection = null;

  function installGlobalErrorCapture() {
    if (!hasTauriRuntime()) return;

    const safeLog = (context, message, stack) => {
      try {
        invoke("log_frontend_error", { context, message: String(message ?? ""), stack: stack ?? null })
          .catch(() => { /* swallow — diagnostic logging must never throw */ });
      } catch { /* same */ }
    };

    onWindowError = (ev) => {
      safeLog(
        "window.onerror",
        ev?.message || ev?.error?.message || "Unknown error",
        ev?.error?.stack || null,
      );
    };

    onUnhandledRejection = (ev) => {
      const reason = ev?.reason;
      const msg = (reason && (reason.message || String(reason))) || "Unhandled rejection";
      safeLog("unhandledrejection", msg, reason?.stack || null);
    };

    window.addEventListener("error", onWindowError);
    window.addEventListener("unhandledrejection", onUnhandledRejection);
  }

  onMount(async () => {
    // Auto-collapse if window is already narrow on first load
    handleResize();
    window.addEventListener("resize", handleResize);

    // Cross-window preference sync (no-op outside Tauri).
    setupPreferencesSync();

    // Phase 5: subscribe to tray wind-down event.
    setupWindDownListener();

    // Phase 6: start the nudge bus. The bus is self-gated on
    // settings.nudgesEnabled internally — starting it here is cheap
    // (just event listeners + two intervals), and means users don't
    // need to restart after flipping the toggle.
    startNudgeBus();
    startImplementationIntentions();

    // Diagnostics: capture every uncaught frontend error to error_log.
    installGlobalErrorCapture();

    // OS detection: warm the cache so components can use modKeyLabel() /
    // isMac() / isWayland() synchronously after first render. We also
    // use the result to decide whether to render the custom Titlebar +
    // ResizeHandles (non-Linux) or rely on native decorations (Linux).
    loadOsInfo()
      .then(() => { useCustomChrome = !isLinux(); })
      .catch(() => { /* fallback already populated */ });

    if (!tauriRuntimeAvailable) {
      hotkeyBackend = "unavailable";
      return;
    }

    // Detect and initialise the correct hotkey backend
    await initHotkeyBackend();

    // Load profiles (per-profile vocabulary + initial prompt). Task 15.
    await profilesStore.load();

    try {
      const whisper = await invoke("list_models");
      const parakeet = await invoke("list_parakeet_models");
      if (whisper.length === 0 && parakeet.length === 0) {
        page.current = "first-run";
      }
    } catch {
      // If commands fail, skip first-run check
    }

    // Background update check — non-blocking, silent on failure
    invoke("check_for_update")
      .then((version) => {
        if (version) {
          toasts.info(`Lumotia ${version} is available. Download and restart to update.`);
        }
      })
      .catch(() => { /* update check failure must not affect the app */ });

    // Seed the LLM status chip (sidebar) with whichever state the
    // backend is in right now. The chip also reacts to the $effect
    // on settings.aiTier below and to explicit mark-generating
    // calls from DictationPage around cleanup_transcript_text_cmd.
    refreshLlmStatus(settings.aiTier).catch(() => {});

    if (settings.prewarmModelOnStartup) {
      invoke("prewarm_default_model_cmd").catch(() => {});
    }

    // Meeting auto-capture is wired up below as a `$effect` so the
    // 15-second poller only exists while the setting is enabled —
    // toggling off in Settings stops the wakeups, not just the work.
  });

  // Meeting auto-capture poller. Edge-triggered: the first time a matching
  // process appears we surface a non-modal toast; subsequent ticks where
  // the same match is still present stay quiet until the app exits and
  // returns. We never start recording from this signal — the user decides.
  //
  // The effect's only tracked dependencies are `tauriRuntimeAvailable`
  // (constant after mount) and `settings.meetingAutoCapture`. Reads of
  // `settings.meetingAutoCaptureApps` and `settings.globalHotkey` happen
  // inside the interval callback, which runs after the synchronous setup
  // and therefore is not tracked — editing the apps list doesn't tear
  // down the poller.
  $effect(() => {
    if (!tauriRuntimeAvailable) return;
    if (!settings.meetingAutoCapture) return;

    let previous: Set<string> = new Set();
    const id = window.setInterval(async () => {
      const patterns = settings.meetingAutoCaptureApps;
      if (!Array.isArray(patterns) || patterns.length === 0) return;
      try {
        const matches: string[] = await invoke("detect_meeting_processes", { patterns });
        const current = new Set(matches);
        for (const match of matches) {
          if (!previous.has(match)) {
            toasts.info(
              `${match[0].toUpperCase()}${match.slice(1)} detected`,
              `Press ${settings.globalHotkey} to start recording.`,
            );
          }
        }
        previous = current;
      } catch { /* ignore — backend may be mid-restart */ }
    }, 15000);

    return () => { window.clearInterval(id); };
  });

  onDestroy(() => {
    window.removeEventListener("resize", handleResize);
    if (onWindowError) window.removeEventListener("error", onWindowError);
    if (onUnhandledRejection) window.removeEventListener("unhandledrejection", onUnhandledRejection);
    if (!tauriRuntimeAvailable) {
      return;
    }
    if (hotkeyBackend === "evdev") {
      invoke("stop_evdev_hotkey").catch(() => {});
    } else if (hotkeyBackend === "tauri" && registeredHotkey) {
      import("@tauri-apps/plugin-global-shortcut")
        .then((mod) => mod.unregister(registeredHotkey))
        .catch(() => {});
    }
    if (unlistenEvdev) {
      unlistenEvdev();
    }
    if (unlistenPrefs) {
      unlistenPrefs();
    }
    if (unlistenWindDown) {
      unlistenWindDown();
    }
    stopNudgeBus();
    stopImplementationIntentions();
  });
</script>

<svelte:window onkeydown={handleKeydown} />


{#if isSecondaryWindow}
  <!-- Secondary windows (float, viewer) render children only — no shell chrome -->
  {@render children()}
{:else}
  <div class="flex flex-col h-screen w-screen overflow-hidden grain">
    {#if useCustomChrome}
      <Titlebar />
    {/if}
    <div class="flex flex-1 min-h-0 relative">
      {#if page.current !== "first-run"}
        <Sidebar />
      {/if}
      <div class="flex-1 overflow-hidden bg-bg">
        {@render children()}
      </div>
      {#if page.taskSidebarOpen && page.current !== "first-run"}
        <div class="w-[280px] min-w-[280px] shadow-xl">
          <TaskSidebar />
        </div>
      {/if}
    </div>
  </div>
{/if}

<!-- Global toast viewport. Mounted once at the app root so any component
     can call toasts.error(...), toasts.success(...) etc and have it render
     in the bottom-right of the viewport. (Day 3 of the upgrade plan) -->
<ToastViewport />

<!-- Global focus-timer overlay. Renders nothing until a `lumotia:start-timer`
     event fires; then pins a shrinking colour ring to the top-right.
     Phase 1 of the 2026-04-23 feature-complete roadmap — closes the
     visual-time-representation gap from docs/brief/feature-set.md and
     wires the dangling emit in MicroSteps.svelte. -->
<FocusTimer />

<!-- Phase 5: morning triage modal. Self-gated — no-op unless the user
     has enabled `ritualsMorning` and the local clock is past their set
     trigger time. Mounted here so it can appear over any page. -->
<MorningTriageModal />

<!-- Invisible resize margins for frameless (macOS/Windows). On Linux we
     use native decorations, so ResizeHandles would compete with the
     compositor's own resize and is suppressed. -->
{#if useCustomChrome}
  <ResizeHandles />
{/if}