loki-mode 5.7.2 → 5.7.3

package/api/server.ts

@@ -0,0 +1,328 @@
+/**
+ * Loki Mode API Server
+ *
+ * HTTP/SSE server for loki-mode remote control and monitoring.
+ *
+ * Usage:
+ *   deno run --allow-net --allow-read --allow-write --allow-env --allow-run api/server.ts
+ *
+ * Or via CLI:
+ *   loki serve [--port 8420] [--host localhost]
+ */
+
+import { stateWatcher } from "./services/state-watcher.ts";
+import { corsMiddleware } from "./middleware/cors.ts";
+import { authMiddleware } from "./middleware/auth.ts";
+import { errorMiddleware } from "./middleware/error.ts";
+import { LokiApiError, ErrorCodes } from "./middleware/error.ts";
+
+// Import routes
+import {
+  startSession,
+  listSessions,
+  getSession,
+  stopSession,
+  pauseSession,
+  resumeSession,
+  injectInput,
+  deleteSession,
+} from "./routes/sessions.ts";
+import {
+  listTasks,
+  getTask,
+  listAllTasks,
+  getActiveTasks,
+  getQueuedTasks,
+} from "./routes/tasks.ts";
+import {
+  streamEvents,
+  getEventHistory,
+  getEventStats,
+} from "./routes/events.ts";
+import {
+  healthCheck,
+  readinessCheck,
+  livenessCheck,
+  detailedStatus,
+} from "./routes/health.ts";
+
+// Server configuration
+interface ServerConfig {
+  port: number;
+  host: string;
+  cors: boolean;
+  auth: boolean;
+}
+
+const defaultConfig: ServerConfig = {
+  port: parseInt(Deno.env.get("LOKI_API_PORT") || "8420", 10),
+  host: Deno.env.get("LOKI_API_HOST") || "localhost",
+  cors: true,
+  auth: true,
+};
+
+/**
+ * Route handler type
+ */
+type RouteHandler = (
+  req: Request,
+  ...params: string[]
+) => Promise<Response> | Response;
+
+/**
+ * Route definition
+ */
+interface Route {
+  method: string;
+  pattern: RegExp;
+  handler: RouteHandler;
+}
+
+/**
+ * Define all routes
+ */
+const routes: Route[] = [
+  // Health endpoints (no auth required)
+  { method: "GET", pattern: /^\/health$/, handler: healthCheck },
+  { method: "GET", pattern: /^\/health\/ready$/, handler: readinessCheck },
+  { method: "GET", pattern: /^\/health\/live$/, handler: livenessCheck },
+
+  // Status endpoint
+  { method: "GET", pattern: /^\/api\/status$/, handler: detailedStatus },
+
+  // Session endpoints
+  { method: "POST", pattern: /^\/api\/sessions$/, handler: startSession },
+  { method: "GET", pattern: /^\/api\/sessions$/, handler: listSessions },
+  {
+    method: "GET",
+    pattern: /^\/api\/sessions\/([^/]+)$/,
+    handler: getSession,
+  },
+  {
+    method: "POST",
+    pattern: /^\/api\/sessions\/([^/]+)\/stop$/,
+    handler: stopSession,
+  },
+  {
+    method: "POST",
+    pattern: /^\/api\/sessions\/([^/]+)\/pause$/,
+    handler: pauseSession,
+  },
+  {
+    method: "POST",
+    pattern: /^\/api\/sessions\/([^/]+)\/resume$/,
+    handler: resumeSession,
+  },
+  {
+    method: "POST",
+    pattern: /^\/api\/sessions\/([^/]+)\/input$/,
+    handler: injectInput,
+  },
+  {
+    method: "DELETE",
+    pattern: /^\/api\/sessions\/([^/]+)$/,
+    handler: deleteSession,
+  },
+
+  // Task endpoints
+  { method: "GET", pattern: /^\/api\/tasks$/, handler: listAllTasks },
+  { method: "GET", pattern: /^\/api\/tasks\/active$/, handler: getActiveTasks },
+  { method: "GET", pattern: /^\/api\/tasks\/queue$/, handler: getQueuedTasks },
+  {
+    method: "GET",
+    pattern: /^\/api\/sessions\/([^/]+)\/tasks$/,
+    handler: listTasks,
+  },
+  {
+    method: "GET",
+    pattern: /^\/api\/sessions\/([^/]+)\/tasks\/([^/]+)$/,
+    handler: getTask,
+  },
+
+  // Event endpoints
+  { method: "GET", pattern: /^\/api\/events$/, handler: streamEvents },
+  {
+    method: "GET",
+    pattern: /^\/api\/events\/history$/,
+    handler: getEventHistory,
+  },
+  { method: "GET", pattern: /^\/api\/events\/stats$/, handler: getEventStats },
+];
+
+/**
+ * Route a request to the appropriate handler
+ */
+async function routeRequest(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  const path = url.pathname;
+  const method = req.method;
+
+  // Find matching route
+  for (const route of routes) {
+    if (route.method !== method && method !== "OPTIONS") {
+      continue;
+    }
+
+    const match = path.match(route.pattern);
+    if (match) {
+      // Extract path parameters
+      const params = match.slice(1);
+      return route.handler(req, ...params);
+    }
+  }
+
+  // No route matched
+  throw new LokiApiError(
+    `No route found for ${method} ${path}`,
+    ErrorCodes.NOT_FOUND
+  );
+}
+
+/**
+ * Create the main request handler with middleware
+ */
+function createHandler(config: ServerConfig): Deno.ServeHandler {
+  let handler: (req: Request) => Promise<Response> = routeRequest;
+
+  // Apply middleware in reverse order (innermost first)
+  handler = errorMiddleware(handler);
+
+  if (config.auth) {
+    // Skip auth for health endpoints
+    const authHandler = handler;
+    handler = async (req: Request) => {
+      const url = new URL(req.url);
+      if (url.pathname.startsWith("/health")) {
+        return authHandler(req);
+      }
+      return authMiddleware(authHandler)(req);
+    };
+  }
+
+  if (config.cors) {
+    handler = corsMiddleware(handler);
+  }
+
+  return handler;
+}
+
+/**
+ * Print startup banner
+ */
+function printBanner(config: ServerConfig): void {
+  console.log(`
+╔═══════════════════════════════════════════════════════════════╗
+║                    LOKI MODE API SERVER                       ║
+╠═══════════════════════════════════════════════════════════════╣
+║  Version:  ${Deno.env.get("LOKI_VERSION") || "dev".padEnd(50)}║
+║  Host:     ${config.host.padEnd(50)}║
+║  Port:     ${String(config.port).padEnd(50)}║
+║  CORS:     ${(config.cors ? "enabled" : "disabled").padEnd(50)}║
+║  Auth:     ${(config.auth ? "enabled (localhost bypass)" : "disabled").padEnd(50)}║
+╠═══════════════════════════════════════════════════════════════╣
+║  Endpoints:                                                   ║
+║    GET  /health            - Health check                     ║
+║    GET  /api/status        - Detailed status                  ║
+║    GET  /api/events        - SSE event stream                 ║
+║    POST /api/sessions      - Start new session                ║
+║    GET  /api/sessions      - List sessions                    ║
+║    GET  /api/sessions/:id  - Get session details              ║
+║    POST /api/sessions/:id/stop   - Stop session               ║
+║    POST /api/sessions/:id/input  - Inject input               ║
+║    GET  /api/sessions/:id/tasks  - List tasks                 ║
+╚═══════════════════════════════════════════════════════════════╝
+`);
+}
+
+/**
+ * Parse command line arguments
+ */
+function parseArgs(): ServerConfig {
+  const config = { ...defaultConfig };
+  const args = Deno.args;
+
+  for (let i = 0; i < args.length; i++) {
+    switch (args[i]) {
+      case "--port":
+      case "-p":
+        config.port = parseInt(args[++i], 10);
+        break;
+      case "--host":
+      case "-h":
+        config.host = args[++i];
+        break;
+      case "--no-cors":
+        config.cors = false;
+        break;
+      case "--no-auth":
+        config.auth = false;
+        break;
+      case "--help":
+        console.log(`
+Loki Mode API Server
+
+Usage:
+  deno run --allow-all api/server.ts [options]
+
+Options:
+  --port, -p <port>   Port to listen on (default: 8420)
+  --host, -h <host>   Host to bind to (default: localhost)
+  --no-cors           Disable CORS
+  --no-auth           Disable authentication
+  --help              Show this help message
+
+Environment Variables:
+  LOKI_API_PORT       Port (overridden by --port)
+  LOKI_API_HOST       Host (overridden by --host)
+  LOKI_API_TOKEN      API token for remote access
+  LOKI_DIR            Loki installation directory
+  LOKI_VERSION        Version string
+  LOKI_DEBUG          Enable debug output
+`);
+        Deno.exit(0);
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Start the server
+ */
+async function main(): Promise<void> {
+  const config = parseArgs();
+
+  // Start state watcher
+  await stateWatcher.start();
+
+  // Print banner
+  printBanner(config);
+
+  // Create handler
+  const handler = createHandler(config);
+
+  // Start server
+  console.log(`Server listening on http://${config.host}:${config.port}`);
+
+  await Deno.serve(
+    {
+      port: config.port,
+      hostname: config.host,
+      onListen: ({ hostname, port }) => {
+        console.log(`Ready to accept connections on ${hostname}:${port}`);
+      },
+    },
+    handler
+  ).finished;
+}
+
+// Run if this is the main module
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error("Server error:", err);
+    Deno.exit(1);
+  });
+}
+
+// Export for testing
+export { createHandler, routeRequest, parseArgs };

package/api/server_test.ts

@@ -0,0 +1,265 @@
+/**
+ * API Server Tests
+ *
+ * Run with: deno test --allow-all api/server_test.ts
+ */
+
+import {
+  assertEquals,
+  assertExists,
+  assertStringIncludes,
+} from "https://deno.land/std@0.220.0/assert/mod.ts";
+
+import { createHandler, routeRequest } from "./server.ts";
+import { eventBus } from "./services/event-bus.ts";
+
+// Test utilities
+function createRequest(
+  method: string,
+  path: string,
+  body?: unknown,
+  headers: Record<string, string> = {}
+): Request {
+  const url = `http://localhost:8420${path}`;
+  const init: RequestInit = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers,
+    },
+  };
+  if (body) {
+    init.body = JSON.stringify(body);
+  }
+  return new Request(url, init);
+}
+
+// ============================================================
+// Health Endpoint Tests
+// ============================================================
+
+Deno.test("GET /health returns health status", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/health");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.status);
+  assertExists(data.version);
+  assertExists(data.uptime);
+  assertExists(data.providers);
+});
+
+Deno.test("GET /health/live returns alive status", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/health/live");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertEquals(data.alive, true);
+});
+
+// ============================================================
+// Session Endpoint Tests
+// ============================================================
+
+Deno.test("GET /api/sessions returns empty list initially", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/sessions");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.sessions);
+  assertEquals(Array.isArray(data.sessions), true);
+});
+
+Deno.test("POST /api/sessions validates provider", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("POST", "/api/sessions", { provider: "invalid" });
+  const res = await handler(req);
+
+  assertEquals(res.status, 422);
+  const data = await res.json();
+  assertStringIncludes(data.error, "Invalid provider");
+});
+
+Deno.test("GET /api/sessions/:id returns 404 for unknown session", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/sessions/unknown-id");
+  const res = await handler(req);
+
+  assertEquals(res.status, 404);
+  const data = await res.json();
+  assertEquals(data.code, "SESSION_NOT_FOUND");
+});
+
+// ============================================================
+// Task Endpoint Tests
+// ============================================================
+
+Deno.test("GET /api/tasks returns empty list initially", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/tasks");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.tasks);
+  assertEquals(Array.isArray(data.tasks), true);
+});
+
+Deno.test("GET /api/tasks/active returns active tasks", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/tasks/active");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.tasks);
+  assertExists(data.count);
+});
+
+// ============================================================
+// Event Endpoint Tests
+// ============================================================
+
+Deno.test("GET /api/events/stats returns event statistics", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/events/stats");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.subscribers);
+  assertExists(data.historySize);
+});
+
+Deno.test("GET /api/events/history returns event history", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/events/history");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.events);
+  assertEquals(Array.isArray(data.events), true);
+});
+
+// ============================================================
+// Event Bus Tests
+// ============================================================
+
+Deno.test("EventBus publishes and receives events", () => {
+  const received: unknown[] = [];
+
+  const subId = eventBus.subscribe({}, (event) => {
+    received.push(event);
+  });
+
+  eventBus.publish("log:info", "test-session", { message: "test" });
+
+  assertEquals(received.length, 1);
+  assertEquals((received[0] as { type: string }).type, "log:info");
+
+  eventBus.unsubscribe(subId);
+});
+
+Deno.test("EventBus filters by session ID", () => {
+  const received: unknown[] = [];
+
+  const subId = eventBus.subscribe({ sessionId: "session-1" }, (event) => {
+    received.push(event);
+  });
+
+  eventBus.publish("log:info", "session-1", { message: "included" });
+  eventBus.publish("log:info", "session-2", { message: "excluded" });
+
+  assertEquals(received.length, 1);
+  assertEquals((received[0] as { sessionId: string }).sessionId, "session-1");
+
+  eventBus.unsubscribe(subId);
+});
+
+Deno.test("EventBus filters by event type", () => {
+  const received: unknown[] = [];
+
+  const subId = eventBus.subscribe({ types: ["log:error"] }, (event) => {
+    received.push(event);
+  });
+
+  eventBus.publish("log:info", "test", { message: "info" });
+  eventBus.publish("log:error", "test", { message: "error" });
+  eventBus.publish("log:warn", "test", { message: "warn" });
+
+  assertEquals(received.length, 1);
+  assertEquals((received[0] as { type: string }).type, "log:error");
+
+  eventBus.unsubscribe(subId);
+});
+
+// ============================================================
+// CORS Tests
+// ============================================================
+
+Deno.test("OPTIONS request returns CORS headers", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = new Request("http://localhost:8420/api/sessions", {
+    method: "OPTIONS",
+    headers: {
+      Origin: "http://localhost:3000",
+    },
+  });
+  const res = await handler(req);
+
+  assertEquals(res.status, 204);
+  assertExists(res.headers.get("Access-Control-Allow-Origin"));
+  assertExists(res.headers.get("Access-Control-Allow-Methods"));
+});
+
+// ============================================================
+// Error Handling Tests
+// ============================================================
+
+Deno.test("Unknown route returns 404", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/unknown");
+  const res = await handler(req);
+
+  assertEquals(res.status, 404);
+  const data = await res.json();
+  assertEquals(data.code, "NOT_FOUND");
+});
+
+Deno.test("Invalid JSON returns 400", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = new Request("http://localhost:8420/api/sessions", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: "not valid json",
+  });
+  const res = await handler(req);
+
+  assertEquals(res.status, 400);
+});
+
+// ============================================================
+// Status Endpoint Tests
+// ============================================================
+
+Deno.test("GET /api/status returns detailed status", async () => {
+  const handler = createHandler({ port: 8420, host: "localhost", cors: true, auth: false });
+  const req = createRequest("GET", "/api/status");
+  const res = await handler(req);
+
+  assertEquals(res.status, 200);
+  const data = await res.json();
+  assertExists(data.version);
+  assertExists(data.uptime);
+  assertExists(data.providers);
+  assertExists(data.sessions);
+  assertExists(data.events);
+  assertExists(data.system);
+});