feat: real-time log viewer and add facet parsing and rendering for post content

TODO.md

···
 
 ## Milestone 6 — Facets & Log Viewer
 
-- [ ] Frontend: facet parser — convert UTF-8 byte offsets to JS string indices
-- [ ] Frontend: facet renderer — links (`<a>`), mentions (`@handle`), hashtags (`#tag`)
-- [ ] Integrate rendered facets into post text in data table rows
-- [ ] Implement `LogService` — custom `io.Writer` that emits `log:line` events
-- [ ] Wire `LogService` writer into `log.NewWithOptions` alongside file writer
-- [ ] Frontend: log viewer panel with terminal-style dark background, monospace text
-- [ ] Auto-scroll to bottom with scroll-lock toggle
-- [ ] Level filter buttons: Debug, Info, Warn, Error
+- [x] Frontend: facet parser — convert UTF-8 byte offsets to JS string indices
+- [x] Frontend: facet renderer — links (`<a>`), mentions (`@handle`), hashtags (`#tag`)
+- [x] Integrate rendered facets into post text in data table rows
+- [x] Implement `LogService` — custom `io.Writer` that emits `log:line` events
+- [x] Wire `LogService` writer into `log.NewWithOptions` alongside file writer
+- [x] Frontend: log viewer panel with terminal-style dark background, monospace text
+- [x] Auto-scroll to bottom with scroll-lock toggle
+- [x] Level filter buttons: Debug, Info, Warn, Error
 
 ## Milestone 7 — Polish
 

app.go

···
 	authService   *AuthService
 	indexService  *IndexService
 	searchService *SearchService
+	logService    *LogService
 }
 
 // NewApp creates a new App application struct
···
 		authService:   NewAuthService(),
 		indexService:  NewIndexService(),
 		searchService: NewSearchService(),
+		logService:    NewLogService(),
 	}
 }
 
···
 	a.ctx = ctx
 
 	a.indexService.SetContext(ctx)
+	a.logService.SetContext(ctx)
+
+	// Initialize log service first
+	if err := a.logService.Initialize(); err != nil {
+		runtime.LogErrorf(a.ctx, "failed to initialize log service: %v", err)
+	} else {
+		// Initialize the global logger with our log service
+		InitLogger(a.logService)
+		LogInfo("Application started")
+	}
 
 	dbPath := getDBPath()
 	if err := Open(dbPath); err != nil {
···
 
 // shutdown is called when the app shuts down
 func (a *App) shutdown(ctx context.Context) {
+	if err := a.logService.Close(); err != nil {
+		runtime.LogErrorf(ctx, "failed to close log service: %v", err)
+	}
 	if err := Close(); err != nil {
 		runtime.LogErrorf(ctx, "failed to close database: %v", err)
 	}

frontend/src/App.svelte

···
   import { EventsOn } from "../wailsjs/runtime/runtime";
   import SearchBar from "./lib/components/SearchBar.svelte";
   import DataTable from "./lib/components/DataTable.svelte";
+  import LogViewer from "./lib/components/LogViewer.svelte";
   import type { main } from "../wailsjs/go/models";
 
   type AuthInfo = { handle: string; did: string };
···
   let sortColumn = $state("created_at");
   let sortDirection = $state<"asc" | "desc">("desc");
   let isSearching = $state(false);
+  let showLogs = $state(false);
 
   onMount(async () => {
     await checkAuthStatus();
···
           </div>
 
           <div class="flex items-center gap-3">
+            <button
+              onclick={() => showLogs = !showLogs}
+              class="font-mono text-xs px-3 py-2 rounded bg-surface border border-outline hover:bg-outline text-bright transition-colors {showLogs ? 'bg-[#333]' : ''}">
+              {showLogs ? 'Hide Logs' : 'Show Logs'}
+            </button>
+
             <div class="flex items-center gap-2">
               <label for="refreshLimit" class="font-sans text-xs text-muted">Limit:</label>
               <input
···
           <DataTable posts={searchResults} {sortColumn} {sortDirection} onSort={handleSort} />
         {/if}
       </div>
+
+      <!-- Log Viewer -->
+      <LogViewer visible={showLogs} />
 
       <!-- Progress Bar (bottom pinned) -->
       {#if showProgress}

frontend/src/lib/components/DataTable.svelte

···
 <script lang="ts">
   import { BrowserOpenURL } from "../../../wailsjs/runtime/runtime";
   import type { main } from "../../../wailsjs/go/models";
+  import PostText from "./PostText.svelte";
 
   interface Props {
     posts: main.SearchResult[];
···
             </td>
 
             <td class="px-4 py-3 font-mono text-sm text-bright">
-              <div class="line-clamp-2">{truncateText(post.text)}</div>
+              <div class="line-clamp-2">
+                <PostText text={post.text} facetsJson={post.facets} maxLength={120} />
+              </div>
             </td>
 
             <td class="px-4 py-3 font-mono text-xs text-muted">

frontend/src/lib/components/LogViewer.svelte

···
+<script lang="ts">
+  import { EventsOn } from "../../../wailsjs/runtime/runtime";
+  import { onMount } from "svelte";
+
+  type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+
+  interface LogEntry {
+    level: LogLevel;
+    message: string;
+    timestamp: string;
+  }
+
+  interface Props {
+    visible: boolean;
+  }
+
+  let { visible }: Props = $props();
+
+  let logs = $state<LogEntry[]>([]);
+  let scrollLock = $state(false);
+  let logContainer: HTMLDivElement | undefined = $state(undefined);
+  let filterLevel = $state<LogLevel | "ALL">("ALL");
+
+  const levels: LogLevel[] = ["DEBUG", "INFO", "WARN", "ERROR"];
+
+  const levelColors: Record<LogLevel, string> = {
+    DEBUG: "text-gray-500",
+    INFO: "text-blue-400",
+    WARN: "text-yellow-400",
+    ERROR: "text-red-400",
+  };
+
+  const levelBgColors: Record<LogLevel | "ALL", string> = {
+    ALL: "bg-gray-700",
+    DEBUG: "bg-gray-600",
+    INFO: "bg-blue-600",
+    WARN: "bg-yellow-600",
+    ERROR: "bg-red-600",
+  };
+
+  function formatTimestamp(timestamp: string): string {
+    const date = new Date(timestamp);
+    return date.toLocaleTimeString("en-US", {
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+    });
+  }
+
+  function scrollToBottom() {
+    if (logContainer && !scrollLock) {
+      logContainer.scrollTop = logContainer.scrollHeight;
+    }
+  }
+
+  function toggleScrollLock() {
+    scrollLock = !scrollLock;
+  }
+
+  function setFilterLevel(level: LogLevel | "ALL") {
+    filterLevel = level;
+  }
+
+  function clearLogs() {
+    logs = [];
+  }
+
+  function filteredLogs() {
+    if (filterLevel === "ALL") {
+      return logs;
+    }
+    return logs.filter((log) => log.level === filterLevel);
+  }
+
+  onMount(() => {
+    EventsOn("log:line", (entry: LogEntry) => {
+      logs = [...logs, entry];
+
+      if (logs.length > 1000) {
+        logs = logs.slice(logs.length - 1000);
+      }
+
+      setTimeout(scrollToBottom, 0);
+    });
+
+    EventsOn("log:cleared", () => {
+      logs = [];
+    });
+  });
+
+  $effect(() => {
+    if (!scrollLock) {
+      setTimeout(scrollToBottom, 0);
+    }
+  });
+</script>
+
+{#if visible}
+  <div class="border-t border-outline bg-black flex flex-col">
+    <!-- Header -->
+    <div class="flex items-center justify-between px-4 py-2 bg-surface border-b border-outline">
+      <div class="flex items-center gap-2">
+        <span class="font-mono text-sm text-bright">Logs</span>
+        <span class="font-mono text-xs text-muted">({logs.length})</span>
+      </div>
+
+      <div class="flex items-center gap-2">
+        <!-- Level Filter Buttons -->
+        <div class="flex items-center gap-1 mr-4">
+          {#each ["ALL", ...levels] as level}
+            <button
+              onclick={() => setFilterLevel(level as LogLevel | "ALL")}
+              class="font-mono text-xs px-2 py-1 rounded transition-colors {filterLevel === level
+                ? levelBgColors[level] + ' text-white'
+                : 'bg-black text-muted hover:text-bright'}">
+              {level}
+            </button>
+          {/each}
+        </div>
+
+        <!-- Scroll Lock Toggle -->
+        <button
+          onclick={toggleScrollLock}
+          class="font-mono text-xs px-2 py-1 rounded transition-colors {scrollLock
+            ? 'bg-yellow-600 text-white'
+            : 'bg-black text-muted hover:text-bright'}"
+          title={scrollLock ? "Scroll locked" : "Auto-scroll enabled"}>
+          {#if scrollLock}
+            <span class="flex items-center">
+              <i class="i-ri-lock-2-line"></i>
+            </span>
+          {:else}
+            <span class="flex items-center">
+              <i class="i-ri-arrow-down-box-line"></i>
+            </span>
+          {/if}
+        </button>
+
+        <!-- Clear Button -->
+        <button
+          onclick={clearLogs}
+          class="font-mono text-xs px-2 py-1 rounded bg-black text-muted hover:text-red-400 transition-colors">
+          Clear
+        </button>
+      </div>
+    </div>
+
+    <!-- Log Container -->
+    <div
+      bind:this={logContainer}
+      class="flex-1 overflow-y-auto p-2 font-mono text-xs space-y-0.5"
+      style="max-height: 200px;">
+      {#each filteredLogs() as log}
+        <div class="flex items-start gap-2 hover:bg-white/5 px-1 rounded">
+          <span class="text-muted shrink-0">{formatTimestamp(log.timestamp)}</span>
+          <span class="{levelColors[log.level]} shrink-0 w-12">[{log.level}]</span>
+          <span class="text-bright break-all">{log.message}</span>
+        </div>
+      {:else}
+        <div class="text-muted text-center py-4">No logs</div>
+      {/each}
+    </div>
+  </div>
+{/if}

frontend/src/lib/components/PostText.svelte

···
+<script lang="ts">
+  import { parseFacets, renderFacets, truncateRenderedFacets, type Facet } from "../facets";
+
+  interface Props {
+    text: string;
+    facetsJson?: string;
+    maxLength?: number;
+    class?: string;
+  }
+
+  let { text, facetsJson = "", maxLength = 0, class: className = "" }: Props = $props();
+
+  function getRenderedFacets(text: string, facetsJson: string, maxLength: number) {
+    const facets = parseFacets(facetsJson);
+    const rendered = renderFacets(text, facets);
+    
+    if (maxLength > 0 && maxLength < text.length) {
+      const { facets: truncated } = truncateRenderedFacets(rendered, maxLength);
+      return truncated;
+    }
+    
+    return rendered;
+  }
+
+  let renderedFacets = $derived(getRenderedFacets(text, facetsJson, maxLength));
+</script>
+
+<span class="{className}">
+  {#each renderedFacets as facet}
+    {#if facet.type === 'link'}
+      <a 
+        href={facet.href} 
+        target="_blank" 
+        rel="noopener noreferrer"
+        class="text-blue-400 hover:text-blue-300 hover:underline"
+        onclick={(e) => e.stopPropagation()}>
+        {facet.text}
+      </a>
+    {:else if facet.type === 'mention'}
+      <a 
+        href={facet.href} 
+        target="_blank" 
+        rel="noopener noreferrer"
+        class="text-blue-400 hover:text-blue-300 hover:underline"
+        onclick={(e) => e.stopPropagation()}>
+        {facet.text}
+      </a>
+    {:else if facet.type === 'tag'}
+      <a 
+        href={facet.href} 
+        target="_blank" 
+        rel="noopener noreferrer"
+        class="text-pink-400 hover:text-pink-300 hover:underline"
+        onclick={(e) => e.stopPropagation()}>
+        {facet.text}
+      </a>
+    {:else}
+      <span>{facet.text}</span>
+    {/if}
+  {/each}
+</span>

frontend/src/lib/facets.ts

···
+export type FacetFeature = { [key: string]: any; $type: string };
+
+export type FacetByteSlice = { byteStart: number; byteEnd: number };
+
+export interface Facet {
+  index: FacetByteSlice;
+  features: FacetFeature[];
+}
+
+type FacetKind = "link" | "mention" | "tag" | "text";
+
+export type RenderedFacet = { type: FacetKind; text: string; href?: string; did?: string; tag?: string };
+
+/**
+ * Convert UTF-8 byte offsets to JS string indices (UTF-16 code units)
+ */
+function byteOffsetToCharIndex(text: string, byteOffset: number): number {
+  const encoder = new TextEncoder();
+  let currentByte = 0;
+
+  for (const [i, char] of Array.from(text).entries()) {
+    const charBytes = encoder.encode(char).length;
+
+    if (currentByte >= byteOffset) {
+      return i;
+    }
+
+    currentByte += charBytes;
+  }
+
+  return text.length;
+}
+
+/**
+ * Parse a facets JSON string and return parsed Facet objects
+ */
+export function parseFacets(facetsJson: string): Facet[] {
+  if (!facetsJson) return [];
+
+  try {
+    const parsed = JSON.parse(facetsJson);
+    if (Array.isArray(parsed)) {
+      return parsed as Facet[];
+    }
+  } catch (e) {
+    console.warn("Failed to parse facets:", e);
+  }
+
+  return [];
+}
+
+/**
+ * Render facets into an array of RenderedFacet objects
+ * This converts byte offsets to JS string indices and extracts the text segments
+ */
+export function renderFacets(text: string, facets: Facet[]): RenderedFacet[] {
+  if (!facets || facets.length === 0) {
+    return [{ type: "text", text }];
+  }
+
+  const sortedFacets = [...facets].sort((a, b) => a.index.byteStart - b.index.byteStart);
+
+  const result: RenderedFacet[] = [];
+  let lastByteEnd = 0;
+
+  for (const facet of sortedFacets) {
+    if (facet.index.byteStart > lastByteEnd) {
+      const beforeStart = byteOffsetToCharIndex(text, lastByteEnd);
+      const beforeEnd = byteOffsetToCharIndex(text, facet.index.byteStart);
+      const beforeText = text.slice(beforeStart, beforeEnd);
+      if (beforeText) {
+        result.push({ type: "text", text: beforeText });
+      }
+    }
+
+    const facetStart = byteOffsetToCharIndex(text, facet.index.byteStart);
+    const facetEnd = byteOffsetToCharIndex(text, facet.index.byteEnd);
+    const facetText = text.slice(facetStart, facetEnd);
+
+    for (const feature of facet.features) {
+      const type = feature.$type;
+
+      if (type === "app.bsky.richtext.facet#link") {
+        result.push({ type: "link", text: facetText, href: feature.uri });
+      } else if (type === "app.bsky.richtext.facet#mention") {
+        result.push({
+          type: "mention",
+          text: facetText,
+          did: feature.did,
+          href: `https://bsky.app/profile/${feature.did}`,
+        });
+      } else if (type === "app.bsky.richtext.facet#tag") {
+        result.push({
+          type: "tag",
+          text: facetText,
+          tag: feature.tag,
+          href: `https://bsky.app/search?q=%23${encodeURIComponent(feature.tag)}`,
+        });
+      } else {
+        result.push({ type: "text", text: facetText });
+      }
+
+      // TODO: parse ALL features
+      break;
+    }
+
+    lastByteEnd = facet.index.byteEnd;
+  }
+
+  const encoder = new TextEncoder();
+  const textBytes = encoder.encode(text).length;
+  if (lastByteEnd < textBytes) {
+    const remainingStart = byteOffsetToCharIndex(text, lastByteEnd);
+    const remainingText = text.slice(remainingStart);
+    if (remainingText) {
+      result.push({ type: "text", text: remainingText });
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Get plain text with facets stripped (for truncation)
+ */
+export function getPlainText(text: string, facets: Facet[]): string {
+  return text;
+}
+
+/**
+ * Truncate rendered facets to a maximum length while preserving facet boundaries
+ */
+export function truncateRenderedFacets(
+  rendered: RenderedFacet[],
+  maxLen: number,
+): { facets: RenderedFacet[]; truncated: boolean } {
+  let currentLength = 0;
+  const result: RenderedFacet[] = [];
+  let truncated = false;
+
+  for (const facet of rendered) {
+    const remaining = maxLen - currentLength;
+
+    if (remaining <= 0) {
+      truncated = true;
+      break;
+    }
+
+    if (facet.text.length <= remaining) {
+      result.push(facet);
+      currentLength += facet.text.length;
+    } else {
+      const truncatedText = facet.text.slice(0, remaining) + "...";
+      result.push({ ...facet, text: truncatedText });
+      truncated = true;
+      break;
+    }
+  }
+
+  return { facets: result, truncated };
+}

log_service.go

···
+package main
+
+import (
+	"bufio"
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/wailsapp/wails/v2/pkg/runtime"
+)
+
+// LogLevel represents the severity of a log message
+type LogLevel string
+
+const (
+	DebugLevel LogLevel = "DEBUG"
+	InfoLevel  LogLevel = "INFO"
+	WarnLevel  LogLevel = "WARN"
+	ErrorLevel LogLevel = "ERROR"
+)
+
+// LogEntry represents a single log entry
+type LogEntry struct {
+	Level     string    `json:"level"`
+	Message   string    `json:"message"`
+	Timestamp time.Time `json:"timestamp"`
+}
+
+// LogService provides logging functionality via Wails bindings
+type LogService struct {
+	ctx        context.Context
+	mu         sync.RWMutex
+	entries    []LogEntry
+	maxEntries int
+	file       *os.File
+	writer     *LogWriter
+	level      LogLevel
+}
+
+// LogWriter implements io.Writer and emits Wails events
+type LogWriter struct {
+	service *LogService
+	mu      sync.Mutex
+}
+
+func (w *LogWriter) Write(p []byte) (n int, err error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+
+	lines := strings.Split(string(p), "\n")
+	for _, line := range lines {
+		line = strings.TrimSpace(line)
+		if line == "" {
+			continue
+		}
+
+		// Parse the log level from the line
+		level := w.parseLevel(line)
+
+		entry := LogEntry{
+			Level:     string(level),
+			Message:   line,
+			Timestamp: time.Now(),
+		}
+
+		w.service.addEntry(entry)
+		w.service.emitLogLine(entry)
+	}
+
+	return len(p), nil
+}
+
+func (w *LogWriter) parseLevel(line string) LogLevel {
+	upper := strings.ToUpper(line)
+	if strings.Contains(upper, "ERROR") || strings.Contains(upper, "ERR") {
+		return ErrorLevel
+	}
+	if strings.Contains(upper, "WARN") || strings.Contains(upper, "WARNING") {
+		return WarnLevel
+	}
+	if strings.Contains(upper, "DEBUG") || strings.Contains(upper, "DBG") {
+		return DebugLevel
+	}
+	return InfoLevel
+}
+
+// NewLogService creates a new LogService instance
+func NewLogService() *LogService {
+	return &LogService{
+		entries:    make([]LogEntry, 0),
+		maxEntries: 1000,
+		level:      InfoLevel,
+	}
+}
+
+// SetContext sets the Wails context for event emission
+func (s *LogService) SetContext(ctx context.Context) {
+	s.ctx = ctx
+}
+
+// Initialize sets up the log service with a file writer
+func (s *LogService) Initialize() error {
+	// Open log file
+	logPath := s.getLogPath()
+	logDir := filepath.Dir(logPath)
+	if err := os.MkdirAll(logDir, 0755); err != nil {
+		return fmt.Errorf("failed to create log directory: %w", err)
+	}
+
+	file, err := os.OpenFile(logPath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to open log file: %w", err)
+	}
+	s.file = file
+
+	// Create the log writer
+	s.writer = &LogWriter{service: s}
+
+	return nil
+}
+
+// Close closes the log file
+func (s *LogService) Close() error {
+	if s.file != nil {
+		return s.file.Close()
+	}
+	return nil
+}
+
+// GetWriter returns the io.Writer for logging
+func (s *LogService) GetWriter() io.Writer {
+	if s.writer == nil {
+		return io.Discard
+	}
+	return s.writer
+}
+
+// GetMultiWriter returns a MultiWriter that writes to both the log file and the event emitter
+func (s *LogService) GetMultiWriter() io.Writer {
+	if s.file == nil || s.writer == nil {
+		return io.Discard
+	}
+	return io.MultiWriter(s.file, s.writer)
+}
+
+// GetEntries returns all log entries
+func (s *LogService) GetEntries() []LogEntry {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	result := make([]LogEntry, len(s.entries))
+	copy(result, s.entries)
+	return result
+}
+
+// GetEntriesByLevel returns log entries filtered by level
+func (s *LogService) GetEntriesByLevel(level string) []LogEntry {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	var result []LogEntry
+	for _, entry := range s.entries {
+		if entry.Level == level {
+			result = append(result, entry)
+		}
+	}
+	return result
+}
+
+// Clear clears all log entries
+func (s *LogService) Clear() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.entries = make([]LogEntry, 0)
+	s.emitLogCleared()
+}
+
+// SetLevel sets the minimum log level
+func (s *LogService) SetLevel(level string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	s.level = LogLevel(level)
+}
+
+// GetLevel returns the current log level
+func (s *LogService) GetLevel() string {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	return string(s.level)
+}
+
+func (s *LogService) addEntry(entry LogEntry) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+
+	// Only add if level is >= current level
+	if !s.shouldLog(entry.Level) {
+		return
+	}
+
+	s.entries = append(s.entries, entry)
+
+	// Trim if exceeding max entries
+	if len(s.entries) > s.maxEntries {
+		s.entries = s.entries[len(s.entries)-s.maxEntries:]
+	}
+}
+
+func (s *LogService) shouldLog(entryLevel string) bool {
+	levels := map[LogLevel]int{
+		DebugLevel: 0,
+		InfoLevel:  1,
+		WarnLevel:  2,
+		ErrorLevel: 3,
+	}
+
+	entryIdx := levels[LogLevel(entryLevel)]
+	currentIdx := levels[s.level]
+
+	return entryIdx >= currentIdx
+}
+
+func (s *LogService) emitLogLine(entry LogEntry) {
+	if s.ctx != nil {
+		runtime.EventsEmit(s.ctx, "log:line", entry)
+	}
+}
+
+func (s *LogService) emitLogCleared() {
+	if s.ctx != nil {
+		runtime.EventsEmit(s.ctx, "log:cleared", map[string]any{})
+	}
+}
+
+func (s *LogService) getLogPath() string {
+	if path := os.Getenv("BSKY_BROWSER_LOG"); path != "" {
+		return path
+	}
+
+	configDir := os.Getenv("XDG_CONFIG_HOME")
+	if configDir == "" {
+		home, _ := os.UserHomeDir()
+		configDir = filepath.Join(home, ".config")
+	}
+
+	appDir := filepath.Join(configDir, "bsky-browser", "logs")
+	timestamp := time.Now().Format("2006-01-02_15-04-05")
+	return filepath.Join(appDir, fmt.Sprintf("bsky-browser_%s.log", timestamp))
+}
+
+// BufferedLogWriter wraps a writer with buffering for better performance
+type BufferedLogWriter struct {
+	writer  *bufio.Writer
+	service *LogService
+}
+
+func NewBufferedLogWriter(service *LogService) *BufferedLogWriter {
+	return &BufferedLogWriter{
+		writer:  bufio.NewWriter(service.GetMultiWriter()),
+		service: service,
+	}
+}
+
+func (w *BufferedLogWriter) Write(p []byte) (n int, err error) {
+	return w.writer.Write(p)
+}
+
+func (w *BufferedLogWriter) Flush() error {
+	return w.writer.Flush()
+}

logger.go

···
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+// AppLogger provides application logging that writes to both file and Wails events
+type AppLogger struct {
+	stdLogger *log.Logger
+	service   *LogService
+}
+
+var appLogger *AppLogger
+
+// InitLogger initializes the application logger with the log service
+func InitLogger(service *LogService) {
+	multiWriter := service.GetMultiWriter()
+	appLogger = &AppLogger{
+		stdLogger: log.New(multiWriter, "", log.LstdFlags|log.Lshortfile),
+		service:   service,
+	}
+
+	// Redirect standard log to our logger
+	log.SetOutput(multiWriter)
+}
+
+// GetLogger returns the global app logger
+func GetLogger() *AppLogger {
+	if appLogger == nil {
+		// Fallback to stdout if not initialized
+		return &AppLogger{
+			stdLogger: log.New(os.Stdout, "", log.LstdFlags),
+		}
+	}
+	return appLogger
+}
+
+// Debug logs a debug message
+func (l *AppLogger) Debug(msg string) {
+	l.stdLogger.Printf("[DEBUG] %s", msg)
+}
+
+// Debugf logs a formatted debug message
+func (l *AppLogger) Debugf(format string, args ...interface{}) {
+	l.stdLogger.Printf("[DEBUG] "+format, args...)
+}
+
+// Info logs an info message
+func (l *AppLogger) Info(msg string) {
+	l.stdLogger.Printf("[INFO] %s", msg)
+}
+
+// Infof logs a formatted info message
+func (l *AppLogger) Infof(format string, args ...interface{}) {
+	l.stdLogger.Printf("[INFO] "+format, args...)
+}
+
+// Warn logs a warning message
+func (l *AppLogger) Warn(msg string) {
+	l.stdLogger.Printf("[WARN] %s", msg)
+}
+
+// Warnf logs a formatted warning message
+func (l *AppLogger) Warnf(format string, args ...interface{}) {
+	l.stdLogger.Printf("[WARN] "+format, args...)
+}
+
+// Error logs an error message
+func (l *AppLogger) Error(msg string) {
+	l.stdLogger.Printf("[ERROR] %s", msg)
+}
+
+// Errorf logs a formatted error message
+func (l *AppLogger) Errorf(format string, args ...interface{}) {
+	l.stdLogger.Printf("[ERROR] "+format, args...)
+}
+
+// Fatal logs a fatal message and exits
+func (l *AppLogger) Fatal(msg string) {
+	l.stdLogger.Fatalf("[FATAL] %s", msg)
+}
+
+// Fatalf logs a formatted fatal message and exits
+func (l *AppLogger) Fatalf(format string, args ...interface{}) {
+	l.stdLogger.Fatalf("[FATAL] "+format, args...)
+}
+
+// Convenience functions that use the global logger
+func LogDebug(msg string) {
+	GetLogger().Debug(msg)
+}
+
+func LogDebugf(format string, args ...interface{}) {
+	GetLogger().Debugf(format, args...)
+}
+
+func LogInfo(msg string) {
+	GetLogger().Info(msg)
+}
+
+func LogInfof(format string, args ...interface{}) {
+	GetLogger().Infof(format, args...)
+}
+
+func LogWarn(msg string) {
+	GetLogger().Warn(msg)
+}
+
+func LogWarnf(format string, args ...interface{}) {
+	GetLogger().Warnf(format, args...)
+}
+
+func LogError(msg string) {
+	GetLogger().Error(msg)
+}
+
+func LogErrorf(format string, args ...interface{}) {
+	GetLogger().Errorf(format, args...)
+}
+
+func LogFatal(msg string) {
+	GetLogger().Fatal(msg)
+}
+
+func LogFatalf(format string, args ...interface{}) {
+	GetLogger().Fatalf(format, args...)
+}
+
+// String returns a string representation of the logger
+func (l *AppLogger) String() string {
+	return fmt.Sprintf("AppLogger{initialized: %v}", l.service != nil)
+}

main.go

···
 		BackgroundColour: &options.RGBA{R: 0, G: 0, B: 0, A: 1},
 		OnStartup:        app.startup,
 		OnShutdown:       app.shutdown,
-		Bind:             []any{app, app.authService, app.indexService, app.searchService},
+		Bind:             []any{app, app.authService, app.indexService, app.searchService, app.logService},
 	})
 
 	if err != nil {