fix(deps): update all non-major dependencies (#4894)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

.air.toml

@@ -0,0 +1,57 @@
+root = "."
+testdata_dir = "testdata"
+tmp_dir = "tmp"
+
+[build]
+args_bin = []
+bin = "./tmp/dozzle"
+cmd = "go build -race -o ./tmp/dozzle ."
+delay = 1000
+exclude_dir = [
+  "assets",
+  "tmp",
+  "data",
+  "node_modules",
+  "docs",
+  "test-results",
+  "dist",
+  "e2e",
+  "examples",
+]
+exclude_file = []
+exclude_regex = ["_test.go"]
+exclude_unchanged = false
+follow_symlink = false
+full_bin = ""
+include_dir = []
+include_ext = ["go", "tpl", "tmpl", "html"]
+include_file = []
+kill_delay = "2s"
+log = "build-errors.log"
+poll = false
+poll_interval = 0
+post_cmd = []
+pre_cmd = []
+rerun = false
+rerun_delay = 500
+send_interrupt = true
+stop_on_error = true
+
+[color]
+app = ""
+build = "yellow"
+main = "magenta"
+runner = "green"
+watcher = "cyan"
+
+[log]
+main_only = false
+silent = false
+time = false
+
+[misc]
+clean_on_exit = false
+
+[screen]
+clear_on_rebuild = false
+keep_scroll = true

.claude/agent-memory/bug-hunter/MEMORY.md

@@ -0,0 +1,37 @@
+# Bug Hunter Agent Memory
+
+## Codebase Patterns
+
+### Notification System Architecture
+
+- `notification.Manager` owns subscriptions (xsync.Map) and dispatchers (xsync.Map)
+- Two processing goroutines: `processLogEvents` and `processStatEvents` started in `NewManager`
+- Stats listener has start/stop lifecycle; log listener is always-on once started
+- `MultiHostService` wraps Manager and handles config persistence + agent broadcast
+
+### Known Bug-Prone Areas
+
+- **broadcastNotificationConfig**: Has historically missed fields when converting between internal and types packages (APIKey, Prefix, ExpiresAt were missed)
+- **TriggeredContainerIDs lazy init**: Race condition risk - initialized lazily in AddTriggeredContainer without sync
+- **Channel close handling**: enrich() in stats_listener doesn't check for closed channel, can hot-spin
+- **LogAlertFields canSave**: Allows empty logExpression (no error = valid), creates dead subscriptions
+
+### Type Mapping Gotchas
+
+- `container.ContainerStat` -> `types.NotificationStat`: field names differ (CPUPercent vs cpu expr tag)
+- `notification.DispatcherConfig` -> `types.DispatcherConfig`: must copy ALL fields including APIKey, Prefix, ExpiresAt
+- Frontend `NotificationRule.cooldown` is optional, backend defaults to 300 via `GetCooldownSeconds()`
+
+### Concurrency Model
+
+- xsync.Map used throughout for concurrent access (subscriptions, dispatchers, activeStreams, containers)
+- Subscription fields use atomic types: TriggerCount (atomic.Int64), LastTriggeredAt (atomic.Pointer)
+- MetricCooldowns uses xsync.Map for per-container cooldown tracking
+- sendSem (semaphore.Weighted=5) limits concurrent notification sends
+
+### Container Update (feat/container-update)
+
+- **progressCh close contract**: Docker and Agent implementations close progressCh via defer; K8s does NOT, causing handler hang
+- **NetworkSettings nil risk**: `docker.InspectResponse.NetworkSettings` is a pointer; `ContainerCreate` doesn't nil-check before accessing `.Networks`
+- **Destructive recreate**: stop->remove->create->start has no rollback if create fails after remove
+- **SSE parsing in frontend**: Uses manual ReadableStream reader, not EventSource; no AbortController cleanup on unmount

.claude/agent-memory/go-perf-reviewer/MEMORY.md

@@ -0,0 +1,36 @@
+# Go Performance Reviewer Memory
+
+## Hot Paths Identified
+
+- **Stats processing pipeline**: `ContainerStatsListener.enrich()` -> channel -> `Manager.processStatEvents()` -> `processStatEvent()`. Runs continuously for every container stat tick (~1/sec per container).
+- **Log processing pipeline**: `ContainerLogListener` -> `logChannel` (buffered 1000) -> `Manager.processLogEvents()` -> `processLogEvent()`. Every log line from matched containers flows here.
+- Both pipelines do `expr.Run()` per subscription per event -- compiled programs are cached but still run per-event.
+
+## Architecture Notes
+
+- `ContainerStore.SubscribeStats` and `SubscribeEvents` both call `statsCollector.Start/Stop` -- multiple subscribers share the same collector. Stop-on-cancel can interfere across subscribers.
+- `xsync.Map` (from puzpuzpuz/xsync/v4) used extensively for concurrent maps. No built-in TTL/eviction.
+- `ContainerStatEvent` carries full `Container` + `Host` structs by value through channels. `Container` is ~200+ bytes (strings, map, RingBuffer pointer, times).
+- TTL caches in both listeners (`cachedContainerInfo`) lack eviction -- grow unboundedly with container churn.
+
+## Existing Patterns
+
+- Semaphore-based concurrency limiting: `sendSem` (weighted 5) for notification dispatch, `maxFetchParallelism` (30) for container fetching.
+- Lazy stats collection: stats collector starts on first subscriber, stops when last unsubscribes (but the multi-subscriber Stop race exists).
+- `sync.Pool` not currently used in notification/stats paths.
+- Cooldown tracking via `xsync.Map[string, time.Time]` per subscription -- also no eviction.
+
+## Key File Paths
+
+- `internal/container/container_store.go` -- Container store with stats collector lifecycle
+- `internal/notification/processing.go` -- Log + stat event processing (hot path)
+- `internal/notification/stats_listener.go` -- Stats subscription and enrichment
+- `internal/notification/log_listener.go` -- Log stream management
+- `internal/notification/manager.go` -- Subscription CRUD and listener orchestration
+- `internal/notification/types.go` -- Subscription matching (expr evaluation)
+- `internal/cloud/client.go` -- Cloud gRPC bidirectional streaming client
+- `internal/cloud/tools.go` -- Tool definitions and execution dispatch
+
+## Memory Files
+
+- [cloud_client_patterns.md](cloud_client_patterns.md) - Cloud gRPC client architecture and known patterns

.claude/agent-memory/go-perf-reviewer/cloud_client_patterns.md

@@ -0,0 +1,28 @@
+---
+name: Cloud gRPC Client Patterns
+description: Architecture of internal/cloud/ package - gRPC bidirectional streaming for cloud tool calls
+type: project
+---
+
+Cloud client (`internal/cloud/client.go`) uses a bidirectional gRPC stream (`ToolStream`) to receive tool requests from Dozzle Cloud and send responses.
+
+Key architecture:
+
+- `Client.Run()` is the reconnect loop with exponential backoff
+- `Client.connect()` creates a new `grpc.ClientConn` per reconnect (potential optimization: reuse connection)
+- `sendMu sync.Mutex` protects concurrent `stream.Send()` calls (tool calls dispatch to goroutines)
+- `toolSem` (weighted semaphore, max 5) limits concurrent tool execution
+- `apiKeyFunc` closure provides cloud API key; empty string means no cloud configured
+- PermissionDenied from server causes permanent stop (no retry)
+- Tool definitions cached via `sync.Once` + `cachedTools` field (fixed from prior re-serialization issue)
+- `Notify()` / `startCh` pattern ensures zero overhead for non-cloud users
+- Tool dispatch in `tools.go` uses typed proto responses (`CallToolResponse` with oneof `Result`)
+
+Known perf issues found (2026-04):
+
+- `containsIgnoreCase` in `tools_helpers.go` allocates two lowered strings per call; used in filter loops
+- `executeInspectContainer` calls `buildHostNameMap` to resolve a single host name
+- `executeFetchContainerLogs` doesn't drain log channel after early break (potential goroutine leak)
+- `fmt.Sprintf("%v", event.Message)` in log path uses reflect-based formatting
+
+**How to apply:** When reviewing future changes to this package, watch for: undrained channels from streaming APIs, per-call allocations in filter loops, and unnecessary API calls for single lookups.

.claude/agents/bug-hunter.md

@@ -0,0 +1,152 @@
+---
+name: bug-hunter
+description: "Use this agent when you need to review recently written or modified code for bugs, logic errors, edge cases, and unexpected behavior. This includes both Go backend code and Vue/TypeScript frontend code. This agent should be used after writing new features, fixing bugs, or refactoring code to catch issues before they reach production.\\n\\nExamples:\\n\\n- User writes a new HTTP handler in Go:\\n  user: \"I just added a new endpoint for container health checks\"\\n  assistant: \"Let me review the new code for potential bugs and edge cases.\"\\n  <uses Task tool to launch bug-hunter agent to review the recently changed files>\\n\\n- User implements a new Vue composable:\\n  user: \"I created a new composable for managing WebSocket reconnection\"\\n  assistant: \"I'll launch the bug hunter to review your new composable for edge cases and potential issues.\"\\n  <uses Task tool to launch bug-hunter agent to analyze the composable>\\n\\n- User modifies log parsing logic:\\n  user: \"I updated the event_generator.go to handle a new log format\"\\n  assistant: \"Let me have the bug hunter review your changes to ensure all edge cases in log parsing are covered.\"\\n  <uses Task tool to launch bug-hunter agent to review the modified parsing code>\\n\\n- After a chunk of code is written during a feature implementation:\\n  assistant: \"I've finished implementing the notification dispatcher. Let me run the bug hunter to check for issues.\"\\n  <uses Task tool to launch bug-hunter agent proactively to review the new code>"
+model: opus
+color: blue
+memory: project
+---
+
+You are an elite bug-hunting code reviewer with deep expertise in both Go backend systems and Vue 3/TypeScript frontend applications. You have extensive experience finding subtle bugs, race conditions, nil pointer dereferences, unhandled edge cases, type safety issues, and logic errors that slip past typical review. You think adversarially — always asking "what could go wrong here?"
+
+## Your Mission
+
+Review recently written or modified code to find bugs, logic errors, and uncovered edge cases. You focus on code that could fail at runtime, produce incorrect results, or behave unexpectedly under specific conditions.
+
+## Review Process
+
+1. **Identify Changed/New Code**: Use git status, git diff, or examine the files the user points you to. Focus on recently written code, not the entire codebase.
+
+2. **Analyze Each File Systematically**: For every file with changes, examine:
+   - Control flow paths (all branches of if/else, switch, select)
+   - Error handling (are errors checked? propagated correctly? logged?)
+   - Nil/undefined checks (pointer dereference in Go, optional chaining in TS)
+   - Concurrency safety (goroutine leaks, race conditions, channel operations)
+   - Resource cleanup (deferred closes, stream cleanup, event listener removal)
+   - Boundary conditions (empty arrays, zero values, max values, negative numbers)
+   - Type safety (type assertions in Go, type narrowing in TS)
+   - API contract adherence (correct HTTP status codes, proper SSE format, GraphQL schema alignment)
+
+3. **Cross-Layer Analysis**: Check that frontend and backend changes are consistent:
+   - API request/response shapes match between Go handlers and TypeScript types
+   - SSE event names and payload structures align
+   - GraphQL schema, resolvers, and frontend queries are in sync
+   - WebSocket message formats match on both sides
+
+## Go-Specific Bug Patterns to Check
+
+- **Nil pointer dereference**: Especially after type assertions, map lookups, and interface conversions
+- **Goroutine leaks**: Goroutines blocked on channels that are never closed or written to
+- **Race conditions**: Shared state accessed from multiple goroutines without synchronization
+- **Deferred closure in loops**: `defer` inside loops won't execute until function returns
+- **Error shadowing**: Using `:=` that shadows an outer `err` variable
+- **Slice/map initialization**: Operating on nil slices/maps (nil map write panics)
+- **Context cancellation**: Not respecting context.Done() in long-running operations
+- **HTTP response body leaks**: Not closing response bodies after HTTP calls
+- **Integer overflow**: Especially in stats calculations with uint64
+- **String/byte slice sharing**: Modifying a slice that shares underlying array
+- **Channel operations on nil channels**: Blocking forever on nil channel send/receive
+- **Mutex copy**: Passing sync.Mutex by value instead of pointer
+
+## Vue/TypeScript-Specific Bug Patterns to Check
+
+- **Reactive reference unwrapping**: Using `.value` correctly with `ref()` vs `reactive()`
+- **Computed dependency tracking**: Missing reactive dependencies in computed properties
+- **Watch cleanup**: Not cleaning up watchers, event listeners, or timers in `onUnmounted`
+- **SSE/EventSource cleanup**: Connections not properly closed on component unmount
+- **Array reactivity**: Using index assignment instead of reactive methods
+- **Optional chaining gaps**: Accessing nested properties without null checks
+- **Promise error handling**: Unhandled promise rejections, missing `.catch()` or try/catch
+- **Type narrowing issues**: Assuming a type without proper guards
+- **Stale closure references**: Callbacks capturing outdated reactive values
+- **Memory leaks**: Growing arrays without bounds (check maxLogs enforcement, statsHistory rolling window)
+- **Race conditions in async operations**: Component unmounted before async operation completes
+- **Incorrect v-if/v-show usage**: Rendering components that depend on data not yet loaded
+- **Event buffer overflow**: Not handling backpressure in SSE streams
+
+## Project-Specific Concerns
+
+- **EMA calculations**: Alpha=0.2 for stats smoothing — verify division by zero, NaN handling
+- **Rolling window (300 items)**: Ensure proper eviction and no off-by-one errors
+- **Log entry type discrimination**: `LogEntry.create()` must handle all `logEvent.t` values
+- **Multi-host operations**: Container/host lookups via `FindContainer()`/`FindHost()` may return nil
+- **Docker API version negotiation**: Calls may fail on older Docker versions
+- **Protobuf serialization**: `FromProto()` methods must handle nil/empty fields
+- **Authentication modes**: Code must work correctly in all three auth modes (none, simple, forward-proxy)
+- **SSE buffering**: 250ms debounce with 1000ms max — verify timer cleanup
+- **CPU normalization**: Division by `cpuLimit` or `nCPU` — check for zero values
+
+## Output Format
+
+Follow ultra-brief mode as specified in the project guidelines:
+
+- Critical issues only (bugs, security, blockers)
+- Brief bullet points, no lengthy explanations
+- Skip verbose sections (no "Strengths", "Summary", etc.)
+- Include file:line references when relevant
+- Maximum ~10-15 lines per response
+
+For each bug found, report:
+
+- **File:line** — Brief description of the bug
+- **Severity**: 🔴 Critical (will crash/corrupt) | 🟡 Warning (could fail under specific conditions) | 🟠 Edge case (uncovered scenario)
+- One-line fix suggestion if obvious
+
+If no bugs are found, say so concisely. Do not fabricate issues.
+
+## Approach
+
+1. First, determine what code was recently changed (check git diff or ask the user)
+2. Read the changed files carefully
+3. For each file, apply the relevant bug pattern checklist above
+4. Cross-reference frontend and backend changes for consistency
+5. Report findings in the ultra-brief format
+
+Do NOT review code style, naming conventions, or suggest refactors unless they mask a bug. Focus exclusively on correctness.
+
+**Update your agent memory** as you discover recurring bug patterns, common error-prone code paths, areas of the codebase with historical issues, and edge cases specific to this project's architecture. This builds up institutional knowledge across conversations. Write concise notes about what you found and where.
+
+Examples of what to record:
+
+- Recurring nil-check omissions in specific packages
+- Components that frequently have cleanup issues
+- API endpoints with known edge case gaps
+- Stats calculation patterns that are error-prone
+- Log parsing paths that have caused issues before
+
+# Persistent Agent Memory
+
+You have a persistent Persistent Agent Memory directory at `/Users/araminfar/Workspace/dozzle/.claude/agent-memory/bug-hunter/`. Its contents persist across conversations.
+
+As you work, consult your memory files to build on previous experience. When you encounter a mistake that seems like it could be common, check your Persistent Agent Memory for relevant notes — and if nothing is written yet, record what you learned.
+
+Guidelines:
+
+- `MEMORY.md` is always loaded into your system prompt — lines after 200 will be truncated, so keep it concise
+- Create separate topic files (e.g., `debugging.md`, `patterns.md`) for detailed notes and link to them from MEMORY.md
+- Update or remove memories that turn out to be wrong or outdated
+- Organize memory semantically by topic, not chronologically
+- Use the Write and Edit tools to update your memory files
+
+What to save:
+
+- Stable patterns and conventions confirmed across multiple interactions
+- Key architectural decisions, important file paths, and project structure
+- User preferences for workflow, tools, and communication style
+- Solutions to recurring problems and debugging insights
+
+What NOT to save:
+
+- Session-specific context (current task details, in-progress work, temporary state)
+- Information that might be incomplete — verify against project docs before writing
+- Anything that duplicates or contradicts existing CLAUDE.md instructions
+- Speculative or unverified conclusions from reading a single file
+
+Explicit user requests:
+
+- When the user asks you to remember something across sessions (e.g., "always use bun", "never auto-commit"), save it — no need to wait for multiple interactions
+- When the user asks to forget or stop remembering something, find and remove the relevant entries from your memory files
+- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project
+
+## MEMORY.md
+
+Your MEMORY.md is currently empty. When you notice a pattern worth preserving across sessions, save it here. Anything in MEMORY.md will be included in your system prompt next time.

.claude/agents/go-perf-reviewer.md

@@ -0,0 +1,145 @@
+---
+name: go-perf-reviewer
+description: "Use this agent when Go code has been written or modified and needs review for performance issues, inefficient patterns, or unnecessary resource loading. This agent focuses exclusively on Go backend code and should be triggered after changes to `.go` files.\\n\\nExamples:\\n\\n- user: \"I just added a new endpoint that fetches container stats\"\\n  assistant: \"Let me use the go-perf-reviewer agent to check the new endpoint for performance issues.\"\\n  <commentary>Since Go code was written for a new endpoint, use the Task tool to launch the go-perf-reviewer agent to review the changes for inefficient patterns.</commentary>\\n\\n- user: \"Can you review my changes to the Docker client wrapper?\"\\n  assistant: \"I'll launch the go-perf-reviewer agent to analyze your Docker client changes for performance concerns.\"\\n  <commentary>The user is asking for a review of Go code changes. Use the Task tool to launch the go-perf-reviewer agent to identify any performance anti-patterns.</commentary>\\n\\n- user: \"I refactored the log streaming pipeline\"\\n  assistant: \"Let me run the go-perf-reviewer agent against your refactored streaming code to catch any performance regressions.\"\\n  <commentary>Streaming code is performance-critical. Use the Task tool to launch the go-perf-reviewer agent to ensure the refactor doesn't introduce inefficiencies.</commentary>"
+model: opus
+color: green
+memory: project
+---
+
+You are an expert Go performance engineer with deep knowledge of runtime internals, memory allocation patterns, garbage collector behavior, and idiomatic high-performance Go. You specialize in reviewing Go code for performance anti-patterns in long-running server applications that interact with Docker, gRPC, and streaming APIs.
+
+**Core Philosophy**: Dozzle must be lean and lazy by default. It should never load, allocate, compute, or fetch anything until it is actually needed. Every byte of memory and every CPU cycle matters in a lightweight monitoring tool.
+
+## Your Review Process
+
+1. **Examine only the changed Go files**. Use available tools to read the recent changes or diffs.
+2. **Identify specific performance issues** — do not comment on style, naming, or correctness unless it directly causes a performance problem.
+3. **Provide actionable feedback** with file:line references and concrete fix suggestions.
+
+## Patterns to Flag
+
+### Memory & Allocation
+
+- Unnecessary allocations in hot paths (loops, stream handlers, per-request code)
+- Slice/map pre-allocation missing when size is known or estimable
+- `append` in tight loops without pre-sized slices
+- String concatenation with `+` instead of `strings.Builder` in loops
+- Returning large structs by value instead of pointer when appropriate
+- Unnecessary copies of large data (e.g., ranging over slice of structs by value)
+- `[]byte` ↔ `string` conversions that could be avoided
+- Creating closures in loops that capture loop variables unnecessarily
+- Allocating buffers per-call that could be pooled via `sync.Pool`
+
+### Lazy Loading & Eager Initialization
+
+- **Top priority**: Loading data, making API calls, or initializing resources before they are actually needed
+- Fetching all containers/stats when only a subset is requested
+- Initializing clients, connections, or caches at startup that may never be used
+- Reading entire files/streams into memory when streaming/pagination would suffice
+- Computing derived data eagerly when it could be computed on demand
+- Pre-populating maps/caches with all possible entries instead of lazy-filling
+
+### Concurrency & Goroutines
+
+- Goroutine leaks: goroutines without proper cancellation via `context.Context`
+- Missing `defer cancel()` after `context.WithCancel/WithTimeout`
+- Unbounded goroutine spawning without semaphore/worker pool
+- Channel misuse: unbuffered channels causing unnecessary blocking, or oversized buffered channels wasting memory
+- Holding locks longer than necessary; lock contention in hot paths
+- Using `sync.Mutex` where `sync.RWMutex` would reduce contention
+
+### I/O & Streaming
+
+- Not using `bufio.Reader`/`bufio.Writer` for I/O operations
+- Reading entire HTTP response bodies into memory (`io.ReadAll`) when streaming is possible
+- Not closing response bodies, readers, or connections (resource leaks)
+- Blocking I/O without timeouts or context cancellation
+- Serializing/deserializing JSON repeatedly when it could be done once
+- Using `encoding/json` in ultra-hot paths where a faster serializer is warranted
+
+### Docker/gRPC Specific
+
+- Making redundant Docker API calls (e.g., inspecting a container multiple times)
+- Not using Docker API filters to narrow results server-side
+- Fetching all container logs when `tail` or `since` parameters should limit scope
+- gRPC streams not properly drained or closed
+- Creating new Docker/gRPC clients per request instead of reusing
+
+### General Go Anti-Patterns
+
+- `reflect` usage in hot paths
+- `fmt.Sprintf` for simple string operations where direct concatenation suffices
+- `interface{}` / `any` boxing causing heap escapes
+- Unnecessary use of `defer` in tight loops (small but real overhead)
+- `time.After` in select loops (creates new timer each iteration; use `time.NewTimer` + `Reset`)
+- Regex compilation inside functions instead of package-level `var` with `regexp.MustCompile`
+- Sorting large slices repeatedly instead of maintaining sorted order
+
+## Output Format
+
+Use ultra-brief mode as specified by the project:
+
+- Critical performance issues only
+- Brief bullet points with file:line references
+- Concrete suggestion for each issue
+- Maximum ~10-15 lines per response
+- No praise sections, no summaries, no fluff
+
+Example output:
+
+```
+- `internal/docker/client.go:142` — `io.ReadAll(resp.Body)` reads entire log stream into memory. Stream with `bufio.Scanner` instead.
+- `internal/web/logs.go:87` — New `json.Encoder` created per log line in hot loop. Reuse encoder or use `sync.Pool`.
+- `internal/support/docker/manager.go:53` — All hosts initialized eagerly at startup. Defer client creation until first access.
+```
+
+If no performance issues are found, state that clearly in one line.
+
+**Update your agent memory** as you discover performance patterns, hot paths, allocation-heavy code paths, and architectural decisions in this codebase. This builds up institutional knowledge across conversations. Write concise notes about what you found and where.
+
+Examples of what to record:
+
+- Hot paths identified (log streaming, stats collection, event processing)
+- Existing `sync.Pool` usage or buffer reuse patterns
+- Known allocation-heavy areas
+- Docker API call patterns and caching strategies
+- gRPC streaming patterns used in agent mode
+- Areas where lazy loading is already implemented vs. missing
+
+# Persistent Agent Memory
+
+You have a persistent Persistent Agent Memory directory at `/Users/araminfar/Workspace/dozzle/.claude/agent-memory/go-perf-reviewer/`. Its contents persist across conversations.
+
+As you work, consult your memory files to build on previous experience. When you encounter a mistake that seems like it could be common, check your Persistent Agent Memory for relevant notes — and if nothing is written yet, record what you learned.
+
+Guidelines:
+
+- `MEMORY.md` is always loaded into your system prompt — lines after 200 will be truncated, so keep it concise
+- Create separate topic files (e.g., `debugging.md`, `patterns.md`) for detailed notes and link to them from MEMORY.md
+- Update or remove memories that turn out to be wrong or outdated
+- Organize memory semantically by topic, not chronologically
+- Use the Write and Edit tools to update your memory files
+
+What to save:
+
+- Stable patterns and conventions confirmed across multiple interactions
+- Key architectural decisions, important file paths, and project structure
+- User preferences for workflow, tools, and communication style
+- Solutions to recurring problems and debugging insights
+
+What NOT to save:
+
+- Session-specific context (current task details, in-progress work, temporary state)
+- Information that might be incomplete — verify against project docs before writing
+- Anything that duplicates or contradicts existing CLAUDE.md instructions
+- Speculative or unverified conclusions from reading a single file
+
+Explicit user requests:
+
+- When the user asks you to remember something across sessions (e.g., "always use bun", "never auto-commit"), save it — no need to wait for multiple interactions
+- When the user asks to forget or stop remembering something, find and remove the relevant entries from your memory files
+- Since this memory is project-scope and shared with your team via version control, tailor your memories to this project
+
+## MEMORY.md
+
+Your MEMORY.md is currently empty. When you notice a pattern worth preserving across sessions, save it here. Anything in MEMORY.md will be included in your system prompt next time.

.claude/settings.json

@@ -0,0 +1,25 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(gh pr view:*)",
+      "Bash(gh api:*)",
+      "Bash(gh issue view:*)",
+      "Bash(gh pr list:*)",
+      "WebFetch(domain:github.com)",
+      "Bash(make test:*)",
+      "Bash(go test:*)",
+      "Bash(go build:*)",
+      "Bash(pnpm test:*)",
+      "Bash(pnpm build:*)",
+      "Bash(pnpm typecheck:*)",
+      "Bash(pnpm list:*)",
+      "Bash(node --version:*)",
+      "Bash(git rebase:*)",
+      "Bash(git add:*)",
+      "Bash(git commit:*)",
+      "Bash(git checkout:*)",
+      "Bash(git push:*)",
+      "Bash(xargs ls:*)"
+    ]
+  }
+}

.claude/skills/update-int-snapshots/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: update-int-snapshots
+description: Use when Playwright visual snapshots in e2e/visual.spec.ts-snapshots/ need to be regenerated after a UI change (logo, theme, layout, anything that affects rendered pixels) and the integration suite needs to be rerun via make int
+---
+
+# Update Integration Snapshots
+
+## When to Use
+
+- A visual change landed (logo, color, spacing, fonts) and `make int` will fail on `visual.spec.ts` until snapshots are regenerated.
+- A snapshot test reports diffs you've confirmed are intentional.
+
+Do NOT use when diffs are unintentional regressions — investigate first.
+
+## Procedure
+
+1. **Delete the stale snapshots** so Playwright writes fresh ones (don't try to update in place, the old PNGs can confuse the diff):
+
+   ```bash
+   rm e2e/visual.spec.ts-snapshots/*.png
+   ```
+
+2. **Check for port 8080 conflicts.** The `custom_base` test container binds host port 8080. If another container is already on it (common: `doligence-api-1`), the run fails with `Bind for 0.0.0.0:8080 failed: port is already allocated`.
+
+   ```bash
+   docker ps --format '{{.Names}}\t{{.Ports}}' | grep ':8080->'
+   ```
+
+   If anything other than test containers is bound, stop it first (ask the user before stopping containers from other projects).
+
+3. **Run with `--update-snapshots` via `compose up`.** You must use `compose up` (not `compose run`) because the navigation sidebar snapshot includes the live container list, and the two modes produce different sibling containers. The cleanest way is to patch the playwright command in `docker-compose.yml` temporarily:
+
+   ```bash
+   sed -i.bak 's|command: npx --yes playwright test|command: npx --yes playwright test --update-snapshots|' docker-compose.yml
+   make int
+   mv docker-compose.yml.bak docker-compose.yml
+   ```
+
+   Snapshots must be generated in Linux/Chromium (the compose image), not macOS, because filenames include the platform suffix (e.g. `-chromium-linux.png`).
+
+4. **Verify** by rerunning the normal suite:
+
+   ```bash
+   make int
+   ```
+
+   Should now pass cleanly.
+
+5. **Commit the regenerated PNGs** alongside the UI change so CI stays green.
+
+## Common Mistakes
+
+- **Running `npx playwright test --update-snapshots` locally on macOS.** Generates `-darwin` filenames CI doesn't use. Always go through the docker compose image.
+- **Forgetting to delete first.** `--update-snapshots` does overwrite, but if the test layout changed (new test, renamed snapshot), stale PNGs are left behind. Wipe-and-regenerate is safest.
+- **Stopping unrelated containers without asking.** The port conflict is annoying but the user's other dev containers may be holding important state.
+
+## Quick Reference
+
+```bash
+rm e2e/visual.spec.ts-snapshots/*.png
+docker ps | grep ':8080->'   # confirm port free
+sed -i.bak 's|command: npx --yes playwright test|& --update-snapshots|' docker-compose.yml
+make int
+mv docker-compose.yml.bak docker-compose.yml
+make int   # verify pass
+```

.github/ISSUE_TEMPLATE/0_bug_report.yml

@@ -0,0 +1,65 @@
+name: 🐛 Bug Report
+labels: ["bug"]
+description: |
+  Use this template if something is not working as expected.
+body:
+  - type: markdown
+    attributes:
+      value: |
+        I get an overwhelming of issues which I don't have time to investigate. Most often, they are due to configuration issues. For this reason, I ask you to help me by providing as much information as possible. For issues with `docker-socket-proxy` I may not be able to help as those are not related to Dozzle.
+  - type: checkboxes
+    attributes:
+      label: 🔍 Check for existing issues
+      description: Check the backlog of issues to reduce the chances of creating duplicates; if an issue already exists, place a `+1` (👍) on it.
+      options:
+        - label: Completed
+          required: true
+  - type: dropdown
+    attributes:
+      label: How is Dozzle deployed?
+      description: Select the components that you are using.
+      options:
+        - Standalone Deployment
+        - Agents
+        - Remote Hosts
+        - Swarm Mode
+        - Kubernetes
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: 📦 Dozzle version
+      description: Run `docker run amir20/dozzle --version` or `curl http://<host>/api/version`.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: ✅ Command used to run Dozzle
+      description: Please provide the command used to run Dozzle. Provide docker-compose.yml if applicable.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 🐛 Describe the bug / provide steps to reproduce it
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    id: environment
+    attributes:
+      label: 💻 Environment
+      description: Run `docker system info` and paste the output in the field below.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 📜 Dozzle logs are required for debugging purposes. You may need to enable debug mode. See https://dozzle.dev/guide/debugging.
+      description: Drag log files or paste the logs into the text input below
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: 📸 If applicable, add screenshots to help explain your bug
+      description: Drag screenshots into the text input below
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/1_feature_request.yml

@@ -0,0 +1,20 @@
+name: 🚀 Feature Request
+labels: ["enhancement"]
+description: |
+  Use this template if you have a feature request or an idea for a new feature.
+body:
+  - type: textarea
+    attributes:
+      label: Describe the feature you would like to see
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe how you would like to see this feature implemented
+    validations:
+      required: false
+  - type: textarea
+    attributes:
+      label: Describe any alternatives you've considered
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/2_peformance_report.yml

@@ -0,0 +1,52 @@
+name: 🚤 Performance Issue
+labels: ["performance"]
+description: |
+  Use this template if you are seeing performance issues such as slow loading times or high CPU usage.
+body:
+  - type: checkboxes
+    attributes:
+      label: Check for existing issues
+      description: Check the backlog of issues to reduce the chances of creating duplicates; if an issue already exists, place a `+1` (👍) on it.
+      options:
+        - label: Completed
+          required: true
+  - type: dropdown
+    attributes:
+      label: How is Dozzle deployed?
+      description: Select the components that you are using.
+      options:
+        - Standalone Deployment
+        - Agents
+        - Remote Hosts
+        - Swarm Mode
+    validations:
+      required: true
+  - type: input
+    attributes:
+      label: Dozzle version
+      description: Can be found in logs or settings page.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: ✅ Command used to run Dozzle
+      description: Please provide the command used to run Dozzle. Provide docker-compose.yml if applicable.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the performance issue you are seeing
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: How many containers, hosts, agents, etc. are you using?
+      description: Any details to reproduce the issue would be helpful. If related to volume of logs, please provide a guesstimate of how many logs are being generated.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Screenshots, videos, or logs
+      description: Drag issues into the text input below
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/3_cloud_bug_report.yml

@@ -0,0 +1,30 @@
+name: "\u2601\uFE0F Dozzle Cloud Bug Report"
+labels: ["bug", "cloud"]
+description: |
+  Use this template for issues related to Dozzle Cloud.
+body:
+  - type: checkboxes
+    attributes:
+      label: Check for existing issues
+      description: Check the backlog of issues to reduce the chances of creating duplicates; if an issue already exists, place a `+1` on it.
+      options:
+        - label: Completed
+          required: true
+  - type: input
+    attributes:
+      label: Dozzle version
+      description: The version of Dozzle connected to Dozzle Cloud.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Describe the bug / provide steps to reproduce it
+      description: A clear and concise description of what the bug is.
+    validations:
+      required: true
+  - type: textarea
+    attributes:
+      label: Screenshots or logs
+      description: Drag screenshots or paste logs into the text input below.
+    validations:
+      required: false

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,33 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ""
-labels: ""
-assignees: amir20
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**To Reproduce**
-Steps to reproduce the behavior:
-
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Expected behavior**
-A clear and concise description of what you expected to happen.
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Desktop (please complete the following information):**
-
-- OS: [e.g. iOS, Windows or Mac Os]
-- Docker version [e.g. `docker version`'s output]
-- Browser & version [e.g. chrome, safari]
-- Version [e.g. 1.26.1. Can be found at `<Dozzle-host>/version`]
-
-**If applicable include logs with `--level debug` and browser logs**

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: 💁🏼 Common Issues
+    url: https://dozzle.dev/guide/faq
+    about: Check the FAQ for common issues.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,19 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ""
-labels: enhancement
-assignees: amir20
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/funding.yml

@@ -0,0 +1 @@
+buy_me_a_coffee: amirraminfar

.github/renovate.json

@@ -1,5 +1,13 @@
 {
   "$schema": "https://docs.renovatebot.com/renovate-schema.json",
-  "extends": ["config:base", "schedule:weekly", "group:allNonMajor", ":automergeMinor"],
-  "rangeStrategy": "bump"
+  "extends": ["config:recommended", "schedule:weekly", "group:allNonMajor", ":automergeMinor"],
+  "rangeStrategy": "bump",
+  "minimumReleaseAge": "24 hours",
+  "ignoreDeps": [],
+  "packageRules": [
+    {
+      "matchPackageNames": ["@playwright/test", "mcr.microsoft.com/playwright"],
+      "groupName": "playwright"
+    }
+  ]
 }

.github/stale.yml

@@ -6,6 +6,7 @@ daysUntilClose: 3
 exemptLabels:
   - pinned
   - security
+  - keep
 # Label to use when marking an issue as stale
 staleLabel: wontfix
 # Comment to post when marking an issue as stale. Set to `false` to disable

.github/workflows/claude-code-review.yml

@@ -0,0 +1,58 @@
+name: Claude Code Review
+
+on:
+  pull_request:
+    types: [opened, synchronize]
+    # Optional: Only run on specific file changes
+    # paths:
+    #   - "src/**/*.ts"
+    #   - "src/**/*.tsx"
+    #   - "src/**/*.js"
+    #   - "src/**/*.jsx"
+
+jobs:
+  claude-review:
+    # Optional: Filter by PR author
+    # if: |
+    #   github.event.pull_request.user.login == 'external-contributor' ||
+    #   github.event.pull_request.user.login == 'new-developer' ||
+    #   github.event.pull_request.author_association == 'FIRST_TIME_CONTRIBUTOR'
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
+      issues: read
+      id-token: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code Review
+        id: claude-review
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+          use_sticky_comment: true
+          prompt: |
+            REPO: ${{ github.repository }}
+            PR NUMBER: ${{ github.event.pull_request.number }}
+
+            Please review this pull request and provide feedback on:
+            - Code quality and best practices
+            - Potential bugs or issues
+            - Performance considerations
+            - Security concerns
+            - Test coverage
+
+            Use the repository's CLAUDE.md for guidance on style and conventions. Be constructive and helpful in your feedback.
+
+            Use `gh pr comment` with your Bash tool to leave your review as a comment on the PR.
+
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://docs.claude.com/en/docs/claude-code/cli-reference for available options
+          claude_args: '--allowed-tools "Bash(gh issue view:*),Bash(gh search:*),Bash(gh issue list:*),Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*)"'
+

.github/workflows/claude.yml

@@ -0,0 +1,53 @@
+name: Claude Code
+
+on:
+  issue_comment:
+    types: [created]
+  pull_request_review_comment:
+    types: [created]
+  issues:
+    types: [opened, assigned]
+  pull_request_review:
+    types: [submitted]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  claude:
+    if: |
+      (github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
+      (github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
+      (github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+      issues: write
+      id-token: write
+      actions: read # Required for Claude to read CI results on PRs
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 1
+
+      - name: Run Claude Code
+        id: claude
+        uses: anthropics/claude-code-action@v1
+        with:
+          claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
+
+          # This is an optional setting that allows Claude to read CI results on PRs
+          additional_permissions: |
+            actions: read
+
+          # Optional: Give a custom prompt to Claude. If this is not specified, Claude will perform the instructions specified in the comment that tagged it.
+          # prompt: 'Update the pull request description to include a summary of changes.'
+
+          # Optional: Add claude_args to customize behavior and configuration
+          # See https://github.com/anthropics/claude-code-action/blob/main/docs/usage.md
+          # or https://docs.claude.com/en/docs/claude-code/cli-reference for available options
+          # claude_args: '--allowed-tools Bash(gh pr:*)'

.github/workflows/deploy.yml

@@ -3,19 +3,24 @@ on:
     tags:
       - "v*"
 name: Test and Release
+
+permissions:
+  contents: read
+
 jobs:
   npm-test:
     name: JavaScript Tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         name: Install Node
         with:
           node-version: latest
+      - run: npm install --global corepack@latest
       - run: corepack enable
       - run: pnpm --version
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v7
         with:
           node-version: latest
           cache: "pnpm"
@@ -29,26 +34,34 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Install Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v7
         with:
-          go-version: 1.20.x
+          go-version: 1.26.5
+          check-latest: true
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v7
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+      - name: Install gRPC and Go
+        run: |
+          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
+          go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
       - name: Run Go Tests with Coverage
-        run: make test SKIP_ASSET=1
+        run: make test
   int-test:
     name: Integration Tests
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         name: Install Node
         with:
           node-version: latest
+      - run: npm install --global corepack@latest
       - run: corepack enable
       - run: pnpm --version
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v7
         with:
           node-version: latest
           cache: "pnpm"
@@ -56,17 +69,22 @@ jobs:
       - name: Install dependencies
         run: pnpm install
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v4
+      - name: Writing certs to file
+        run: |
+          echo "${{ secrets.TTL_KEY }}" > shared_key.pem
+          echo "${{ secrets.TTL_CERT }}" > shared_cert.pem
       - name: Build
-        uses: docker/bake-action@v3
+        uses: docker/bake-action@v7
         with:
+          source: .
           load: true
           set: |
             *.cache-from=type=gha
             *.cache-to=type=gha,mode=max
       - name: Run Playwright tests
         run: docker compose up --exit-code-from playwright
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v7
         if: always()
         with:
           name: playwright-report
@@ -76,24 +94,48 @@ jobs:
     needs: [go-test, npm-test, int-test]
     name: Release
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
     steps:
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: amir20/dozzle
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.9.1
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0
       - name: Login to DockerHub
-        uses: docker/login-action@v2.2.0
+        uses: docker/login-action@v4.6.0
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Log in to the Container registry
+        uses: docker/login-action@v4.6.0
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          images: |
+            amir20/dozzle
+            ghcr.io/amir20/dozzle
+          tags: |
+            type=raw,value=latest
+            type=semver,pattern={{version}},prefix=v
+            type=semver,pattern={{major}}.{{minor}},prefix=v
+            type=semver,pattern={{major}},prefix=v
+      - name: Writing certs to file
+        run: |
+          echo "${{ secrets.TTL_KEY }}" > shared_key.pem
+          echo "${{ secrets.TTL_CERT }}" > shared_cert.pem
       - name: Build and push
-        uses: docker/build-push-action@v4.1.1
+        uses: docker/build-push-action@v7.3.0
         with:
           push: true
-          platforms: linux/amd64,linux/arm/v7,linux/arm64/v8
+          sbom: true
+          context: .
+          platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64/v8
           tags: ${{ steps.meta.outputs.tags }}
           build-args: TAG=${{ steps.meta.outputs.version }}
           labels: ${{ steps.meta.outputs.labels }}
@@ -103,13 +145,15 @@ jobs:
     needs: [buildx]
     name: Github Release
     runs-on: ubuntu-latest
+    permissions:
+      contents: write
     steps:
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v7
         with:
           fetch-depth: 0
       - name: Install Node
-        uses: actions/setup-node@v3
+        uses: actions/setup-node@v7
       - name: Release to Github
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/dev.yml

@@ -6,31 +6,54 @@ on:
     branches:
       - master
 name: Push container
+
+permissions:
+  contents: read
+  packages: write
+
 jobs:
   buildx:
     name: Push branches and PRs
     runs-on: ubuntu-latest
     if: ${{ !github.event.repository.fork && !github.event.pull_request.head.repo.fork && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == 'amir20/dozzle') }}
     steps:
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v4
-        with:
-          images: amir20/dozzle
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2.9.1
+        uses: docker/setup-buildx-action@bb05f3f5519dd87d3ba754cc423b652a5edd6d2c # v4.2.0
       - name: Login to DockerHub
-        uses: docker/login-action@v2.2.0
+        uses: docker/login-action@v4.6.0
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
-      - name: Build and push
-        uses: docker/build-push-action@v4.1.1
+      - name: Log in to the Container registry
+        uses: docker/login-action@v4.6.0
         with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      - name: Checkout
+        uses: actions/checkout@v7
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v6
+        with:
+          images: |
+            amir20/dozzle
+            ghcr.io/amir20/dozzle
+      - name: Short SHA
+        id: sha
+        run: echo "short=${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
+      - name: Writing certs to file
+        run: |
+          echo "${{ secrets.TTL_KEY }}" > shared_key.pem
+          echo "${{ secrets.TTL_CERT }}" > shared_cert.pem
+      - name: Build and push
+        uses: docker/build-push-action@v7.3.0
+        with:
+          context: .
           push: true
-          platforms: linux/amd64,linux/arm/v7,linux/arm64/v8
+          platforms: linux/amd64,linux/arm64/v8
           tags: ${{ steps.meta.outputs.tags }}
-          build-args: TAG=${{ steps.meta.outputs.version }}
+          build-args: TAG=${{ steps.meta.outputs.version }}-${{ steps.sha.outputs.short }}
           labels: ${{ steps.meta.outputs.labels }}
           cache-from: type=gha
           cache-to: type=gha,mode=max

.github/workflows/pages.yml

@@ -0,0 +1,66 @@
+name: Deploy VitePress site to Pages
+
+on:
+  push:
+    branches: [master]
+
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: pages
+  cancel-in-progress: false
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v7
+        with:
+          fetch-depth: 0 # Not needed if lastUpdated is not enabled
+      - name: Install Node
+        uses: actions/setup-node@v7
+        with:
+          node-version: latest
+      - run: npm install --global corepack@latest
+      - run: corepack enable
+      - run: pnpm --version
+      - name: Setup Node
+        uses: actions/setup-node@v7
+        with:
+          node-version: latest
+          cache: pnpm # or pnpm / yarn
+      - name: Setup Pages
+        uses: actions/configure-pages@v6
+      - name: Install dependencies
+        run: pnpm install
+      - name: Build with VitePress
+        run: |
+          pnpm docs:build
+          touch docs/.vitepress/dist/.nojekyll
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v5
+        with:
+          path: docs/.vitepress/dist
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    needs: build
+    runs-on: ubuntu-latest
+    name: Deploy
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v5

.github/workflows/pr.yml

@@ -0,0 +1,20 @@
+name: "Lint PR"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - edited
+      - synchronize
+
+permissions:
+  pull-requests: read
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    steps:
+      - uses: amannn/action-semantic-pull-request@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test.yml

@@ -6,19 +6,24 @@ on:
     branches:
       - master
 name: Test
+
+permissions:
+  contents: read
+
 jobs:
   typecheck:
     name: Typecheck
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         name: Install Node
         with:
           node-version: latest
+      - run: npm install --global corepack@latest
       - run: corepack enable
       - run: pnpm --version
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v7
         with:
           node-version: latest
           cache: "pnpm"
@@ -31,14 +36,15 @@ jobs:
     name: JavaScript Tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         name: Install Node
         with:
           node-version: latest
+      - run: npm install --global corepack@latest
       - run: corepack enable
       - run: pnpm --version
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v7
         with:
           node-version: latest
           cache: "pnpm"
@@ -52,26 +58,53 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Install Go
-        uses: actions/setup-go@v4
+        uses: actions/setup-go@v7
         with:
-          go-version: 1.20.x
+          go-version: "1.26.5"
+          check-latest: true
       - name: Checkout code
-        uses: actions/checkout@v3
+        uses: actions/checkout@v7
+      - name: Install Protoc
+        uses: arduino/setup-protoc@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Install gRPC and Go
+        run: |
+          go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
+          go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
       - name: Run Go Tests with Coverage
-        run: make test SKIP_ASSET=1
+        run: make test
+  staticcheck:
+    runs-on: ubuntu-latest
+    name: Go Staticcheck
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v7
+      - name: Setup Go
+        uses: actions/setup-go@v7
+        with:
+          go-version: "1.26.5"
+          check-latest: true
+      - name: Generate dependencies
+        run: make fake_assets shared_key.pem shared_cert.pem
+      - name: Stactic checker
+        uses: dominikh/staticcheck-action@v1.4.1
+        with:
+          install-go: false
   int-test:
     name: Integration Tests
     timeout-minutes: 60
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
         name: Install Node
         with:
           node-version: latest
+      - run: npm install --global corepack@latest
       - run: corepack enable
       - run: pnpm --version
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v7
         with:
           node-version: latest
           cache: "pnpm"
@@ -79,17 +112,20 @@ jobs:
       - name: Install dependencies
         run: pnpm install
       - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v4
+      - name: Generate certs
+        run: make shared_key.pem shared_cert.pem
       - name: Build
-        uses: docker/bake-action@v3
+        uses: docker/bake-action@v7
         with:
+          source: .
           load: true
           set: |
             *.cache-from=type=gha
             *.cache-to=type=gha,mode=max
       - name: Run Playwright tests
         run: docker compose up --exit-code-from playwright
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v7
         if: always()
         with:
           name: playwright-report

.gitignore

@@ -1,4 +1,5 @@
 certs
+/data
 dist
 node_modules
 .cache
@@ -11,3 +12,8 @@ coverage.out
 /test-results/
 /playwright-report/
 /playwright/.cache/
+*.pem
+*.csr
+tmp
+.claude/settings.local.json
+.claude/worktrees/

.npmrc

@@ -1,3 +1,4 @@
 shared-workspace-lockfile=false
 include-workspace-root=true
 ignore-workspace-root-check=true
+

.prettierignore

@@ -1,5 +1,7 @@
 auto-imports.d.ts
 components.d.ts
+typed-router.d.ts
 docs/.vitepress/cache
 docs/.vitepress/dist
 dist
+assets/types/graphql.ts

.prettierrc.cjs

@@ -0,0 +1,4 @@
+module.exports = {
+  printWidth: 120,
+  plugins: ["prettier-plugin-tailwindcss"],
+};

.prettierrc.js

@@ -1,3 +0,0 @@
-module.exports = {
-  printWidth: 120,
-};

.reflex

@@ -1 +0,0 @@
--r '\.(go)$' -R 'node_modules' -G '\*\_test.go' -s -- go run main.go --level debug --remote-host tcp://64.225.88.189:2376|clashleaders.com

.vscode/settings.json

@@ -1,6 +0,0 @@
-{
-  "i18n-ally.localesPaths": ["locales"],
-  "i18n-ally.keystyle": "nested",
-  "cSpell.words": ["healthcheck"],
-  "editor.formatOnSave": true
-}

CLAUDE.md

@@ -0,0 +1,468 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Comment Style
+
+**Always use ultra-brief mode for all PR reviews and responses.**
+
+Format:
+
+- Critical issues only (bugs, security, blockers)
+- Brief bullet points, no lengthy explanations
+- Skip verbose sections (no "Strengths", "Summary", etc.)
+- Include file:line references when relevant
+- Maximum ~10-15 lines per response
+
+## Testing Unreleased PRs
+
+When replying to a GitHub issue or discussion where the fix lives in an open PR, ask the reporter to test the pre-built image: `amir20/dozzle:pr-XXX` (XXX = PR number). CI builds a tagged image per PR, so reporters can verify without waiting for the next release.
+
+## GitHub Tone (issues, PRs, comments, discussions)
+
+When posting anything to GitHub, write like a human maintainer, not an AI assistant. Avoid telltale LLM patterns:
+
+- No em dashes or en dashes. Use commas, periods, or parentheses instead.
+- No "Not X, but Y" rhetorical contrasts.
+- No throat-clearing openers ("Great point", "Makes sense", "Thanks for the detailed write-up").
+- No closing summaries or recap sentences.
+- No bolded inline labels mid-paragraph ("**Why:**", "**Note:**").
+- Drop hedges ("essentially", "basically", "essentially just"). Say it plain.
+- Lowercase casual tone is fine. Contractions are fine. Short sentences are fine.
+- Don't over-explain tradeoffs. State the decision, give one reason, stop.
+
+## Project Overview
+
+Dozzle is a lightweight, web-based Docker log viewer with real-time monitoring capabilities. It's a hybrid application with:
+
+- **Backend**: Go (HTTP server, Docker API client, WebSocket streaming)
+- **Frontend**: Vue 3 (SPA with Vite, TypeScript)
+
+The application supports multiple deployment modes: standalone server, Docker Swarm, and Kubernetes (k8s).
+
+## Development Commands
+
+### Setup
+
+```bash
+# Install dependencies
+pnpm install
+
+# Generate certificates and protobuf files
+make generate
+```
+
+### Development
+
+```bash
+# Run full development environment (backend + frontend with hot reload)
+make dev
+
+# Alternative: Run backend and frontend separately
+pnpm run watch:backend  # Go backend with air (port 3100)
+pnpm run watch:frontend # Vite dev server (port 3100)
+
+# Run in agent mode for development
+pnpm run agent:dev
+```
+
+### Building
+
+```bash
+# Build frontend assets
+pnpm build
+# or
+make dist
+
+# Build entire application (includes frontend build)
+make build
+
+# Build Docker image
+make docker
+```
+
+### Testing
+
+```bash
+# Run Go tests
+make test
+
+# Run frontend tests (Vitest)
+pnpm test
+# Run in watch mode
+TZ=UTC pnpm test --watch
+
+# Type checking
+pnpm typecheck
+```
+
+### Preview & Other
+
+```bash
+# Preview production build locally
+pnpm preview
+# or
+make preview
+
+# Run integration tests (Playwright)
+make int
+```
+
+## Architecture
+
+### Backend (Go)
+
+The Go backend is organized into these key packages:
+
+- **`internal/web/`** - HTTP server and routing layer
+  - Routes defined in `routes.go` using chi router
+  - WebSocket/SSE handlers for log streaming (`logs.go`)
+  - Authentication middleware and token management (`auth.go`)
+  - Container action handlers (`actions.go`)
+
+- **`internal/docker/`** - Docker API client implementation
+  - `client.go`: Main Docker client wrapper with container operations
+  - `log_reader.go`: Streaming container logs
+  - `stats_collector.go`: Real-time container stats collection
+
+- **`internal/agent/`** - gRPC agent for multi-host support
+  - Uses Protocol Buffers (protos defined in `protos/`)
+  - Enables distributed log collection across Docker hosts
+
+- **`internal/cloud/`** - Dozzle Cloud integration (tool execution engine)
+  - `client.go`: Bidirectional gRPC stream client with auto-reconnect and exponential backoff
+  - `tools.go`: Tool registration, dispatch (`executeTool`), and `ToolHostService` interface
+  - `tools_containers.go`: Container listing, finding, stats, and inspection tools
+  - `tools_logs.go`: Log fetching with level/query/regex filtering (max 100 lines)
+  - `tools_actions.go`: Container start/stop/restart actions (gated by `enableActions`)
+  - `tools_helpers.go`: Proto conversion utilities and host name resolution
+  - Uses `protos/cloud.proto` for service and message definitions
+
+- **`internal/k8s/`** - Kubernetes client support
+  - Alternative to Docker client for k8s deployments
+
+- **`internal/support/`** - Support utilities
+  - `cli/`: Command-line argument parsing and validation
+  - `docker/`: Multi-host Docker management and Swarm support (`docker_service.go`, client managers)
+  - `k8s/`: Kubernetes service abstractions
+  - `web/`: Web service utilities
+
+- **`internal/auth/`** - Authentication providers
+  - Simple file-based auth (`simple.go`)
+  - Forward proxy auth (`proxy.go`)
+  - Role-based authorization (`roles.go`)
+
+- **`internal/container/`** - Container domain models and interfaces
+  - `event_generator.go`: Log parsing and grouping logic (multi-line, JSON detection)
+
+- **`internal/notification/`** - Alert and notification system
+  - `manager.go`: Notification rule evaluation and dispatching
+  - `log_listener.go`: Log pattern matching for alerts
+  - `dispatcher/`: Notification channel implementations (email, webhook, etc.)
+
+- **`main.go`** - Application entry point with mode switching (server/swarm/k8s/agent)
+
+### Frontend (Vue 3)
+
+The frontend uses file-based routing with these conventions:
+
+- **`assets/pages/`** - File-based routes (unplugin-vue-router)
+  - `container/[id].vue`: Single container view
+  - `merged/[ids].vue`: Multi-container merged view
+  - `host/[id].vue`: Host-level logs
+  - `service/[name].vue`: Swarm service logs
+  - `stack/[name].vue`: Docker stack logs
+  - `group/[name].vue`: Custom grouped logs
+
+- **`assets/components/`** - Vue components (auto-imported)
+  - `LogViewer/`: Core log viewing components
+    - `SimpleLogItem.vue`: Single-line log entries
+    - `ComplexLogItem.vue`: JSON/structured log entries
+    - `GroupedLogItem.vue`: Multi-line grouped log entries
+    - `ContainerEventLogItem.vue`: Container lifecycle events
+    - `SkippedEntriesLogItem.vue`: Placeholder for skipped logs
+    - `LoadMoreLogItem.vue`: Load more historical logs
+  - `ContainerViewer/`: Container-specific UI
+  - `common/`: Reusable UI components
+  - `BarChart.vue`: Lightweight bar chart with automatic downsampling
+  - `HostCard.vue`: Host overview card with metrics
+  - `MetricCard.vue`: Reusable metric display component
+  - `ContainerTable.vue`: Container table with historical stat visualization
+
+- **`assets/stores/`** - Pinia stores (auto-imported)
+  - `config.ts`: App configuration and feature flags (injected from backend HTML, frozen immutable)
+  - `container.ts`: Container state management with EventSource streaming (`/api/events/stream`)
+  - `hosts.ts`: Multi-host state
+  - `settings.ts`: User preferences (localStorage-backed via profileStorage)
+  - `pinned.ts`: Pinned container logs for side-by-side viewing
+  - `swarm.ts`, `k8s.ts`: Deployment mode-specific state
+  - `announcements.ts`: Feature announcements
+
+- **`assets/composable/`** - Vue composables (auto-imported)
+  - `eventStreams.ts`: SSE connection management with buffer-based flushing (250ms debounce)
+  - `historicalLogs.ts`: Historical log fetching
+  - `logContext.ts`: Log filtering and search context (provide/inject pattern)
+  - `scrollContext.ts`: Scroll state management (paused, progress, currentDate)
+  - `storage.ts`: LocalStorage abstractions with reactivity
+  - `visible.ts`: Log filtering by visible keys for complex logs
+  - `containerActions.ts`: Container control operations
+  - `duckdb.ts`: DuckDB WASM for SQL queries on logs
+
+- **`assets/modules/`** - Vue plugins
+  - `router.ts`: Vue Router configuration
+  - `pinia.ts`: Pinia store setup
+  - `i18n.ts`: Internationalization
+
+### Communication Flow
+
+1. **Real-time Logs**: Frontend establishes SSE connections to `/api/hosts/{host}/containers/{id}/logs/stream`
+2. **Container Events**: SSE stream at `/api/events/stream` pushes container lifecycle events
+3. **Stats**: Real-time CPU/memory stats streamed via SSE alongside events
+4. **Actions**: POST to `/api/hosts/{host}/containers/{id}/actions/{action}` (start/stop/restart)
+5. **Terminal**: WebSocket connections for container attach/exec at `/api/hosts/{host}/containers/{id}/attach`
+
+### Build System
+
+- **Frontend**: Vite builds to `dist/` with manifest
+- **Backend**: Embeds `dist/` using Go embed directive
+- **Hot Reload**: In development, `DEV=true` disables embedded assets, `LIVE_FS=true` serves from filesystem
+- **Makefile**: Orchestrates builds and dependency generation
+
+## Important Development Notes
+
+### Frontend
+
+- Auto-imports are configured for Vue composables, components, and Pinia stores (see `vite.config.ts`)
+- Icons use unplugin-icons with multiple icon sets (mdi, carbon, material-symbols, etc.)
+- Tailwind CSS with DaisyUI for styling
+- TypeScript definitions auto-generated in `assets/auto-imports.d.ts` and `assets/components.d.ts`
+- **Log Entry Types**: Three types of log messages supported
+  - `SimpleLogEntry`: Single-line text logs (`string`)
+  - `ComplexLogEntry`: Structured JSON logs (`JSONObject`)
+  - `GroupedLogEntry`: Multi-line grouped logs (`string[]`)
+- **Type consistency**: Use `LogMessage` type alias instead of `string | string[] | JSONObject` for log entry messages
+- **Log Entry Factory Pattern**: Use `LogEntry.create(logEvent)` to instantiate the correct entry type based on `logEvent.t` field
+- **EventSource Buffering**: Log streams use buffer-based flushing (250ms debounce, 1000ms max) to batch UI updates
+- **Charts/Visualizations**: Custom lightweight implementations (no D3.js)
+  - `BarChart.vue`: Self-contained bar chart with responsive downsampling
+  - Downsampling algorithm: Averages data into buckets based on available screen width
+  - All stat history tracked in `Container.statsHistory` (max 300 items via rolling window)
+  - `chartData` is always a rolling window of max 300 items — array length stays constant
+  - Uses `ref` (not `computed`) for `downsampledBars` to enable in-place mutation of the last bar, avoiding full re-renders
+  - Component instance is reused when switching containers; after init the chart only patches the last bar per tick, so on a wholesale `chartData` replacement (container switch) the parent must call the exposed `recalculate()`. `MultiContainerStat` holds refs to its `BarChart`s and calls it in the `containers` watch. (Note: `Container` carries Vue `ref`s, so VueTestUtils `setProps` cannot retrigger such a watch — tests must swap the container via a parent `ref` re-render.)
+
+### Backend
+
+- The application uses Go 1.25+ with module support
+- Certificate generation is required (`make generate` creates shared_key.pem and shared_cert.pem)
+- Protocol buffer generation happens via `go generate` directive in `main.go`
+- Docker client uses API version negotiation for compatibility
+- **Service Layer Architecture**:
+  - `ClientService` interface abstracts Docker/K8s/Agent backends
+  - `MultiHostService` orchestrates multi-host operations
+  - `ClientManager` implementations: `RetriableClientManager` (server mode), `SwarmClientManager` (swarm mode)
+
+### Authentication
+
+- Three modes: none, simple (file-based users.yml), forward-proxy (e.g., Authelia)
+- JWT tokens for simple auth with configurable TTL
+- User file location: `./data/users.yml` or `./data/users.yaml`
+
+### Testing
+
+- Go tests use standard `testing` package with testify assertions
+- Frontend uses Vitest with `@vue/test-utils`
+- Integration tests with Playwright in `e2e/`
+- Tests must run with `TZ=UTC` for consistent timestamps
+
+### Container Stats & Metrics
+
+- Stats are tracked using exponential moving average (EMA) with alpha=0.2
+- History stored in rolling window (300 items max) via `useSimpleRefHistory`
+- CPU metrics normalized by core count (respects `cpuLimit` or falls back to host `nCPU`)
+- Memory metrics include both percentage and absolute usage (`memoryUsage` vs `memory`)
+- Stats visualization uses adaptive downsampling for performance
+
+### Container Labels
+
+- `dev.dozzle.name`: Custom container display name
+- `dev.dozzle.group`: Group containers together
+- Label-based filtering throughout the application
+
+### Deployment Modes
+
+- **Server mode** (default): Single or multi-host Docker monitoring
+  - Uses `RetriableClientManager` with local + remote agent clients
+- **Swarm mode**: Automatic discovery of Swarm nodes via Docker API
+  - Creates gRPC agent server on each node (port 7007)
+  - Uses `SwarmClientManager` for node discovery
+- **K8s mode**: Pod log monitoring in Kubernetes cluster
+  - Implements `container.Client` interface via Kubernetes API
+- **Agent mode**: Lightweight gRPC agent for remote log collection
+  - Run with `dozzle agent` or `pnpm run agent:dev`
+  - Listens on port 7007 with TLS certificate authentication
+
+## Key Architectural Patterns
+
+### Backend Abstraction Layers
+
+The backend follows a clean layered architecture:
+
+```
+HTTP Handlers (internal/web)
+    ↓
+HostService Interface (MultiHostService)
+    ↓
+ClientService Interface (per host)
+    ↓
+container.Client Interface
+    ↓
+Implementation (DockerClient, K8sClient, AgentClient)
+```
+
+**When adding new container operations:**
+
+1. Define method in `container.Client` interface (`internal/container/client.go`)
+2. Implement in `internal/docker/client.go` (and `internal/k8s/client.go` if applicable)
+3. Add wrapper method in `ClientService` interface (`internal/support/docker/docker_service.go`)
+4. Add HTTP handler in `internal/web/` with appropriate route
+
+### Frontend Data Flow
+
+**Real-time Log Viewing:**
+
+1. User navigates to `/container/{id}` route
+2. Page component calls `useContainerStream(container)` composable
+3. Composable creates EventSource connection to `/api/hosts/{host}/containers/{id}/logs/stream`
+4. Backend streams `LogEvent` objects via SSE
+5. Frontend buffers events (250ms debounce, max 1000ms)
+6. Batched buffer flushes update reactive `messages` array
+7. `LogViewer.vue` renders using appropriate component (`SimpleLogItem`, `ComplexLogItem`, `GroupedLogItem`)
+8. When messages exceed `maxLogs` (400), oldest entries replaced or marked as `SkippedLogsEntry`
+
+**Stats Streaming:**
+
+1. `container.ts` store connects to `/api/events/stream` on app init
+2. Backend multiplexes container events and stats into single SSE stream
+3. `container-stat` events update `Container._stat` and append to `_statsHistory`
+4. EMA calculation provides smoothed `movingAverageStat` (alpha=0.2)
+5. `ContainerTable.vue` displays mini bar charts using `statsHistory` with downsampling
+
+### Protocol Buffer Flow (Agent Mode)
+
+1. Main server creates `agent.NewClient(endpoint, certs)` for each remote host
+2. AgentClient implements `container.Client` interface
+3. Method calls translate to gRPC requests defined in `protos/rpc.proto`
+4. Remote agent receives gRPC call, delegates to local `DockerClient`
+5. Streaming RPCs (logs, stats, events) use bidirectional channels
+6. Responses converted back to domain models via `FromProto()` methods
+
+### Cloud Tool Execution Flow
+
+1. `cloud.Client.Run()` blocks until `Notify()` signals a cloud dispatcher is configured
+2. `connect()` establishes bidirectional gRPC stream (`ToolStream` RPC) to cloud endpoint
+3. Cloud sends `ToolRequest` (ListTools or CallTool), client dispatches via `executeTool()`
+4. Tool calls run concurrently (max 5 via weighted semaphore), responses sent back on stream
+5. On disconnect, exponential backoff (1s→30s with jitter) triggers reconnection
+6. `PermissionDenied` errors stop retrying permanently (invalid API key / no pro plan)
+7. Tool definitions cached via `sync.Once`; zero overhead for non-cloud users
+
+### Log Parsing Pipeline
+
+1. Docker API returns multiplexed stream (8-byte headers + payload)
+2. `log_reader.go` parses headers, extracts stdout/stderr type
+3. `event_generator.go` receives raw log lines
+4. Detection logic identifies:
+   - JSON structure → `ComplexLogEntry`
+   - Multi-line patterns (stack traces) → `GroupedLogEntry`
+   - Single lines → `SimpleLogEntry`
+5. Log level extraction via regex patterns
+6. `LogEvent` serialized to JSON and sent via SSE
+7. Frontend deserializes and renders with appropriate component
+
+## Adding New Features
+
+### Adding a New HTTP Route
+
+1. Define route in `internal/web/routes.go` using chi router:
+   ```go
+   r.Get("/api/custom-endpoint", h.customHandler)
+   ```
+2. Implement handler method in appropriate file (e.g., `actions.go`, `logs.go`)
+3. Use `hostService` to find container/host via `FindContainer()` or `FindHost()`
+4. Return JSON response or establish SSE/WebSocket stream
+
+### Adding a New Log View Type
+
+1. Create route file in `assets/pages/` (e.g., `custom/[id].vue`)
+2. Create composable in `assets/composable/eventStreams.ts` (e.g., `useCustomStream()`)
+3. Composable should:
+   - Build API URL with appropriate filters
+   - Create EventSource connection
+   - Handle buffering and message batching
+   - Return reactive `messages` array and control methods
+4. Use `LogViewer.vue` component to render messages
+5. Add backend API endpoint if needed (see above)
+
+### Adding Container Stats/Metrics
+
+1. Add field to `Stat` type in `internal/container/types.go`
+2. Update `stats_collector.go` to extract metric from Docker API response
+3. Add calculation logic in `docker/calculation.go` if needed
+4. Ensure protobuf definition includes field in `protos/rpc.proto`
+5. Frontend automatically receives updates via existing SSE stream
+6. Update `Container` model in `assets/models/Container.ts` if UI needs access
+
+### Working with Notifications/Alerts
+
+**Backend** (`internal/notification/`):
+
+- `manager.go`: Rule evaluation engine, manages alert state
+- `log_listener.go`: Subscribes to container log streams, evaluates rules against incoming logs
+- `types.go`: Alert rule definitions (log pattern matching, thresholds)
+- `dispatcher/`: Notification channel implementations
+
+**Frontend** (`assets/pages/notifications.vue`, `assets/components/Notification/`):
+
+- `AlertForm.vue`, `DestinationForm.vue`: UI for creating rules
+- Rules persisted to `./data/notifications.yml` via `internal/notification/persist.go`
+- Alert state displayed in notification cards
+
+**Adding a new notification channel:**
+
+1. Implement dispatcher interface in `internal/notification/dispatcher/`
+2. Register in `manager.go` dispatcher factory
+3. Add UI form in `assets/components/Notification/DestinationForm.vue`
+
+### Adding a New Cloud Tool
+
+1. Define the tool in `AvailableTools()` in `internal/cloud/tools.go` with name, description, and parameter schema
+2. Add a response message type in `protos/cloud.proto` and add it to the `CallToolResponse.result` oneof
+3. Run `make generate` to regenerate protobuf code
+4. Add a case in the `executeTool()` switch in `internal/cloud/tools.go`
+5. Implement the execution function in the appropriate `tools_*.go` file
+6. Use `ToolHostService` interface methods to access container/host data
+7. Add tests in `tools_test.go`
+
+## Common Development Patterns
+
+### Testing
+
+- Always run Go tests with race detector: `go test -race`
+- Frontend tests require `TZ=UTC` for timestamp consistency
+- Integration tests use Playwright with `make int` (runs docker-compose setup)
+- Use `testify/assert` for Go test assertions
+
+### Hot Reload Development
+
+- `make dev` runs both backend (air) and frontend (vite) with hot reload
+- `DEV=true` disables embedded asset serving
+- `LIVE_FS=true` serves assets from filesystem instead of embedded
+- Backend changes trigger air restart automatically
+- Frontend changes trigger vite HMR
+
+### Debugging
+
+- Backend logs: Set `--level debug` flag or `DOZZLE_LEVEL=debug` env var
+- Frontend: Vue DevTools browser extension
+- SSE streams: Browser DevTools Network tab shows EventSource connections

Dockerfile

@@ -1,28 +1,33 @@
 # Build assets
-FROM --platform=$BUILDPLATFORM node:20-alpine as node
+FROM --platform=$BUILDPLATFORM node:25.9.0-alpine AS node
 
-RUN corepack enable
+RUN npm install -g --force corepack && corepack enable
+
+ENV CI=true
 
 WORKDIR /build
 
 # Install dependencies from lock file
-COPY pnpm-*.yaml ./
-RUN pnpm fetch --ignore-scripts --no-optional
+COPY pnpm-lock.yaml pnpm-workspace.yaml ./
+RUN pnpm fetch --ignore-scripts
 
 # Copy package.json and install dependencies
 COPY package.json ./
-RUN pnpm install --offline --ignore-scripts --no-optional
+RUN pnpm install --offline --ignore-scripts
 
 # Copy assets and translations to build
-COPY .* vite.config.ts ./
+COPY vite.config.ts tsconfig.json .prettierrc.cjs .npmrc ./
 COPY assets ./assets
 COPY locales ./locales
 COPY public ./public
 
+ARG CLOUD_URL
+ENV CLOUD_URL=$CLOUD_URL
+
 # Build assets
 RUN pnpm build
 
-FROM --platform=$BUILDPLATFORM golang:1.20.7-alpine AS builder
+FROM --platform=$BUILDPLATFORM golang:1.26-alpine AS builder
 
 RUN apk add --no-cache ca-certificates && mkdir /dozzle
 
@@ -30,30 +35,33 @@ WORKDIR /dozzle
 
 # Copy go mod files
 COPY go.* ./
-RUN go mod download
+RUN --mount=type=cache,target=/go/pkg/mod go mod download
+
+# Copy all other files
+COPY internal ./internal
+COPY proto ./proto
+COPY types ./types
+COPY main.go ./
+COPY protos ./protos
+COPY shared_key.pem shared_cert.pem ./
 
 # Copy assets built with node
 COPY --from=node /build/dist ./dist
 
-# Copy all other files
-COPY analytics ./analytics
-COPY healthcheck ./healthcheck
-COPY docker ./docker
-COPY web ./web
-COPY main.go ./
-
 # Args
 ARG TAG=dev
 ARG TARGETOS TARGETARCH
 
 # Build binary
-RUN GOOS=$TARGETOS GOARCH=$TARGETARCH CGO_ENABLED=0 go build -ldflags "-s -w -X main.version=$TAG"  -o dozzle
+RUN --mount=type=cache,target=/go/pkg/mod --mount=type=cache,target=/root/.cache/go-build \
+  GOOS=$TARGETOS GOARCH=$TARGETARCH CGO_ENABLED=0 go build -ldflags "-s -w -X github.com/amir20/dozzle/internal/support/cli.Version=$TAG" -o dozzle
 
+RUN mkdir /data
 
 FROM scratch
 
-ENV PATH /bin
-
+COPY --from=builder /data /data
+COPY --from=builder /tmp /tmp
 COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
 COPY --from=builder /dozzle/dozzle /dozzle
 

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Amir Raminfar
+Copyright (c) 2025 Amir Raminfar
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

MAJOR_VERSIONS.md

@@ -0,0 +1,84 @@
+# Dozzle Major Version Highlights
+
+A summary of major features introduced with each major version bump since 2020.
+
+## v2.0.0 — 2020-06-27
+
+- Theme overhaul using CSS variables
+- Progress notification bar
+- Toggle between new light and dark themes
+
+## v3.0.0 — 2020-09-06
+
+- Live container stats (CPU/memory) streamed in real time
+- Pinned tabs and improved mobile/responsive layout
+- Major UI overhaul
+
+## v4.0.0 — 2022-08-17
+
+- First-class JSON log support
+- Jump-to-context, soft wraps, clear-logs action
+- Auto color scheme, dark mode polish
+- Container stats panel, total CPU/mem usage
+- Healthcheck endpoint and "wait for docker" startup option
+
+## v5.0.0 — 2023-09-23
+
+- Multi-host support with parallel client connections
+- New homepage dashboard with all containers, sortable table, pagination, bar charts
+- Exponential moving average for stats
+- Container pinning, keyboard shortcut overlay
+- stdout/stderr stream separation
+- i18n: Chinese, German added; locale infrastructure
+- Refactored UI with faster components
+
+## v6.0.0 — 2024-01-01
+
+- **Forward-proxy authentication** (Authelia, etc.) and `users.yml` file-based auth
+- Container actions: start/stop/restart from the UI
+- Hot-reload of users.yml without restart
+- Custom headers for forward-proxy auth
+- Settings synced to disk for authenticated users
+- Toast notifications, release list, redirect-to-new-container
+- Removed legacy auth model (breaking)
+
+## v7.0.0 — 2024-05-24
+
+- **Docker Swarm mode** with stacks and services on remote hosts
+- Host cards on dashboard with per-host stats
+- Container grouping by stack/compose
+- Background stats collection (up to 5 min) with idle deactivation
+- LogFmt parser support
+- Compact mode, draggable search, alt-click split panes
+- Many new locales (French, Italian, Polish, Danish, Turkish, …)
+- `generate` subcommand for users.yml
+
+## v8.0.0 — 2024-07-05
+
+- **Swarm mode rebuilt on gRPC agents** (breaking architecture change)
+- Critical/severe log levels
+- Stacks and services in fuzzy search
+- Improved search with full match scrolling
+- Container start events shown inline
+
+## v9.0.0 — 2026-01-06
+
+- **Kubernetes mode** with k8s-specific menu
+- **User roles** and `dozzle_*` role mapping; logout URL for forward proxy
+- Historical stats on homepage, hosts, and containers
+- Permanent links to specific past log lines
+- Grouping by `dev.dozzle.group` label, log message grouping
+- Shell resize support, action toolbar in menu
+- Settings page, collapsible side menu sections
+- Parallel container fetching, gRPC compression
+- CLEF (`@l`) log level extraction
+- New locales: Korean, Indonesian, Dutch
+
+## v10.0.0 — 2026-02-10
+
+- **Dozzle Cloud** integration (bidirectional gRPC tool execution)
+- **Notifications & alerts**: full notifications page, webhooks, dispatchers, Go template support, test connections
+- Notifications work across agents
+- Per-container network usage stats (with mobile view)
+- Coolify label fallbacks for container name/group
+- Alert creation shortcut, JSON syntax in templates

Makefile

@@ -1,7 +1,11 @@
+GEN_DIR := internal/agent/pb
+
 .PHONY: clean
 clean:
 	@rm -rf dist
 	@go clean -i
+	@rm -f shared_key.pem shared_cert.pem
+	@rm -f $(GEN_DIR)/*.pb.go
 
 .PHONY: dist
 dist:
@@ -14,21 +18,56 @@ fake_assets:
 	@echo "assets build was skipped" > dist/index.html
 
 .PHONY: test
-test: fake_assets
-	go test -cover ./...
+test: fake_assets generate
+	go test -cover -race -count 1 -timeout 40s ./...
+
+.PHONY: test-update
+test-update: fake_assets generate
+	go test -cover -race -count 1 -timeout 5s ./... -- -- -u
 
 .PHONY: build
-build: dist
-	CGO_ENABLED=0 go build -ldflags "-s -w"
+build: dist generate
+	CGO_ENABLED=0 go build -ldflags "-s -w -X github.com/amir20/dozzle/internal/support/cli.Version=local"
 
 .PHONY: docker
-docker:
-	@docker build -t amir20/dozzle .
+docker: generate
+	@docker build --build-arg TAG=local --build-arg CLOUD_URL=$(CLOUD_URL) -t amir20/dozzle:local .
+
+.PHONY: generate
+generate: shared_key.pem shared_cert.pem
+	@go generate ./...
 
 .PHONY: dev
-dev:
+dev: generate fake_assets
 	pnpm dev
 
 .PHONY: int
 int:
 	docker compose up --build --force-recreate --exit-code-from playwright
+
+shared_key.pem:
+	@openssl genpkey -algorithm Ed25519 -out shared_key.pem
+
+shared_cert.pem: shared_key.pem
+	@openssl req -new -key shared_key.pem -out shared_request.csr -subj "/C=US/ST=California/L=San Francisco/O=Dozzle"
+	@openssl x509 -req -in shared_request.csr -signkey shared_key.pem -out shared_cert.pem -days 1825
+	@rm shared_request.csr
+
+.PHONY: run
+run: docker
+	docker run -it --rm -p 8080:8080 -v /var/run/docker.sock:/var/run/docker.sock amir20/dozzle:local
+
+.PHONY: preview
+preview: build
+	pnpm preview
+
+.PHONY: agent-reload
+agent-reload: docker
+	@VM_NAME=$${VM_NAME:-dozzle-agent}; \
+	echo "📦 Loading image into VM $$VM_NAME..."; \
+	docker save amir20/dozzle:local | orb exec -m $$VM_NAME docker load; \
+	echo "🔄 Recreating agent..."; \
+	orb exec -m $$VM_NAME docker stop dozzle-agent || true; \
+	orb exec -m $$VM_NAME docker rm dozzle-agent || true; \
+	orb exec -m $$VM_NAME docker run -d --name dozzle-agent -p 7007:7007 -v /var/run/docker.sock:/var/run/docker.sock -v ~/dozzle-certs:/certs -v ~/dozzle-data:/data -e DOZZLE_LEVEL=debug amir20/dozzle:local agent --cert /certs/shared_cert.pem --key /certs/shared_key.pem; \
+	echo "✅ Agent reloaded"

README.md

@@ -1,226 +1,143 @@
+<p align="center">
+  <img src="assets/logo.svg" alt="Dozzle Logo" width="200"/>
+</p>
+
 # Dozzle - [dozzle.dev](https://dozzle.dev/)
 
-Dozzle is a small lightweight application with a web based interface to monitor Docker logs. It doesn’t store any log files. It is for live monitoring of your container logs only.
+Dozzle is a lightweight, web-based application for monitoring Docker logs in real time. It doesn't store any log files—it's designed purely for live log viewing.
 
-https://user-images.githubusercontent.com/260667/227634771-9ebbe381-16a8-465a-b28a-450c5cd20c94.mp4
+https://github.com/user-attachments/assets/66a7b4b2-d6c9-4fca-ab04-aef6cd7c0c31
 
-[![Go Report Card](https://goreportcard.com/badge/github.com/amir20/dozzle)](https://goreportcard.com/report/github.com/amir20/dozzle)
+[![Docker Image Size (latest by date)](https://img.shields.io/docker/image-size/amir20/dozzle)](https://hub.docker.com/r/amir20/dozzle/)
 [![Docker Pulls](https://img.shields.io/docker/pulls/amir20/dozzle.svg)](https://hub.docker.com/r/amir20/dozzle/)
 [![Docker Version](https://img.shields.io/docker/v/amir20/dozzle?sort=semver)](https://hub.docker.com/r/amir20/dozzle/)
 ![Test](https://github.com/amir20/dozzle/workflows/Test/badge.svg)
 
+> [!NOTE]
+> If you like Dozzle, check out [`dtop`](https://github.com/amir20/dtop), a top-like application for monitoring Docker containers. It integrates with Dozzle to link directly to container logs.
+
 ## Features
 
-- Intelligent fuzzy search for container names 🤖
-- Search logs using regex 🔦
-- Small memory footprint 🏎
+- Intelligent fuzzy search for container names
+- Search logs using regex
+- Search logs using [SQL queries](https://dozzle.dev/guide/sql-engine)
+- Small memory footprint
 - Split screen for viewing multiple logs
-- Download logs easy
 - Live stats with memory and CPU usage
-- Authentication with username and password 🚨
+- Multi-user [authentication](https://dozzle.dev/guide/authentication) with support for forward proxy authorization
+- [Swarm mode](https://dozzle.dev/guide/swarm-mode) support
+- [Agent mode](https://dozzle.dev/guide/agent) for monitoring multiple Docker hosts
+- Dark mode
 
-Dozzle should work for most. It has been tested with hundreds of containers. However, it doesn't support offline searching. Products like [Loggly](https://www.loggly.com), [Papertrail](https://papertrailapp.com) or [Kibana](https://www.elastic.co/products/kibana) are more suited for full search capabilities.
+Dozzle has been tested with hundreds of containers. However, it doesn't support offline searching. Products like [Loggly](https://www.loggly.com), [Papertrail](https://papertrailapp.com), or [Kibana](https://www.elastic.co/products/kibana) are better suited for full search capabilities.
 
-Dozzle doesn't cost any money and aims to focus on real-time debugging.
+## Getting Started
 
-## Getting Dozzle
-
-Dozzle is a very small Docker container (4 MB compressed). Pull the latest release from the index:
+Dozzle is a small container (7 MB compressed). Pull the latest release with:
 
     $ docker pull amir20/dozzle:latest
 
-## Using Dozzle
+### Running Dozzle
 
-The simplest way to use dozzle is to run the docker container. Also, mount the Docker Unix socket with `--volume` to `/var/run/docker.sock`:
+The simplest way to use Dozzle is to run the Docker container. Mount the Docker Unix socket with `--volume` to `/var/run/docker.sock`:
 
-    $ docker run --name dozzle -d --volume=/var/run/docker.sock:/var/run/docker.sock -p 8888:8080 amir20/dozzle:latest
+    $ docker run --name dozzle -d --volume=/var/run/docker.sock:/var/run/docker.sock -v dozzle_data:/data -p 8080:8080 amir20/dozzle:latest
 
-Dozzle will be available at [http://localhost:8888/](http://localhost:8888/). You can change `-p 8888:8080` to any port. For example, if you want to view dozzle over port 4040 then you would do `-p 4040:8080`.
+Dozzle will be available at [http://localhost:8080/](http://localhost:8080/).
 
-### Connecting with Docker compose
+Here is a Docker Compose example:
 
-    version: "3"
     services:
       dozzle:
         container_name: dozzle
         image: amir20/dozzle:latest
         volumes:
           - /var/run/docker.sock:/var/run/docker.sock
-        ports:
-          - 9999:8080
-
-### Connecting to remote hosts
-
-Dozzle supports connecting to multiple remote hosts via `tcp://` using TLS or without. Appropriate certs need to be mounted for Dozzle to be able to successfully connect. At this point, `ssh://` is not supported because Dozzle docker image does not ship with any ssh clients.
-
-To configure remote hosts, `--remote-host` or `DOZZLE_REMOTE_HOST` need to provided and the `pem` files need to be mounted to `/cert` directory. The `/cert` directory expects to have `/certs/{ca,cert,key}.pem` or `/certs/{host}/{ca,cert,key}.pem` in case of multiple hosts.
-
-Below are examples of using `--remote-host` via CLI:
-
-    $ docker run -v /var/run/docker.sock:/var/run/docker.sock -v /path/to/certs:/certs -p 8080:8080 amir20/dozzle --remote-host tcp://167.99.1.1:2376
-
-Multiple `--remote-host` flags can be used to specify multiple hosts.
-
-Or to use compose:
-
-    version: "3"
-    services:
-      dozzle:
-        image: amir20/dozzle:latest
-        volumes:
-          - /var/run/docker.sock:/var/run/docker.sock
-          - /path/to/certs:/certs
+          - dozzle_data:/data
         ports:
           - 8080:8080
-        environment:
-          DOZZLE_REMOTE_HOST: tcp://167.99.1.1:2376,tcp://167.99.1.2:2376
+    volumes:
+      dozzle_data:
 
-You need to make sure appropriate certs are provided in `/certs/167.99.1.1/{ca,cert,key}.pem` and `/certs/167.99.1.2/{ca,cert,key}.pem` for both hosts to work.
+For advanced options like [authentication](https://dozzle.dev/guide/authentication), [remote hosts](https://dozzle.dev/guide/remote-hosts), or common [questions](https://dozzle.dev/guide/faq), see the documentation at [dozzle.dev](https://dozzle.dev/guide/getting-started).
 
-### Adding health check
+## Swarm Mode
 
-Dozzle doesn't enable healthcheck by default as it adds extra CPU usage. `healthcheck` can be enabled manually.
+Dozzle works with Docker Swarm. You can run Dozzle as a global service:
 
-    version: "3"
-    services:
-      dozzle:
-        container_name: dozzle
-        image: amir20/dozzle:latest
-        volumes:
-          - /var/run/docker.sock:/var/run/docker.sock
-        ports:
-          - 8080:8080
-        environment:
-          DOZZLE_LEVEL: trace
-        healthcheck:
-          test: [ "CMD", "/dozzle", "healthcheck" ]
-          interval: 3s
-          timeout: 30s
-          retries: 5
-          start_period: 30s
+    $ docker service create --name dozzle --env DOZZLE_MODE=swarm --mode global --mount type=bind,source=/var/run/docker.sock,target=/var/run/docker.sock -p 8080:8080 amir20/dozzle:latest
 
-#### Security
+See the [Swarm Mode](https://dozzle.dev/guide/swarm-mode) documentation for more details.
 
-You can control the device Dozzle binds to by passing `--addr` parameter. For example,
+## Agent Mode
 
-    $ docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8888:1224 amir20/dozzle:latest --addr localhost:1224
+Dozzle can monitor multiple Docker hosts. Run Dozzle in agent mode with:
 
-will bind to `localhost` on port `1224`. You can then use a reverse proxy to control who can see dozzle.
+    $ docker run -v /var/run/docker.sock:/var/run/docker.sock -p 7007:7007 amir20/dozzle:latest agent
 
-If you wish to restrict the containers shown you can pass the `--filter` parameter. For example,
+See the [Agent Mode](https://dozzle.dev/guide/agent) documentation for more details.
 
-    $ docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8888:1224 amir20/dozzle:latest --filter name=foo
+## Technical Details
 
-this would then only allow you to view containers with a name starting with "foo". You can use other filters like `status` as well, please check the official docker [command line docs](https://docs.docker.com/engine/reference/commandline/ps/#filtering) for available filters. Multiple `--filter` arguments can be provided.
+Dozzle uses automatic API negotiation, which works with most Docker configurations. Dozzle also works with [Colima](https://github.com/abiosoft/colima) and [Podman](https://podman.io/).
 
-#### Authentication
+Dozzle requires Docker Engine 19.03 or newer (API version 1.40+). Older daemons are not supported by the underlying Docker SDK.
 
-Dozzle supports a very simple authentication out of the box with just username and password. You should deploy using SSL to keep the credentials safe. See configuration to use `--username` and `--password`. You can also use [docker secrets](https://docs.docker.com/engine/swarm/secrets/) `--usernamefile` and `--passwordfile`.
+### Installation on Podman
 
-#### Changing base URL
+By default, Podman doesn't have a background process, but you can enable the remote socket for Dozzle to work.
 
-Dozzle by default mounts to "/". If you want to control the base path you can use the `--base` option. For example, if you want to mount at "/foobar",
-then you can override by using `--base /foobar`. See env variables below for using `DOZZLE_BASE` to change this.
-
-    $ docker run --volume=/var/run/docker.sock:/var/run/docker.sock -p 8080:8080 amir20/dozzle:latest --base /foobar
-
-Dozzle will be available at [http://localhost:8080/foobar/](http://localhost:8080/foobar/).
-
-#### Analytics collected
-
-Dozzle collects anonymous user configurations using Google Analytics. Why? Dozzle is an open source project with no funding. As a result, there is no time to do user studies of Dozzle. Analytics is collected to prioritize features and fixes based on how people use Dozzle. This data is completely public and can be viewed live using [ Data Studio dashboard](https://datastudio.google.com/s/naeIu0MiWsY).
-
-If you do not want to be tracked at all, see the `--no-analytics` flag below.
-
-#### Environment variables and configuration
-
-Dozzle follows the [12-factor](https://12factor.net/) model. Configurations can use the CLI flags or environment variables. The table below outlines all supported options and their respective env vars.
-
-| Flag             | Env Variable           | Default |
-| ---------------- | ---------------------- | ------- |
-| `--addr`         | `DOZZLE_ADDR`          | `:8080` |
-| `--base`         | `DOZZLE_BASE`          | `/`     |
-| `--hostname`     | `DOZZLE_HOSTNAME`      | `""`    |
-| `--level`        | `DOZZLE_LEVEL`         | `info`  |
-| `--filter`       | `DOZZLE_FILTER`        | `""`    |
-| `--username`     | `DOZZLE_USERNAME`      | `""`    |
-| `--password`     | `DOZZLE_PASSWORD`      | `""`    |
-| `--usernamefile` | `DOZZLE_USERNAME_FILE` | `""`    |
-| `--passwordfile` | `DOZZLE_PASSWORD_FILE` | `""`    |
-| `--no-analytics` | `DOZZLE_NO_ANALYTICS`  | false   |
-| `--remote-host`  | `DOZZLE_REMOTE_HOST`   |         |
-
-## Troubleshooting and FAQs
-
-<details>
- <summary>I installed Dozzle, but logs are slow or they never load. Help!</summary>
-
-Dozzle uses Server Sent Events (SSE) which connects to a server using a HTTP stream without closing the connection. If any proxy tries to buffer this connection, then Dozzle never receives the data and hangs forever waiting for the reverse proxy to flush the buffer. Since version `1.23.0`, Dozzle sends the `X-Accel-Buffering: no` header which should stop reverse proxies buffering. However, some proxies may ignore this header. In those cases, you need to explicitly disable any buffering.
-
-Below is an example with nginx and using `proxy_pass` to disable buffering.
+First, verify if your Podman installation has the remote socket enabled:
 
 ```
-    server {
-        ...
-
-        location / {
-            proxy_pass                  http://<dozzle.container.ip.address>:8080;
-        }
-
-        location /api {
-            proxy_pass                  http://<dozzle.container.ip.address>:8080;
-
-            proxy_buffering             off;
-            proxy_cache                 off;
-        }
-    }
-
+podman info
 ```
 
-</details>
-
-<details>
- <summary>What data does Dozzle collect?</summary>
-
-Dozzle does collect some analytics. Analytics is anonymous usage tracking of the features which are used the most. See the section above on how to disable any analytic collection.
-
-In the browser, Dozzle has a [strict](https://github.com/amir20/dozzle/blob/master/web/csp.go#L9) Content Security Policy which only allows the following policies:
-
-- Allow connect to `api.github.com` to fetch most recent version.
-- Only allow `<script>` and `<style>` files from `self`
-
-Dozzle opens all links with `rel="noopener"`.
-
-</details>
-
-<details>
- <summary>We have tools that uses Dozzle when a new container is created. How can I get a direct link to a container by name?</summary>
-
-Dozzle has a [special route](https://github.com/amir20/dozzle/blob/master/assets/pages/Show.vue) that can be used to search containers by name and then forward to that container. For example, if you have a container with name `"foo.bar"` and id `abc123`, you can send your users to `/show?name=foo.bar` which will be forwarded to `/container/abc123`.
-
-</details>
-
-<details>
- <summary>I installed Dozzle but memory consumption doesn't show up!</summary>
-
-_This is an issue specific to ARM devices_
-
-Dozzle uses the Docker API to gather information about the containers' memory usage. If the memory usage is not showing up, then it is likely that the Docker API is not returning the memory usage.
-
-You can verify this by running `docker info`, and you should see the following:
+If you see output like this under the remote socket key, it's already enabled:
 
 ```
-WARNING: No memory limit support
-WARNING: No swap limit support
+  remoteSocket:
+    exists: true
+    path: /run/user/1000/podman/podman.sock
 ```
 
-In this case, you'll need to add the following line to your `/boot/cmdline.txt` file and reboot your device.
+If it's not enabled, follow [this tutorial](https://github.com/containers/podman/blob/main/docs/tutorials/socket_activation.md) to enable it.
+
+Once the Podman remote socket is enabled, you can run Dozzle:
 
 ```
-cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1
+podman run --volume=/run/user/1000/podman/podman.sock:/var/run/docker.sock -d -p 8080:8080 docker.io/amir20/dozzle:latest
 ```
 
-</details>
+Additionally, you need to create a fake engine-id to prevent `host not found` errors. Podman doesn't generate an engine-id like Docker does, due to its daemonless architecture.
+
+Create a file named `engine-id` under `/var/lib/docker`. On a system with Podman, you'll need to create the folder path as well. Place a UUID inside the file, for example using `uuidgen > engine-id`. The file should contain an identifier like: `b9f1d7fc-b459-4b6e-9f7a-e3d1cd2e14a9`.
+
+For more details, see [Podman Info](docs/guide/podman.md) or the [FAQ](docs/guide/faq.md#i-am-seeing-host-not-found-error-in-the-logs-how-do-i-fix-it).
+
+## Security
+
+Dozzle supports file-based authentication and forward proxy authentication with tools like [Authelia](https://www.authelia.com/). See the documentation at https://dozzle.dev/guide/authentication.
+
+## Analytics
+
+Dozzle collects anonymous user configurations using Google Analytics. Why? Dozzle is an open source project with no funding, so there's no time for formal user studies. Analytics help prioritize features and fixes based on how people use Dozzle. This data is completely public and can be viewed live on the [Data Studio dashboard](https://datastudio.google.com/s/naeIu0MiWsY).
+
+To disable analytics, use the `--no-analytics` flag.
+
+## Environment Variables and Configuration
+
+Dozzle follows the [12-factor](https://12factor.net/) model. Configuration can be done via CLI flags or environment variables. See the documentation at [dozzle.dev/guide/supported-env-vars](https://dozzle.dev/guide/supported-env-vars) for more details.
+
+## Support
+
+There are many ways to support Dozzle:
+
+- Use it! Write about it! Star it! If you love Dozzle, drop me a line and tell me what you love.
+- Blog about Dozzle to spread the word. If you're good at writing, send PRs to improve the documentation at [dozzle.dev](https://dozzle.dev/).
+- Sponsor my work at https://www.buymeacoffee.com/amirraminfar
+
+<a href="https://www.buymeacoffee.com/amirraminfar" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>
 
 ## License
 
@@ -228,10 +145,51 @@ cgroup_enable=cpuset cgroup_enable=memory cgroup_memory=1
 
 ## Building
 
-To Build and test locally:
+Want to contribute? Great! Dozzle has two parts: a **Go backend** that talks to Docker, and a **Vue frontend** that runs in the browser. You don't need to know both — pick the side that matches what you want to change. For documentation fixes, no setup is needed at all; just edit the file on GitHub.
 
-1. Install [NodeJs](https://nodejs.org/en/download/) and [pnpm](https://pnpm.io/installation).
-2. Install [Go](https://go.dev/doc/install).
-3. Install [reflex](https://github.com/cespare/reflex) with `go get -u github.com/cespare/reflex` outside of dozzle.
-4. Install node modules `pnpm install`.
-5. Do `pnpm dev`
+### 1. Install the prerequisites
+
+You'll need [Go](https://go.dev/doc/install) (1.25+), [Node.js](https://nodejs.org/en/download/) (with [pnpm](https://pnpm.io/installation)), and [protoc](https://grpc.io/docs/protoc-installation/).
+
+On macOS, you can install everything in one go:
+
+```bash
+brew install go node pnpm protobuf
+```
+
+On Linux (Debian/Ubuntu):
+
+```bash
+sudo apt install golang nodejs protobuf-compiler
+npm install -g pnpm
+```
+
+On Windows, we recommend using [WSL2](https://learn.microsoft.com/en-us/windows/wsl/install) and following the Linux instructions.
+
+### 2. Clone and set up
+
+```bash
+git clone https://github.com/amir20/dozzle.git
+cd dozzle
+pnpm install                # installs frontend dependencies
+go install tool             # installs Go build tools listed in go.mod (air, protoc-gen-go, etc.)
+make generate               # generates TLS certificates and protobuf code (only needed once)
+```
+
+### 3. Start the dev server
+
+```bash
+make dev
+```
+
+Open [http://localhost:3100](http://localhost:3100) — you should see the Dozzle UI connected to your local Docker. Both the frontend and backend reload automatically when you save a file.
+
+### Making your first change
+
+Try editing `assets/pages/index.vue` and saving — the browser updates instantly. For backend changes, edit any `.go` file and the server will restart on its own.
+
+### Troubleshooting
+
+- **Nothing shows up at localhost:3100** — make sure Docker is running and the socket is accessible at `/var/run/docker.sock`.
+- **`make generate` fails** — confirm `protoc` is on your PATH (`protoc --version`).
+- **Still stuck?** Open a question in [GitHub Discussions](https://github.com/amir20/dozzle/discussions) — we're happy to help.

SECURITY.md

@@ -0,0 +1,5 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Dozzle is checked daily with https://docs.docker.com/scout/ and its dependencies are updated regularly. If you find a security bug, please update to the latest. For vulnerability on latest images please file an issue on Github. 

analytics/ga.go

@@ -1,73 +0,0 @@
-package analytics
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"net/http/httputil"
-
-	log "github.com/sirupsen/logrus"
-)
-
-func SendStartEvent(se StartEvent) error {
-	postBody := map[string]interface{}{
-		"client_id": se.ClientId,
-		"events": []map[string]interface{}{
-			{
-				"name":   "start",
-				"params": se,
-			},
-		},
-	}
-
-	return doRequest(postBody)
-}
-
-func SendRequestEvent(re RequestEvent) error {
-	postBody := map[string]interface{}{
-		"client_id": re.ClientId,
-		"events": []map[string]interface{}{
-			{
-				"name":   "request",
-				"params": re,
-			},
-		},
-	}
-
-	return doRequest(postBody)
-}
-
-func doRequest(body map[string]interface{}) error {
-	jsonValue, err := json.Marshal(body)
-	if err != nil {
-		return err
-	}
-
-	req, err := http.NewRequest("POST", "https://www.google-analytics.com/mp/collect", bytes.NewBuffer(jsonValue))
-	if err != nil {
-		return err
-	}
-
-	q := req.URL.Query()
-	q.Add("measurement_id", "G-S6NT05VXK9")
-	q.Add("api_secret", "7FFhe65HQK-bXvujpQMquQ")
-	req.URL.RawQuery = q.Encode()
-
-	response, err := http.DefaultClient.Do(req)
-	if err != nil {
-		return err
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode/100 != 2 {
-		dump, err := httputil.DumpResponse(response, true)
-		if err != nil {
-			return err
-		}
-		log.Debugf("%v", string(dump))
-		return fmt.Errorf("google analytics returned non-2xx status code: %v", response.Status)
-	}
-
-	return nil
-}

analytics/types.go

@@ -1,18 +0,0 @@
-package analytics
-
-type StartEvent struct {
-	ClientId         string `json:"-"`
-	Version          string `json:"version"`
-	FilterLength     int    `json:"filterLength"`
-	RemoteHostLength int    `json:"remoteHostLength"`
-	CustomAddress    bool   `json:"customAddress"`
-	CustomBase       bool   `json:"customBase"`
-	Protected        bool   `json:"protected"`
-	HasHostname      bool   `json:"hasHostname"`
-}
-
-type RequestEvent struct {
-	ClientId          string `json:"-"`
-	TotalContainers   int    `json:"totalContainers"`
-	RunningContainers int    `json:"runningContainers"`
-}

assets/App.vue

@@ -3,6 +3,7 @@
 </template>
 
 <script lang="ts" setup>
+const mode = useColorMode();
 watchEffect(() => {
   if (smallerScrollbars.value) {
     document.documentElement.classList.add("has-custom-scrollbars");
@@ -10,17 +11,42 @@ watchEffect(() => {
     document.documentElement.classList.remove("has-custom-scrollbars");
   }
 
-  switch (lightTheme.value) {
-    case "dark":
-      document.documentElement.setAttribute("data-theme", "dark");
-      break;
-    case "light":
-      document.documentElement.setAttribute("data-theme", "light");
-      break;
-    default:
-      document.documentElement.removeAttribute("data-theme");
+  let theme = lightTheme.value;
+  if (theme === "auto") {
+    theme = mode.value;
   }
+  document.querySelector('meta[name="theme-color"]')?.setAttribute("content", theme == "dark" ? "#121212" : "#F5F5F5");
+  document.documentElement.setAttribute("data-theme", theme);
 });
 </script>
+<style>
+html.has-custom-scrollbars {
+  ::-webkit-scrollbar {
+    width: 8px;
+    display: content;
+  }
 
-<style scoped lang="scss"></style>
+  ::-webkit-scrollbar-thumb {
+    background-color: rgba(128, 128, 128, 0.33);
+    outline: 1px solid slategrey;
+    border-radius: 4px;
+  }
+
+  ::-webkit-scrollbar-thumb:active {
+    background-color: #777;
+  }
+
+  ::-webkit-scrollbar-track {
+    background-color: transparent;
+  }
+
+  ::-webkit-scrollbar-track:hover {
+    background-color: rgba(64, 64, 64, 0.33);
+  }
+
+  section main {
+    scrollbar-color: #353535 transparent;
+    scrollbar-width: thin;
+  }
+}
+</style>

assets/build.spec.ts

@@ -0,0 +1,24 @@
+import { build } from "vite";
+import { describe, expect, it } from "vitest";
+
+describe("production build", () => {
+  it("emits font URLs relative to the generated stylesheet", async () => {
+    const result = await build({
+      configFile: "vite.config.ts",
+      logLevel: "silent",
+      build: { write: false },
+    });
+    const outputs = Array.isArray(result) ? result : [result];
+    const stylesheet = outputs
+      .flatMap((output) => ("output" in output ? output.output : []))
+      .find((item) => item.type === "asset" && item.fileName.endsWith(".css"));
+
+    expect(stylesheet).toBeDefined();
+    if (!stylesheet || stylesheet.type !== "asset") {
+      throw new Error("Production build did not emit a stylesheet");
+    }
+    const css = String(stylesheet.source);
+    expect(css).toMatch(/url\(\.\/jetbrains-mono/);
+    expect(css).not.toMatch(/url\(\/assets\/jetbrains-mono/);
+  }, 15_000);
+});

assets/components.d.ts

@@ -1,66 +1,213 @@
 /* eslint-disable */
-/* prettier-ignore */
 // @ts-nocheck
+// biome-ignore lint: disable
+// oxlint-disable
+// ------
 // Generated by unplugin-vue-components
 // Read more: https://github.com/vuejs/core/pull/3399
+
 export {}
 
+/* prettier-ignore */
 declare module 'vue' {
   export interface GlobalComponents {
+    AlertCard: typeof import('./components/Notification/AlertCard.vue')['default']
+    AlertForm: typeof import('./components/Notification/AlertForm.vue')['default']
+    Announcements: typeof import('./components/Announcements.vue')['default']
     BarChart: typeof import('./components/BarChart.vue')['default']
+    'Carbon:add': typeof import('~icons/carbon/add')['default']
     'Carbon:caretDown': typeof import('~icons/carbon/caret-down')['default']
     'Carbon:circleSolid': typeof import('~icons/carbon/circle-solid')['default']
+    'Carbon:close': typeof import('~icons/carbon/close')['default']
+    'Carbon:information': typeof import('~icons/carbon/information')['default']
+    'Carbon:logoKubernetes': typeof import('~icons/carbon/logo-kubernetes')['default']
+    'Carbon:macShift': typeof import('~icons/carbon/mac-shift')['default']
+    'Carbon:play': typeof import('~icons/carbon/play')['default']
+    'Carbon:restart': typeof import('~icons/carbon/restart')['default']
+    'Carbon:star': typeof import('~icons/carbon/star')['default']
+    'Carbon:starFilled': typeof import('~icons/carbon/star-filled')['default']
+    'Carbon:stopFilledAlt': typeof import('~icons/carbon/stop-filled-alt')['default']
+    'Carbon:upgrade': typeof import('~icons/carbon/upgrade')['default']
+    'Carbon:warning': typeof import('~icons/carbon/warning')['default']
+    Carousel: typeof import('./components/common/Carousel.vue')['default']
+    CarouselItem: typeof import('./components/common/CarouselItem.vue')['default']
     'Cil:checkCircle': typeof import('~icons/cil/check-circle')['default']
     'Cil:circle': typeof import('~icons/cil/circle')['default']
     'Cil:columns': typeof import('~icons/cil/columns')['default']
-    'Cil:findInPage': typeof import('~icons/cil/find-in-page')['default']
     'Cil:xCircle': typeof import('~icons/cil/x-circle')['default']
+    CloudDestinationForm: typeof import('./components/Notification/CloudDestinationForm.vue')['default']
+    CloudPopover: typeof import('./components/CloudPopover.vue')['default']
+    CloudSearchInline: typeof import('./components/CloudSearchInline.vue')['default']
+    CloudSettingsCard: typeof import('./components/CloudSettingsCard.vue')['default']
     ComplexLogItem: typeof import('./components/LogViewer/ComplexLogItem.vue')['default']
-    ContainerHealth: typeof import('./components/LogViewer/ContainerHealth.vue')['default']
-    ContainerPopup: typeof import('./components/LogViewer/ContainerPopup.vue')['default']
-    ContainerStat: typeof import('./components/LogViewer/ContainerStat.vue')['default']
+    ContainerActionsToolbar: typeof import('./components/ContainerViewer/ContainerActionsToolbar.vue')['default']
+    ContainerDropdown: typeof import('./components/ContainerDropdown.vue')['default']
+    ContainerEventLogItem: typeof import('./components/LogViewer/ContainerEventLogItem.vue')['default']
+    ContainerHealth: typeof import('./components/ContainerViewer/ContainerHealth.vue')['default']
+    ContainerLog: typeof import('./components/ContainerViewer/ContainerLog.vue')['default']
+    ContainerPopup: typeof import('./components/ContainerPopup.vue')['default']
+    ContainerStatCell: typeof import('./components/ContainerStatCell.vue')['default']
     ContainerTable: typeof import('./components/ContainerTable.vue')['default']
-    ContainerTitle: typeof import('./components/LogViewer/ContainerTitle.vue')['default']
+    ContainerTitle: typeof import('./components/ContainerViewer/ContainerTitle.vue')['default']
+    CooldownField: typeof import('./components/Notification/CooldownField.vue')['default']
     DateTime: typeof import('./components/common/DateTime.vue')['default']
-    DistanceTime: typeof import('./components/common/DistanceTime.vue')['default']
-    DockerEventLogItem: typeof import('./components/LogViewer/DockerEventLogItem.vue')['default']
-    DropdownMenu: typeof import('./components/DropdownMenu.vue')['default']
-    FieldList: typeof import('./components/LogViewer/FieldList.vue')['default']
+    DestinationCard: typeof import('./components/Notification/DestinationCard.vue')['default']
+    DestinationForm: typeof import('./components/Notification/DestinationForm.vue')['default']
+    Dropdown: typeof import('./components/common/Dropdown.vue')['default']
+    DropdownMenu: typeof import('./components/common/DropdownMenu.vue')['default']
+    EventAlertFields: typeof import('./components/Notification/EventAlertFields.vue')['default']
+    EventSource: typeof import('./components/LogViewer/EventSource.vue')['default']
     FuzzySearchModal: typeof import('./components/FuzzySearchModal.vue')['default']
-    InfiniteLoader: typeof import('./components/InfiniteLoader.vue')['default']
-    LogActionsToolbar: typeof import('./components/LogViewer/LogActionsToolbar.vue')['default']
-    LogContainer: typeof import('./components/LogViewer/LogContainer.vue')['default']
+    GroupedLog: typeof import('./components/GroupedViewer/GroupedLog.vue')['default']
+    GroupedLogItem: typeof import('./components/LogViewer/GroupedLogItem.vue')['default']
+    GroupMenu: typeof import('./components/GroupMenu.vue')['default']
+    HistoricalContainerLog: typeof import('./components/ContainerViewer/HistoricalContainerLog.vue')['default']
+    HostCard: typeof import('./components/HostCard.vue')['default']
+    HostGroupLog: typeof import('./components/HostViewer/HostGroupLog.vue')['default']
+    HostIcon: typeof import('./components/common/HostIcon.vue')['default']
+    HostList: typeof import('./components/HostList.vue')['default']
+    HostLog: typeof import('./components/HostViewer/HostLog.vue')['default']
+    HostMenu: typeof import('./components/HostMenu.vue')['default']
+    'Ic:sharpKeyboardReturn': typeof import('~icons/ic/sharp-keyboard-return')['default']
+    IndeterminateBar: typeof import('./components/common/IndeterminateBar.vue')['default']
+    IOCard: typeof import('./components/LogViewer/IOCard.vue')['default']
+    'Ion:ellipsisVertical': typeof import('~icons/ion/ellipsis-vertical')['default']
+    JsonFormatted: typeof import('./components/common/JsonFormatted.vue')['default']
+    JsonText: typeof import('./components/common/JsonText.vue')['default']
+    JsonValue: typeof import('./components/common/JsonValue.vue')['default']
+    K8sMenu: typeof import('./components/K8sMenu.vue')['default']
+    KeyShortcut: typeof import('./components/common/KeyShortcut.vue')['default']
+    LabeledInput: typeof import('./components/common/LabeledInput.vue')['default']
+    Links: typeof import('./components/Links.vue')['default']
+    LoadMoreLogItem: typeof import('./components/LogViewer/LoadMoreLogItem.vue')['default']
+    LogActions: typeof import('./components/LogViewer/LogActions.vue')['default']
+    LogAlertFields: typeof import('./components/Notification/LogAlertFields.vue')['default']
+    LogAnalytics: typeof import('./components/LogViewer/LogAnalytics.vue')['default']
     LogDate: typeof import('./components/LogViewer/LogDate.vue')['default']
-    LogEventSource: typeof import('./components/LogViewer/LogEventSource.vue')['default']
+    LogDetails: typeof import('./components/LogViewer/LogDetails.vue')['default']
+    LogItem: typeof import('./components/LogViewer/LogItem.vue')['default']
     LogLevel: typeof import('./components/LogViewer/LogLevel.vue')['default']
+    LogList: typeof import('./components/LogViewer/LogList.vue')['default']
     LogStd: typeof import('./components/LogViewer/LogStd.vue')['default']
     LogViewer: typeof import('./components/LogViewer/LogViewer.vue')['default']
-    LogViewerWithSource: typeof import('./components/LogViewer/LogViewerWithSource.vue')['default']
+    'MaterialSymbols:codeBlocksRounded': typeof import('~icons/material-symbols/code-blocks-rounded')['default']
+    'MaterialSymbols:contentCopy': typeof import('~icons/material-symbols/content-copy')['default']
+    'MaterialSymbols:eyeTracking': typeof import('~icons/material-symbols/eye-tracking')['default']
+    'MaterialSymbols:link': typeof import('~icons/material-symbols/link')['default']
+    'MaterialSymbols:logout': typeof import('~icons/material-symbols/logout')['default']
+    'MaterialSymbols:person': typeof import('~icons/material-symbols/person')['default']
+    'MaterialSymbols:terminal': typeof import('~icons/material-symbols/terminal')['default']
+    'MaterialSymbolsLight:collapseAll': typeof import('~icons/material-symbols-light/collapse-all')['default']
+    'MaterialSymbolsLight:expandAll': typeof import('~icons/material-symbols-light/expand-all')['default']
+    'Mdi:account': typeof import('~icons/mdi/account')['default']
+    'Mdi:alert': typeof import('~icons/mdi/alert')['default']
+    'Mdi:alertCircle': typeof import('~icons/mdi/alert-circle')['default']
+    'Mdi:alertCircleOutline': typeof import('~icons/mdi/alert-circle-outline')['default']
+    'Mdi:alertOutline': typeof import('~icons/mdi/alert-outline')['default']
+    'Mdi:announcement': typeof import('~icons/mdi/announcement')['default']
+    'Mdi:arrowCollapse': typeof import('~icons/mdi/arrow-collapse')['default']
+    'Mdi:arrowExpand': typeof import('~icons/mdi/arrow-expand')['default']
     'Mdi:arrowUp': typeof import('~icons/mdi/arrow-up')['default']
-    'Mdi:dotsVertical': typeof import('~icons/mdi/dots-vertical')['default']
-    'Mdi:lightChevronDoubleDown': typeof import('~icons/mdi-light/chevron-double-down')['default']
-    'Mdi:lightChevronLeft': typeof import('~icons/mdi-light/chevron-left')['default']
-    'Mdi:lightChevronRight': typeof import('~icons/mdi-light/chevron-right')['default']
-    'Mdi:lightCog': typeof import('~icons/mdi-light/cog')['default']
-    'Mdi:lightLogout': typeof import('~icons/mdi-light/logout')['default']
-    'Mdi:lightMagnify': typeof import('~icons/mdi-light/magnify')['default']
+    'Mdi:beer': typeof import('~icons/mdi/beer')['default']
+    'Mdi:bell': typeof import('~icons/mdi/bell')['default']
+    'Mdi:bellRingOutline': typeof import('~icons/mdi/bell-ring-outline')['default']
+    'Mdi:chartBar': typeof import('~icons/mdi/chart-bar')['default']
+    'Mdi:chartLine': typeof import('~icons/mdi/chart-line')['default']
+    'Mdi:check': typeof import('~icons/mdi/check')['default']
+    'Mdi:checkCircle': typeof import('~icons/mdi/check-circle')['default']
+    'Mdi:chevronDoubleDown': typeof import('~icons/mdi/chevron-double-down')['default']
+    'Mdi:chevronDown': typeof import('~icons/mdi/chevron-down')['default']
+    'Mdi:chevronLeft': typeof import('~icons/mdi/chevron-left')['default']
+    'Mdi:chevronRight': typeof import('~icons/mdi/chevron-right')['default']
+    'Mdi:close': typeof import('~icons/mdi/close')['default']
+    'Mdi:cloud': typeof import('~icons/mdi/cloud')['default']
+    'Mdi:cloudCheckOutline': typeof import('~icons/mdi/cloud-check-outline')['default']
+    'Mdi:cloudOffOutline': typeof import('~icons/mdi/cloud-off-outline')['default']
+    'Mdi:cloudOutline': typeof import('~icons/mdi/cloud-outline')['default']
+    'Mdi:cloudSearchOutline': typeof import('~icons/mdi/cloud-search-outline')['default']
+    'Mdi:cog': typeof import('~icons/mdi/cog')['default']
+    'Mdi:contentCopy': typeof import('~icons/mdi/content-copy')['default']
+    'Mdi:docker': typeof import('~icons/mdi/docker')['default']
+    'Mdi:filterOffOutline': typeof import('~icons/mdi/filter-off-outline')['default']
+    'Mdi:filterOutline': typeof import('~icons/mdi/filter-outline')['default']
+    'Mdi:flash': typeof import('~icons/mdi/flash')['default']
+    'Mdi:gauge': typeof import('~icons/mdi/gauge')['default']
+    'Mdi:github': typeof import('~icons/mdi/github')['default']
+    'Mdi:hamburgerMenu': typeof import('~icons/mdi/hamburger-menu')['default']
+    'Mdi:heart': typeof import('~icons/mdi/heart')['default']
+    'Mdi:hexagonMultiple': typeof import('~icons/mdi/hexagon-multiple')['default']
+    'Mdi:key': typeof import('~icons/mdi/key')['default']
+    'Mdi:keyboardEsc': typeof import('~icons/mdi/keyboard-esc')['default']
+    'Mdi:lightningBolt': typeof import('~icons/mdi/lightning-bolt')['default']
+    'Mdi:linkVariant': typeof import('~icons/mdi/link-variant')['default']
+    'Mdi:linkVariantOff': typeof import('~icons/mdi/link-variant-off')['default']
+    'Mdi:magnify': typeof import('~icons/mdi/magnify')['default']
+    'Mdi:pencilOutline': typeof import('~icons/mdi/pencil-outline')['default']
+    'Mdi:plus': typeof import('~icons/mdi/plus')['default']
+    'Mdi:poll': typeof import('~icons/mdi/poll')['default']
+    'Mdi:refresh': typeof import('~icons/mdi/refresh')['default']
+    'Mdi:satelliteVariant': typeof import('~icons/mdi/satellite-variant')['default']
+    'Mdi:textBoxOutline': typeof import('~icons/mdi/text-box-outline')['default']
+    'Mdi:trashCanOutline': typeof import('~icons/mdi/trash-can-outline')['default']
+    'Mdi:webhook': typeof import('~icons/mdi/webhook')['default']
+    MetricAlertFields: typeof import('./components/Notification/MetricAlertFields.vue')['default']
+    MetricCard: typeof import('./components/MetricCard.vue')['default']
     MobileMenu: typeof import('./components/common/MobileMenu.vue')['default']
+    MultiContainerActionToolbar: typeof import('./components/LogViewer/MultiContainerActionToolbar.vue')['default']
+    MultiContainerLog: typeof import('./components/MultiContainerViewer/MultiContainerLog.vue')['default']
+    MultiContainerStat: typeof import('./components/LogViewer/MultiContainerStat.vue')['default']
+    NamespaceLog: typeof import('./components/K8sViewer/NamespaceLog.vue')['default']
     'Octicon:container24': typeof import('~icons/octicon/container24')['default']
     'Octicon:download24': typeof import('~icons/octicon/download24')['default']
     'Octicon:trash24': typeof import('~icons/octicon/trash24')['default']
+    OwnerLog: typeof import('./components/K8sViewer/OwnerLog.vue')['default']
+    PageWithLinks: typeof import('./components/PageWithLinks.vue')['default']
+    'Ph:arrowsMerge': typeof import('~icons/ph/arrows-merge')['default']
+    'Ph:boundingBoxFill': typeof import('~icons/ph/bounding-box-fill')['default']
+    'Ph:caretRight': typeof import('~icons/ph/caret-right')['default']
+    'Ph:circlesFour': typeof import('~icons/ph/circles-four')['default']
+    'Ph:command': typeof import('~icons/ph/command')['default']
+    'Ph:computerTower': typeof import('~icons/ph/computer-tower')['default']
+    'Ph:controlBold': typeof import('~icons/ph/control-bold')['default']
+    'Ph:database': typeof import('~icons/ph/database')['default']
+    'Ph:dotsThreeVerticalBold': typeof import('~icons/ph/dots-three-vertical-bold')['default']
+    'Ph:downloadSimple': typeof import('~icons/ph/download-simple')['default']
+    'Ph:fileSql': typeof import('~icons/ph/file-sql')['default']
+    'Ph:globeSimple': typeof import('~icons/ph/globe-simple')['default']
+    'Ph:stack': typeof import('~icons/ph/stack')['default']
+    'Ph:stackSimple': typeof import('~icons/ph/stack-simple')['default']
     Popup: typeof import('./components/Popup.vue')['default']
+    RandomColorTag: typeof import('./components/LogViewer/RandomColorTag.vue')['default']
+    RelativeTime: typeof import('./components/common/RelativeTime.vue')['default']
+    'Ri:terminalWindowFill': typeof import('~icons/ri/terminal-window-fill')['default']
     RouterLink: typeof import('vue-router')['RouterLink']
     RouterView: typeof import('vue-router')['RouterView']
     ScrollableView: typeof import('./components/ScrollableView.vue')['default']
     ScrollProgress: typeof import('./components/ScrollProgress.vue')['default']
     Search: typeof import('./components/Search.vue')['default']
+    SearchStatus: typeof import('./components/LogViewer/SearchStatus.vue')['default']
+    ServiceLog: typeof import('./components/ServiceViewer/ServiceLog.vue')['default']
+    SideDrawer: typeof import('./components/common/SideDrawer.vue')['default']
     SideMenu: typeof import('./components/SideMenu.vue')['default']
     SidePanel: typeof import('./components/SidePanel.vue')['default']
+    'SimpleIcons:podman': typeof import('~icons/simple-icons/podman')['default']
     SimpleLogItem: typeof import('./components/LogViewer/SimpleLogItem.vue')['default']
     SkippedEntriesLogItem: typeof import('./components/LogViewer/SkippedEntriesLogItem.vue')['default']
-    StatMonitor: typeof import('./components/LogViewer/StatMonitor.vue')['default']
-    StatSparkline: typeof import('./components/LogViewer/StatSparkline.vue')['default']
+    SlideTransition: typeof import('./components/common/SlideTransition.vue')['default']
+    SQLTable: typeof import('./components/LogViewer/SQLTable.vue')['default']
+    StackLog: typeof import('./components/StackViewer/StackLog.vue')['default']
+    StatCard: typeof import('./components/LogViewer/StatCard.vue')['default']
+    'SvgSpinners:ringResize': typeof import('~icons/svg-spinners/ring-resize')['default']
+    SwarmMenu: typeof import('./components/SwarmMenu.vue')['default']
     Tag: typeof import('./components/common/Tag.vue')['default']
+    Terminal: typeof import('./components/Terminal.vue')['default']
+    TimedButton: typeof import('./components/common/TimedButton.vue')['default']
+    ToastModal: typeof import('./components/common/ToastModal.vue')['default']
+    Toggle: typeof import('./components/common/Toggle.vue')['default']
+    ViewerWithSource: typeof import('./components/LogViewer/ViewerWithSource.vue')['default']
+    VolumeWarning: typeof import('./components/ContainerViewer/VolumeWarning.vue')['default']
+    WebhookDestinationForm: typeof import('./components/Notification/WebhookDestinationForm.vue')['default']
+    WelcomeModal: typeof import('./components/WelcomeModal.vue')['default']
     ZigZag: typeof import('./components/LogViewer/ZigZag.vue')['default']
   }
 }

assets/components/Announcements.vue

@@ -0,0 +1,119 @@
+<template>
+  <Dropdown
+    class="dropdown-end"
+    @click="config.releaseCheckMode === 'manual' && fetchReleases()"
+    @closed="releaseSeen = mostRecent?.tag ?? config.version"
+  >
+    <template #trigger>
+      <mdi:announcement class="size-6 -rotate-12" />
+      <template v-if="announcements.length > 0 && releaseSeen != mostRecent?.tag">
+        <span class="bg-red absolute top-0 right-px size-2 animate-ping rounded-full opacity-75"></span>
+        <span class="bg-red absolute top-0 right-px size-2 rounded-full"></span>
+      </template>
+    </template>
+    <template #content>
+      <div class="w-72">
+        <ul class="space-y-4 p-2">
+          <li v-for="release in announcements" v-if="announcements.length > 0">
+            <template v-if="release.announcement">
+              <div class="flex items-baseline gap-1">
+                <carbon:information class="text-info self-center" />
+                <a
+                  :href="release.htmlUrl"
+                  class="link-primary text-lg font-bold"
+                  target="_blank"
+                  rel="noreferrer noopener"
+                >
+                  {{ release.name }}
+                </a>
+                <span class="ml-1 text-xs"><RelativeTime :date="release.createdAt" /></span>
+              </div>
+              <div class="text-base-content/80 text-sm">
+                {{ release.body }}
+              </div>
+            </template>
+            <template v-else>
+              <div class="flex items-baseline gap-1">
+                <carbon:warning class="stroke-orange self-center" v-if="release.breaking > 0" />
+                <a
+                  :href="release.htmlUrl"
+                  class="link-primary text-lg font-bold"
+                  target="_blank"
+                  rel="noreferrer noopener"
+                >
+                  {{ release.name }}
+                </a>
+                <span class="ml-1 text-xs"><RelativeTime :date="release.createdAt" /></span>
+                <Tag class="bg-red ml-auto px-1 py-1 text-xs" v-if="release.latest">
+                  {{ $t("releases.latest") }}
+                </Tag>
+              </div>
+              <div class="text-base-content/80 text-sm">
+                {{ summary(release) }}
+              </div>
+            </template>
+          </li>
+          <li v-else>
+            <div class="text-base-content/80 text-sm">
+              {{ $t("releases.no_releases") }}
+            </div>
+          </li>
+        </ul>
+      </div>
+    </template>
+  </Dropdown>
+</template>
+
+<script setup lang="ts">
+import { useAnnouncements } from "@/stores/announcements";
+
+const { announcements, mostRecent, fetchReleases } = useAnnouncements();
+const { t } = useI18n();
+
+const releaseSeen = useProfileStorage("releaseSeen", config.version);
+
+function summary(release: { features: number; bugFixes: number; breaking: number }) {
+  if (release.features > 0 && release.bugFixes > 0 && release.breaking > 0) {
+    return t("releases.three_parts", {
+      first: t("releases.breaking", { count: release.breaking }),
+      second: t("releases.features", { count: release.features }),
+      third: t("releases.bugFixes", { count: release.bugFixes }),
+    });
+  }
+
+  if (release.features > 0 && release.bugFixes > 0) {
+    return t("releases.two_parts", {
+      first: t("releases.features", { count: release.features }),
+      second: t("releases.bugFixes", { count: release.bugFixes }),
+    });
+  }
+
+  if (release.features > 0 && release.breaking > 0) {
+    return t("releases.two_parts", {
+      first: t("releases.features", { count: release.features }),
+      second: t("releases.breaking", { count: release.breaking }),
+    });
+  }
+
+  if (release.bugFixes > 0 && release.breaking > 0) {
+    return t("releases.two_parts", {
+      first: t("releases.bugFixes", { count: release.bugFixes }),
+      second: t("releases.breaking", { count: release.breaking }),
+    });
+  }
+
+  if (release.features > 0) {
+    return t("releases.features", { count: release.features });
+  }
+
+  if (release.bugFixes > 0) {
+    return t("releases.bugFixes", { count: release.bugFixes });
+  }
+
+  if (release.breaking > 0) {
+    return t("releases.breaking", { count: release.breaking });
+  }
+}
+</script>
+
+<style scoped></style>

assets/components/BarChart.spec.ts

@@ -0,0 +1,75 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { flushPromises, mount } from "@vue/test-utils";
+import { describe, expect, test, vi } from "vitest";
+import { nextTick } from "vue";
+import BarChart, { type BarDataPoint } from "./BarChart.vue";
+
+// useElementSize relies on ResizeObserver which jsdom lacks, so the width stays
+// 0 and the chart never renders. Mock it with a controllable width ref that we
+// flip to a real value after mount to mimic the ResizeObserver firing.
+const holder = vi.hoisted(() => ({ width: null as ReturnType<typeof import("vue").ref<number>> | null }));
+vi.mock("@vueuse/core", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@vueuse/core")>();
+  const { ref: vueRef } = await import("vue");
+  holder.width = vueRef(0);
+  return { ...actual, useElementSize: () => ({ width: holder.width, height: vueRef(0) }) };
+});
+
+function ramp(start = 0, n = 300): BarDataPoint[] {
+  return Array.from({ length: n }, (_, i) => ({ percent: start + i, value: start + i }));
+}
+
+function constant(percent: number, n = 300): BarDataPoint[] {
+  return Array.from({ length: n }, () => ({ percent, value: percent }));
+}
+
+function heightOf(wrapper: ReturnType<typeof mount>, index: number): number {
+  const style = wrapper.findAll(".bar")[index]?.attributes("style") ?? "";
+  const match = style.match(/--height:\s*([\d.]+)%/);
+  return match ? parseFloat(match[1]) : 0;
+}
+
+async function mountAndRender(chartData: BarDataPoint[]) {
+  // Mount with an unmeasured element, then simulate ResizeObserver reporting a
+  // real width -> triggers the initial recalculate, like the live component.
+  holder.width!.value = 0;
+  const wrapper = mount(BarChart, { props: { chartData } });
+  await nextTick();
+  holder.width!.value = 300;
+  await nextTick();
+  await flushPromises();
+  return wrapper;
+}
+
+describe("<BarChart />", () => {
+  test("exposed recalculate() rebuilds all bars after a wholesale data swap", async () => {
+    // First container: a ramp where the oldest bars are near zero.
+    const wrapper = await mountAndRender(ramp());
+    expect(heightOf(wrapper, 0)).toBeLessThan(20); // oldest ramp bar is tiny
+
+    // A stat tick arrives: the rolling window shifts by one, marking the chart
+    // initialized so further changes only patch the last bar.
+    await wrapper.setProps({ chartData: ramp(1) });
+    await nextTick();
+
+    // Switch containers: the whole series is replaced with a flat high value.
+    // The chart caches bars and only patches the last one, so without help the
+    // older bars stay stale.
+    await wrapper.setProps({ chartData: constant(1000) });
+    await nextTick();
+    expect(heightOf(wrapper, 0)).toBeLessThan(20); // still stale
+
+    // The parent owns container switches and calls recalculate() to refresh.
+    (wrapper.vm as unknown as { recalculate: () => void }).recalculate();
+    await nextTick();
+    expect(heightOf(wrapper, 0)).toBeGreaterThan(50); // flat series -> uniform height
+  });
+
+  test("renders downsampled bars once width is known", async () => {
+    const wrapper = await mountAndRender(constant(1000));
+    expect(wrapper.findAll(".bar").length).toBeGreaterThan(0);
+    expect(heightOf(wrapper, 0)).toBeGreaterThan(50);
+  });
+});

assets/components/BarChart.vue

@@ -1,31 +1,137 @@
 <template>
-  <div class="is-relative">
-    <div class="bar"></div>
-    <div class="is-overlay">
-      <slot></slot>
-    </div>
+  <div ref="chartContainer" class="flex items-end gap-[2px]" @mousemove="onContainerHover">
+    <div
+      v-for="(bar, i) in downsampledBars"
+      :key="i"
+      class="bar min-h-px flex-1 rounded-t-sm"
+      :class="barClass"
+      :style="{ '--height': `${maxValue > 0 ? (bar.percent / maxValue) * 100 : 0}%` }"
+    ></div>
   </div>
 </template>
 
-<script lang="ts" setup>
-const { value } = defineProps<{ value: number }>();
-
-const minValue = computed(() => Math.min(value, 1));
-</script>
-
 <style scoped>
 .bar {
-  height: 1.5em;
-  background-color: var(--primary-color);
-  transform-origin: left;
-  transform: scaleX(v-bind(minValue));
-  transition: transform 0.2s ease-out;
-  border-top-right-radius: 0.2em;
-  border-bottom-right-radius: 0.2em;
-}
-
-.is-overlay {
-  font-size: 0.9em;
-  padding: 0 0.5em;
+  height: var(--height);
+  will-change: height;
+  contain: layout;
 }
 </style>
+
+<script setup lang="ts">
+export interface BarDataPoint {
+  percent: number;
+  value: number;
+}
+
+const { chartData, barClass = "" } = defineProps<{
+  chartData: BarDataPoint[];
+  barClass?: string;
+}>();
+
+const hoverValue = defineEmit<[value: number]>();
+
+const chartContainer = ref<HTMLElement | null>(null);
+const { width } = useElementSize(chartContainer);
+
+const BAR_WIDTH = 3;
+const GAP = 2;
+
+const availableBars = computed(() => Math.floor(width.value / (BAR_WIDTH + GAP)));
+const bucketSize = computed(() => Math.ceil(chartData.length / availableBars.value));
+
+const downsampledBars = ref<BarDataPoint[]>([]);
+const maxValue = computed(() => {
+  const dataMax = Math.max(0, ...downsampledBars.value.map((b) => b.percent));
+  return Math.max(dataMax * 1.25, 1);
+});
+// Full recalculate when width/bucket size changes
+watch([availableBars, bucketSize], () => {
+  recalculate();
+  changeCounter.value = 0;
+});
+
+// On data changes, only update the last bar unless a new bucket boundary is crossed.
+// A wholesale replacement of the series (e.g. switching containers) is not detected
+// here; the parent owns that and must call the exposed recalculate() on switch.
+const changeCounter = ref(0);
+let initialized = false;
+watch(
+  () => chartData.at(-1),
+  () => {
+    if (!initialized) {
+      initialized = true;
+      recalculate();
+      return;
+    }
+    changeCounter.value++;
+    if (changeCounter.value >= bucketSize.value) {
+      recalculate();
+      changeCounter.value = 0;
+    } else {
+      updateLastBar();
+    }
+  },
+);
+
+defineExpose({ recalculate });
+
+function averageBucket(bucket: BarDataPoint[]): BarDataPoint {
+  const percent = bucket.reduce((sum, d) => sum + d.percent, 0) / bucket.length;
+  const value = bucket.reduce((sum, d) => sum + d.value, 0) / bucket.length;
+  return { percent, value };
+}
+
+function recalculate() {
+  if (availableBars.value === 0) return;
+
+  if (chartData.length <= availableBars.value) {
+    downsampledBars.value = [...chartData];
+    return;
+  }
+
+  const size = bucketSize.value;
+  const result: BarDataPoint[] = [];
+  const numBuckets = Math.ceil(chartData.length / size);
+
+  for (let i = 0; i < numBuckets; i++) {
+    const start = i * size;
+    const end = Math.min(start + size, chartData.length);
+    result.push(averageBucket(chartData.slice(start, end)));
+  }
+
+  downsampledBars.value = result.slice(-availableBars.value);
+}
+
+function updateLastBar() {
+  if (downsampledBars.value.length === 0) return;
+
+  const size = bucketSize.value;
+  const lastBucketStart = (Math.ceil(chartData.length / size) - 1) * size;
+  const bucket = chartData.slice(lastBucketStart);
+
+  downsampledBars.value[downsampledBars.value.length - 1] = averageBucket(bucket);
+}
+
+function onContainerHover(event: MouseEvent) {
+  if (!chartContainer.value) return;
+
+  const bars = chartContainer.value.children;
+  if (bars.length === 0) return;
+
+  const mouseX = event.clientX;
+  let index = 0;
+
+  // Find the bar whose column contains the mouse x position
+  for (let i = 0; i < bars.length; i++) {
+    const rect = bars[i].getBoundingClientRect();
+    if (mouseX >= rect.left) {
+      index = i;
+    } else {
+      break;
+    }
+  }
+
+  hoverValue(downsampledBars.value[index].value);
+}
+</script>

assets/components/CloudPopover.vue

@@ -0,0 +1,158 @@
+<template>
+  <Dropdown class="dropdown-end" @click="onOpen">
+    <template #trigger>
+      <div class="relative">
+        <mdi:cloud
+          class="size-6"
+          :class="
+            !cloudConfig
+              ? 'text-base-content/40'
+              : cloudConfig.linked && !cloudStatusError
+                ? 'text-info'
+                : cloudStatusError === 'unavailable'
+                  ? 'text-warning'
+                  : 'text-error'
+          "
+        />
+        <span
+          v-if="cloudConfig?.linked"
+          class="absolute -top-0.5 -right-0.5 size-2 rounded-full"
+          :class="
+            cloudStatusError === 'auth'
+              ? 'bg-error'
+              : cloudStatusError === 'unavailable'
+                ? 'bg-warning'
+                : cloudStatusError
+                  ? 'bg-error'
+                  : 'bg-success'
+          "
+        ></span>
+      </div>
+    </template>
+    <template #content>
+      <div class="w-80 space-y-3 p-1">
+        <!-- Not linked -->
+        <template v-if="!cloudConfig">
+          <div class="flex flex-col items-center gap-2 p-2 text-center">
+            <mdi:cloud class="text-base-content/40 text-4xl" />
+            <h3 class="text-base font-bold">{{ $t("cloud.title") }}</h3>
+            <p class="text-base-content/60 text-sm">{{ $t("cloud.description") }}</p>
+            <div class="mt-2 flex w-full gap-2">
+              <a :href="`${cloudUrl}`" target="_blank" rel="noreferrer noopener" class="btn btn-sm flex-1">
+                {{ $t("cloud.learn-more") }}
+              </a>
+              <a :href="cloudLinkUrl" class="btn btn-primary btn-sm flex-1">
+                <mdi:link-variant class="text-base" />
+                {{ $t("cloud.link-instance") }}
+              </a>
+            </div>
+          </div>
+        </template>
+
+        <!-- Linked -->
+        <template v-else-if="cloudConfig.linked">
+          <!-- Error state -->
+          <div v-if="cloudStatusError" class="space-y-3">
+            <div class="alert" :class="cloudStatusError === 'auth' ? 'alert-error' : 'alert-warning'">
+              <mdi:alert-circle v-if="cloudStatusError === 'auth'" class="text-lg" />
+              <mdi:cloud-off-outline v-else class="text-lg" />
+              <span class="text-sm">{{
+                cloudStatusError === "auth" ? $t("cloud.error") : $t("cloud.error-unavailable")
+              }}</span>
+            </div>
+            <a v-if="cloudStatusError === 'auth'" :href="cloudLinkUrl" class="btn btn-primary btn-sm w-full">
+              <mdi:link-variant class="text-base" />
+              {{ $t("cloud.relink-instance") }}
+            </a>
+            <button v-else class="btn btn-sm w-full" @click="fetchCloudStatus">
+              <mdi:refresh class="text-base" />
+              {{ $t("button.retry") }}
+            </button>
+          </div>
+
+          <!-- Loading -->
+          <div v-else-if="isLoadingCloudStatus" class="flex items-center justify-center gap-2 py-4">
+            <span class="loading loading-spinner loading-xs"></span>
+          </div>
+
+          <!-- Healthy -->
+          <div v-else-if="cloudStatus" class="space-y-3">
+            <div class="flex items-center justify-between">
+              <h3 class="font-bold">{{ $t("cloud.title") }}</h3>
+              <div class="flex items-center gap-1">
+                <span class="badge badge-success badge-sm">{{ $t("cloud.connected") }}</span>
+                <span class="badge badge-primary badge-sm capitalize">{{ cloudStatus.plan.name }}</span>
+              </div>
+            </div>
+
+            <div>
+              <div class="mb-1 flex items-center justify-between text-sm">
+                <span class="text-base-content/60">{{ $t("cloud.usage") }}</span>
+                <span>
+                  {{ cloudStatus.usage.events_used.toLocaleString() }} /
+                  {{ cloudStatus.usage.events_limit.toLocaleString() }}
+                </span>
+              </div>
+              <progress
+                class="progress w-full"
+                :class="
+                  usagePercent > 90 ? 'progress-error' : usagePercent > 70 ? 'progress-warning' : 'progress-primary'
+                "
+                :value="cloudStatus.usage.events_used"
+                :max="cloudStatus.usage.events_limit"
+              ></progress>
+            </div>
+
+            <div class="flex gap-2">
+              <a :href="cloudUrl" target="_blank" rel="noreferrer noopener" class="btn btn-sm flex-1">
+                {{ $t("cloud.dashboard") }}
+              </a>
+              <a :href="`${cloudUrl}/settings`" target="_blank" rel="noreferrer noopener" class="btn btn-sm flex-1">
+                {{ $t("cloud.settings") }}
+              </a>
+            </div>
+          </div>
+        </template>
+      </div>
+    </template>
+  </Dropdown>
+  <WelcomeModal ref="welcomeModal" />
+</template>
+
+<script lang="ts" setup>
+const cloudUrl = __CLOUD_URL__;
+const callbackUrl = `${window.location.origin}${withBase("/")}`;
+const cloudLinkUrl = `${cloudUrl}/link?appUrl=${encodeURIComponent(callbackUrl)}&from=cloud`;
+
+const { cloudConfig, cloudStatus, cloudStatusError, isLoadingCloudStatus, fetchCloudConfig, fetchCloudStatus } =
+  useCloudConfig();
+
+const welcomeModal = ref<{ open: () => void }>();
+const cloudWelcomeShown = useProfileStorage("cloudWelcomeShown", false);
+
+const usagePercent = computed(() => {
+  if (!cloudStatus.value) return 0;
+  return (cloudStatus.value.usage.events_used / cloudStatus.value.usage.events_limit) * 100;
+});
+
+function onOpen() {
+  if (cloudConfig.value?.linked && !cloudStatus.value && !isLoadingCloudStatus.value) {
+    fetchCloudStatus();
+  }
+}
+
+onMounted(async () => {
+  await fetchCloudConfig();
+
+  if (cloudConfig.value?.linked) {
+    fetchCloudStatus();
+  }
+
+  // Handle successful OAuth return — show welcome modal
+  if (window.location.hash === "#cloudLinked" && !cloudWelcomeShown.value) {
+    cloudWelcomeShown.value = true;
+    nextTick(() => welcomeModal.value?.open());
+    history.replaceState(history.state, "", window.location.pathname + window.location.search);
+  }
+});
+</script>

assets/components/CloudSearchInline.vue

@@ -0,0 +1,35 @@
+<template>
+  <button
+    type="button"
+    data-testid="search"
+    class="bg-base-200 border-base-content/15 hover:border-primary/50 hover:bg-base-200/80 flex h-9 w-full items-center gap-2 rounded-md border px-3 text-left transition-colors"
+    @click="openSearch"
+  >
+    <mdi:magnify class="size-4 shrink-0" :class="cloudReady ? 'text-primary' : 'text-base-content/60'" />
+    <!-- Show the active query when we're on the cloud search page so the
+         topbar reflects what the user is looking at. -->
+    <span v-if="activeQuery" class="text-base-content truncate font-mono text-sm">{{ activeQuery }}</span>
+    <span v-else class="text-base-content/60 truncate text-sm">
+      <template v-if="cloudReady">{{ $t("cloud-search.hero-title-cloud") }}</template>
+      <template v-else>{{ $t("cloud-search.hero-title-plain") }}</template>
+    </span>
+    <span class="ml-auto flex items-center gap-1">
+      <kbd class="kbd kbd-xs">⌘</kbd>
+      <kbd class="kbd kbd-xs">K</kbd>
+    </span>
+  </button>
+</template>
+
+<script lang="ts" setup>
+import { useFuzzySearch } from "@/composable/fuzzySearch";
+import { useCloudConfig } from "@/composable/cloudConfig";
+
+const { openSearch } = useFuzzySearch();
+const { cloudConfig } = useCloudConfig();
+const cloudReady = computed(() => !!cloudConfig.value?.linked && !!cloudConfig.value?.streamLogs);
+
+const route = useRoute();
+const activeQuery = computed(() =>
+  route?.path === "/cloud/search" && typeof route.query?.q === "string" ? route.query.q : "",
+);
+</script>

assets/components/CloudSettingsCard.vue

@@ -0,0 +1,207 @@
+<template>
+  <div class="border-base-content/15 bg-base-200/40 divide-base-content/10 divide-y rounded-lg border">
+    <!-- Not linked -->
+    <template v-if="!cloudConfig">
+      <div class="flex items-start gap-4 p-4">
+        <mdi:cloud class="text-base-content/40 mt-0.5 text-4xl" />
+        <div class="flex flex-col gap-1">
+          <p class="text-base-content/70 text-sm">{{ $t("cloud.description") }}</p>
+          <div class="mt-3 flex gap-2">
+            <a :href="`${cloudUrl}`" target="_blank" rel="noreferrer noopener" class="btn btn-sm">
+              {{ $t("cloud.learn-more") }}
+            </a>
+            <a :href="cloudLinkUrl" class="btn btn-primary btn-sm">
+              <mdi:link-variant class="text-base" />
+              {{ $t("cloud.link-instance") }}
+            </a>
+          </div>
+        </div>
+      </div>
+    </template>
+
+    <!-- Linked -->
+    <template v-else-if="cloudConfig.linked">
+      <!-- Error state -->
+      <div v-if="cloudStatusError" class="space-y-3 p-4">
+        <div class="alert" :class="cloudStatusError === 'auth' ? 'alert-error' : 'alert-warning'">
+          <mdi:alert-circle v-if="cloudStatusError === 'auth'" class="text-lg" />
+          <mdi:cloud-off-outline v-else class="text-lg" />
+          <span class="text-sm">{{
+            cloudStatusError === "auth" ? $t("cloud.error") : $t("cloud.error-unavailable")
+          }}</span>
+        </div>
+        <div class="flex gap-2">
+          <a v-if="cloudStatusError === 'auth'" :href="cloudLinkUrl" class="btn btn-primary btn-sm">
+            <mdi:link-variant class="text-base" />
+            {{ $t("cloud.relink-instance") }}
+          </a>
+          <button v-else class="btn btn-sm" @click="fetchCloudStatus">
+            <mdi:refresh class="text-base" />
+            {{ $t("button.retry") }}
+          </button>
+          <button class="btn btn-sm btn-error" @click="confirmUnlink">
+            <mdi:link-variant-off class="text-base" />
+            {{ $t("cloud.unlink") }}
+          </button>
+        </div>
+      </div>
+
+      <!-- Loading -->
+      <div v-else-if="isLoadingCloudStatus" class="flex items-center gap-2 p-4">
+        <span class="loading loading-spinner loading-sm"></span>
+      </div>
+
+      <!-- Healthy -->
+      <template v-else-if="cloudStatus">
+        <div class="flex flex-wrap items-center gap-2 p-4">
+          <span class="status-pill status-pill-success">
+            <span class="size-1.5 rounded-full bg-current"></span>
+            {{ $t("cloud.connected") }}
+          </span>
+          <span class="status-pill status-pill-primary">{{ cloudStatus.plan.name }}</span>
+          <span class="text-base-content/50 text-sm">{{ cloudStatus.user.email }}</span>
+        </div>
+
+        <div class="flex flex-col gap-2 p-4">
+          <div class="flex items-baseline justify-between">
+            <span class="text-base-content/60 text-sm font-medium">{{ $t("cloud.usage") }}</span>
+            <span class="font-mono text-sm">
+              <span class="font-semibold">{{ cloudStatus.usage.events_used.toLocaleString() }}</span>
+              <span class="text-base-content/40"> / {{ cloudStatus.usage.events_limit.toLocaleString() }}</span>
+            </span>
+          </div>
+          <progress
+            class="progress w-full"
+            :class="usagePercent > 90 ? 'progress-error' : usagePercent > 70 ? 'progress-warning' : 'progress-primary'"
+            :value="cloudStatus.usage.events_used"
+            :max="cloudStatus.usage.events_limit"
+          ></progress>
+          <div class="text-base-content/40 flex justify-between font-mono text-xs">
+            <span v-if="cloudStatus.usage.period">{{ cloudStatus.usage.period }}</span>
+            <span v-else></span>
+            <span>{{ usagePercent.toFixed(2) }}% used</span>
+          </div>
+        </div>
+
+        <label class="flex min-h-13 cursor-pointer items-center justify-between gap-4 p-4">
+          <div class="flex flex-col gap-0.5">
+            <span class="text-sm font-medium">{{ $t("cloud.stream-logs") }}</span>
+            <span class="text-base-content/60 text-xs">{{ $t("cloud.stream-logs-help") }}</span>
+          </div>
+          <input
+            type="checkbox"
+            class="toggle toggle-primary toggle-sm shrink-0"
+            :checked="streamLogs"
+            :disabled="isSavingStreamLogs"
+            @change="onStreamLogsChange(($event.target as HTMLInputElement).checked)"
+          />
+        </label>
+
+        <div class="flex gap-2 p-4">
+          <a :href="cloudUrl" target="_blank" rel="noreferrer noopener" class="btn btn-sm">
+            {{ $t("cloud.dashboard") }}
+          </a>
+          <button class="btn btn-sm btn-error" @click="confirmUnlink">
+            {{ $t("cloud.unlink") }}
+          </button>
+        </div>
+      </template>
+    </template>
+
+    <!-- Unlink confirmation modal -->
+    <dialog ref="unlinkModal" class="modal">
+      <div class="modal-box">
+        <h3 class="text-lg font-bold">{{ $t("cloud.unlink") }}</h3>
+        <p class="py-4 text-sm">{{ $t("cloud.unlink-confirm") }}</p>
+        <div class="modal-action">
+          <form method="dialog">
+            <button class="btn btn-sm">{{ $t("button.cancel") }}</button>
+          </form>
+          <button class="btn btn-error btn-sm" :disabled="isUnlinking" @click="doUnlink">
+            <span v-if="isUnlinking" class="loading loading-spinner loading-xs"></span>
+            {{ $t("cloud.unlink") }}
+          </button>
+        </div>
+      </div>
+      <form method="dialog" class="modal-backdrop">
+        <button></button>
+      </form>
+    </dialog>
+  </div>
+</template>
+
+<script lang="ts" setup>
+const cloudUrl = __CLOUD_URL__;
+const callbackUrl = `${window.location.origin}${withBase("/")}`;
+const cloudLinkUrl = `${cloudUrl}/link?appUrl=${encodeURIComponent(callbackUrl)}&from=cloud`;
+
+const {
+  cloudConfig,
+  cloudStatus,
+  cloudStatusError,
+  isLoadingCloudStatus,
+  initialLoad,
+  fetchCloudStatus,
+  clearCloudState,
+} = useCloudConfig();
+const isUnlinking = ref(false);
+const unlinkModal = ref<HTMLDialogElement | null>(null);
+
+const streamLogs = ref(true);
+const isSavingStreamLogs = ref(false);
+watchEffect(() => {
+  if (cloudConfig.value) streamLogs.value = cloudConfig.value.streamLogs;
+});
+
+async function onStreamLogsChange(value: boolean | undefined) {
+  if (!cloudConfig.value || value === undefined) return;
+  isSavingStreamLogs.value = true;
+  try {
+    const res = await fetch(withBase("/api/cloud/config"), {
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ streamLogs: value }),
+    });
+    if (!res.ok) {
+      streamLogs.value = !value;
+      return;
+    }
+    cloudConfig.value.streamLogs = value;
+  } catch {
+    streamLogs.value = !value;
+  } finally {
+    isSavingStreamLogs.value = false;
+  }
+}
+
+const usagePercent = computed(() => {
+  if (!cloudStatus.value) return 0;
+  return (cloudStatus.value.usage.events_used / cloudStatus.value.usage.events_limit) * 100;
+});
+
+function confirmUnlink() {
+  unlinkModal.value?.showModal();
+}
+
+async function doUnlink() {
+  isUnlinking.value = true;
+  try {
+    const res = await fetch(withBase("/api/cloud/config"), { method: "DELETE" });
+    if (!res.ok) {
+      cloudStatusError.value = "unavailable";
+      return;
+    }
+    clearCloudState();
+    unlinkModal.value?.close();
+  } finally {
+    isUnlinking.value = false;
+  }
+}
+
+onMounted(async () => {
+  await initialLoad;
+  if (cloudConfig.value?.linked) {
+    fetchCloudStatus();
+  }
+});
+</script>

assets/components/ContainerDropdown.vue

@@ -0,0 +1,25 @@
+<template>
+  <div class="dropdown">
+    <button tabindex="0" role="button" class="btn btn-xs md:btn-sm"><slot /> <carbon:caret-down /></button>
+    <ul tabindex="0" class="dropdown-content menu rounded-box bg-base-100 border-base-content/20 border shadow-sm">
+      <li v-for="other in containers">
+        <router-link :to="{ name: '/container/[id]', params: { id: other.id } }" class="text-nowrap">
+          <div
+            class="status data-[state=exited]:status-error data-[state=running]:status-success data-[state=paused]:status-warning"
+            :data-state="other.state"
+          ></div>
+          {{ other.name }}
+          <div v-if="other.state === 'running'">running</div>
+          <div v-else-if="other.state === 'paused'">paused</div>
+          <RelativeTime :date="other.finishedAt" class="text-base-content/70 text-xs" v-else />
+        </router-link>
+      </li>
+    </ul>
+  </div>
+</template>
+<script lang="ts" setup>
+import { type Container } from "@/models/Container";
+const { containers } = defineProps<{
+  containers: Container[];
+}>();
+</script>

assets/components/ContainerPopup.vue

@@ -0,0 +1,38 @@
+<template>
+  <table class="w-full border-separate border-spacing-x-1">
+    <tbody>
+      <tr>
+        <th class="text-right font-light capitalize">STATE</th>
+        <td class="font-semibold uppercase">{{ container.state }}</td>
+      </tr>
+      <tr v-if="container.startedAt.getFullYear() > 0">
+        <th class="text-right font-light capitalize">STARTED</th>
+        <td class="font-semibold">
+          <RelativeTime :date="container.startedAt" />
+        </td>
+      </tr>
+      <tr v-if="container.state != 'running' && container.finishedAt.getFullYear() > 0">
+        <th class="text-right font-light capitalize">FINISHED</th>
+        <td class="font-semibold">
+          <RelativeTime :date="container.finishedAt" />
+        </td>
+      </tr>
+      <tr v-if="container.state == 'running'">
+        <th class="text-right font-light capitalize">Load</th>
+        <td class="font-semibold">{{ container.stat.cpu.toFixed(2) }}%</td>
+      </tr>
+      <tr v-if="container.state == 'running'">
+        <th class="text-right font-light capitalize">MEM</th>
+        <td class="font-semibold">{{ formatBytes(container.stat.memoryUsage) }}</td>
+      </tr>
+    </tbody>
+  </table>
+</template>
+
+<script lang="ts" setup>
+import { Container } from "@/models/Container";
+
+const { container } = defineProps<{
+  container: Container;
+}>();
+</script>

assets/components/ContainerStatCell.spec.ts

@@ -0,0 +1,112 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { mount } from "@vue/test-utils";
+import { describe, expect, test, vi } from "vitest";
+import ContainerStatCell from "./ContainerStatCell.vue";
+import { Container, emptyStat, type Stat } from "@/models/Container";
+import type { Host } from "@/stores/hosts";
+
+vi.mock("@/stores/config", () => ({
+  __esModule: true,
+  default: { base: "", hosts: [{ name: "localhost", id: "localhost" }] },
+  withBase: (path: string) => path,
+}));
+
+function makeStat(partial: Partial<Stat> = {}): Stat {
+  return { ...emptyStat(), ...partial };
+}
+
+function makeContainer(lastStat: Partial<Stat>, cpuLimit = 0): Container {
+  return new Container(
+    "id-1",
+    new Date(),
+    new Date(),
+    new Date(),
+    "image",
+    "name",
+    "command",
+    "localhost",
+    {},
+    "running",
+    cpuLimit,
+    0,
+    [makeStat(lastStat)],
+  );
+}
+
+function host(nCPU?: number): Host {
+  return { id: "localhost", name: "localhost", nCPU } as unknown as Host;
+}
+
+function mountCell(props: { container: Container; type: "cpu" | "mem"; host: Host; mode?: "chart" | "progress" }) {
+  return mount(ContainerStatCell, {
+    props: { mode: "progress", ...props },
+    global: { stubs: { BarChart: true } },
+  });
+}
+
+describe("<ContainerStatCell /> cpu", () => {
+  test("normalizes by cpuLimit when set", () => {
+    const wrapper = mountCell({ container: makeContainer({ cpu: 100 }, 2), type: "cpu", host: host(8) });
+    expect(wrapper.find(".tabular-nums").text()).toBe("50%");
+    expect(wrapper.find("progress").attributes("value")).toBe("50");
+    expect(wrapper.find("progress").classes()).toContain("progress-success");
+  });
+
+  test("falls back to host nCPU when no cpuLimit", () => {
+    const wrapper = mountCell({ container: makeContainer({ cpu: 360 }, 0), type: "cpu", host: host(4) });
+    expect(wrapper.find(".tabular-nums").text()).toBe("90%");
+    expect(wrapper.find("progress").classes()).toContain("progress-warning");
+  });
+
+  test("falls back to a single core and clamps at 100%", () => {
+    const wrapper = mountCell({ container: makeContainer({ cpu: 200 }, 0), type: "cpu", host: host(undefined) });
+    expect(wrapper.find(".tabular-nums").text()).toBe("100%");
+    expect(wrapper.find("progress").classes()).toContain("progress-error");
+  });
+});
+
+describe("<ContainerStatCell /> memory", () => {
+  test("shows absolute usage and percentage-based color", () => {
+    const wrapper = mountCell({
+      container: makeContainer({ memory: 40, memoryUsage: 1500 }),
+      type: "mem",
+      host: host(4),
+    });
+    expect(wrapper.find(".tabular-nums").text()).toBe("1.46 KB");
+    expect(wrapper.find("progress").attributes("value")).toBe("40");
+    expect(wrapper.find("progress").classes()).toContain("progress-success");
+  });
+});
+
+describe("<ContainerStatCell /> color thresholds", () => {
+  test.each([
+    [50, "bg-success"],
+    [70, "bg-secondary"],
+    [90, "bg-warning"],
+    [95, "bg-error"],
+  ])("memory %i%% -> %s", (memory, expected) => {
+    const wrapper = mountCell({ container: makeContainer({ memory }), type: "mem", host: host(4) });
+    expect((wrapper.vm as unknown as { barClass: string }).barClass).toBe(expected);
+  });
+});
+
+describe("<ContainerStatCell /> chart data", () => {
+  test("cpu series is normalized by cores", () => {
+    const wrapper = mountCell({ container: makeContainer({ cpu: 100 }, 4), type: "cpu", host: host(8) });
+    const chartData = (wrapper.vm as unknown as { chartData: { percent: number; value: number }[] }).chartData;
+    expect(chartData).toHaveLength(300);
+    expect(chartData.at(-1)).toEqual({ percent: 25, value: 100 });
+  });
+
+  test("memory series uses percent and absolute usage", () => {
+    const wrapper = mountCell({
+      container: makeContainer({ memory: 30, memoryUsage: 2048 }),
+      type: "mem",
+      host: host(4),
+    });
+    const chartData = (wrapper.vm as unknown as { chartData: { percent: number; value: number }[] }).chartData;
+    expect(chartData.at(-1)).toEqual({ percent: 30, value: 2048 });
+  });
+});

assets/components/ContainerStatCell.vue

@@ -0,0 +1,90 @@
+<template>
+  <div
+    v-if="isMobile"
+    class="flex w-fit items-center gap-1.5 rounded-md px-2 py-1 text-sm font-medium tabular-nums"
+    :class="type === 'cpu' ? 'bg-primary/10 text-primary' : 'bg-secondary/10 text-secondary'"
+  >
+    <component :is="type === 'cpu' ? PhCpu : PhMemory" class="size-3.5 shrink-0" />
+    <span>{{ displayValue }}</span>
+  </div>
+  <div v-else class="flex flex-row items-center gap-2">
+    <template v-if="mode === 'chart'">
+      <BarChart class="h-4 flex-1" :chart-data="chartData" :bar-class="barClass" />
+    </template>
+    <template v-else>
+      <progress class="progress flex-1" :class="progressClass" :value="averageValue" max="100"></progress>
+    </template>
+    <span class="min-w-12 text-right text-sm tabular-nums">{{ displayValue }}</span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { Container } from "@/models/Container";
+import type { Host } from "@/stores/hosts";
+import PhCpu from "~icons/ph/cpu";
+import PhMemory from "~icons/ph/memory";
+
+const {
+  container,
+  type,
+  host,
+  mode = "chart",
+} = defineProps<{
+  container: Container;
+  type: "cpu" | "mem";
+  host: Host;
+  mode?: "chart" | "progress";
+}>();
+
+function totalCores(): number {
+  if (container.cpuLimit && container.cpuLimit > 0) {
+    return container.cpuLimit;
+  }
+  return host.nCPU ?? 1;
+}
+
+const chartData = computed(() => {
+  if (type === "cpu") {
+    const cores = totalCores();
+    return container.statsHistory.map((stat) => {
+      const percent = Math.min(stat.cpu / cores, 100);
+      return { percent, value: stat.cpu };
+    });
+  }
+  return container.statsHistory.map((stat) => {
+    const percent = Math.min(stat.memory, 100);
+    return { percent, value: stat.memoryUsage };
+  });
+});
+
+const averageValue = computed(() => {
+  if (type === "cpu") {
+    const cores = totalCores();
+    return Math.min(container.movingAverage.cpu / cores, 100);
+  }
+  return container.movingAverage.memory;
+});
+
+const displayValue = computed(() => {
+  if (type === "cpu") {
+    return `${averageValue.value.toFixed(0)}%`;
+  }
+  return formatBytes(container.movingAverage.memoryUsage);
+});
+
+const barClass = computed(() => {
+  const value = averageValue.value;
+  if (value <= 50) return "bg-success";
+  if (value <= 70) return "bg-secondary";
+  if (value <= 90) return "bg-warning";
+  return "bg-error";
+});
+
+const progressClass = computed(() => {
+  const value = averageValue.value;
+  if (value <= 50) return "progress-success";
+  if (value <= 70) return "progress-secondary";
+  if (value <= 90) return "progress-warning";
+  return "progress-error";
+});
+</script>

assets/components/ContainerTable.vue

@@ -1,118 +1,229 @@
-!
 <template>
-  <table class="table is-fullwidth">
-    <thead>
-      <tr :data-direction="direction > 0 ? 'asc' : 'desc'">
-        <th
-          v-for="(value, key) in fields"
-          :key="key"
-          @click.prevent="sort(key)"
-          :class="{ 'selected-sort': key === sortField }"
-          v-show="isVisible(key)"
-        >
-          <a>
-            <span class="icon-text">
-              <span>{{ $t(value.label) }}</span>
-              <span class="icon">
-                <mdi:arrow-up />
-              </span>
-            </span>
-          </a>
-        </th>
-      </tr>
-    </thead>
-    <tbody>
-      <tr v-for="container in paginated" :key="container.id">
-        <td v-if="isVisible('name')">
-          <router-link :to="{ name: 'container-id', params: { id: container.id } }" :title="container.name">
-            {{ container.name }}
-          </router-link>
-        </td>
-        <td v-if="isVisible('state')">{{ container.state }}</td>
-        <td v-if="isVisible('created')">
-          <distance-time :date="container.created" strict :suffix="false"></distance-time>
-        </td>
-        <td v-if="isVisible('cpu')">
-          <bar-chart :value="container.movingAverage.cpu / 100">
-            {{ (container.movingAverage.cpu / 100).toLocaleString(undefined, { style: "percent" }) }}
-          </bar-chart>
-        </td>
-        <td v-if="isVisible('mem')">
-          <bar-chart :value="container.movingAverage.memory / 100">
-            {{ (container.movingAverage.memory / 100).toLocaleString(undefined, { style: "percent" }) }}
-          </bar-chart>
-        </td>
-      </tr>
-    </tbody>
-  </table>
-  <nav class="pagination is-right" role="navigation" aria-label="pagination" v-if="isPaginated">
-    <ul class="pagination-list">
-      <li v-for="i in totalPages">
-        <a class="pagination-link" :class="{ 'is-current': i === currentPage }" @click.prevent="currentPage = i">{{
-          i
-        }}</a>
-      </li>
-    </ul>
-  </nav>
+  <div class="flex flex-col gap-4">
+    <div class="flex flex-row">
+      <div v-if="Object.keys(hosts).length > 1" class="flex-1">
+        <div role="tablist" class="tabs-boxed tabs block" v-if="Object.keys(hosts).length < 4">
+          <input
+            type="radio"
+            name="host"
+            role="tab"
+            class="tab rounded-sm!"
+            aria-label="Show All"
+            v-model="selectedHost"
+            :value="null"
+          />
+          <input
+            type="radio"
+            name="host"
+            role="tab"
+            class="tab rounded-sm!"
+            :aria-label="host.name"
+            v-for="host in hosts"
+            :value="host.id"
+            :key="host.id"
+            v-model="selectedHost"
+          />
+        </div>
+
+        <DropdownMenu
+          class="btn-sm"
+          v-model="selectedHost"
+          :options="[
+            { label: 'Show All', value: null },
+            ...Object.values(hosts).map((host) => ({ label: host.name, value: host.id })),
+          ]"
+          v-else
+        />
+      </div>
+      <div class="flex flex-1 items-center justify-end gap-2">
+        <div v-show="containers.length > pageSizes[0]">
+          {{ $t("label.per-page") }}
+
+          <DropdownMenu
+            class="dropdown-left btn-xs md:btn-sm"
+            v-model="perPage"
+            :options="pageSizes.map((i) => ({ label: i.toLocaleString(), value: i }))"
+          />
+        </div>
+        <div class="join max-md:hidden">
+          <button
+            class="btn join-item btn-xs md:btn-sm"
+            :class="statMode === 'chart' ? 'btn-active' : 'btn-ghost'"
+            @click="statMode = 'chart'"
+          >
+            <mdi:chart-bar />
+          </button>
+          <button
+            class="btn join-item btn-xs md:btn-sm"
+            :class="statMode === 'progress' ? 'btn-active' : 'btn-ghost'"
+            @click="statMode = 'progress'"
+          >
+            <mdi:poll class="scale-x-[-1] rotate-90" />
+          </button>
+        </div>
+      </div>
+    </div>
+    <div class="rounded-box border-base-content/10 overflow-x-auto border">
+      <table class="table-md md:table-lg table-zebra table">
+        <thead>
+          <tr :data-direction="direction > 0 ? 'asc' : 'desc'">
+            <th
+              v-for="(value, key) in fields"
+              :key="key"
+              @click.prevent="sort(key)"
+              :class="[value.customClass, { 'selected-sort': key === sortField }]"
+              v-show="isVisible(key)"
+            >
+              <a class="inline-flex cursor-pointer gap-2 text-sm uppercase">
+                <span>{{ $t(isMobile && value.mobileLabel ? value.mobileLabel : value.label) }}</span>
+                <span class="h-4" data-icon>
+                  <mdi:arrow-up />
+                </span>
+              </a>
+            </th>
+          </tr>
+        </thead>
+        <tbody class="bg-base-300/30">
+          <tr
+            v-for="container in paginated"
+            :key="container.id"
+            v-memo="[container.id, statMode, isMobile]"
+            class="hover:bg-base-100/80!"
+          >
+            <td v-if="isVisible('name')" class="max-w-80 truncate max-md:max-w-32">
+              <router-link :to="{ name: '/container/[id]', params: { id: container.id } }" :title="container.name">
+                {{ container.name }}
+              </router-link>
+            </td>
+            <td v-if="isVisible('host')">{{ container.hostLabel }}</td>
+            <td v-if="isVisible('state')">{{ container.state }}</td>
+            <td v-if="isVisible('created')">
+              <RelativeTime :date="container.created" />
+            </td>
+            <td v-if="isVisible('cpu')">
+              <ContainerStatCell :container="container" type="cpu" :host="hosts[container.host]" :mode="statMode" />
+            </td>
+            <td v-if="isVisible('mem')">
+              <ContainerStatCell :container="container" type="mem" :host="hosts[container.host]" :mode="statMode" />
+            </td>
+          </tr>
+        </tbody>
+      </table>
+    </div>
+    <div class="p-4 text-center">
+      <nav class="join" v-if="isPaginated && totalPages <= 15">
+        <input
+          class="btn btn-square join-item"
+          type="radio"
+          v-model="currentPage"
+          :aria-label="`${i}`"
+          :value="i"
+          v-for="i in totalPages"
+        />
+      </nav>
+      <DropdownMenu
+        v-else-if="isPaginated"
+        class="btn-sm"
+        v-model="currentPage"
+        :options="Array.from({ length: totalPages }, (_, i) => ({ label: `${i + 1}`, value: i + 1 }))"
+      />
+    </div>
+  </div>
 </template>
 
 <script setup lang="ts">
 import { Container } from "@/models/Container";
+import { toRefs } from "@vueuse/core";
 
-const fields = {
+const { hosts } = useHosts();
+const selectedHost = ref(null);
+
+const fields: Record<
+  string,
+  {
+    label: string;
+    mobileLabel?: string;
+    sortFunc: (a: Container, b: Container) => number;
+    mobileVisible: boolean;
+    customClass?: string;
+  }
+> = {
   name: {
     label: "label.container-name",
+    mobileLabel: "label.name",
     sortFunc: (a: Container, b: Container) => a.name.localeCompare(b.name) * direction.value,
     mobileVisible: true,
   },
+  host: {
+    label: "label.host",
+    sortFunc: (a: Container, b: Container) => a.hostLabel.localeCompare(b.hostLabel) * direction.value,
+    mobileVisible: false,
+    customClass: "w-1",
+  },
   state: {
     label: "label.status",
     sortFunc: (a: Container, b: Container) => a.state.localeCompare(b.state) * direction.value,
     mobileVisible: false,
+    customClass: "w-1",
   },
   created: {
     label: "label.created",
     sortFunc: (a: Container, b: Container) => (a.created.getTime() - b.created.getTime()) * direction.value,
-    mobileVisible: true,
+    mobileVisible: false,
+    customClass: "w-1",
   },
   cpu: {
     label: "label.avg-cpu",
+    mobileLabel: "label.cpu",
     sortFunc: (a: Container, b: Container) => (a.movingAverage.cpu - b.movingAverage.cpu) * direction.value,
-    mobileVisible: false,
+    mobileVisible: true,
+    customClass: "min-w-48 max-md:min-w-0",
   },
   mem: {
     label: "label.avg-mem",
-    sortFunc: (a: Container, b: Container) => (a.movingAverage.memory - b.movingAverage.memory) * direction.value,
-    mobileVisible: false,
+    mobileLabel: "label.mem",
+    sortFunc: (a: Container, b: Container) =>
+      (a.movingAverage.memoryUsage - b.movingAverage.memoryUsage) * direction.value,
+    mobileVisible: true,
+    customClass: "min-w-48 max-md:min-w-0",
   },
 };
 
-const { containers, perPage = 15 } = defineProps<{
+const { containers } = defineProps<{
   containers: Container[];
-  perPage?: number;
 }>();
-const sortField: Ref<keyof typeof fields> = ref("created");
-const direction = ref<1 | -1>(-1);
+type keys = keyof typeof fields;
+
+const statMode = useStorage<"chart" | "progress">("DOZZLE_TABLE_STAT_MODE", "chart");
+const perPage = useStorage("DOZZLE_TABLE_PAGE_SIZE", 15);
+const pageSizes = [15, 30, 50, 100];
+
+const storage = useStorage<{ column: keys; direction: 1 | -1 }>("DOZZLE_TABLE_CONTAINERS_SORT", {
+  column: "created" as keys,
+  direction: -1 as 1 | -1,
+});
+const { column: sortField, direction } = toRefs(storage.value);
+const counter = useInterval(10000);
+const filteredContainers = computed(() =>
+  containers.filter((c) => selectedHost.value === null || c.host === selectedHost.value),
+);
 const sortedContainers = computedWithControl(
-  () => [containers.length, sortField.value, direction.value],
-  () => {
-    return containers.sort((a, b) => {
-      return fields[sortField.value].sortFunc(a, b);
-    });
-  },
+  () => [filteredContainers.value.length, sortField.value, direction.value, counter.value],
+  () => filteredContainers.value.sort((a, b) => fields[sortField.value].sortFunc(a, b)),
 );
 
-const totalPages = computed(() => Math.ceil(sortedContainers.value.length / perPage));
+const totalPages = computed(() => Math.ceil(sortedContainers.value.length / perPage.value));
 const isPaginated = computed(() => totalPages.value > 1);
 const currentPage = ref(1);
+watch(perPage, () => (currentPage.value = 1));
 const paginated = computed(() => {
-  const start = (currentPage.value - 1) * perPage;
-  const end = start + perPage;
+  const start = (currentPage.value - 1) * perPage.value;
+  const end = start + perPage.value;
 
   return sortedContainers.value.slice(start, end);
 });
 
-function sort(field: keyof typeof fields) {
+function sort(field: keys) {
   if (sortField.value === field) {
     direction.value *= -1;
   } else {
@@ -120,31 +231,38 @@ function sort(field: keyof typeof fields) {
     direction.value = 1;
   }
 }
-function isVisible(field: keyof typeof fields) {
+function isVisible(field: keys) {
   return fields[field].mobileVisible || !isMobile.value;
 }
 </script>
 
-<style lang="scss" scoped>
-.icon {
+<style scoped>
+@reference "@/main.css";
+
+[data-icon] {
   display: none;
   transition: transform 0.2s ease-in-out;
   [data-direction="desc"] & {
     transform: rotate(180deg);
   }
 }
-.selected-sort {
-  font-weight: bold;
-  border-color: var(--primary-color);
-  .icon {
-    display: inline-block;
+
+th {
+  @apply border-base-200 border-b-2;
+  &.selected-sort {
+    font-weight: bold;
+    @apply border-primary;
+    [data-icon] {
+      display: inline-block;
+    }
   }
 }
 
 tbody td {
-  max-width: 0;
-  overflow: hidden;
-  text-overflow: ellipsis;
   white-space: nowrap;
 }
+
+a {
+  @apply hover:text-primary;
+}
 </style>

assets/components/ContainerViewer/ContainerActionsToolbar.vue

@@ -0,0 +1,390 @@
+<template>
+  <div class="dropdown dropdown-end dropdown-hover z-20">
+    <label tabindex="0" class="btn btn-ghost btn-sm w-8 gap-0 px-0 md:gap-0.5">
+      <carbon:circle-solid class="text-red w-2 md:w-2.5" v-if="streamConfig.stderr" />
+      <carbon:circle-solid class="text-blue w-2 md:w-2.5" v-if="streamConfig.stdout" />
+    </label>
+    <ul
+      tabindex="0"
+      class="menu dropdown-content rounded-box bg-base-200 border-base-content/20 z-50 w-52 border p-1 shadow-sm"
+      @click="hideMenu"
+    >
+      <li v-if="!historical">
+        <a @click="showSearch = true">
+          <mdi:magnify /> {{ $t("toolbar.search") }}
+          <KeyShortcut char="f" />
+        </a>
+      </li>
+      <li v-if="!historical">
+        <a @click="clear()">
+          <octicon:trash-24 /> {{ $t("toolbar.clear") }}
+          <KeyShortcut char="l" :modifiers="['shift', 'meta']" />
+        </a>
+      </li>
+      <li v-if="hasComplexLogs">
+        <a @click="showDrawer(LogAnalytics, { container }, 'lg')">
+          <ph:file-sql /> SQL Analytics
+          <KeyShortcut char="f" :modifiers="['shift', 'meta']" />
+        </a>
+      </li>
+      <li class="line"></li>
+      <li>
+        <details>
+          <summary>
+            <div class="flex w-4">
+              <carbon:circle-solid class="text-red w-2.5" v-if="streamConfig.stderr" />
+              <carbon:circle-solid class="text-blue w-2.5" v-if="streamConfig.stdout" />
+            </div>
+            Streams
+          </summary>
+          <ul class="menu">
+            <li>
+              <a
+                @click="
+                  streamConfig.stdout = true;
+                  streamConfig.stderr = true;
+                "
+              >
+                <mdi:check class="w-4" v-if="streamConfig.stdout == true && streamConfig.stderr == true" />
+                <div v-else class="w-4"></div>
+                {{ $t("toolbar.show-all") }}
+              </a>
+            </li>
+            <li>
+              <a
+                @click="
+                  streamConfig.stdout = true;
+                  streamConfig.stderr = false;
+                "
+              >
+                <mdi:check class="w-4" v-if="streamConfig.stdout == true && streamConfig.stderr == false" />
+                <div v-else class="w-4"></div>
+                {{ $t("toolbar.show", { std: "STDOUT" }) }}
+              </a>
+            </li>
+            <li>
+              <a
+                @click="
+                  streamConfig.stdout = false;
+                  streamConfig.stderr = true;
+                "
+              >
+                <mdi:check class="w-4" v-if="streamConfig.stdout == false && streamConfig.stderr == true" />
+                <div v-else class="w-4"></div>
+                {{ $t("toolbar.show", { std: "STDERR" }) }}
+              </a>
+            </li>
+          </ul>
+        </details>
+      </li>
+      <li>
+        <details class="group/details">
+          <summary>
+            <mdi:gauge />
+            Levels
+            <Toggle
+              class="toggle-xs invisible group-open/details:visible"
+              v-model="toggleAllLevels"
+              title="Toggle all levels"
+            />
+          </summary>
+          <ul class="menu">
+            <li v-for="level in allLevels">
+              <a class="capitalize" @click="levels.has(level) ? levels.delete(level) : levels.add(level)">
+                <mdi:check class="w-4" v-if="levels.has(level)" />
+                <div v-else class="w-4"></div>
+
+                <div class="flex">
+                  <div class="badge" :data-level="level">{{ level }}</div>
+                </div>
+              </a>
+            </li>
+          </ul>
+        </details>
+      </li>
+
+      <li class="line"></li>
+      <li v-if="enableDownload">
+        <a :href="downloadUrl" download>
+          <octicon:download-24 />
+          {{ isFiltered ? $t("toolbar.download-filtered") : $t("toolbar.download") }}
+        </a>
+      </li>
+      <li v-if="isSupported">
+        <a @click="copyLogs()">
+          <mdi:content-copy />
+          {{ isFiltered ? $t("toolbar.copy-filtered-logs") : $t("toolbar.copy-logs") }}
+        </a>
+      </li>
+      <li>
+        <a @click="copyPermalink()">
+          <material-symbols:link />
+          {{ $t("toolbar.copy-permalink") }}
+        </a>
+      </li>
+
+      <!-- Container Actions (Enabled via config) -->
+      <template v-if="enableActions && !historical">
+        <li class="line"></li>
+        <li>
+          <button
+            @click="stop()"
+            :disabled="actionStates.stop || actionStates.restart"
+            v-if="container.state == 'running'"
+          >
+            <carbon:stop-filled-alt /> {{ $t("toolbar.stop") }}
+          </button>
+
+          <button
+            @click="start()"
+            :disabled="actionStates.start || actionStates.restart"
+            v-if="container.state != 'running'"
+          >
+            <carbon:play /> {{ $t("toolbar.start") }}
+          </button>
+        </li>
+        <li>
+          <button @click="restart()" :disabled="disableRestart">
+            <carbon:restart
+              :class="{
+                'animate-spin': actionStates.restart,
+                'text-secondary': actionStates.restart,
+              }"
+            />
+            {{ $t("toolbar.restart") }}
+          </button>
+        </li>
+        <li>
+          <button @click="update()" :disabled="actionStates.update">
+            <carbon:upgrade />
+            {{ container.isSwarm ? $t("toolbar.update-service") : $t("toolbar.update") }}
+          </button>
+        </li>
+      </template>
+
+      <template v-if="enableShell && !historical">
+        <li class="line"></li>
+        <li>
+          <a @click="showDrawer(Terminal, { container, action: 'attach' }, 'lg')">
+            <ri:terminal-window-fill />
+            {{ $t("toolbar.attach") }}
+            <KeyShortcut char="a" :modifiers="['shift', 'meta']" />
+          </a>
+        </li>
+        <li>
+          <a @click="showDrawer(Terminal, { container, action: 'exec' }, 'lg')">
+            <material-symbols:terminal />
+            {{ $t("toolbar.shell") }}
+            <KeyShortcut char="e" :modifiers="['shift', 'meta']" />
+          </a>
+        </li>
+      </template>
+    </ul>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { Container } from "@/models/Container";
+import { allLevels } from "@/composable/logContext";
+import LogAnalytics from "../LogViewer/LogAnalytics.vue";
+import Terminal from "@/components/Terminal.vue";
+
+const { showSearch } = useSearchFilter();
+const { enableActions, enableShell, enableDownload } = config;
+const { streamConfig, hasComplexLogs, levels } = useLoggingContext();
+const showDrawer = useDrawer();
+
+const { container, historical = false } = defineProps<{ container: Container; historical?: boolean }>();
+const clear = defineEmit();
+const { actionStates, start, stop, restart, update } = useContainerActions(toRef(() => container));
+
+const router = useRouter();
+const { copy, copied, isSupported } = useClipboard({ legacy: true });
+const { t } = useI18n();
+const { showToast, removeToast } = useToast();
+
+async function copyPermalink() {
+  const url = router.resolve({
+    name: "/show",
+    query: { name: container.name, host: container.host },
+  }).href;
+
+  const resolved = new URL(url, window.location.origin);
+
+  if (!isSupported.value) {
+    showToast(
+      {
+        title: t("error.copy-not-supported-hint"),
+        message: resolved.href,
+        type: "info",
+      },
+      { expire: 10000 },
+    );
+    return;
+  }
+
+  await copy(resolved.href);
+
+  if (copied.value) {
+    showToast(
+      {
+        title: t("toasts.copied.title"),
+        message: t("toasts.copied.message"),
+        type: "info",
+      },
+      { expire: 2000 },
+    );
+  }
+}
+
+async function copyLogs() {
+  const params = new URLSearchParams();
+  if (streamConfig.value.stdout) params.append("stdout", "1");
+  if (streamConfig.value.stderr) params.append("stderr", "1");
+  params.append("everything", "1");
+
+  const { debouncedSearchFilter } = useSearchFilter();
+  if (debouncedSearchFilter.value) {
+    params.append("filter", debouncedSearchFilter.value);
+  }
+
+  const selectedLevels = Array.from(levels.value);
+  if (selectedLevels.length > 0 && selectedLevels.length < allLevels.length) {
+    selectedLevels.forEach((level) => params.append("levels", level));
+  }
+
+  const url = withBase(`/api/hosts/${container.host}/containers/${container.id}/logs?${params.toString()}`);
+
+  const toastId = "copy-logs";
+  showToast(
+    {
+      id: toastId,
+      title: t("toolbar.copying-logs"),
+      message: "",
+      type: "info",
+    },
+    { once: true },
+  );
+
+  const blobPromise = fetch(url, { headers: { Accept: "text/plain" } })
+    .then((response) => {
+      if (!response.ok) throw new Error(response.statusText);
+      return response.blob();
+    })
+    .then((blob) => {
+      removeToast(toastId);
+      showToast(
+        {
+          title: t("toasts.copied.title"),
+          message: t("toasts.copied.message"),
+          type: "info",
+        },
+        { expire: 2000 },
+      );
+      return blob;
+    })
+    .catch((err) => {
+      removeToast(toastId);
+      showToast(
+        {
+          title: "Error",
+          message: err.message,
+          type: "error",
+        },
+        { expire: 5000 },
+      );
+      throw err;
+    });
+
+  await navigator.clipboard.write([new ClipboardItem({ "text/plain": blobPromise })]);
+}
+
+onKeyStroke(["f", "F"], (e) => {
+  if (hasComplexLogs.value) {
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey) {
+      showDrawer(LogAnalytics, { container }, "lg");
+      e.preventDefault();
+    }
+  }
+});
+if (enableShell) {
+  onKeyStroke(["a", "A"], (e) => {
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey) {
+      showDrawer(Terminal, { container, action: "attach" }, "lg");
+      e.preventDefault();
+    }
+  });
+
+  onKeyStroke(["e", "E"], (e) => {
+    if ((e.ctrlKey || e.metaKey) && e.shiftKey) {
+      showDrawer(Terminal, { container, action: "exec" }, "lg");
+      e.preventDefault();
+    }
+  });
+}
+
+const containerRef = computed(() => [container]);
+const { downloadUrl, isFiltered } = useDownloadUrl(
+  containerRef,
+  streamConfig,
+  levels,
+  toRef(() => container.name),
+);
+
+const disableRestart = computed(() => actionStates.stop || actionStates.start || actionStates.restart);
+
+const toggleAllLevels = computed({
+  get: () => levels.value.size === allLevels.length,
+  set: (value) => {
+    if (value) {
+      allLevels.forEach((level) => levels.value.add(level));
+    } else {
+      levels.value.clear();
+    }
+  },
+});
+
+const hideMenu = (e: MouseEvent) => {
+  if (e.target instanceof HTMLAnchorElement) {
+    setTimeout(() => {
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+    }, 50);
+  }
+};
+</script>
+
+<style scoped>
+@reference "@/main.css";
+
+li.line {
+  @apply bg-base-content/20 h-px;
+}
+
+a {
+  @apply whitespace-nowrap;
+}
+
+/* daisyUI's .menu is width: fit-content, so nested submenus (Streams, Levels)
+ * shrink to their content and the hover highlight stops short. Stretch them to
+ * fill the dropdown so the row highlight spans the full width. */
+.menu li ul {
+  margin-inline-start: 0;
+  width: 100%;
+  &:before {
+    display: none;
+  }
+}
+
+/* Keep the solid level colors, but use white labels in the light theme so the
+ * text reads against the saturated chip backgrounds. warn is a light orange,
+ * where dark text has better contrast than white, so it keeps the default. */
+[data-theme="light"] .badge[data-level="info"],
+[data-theme="light"] .badge[data-level="debug"],
+[data-theme="light"] .badge[data-level="trace"],
+[data-theme="light"] .badge[data-level="error"],
+[data-theme="light"] .badge[data-level="fatal"] {
+  color: oklch(100% 0 0) !important;
+}
+</style>

assets/components/ContainerViewer/ContainerHealth.vue

@@ -1,5 +1,5 @@
 <template>
-  <div class="icon is-small health" :health="health" v-if="health" :title="health">
+  <div class="inline-flex size-4" :health="health" v-if="health" :title="health">
     <cil:check-circle v-if="health == 'healthy'" />
     <cil:x-circle v-else-if="health == 'unhealthy'" />
     <cil:circle v-else />
@@ -14,14 +14,13 @@ defineProps<{
 }>();
 </script>
 
-<style lang="scss" scoped>
-.health {
-  &[health="unhealthy"] {
-    color: var(--red-color);
-  }
+<style scoped>
+@reference "@/main.css";
+[health="unhealthy"] {
+  @apply text-red;
+}
 
-  &[health="healthy"] {
-    color: var(--green-color);
-  }
+[health="healthy"] {
+  @apply text-green;
 }
 </style>

assets/components/ContainerViewer/ContainerLog.vue

@@ -0,0 +1,56 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="container">
+    <template #header v-if="showTitle">
+      <div class="@container mx-2 flex items-center gap-1 md:ml-4 md:gap-2">
+        <ContainerTitle :container="container" />
+        <MultiContainerStat
+          class="ml-auto lg:hidden lg:@3xl:flex"
+          :containers="[container]"
+          v-if="container.state === 'running'"
+        />
+
+        <ContainerActionsToolbar @clear="viewer?.clear()" :container="container" />
+        <a class="btn btn-circle btn-xs" @click="close()" v-if="closable">
+          <mdi:close />
+        </a>
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useContainerStream"
+        :entity="container"
+        :visible-keys="visibleKeys"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const {
+  id,
+  showTitle = false,
+  scrollable = false,
+  closable = false,
+} = defineProps<{
+  id: string;
+  showTitle?: boolean;
+  scrollable?: boolean;
+  closable?: boolean;
+}>();
+
+const close = defineEmit();
+
+const store = useContainerStore();
+const container = store.currentContainer(toRef(() => id));
+const visibleKeys = persistentVisibleKeysForContainer(container);
+const viewer = useTemplateRef<ComponentExposed<typeof ViewerWithSource>>("viewer");
+
+provideLoggingContext(
+  toRef(() => [container.value]),
+  { showContainerName: false, showHostname: false },
+);
+</script>

assets/components/ContainerViewer/ContainerTitle.vue

@@ -0,0 +1,106 @@
+<template>
+  <div class="@container flex min-w-0 flex-1 items-center gap-1.5 md:gap-2">
+    <label class="swap swap-rotate size-4">
+      <input type="checkbox" v-model="pinned" />
+      <carbon:star-filled class="swap-on text-secondary" />
+      <carbon:star class="swap-off" />
+    </label>
+    <div class="inline-flex min-w-0 items-center text-sm">
+      <div class="breadcrumbs min-w-0 overflow-x-visible p-0 font-mono">
+        <ul>
+          <li v-if="config.hosts.length > 1" class="font-thin max-md:hidden">
+            {{ container.hostLabel }}
+          </li>
+          <li class="min-w-0">
+            <template v-if="otherContainers.length === 0"
+              ><span class="block truncate">{{ container.name }}</span></template
+            >
+            <div v-else>
+              <div class="dropdown">
+                <button tabindex="0" role="button" class="btn btn-xs md:btn-sm">
+                  {{ container.name }} <carbon:caret-down />
+                </button>
+                <ul
+                  tabindex="0"
+                  class="dropdown-content menu rounded-box bg-base-100 border-base-content/20 border shadow-sm"
+                >
+                  <li v-for="other in otherContainers">
+                    <router-link :to="{ name: '/container/[id]', params: { id: other.id } }">
+                      <div
+                        class="status data-[state=exited]:status-error data-[state=running]:status-success data-[state=paused]:status-warning"
+                        :data-state="other.state"
+                      ></div>
+                      <div v-if="other.isSwarm">{{ other.swarmId }}</div>
+                      <div v-else>{{ other.name }}</div>
+                      <div v-if="other.state === 'running'">running</div>
+                      <div v-else-if="other.state === 'paused'">paused</div>
+                      <RelativeTime :date="other.finishedAt" class="text-base-content/70 text-xs" v-else />
+                    </router-link>
+                  </li>
+                </ul>
+              </div>
+            </div>
+          </li>
+        </ul>
+      </div>
+    </div>
+    <ContainerHealth :health="container.health" v-if="container.health" />
+    <VolumeWarning :container="container" />
+    <Tag
+      class="group hidden! cursor-pointer items-center gap-1.5 pr-1! font-mono @md:inline-flex!"
+      size="small"
+      role="button"
+      :title="$t('toolbar.copy-image')"
+      :aria-label="$t('toolbar.copy-image')"
+      @click="copyImage"
+    >
+      <span class="truncate">{{ imageTag }}</span>
+      <span
+        class="bg-base-content/10 text-base-content/40 group-hover:text-base-content/70 flex size-4 shrink-0 items-center justify-center rounded-sm transition-colors"
+      >
+        <mdi:content-copy class="size-3" />
+      </span>
+    </Tag>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { Container } from "@/models/Container";
+
+const { container } = defineProps<{ container: Container }>();
+
+const { t } = useI18n();
+const { copy, copied, isSupported } = useClipboard({ legacy: true });
+const { showToast } = useToast();
+
+const imageTag = computed(() => container.image.replace(/@sha.*/, ""));
+
+async function copyImage() {
+  if (!isSupported.value) return;
+  await copy(imageTag.value);
+  if (copied.value) {
+    showToast({ title: t("toasts.copied.title"), message: t("toasts.copied.message"), type: "info" }, { expire: 2000 });
+  }
+}
+
+const pinned = computed({
+  get: () => pinnedContainers.value.has(container.name),
+  set: (value) => {
+    if (value) {
+      pinnedContainers.value.add(container.name);
+    } else {
+      pinnedContainers.value.delete(container.name);
+    }
+  },
+});
+const store = useContainerStore();
+const { containers: allContainers } = storeToRefs(store);
+
+const otherContainers = computed(() =>
+  allContainers.value
+    .filter((c) => c.name === container.name && c.id !== container.id)
+    .sort((a, b) => +b.created - +a.created),
+);
+</script>
+
+<style scoped></style>

assets/components/ContainerViewer/HistoricalContainerLog.vue

@@ -0,0 +1,63 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="container">
+    <template #header v-if="showTitle">
+      <div class="@container mx-2 flex items-center gap-2 md:ml-4">
+        <ContainerTitle :container="container" />
+        <router-link
+          :to="{ name: '/container/[id]', params: { id: container.id } }"
+          class="btn btn-secondary btn-sm"
+          v-if="container.state === 'running'"
+        >
+          <mdi:lightning-bolt />
+          Live Logs
+        </router-link>
+
+        <ContainerActionsToolbar class="max-md:hidden" :container="container" historical />
+        <a class="btn btn-circle btn-xs" @click="close()" v-if="closable">
+          <mdi:close />
+        </a>
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useHistoricalContainerLog"
+        :entity="historicalContainer"
+        :visible-keys="visibleKeys"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { HistoricalContainer } from "@/models/Container";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const {
+  id,
+  showTitle = false,
+  scrollable = false,
+  closable = false,
+  date,
+} = defineProps<{
+  id: string;
+  showTitle?: boolean;
+  scrollable?: boolean;
+  closable?: boolean;
+  date: Date;
+}>();
+
+const close = defineEmit();
+
+const store = useContainerStore();
+const container = store.currentContainer(toRef(() => id));
+const historicalContainer = toRef(() => new HistoricalContainer(container.value, date));
+const visibleKeys = persistentVisibleKeysForContainer(container);
+useTemplateRef<ComponentExposed<typeof ViewerWithSource>>("viewer");
+
+provideLoggingContext(
+  toRef(() => [container.value]),
+  { showContainerName: false, showHostname: false, historical: true },
+);
+</script>

assets/components/ContainerViewer/VolumeWarning.vue

@@ -0,0 +1,113 @@
+<template>
+  <div v-if="worst" class="dropdown dropdown-end" :class="{ 'dropdown-bottom': !openUp }">
+    <button
+      tabindex="0"
+      role="button"
+      class="inline-flex items-center gap-1 rounded-md px-2 py-0.5 text-xs font-medium tabular-nums"
+      :class="badgeClass"
+      :title="title"
+    >
+      <PhWarning class="size-3.5" />
+      <span class="max-md:hidden">{{ worst.destination }}</span>
+      <span>{{ formatPct(worst.pct) }}</span>
+    </button>
+    <div
+      tabindex="0"
+      class="dropdown-content rounded-box bg-base-200 border-base-content/20 z-50 mt-1 w-72 border p-2 text-xs shadow-sm"
+    >
+      <div class="text-base-content/60 mb-1.5 px-1 text-[11px] tracking-wide uppercase">{{ t("tooltip.volumes") }}</div>
+      <ul class="space-y-1.5">
+        <li
+          v-for="m in sortedMounts"
+          :key="m.destination"
+          class="flex flex-col gap-1 rounded p-1.5"
+          :class="rowClass(m.pct, m.available)"
+        >
+          <div class="flex items-baseline justify-between gap-2">
+            <span class="truncate font-mono text-[11.5px]" :title="m.destination">{{ m.destination }}</span>
+            <span v-if="m.available" class="tabular-nums">{{ formatPct(m.pct) }}</span>
+            <span v-else class="text-base-content/50">n/a</span>
+          </div>
+          <div v-if="m.available" class="bg-base-content/10 h-1 w-full overflow-hidden rounded">
+            <div class="h-full" :class="barClass(m.pct)" :style="{ width: Math.min(100, m.pct * 100) + '%' }"></div>
+          </div>
+          <div class="text-base-content/60 flex justify-between tabular-nums">
+            <span v-if="m.available">{{ formatBytes(m.used) }} / {{ formatBytes(m.total) }}</span>
+            <span v-else>{{ t("tooltip.volume-unreachable") }}</span>
+            <RelativeTime v-if="m.lastChecked" :date="m.lastChecked" class="text-[10.5px]" />
+          </div>
+        </li>
+      </ul>
+    </div>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import { Container } from "@/models/Container";
+import PhWarning from "~icons/ph/warning-fill";
+
+const WARN = 0.85;
+const CRITICAL = 0.95;
+
+const { container } = defineProps<{ container: Container; openUp?: boolean }>();
+
+const { t } = useI18n();
+
+interface DerivedMount {
+  destination: string;
+  total: number;
+  used: number;
+  free: number;
+  available: boolean;
+  pct: number;
+  lastChecked?: Date;
+}
+
+const mounts = computed<DerivedMount[]>(() => {
+  const raw = container.mountStats ?? {};
+  return Object.values(raw).map((m) => ({
+    destination: m.destination,
+    total: m.total,
+    used: m.used,
+    free: m.free,
+    available: m.available && m.total > 0,
+    pct: m.available && m.total > 0 ? m.used / m.total : 0,
+    lastChecked: m.lastChecked ? new Date(m.lastChecked) : undefined,
+  }));
+});
+
+const sortedMounts = computed(() => [...mounts.value].sort((a, b) => b.pct - a.pct));
+
+const worst = computed(() => {
+  const candidate = sortedMounts.value.find((m) => m.available && m.pct >= WARN);
+  return candidate ?? null;
+});
+
+const badgeClass = computed(() => {
+  if (!worst.value) return "";
+  if (worst.value.pct >= CRITICAL) return "bg-error/15 text-error hover:bg-error/25";
+  return "bg-warning/15 text-warning hover:bg-warning/25";
+});
+
+function rowClass(pct: number, available: boolean) {
+  if (!available) return "bg-base-content/[0.04]";
+  if (pct >= CRITICAL) return "bg-error/10";
+  if (pct >= WARN) return "bg-warning/10";
+  return "bg-base-content/[0.04]";
+}
+
+function barClass(pct: number) {
+  if (pct >= CRITICAL) return "bg-error";
+  if (pct >= WARN) return "bg-warning";
+  return "bg-success";
+}
+
+function formatPct(pct: number) {
+  return `${Math.round(pct * 100)}%`;
+}
+
+const title = computed(() => {
+  if (!worst.value) return "";
+  return t("tooltip.volume-full", { destination: worst.value.destination, pct: formatPct(worst.value.pct) });
+});
+</script>

assets/components/DropdownMenu.vue

@@ -1,48 +0,0 @@
-<template>
-  <div class="dropdown is-hoverable">
-    <div class="dropdown-trigger">
-      <slot name="trigger">
-        <button class="button" aria-haspopup="true" aria-controls="dropdown-menu">
-          <span class="icon">
-            <mdi:dots-vertical />
-          </span>
-        </button>
-      </slot>
-    </div>
-    <div class="dropdown-menu" id="dropdown-menu" role="menu">
-      <div class="dropdown-content">
-        <slot></slot>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script lang="ts" setup></script>
-
-<style lang="scss" scoped>
-.minimal .button {
-  background-color: rgba(0, 0, 0, 0);
-  border: none;
-  padding: 0.1em;
-  height: 100%;
-
-  & > .icon {
-    height: 100%;
-
-    & > svg {
-      align-self: flex-start;
-      height: 0.85em;
-    }
-  }
-}
-
-.is-top {
-  & .dropdown-menu {
-    top: 0;
-  }
-
-  &.is-last .dropdown-menu {
-    top: -30px;
-  }
-}
-</style>

assets/components/FuzzySearchModal.spec.ts

@@ -0,0 +1,147 @@
+import { createTestingPinia } from "@pinia/testing";
+import { mount } from "@vue/test-utils";
+
+import FuzzySearchModal from "./FuzzySearchModal.vue";
+
+import { Container } from "@/models/Container";
+import { lightTheme } from "@/stores/settings";
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { createI18n } from "vue-i18n";
+import { useRouter } from "vue-router";
+import { router } from "@/modules/router";
+
+// @ts-ignore
+import EventSource, { sources } from "eventsourcemock";
+
+vi.mock("vue-router");
+
+vi.mock("@/stores/config", () => ({
+  __esModule: true,
+  default: { base: "", hosts: [{ name: "localhost", id: "localhost" }], enableActions: true },
+  withBase: (path: string) => path,
+}));
+
+function createFuzzySearchModal() {
+  global.EventSource = EventSource;
+  const wrapper = mount(FuzzySearchModal, {
+    global: {
+      plugins: [
+        createI18n({}),
+        createTestingPinia({
+          createSpy: vi.fn,
+          initialState: {
+            container: {
+              containers: [
+                new Container(
+                  "123",
+                  new Date(),
+                  new Date(),
+                  new Date(),
+                  "image",
+                  "test",
+                  "command",
+                  "host",
+                  {},
+                  "running",
+                  0,
+                  0,
+                  [],
+                ),
+                new Container(
+                  "345",
+                  new Date(),
+                  new Date(),
+                  new Date(),
+                  "image",
+                  "foo bar",
+                  "command",
+                  "host",
+                  {},
+                  "running",
+                  0,
+                  0,
+                  [],
+                ),
+                new Container(
+                  "567",
+                  new Date(),
+                  new Date(),
+                  new Date(),
+                  "image",
+                  "baz",
+                  "command",
+                  "host",
+                  {},
+                  "running",
+                  0,
+                  0,
+                  [],
+                ),
+              ],
+            },
+          },
+        }),
+      ],
+    },
+  });
+  return wrapper;
+}
+
+/**
+ * @vitest-environment jsdom
+ */
+describe("<FuzzySearchModal />", () => {
+  vi.mocked(useRouter).mockReturnValue({
+    ...router,
+    push: vi.fn(),
+  });
+
+  beforeEach(() => {
+    vi.mocked(useRouter().push).mockReset();
+  });
+
+  test("shows none initially", async () => {
+    const wrapper = createFuzzySearchModal();
+    expect(wrapper.findAll("li").length).toBe(0);
+  });
+
+  test("search for foo", async () => {
+    const wrapper = createFuzzySearchModal();
+    await wrapper.find("input").setValue("foo");
+    expect(wrapper.findAll("li").length).toBe(1);
+    expect(wrapper.find("ul [data-name]").html()).toMatchInlineSnapshot(
+      `"<span data-v-dc2e8c61="" class="text-base-content" data-name=""><mark>foo</mark> bar</span>"`,
+    );
+  });
+
+  test("choose baz", async () => {
+    const wrapper = createFuzzySearchModal();
+    await wrapper.find("input").setValue("baz");
+    await wrapper.find("input").trigger("keydown.enter");
+    expect(useRouter().push).toHaveBeenCalledWith({ name: "/container/[id]", params: { id: "567" } });
+  });
+
+  test("matches commands by keyword", async () => {
+    const wrapper = createFuzzySearchModal();
+    await wrapper.find("input").setValue("theme");
+    const items = wrapper.findAll("li").map((li) => li.text());
+    expect(items).toContain("command-palette.theme-dark");
+  });
+
+  test("theme commands set the theme explicitly", async () => {
+    lightTheme.value = "auto";
+    const wrapper = createFuzzySearchModal();
+
+    await wrapper.find("input").setValue("dark theme");
+    await wrapper.find("input").trigger("keydown.enter");
+    expect(lightTheme.value).toBe("dark");
+
+    await wrapper.find("input").setValue("light theme");
+    await wrapper.find("input").trigger("keydown.enter");
+    expect(lightTheme.value).toBe("light");
+
+    await wrapper.find("input").setValue("system theme");
+    await wrapper.find("input").trigger("keydown.enter");
+    expect(lightTheme.value).toBe("auto");
+  });
+});

assets/components/FuzzySearchModal.vue

@@ -1,143 +1,437 @@
 <template>
-  <div class="panel">
-    <o-autocomplete
-      ref="autocomplete"
-      v-model="query"
-      :placeholder="$t('placeholder.search-containers')"
-      open-on-focus
-      keep-first
-      expanded
-      :data="data"
-      @select="selected"
-    >
-      <template #default="{ option: item }">
-        <div class="media">
-          <div class="media-left">
-            <span class="icon is-small" :class="item.state">
-              <octicon:container-24 />
-            </span>
+  <!-- Single bordered card containing the input, results, and footer in one
+       frame to match the design mock. No daisyUI input/dropdown chrome. -->
+  <div class="bg-base-200 border-base-content/15 w-full overflow-hidden rounded-xl border shadow-2xl">
+    <!-- Input row -->
+    <div class="flex items-center gap-3 px-4 py-3.5">
+      <mdi:magnify class="text-base-content/60 size-5 shrink-0" />
+      <input
+        tabindex="0"
+        class="text-base-content placeholder:text-base-content/40 flex-1 bg-transparent text-base outline-none"
+        ref="input"
+        @keydown.down="selectedIndex = Math.min(selectedIndex + 1, totalCount - 1)"
+        @keydown.up="selectedIndex = Math.max(selectedIndex - 1, 0)"
+        @keydown.enter.exact="onEnter"
+        @keydown.shift.enter.exact.prevent="runLogSearch"
+        @keydown.alt.enter.exact.prevent="onPin"
+        v-model="query"
+        :placeholder="placeholderCopy"
+      />
+      <form method="dialog" class="flex">
+        <button v-if="isMobile" class="text-base-content/50 hover:text-base-content">
+          <mdi:close class="size-5" />
+        </button>
+        <button v-else>
+          <kbd class="kbd kbd-xs">esc</kbd>
+        </button>
+      </form>
+    </div>
+
+    <!-- Body: results + log search CTA. Only renders when there is something
+         to show — keeps the empty modal compact. -->
+    <div v-if="totalCount || logSearchVisible" class="border-base-content/10 border-t">
+      <!-- Scroll container spans both sections so the flat Commands + Containers
+           list scrolls as one, matching the unified selection index. -->
+      <div class="max-h-[50vh] overflow-y-auto overscroll-contain">
+        <!-- Commands section -->
+        <template v-if="commandEntries.length">
+          <div class="text-base-content/40 px-4 pt-3 pb-1.5 text-xs font-semibold tracking-wider uppercase">
+            {{ $t("command-palette.section-commands") }} · {{ commandEntries.length }}
           </div>
-          <div class="media-content">{{ item.host }} / {{ item.name }}</div>
-          <div class="media-right">
-            <span
-              class="icon is-small column-icon"
-              @click.stop.prevent="addColumn(item)"
-              :title="$t('tooltip.pin-column')"
+          <ul class="pb-1">
+            <li v-for="(command, index) in commandEntries" :ref="(el) => setItemRef(el, index)">
+              <a
+                class="hover:bg-base-content/5 flex cursor-pointer items-center gap-3 px-4 py-2"
+                :class="{ 'bg-base-content/10': index === selectedIndex }"
+                @click.prevent="runCommand(command)"
+              >
+                <component :is="command.icon" class="text-base-content/60 size-4 shrink-0" />
+                <span class="min-w-0 flex-1 truncate text-sm">{{ command.title }}</span>
+                <ic:sharp-keyboard-return v-if="index === selectedIndex" class="text-base-content/40 size-4" />
+              </a>
+            </li>
+          </ul>
+        </template>
+
+        <!-- Containers section -->
+        <template v-if="containerEntries.length">
+          <div
+            class="text-base-content/40 px-4 pt-3 pb-1.5 text-xs font-semibold tracking-wider uppercase"
+            :class="{ 'border-base-content/10 mt-1 border-t': commandEntries.length }"
+          >
+            {{ $t("cloud-search.containers-section") }} · {{ containerEntries.length }}
+          </div>
+          <ul class="pb-1">
+            <li
+              v-for="(result, index) in containerEntries"
+              :ref="(el) => setItemRef(el, commandEntries.length + index)"
             >
-              <cil:columns />
+              <a
+                class="hover:bg-base-content/5 flex cursor-pointer items-center gap-3 px-4 py-2"
+                :class="{ 'bg-base-content/10': commandEntries.length + index === selectedIndex }"
+                @click.prevent="selected(result.item)"
+              >
+                <div :class="result.item.state === 'running' ? 'text-primary' : 'text-base-content/50'">
+                  <template v-if="result.item.type === 'container'">
+                    <octicon:container-24 class="size-4" />
+                  </template>
+                  <template v-else-if="result.item.type === 'service'">
+                    <ph:stack-simple class="size-4" />
+                  </template>
+                  <template v-else-if="result.item.type === 'stack'">
+                    <ph:stack class="size-4" />
+                  </template>
+                </div>
+                <div class="min-w-0 flex-1 truncate text-sm">
+                  <template v-if="config.hosts.length > 1 && result.item.host">
+                    <span class="text-base-content/50 font-light">{{ result.item.host }}</span>
+                    <span class="text-base-content/30"> / </span>
+                  </template>
+                  <span class="text-base-content" data-name v-html="matchedName(result)"></span>
+                </div>
+                <RelativeTime :date="result.item.created" class="text-base-content/40 text-xs" />
+                <span
+                  @click.stop.prevent="addColumn(result.item)"
+                  :title="$t('tooltip.pin-column')"
+                  class="text-base-content/40 hover:text-secondary"
+                >
+                  <ic:sharp-keyboard-return v-if="commandEntries.length + index === selectedIndex" class="size-4" />
+                  <cil:columns v-else-if="result.item.type === 'container'" class="size-4" />
+                </span>
+              </a>
+            </li>
+          </ul>
+        </template>
+      </div>
+      <!-- Log search CTA -->
+      <div
+        v-if="logSearchVisible"
+        class="border-base-content/10 border-t"
+        :class="{ 'cursor-pointer': cloudSearch.available.value, 'opacity-70': !cloudSearch.available.value }"
+        @click="cloudSearch.available.value && runLogSearch()"
+      >
+        <div
+          class="flex items-center gap-3 px-4 py-3"
+          :class="cloudSearch.available.value ? 'bg-primary/[0.07] hover:bg-primary/10' : ''"
+        >
+          <mdi:cloud-search-outline
+            class="size-5 shrink-0"
+            :class="cloudSearch.available.value ? 'text-primary' : 'text-base-content/40'"
+          />
+          <div class="flex min-w-0 flex-1 flex-col">
+            <span
+              class="truncate text-sm font-semibold"
+              :class="cloudSearch.available.value ? 'text-primary' : 'text-base-content/60'"
+            >
+              <i18n-t keypath="cloud-search.search-logs-for">
+                <template #query>
+                  <span class="font-mono">{{ query }}</span>
+                </template>
+              </i18n-t>
+            </span>
+            <span class="text-base-content/50 mt-0.5 flex items-center gap-1 text-xs">
+              <template v-if="cloudSearch.available.value">
+                <mdi:flash class="text-primary size-3" />
+                {{ $t("cloud-search.across-containers") }}
+              </template>
+              <template v-else-if="cloudConfig?.linked && !cloudConfig.streamLogs">
+                <mdi:cloud-off-outline class="size-3" />
+                <RouterLink to="/settings/cloud" class="link link-hover" @click.stop>
+                  {{ $t("cloud-search.enable-streaming-to-search") }}
+                </RouterLink>
+              </template>
+              <template v-else>
+                <mdi:cloud-off-outline class="size-3" />
+                <RouterLink to="/settings/cloud" class="link link-hover" @click.stop>
+                  {{ $t("cloud-search.connect-to-enable") }}
+                </RouterLink>
+              </template>
             </span>
           </div>
+          <kbd class="kbd kbd-xs">⇧</kbd>
+          <kbd class="kbd kbd-xs">↵</kbd>
         </div>
-      </template>
-    </o-autocomplete>
+      </div>
+    </div>
+
+    <!-- Footer: kbd hints + cloud status. Always present while the modal is
+         open so users know log search is available before they type. -->
+    <div
+      class="bg-base-300/40 border-base-content/10 text-base-content/50 flex items-center gap-4 border-t px-4 py-2 text-xs"
+    >
+      <span v-if="totalCount" class="flex items-center gap-1.5">
+        <kbd class="kbd kbd-xs">↵</kbd> {{ $t("cloud-search.open-container") }}
+      </span>
+      <span v-if="cloudSearch.available.value && logSearchVisible" class="flex items-center gap-1">
+        <kbd class="kbd kbd-xs">⇧</kbd><kbd class="kbd kbd-xs">↵</kbd>
+        <span class="ml-0.5">{{ $t("cloud-search.search-logs-shortcut") }}</span>
+      </span>
+
+      <span v-if="cloudSearch.available.value" class="ml-auto flex items-center gap-1.5">
+        <mdi:cloud-check-outline class="text-primary size-3.5" />
+        {{ $t("cloud-search.cloud-connected") }}
+      </span>
+      <span v-else-if="cloudConfig?.linked" class="ml-auto flex items-center gap-1.5">
+        <mdi:cloud-off-outline class="size-3.5" />
+        <RouterLink to="/settings/cloud" class="link link-hover" @click.stop>
+          {{ $t("cloud-search.enable-streaming-to-search") }}
+        </RouterLink>
+      </span>
+      <span v-else class="ml-auto flex items-center gap-1.5">
+        <mdi:cloud-off-outline class="size-3.5" />
+        <RouterLink to="/settings/cloud" class="link link-hover" @click.stop>
+          {{ $t("cloud-search.connect-to-enable") }}
+        </RouterLink>
+      </span>
+    </div>
   </div>
 </template>
 
 <script lang="ts" setup>
-import { Container } from "@/models/Container";
+import { ContainerState } from "@/types/Container";
 import { useFuse } from "@vueuse/integrations/useFuse";
-
-const { maxResults: resultLimit = 20 } = defineProps<{
-  maxResults?: number;
-}>();
+import { type FuseResult } from "fuse.js";
+import { useCloudConfig } from "@/composable/cloudConfig";
+import { useCloudLogSearch } from "@/composable/cloudLogSearch";
+import { useCommands, type Command } from "@/composable/commands";
 
 const close = defineEmit();
 
-const query = ref("");
-const autocomplete = ref<HTMLElement>();
 const router = useRouter();
-const store = useContainerStore();
-const { containers } = storeToRefs(store);
+const route = useRoute();
+
+// Prefill with the current /cloud/search query so the user can refine
+// without retyping. Empty everywhere else. Null-safe for unit tests
+// that mount the component without a router context.
+const initialQuery = route?.path === "/cloud/search" && typeof route.query?.q === "string" ? route.query.q : "";
+const query = ref(initialQuery);
+const input = ref<HTMLInputElement>();
+const listItems = ref<(Element | null)[]>([]);
+const selectedIndex = ref(0);
+
+// Function ref into a single flat array so Commands and Containers share one
+// selection index for arrow-key navigation and scroll-into-view.
+function setItemRef(el: any, index: number) {
+  listItems.value[index] = (el?.$el ?? el) as Element | null;
+}
+
+const containerStore = useContainerStore();
+const pinnedStore = usePinnedLogsStore();
+const { visibleContainers } = storeToRefs(containerStore);
+
+const swarmStore = useSwarmStore();
+const { stacks, services } = storeToRefs(swarmStore);
+
+const { cloudConfig } = useCloudConfig();
+// Mounted only so the "Search logs for X" CTA can read `available`. We
+// don't render the hits inside the popup. The composable's debounced
+// watch short-circuits on empty query, so opening the modal alone does
+// not fire a request.
+const cloudSearch = useCloudLogSearch(query);
+
+const logSearchVisible = computed(() => query.value.trim().length > 0);
+
+const { t } = useI18n();
+const placeholderCopy = computed(() =>
+  cloudSearch.available.value ? t("cloud-search.modal-placeholder-cloud") : t("cloud-search.modal-placeholder-plain"),
+);
+
+onMounted(async () => {
+  const dialog = input.value?.closest("dialog");
+  if (dialog) {
+    const animations = dialog.getAnimations();
+    await Promise.all(animations.map((animation) => animation.finished));
+    input.value?.focus();
+    if (initialQuery) input.value?.select();
+  }
+});
+
+type Item = {
+  id: string;
+  created: Date;
+  name: string;
+  state?: ContainerState;
+  host?: string;
+  type: "container" | "service" | "stack";
+};
 
 const list = computed(() => {
-  return containers.value.map(({ id, created, name, state, host }) => {
-    return {
-      id,
-      created,
-      name,
-      state,
-      host,
-    };
+  const items: Item[] = [];
+
+  for (const container of visibleContainers.value) {
+    items.push({
+      id: container.id,
+      created: container.created,
+      name: container.name,
+      state: container.state,
+      host: container.hostLabel,
+      type: "container",
+    });
+  }
+
+  for (const service of services.value) {
+    items.push({
+      id: service.name,
+      created: service.updatedAt,
+      name: service.name,
+      state: "running",
+      type: "service",
+    });
+  }
+
+  for (const stack of stacks.value) {
+    items.push({
+      id: stack.name,
+      created: stack.updatedAt,
+      name: stack.name,
+      state: "running",
+      type: "stack",
+    });
+  }
+
+  return items;
+});
+
+const { results: fuseResults } = useFuse(query, list, {
+  fuseOptions: {
+    keys: ["name", "host"],
+    includeScore: true,
+    useExtendedSearch: true,
+    threshold: 0.3,
+    includeMatches: true,
+  },
+});
+
+const results = computed(() => (query.value ? fuseResults.value : []));
+
+// Commands palette. Fuzzy-matched against title/keywords while typing; the
+// context commands (container actions) show up front on an empty query.
+const { commands, contextCommands } = useCommands();
+const { results: commandFuseResults } = useFuse(query, commands, {
+  fuseOptions: {
+    keys: ["title", "keywords"],
+    useExtendedSearch: true,
+    threshold: 0.3,
+  },
+});
+const commandEntries = computed<Command[]>(() =>
+  query.value ? commandFuseResults.value.map((r) => r.item) : contextCommands.value,
+);
+
+const data = computed(() => {
+  return [...results.value].sort((a: FuseResult<Item>, b: FuseResult<Item>) => {
+    if (a.score === b.score) {
+      if (a.item.state === b.item.state) {
+        return b.item.created.getTime() - a.item.created.getTime();
+      } else if (a.item.state === "running" && b.item.state !== "running") {
+        return -1;
+      } else {
+        return 1;
+      }
+    } else {
+      return (a.score ?? 0) - (b.score ?? 0);
+    }
   });
 });
 
-const { results } = useFuse(query, list, {
-  fuseOptions: { keys: ["name"], includeScore: true },
-  resultLimit,
-  matchAllWhenSearchEmpty: true,
+// Container hits, mirrors the previously named `data` list for the template.
+const containerEntries = computed(() => data.value);
+const totalCount = computed(() => commandEntries.value.length + containerEntries.value.length);
+
+// Reset to the top only when the user types. Live SSE container add/remove
+// changes totalCount too, and resetting on that would snap the selection back
+// to 0 while the palette is open.
+watch(query, () => {
+  selectedIndex.value = 0;
 });
 
-const data = computed(() => {
-  return results.value
-    .sort((a, b) => {
-      if (a.score === b.score) {
-        if (a.item.state === "running" && b.item.state !== "running") {
-          return -1;
-        } else {
-          return 1;
-        }
-      } else if (a.score && b.score) {
-        return a.score - b.score;
-      } else {
-        return 0;
-      }
-    })
-    .map(({ item }) => item);
+// Keep the selection in bounds when the result count shrinks underneath it.
+watch(totalCount, (count) => {
+  if (selectedIndex.value > count - 1) {
+    selectedIndex.value = Math.max(count - 1, 0);
+  }
 });
-watchOnce(autocomplete, () => autocomplete.value?.focus());
 
-function selected({ id }: { id: string }) {
-  router.push({ name: "container-id", params: { id } });
+watch(selectedIndex, () => {
+  listItems.value?.[selectedIndex.value]?.scrollIntoView({ block: "nearest" });
+});
+
+function selected(item: Item) {
+  if (item.type === "container") {
+    router.push({ name: "/container/[id]", params: { id: item.id } });
+  } else if (item.type === "service") {
+    router.push({ name: "/service/[name]", params: { name: item.id } });
+  } else if (item.type === "stack") {
+    router.push({ name: "/stack/[name]", params: { name: item.id } });
+  }
   close();
 }
-function addColumn(container: Container) {
-  store.appendActiveContainer(container);
+
+async function runCommand(command: Command) {
   close();
+  await command.perform();
+}
+
+function onEnter() {
+  // Commands come first in the flat list, then containers. With nothing
+  // selectable (cloud-only query like "OOM"), fall back to log search so the
+  // user isn't stuck on a popup that does nothing.
+  const commandCount = commandEntries.value.length;
+  if (selectedIndex.value < commandCount) {
+    runCommand(commandEntries.value[selectedIndex.value]);
+  } else if (containerEntries.value.length > 0) {
+    selected(containerEntries.value[selectedIndex.value - commandCount].item);
+  } else if (cloudSearch.available.value && logSearchVisible.value) {
+    runLogSearch();
+  }
+}
+
+function onPin() {
+  // Alt+Enter pins a container column. Only meaningful when a container row is
+  // selected, not a command.
+  const commandCount = commandEntries.value.length;
+  if (selectedIndex.value >= commandCount) {
+    const entry = containerEntries.value[selectedIndex.value - commandCount];
+    if (entry?.item.type === "container") addColumn(entry.item);
+  }
+}
+
+function runLogSearch() {
+  if (!cloudSearch.available.value) return;
+  const q = query.value.trim();
+  if (!q) return;
+  router.push({ path: "/cloud/search", query: { q } });
+  close();
+}
+
+function addColumn(container: { id: string }) {
+  pinnedStore.pinContainer(container);
+  close();
+}
+
+function matchedName({ item, matches = [] }: FuseResult<Item>) {
+  const matched = matches.find((match) => match.key === "name");
+  if (matched) {
+    const { indices } = matched;
+    const result = [];
+    let lastIndex = 0;
+    for (const [start, end] of indices) {
+      if (lastIndex > start) continue;
+      result.push(item.name.slice(lastIndex, start));
+      result.push(`<mark>${item.name.slice(start, end + 1)}</mark>`);
+      lastIndex = end + 1;
+    }
+    result.push(item.name.slice(lastIndex));
+    return result.join("");
+  } else {
+    return item.name;
+  }
 }
 </script>
 
-<style lang="scss" scoped>
-.panel {
-  min-height: 400px;
-  width: 580px;
-}
-
-@media screen and (max-width: 768px) {
-  .panel {
-    min-height: 200px;
-    width: auto;
-    margin-left: 0.25rem !important;
-    margin-right: 0.25rem !important;
-  }
-}
-
-.running {
-  color: var(--primary-color);
-}
-
-.exited {
-  color: var(--scheme-main-ter);
-}
-
-.column-icon {
-  &:hover {
-    color: var(--secondary-color);
-  }
-}
-
-:deep(a.dropdown-item) {
-  padding-right: 1em;
-
-  .media-right {
-    visibility: hidden;
-  }
-
-  &:hover .media-right {
-    visibility: visible;
-  }
-}
-
-.icon {
-  vertical-align: middle;
+<style scoped>
+@reference "@/main.css";
+:deep(mark) {
+  @apply bg-transparent text-inherit underline underline-offset-2;
 }
 </style>

assets/components/GroupMenu.vue

@@ -0,0 +1,29 @@
+<template>
+  <ul class="menu w-full p-0 text-[0.95rem]">
+    <li v-if="customGroups.length > 0">
+      <details open>
+        <summary class="text-base-content/80 font-light">
+          <ph:bounding-box-fill />
+          {{ $t("label.group-menu") }}
+        </summary>
+        <ul>
+          <li v-for="group in customGroups" :key="group.name">
+            <router-link :to="{ name: '/group/[name]', params: { name: group.name } }" active-class="menu-active">
+              <ph:stack-simple />
+              <div class="truncate">
+                {{ group.name }}
+              </div>
+            </router-link>
+          </li>
+        </ul>
+      </details>
+    </li>
+  </ul>
+</template>
+
+<script lang="ts" setup>
+const store = useSwarmStore();
+
+const { customGroups } = storeToRefs(store);
+</script>
+<style scoped></style>

assets/components/GroupedViewer/GroupedLog.vue

@@ -0,0 +1,47 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="group.containers.length && ready">
+    <template #header>
+      <div class="mx-2 flex items-center gap-2 md:ml-4">
+        <ContainerDropdown :containers="group.containers">
+          {{ $t("label.container", group.containers.length) }}
+        </ContainerDropdown>
+        <MultiContainerStat class="ml-auto" :containers="group.containers" />
+        <MultiContainerActionToolbar class="max-md:hidden" :name="group.name" @clear="viewer?.clear()" />
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useGroupedStream"
+        :entity="group"
+        :visible-keys="new Map<string[], boolean>()"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { GroupedContainers } from "@/models/Container";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const { name, scrollable = false } = defineProps<{
+  name: string;
+  scrollable?: boolean;
+}>();
+
+const containerStore = useContainerStore();
+const viewer = ref<ComponentExposed<typeof ViewerWithSource>>();
+
+const { ready } = storeToRefs(containerStore);
+
+const swarmStore = useSwarmStore();
+const { customGroups } = storeToRefs(swarmStore);
+
+const group = computed(() => customGroups.value.find((g) => g.name === name) ?? new GroupedContainers("", []));
+
+provideLoggingContext(
+  toRef(() => group.value.containers),
+  { showContainerName: true, showHostname: false },
+);
+</script>

assets/components/HostCard.vue

@@ -0,0 +1,159 @@
+<template>
+  <div class="card bg-base-100">
+    <div class="card-body flex gap-3 max-md:p-4">
+      <div class="flex flex-row items-center gap-3 overflow-hidden">
+        <div class="flex min-w-0 items-center gap-2 text-lg font-semibold tracking-tight md:text-xl">
+          <HostIcon :type="host.type" class="text-base-content/80 flex-none" />
+          <div class="truncate">{{ host.name }}</div>
+
+          <span class="badge badge-error badge-xs gap-1 p-2 font-normal" v-if="!host.available">
+            <carbon:warning />
+            offline
+          </span>
+          <span
+            class="badge badge-success badge-xs gap-1 p-2 font-normal"
+            :class="{ 'badge-warning': config.version != host.agentVersion }"
+            v-else-if="host.type == 'agent'"
+            title="Dozzle Agent"
+          >
+            {{ host.agentVersion }}
+          </span>
+        </div>
+
+        <ul
+          class="text-base-content/60 ml-auto flex shrink-0 flex-row flex-wrap items-center gap-x-3 text-xs tabular-nums md:text-sm"
+        >
+          <li class="flex items-center gap-1.5">
+            <octicon:container-24 class="size-3.5" />
+            {{ $t("label.container", hostContainers.length) }}
+          </li>
+          <li class="flex items-center gap-1.5" :title="runtimeLabel">
+            <simple-icons:podman v-if="host.runtime === 'podman'" class="size-3.5" />
+            <mdi:docker v-else class="size-3.5" />
+            {{ host.dockerVersion }}
+          </li>
+        </ul>
+      </div>
+
+      <div class="grid grid-cols-2 gap-2 md:gap-3" v-if="stats">
+        <MetricCard
+          :icon="PhCpu"
+          :value="stats.weighted.movingAverage.totalCPU"
+          :chartData="cpuHistory"
+          container-class="bg-primary/10"
+          text-class="text-primary"
+          bar-class="bg-primary"
+          :formatValue="(value) => `${value.toFixed(1)}%`"
+          :label="`${host.nCPU} CPU`"
+        />
+
+        <MetricCard
+          :icon="PhMemory"
+          :value="stats.weighted.movingAverage.totalMemUsage"
+          :chartData="memHistory"
+          container-class="bg-secondary/10"
+          text-class="text-secondary"
+          bar-class="bg-secondary"
+          :formatValue="(value) => formatBytes(value, { decimals: 1 })"
+          :label="formatBytes(host.memTotal, { decimals: 1 })"
+        />
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup lang="ts">
+import type { Host } from "@/stores/hosts";
+import { Container } from "@/models/Container";
+import PhCpu from "~icons/ph/cpu";
+import PhMemory from "~icons/ph/memory";
+
+const props = defineProps<{
+  host: Host;
+}>();
+
+const containerStore = useContainerStore();
+const { containers } = storeToRefs(containerStore) as unknown as {
+  containers: Ref<Container[]>;
+};
+
+const hostContainers = computed(() =>
+  containers.value.filter((container) => container.host === props.host.id && container.state === "running"),
+);
+
+const runtimeLabel = computed(() => (props.host.runtime === "podman" ? "Podman" : "Docker"));
+
+function toContainerCores(container: Container): number {
+  if (container.cpuLimit && container.cpuLimit > 0) {
+    return container.cpuLimit;
+  }
+  return props.host.nCPU ?? 1;
+}
+
+type TotalStat = {
+  totalCPU: number;
+  totalMem: number;
+  totalMemUsage: number;
+};
+
+const totalStat = ref<TotalStat>({ totalCPU: 0, totalMem: 0, totalMemUsage: 0 });
+const { history, reset } = useSimpleRefHistory(totalStat, { capacity: 300 });
+
+const cpuHistory = computed(() =>
+  history.value.map((stat) => ({
+    percent: stat.totalCPU,
+    value: stat.totalCPU,
+  })),
+);
+const memHistory = computed(() =>
+  history.value.map((stat) => ({
+    percent: stat.totalMem,
+    value: stat.totalMemUsage,
+  })),
+);
+
+const stats = reactive({ mostRecent: totalStat, weighted: useExponentialMovingAverage(totalStat) });
+
+watch(
+  () => hostContainers.value,
+  () => {
+    const initial: TotalStat[] = [];
+
+    for (let i = 1; i <= 300; i++) {
+      const stat = hostContainers.value.reduce(
+        (acc, container) => {
+          const item = container.statsHistory.at(-i);
+          if (!item) {
+            return acc;
+          }
+          const cores = toContainerCores(container);
+          return {
+            totalCPU: acc.totalCPU + item.cpu / cores,
+            totalMem: acc.totalMem + item.memory,
+            totalMemUsage: acc.totalMemUsage + item.memoryUsage,
+          };
+        },
+        { totalCPU: 0, totalMem: 0, totalMemUsage: 0 },
+      );
+      initial.push(stat);
+    }
+    reset({ initial: initial.reverse() });
+    stats.weighted.reset(initial.at(-1)!);
+  },
+  { immediate: true },
+);
+
+useIntervalFn(() => {
+  totalStat.value = hostContainers.value.reduce(
+    (acc, container) => {
+      const cores = toContainerCores(container);
+      return {
+        totalCPU: acc.totalCPU + container.stat.cpu / cores,
+        totalMem: acc.totalMem + container.stat.memory,
+        totalMemUsage: acc.totalMemUsage + container.stat.memoryUsage,
+      };
+    },
+    { totalCPU: 0, totalMem: 0, totalMemUsage: 0 },
+  );
+}, 1000);
+</script>

assets/components/HostList.vue

@@ -0,0 +1,11 @@
+<template>
+  <ul class="grid gap-4 md:grid-cols-[repeat(auto-fill,minmax(480px,1fr))]">
+    <li v-for="host in hosts" :key="host.id">
+      <HostCard :host="host" />
+    </li>
+  </ul>
+</template>
+
+<script setup lang="ts">
+const { hosts } = useHosts();
+</script>

assets/components/HostMenu.vue

@@ -0,0 +1,410 @@
+<template>
+  <div class="flex items-center">
+    <div class="breadcrumbs flex-1">
+      <ul>
+        <li>
+          <a @click.prevent="setHost(null)" class="link-primary">{{ $t("label.hosts") }}</a>
+        </li>
+        <li v-if="sessionHost && hosts[sessionHost]" class="cursor-default">
+          <router-link
+            :to="{
+              name: '/host/[id]',
+              params: { id: hosts[sessionHost].id },
+            }"
+            class="btn btn-outline btn-primary btn-xs"
+            active-class="btn-active"
+            :title="$t('tooltip.merge-all')"
+          >
+            <ph:arrows-merge />
+            {{ hosts[sessionHost].name }}
+          </router-link>
+        </li>
+      </ul>
+    </div>
+    <div class="flex-none">
+      <div class="dropdown dropdown-end dropdown-hover">
+        <label tabindex="0" class="btn btn-square btn-ghost btn-sm">
+          <ion:ellipsis-vertical />
+        </label>
+        <ul
+          tabindex="0"
+          class="menu dropdown-content rounded-box bg-base-200 border-base-content/20 z-50 w-52 border p-1 shadow-sm"
+        >
+          <li>
+            <a class="text-sm capitalize" @click="toggleShowAllContainers()">
+              <mdi:check class="w-4" v-if="showAllContainers" />
+              <div v-else class="w-4"></div>
+              {{ $t("label.show-all-containers") }}
+            </a>
+            <a v-if="hasCollapsible" class="text-sm capitalize" @click="collapseAll()">
+              <material-symbols-light:expand-all class="w-4" v-if="allCollapsed" />
+              <material-symbols-light:collapse-all class="w-4" v-else />
+              {{ allCollapsed ? $t("label.expand-all") : $t("label.collapse-all") }}
+            </a>
+          </li>
+        </ul>
+      </div>
+    </div>
+  </div>
+
+  <SlideTransition :slide-right="!!sessionHost">
+    <template #left>
+      <ul class="menu p-0">
+        <template v-if="!hasHostGroups">
+          <li v-for="host in hosts" :key="host.id">
+            <a
+              @click.prevent="setHost(host.id)"
+              class="auto-cols-[max-content_minmax(0,1fr)_max-content]"
+              :class="{ 'text-base-content/50 pointer-events-none': !host.available }"
+            >
+              <HostIcon :type="host.type" />
+              <span class="truncate">{{ host.name }}</span>
+              <span class="badge badge-error badge-xs p-1.5" v-if="!host.available">offline</span>
+            </a>
+          </li>
+        </template>
+        <template v-else v-for="[groupName, groupHosts] in groupedHostEntries" :key="groupName || '__ungrouped__'">
+          <li v-if="groupName" class="host-group">
+            <details :open="!collapsedHostGroups.has(groupName)" @toggle="updateCollapsedHostGroups($event, groupName)">
+              <summary class="host-group-summary">
+                <span class="truncate">{{ groupName }}</span>
+                <router-link
+                  :to="{ name: '/host-group/[name]', params: { name: groupName } }"
+                  class="btn btn-square btn-outline btn-primary btn-xs"
+                  :title="$t('tooltip.merge-all')"
+                  @click.stop
+                >
+                  <ph:arrows-merge />
+                </router-link>
+                <button
+                  v-if="!collapsedHostGroups.has(groupName)"
+                  type="button"
+                  class="btn btn-square btn-outline btn-primary btn-xs"
+                  :title="$t('label.collapse-group')"
+                  @click.stop.prevent="collapseHostGroup(groupName)"
+                >
+                  <material-symbols-light:collapse-all />
+                </button>
+              </summary>
+              <ul>
+                <li v-for="host in groupHosts" :key="host.id">
+                  <a
+                    @click.prevent="setHost(host.id)"
+                    class="auto-cols-[max-content_minmax(0,1fr)_max-content]"
+                    :class="{ 'text-base-content/50 pointer-events-none': !host.available }"
+                  >
+                    <HostIcon :type="host.type" />
+                    <span class="truncate">{{ host.name }}</span>
+                    <span class="badge badge-error badge-xs p-1.5" v-if="!host.available">offline</span>
+                  </a>
+                </li>
+              </ul>
+            </details>
+          </li>
+          <template v-else>
+            <li v-for="host in groupHosts" :key="host.id">
+              <a
+                @click.prevent="setHost(host.id)"
+                class="auto-cols-[max-content_minmax(0,1fr)_max-content]"
+                :class="{ 'text-base-content/50 pointer-events-none': !host.available }"
+              >
+                <HostIcon :type="host.type" />
+                <span class="truncate">{{ host.name }}</span>
+                <span class="badge badge-error badge-xs p-1.5" v-if="!host.available">offline</span>
+              </a>
+            </li>
+          </template>
+        </template>
+      </ul>
+    </template>
+    <template #right>
+      <ul class="containers menu w-full p-0 [&_li.menu-title]:px-0">
+        <li v-for="{ label, containers, icon } in menuItems" :key="label">
+          <details :open="!collapsedGroups.has(label)" @toggle="updateCollapsedGroups($event, label)">
+            <summary class="text-base-content/80 font-light">
+              <component :is="icon" />
+              {{ label.startsWith("label.") ? $t(label) : label }} ({{ containers.length }})
+
+              <router-link
+                :to="{
+                  name: '/merged/[ids]',
+                  params: { ids: containers.map(({ id }) => id).join(',') },
+                }"
+                class="btn btn-square btn-outline btn-primary btn-xs"
+                active-class="btn-active"
+                :title="$t('tooltip.merge-all')"
+              >
+                <ph:arrows-merge />
+              </router-link>
+            </summary>
+            <ul>
+              <li
+                v-for="item in containers"
+                :class="[item.state, { 'highlight-new': item.isNew }]"
+                :key="item.id"
+                @animationend="item.isNew = false"
+              >
+                <Popup>
+                  <router-link
+                    :to="{ name: '/container/[id]', params: { id: item.id } }"
+                    active-class="menu-active"
+                    @click.alt.stop.prevent="pinnedStore.pinContainer(item)"
+                    :title="item.name"
+                    class="group auto-cols-[max-content_minmax(0,1fr)_max-content_max-content]"
+                  >
+                    <svg-spinners:ring-resize v-if="item.isNew" class="text-secondary w-2" />
+                    <div
+                      v-else
+                      class="status data-[state=exited]:status-error data-[state=running]:status-success data-[state=paused]:status-warning"
+                      :data-state="item.state"
+                    ></div>
+                    <div class="truncate">
+                      {{ item.name }}
+                    </div>
+                    <ContainerHealth :health="item.health" />
+                    <span
+                      class="hover:text-secondary hidden group-hover:inline-block"
+                      @click.stop.prevent="pinnedStore.pinContainer(item)"
+                      v-show="!pinnedStore.isPinned(item)"
+                      :title="$t('tooltip.pin-column')"
+                    >
+                      <cil:columns />
+                    </span>
+                  </router-link>
+                  <template #content>
+                    <ContainerPopup :container="item" />
+                  </template>
+                </Popup>
+              </li>
+            </ul>
+          </details>
+        </li>
+      </ul>
+    </template>
+  </SlideTransition>
+</template>
+
+<script lang="ts" setup>
+import { Container } from "@/models/Container";
+import { sessionHost } from "@/composable/storage";
+import { showAllContainers, groupContainers } from "@/stores/settings";
+
+import Pin from "~icons/ph/map-pin-simple";
+import Stack from "~icons/ph/stack";
+import Containers from "~icons/octicon/container-24";
+
+const containerStore = useContainerStore();
+const { visibleContainers } = storeToRefs(containerStore);
+
+const pinnedStore = usePinnedLogsStore();
+
+const { hosts } = useHosts();
+
+const setHost = (host: string | null) => (sessionHost.value = host);
+
+const hasHostGroups = computed(() => Object.values(hosts.value).some((h) => h.group));
+
+const groupedHostEntries = computed(() => {
+  const groups: Record<string, (typeof hosts.value)[string][]> = {};
+  const ungrouped: (typeof hosts.value)[string][] = [];
+
+  for (const host of Object.values(hosts.value)) {
+    if (host.group) {
+      groups[host.group] ||= [];
+      groups[host.group].push(host);
+    } else {
+      ungrouped.push(host);
+    }
+  }
+
+  const entries = Object.entries(groups).sort(([a], [b]) => a.localeCompare(b)) as [string, typeof ungrouped][];
+  if (ungrouped.length > 0) {
+    entries.push(["", ungrouped]);
+  }
+  return entries;
+});
+
+const collapsedGroups = useProfileStorage("collapsedGroups", new Set<string>());
+const collapsedHostGroups = useProfileStorage("collapsedHostGroups", new Set<string>());
+const updateCollapsedGroups = (event: Event, label: string) => {
+  const details = event.target as HTMLDetailsElement;
+  if (details.open) {
+    collapsedGroups.value.delete(label);
+  } else {
+    collapsedGroups.value.add(label);
+  }
+  if (document.activeElement instanceof HTMLElement) {
+    document.activeElement.blur();
+  }
+};
+
+const updateCollapsedHostGroups = (event: Event, groupName: string) => {
+  const details = event.target as HTMLDetailsElement;
+  if (details.open) {
+    collapsedHostGroups.value.delete(groupName);
+  } else {
+    collapsedHostGroups.value.add(groupName);
+  }
+  if (document.activeElement instanceof HTMLElement) {
+    document.activeElement.blur();
+  }
+};
+
+const collapseHostGroup = (groupName: string) => {
+  collapsedHostGroups.value.add(groupName);
+  if (document.activeElement instanceof HTMLElement) {
+    document.activeElement.blur();
+  }
+};
+
+const hasCollapsible = computed(
+  () => menuItems.value.length > 0 || groupedHostEntries.value.some(([groupName]) => groupName),
+);
+
+const allCollapsed = computed(() => {
+  const containerGroups = menuItems.value;
+  const hostGroups = groupedHostEntries.value.filter(([groupName]) => groupName);
+  if (containerGroups.length === 0 && hostGroups.length === 0) return false;
+  return (
+    containerGroups.every(({ label }) => collapsedGroups.value.has(label)) &&
+    hostGroups.every(([groupName]) => collapsedHostGroups.value.has(groupName))
+  );
+});
+
+const collapseAll = () => {
+  if (allCollapsed.value) {
+    menuItems.value.forEach(({ label }) => collapsedGroups.value.delete(label));
+    groupedHostEntries.value.forEach(([groupName]) => {
+      if (groupName) collapsedHostGroups.value.delete(groupName);
+    });
+  } else {
+    menuItems.value.forEach(({ label }) => collapsedGroups.value.add(label));
+    groupedHostEntries.value.forEach(([groupName]) => {
+      if (groupName) collapsedHostGroups.value.add(groupName);
+    });
+  }
+  if (document.activeElement instanceof HTMLElement) {
+    document.activeElement.blur();
+  }
+};
+
+const debouncedPinnedContainers = debouncedRef(pinnedContainers, 200);
+const sortedContainers = computed(() =>
+  visibleContainers.value.filter((c) => c.host === sessionHost.value).sort(sorter),
+);
+
+const sorter = (a: Container, b: Container) => {
+  if (a.state === "running" && b.state !== "running") {
+    return -1;
+  } else if (a.state !== "running" && b.state === "running") {
+    return 1;
+  } else {
+    return a.name.localeCompare(b.name);
+  }
+};
+
+const menuItems = computed(() => {
+  const namespaced: Record<string, Container[]> = {};
+  const pinned = [];
+  const singular = [];
+
+  for (const item of sortedContainers.value) {
+    const namespace = item.namespace;
+    if (debouncedPinnedContainers.value?.has(item.name)) {
+      pinned.push(item);
+    } else if (namespace) {
+      namespaced[namespace] ||= [];
+      namespaced[namespace].push(item);
+    } else {
+      singular.push(item);
+    }
+  }
+
+  const items = [];
+  if (pinned.length) {
+    items.push({ label: "label.pinned", containers: pinned, icon: Pin });
+  }
+  for (const [label, containers] of Object.entries(namespaced).sort(([a], [b]) => a.localeCompare(b))) {
+    const shouldGroup =
+      groupContainers.value === "always" || (groupContainers.value === "at-least-2" && containers.length > 1);
+
+    if (shouldGroup) {
+      items.push({ label, containers, icon: Stack });
+    } else {
+      for (const container of containers) {
+        singular.push(container);
+      }
+    }
+  }
+
+  singular.sort(sorter);
+
+  if (singular.length) {
+    items.push({
+      label: showAllContainers.value ? "label.all-containers" : "label.running-containers",
+      containers: singular,
+      icon: Containers,
+    });
+  }
+
+  return items;
+});
+
+const route = useRoute("/container/[id]");
+
+watch(
+  [() => route.name, () => route.params.id],
+  ([name, id]) => {
+    if (name === "/container/[id]") {
+      const container = containerStore.findContainerById(id as string);
+      if (container) {
+        setHost(container.host);
+      }
+    }
+  },
+  { immediate: true },
+);
+
+const toggleShowAllContainers = () => (showAllContainers.value = !showAllContainers.value);
+</script>
+<style scoped>
+.menu {
+  @apply text-[0.95rem];
+}
+
+.host-group-summary {
+  display: grid;
+  grid-template-columns: minmax(0, auto) max-content max-content max-content;
+  align-items: center;
+  justify-content: start;
+  gap: 0.5rem;
+  padding-left: 0;
+  padding-right: 0.25rem;
+  color: color-mix(in oklch, var(--color-base-content) 50%, transparent);
+}
+
+.host-group-summary::after {
+  margin-left: 0.25rem;
+}
+
+li.exited {
+  @apply opacity-75;
+}
+
+li.deleted {
+  @apply hidden;
+}
+
+li.highlight-new {
+  animation: highlight-fade 3s ease-out;
+}
+
+@keyframes highlight-fade {
+  from {
+    background-color: oklch(from var(--color-secondary) l c h / 0.25);
+  }
+  to {
+    background-color: transparent;
+  }
+}
+</style>

assets/components/HostViewer/HostGroupLog.vue

@@ -0,0 +1,61 @@
+<template>
+  <div v-if="groupHosts.length === 0" class="hero min-h-[50vh]">
+    <div class="hero-content text-center">
+      <p class="text-base-content/70 text-lg">{{ $t("error.host-group-not-found", { name }) }}</p>
+    </div>
+  </div>
+  <ScrollableView :scrollable="scrollable" v-else>
+    <template #header>
+      <div class="mx-2 flex items-center gap-2 md:ml-4">
+        <div class="flex flex-1 items-center gap-1.5 truncate md:gap-2">
+          <ph:computer-tower />
+          <div class="inline-flex font-mono text-sm">
+            <div class="font-semibold">{{ name }}</div>
+          </div>
+          <Tag class="font-mono max-md:hidden" size="small">
+            {{ $t("label.host-count", groupHosts.length) }}
+          </Tag>
+          <Tag class="font-mono max-md:hidden" size="small">
+            {{ $t("label.container", containers.length) }}
+          </Tag>
+        </div>
+        <MultiContainerStat class="ml-auto" :containers="containers" />
+        <MultiContainerActionToolbar class="max-md:hidden" :name="name" @clear="viewer?.clear()" />
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useHostGroupStream"
+        :entity="groupRef"
+        :visible-keys="visibleKeys"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { useHostGroupStream } from "@/composable/eventStreams";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const { name, scrollable = false } = defineProps<{
+  name: string;
+  scrollable?: boolean;
+}>();
+
+const { hosts } = useHosts();
+const store = useContainerStore();
+const { containersByHost } = storeToRefs(store);
+
+const groupHosts = computed(() => Object.values(hosts.value).filter((h) => h.group === name));
+const groupRef = computed(() => ({ name }));
+const visibleKeys = new Map<string[], boolean>();
+
+const containers = computed(() =>
+  groupHosts.value.flatMap((h) => containersByHost.value?.[h.id]?.filter((c) => c.state === "running") ?? []),
+);
+
+const viewer = useTemplateRef<ComponentExposed<typeof ViewerWithSource>>("viewer");
+provideLoggingContext(containers, { showContainerName: true, showHostname: true });
+</script>

assets/components/HostViewer/HostLog.vue

@@ -0,0 +1,43 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="host">
+    <template #header>
+      <div class="mx-2 flex items-center gap-2 md:ml-4">
+        <div class="flex flex-1 items-center gap-1.5 truncate md:gap-2">
+          <ph:computer-tower />
+          <div class="inline-flex font-mono text-sm">
+            <div class="font-semibold">{{ host.name }}</div>
+          </div>
+          <Tag class="font-mono max-md:hidden" size="small">
+            {{ $t("label.container", containers.length) }}
+          </Tag>
+        </div>
+        <MultiContainerStat class="ml-auto" :containers="containers" />
+        <MultiContainerActionToolbar class="max-md:hidden" :name="host.name" @clear="viewer?.clear()" />
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useHostStream"
+        :entity="host"
+        :visible-keys="new Map<string[], boolean>()"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { ComponentExposed } from "vue-component-type-helpers";
+const { id, scrollable = false } = defineProps<{
+  id: string;
+  scrollable?: boolean;
+}>();
+const store = useContainerStore();
+const { containersByHost } = storeToRefs(store);
+const { hosts } = useHosts();
+const host = computed(() => hosts.value[id]);
+const containers = computed(() => containersByHost.value?.[id]?.filter((c) => c.state === "running") ?? []);
+const viewer = useTemplateRef<ComponentExposed<typeof ViewerWithSource>>("viewer");
+provideLoggingContext(containers, { showContainerName: true, showHostname: false });
+</script>

assets/components/InfiniteLoader.vue

@@ -1,73 +0,0 @@
-<template>
-  <div ref="root" class="infinte-loader">
-    <div class="spinner" v-show="isLoading">
-      <div class="bounce1"></div>
-      <div class="bounce2"></div>
-      <div class="bounce3"></div>
-    </div>
-  </div>
-</template>
-
-<script lang="ts" setup>
-const { onLoadMore = () => {}, enabled } = defineProps<{
-  onLoadMore: () => void;
-  enabled: boolean;
-}>();
-
-const isLoading = ref(false);
-const root = ref<HTMLElement>();
-
-const observer = new IntersectionObserver(async (entries) => {
-  if (entries[0].intersectionRatio <= 0) return;
-  if (onLoadMore && enabled) {
-    const scrollingParent = root.value?.closest("[data-scrolling]") || document.documentElement;
-    const previousHeight = scrollingParent.scrollHeight;
-    isLoading.value = true;
-    await onLoadMore();
-    isLoading.value = false;
-    await nextTick();
-    scrollingParent.scrollTop += scrollingParent.scrollHeight - previousHeight;
-  }
-});
-
-onMounted(() => observer.observe(root.value!));
-onUnmounted(() => observer.disconnect());
-</script>
-
-<style scoped lang="scss">
-.infinte-loader {
-  min-height: 1px;
-}
-.spinner {
-  margin: 10px auto 0;
-  width: 70px;
-  text-align: center;
-
-  & > div {
-    width: 12px;
-    height: 12px;
-    background-color: var(--primary-color);
-    border-radius: 100%;
-    display: inline-block;
-    animation: sk-bouncedelay 0.8s infinite ease-in-out both;
-  }
-  & .bounce1 {
-    animation-delay: -0.32s;
-  }
-
-  & .bounce2 {
-    animation-delay: -0.16s;
-  }
-}
-
-@keyframes sk-bouncedelay {
-  0%,
-  80%,
-  100% {
-    transform: scale(0);
-  }
-  40% {
-    transform: scale(1);
-  }
-}
-</style>

assets/components/K8sMenu.vue

@@ -0,0 +1,142 @@
+<template>
+  <div class="flex items-center">
+    <div class="breadcrumbs flex-1">
+      <ul>
+        <li>
+          <a @click.prevent="setNamespace(null)" class="link-primary">{{ $t("label.namespaces") }}</a>
+        </li>
+        <li v-if="selectedNamespace === 'all'">
+          {{ $t("label.all-namespaces") }}
+        </li>
+        <li v-else-if="selectedNamespace" class="cursor-default">
+          <router-link
+            :to="{
+              name: '/namespace/[name]',
+              params: { name: selectedNamespace },
+            }"
+            class="btn btn-outline btn-primary btn-xs"
+            active-class="btn-active"
+          >
+            <ph:arrows-merge />
+            {{ selectedNamespace }}
+          </router-link>
+        </li>
+      </ul>
+    </div>
+    <div class="flex-none">
+      <div class="dropdown dropdown-end dropdown-hover">
+        <label tabindex="0" class="btn btn-square btn-ghost btn-sm">
+          <ph:dots-three-vertical-bold />
+        </label>
+        <ul
+          tabindex="0"
+          class="menu dropdown-content rounded-box bg-base-200 border-base-content/20 z-50 w-52 border p-1 shadow-sm"
+        >
+          <li>
+            <a class="text-sm capitalize" @click="collapseAll()">
+              <material-symbols-light:collapse-all class="w-4" />
+              {{ $t("label.collapse-all") }}
+            </a>
+          </li>
+        </ul>
+      </div>
+    </div>
+  </div>
+
+  <SlideTransition :slide-right="selectedNamespace !== null">
+    <template #left>
+      <ul class="menu p-0">
+        <li>
+          <a @click.prevent="setNamespace('all')">
+            <ph:circles-four />
+            {{ $t("label.all-namespaces") }}
+          </a>
+        </li>
+        <li v-for="ns in namespaces" :key="ns.name">
+          <a @click.prevent="setNamespace(ns.name)">
+            <ph:circles-four />
+            {{ ns.name }}
+          </a>
+        </li>
+      </ul>
+    </template>
+    <template #right>
+      <ul class="menu w-full p-0 text-[0.95rem]" ref="menu">
+        <li v-for="{ name, owners } in filteredNamespaces" :key="name">
+          <details open>
+            <summary class="text-base-content/80 font-light">
+              <ph:stack />
+              {{ name }} ({{ owners.length }})
+
+              <router-link
+                :to="{ name: '/namespace/[name]', params: { name } }"
+                class="btn btn-square btn-outline btn-primary btn-xs"
+                active-class="btn-active"
+                :title="$t('tooltip.merge-all')"
+              >
+                <ph:arrows-merge />
+              </router-link>
+            </summary>
+            <ul>
+              <li v-for="owner in owners" :key="owner.key">
+                <router-link :to="{ name: '/owner/[name]', params: { name: owner.key } }" active-class="menu-active">
+                  <ph:stack-simple />
+                  <div class="truncate">{{ owner.kind }}/{{ owner.name }}</div>
+                </router-link>
+              </li>
+            </ul>
+          </details>
+        </li>
+
+        <li v-if="ownersWithoutNamespace.length > 0">
+          <details open>
+            <summary class="text-base-content/80 font-light">
+              <ph:circles-four />
+              {{ $t("label.owners") }} ({{ ownersWithoutNamespace.length }})
+            </summary>
+            <ul>
+              <li v-for="owner in ownersWithoutNamespace" :key="owner.key">
+                <router-link :to="{ name: '/owner/[name]', params: { name: owner.key } }" active-class="menu-active">
+                  <ph:stack-simple />
+                  <div class="truncate">{{ owner.kind }}/{{ owner.name }}</div>
+                </router-link>
+              </li>
+            </ul>
+          </details>
+        </li>
+      </ul>
+    </template>
+  </SlideTransition>
+</template>
+
+<script lang="ts" setup>
+const store = useK8sStore();
+
+const { namespaces, owners } = storeToRefs(store);
+
+const selectedNamespace = ref<string | null>("all");
+
+const setNamespace = (namespace: string | null) => (selectedNamespace.value = namespace);
+
+const filteredNamespaces = computed(() => {
+  if (selectedNamespace.value === null || selectedNamespace.value === "all") {
+    return namespaces.value;
+  }
+  return namespaces.value.filter((ns) => ns.name === selectedNamespace.value);
+});
+
+const ownersWithoutNamespace = computed(() => {
+  const filtered = owners.value.filter((owner) => !owner.namespace);
+  if (selectedNamespace.value === null || selectedNamespace.value === "all") {
+    return filtered;
+  }
+  return [];
+});
+
+const menu = useTemplateRef("menu");
+
+const collapseAll = () => {
+  const details = menu.value?.querySelectorAll("details");
+  details?.forEach((detail) => (detail.open = false));
+};
+</script>

assets/components/K8sViewer/NamespaceLog.vue

@@ -0,0 +1,43 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="namespace.name">
+    <template #header>
+      <div class="mx-2 flex items-center gap-2 md:ml-4">
+        <div class="@container flex flex-1 items-center gap-1.5 md:gap-2">
+          <ph:stack />
+          <div class="font-mono text-sm font-semibold">{{ namespace.name }}</div>
+          <ContainerDropdown :containers="namespace.containers">
+            {{ $t("label.container", namespace.containers.length) }}
+          </ContainerDropdown>
+        </div>
+        <MultiContainerStat class="ml-auto" :containers="namespace.containers" />
+        <MultiContainerActionToolbar class="max-md:hidden" :name="namespace.name" @clear="viewer?.clear()" />
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useNamespaceStream"
+        :entity="namespace"
+        :visible-keys="new Map<string[], boolean>()"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import { K8sNamespace } from "@/stores/k8s";
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const { namespace, scrollable = false } = defineProps<{
+  scrollable?: boolean;
+  namespace: K8sNamespace;
+}>();
+
+const viewer = ref<ComponentExposed<typeof ViewerWithSource>>();
+
+provideLoggingContext(
+  toRef(() => namespace.containers),
+  { showContainerName: true, showHostname: false },
+);
+</script>

assets/components/K8sViewer/OwnerLog.vue

@@ -0,0 +1,43 @@
+<template>
+  <ScrollableView :scrollable="scrollable" v-if="owner.name">
+    <template #header>
+      <div class="mx-2 flex items-center gap-2 md:ml-4">
+        <div class="@container flex flex-1 items-center gap-1.5 md:gap-2">
+          <ph:stack-simple />
+          <div class="font-mono text-sm font-semibold">{{ owner.kind }}/{{ owner.name }}</div>
+          <ContainerDropdown :containers="owner.containers">
+            {{ $t("label.container", owner.containers.length) }}
+          </ContainerDropdown>
+        </div>
+        <MultiContainerStat class="ml-auto" :containers="owner.containers" />
+        <MultiContainerActionToolbar class="max-md:hidden" :name="owner.name" @clear="viewer?.clear()" />
+      </div>
+    </template>
+    <template #default>
+      <ViewerWithSource
+        ref="viewer"
+        :stream-source="useOwnerStream"
+        :entity="owner"
+        :visible-keys="new Map<string[], boolean>()"
+      />
+    </template>
+  </ScrollableView>
+</template>
+
+<script lang="ts" setup>
+import { K8sOwner } from "@/stores/k8s";
+import ViewerWithSource from "@/components/LogViewer/ViewerWithSource.vue";
+import { ComponentExposed } from "vue-component-type-helpers";
+
+const { owner, scrollable = false } = defineProps<{
+  scrollable?: boolean;
+  owner: K8sOwner;
+}>();
+
+const viewer = ref<ComponentExposed<typeof ViewerWithSource>>();
+
+provideLoggingContext(
+  toRef(() => owner.containers),
+  { showContainerName: true, showHostname: false },
+);
+</script>

assets/components/Links.vue

@@ -0,0 +1,73 @@
+<template>
+  <div class="flex items-center justify-end gap-4">
+    <slot name="more-items"></slot>
+    <Announcements />
+
+    <router-link
+      :to="{ name: '/notifications' }"
+      :aria-label="$t('title.notifications')"
+      data-testid="notifications"
+      class="btn btn-circle btn-sm"
+    >
+      <mdi:bell class="size-6" />
+    </router-link>
+
+    <CloudPopover />
+
+    <router-link
+      :to="{ name: '/settings' }"
+      :aria-label="$t('title.settings')"
+      data-testid="settings"
+      class="btn btn-circle btn-sm"
+    >
+      <mdi:cog class="size-6" />
+    </router-link>
+
+    <dropdown class="dropdown-end" data-testid="user-menu" v-if="config.user">
+      <template #trigger>
+        <template v-if="config.disableAvatars || !config.user.email">
+          <material-symbols:person class="size-6" />
+        </template>
+        <template v-else>
+          <img
+            class="ring-base-content/60 size-6 max-w-none rounded-full p-px ring-1"
+            :src="withBase('/api/profile/avatar')"
+          />
+        </template>
+      </template>
+      <template #content>
+        <div class="p-2">
+          <div class="font-bold">
+            {{ config.user.name }}
+          </div>
+          <div v-if="config.user.email" class="text-sm font-light">
+            {{ config.user.email }}
+          </div>
+        </div>
+        <ul v-if="config.authProvider === 'simple' || config.logoutUrl" class="menu mt-4 p-0">
+          <li>
+            <button @click.prevent="logout()" class="text-primary p-2">
+              <material-symbols:logout />
+              {{ $t("button.logout") }}
+            </button>
+          </li>
+        </ul>
+      </template>
+    </dropdown>
+  </div>
+</template>
+<script lang="ts" setup>
+const { logoutUrl } = config;
+
+async function logout() {
+  if (logoutUrl) {
+    location.href = logoutUrl;
+  } else {
+    await fetch(withBase("/api/token"), {
+      method: "DELETE",
+    });
+
+    location.reload();
+  }
+}
+</script>

assets/components/LogViewer/ComplexLogItem.spec.ts

@@ -0,0 +1,66 @@
+/**
+ * @vitest-environment jsdom
+ */
+import { mount } from "@vue/test-utils";
+import { describe, expect, test, vi } from "vitest";
+import { ref } from "vue";
+import ComplexLogItem from "./ComplexLogItem.vue";
+import { ComplexLogEntry, type JSONObject } from "@/models/LogEntry";
+
+vi.mock("@/stores/config", () => ({
+  __esModule: true,
+  default: { base: "", hosts: [{ name: "localhost", id: "localhost" }] },
+  withBase: (path: string) => path,
+}));
+
+function mountItem(message: JSONObject, visibleKeys?: ReturnType<typeof ref<Map<string[], boolean>>>) {
+  const entry = new ComplexLogEntry(message, "c1", 1, new Date(), "info", "stdout", "raw", visibleKeys as any);
+  return mount(ComplexLogItem, {
+    props: { logEntry: entry },
+    global: {
+      // LogItem pulls in stores/hosts; we only care about the payload rendering.
+      stubs: { LogItem: { template: "<div><slot /></div>" }, LogLevel: true },
+    },
+  });
+}
+
+describe("<ComplexLogItem />", () => {
+  test("renders key=value pairs", () => {
+    const wrapper = mountItem({ foo: "bar", n: 1 });
+    expect(wrapper.findAll("li")).toHaveLength(2);
+    expect(wrapper.text()).toContain("foo=");
+    expect(wrapper.text()).toContain("bar");
+    expect(wrapper.text()).toContain("n=");
+    expect(wrapper.text()).toContain("1");
+  });
+
+  test("renders null values as <null>", () => {
+    const wrapper = mountItem({ x: null } as any);
+    expect(wrapper.text()).toContain("<null>");
+  });
+
+  test("filters out undefined values", () => {
+    const wrapper = mountItem({ a: undefined as any, b: 2 });
+    expect(wrapper.findAll("li")).toHaveLength(1);
+    expect(wrapper.text()).toContain("b=");
+    expect(wrapper.text()).not.toContain("a=");
+  });
+
+  test("renders array values as a list", () => {
+    const wrapper = mountItem({ tags: ["a", "b"] });
+    expect(wrapper.find(".array").exists()).toBe(true);
+    expect(wrapper.find(".array").text()).toContain("a");
+    expect(wrapper.find(".array").text()).toContain("b");
+  });
+
+  test("renders null inside an array without throwing", () => {
+    const wrapper = mountItem({ tags: ["a", null, "b"] } as any);
+    expect(wrapper.find(".array").text()).toContain("null");
+  });
+
+  test("shows a placeholder when every value is hidden", () => {
+    const visibleKeys = ref(new Map<string[], boolean>([[["a"], false]]));
+    const wrapper = mountItem({ a: 1 }, visibleKeys);
+    expect(wrapper.text()).toContain("all values are hidden");
+  });
+});

assets/components/LogViewer/ComplexLogItem.vue

@@ -1,76 +1,75 @@
 <template>
-  <div class="columns is-1 is-variable is-mobile">
-    <div class="column is-narrow" v-if="showStd">
-      <log-std :std="logEntry.std"></log-std>
+  <DefineTemplate v-slot="{ data }">
+    <ul class="inline-flex flex-wrap space-x-4" @click="preventDefaultOnLinks">
+      <li v-for="(value, name) in data" :key="name" v-if="isObject(data)">
+        <span class="key">{{ name }}=</span>
+        <span class="value" v-if="value === null">&lt;null&gt;</span>
+        <ReuseTemplate :data="value" v-else-if="isObject(value) || Array.isArray(value)" />
+        <span v-else class="value" :class="typeof value" v-html="stripAnsi(String(value))"></span>
+      </li>
+      <li v-else-if="Array.isArray(data)">
+        <ul class="array inline-flex flex-wrap space-x-1">
+          <li
+            v-for="(item, index) in data"
+            :key="index"
+            class="after:text-base-content/70 not-last:after:content-[',']"
+          >
+            <ReuseTemplate :data="item" v-if="isObject(item) || Array.isArray(item)" />
+            <span v-else class="value" :class="typeof item" v-html="stripAnsi(String(item))"></span>
+          </li>
+        </ul>
+      </li>
+      <li class="key" v-if="Object.keys(validValues).length === 0">all values are hidden</li>
+    </ul>
+  </DefineTemplate>
+  <LogItem :logEntry>
+    <LogLevel class="flex select-none" :level="logEntry.level" />
+    <div @click="containers.length > 0 && showDrawer(LogDetails, { entry: logEntry })" class="cursor-pointer">
+      <ReuseTemplate :data="validValues" />
     </div>
-    <div class="column is-narrow" v-if="showTimestamp">
-      <log-date :date="logEntry.date"></log-date>
-    </div>
-    <div class="column is-narrow is-flex">
-      <log-level :level="logEntry.level"></log-level>
-    </div>
-    <div class="column">
-      <ul class="fields" :class="{ expanded }" @click="expandToggle()">
-        <li v-for="(value, name) in validValues">
-          <span class="has-text-grey">{{ name }}=</span
-          ><span class="has-text-weight-bold" v-if="value === null">&lt;null&gt;</span>
-          <template v-else-if="Array.isArray(value)">
-            <span class="has-text-weight-bold" v-html="markSearch(JSON.stringify(value))"> </span>
-          </template>
-          <span class="has-text-weight-bold" v-html="markSearch(value)" v-else></span>
-        </li>
-        <li class="has-text-grey" v-if="Object.keys(validValues).length === 0">all values are hidden</li>
-      </ul>
-      <field-list :fields="logEntry.unfilteredMessage" :expanded="expanded" :visible-keys="visibleKeys"></field-list>
-    </div>
-  </div>
+  </LogItem>
 </template>
 <script lang="ts" setup>
+import stripAnsi from "strip-ansi";
 import { type ComplexLogEntry } from "@/models/LogEntry";
-
-const { markSearch } = useSearchFilter();
+import LogDetails from "./LogDetails.vue";
 
 const { logEntry } = defineProps<{
   logEntry: ComplexLogEntry;
-  visibleKeys: string[][];
+  showContainerName?: boolean;
 }>();
 
-const [expanded, expandToggle] = useToggle();
+const { containers } = useLoggingContext();
+
+const [DefineTemplate, ReuseTemplate] = createReusableTemplate();
 
 const validValues = computed(() => {
   return Object.fromEntries(Object.entries(logEntry.message).filter(([_, value]) => value !== undefined));
 });
-</script>
 
-<style lang="scss" scoped>
-.fields {
-  display: inline-block;
-  list-style: none;
-
-  &:hover {
-    cursor: pointer;
-
-    &::after {
-      content: "expand json";
-      color: var(--secondary-color);
-      display: inline-block;
-      margin-left: 0.5em;
-      font-family: "Segoe UI", Tahoma, Geneva, Verdana, sans-serif;
-    }
-  }
-
-  &.expanded:hover {
-    &::after {
-      content: "collapse json";
-    }
-  }
-
-  li {
-    display: inline-block;
-
-    & + li {
-      margin-left: 1em;
-    }
+const showDrawer = useDrawer();
+function preventDefaultOnLinks(event: MouseEvent) {
+  if (event.target instanceof HTMLAnchorElement && event.target.rel?.includes("external")) {
+    event.stopImmediatePropagation();
   }
 }
+</script>
+
+<style scoped>
+@reference "@/main.css";
+.key {
+  @apply text-base-content/70 font-light;
+}
+
+.value {
+  @apply text-base-content font-bold;
+}
+
+.array {
+  @apply before:text-base-content/80 after:text-base-content/80 before:content-['['] after:content-[']'];
+}
+
+.string {
+  @apply before:content-['"'] after:content-['"'];
+}
 </style>

assets/components/LogViewer/ContainerEventLogItem.vue

@@ -0,0 +1,23 @@
+<template>
+  <LogItem :logEntry>
+    <div class="whitespace-pre-wrap" :data-event="logEntry.event" v-html="logEntry.message"></div>
+  </LogItem>
+</template>
+<script lang="ts" setup>
+import { ContainerEventLogEntry } from "@/models/LogEntry";
+
+const { logEntry } = defineProps<{
+  logEntry: ContainerEventLogEntry;
+  showContainerName?: boolean;
+}>();
+</script>
+
+<style scoped>
+@reference "@/main.css";
+[data-event="container-stopped"] {
+  @apply text-red;
+}
+[data-event="container-started"] {
+  @apply text-green;
+}
+</style>

assets/components/LogViewer/ContainerPopup.vue

@@ -1,26 +0,0 @@
-<template>
-  <div>
-    <span class="has-text-weight-light"> RUNNING </span>
-    <span class="has-text-weight-semibold">
-      <distance-time :date="container.created" strict :suffix="false"></distance-time>
-    </span>
-  </div>
-  <div>
-    <span class="has-text-weight-light"> LOAD </span>
-    <span class="has-text-weight-semibold"> {{ container.stat.cpu }}% </span>
-  </div>
-  <div>
-    <span class="has-text-weight-light"> MEM </span>
-    <span class="has-text-weight-semibold"> {{ formatBytes(container.stat.memoryUsage) }} </span>
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { Container } from "@/models/Container";
-
-const { container } = defineProps<{
-  container: Container;
-}>();
-</script>
-
-<style lang="scss" scoped></style>

assets/components/LogViewer/ContainerStat.vue

@@ -1,70 +0,0 @@
-<template>
-  <div class="is-size-7 is-uppercase columns is-marginless is-mobile is-vcentered" v-if="container.stat">
-    <stat-monitor
-      class="column is-narrow"
-      :data="memoryData"
-      label="mem"
-      :stat-value="formatBytes(unref(container.stat).memoryUsage)"
-    ></stat-monitor>
-    <stat-monitor
-      class="column is-narrow"
-      :data="cpuData"
-      label="load"
-      :stat-value="unref(container.stat).cpu + '%'"
-    ></stat-monitor>
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { Container } from "@/models/Container";
-import { type ComputedRef } from "vue";
-
-const container = inject("container") as ComputedRef<Container>;
-
-const cpuData = computedWithControl(
-  () => container.value.stat,
-  () => {
-    const history = container.value.statHistory;
-    const points: Point<unknown>[] = history.map((stat, i) => ({
-      x: i,
-      y: stat.snapshot.cpu,
-      value: stat.snapshot.cpu + "%",
-    }));
-    return points;
-  },
-);
-
-const memoryData = computedWithControl(
-  () => container.value.stat,
-  () => {
-    const history = container.value.statHistory;
-    const points: Point<string>[] = history.map((stat, i) => ({
-      x: i,
-      y: stat.snapshot.memory,
-      value: formatBytes(stat.snapshot.memoryUsage),
-    }));
-    return points;
-  },
-);
-</script>
-
-<style lang="scss" scoped>
-.has-border {
-  border: 1px solid var(--primary-color);
-  border-radius: 3px;
-  padding: 1px 1px 0 1px;
-  display: flex;
-  overflow: hidden;
-  padding-top: 0.25em;
-}
-
-.has-background-body-color {
-  background-color: var(--body-background-color);
-}
-
-.is-top-left {
-  position: absolute;
-  top: 0;
-  left: 0.75em;
-}
-</style>

assets/components/LogViewer/ContainerTitle.vue

@@ -1,24 +0,0 @@
-<template>
-  <div class="columns is-marginless has-text-weight-bold is-family-monospace">
-    <div class="column is-narrow is-hidden-mobile" v-if="container.health">
-      <container-health :health="container.health"></container-health>
-    </div>
-    <div class="column is-ellipsis">
-      {{ container.name }}<span v-if="container.isSwarm">{{ container.swarmId }}</span>
-      <tag class="is-hidden-mobile">{{ container.image.replace(/@sha.*/, "") }}</tag>
-    </div>
-  </div>
-</template>
-
-<script lang="ts" setup>
-import { Container } from "@/models/Container";
-import { type ComputedRef } from "vue";
-
-const container = inject("container") as ComputedRef<Container>;
-</script>
-
-<style lang="scss" scoped>
-.icon {
-  vertical-align: middle;
-}
-</style>

assets/components/LogViewer/DockerEventLogItem.vue

@@ -1,24 +0,0 @@
-<template>
-  <span class="text" :data-event="logEntry.event" v-html="logEntry.message"></span>
-</template>
-<script lang="ts" setup>
-import { DockerEventLogEntry } from "@/models/LogEntry";
-
-defineProps<{
-  logEntry: DockerEventLogEntry;
-}>();
-</script>
-
-<style lang="scss" scoped>
-span {
-  &[data-event="container-stopped"] {
-    color: #f14668;
-  }
-  &[data-event="container-started"] {
-    color: hsl(141, 53%, 53%);
-  }
-  &.text {
-    white-space: pre-wrap;
-  }
-}
-</style>

assets/components/LogViewer/EventSource.spec.ts

@@ -0,0 +1,242 @@
+import { createTestingPinia } from "@pinia/testing";
+import { mount } from "@vue/test-utils";
+import { useSearchFilter } from "@/composable/search";
+import { settings } from "@/stores/settings";
+// @ts-ignore
+import EventSource, { sources } from "eventsourcemock";
+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
+import { computed, nextTick } from "vue";
+import { createI18n } from "vue-i18n";
+import { createRouter, createWebHistory } from "vue-router";
+import { default as Component } from "./EventSource.vue";
+import SearchStatus from "./SearchStatus.vue";
+import LogViewer from "@/components/LogViewer/LogViewer.vue";
+import { Container } from "@/models/Container";
+import { Level } from "@/models/LogEntry";
+
+vi.mock("@/stores/config", () => ({
+  __esModule: true,
+  default: { base: "", hosts: [{ name: "localhost", id: "localhost" }] },
+  withBase: (path: string) => path,
+}));
+
+/**
+ * @vitest-environment jsdom
+ */
+describe("<ContainerEventSource />", () => {
+  const search = useSearchFilter();
+
+  beforeEach(() => {
+    global.EventSource = EventSource;
+    // @ts-ignore
+    window.scrollTo = vi.fn();
+    global.IntersectionObserver = class IntersectionObserver {
+      observe = vi.fn();
+      disconnect = vi.fn();
+      unobserve = vi.fn();
+      takeRecords = vi.fn();
+      root = null;
+      rootMargin = "";
+      thresholds = [];
+    } as any;
+    vi.useFakeTimers();
+    vi.setSystemTime(1560336942459);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.useRealTimers();
+  });
+
+  function createLogEventSource(
+    {
+      searchFilter = "",
+      hourStyle = "auto",
+    }: { searchFilter?: string | undefined; hourStyle?: "auto" | "24" | "12" } = {
+      hourStyle: "auto",
+    },
+  ) {
+    settings.value.hourStyle = hourStyle;
+    search.searchQueryFilter.value = searchFilter;
+    if (searchFilter) {
+      search.showSearch.value = true;
+    }
+
+    const router = createRouter({
+      history: createWebHistory("/"),
+      routes: [
+        {
+          path: "/",
+          component: {
+            template: "Test from createLogEventSource",
+          },
+        },
+        {
+          name: "/container/[id].time.[datetime]",
+          path: "/container/:id/time/:datetime",
+          component: {
+            template: "Test from createLogEventSource",
+          },
+        },
+      ],
+    });
+
+    return mount(Component, {
+      global: {
+        plugins: [
+          router,
+          createTestingPinia({
+            createSpy: vi.fn,
+            stubActions: false,
+            initialState: {
+              container: { containers: [{ id: "abc", image: "test:v123", host: "localhost" }] },
+            },
+          }),
+          createI18n({}),
+        ],
+        components: {
+          LogViewer,
+        },
+        provide: {
+          [scrollContextKey as symbol]: {
+            paused: computed(() => false),
+            loading: computed(() => false),
+          },
+          [loggingContextKey as symbol]: {
+            containers: computed(() => [{ id: "abc", image: "test:v123", host: "localhost" }]),
+            streamConfig: reactive({ stdout: true, stderr: true }),
+            hasComplexLogs: ref(false),
+            levels: new Set<Level>(["info"]),
+            historical: ref(false),
+          },
+        },
+      },
+      slots: {
+        default: `
+        <template #scoped="params"><LogViewer :messages="params.messages" :show-container-name="false" :visible-keys="[]" /></template>
+        `,
+      },
+      props: {
+        streamSource: useContainerStream,
+        entity: new Container(
+          "abc",
+          new Date(), // created
+          new Date(), // started
+          new Date(), // finished
+          "image",
+          "name",
+          "command",
+          "localhost",
+          {},
+          "created",
+          0,
+          0,
+          [],
+        ),
+      },
+    });
+  }
+
+  const sourceUrl = "/api/hosts/localhost/containers/abc/logs/stream?stdout=1&stderr=1&levels=info";
+
+  test("renders loading correctly", async () => {
+    const wrapper = createLogEventSource();
+    expect(wrapper.find("ul.animate-pulse").exists()).toBe(true);
+  });
+
+  test("should connect to EventSource", async () => {
+    const wrapper = createLogEventSource();
+    sources[sourceUrl].emitOpen();
+    expect(sources[sourceUrl].readyState).toBe(1);
+    wrapper.unmount();
+  });
+
+  test("should close EventSource", async () => {
+    const wrapper = createLogEventSource();
+    sources[sourceUrl].emitOpen();
+    wrapper.unmount();
+    expect(sources[sourceUrl].readyState).toBe(2);
+  });
+
+  test("should parse messages", async () => {
+    const wrapper = createLogEventSource();
+    sources[sourceUrl].emitOpen();
+    sources[sourceUrl].emitMessage({
+      data: `{"ts":1560336942459, "m":"This is a message.", "id":1, "rm": "This is a message.", "c": "abc"}`,
+    });
+
+    vi.runAllTimers();
+    await nextTick();
+
+    // @ts-ignore
+    const [message, _] = wrapper.vm.messages;
+    expect(message).toMatchSnapshot();
+  });
+
+  describe("search status", () => {
+    test("shows no-logs when not searching and the stream is empty", async () => {
+      const wrapper = createLogEventSource();
+      sources[sourceUrl].emitOpen();
+
+      await vi.advanceTimersByTimeAsync(3500);
+      await nextTick();
+
+      expect(wrapper.find('[data-testid="no-logs"]').exists()).toBe(true);
+    });
+
+    test("suppresses no-logs while a search is still running", async () => {
+      const wrapper = createLogEventSource();
+      sources[sourceUrl].emitOpen();
+      sources[sourceUrl].emit("search-status", {
+        data: JSON.stringify({ scannedTo: "2026-06-01T14:31:00Z", matches: 0, done: false }),
+      });
+
+      vi.advanceTimersByTime(3000);
+      await nextTick();
+
+      expect(wrapper.find('[data-testid="no-logs"]').exists()).toBe(false);
+      expect(wrapper.findComponent(SearchStatus).exists()).toBe(true);
+    });
+  });
+
+  describe("render html correctly", () => {
+    test("should render messages", async () => {
+      const wrapper = createLogEventSource();
+      sources[sourceUrl].emitOpen();
+      sources[sourceUrl].emitMessage({
+        data: `{"ts":1560336942459, "m":"This is a message.", "id":1, "rm": "This is a message.", "c": "abc"}`,
+      });
+
+      vi.runAllTimers();
+      await nextTick();
+
+      expect(wrapper.find("ul[data-logs]").html()).toMatchSnapshot();
+    });
+
+    test("should render dates with 12 hour style", async () => {
+      const wrapper = createLogEventSource({ hourStyle: "12" });
+      sources[sourceUrl].emitOpen();
+      sources[sourceUrl].emitMessage({
+        data: `{"ts":1560336942459, "m":"foo bar", "id":1, "rm": "foo bar", "c": "abc"}`,
+      });
+
+      vi.runAllTimers();
+      await nextTick();
+
+      expect(wrapper.find("ul[data-logs]").html()).toMatchSnapshot();
+    });
+
+    test("should render dates with 24 hour style", async () => {
+      const wrapper = createLogEventSource({ hourStyle: "24" });
+      sources[sourceUrl].emitOpen();
+      sources[sourceUrl].emitMessage({
+        data: `{"ts":1560336942459, "m":"foo bar", "id":1, "c": "abc"}`,
+      });
+
+      vi.runAllTimers();
+      await nextTick();
+
+      expect(wrapper.find("ul[data-logs]").html()).toMatchSnapshot();
+    });
+  });
+});

assets/components/LogViewer/EventSource.vue

@@ -0,0 +1,82 @@
+<template>
+  <SearchStatus :status="searchStatus" class="sticky top-0 z-10" />
+  <ul class="flex animate-pulse flex-col gap-4 p-4" v-if="loading || (noLogs && waitingForMoreLog && !inSearch)">
+    <div class="flex flex-row gap-2" v-for="size in sizes">
+      <div class="bg-base-content/50 h-3 w-40 shrink-0 rounded-full opacity-50"></div>
+      <div class="bg-base-content/50 h-3 rounded-full opacity-50" :class="size"></div>
+    </div>
+    <span class="sr-only">Loading...</span>
+  </ul>
+  <div v-else-if="noLogs && !waitingForMoreLog && !inSearch" class="p-4" data-testid="no-logs">
+    {{ $t("label.no-logs") }}
+  </div>
+  <slot :messages="messages" v-else></slot>
+  <IndeterminateBar :color v-if="!historical" />
+</template>
+
+<script lang="ts" setup generic="T">
+import { LogStreamSource } from "@/composable/eventStreams";
+const route = useRoute();
+
+const { entity, streamSource } = $defineProps<{
+  streamSource: (t: Ref<T>) => LogStreamSource;
+  entity: T;
+}>();
+
+const { historical } = useLoggingContext();
+
+const { messages, opened, loading, error, searchStatus } = streamSource(toRef(() => entity));
+
+// While a search is running (or just finished), SearchStatus owns the empty
+// messaging, so suppress the generic "no logs" state to avoid the false signal.
+const inSearch = computed(() => searchStatus.value.active || searchStatus.value.done);
+
+const color = computed(() => {
+  if (error.value) return "error";
+  if (loading.value) return "secondary";
+  if (opened.value) return "primary";
+  return "error";
+});
+
+const noLogs = computed(() => messages.value.length === 0);
+const waitingForMoreLog = refAutoReset(false, 3000);
+watchImmediate(loading, () => (waitingForMoreLog.value = true));
+
+defineExpose({
+  clear: () => (messages.value = []),
+});
+
+if (historical.value && typeof route.query.logId === "string") {
+  const targetId = route.query.logId;
+  watchOnce(messages, async () => {
+    await nextTick();
+    document.getElementById(targetId)?.scrollIntoView({ behavior: "instant", block: "center" });
+  });
+}
+
+const sizes = ref<string[]>([]);
+watch(
+  opened,
+  (value) => {
+    if (value) return;
+    const sizeOptions = [
+      "w-2/12",
+      "w-3/12",
+      "w-4/12",
+      "w-5/12",
+      "w-6/12",
+      "w-7/12",
+      "w-8/12",
+      "w-9/12",
+      "w-10/12",
+      "w-11/12",
+      "w-full",
+    ];
+    sizes.value = Array.from({ length: 18 }, () => sizeOptions[Math.floor(Math.random() * sizeOptions.length)]);
+  },
+  {
+    flush: "sync",
+    immediate: true,
+  },
+);
+</script>

assets/components/LogViewer/FieldList.vue

@@ -1,75 +0,0 @@
-<template>
-  <ul v-if="expanded" ref="root">
-    <li v-for="(value, name) in fields">
-      <template v-if="isObject(value)">
-        <span class="has-text-grey">{{ name }}=</span>
-        <field-list
-          :fields="value"
-          :parent-key="parentKey.concat(name)"
-          :visible-keys="visibleKeys"
-          expanded
-        ></field-list>
-      </template>
-      <template v-else-if="Array.isArray(value)">
-        <a @click="toggleField(name)"> {{ hasField(name) ? "remove" : "add" }}&nbsp;</a>
-        <span class="has-text-grey">{{ name }}=</span>[
-        <span class="has-text-weight-bold" v-for="(item, index) in value">
-          <span v-html="JSON.stringify(item)"></span><span v-if="index !== value.length - 1">,</span>
-        </span>
-        ]
-      </template>
-      <template v-else>
-        <a @click="toggleField(name)"> {{ hasField(name) ? "remove" : "add" }}&nbsp;</a>
-        <span class="has-text-grey">{{ name }}=</span><span class="has-text-weight-bold" v-html="value"></span>
-      </template>
-    </li>
-  </ul>
-</template>
-<script lang="ts" setup>
-import { arrayEquals, isObject } from "@/utils";
-
-const {
-  fields,
-  expanded = false,
-  parentKey = [],
-  visibleKeys = [],
-} = defineProps<{
-  fields: Record<string, any>;
-  expanded?: boolean;
-  parentKey?: string[];
-  visibleKeys?: string[][];
-}>();
-
-const root = ref<HTMLElement>();
-
-async function toggleField(field: string) {
-  const index = fieldIndex(field);
-
-  if (index > -1) {
-    visibleKeys.splice(index, 1);
-  } else {
-    visibleKeys.push(parentKey.concat(field));
-  }
-
-  await nextTick();
-
-  root.value?.scrollIntoView({
-    block: "center",
-  });
-}
-
-function hasField(field: string) {
-  return fieldIndex(field) > -1;
-}
-
-function fieldIndex(field: string) {
-  const path = parentKey.concat(field);
-  return visibleKeys.findIndex((keys) => arrayEquals(toRaw(keys), toRaw(path)));
-}
-</script>
-
-<style lang="scss" scoped>
-ul {
-  margin-left: 2em;
-}
-</style>

assets/components/LogViewer/GroupedLogItem.vue

@@ -0,0 +1,28 @@
+<template>
+  <LogItem :logEntry>
+    <div class="flex flex-col">
+      <div v-for="(msg, index) in logEntry.message" :key="index" class="flex items-start gap-x-2">
+        <LogLevel class="flex select-none" :level="logEntry.level" :position="getPosition(index)" />
+        <div
+          class="[word-break:break-word] whitespace-pre-wrap group-[.disable-wrap]:whitespace-pre"
+          v-html="colorize(msg)"
+          :class="{ 'min-h-4': msg === '' }"
+        ></div>
+      </div>
+    </div>
+  </LogItem>
+</template>
+<script lang="ts" setup>
+import { GroupedLogEntry, type Position } from "@/models/LogEntry";
+
+const { logEntry } = defineProps<{
+  logEntry: GroupedLogEntry;
+}>();
+
+const getPosition = (index: number): Position => {
+  const len = logEntry.message.length;
+  if (index === 0) return "start";
+  if (index === len - 1) return "end";
+  return "middle";
+};
+</script>

assets/components/LogViewer/IOCard.vue

@@ -0,0 +1,40 @@
+<template>
+  <div
+    class="bg-base-content/[0.06] grid min-w-0 grid-cols-[auto_auto_3.5rem_auto_3.5rem] items-center gap-x-1.5 gap-y-1 rounded-md px-2.5 py-1.5 text-[12.5px] leading-none tabular-nums max-md:hidden @max-5xl:hidden"
+    :title="tooltip"
+  >
+    <PhNetwork class="text-base-content/60 size-3.5" />
+    <PhArrowUp class="text-primary text-[10px]" />
+    <span class="text-right">{{ formatBytes(networkTx, { short: true, decimals: 1 }) }}/s</span>
+    <PhArrowDown class="text-secondary text-[10px]" />
+    <span class="text-right">{{ formatBytes(networkRx, { short: true, decimals: 1 }) }}/s</span>
+
+    <PhHardDrives class="text-base-content/60 size-3.5" />
+    <PhArrowUp class="text-primary text-[10px]" />
+    <span class="text-right">{{ formatBytes(diskWrite, { short: true, decimals: 1 }) }}/s</span>
+    <PhArrowDown class="text-secondary text-[10px]" />
+    <span class="text-right">{{ formatBytes(diskRead, { short: true, decimals: 1 }) }}/s</span>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import PhNetwork from "~icons/ph/network";
+import PhHardDrives from "~icons/ph/hard-drives";
+import PhArrowUp from "~icons/ph/arrow-up";
+import PhArrowDown from "~icons/ph/arrow-down";
+
+const { networkRx, networkTx, diskRead, diskWrite } = defineProps<{
+  networkRx: number;
+  networkTx: number;
+  diskRead: number;
+  diskWrite: number;
+}>();
+
+const { t } = useI18n();
+const tooltip = computed(
+  () =>
+    t("tooltip.network-io", { tx: formatBytes(networkTx), rx: formatBytes(networkRx) }) +
+    "\n" +
+    t("tooltip.disk-io", { write: formatBytes(diskWrite), read: formatBytes(diskRead) }),
+);
+</script>

assets/components/LogViewer/LoadMoreLogItem.vue

@@ -0,0 +1,31 @@
+<template>
+  <div ref="root" class="flex min-h-[1px] flex-1 content-center justify-center">
+    <span class="loading loading-bars loading-md text-primary m-2" v-show="isLoading"></span>
+  </div>
+</template>
+<script lang="ts" setup>
+import { LoadMoreLogEntry } from "@/models/LogEntry";
+
+const { logEntry } = defineProps<{
+  logEntry: LoadMoreLogEntry;
+}>();
+
+const isLoading = ref(false);
+const root = ref<HTMLElement>();
+
+useIntersectionObserver(root, async (entries) => {
+  if (entries[0].intersectionRatio <= 0) return;
+  if (isLoading.value) return;
+  const scrollingParent = root.value?.closest("[data-scrolling]") || document.documentElement;
+  const previousHeight = scrollingParent.scrollHeight;
+  isLoading.value = true;
+  await logEntry.loadMore();
+  isLoading.value = false;
+  await nextTick();
+  if (logEntry.rememberScrollPosition) {
+    scrollingParent.scrollTop += scrollingParent.scrollHeight - previousHeight;
+  }
+});
+</script>
+
+<style scoped></style>

assets/components/LogViewer/LogActions.vue

@@ -0,0 +1,197 @@
+<template>
+  <div
+    class="dropdown dropdown-hover absolute -left-2 z-10 font-sans"
+    :class="shouldShowBelow ? 'dropdown-right' : 'dropdown-right dropdown-end'"
+    v-show="container"
+    ref="dropdownRef"
+    @mouseenter="checkDropdownPosition"
+  >
+    <router-link
+      v-if="isFiltered"
+      @click="resetSearch()"
+      tabindex="0"
+      class="btn btn-square btn-xs border-base-content/20 bg-base-100 pointer-events-auto! opacity-0 shadow-sm group-hover/entry:opacity-90"
+      :to="{
+        name: '/container/[id].time.[datetime]',
+        params: { id: container.id, datetime: logEntry.date.toISOString() },
+        query: { logId: logEntry.id },
+      }"
+    >
+      <material-symbols:eye-tracking />
+    </router-link>
+    <button
+      tabindex="0"
+      class="btn btn-square btn-xs border-base-content/20 bg-base-100 border opacity-0 shadow-sm group-hover/entry:opacity-90"
+      v-else
+    >
+      <ion:ellipsis-vertical />
+    </button>
+    <ul
+      tabindex="0"
+      class="menu dropdown-content rounded-box bg-base-200 border-base-content/20 z-50 w-52 border p-1 text-sm shadow-sm"
+      @click="hideMenu"
+    >
+      <li v-if="isFiltered">
+        <router-link
+          @click="resetSearch()"
+          :to="{
+            name: '/container/[id].time.[datetime]',
+            params: { id: container.id, datetime: logEntry.date.toISOString() },
+            query: { logId: logEntry.id },
+          }"
+        >
+          <material-symbols:eye-tracking />
+          {{ $t("action.see-in-context") }}
+        </router-link>
+      </li>
+      <li>
+        <a
+          @click="copyLogMessage()"
+          :disabled="!isSupported"
+          :title="!isSupported ? $t('error.copy-not-supported') : ''"
+          :class="{ 'cursor-not-allowed opacity-50': !isSupported }"
+        >
+          <material-symbols:content-copy />
+          {{ $t("action.copy-log") }}
+        </a>
+      </li>
+      <li>
+        <a
+          @click="copyPermalink()"
+          :disabled="!isSupported"
+          :title="!isSupported ? $t('error.copy-not-supported') : ''"
+          :class="{ 'cursor-not-allowed opacity-50': !isSupported }"
+        >
+          <material-symbols:link />
+          {{ $t("action.copy-link") }}
+        </a>
+      </li>
+
+      <li v-if="logEntry instanceof ComplexLogEntry">
+        <a @click="showDrawer(LogDetails, { entry: logEntry })">
+          <material-symbols:code-blocks-rounded />
+          {{ $t("action.show-details") }}
+        </a>
+      </li>
+      <li>
+        <a @click="createAlert()">
+          <mdi:bell />
+          {{ $t("action.create-alert") }}
+        </a>
+      </li>
+    </ul>
+  </div>
+</template>
+
+<script lang="ts" setup>
+import stripAnsi from "strip-ansi";
+import { Container } from "@/models/Container";
+import { LogEntry, SimpleLogEntry, ComplexLogEntry, GroupedLogEntry, JSONObject } from "@/models/LogEntry";
+import LogDetails from "./LogDetails.vue";
+import AlertForm from "@/components/Notification/AlertForm.vue";
+
+const { logEntry, container } = defineProps<{
+  logEntry: LogEntry<string | JSONObject>;
+  container: Container;
+}>();
+
+const { showToast } = useToast();
+const showDrawer = useDrawer();
+const router = useRouter();
+const { isSearching, resetSearch } = useSearchFilter();
+const { levels } = useLoggingContext();
+
+// Show "see in context" whenever the stream is narrowed, either by a text search
+// or by a log-level filter, so the entry can be inspected in the full log stream.
+const isFiltered = computed(() => isSearching.value || allLevels.some((level) => !levels.value.has(level)));
+
+const { copy, isSupported, copied } = useClipboard({ legacy: true });
+const { t } = useI18n();
+
+async function copyLogMessage() {
+  if (!isSupported.value) {
+    return;
+  }
+
+  if (logEntry instanceof ComplexLogEntry) {
+    await copy(stripAnsi(logEntry.rawMessage));
+  } else if (logEntry instanceof SimpleLogEntry) {
+    await copy(stripAnsi(logEntry.rawMessage));
+  } else if (logEntry instanceof GroupedLogEntry) {
+    await copy(stripAnsi(logEntry.message.join("\n")));
+  }
+
+  if (copied.value) {
+    showToast(
+      {
+        title: t("toasts.copied.title"),
+        message: t("toasts.copied.message"),
+        type: "info",
+      },
+      { expire: 2000 },
+    );
+  }
+}
+
+async function copyPermalink() {
+  if (!isSupported.value) {
+    return;
+  }
+  const url = router.resolve({
+    name: "/container/[id].time.[datetime]",
+    params: { id: container.id, datetime: logEntry.date.toISOString() },
+    query: { logId: logEntry.id },
+  }).href;
+
+  const resolved = new URL(url, window.location.origin);
+
+  await copy(resolved.href);
+
+  if (copied.value) {
+    showToast(
+      {
+        title: t("toasts.copied.title"),
+        message: t("toasts.copied.message"),
+        type: "info",
+      },
+      { expire: 2000 },
+    );
+  }
+}
+
+function createAlert() {
+  const containerExpr = `name contains "${container.name}"`;
+  let logExpr = "";
+  if (logEntry.level && logEntry.level !== "unknown") {
+    logExpr = `level == "${logEntry.level}"`;
+  }
+
+  const nameParts = [container.name];
+  if (logEntry.level && logEntry.level !== "unknown") {
+    nameParts.push(logEntry.level);
+  }
+  const name = nameParts.join(" ");
+
+  showDrawer(AlertForm, { prefill: { name, containerExpression: containerExpr, logExpression: logExpr } }, "lg");
+}
+
+function hideMenu(e: MouseEvent) {
+  if (e.target instanceof HTMLAnchorElement) {
+    setTimeout(() => {
+      if (document.activeElement instanceof HTMLElement) {
+        document.activeElement.blur();
+      }
+    }, 50);
+  }
+}
+
+const dropdownRef = useTemplateRef<HTMLDivElement>("dropdownRef");
+const shouldShowBelow = ref(false);
+
+function checkDropdownPosition() {
+  if (!dropdownRef.value) return;
+
+  const rect = dropdownRef.value.getBoundingClientRect();
+  shouldShowBelow.value = rect.top < 150;
+}
+</script>

assets/components/LogViewer/LogActionsToolbar.vue

@@ -1,135 +0,0 @@
-<template>
-  <dropdown-menu class="is-right">
-    <template #trigger>
-      <button class="button" aria-haspopup="true" aria-controls="dropdown-menu">
-        <span class="icon">
-          <carbon:circle-solid class="is-red is-small" v-if="streamConfig.stderr" />
-          <carbon:circle-solid class="is-blue is-small" v-if="streamConfig.stdout" />
-        </span>
-      </button>
-    </template>
-    <a class="dropdown-item" @click="clear()">
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <octicon:trash-24 />
-          </div>
-        </div>
-        <div class="level-right">
-          <div class="level-item">{{ $t("toolbar.clear") }}</div>
-        </div>
-      </div>
-    </a>
-    <a class="dropdown-item" :href="`${base}/api/logs/download/${container.host}/${container.id}`">
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <octicon:download-24 />
-          </div>
-        </div>
-        <div class="level-right">
-          <div class="level-item">{{ $t("toolbar.download") }}</div>
-        </div>
-      </div>
-    </a>
-    <hr class="dropdown-divider" />
-    <a class="dropdown-item" @click="showSearch = true">
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <mdi:light-magnify />
-          </div>
-        </div>
-        <div class="level-right">
-          <div class="level-item">{{ $t("toolbar.search") }}</div>
-        </div>
-      </div>
-    </a>
-
-    <hr class="dropdown-divider" />
-    <a
-      class="dropdown-item"
-      @click="
-        streamConfig.stdout = true;
-        streamConfig.stderr = true;
-      "
-    >
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <template v-if="streamConfig.stderr && streamConfig.stdout">
-              <carbon:circle-solid class="is-red is-small" />
-              <carbon:circle-solid class="is-blue is-small" />
-            </template>
-          </div>
-        </div>
-        <div class="level-right">
-          {{ $t("toolbar.show-all") }}
-        </div>
-      </div>
-    </a>
-    <a
-      class="dropdown-item"
-      @click="
-        streamConfig.stdout = true;
-        streamConfig.stderr = false;
-      "
-    >
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <carbon:circle-solid class="is-blue is-small" v-if="!streamConfig.stderr && streamConfig.stdout" />
-          </div>
-        </div>
-        <div class="level-right">
-          {{ $t("toolbar.show", { std: "STDOUT" }) }}
-        </div>
-      </div>
-    </a>
-    <a
-      class="dropdown-item"
-      @click="
-        streamConfig.stdout = false;
-        streamConfig.stderr = true;
-      "
-    >
-      <div class="level is-justify-content-start">
-        <div class="level-left">
-          <div class="level-item">
-            <carbon:circle-solid class="is-red is-small" v-if="streamConfig.stderr && !streamConfig.stdout" />
-          </div>
-        </div>
-        <div class="level-right">
-          <div class="level-item">
-            {{ $t("toolbar.show", { std: "STDERR" }) }}
-          </div>
-        </div>
-      </div>
-    </a>
-  </dropdown-menu>
-</template>
-
-<script lang="ts" setup>
-import { type ComputedRef } from "vue";
-import { Container } from "@/models/Container";
-
-const { showSearch } = useSearchFilter();
-const { base } = config;
-
-const clear = defineEmit();
-
-const container = inject("container") as ComputedRef<Container>;
-const streamConfig = inject("stream-config") as { stdout: boolean; stderr: boolean };
-</script>
-
-<style lang="scss" scoped>
-.level-left .level-item {
-  width: 2.2em;
-  align-items: center;
-  margin-right: 0.5em;
-}
-
-.is-small {
-  width: 0.6em;
-}
-</style>

assets/components/LogViewer/LogAnalytics.vue

@@ -0,0 +1,310 @@
+<template>
+  <aside class="flex flex-col gap-5 pb-8">
+    <header class="flex items-center gap-3 pr-8">
+      <ph:file-sql class="text-primary size-7 shrink-0" />
+      <div class="flex min-w-0 flex-col">
+        <h1 class="text-xl leading-tight font-semibold">{{ $t("analytics.title") }}</h1>
+        <p class="text-base-content/60 flex items-center gap-1.5 text-sm">
+          <span class="truncate">{{ container.name }}</span>
+          <span class="opacity-40">·</span>
+          <RelativeTime :date="container.created" />
+        </p>
+      </div>
+    </header>
+
+    <section class="flex flex-col gap-2">
+      <textarea
+        ref="queryEl"
+        v-model="query"
+        class="textarea textarea-primary w-full resize-y font-mono text-sm leading-relaxed"
+        :class="{ 'textarea-error!': error }"
+        :disabled="state !== 'ready'"
+        rows="3"
+        spellcheck="false"
+        autocapitalize="off"
+        autocomplete="off"
+        :aria-label="$t('analytics.title')"
+        @keydown.meta.enter.prevent="run"
+        @keydown.ctrl.enter.prevent="run"
+      ></textarea>
+
+      <div class="flex min-h-6 items-center text-sm">
+        <div class="min-w-0 flex-1 truncate">
+          <span class="text-error" v-if="error">{{ error }}</span>
+          <span class="text-base-content/60 inline-flex items-center gap-2" v-else-if="state === 'initializing'">
+            <span class="loading loading-spinner loading-xs"></span>{{ $t("analytics.creating_table") }}
+          </span>
+          <span class="text-base-content/60 inline-flex items-center gap-2" v-else-if="state === 'downloading'">
+            <span class="loading loading-spinner loading-xs"></span
+            >{{ $t("analytics.downloading", { size: formatBytes(bytes, { decimals: 1 }) }) }}
+          </span>
+          <span class="text-base-content/60 inline-flex items-center gap-2" v-else-if="evaluating">
+            <span class="loading loading-spinner loading-xs"></span>{{ $t("analytics.evaluating_query") }}
+          </span>
+          <span class="text-base-content/60" v-else>
+            {{ $t("analytics.total_records", { count: results.numRows.toLocaleString() }) }}
+            <template v-if="results.numRows > pageLimit">{{
+              $t("analytics.showing_first", { count: page.numRows.toLocaleString() })
+            }}</template>
+          </span>
+        </div>
+
+        <div class="dropdown dropdown-end shrink-0" v-if="canExport">
+          <div tabindex="0" role="button" class="btn btn-xs btn-ghost cursor-pointer gap-1">
+            <ph:download-simple class="size-4" />
+            {{ $t("analytics.export") }}
+          </div>
+          <ul tabindex="0" class="dropdown-content menu bg-base-200 rounded-box z-30 w-44 p-2 shadow-sm">
+            <li>
+              <a class="cursor-pointer whitespace-nowrap" @click="exportResults('csv')">{{
+                $t("analytics.export_csv")
+              }}</a>
+            </li>
+            <li>
+              <a class="cursor-pointer whitespace-nowrap" @click="exportResults('json')">{{
+                $t("analytics.export_json")
+              }}</a>
+            </li>
+          </ul>
+        </div>
+      </div>
+    </section>
+
+    <section v-if="state === 'ready' && columns.length" class="flex flex-col gap-2 text-xs">
+      <div class="flex flex-wrap items-center gap-x-2 gap-y-1">
+        <span class="text-base-content/50 font-medium">{{ $t("analytics.examples") }}</span>
+        <button
+          v-for="ex in examples"
+          :key="ex.key"
+          class="badge badge-sm badge-outline hover:border-primary hover:text-primary cursor-pointer"
+          @click="applyExample(ex.sql)"
+        >
+          {{ $t(ex.key, ex.params ?? {}) }}
+        </button>
+      </div>
+
+      <details class="group">
+        <summary
+          class="text-base-content/50 hover:text-base-content/80 flex w-fit cursor-pointer items-center gap-1 font-medium select-none"
+        >
+          <ph:caret-right class="size-3 transition-transform group-open:rotate-90" />
+          {{ $t("analytics.columns") }}
+          <span class="opacity-60">{{ columns.length }}</span>
+        </summary>
+        <div class="mt-2 flex max-h-40 flex-wrap gap-1.5 overflow-y-auto">
+          <button
+            v-for="col in columns"
+            :key="col.name"
+            class="badge badge-sm badge-ghost hover:border-primary hover:text-primary cursor-pointer font-mono"
+            :title="col.type"
+            @click="insertColumn(col.name)"
+          >
+            {{ col.name }}
+          </button>
+        </div>
+      </details>
+    </section>
+
+    <SQLTable :table="page" :loading="evaluating || state !== 'ready'" />
+  </aside>
+</template>
+
+<script setup lang="ts">
+import { Container } from "@/models/Container";
+import { type Table } from "@apache-arrow/esnext-esm";
+
+const { container } = defineProps<{ container: Container }>();
+const query = ref("SELECT * FROM logs LIMIT 100");
+const error = ref<string | null>(null);
+const evaluating = ref(false);
+const pageLimit = 1000;
+const state = ref<"downloading" | "ready" | "initializing">("downloading");
+const bytes = ref(0);
+const columns = ref<{ name: string; type: string }[]>([]);
+const queryEl = useTemplateRef<HTMLTextAreaElement>("queryEl");
+
+const runQuery = ref(query.value);
+watchDebounced(query, (v) => (runQuery.value = v), { debounce: 500 });
+
+const url = withBase(
+  `/api/hosts/${container.host}/containers/${container.id}/logs?stdout=1&stderr=1&everything&jsonOnly`,
+);
+
+const [{ useDuckDB }, response] = await Promise.all([import(`@/composable/duckdb`), fetch(url)]);
+
+if (!response.ok) {
+  console.log("error fetching logs from", url);
+  throw new Error(`Failed to fetch logs: ${response.statusText}`);
+}
+
+const { db, conn } = await useDuckDB();
+const empty = await conn.query<Record<string, any>>(`SELECT 1 LIMIT 0`);
+
+onMounted(async () => {
+  try {
+    state.value = "downloading";
+
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error("No reader available from stream");
+
+    const chunks: Uint8Array[] = [];
+    bytes.value = 0;
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      bytes.value += value.length;
+    }
+
+    const arrayBuffer = new Uint8Array(bytes.value);
+    let position = 0;
+    for (const chunk of chunks) {
+      arrayBuffer.set(chunk, position);
+      position += chunk.length;
+    }
+
+    await db.registerFileBuffer("logs.json", arrayBuffer);
+
+    state.value = "initializing";
+    await conn.query(
+      `CREATE TABLE logs AS SELECT unnest(m) FROM read_json('logs.json', ignore_errors = true, format = 'newline_delimited', map_inference_threshold = -1)`,
+    );
+
+    const described = await conn.query<{ column_name: any; column_type: any }>(`DESCRIBE logs`);
+    columns.value = described.toArray().map((row) => ({
+      name: String(row.column_name),
+      type: String(row.column_type),
+    }));
+
+    state.value = "ready";
+  } catch (e) {
+    console.error(e);
+    if (e instanceof Error) {
+      error.value = e.message;
+    }
+  }
+});
+
+const examples = computed(() => {
+  const names = columns.value.map((c) => c.name);
+  const pick = ["level", "severity", "lvl", "status"].find((c) => names.includes(c)) ?? names[0];
+  const list: { key: string; sql: string; params?: Record<string, string> }[] = [
+    { key: "analytics.example_all", sql: "SELECT * FROM logs LIMIT 100" },
+    { key: "analytics.example_count", sql: "SELECT count(*) AS total FROM logs" },
+  ];
+  if (pick) {
+    list.push({
+      key: "analytics.example_group",
+      params: { column: pick },
+      sql: `SELECT "${pick}", count(*) AS count FROM logs GROUP BY "${pick}" ORDER BY count DESC`,
+    });
+  }
+  return list;
+});
+
+function run() {
+  if (state.value !== "ready") return;
+  runQuery.value = query.value;
+}
+
+function applyExample(sql: string) {
+  query.value = sql;
+  nextTick(run);
+}
+
+function insertColumn(name: string) {
+  const text = `"${name}"`;
+  const el = queryEl.value;
+  if (!el) {
+    query.value += text;
+    return;
+  }
+  const start = el.selectionStart ?? query.value.length;
+  const end = el.selectionEnd ?? start;
+  query.value = query.value.slice(0, start) + text + query.value.slice(end);
+  nextTick(() => {
+    el.focus();
+    const pos = start + text.length;
+    el.setSelectionRange(pos, pos);
+  });
+}
+
+const results = computedAsync(
+  async () => {
+    if (state.value === "ready") {
+      return await conn.query<Record<string, any>>(runQuery.value);
+    } else {
+      return empty;
+    }
+  },
+  empty,
+  {
+    onError: (e) => {
+      console.error(e);
+      if (e instanceof Error) {
+        error.value = e.message;
+      }
+    },
+    evaluating,
+  },
+);
+
+whenever(evaluating, () => {
+  error.value = null;
+  state.value = "ready";
+});
+const page = computed(() =>
+  results.value.numRows > pageLimit ? results.value.slice(0, pageLimit) : results.value,
+) as unknown as ComputedRef<Table<Record<string, any>>>;
+
+const canExport = computed(() => state.value === "ready" && !evaluating.value && results.value.numRows > 0);
+
+function stringify(value: unknown): string {
+  if (value === null || value === undefined) return "";
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "object") return JSON.stringify(value, (_, v) => (typeof v === "bigint" ? v.toString() : v));
+  return String(value);
+}
+
+function toCSV(table: Table<Record<string, any>>, columns: string[]): string {
+  const escape = (value: string) => (/[",\n\r]/.test(value) ? `"${value.replaceAll('"', '""')}"` : value);
+  const lines = [columns.map(escape).join(",")];
+  for (const row of table) {
+    lines.push(columns.map((column) => escape(stringify((row as Record<string, any>)[column]))).join(","));
+  }
+  return lines.join("\n");
+}
+
+function toJSON(table: Table<Record<string, any>>, columns: string[]): string {
+  const rows = [];
+  for (const row of table) {
+    const record: Record<string, unknown> = {};
+    for (const column of columns) {
+      const value = (row as Record<string, any>)[column];
+      record[column] = typeof value === "bigint" ? value.toString() : value;
+    }
+    rows.push(record);
+  }
+  return JSON.stringify(rows, null, 2);
+}
+
+function exportResults(format: "csv" | "json") {
+  const table = results.value as unknown as Table<Record<string, any>>;
+  if (table.numRows === 0) return;
+
+  const columns = Object.keys(table.get(0) as Record<string, any>);
+  const content = format === "csv" ? toCSV(table, columns) : toJSON(table, columns);
+  const type = format === "csv" ? "text/csv;charset=utf-8" : "application/json";
+  const name = container.name.replace(/[^\w.-]+/g, "-");
+
+  const url = URL.createObjectURL(new Blob([content], { type }));
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = `${name}-query.${format}`;
+  link.click();
+  URL.revokeObjectURL(url);
+  (document.activeElement as HTMLElement | null)?.blur();
+}
+</script>
+<style scoped></style>

assets/components/LogViewer/LogContainer.vue

@@ -1,71 +0,0 @@
-<template>
-  <scrollable-view :scrollable="scrollable" v-if="container">
-    <template #header v-if="showTitle">
-      <div class="mr-0 columns is-mobile is-vcentered is-marginless has-boxshadow">
-        <div class="column is-clipped is-paddingless">
-          <container-title @close="$emit('close')" />
-        </div>
-        <div class="column is-narrow is-paddingless">
-          <container-stat />
-        </div>
-
-        <div class="mr-2 column is-narrow is-paddingless is-hidden-mobile">
-          <log-actions-toolbar @clear="onClearClicked()" />
-        </div>
-        <div class="mr-2 column is-narrow is-paddingless" v-if="closable">
-          <button class="delete is-medium" @click="close()"></button>
-        </div>
-      </div>
-    </template>
-    <template #default="{ setLoading }">
-      <log-viewer-with-source ref="viewer" @loading-more="setLoading($event)" />
-    </template>
-  </scrollable-view>
-</template>
-
-<script lang="ts" setup>
-import LogViewerWithSource from "./LogViewerWithSource.vue";
-
-const {
-  id,
-  showTitle = false,
-  scrollable = false,
-  closable = false,
-} = defineProps<{
-  id: string;
-  showTitle?: boolean;
-  scrollable?: boolean;
-  closable?: boolean;
-}>();
-
-const close = defineEmit();
-
-const store = useContainerStore();
-
-const container = store.currentContainer($$(id));
-const config = reactive({ stdout: true, stderr: true });
-
-provide("container", container);
-provide("stream-config", config);
-
-const viewer = ref<InstanceType<typeof LogViewerWithSource>>();
-
-function onClearClicked() {
-  viewer.value?.clear();
-}
-</script>
-<style lang="scss" scoped>
-button.delete {
-  background-color: var(--scheme-main-ter);
-  opacity: 0.6;
-
-  &:after,
-  &:before {
-    background-color: var(--text-color);
-  }
-
-  &:hover {
-    opacity: 1;
-  }
-}
-</style>

assets/components/LogViewer/LogDate.vue

@@ -1,19 +1,10 @@
 <template>
-  <date-time :date="date" class="date"></date-time>
+  <Tag class="items-start!">
+    <DateTime :date="date" class="text-blue whitespace-nowrap" />
+  </Tag>
 </template>
 <script lang="ts" setup>
 defineProps<{
   date: Date;
 }>();
 </script>
-
-<style lang="scss" scoped>
-.date {
-  padding-left: 5px;
-  padding-right: 5px;
-  border-radius: 3px;
-  white-space: nowrap;
-  background-color: var(--scheme-main-ter);
-  color: #258ccd;
-}
-</style>

assets/components/LogViewer/LogDetails.vue

@@ -0,0 +1,160 @@
+<template>
+  <header class="flex items-center gap-4">
+    <Tag :data-level="entry.level" class="show-unknown text-white uppercase" v-if="entry.level">{{ entry.level }}</Tag>
+    <h1 class="text-lg max-md:hidden">
+      <DateTime :date="entry.date" />
+    </h1>
+    <h2 class="text-sm"><RelativeTime :date="entry.date" /> on {{ entry.std }}</h2>
+  </header>
+
+  <div class="mt-8 flex flex-col gap-10">
+    <section class="grid grid-cols-3 gap-2">
+      <div>
+        <div class="font-thin">Container Name</div>
+        <div class="truncate text-lg font-bold">{{ container.name }}</div>
+      </div>
+      <div>
+        <div class="font-thin">Host</div>
+        <div class="truncate text-lg font-bold">
+          {{ hosts[container.host].name }}
+        </div>
+      </div>
+      <div>
+        <div class="font-thin">Image</div>
+        <div class="truncate text-lg font-bold">{{ container.image }}</div>
+      </div>
+    </section>
+
+    <section class="flex flex-col gap-2">
+      <div class="flex gap-2">
+        Raw JSON
+
+        <UseClipboard v-slot="{ copy, copied }" :source="entry.rawMessage">
+          <button class="swap outline-hidden" @click="copy()" :class="{ 'hover:swap-active': copied }">
+            <mdi:check class="swap-on" />
+            <material-symbols:content-copy class="swap-off" />
+          </button>
+        </UseClipboard>
+      </div>
+      <div class="bg-base-200 max-h-125 overflow-scroll rounded-sm border border-white/20 p-2">
+        <JsonFormatted :value="entry.rawMessage" class="text-sm" />
+      </div>
+    </section>
+    <table class="table-pin-rows table table-fixed" v-if="entry instanceof ComplexLogEntry">
+      <caption class="caption-bottom">
+        Fields are sortable by dragging and dropping.
+      </caption>
+      <thead class="text-lg">
+        <tr>
+          <th class="w-60">Field</th>
+          <th class="max-md:hidden">Value</th>
+          <th class="w-20">
+            <input type="checkbox" class="toggle toggle-primary" v-model="toggleAllFields" title="Toggle all" />
+          </th>
+        </tr>
+      </thead>
+      <tbody ref="list">
+        <tr v-for="{ key, value, enabled } in fields" :key="key.join('.')" class="hover">
+          <td class="cursor-move font-mono break-all">
+            {{ key.join(".") }}
+          </td>
+          <td class="truncate max-md:hidden">
+            <code>{{ JSON.stringify(value) }}</code>
+          </td>
+          <td>
+            <input type="checkbox" class="toggle toggle-primary" :checked="enabled" @change="toggleField(key)" />
+          </td>
+        </tr>
+      </tbody>
+    </table>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { ComplexLogEntry } from "@/models/LogEntry";
+import { UseClipboard } from "@vueuse/components";
+
+const { entry } = defineProps<{ entry: ComplexLogEntry }>();
+const { currentContainer } = useContainerStore();
+const list = ref<HTMLElement>();
+const container = currentContainer(toRef(() => entry.containerID));
+const visibleKeys = persistentVisibleKeysForContainer(container);
+const { hosts } = useHosts();
+
+const { useSortable } = await import("@vueuse/integrations/useSortable");
+
+function toggleField(key: string[]) {
+  if (visibleKeys.value.size === 0) {
+    visibleKeys.value = new Map<string[], boolean>(fields.value.map(({ key }) => [key, true]));
+  }
+
+  const enabled = visibleKeys.value.get(key) ?? true;
+
+  visibleKeys.value.set(key, !enabled);
+}
+
+const fields = computed({
+  get() {
+    const fieldsWithValue: { key: string[]; value: any; enabled: boolean }[] = [];
+    const rawFields = JSON.parse(entry.rawMessage);
+    const allFields = flattenJSONToMap(rawFields);
+    if (visibleKeys.value.size === 0) {
+      for (const [key, value] of allFields) {
+        fieldsWithValue.push({ key, value, enabled: true });
+      }
+    } else {
+      for (const [key, enabled] of visibleKeys.value) {
+        const value = getDeep(rawFields, key);
+        fieldsWithValue.push({ key, value, enabled });
+      }
+
+      for (const [key, value] of allFields) {
+        if ([...visibleKeys.value.keys()].findIndex((k) => arrayEquals(k, key)) === -1) {
+          fieldsWithValue.push({ key, value, enabled: true });
+        }
+      }
+    }
+
+    return fieldsWithValue;
+  },
+  set(value) {
+    const map = new Map<string[], boolean>();
+    for (const { key, enabled } of value) {
+      map.set(key, enabled);
+    }
+    visibleKeys.value = map;
+  },
+});
+
+const toggleAllFields = computed({
+  get: () => fields.value.every(({ enabled }) => enabled),
+  set(value) {
+    if (visibleKeys.value.size === 0) {
+      visibleKeys.value = new Map<string[], boolean>(fields.value.map(({ key }) => [key, true]));
+    }
+    for (const key of visibleKeys.value.keys()) {
+      visibleKeys.value.set(key, value);
+    }
+
+    for (const field of fields.value) {
+      visibleKeys.value.set(field.key, value);
+    }
+  },
+});
+
+useSortable(list, fields);
+</script>
+<style scoped>
+@reference "@/main.css";
+.font-mono {
+  font-family:
+    ui-monospace,
+    SFMono-Regular,
+    SF Mono,
+    Consolas,
+    Liberation Mono,
+    monaco,
+    Menlo,
+    monospace;
+}
+</style>

assets/components/LogViewer/LogEventSource.spec.ts

@@ -1,206 +0,0 @@
-import { mount } from "@vue/test-utils";
-import { createTestingPinia } from "@pinia/testing";
-// @ts-ignore
-import EventSource, { sources } from "eventsourcemock";
-import LogEventSource from "./LogEventSource.vue";
-import LogViewer from "./LogViewer.vue";
-import { settings } from "../../composables/settings";
-import { useSearchFilter } from "@/composables/search";
-import { vi, describe, expect, beforeEach, test, afterEach } from "vitest";
-import { computed, nextTick } from "vue";
-import { createRouter, createWebHistory } from "vue-router";
-
-vi.mock("@/stores/config", () => ({
-  __esModule: true,
-  default: { base: "", hosts: ["localhost"] },
-}));
-
-/**
- * @vitest-environment jsdom
- */
-describe("<LogEventSource />", () => {
-  const search = useSearchFilter();
-
-  beforeEach(() => {
-    global.EventSource = EventSource;
-    // @ts-ignore
-    window.scrollTo = vi.fn();
-    global.IntersectionObserver = vi.fn().mockImplementation(() => ({
-      observe: vi.fn(),
-      disconnect: vi.fn(),
-    }));
-    vi.useFakeTimers();
-    vi.setSystemTime(1560336942459);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-    vi.useRealTimers();
-  });
-
-  function createLogEventSource(
-    {
-      searchFilter = "",
-      hourStyle = "auto",
-    }: { searchFilter?: string | undefined; hourStyle?: "auto" | "24" | "12" } = {
-      hourStyle: "auto",
-    },
-  ) {
-    settings.value.hourStyle = hourStyle;
-    search.searchFilter.value = searchFilter;
-    if (searchFilter) {
-      search.showSearch.value = true;
-    }
-
-    const router = createRouter({
-      history: createWebHistory("/"),
-      routes: [
-        {
-          path: "/",
-          component: {
-            template: "Test from createLogEventSource",
-          },
-        },
-      ],
-    });
-
-    return mount(LogEventSource, {
-      global: {
-        plugins: [router, createTestingPinia({ createSpy: vi.fn })],
-        components: {
-          LogViewer,
-        },
-        provide: {
-          container: computed(() => ({ id: "abc", image: "test:v123", host: "localhost" })),
-          "stream-config": reactive({ stdout: true, stderr: true }),
-          scrollingPaused: computed(() => false),
-        },
-      },
-      slots: {
-        default: `
-        <template #scoped="params"><log-viewer :messages="params.messages"></log-viewer></template>
-        `,
-      },
-      props: {},
-    });
-  }
-
-  const sourceUrl = "/api/logs/stream/localhost/abc?lastEventId=&stdout=1&stderr=1";
-
-  test("renders correctly", async () => {
-    const wrapper = createLogEventSource();
-    expect(wrapper.html()).toMatchSnapshot();
-  });
-
-  test("should connect to EventSource", async () => {
-    const wrapper = createLogEventSource();
-    sources[sourceUrl].emitOpen();
-    expect(sources[sourceUrl].readyState).toBe(1);
-    wrapper.unmount();
-  });
-
-  test("should close EventSource", async () => {
-    const wrapper = createLogEventSource();
-    sources[sourceUrl].emitOpen();
-    wrapper.unmount();
-    expect(sources[sourceUrl].readyState).toBe(2);
-  });
-
-  test("should parse messages", async () => {
-    const wrapper = createLogEventSource();
-    sources[sourceUrl].emitOpen();
-    sources[sourceUrl].emitMessage({
-      data: `{"ts":1560336942459, "m":"This is a message.", "id":1}`,
-    });
-
-    vi.runAllTimers();
-    await nextTick();
-
-    // @ts-ignore
-    const [message, _] = wrapper.vm.messages;
-    expect(message).toMatchSnapshot();
-  });
-
-  describe("render html correctly", () => {
-    test("should render messages", async () => {
-      const wrapper = createLogEventSource();
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"This is a message.", "id":1}`,
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-
-    test("should render messages with color", async () => {
-      const wrapper = createLogEventSource();
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: '{"ts":1560336942459,"m":"\\u001b[30mblack\\u001b[37mwhite", "id":1}',
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-
-    test("should render messages with html entities", async () => {
-      const wrapper = createLogEventSource();
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"<test>foo bar</test>", "id":1}`,
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-
-    test("should render dates with 12 hour style", async () => {
-      const wrapper = createLogEventSource({ hourStyle: "12" });
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"<test>foo bar</test>", "id":1}`,
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-
-    test("should render dates with 24 hour style", async () => {
-      const wrapper = createLogEventSource({ hourStyle: "24" });
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"<test>foo bar</test>", "id":1}`,
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-
-    test("should render messages with filter", async () => {
-      const wrapper = createLogEventSource({ searchFilter: "test" });
-      sources[sourceUrl].emitOpen();
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"foo bar", "id":1}`,
-      });
-      sources[sourceUrl].emitMessage({
-        data: `{"ts":1560336942459, "m":"test bar", "id":2}`,
-      });
-
-      vi.runAllTimers();
-      await nextTick();
-
-      expect(wrapper.find("ul.events").html()).toMatchSnapshot();
-    });
-  });
-});

assets/components/LogViewer/LogEventSource.vue

@@ -1,24 +0,0 @@
-<template>
-  <infinite-loader :onLoadMore="fetchMore" :enabled="messages.length > 100"></infinite-loader>
-  <slot :messages="messages"></slot>
-</template>
-
-<script lang="ts" setup>
-import { Container } from "@/models/Container";
-import { type ComputedRef } from "vue";
-
-const loadingMore = defineEmit<[value: boolean]>();
-
-const container = inject("container") as ComputedRef<Container>;
-const config = inject("stream-config") as { stdout: boolean; stderr: boolean };
-const { messages, loadOlderLogs } = useLogStream(container, config);
-
-const beforeLoading = () => loadingMore(true);
-const afterLoading = () => loadingMore(false);
-
-defineExpose({
-  clear: () => (messages.value = []),
-});
-
-const fetchMore = () => loadOlderLogs({ beforeLoading, afterLoading });
-</script>

assets/components/LogViewer/LogItem.vue

@@ -0,0 +1,35 @@
+<template>
+  <div class="relative flex w-full items-start gap-x-2 group-[.compact]:items-stretch">
+    <LogActions :logEntry :container />
+
+    <LogStd :std="logEntry.std" class="shrink-0 select-none" v-if="showStd" />
+
+    <div class="flex gap-x-2 gap-y-1 group-[.compact]:gap-y-0 has-[>_*:nth-of-type(2)]:flex-col-reverse md:flex-row!">
+      <RandomColorTag class="w-30 shrink-0 select-none md:w-40" :value="host.name" v-if="showHostname" />
+      <RandomColorTag
+        v-if="showContainerName"
+        class="w-30 shrink-0 select-none group-[.compact]:flex-1 md:w-40"
+        :value="container.id"
+        truncateRight
+      >
+        {{ container.name }}
+      </RandomColorTag>
+      <LogDate v-if="showTimestamp" :date="logEntry.date" class="shrink-0 select-none" />
+    </div>
+    <slot />
+  </div>
+</template>
+<script lang="ts" setup>
+import { LogEntry } from "@/models/LogEntry";
+
+const { logEntry } = defineProps<{
+  logEntry: LogEntry<any>;
+}>();
+const { showHostname, showContainerName } = useLoggingContext();
+
+const { currentContainer } = useContainerStore();
+const { hosts } = useHosts();
+
+const container = currentContainer(toRef(() => logEntry.containerID));
+const host = computed(() => hosts.value[container.value.host]);
+</script>

assets/components/LogViewer/LogLevel.vue

@@ -1,63 +1,69 @@
 <template>
-  <div :class="level" :data-position="position"></div>
+  <div
+    :data-level="level"
+    :data-position="position"
+    class="mt-1.5 size-2.5 flex-none rounded-lg"
+    :class="{ showUnknown }"
+  ></div>
 </template>
 <script lang="ts" setup>
-import { Position } from "@/models/LogEntry";
+import { Position, Level } from "@/models/LogEntry";
 
-defineProps<{
-  level?: string;
+const {
+  level,
+  position,
+  showUnknown = false,
+} = defineProps<{
+  level?: Level;
   position?: Position;
+  showUnknown?: boolean;
 }>();
 </script>
 
-<style lang="scss" scoped>
-div {
-  display: inline-block;
-  width: 0.7em;
-  height: 0.7em;
-  border-radius: 0.5em;
-  align-self: auto;
-  margin-top: 0.4em;
+<style scoped>
+@reference "@/main.css";
+[data-position="start"],
+[data-position="middle"],
+[data-position="end"] {
+  align-self: stretch;
+  height: auto;
+}
 
-  &[data-position="start"] {
-    border-radius: 0.5em 0.5em 0 0;
-    height: 70%;
-    margin-bottom: -0.2em;
-    margin-top: auto;
-    align-self: flex-end;
-  }
+[data-position="start"] {
+  border-radius: 0.375rem 0.375rem 0 0;
+}
 
-  &[data-position="middle"] {
-    border-radius: 0;
-    height: auto;
-    margin: -0.2em 0;
-    align-self: auto;
-  }
+[data-position="middle"] {
+  border-radius: 0;
+  margin-top: 0;
+}
 
-  &[data-position="end"] {
-    border-radius: 0 0 0.5em 0.5em;
-    height: 70%;
-    margin-top: -0.2em;
-    align-self: flex-start;
-  }
-
-  &.debug,
-  &.trace {
-    background-color: var(--purple-color);
-  }
-
-  &.info {
-    background-color: var(--green-color);
-  }
-
-  &.error,
-  &.fatal {
-    background-color: var(--red-color);
-  }
-
-  &.warn,
-  &.warning {
-    background-color: var(--orange-color);
-  }
+[data-position="end"] {
+  border-radius: 0 0 0.375rem 0.375rem;
+  margin-top: 0;
+}
+</style>
+<style>
+@reference "@/main.css";
+[data-level="debug"],
+[data-level="trace"] {
+  @apply !bg-purple;
+}
+
+[data-level="info"] {
+  @apply !bg-green;
+}
+
+[data-level="error"],
+[data-level="fatal"] {
+  @apply !bg-red;
+}
+
+[data-level="warn"] {
+  @apply !bg-orange;
+}
+
+[data-level="unknown"].show-unknown {
+  @apply !bg-base-300;
 }
 </style>