feat: wire up application logs from OpenSearch, fix event autoscroll

Add GET /api/v1/logs endpoint to query application logs stored in
OpenSearch with filters for application, agent, level, time range,
and text search. Wire up the AgentInstance LogViewer with real data
and an EventFeed-style toolbar (search input + level filter pills).

Fix agent events timeline autoscroll by reversing the DESC-ordered
events so newest entries appear at the bottom where EventFeed
autoscrolls to.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

cameleer3-server-app/src/main/java/com/cameleer3/server/app/controller/LogQueryController.java

@@ -0,0 +1,49 @@
+package com.cameleer3.server.app.controller;
+
+import com.cameleer3.server.app.dto.LogEntryResponse;
+import com.cameleer3.server.app.search.OpenSearchLogIndex;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.time.Instant;
+import java.util.List;
+
+@RestController
+@RequestMapping("/api/v1/logs")
+@Tag(name = "Application Logs", description = "Query application logs stored in OpenSearch")
+public class LogQueryController {
+
+    private final OpenSearchLogIndex logIndex;
+
+    public LogQueryController(OpenSearchLogIndex logIndex) {
+        this.logIndex = logIndex;
+    }
+
+    @GetMapping
+    @Operation(summary = "Search application log entries",
+            description = "Returns log entries for a given application, optionally filtered by agent, level, time range, and text query")
+    public ResponseEntity<List<LogEntryResponse>> searchLogs(
+            @RequestParam String application,
+            @RequestParam(required = false) String agentId,
+            @RequestParam(required = false) String level,
+            @RequestParam(required = false) String query,
+            @RequestParam(required = false) String from,
+            @RequestParam(required = false) String to,
+            @RequestParam(defaultValue = "200") int limit) {
+
+        limit = Math.min(limit, 1000);
+
+        Instant fromInstant = from != null ? Instant.parse(from) : null;
+        Instant toInstant = to != null ? Instant.parse(to) : null;
+
+        List<LogEntryResponse> entries = logIndex.search(
+                application, agentId, level, query, fromInstant, toInstant, limit);
+
+        return ResponseEntity.ok(entries);
+    }
+}

cameleer3-server-app/src/main/java/com/cameleer3/server/app/dto/LogEntryResponse.java

@@ -0,0 +1,13 @@
+package com.cameleer3.server.app.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+
+@Schema(description = "Application log entry from OpenSearch")
+public record LogEntryResponse(
+        @Schema(description = "Log timestamp (ISO-8601)") String timestamp,
+        @Schema(description = "Log level (INFO, WARN, ERROR, DEBUG)") String level,
+        @Schema(description = "Logger name") String loggerName,
+        @Schema(description = "Log message") String message,
+        @Schema(description = "Thread name") String threadName,
+        @Schema(description = "Stack trace (if present)") String stackTrace
+) {}

cameleer3-server-app/src/main/java/com/cameleer3/server/app/search/OpenSearchLogIndex.java

@@ -1,9 +1,15 @@
 package com.cameleer3.server.app.search;
 
 import com.cameleer3.common.model.LogEntry;
+import com.cameleer3.server.app.dto.LogEntryResponse;
 import jakarta.annotation.PostConstruct;
+import org.opensearch.client.json.JsonData;
 import org.opensearch.client.opensearch.OpenSearchClient;
+import org.opensearch.client.opensearch._types.FieldValue;
+import org.opensearch.client.opensearch._types.SortOrder;
 import org.opensearch.client.opensearch._types.mapping.Property;
+import org.opensearch.client.opensearch._types.query_dsl.BoolQuery;
+import org.opensearch.client.opensearch._types.query_dsl.Query;
 import org.opensearch.client.opensearch.core.BulkRequest;
 import org.opensearch.client.opensearch.core.BulkResponse;
 import org.opensearch.client.opensearch.core.bulk.BulkResponseItem;
@@ -15,8 +21,10 @@ import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Repository;
 
 import java.io.IOException;
+import java.time.Instant;
 import java.time.ZoneOffset;
 import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -91,6 +99,60 @@ public class OpenSearchLogIndex {
         }
     }
 
+    public List<LogEntryResponse> search(String application, String agentId, String level,
+                                           String query, Instant from, Instant to, int limit) {
+        try {
+            BoolQuery.Builder bool = new BoolQuery.Builder();
+            bool.must(Query.of(q -> q.term(t -> t.field("application").value(FieldValue.of(application)))));
+            if (agentId != null && !agentId.isEmpty()) {
+                bool.must(Query.of(q -> q.term(t -> t.field("agentId").value(FieldValue.of(agentId)))));
+            }
+            if (level != null && !level.isEmpty()) {
+                bool.must(Query.of(q -> q.term(t -> t.field("level").value(FieldValue.of(level.toUpperCase())))));
+            }
+            if (query != null && !query.isEmpty()) {
+                bool.must(Query.of(q -> q.match(m -> m.field("message").query(FieldValue.of(query)))));
+            }
+            if (from != null || to != null) {
+                bool.must(Query.of(q -> q.range(r -> {
+                    r.field("@timestamp");
+                    if (from != null) r.gte(JsonData.of(from.toString()));
+                    if (to != null) r.lte(JsonData.of(to.toString()));
+                    return r;
+                })));
+            }
+
+            var response = client.search(s -> s
+                    .index(indexPrefix + "*")
+                    .query(Query.of(q -> q.bool(bool.build())))
+                    .sort(so -> so.field(f -> f.field("@timestamp").order(SortOrder.Desc)))
+                    .size(limit), Map.class);
+
+            List<LogEntryResponse> results = new ArrayList<>();
+            for (var hit : response.hits().hits()) {
+                @SuppressWarnings("unchecked")
+                Map<String, Object> src = (Map<String, Object>) hit.source();
+                if (src == null) continue;
+                results.add(new LogEntryResponse(
+                        str(src, "@timestamp"),
+                        str(src, "level"),
+                        str(src, "loggerName"),
+                        str(src, "message"),
+                        str(src, "threadName"),
+                        str(src, "stackTrace")));
+            }
+            return results;
+        } catch (IOException e) {
+            log.error("Failed to search log entries for application={}", application, e);
+            return List.of();
+        }
+    }
+
+    private static String str(Map<String, Object> map, String key) {
+        Object v = map.get(key);
+        return v != null ? v.toString() : null;
+    }
+
     public void indexBatch(String agentId, String application, List<LogEntry> entries) {
         if (entries == null || entries.isEmpty()) {
             return;