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 { 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 { getCurrentWindow } from "@tauri-apps/api/window";
  import { listen } from "@tauri-apps/api/event";
  import { toasts } from "$lib/stores/toasts.svelte.js";

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

  let { children } = $props();

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

  // On Linux Kon 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 kon-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

    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("kon:toggle-recording"));
          });
        });
        registeredHotkey = hotkey;
      }
    } catch (err) {
      console.error("Hotkey registration failed:", err);
    }
  }

  // Listen for evdev hotkey events from the Rust backend
  let unlistenEvdev = null;
  async function setupEvdevListener() {
    if (!tauriRuntimeAvailable) return;
    const { listen } = await import("@tauri-apps/api/event");
    unlistenEvdev = await listen("kon:hotkey-pressed", () => {
      if (page.current !== "dictation") page.current = "dictation";
      requestAnimationFrame(() => {
        window.dispatchEvent(new CustomEvent("kon: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)
  $effect(() => {
    document.documentElement.style.setProperty("--font-size-transcript", `${settings.fontSize}px`);
  });

  // Check whether the keydown originates from a text input (avoid triggering while typing)
  function isInputFocused(e) {
    const tag = e.target?.tagName;
    return tag === "INPUT" || tag === "TEXTAREA" || e.target?.isContentEditable;
  }

  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();
    }
  }

  // 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();

    // 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();

    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(`Kon ${version} is available. Download and restart to update.`);
        }
      })
      .catch(() => { /* update check failure must not affect the app */ });
  });

  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();
    }
  });
</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 />

<!-- 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}