loki-mode 10.5.35 → 10.6.6

package/packages/control-plane/drizzle/0000_new_maelstrom.sql

@@ -0,0 +1,49 @@
+CREATE TABLE `events` (
+	`source_id` text NOT NULL,
+	`run_id` text NOT NULL,
+	`seq` integer NOT NULL,
+	`ts` text NOT NULL,
+	`type` text NOT NULL,
+	`stage` text,
+	`data` text NOT NULL,
+	`line_sha256` text NOT NULL,
+	`received_at` text NOT NULL,
+	PRIMARY KEY(`source_id`, `run_id`, `seq`)
+);
+--> statement-breakpoint
+CREATE INDEX `events_run_seq` ON `events` (`run_id`,`seq`);--> statement-breakpoint
+CREATE INDEX `events_type_ts` ON `events` (`type`,`ts`);--> statement-breakpoint
+CREATE TABLE `runs` (
+	`source_id` text NOT NULL,
+	`run_id` text NOT NULL,
+	`origin_repo` text,
+	`issue_ref` text,
+	`task_source` text,
+	`provider` text,
+	`model` text,
+	`started_at` text,
+	`ended_at` text,
+	`verdict` text,
+	`pr_url` text,
+	`pr_draft` integer,
+	`cost_usd` real,
+	`partial_usd` real NOT NULL,
+	`measured_sessions` integer NOT NULL,
+	`total_sessions` integer NOT NULL,
+	`input_tokens` integer NOT NULL,
+	`output_tokens` integer NOT NULL,
+	`wall_s` real,
+	`last_seq` integer NOT NULL,
+	`last_event_at` text,
+	`tampered` integer NOT NULL,
+	`conflict` integer DEFAULT 0 NOT NULL,
+	PRIMARY KEY(`source_id`, `run_id`)
+);
+--> statement-breakpoint
+CREATE INDEX `runs_started` ON `runs` (`started_at`);--> statement-breakpoint
+CREATE INDEX `runs_verdict` ON `runs` (`verdict`);--> statement-breakpoint
+CREATE TABLE `sources` (
+	`id` text PRIMARY KEY NOT NULL,
+	`first_seen` text NOT NULL,
+	`last_seen` text NOT NULL
+);

package/packages/control-plane/drizzle/meta/0000_snapshot.json

@@ -0,0 +1,343 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "32fa548f-e5a1-47e9-9a54-1be1f970a2de",
+  "prevId": "00000000-0000-0000-0000-000000000000",
+  "tables": {
+    "events": {
+      "name": "events",
+      "columns": {
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "run_id": {
+          "name": "run_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "seq": {
+          "name": "seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "ts": {
+          "name": "ts",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "type": {
+          "name": "type",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "stage": {
+          "name": "stage",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "data": {
+          "name": "data",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "line_sha256": {
+          "name": "line_sha256",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "received_at": {
+          "name": "received_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "events_run_seq": {
+          "name": "events_run_seq",
+          "columns": [
+            "run_id",
+            "seq"
+          ],
+          "isUnique": false
+        },
+        "events_type_ts": {
+          "name": "events_type_ts",
+          "columns": [
+            "type",
+            "ts"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "events_source_id_run_id_seq_pk": {
+          "columns": [
+            "source_id",
+            "run_id",
+            "seq"
+          ],
+          "name": "events_source_id_run_id_seq_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "runs": {
+      "name": "runs",
+      "columns": {
+        "source_id": {
+          "name": "source_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "run_id": {
+          "name": "run_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "origin_repo": {
+          "name": "origin_repo",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "issue_ref": {
+          "name": "issue_ref",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "task_source": {
+          "name": "task_source",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "provider": {
+          "name": "provider",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "model": {
+          "name": "model",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "started_at": {
+          "name": "started_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "ended_at": {
+          "name": "ended_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "verdict": {
+          "name": "verdict",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pr_url": {
+          "name": "pr_url",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "pr_draft": {
+          "name": "pr_draft",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "cost_usd": {
+          "name": "cost_usd",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "partial_usd": {
+          "name": "partial_usd",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "measured_sessions": {
+          "name": "measured_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "total_sessions": {
+          "name": "total_sessions",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "input_tokens": {
+          "name": "input_tokens",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "output_tokens": {
+          "name": "output_tokens",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "wall_s": {
+          "name": "wall_s",
+          "type": "real",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "last_seq": {
+          "name": "last_seq",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_event_at": {
+          "name": "last_event_at",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "tampered": {
+          "name": "tampered",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "conflict": {
+          "name": "conflict",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false,
+          "default": 0
+        }
+      },
+      "indexes": {
+        "runs_started": {
+          "name": "runs_started",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        },
+        "runs_verdict": {
+          "name": "runs_verdict",
+          "columns": [
+            "verdict"
+          ],
+          "isUnique": false
+        }
+      },
+      "foreignKeys": {},
+      "compositePrimaryKeys": {
+        "runs_source_id_run_id_pk": {
+          "columns": [
+            "source_id",
+            "run_id"
+          ],
+          "name": "runs_source_id_run_id_pk"
+        }
+      },
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "sources": {
+      "name": "sources",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "text",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "first_seen": {
+          "name": "first_seen",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "last_seen": {
+          "name": "last_seen",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    }
+  },
+  "views": {},
+  "enums": {},
+  "_meta": {
+    "schemas": {},
+    "tables": {},
+    "columns": {}
+  },
+  "internal": {
+    "indexes": {}
+  }
+}

package/packages/control-plane/drizzle/meta/_journal.json

@@ -0,0 +1,13 @@
+{
+  "version": "7",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "6",
+      "when": 1790870373167,
+      "tag": "0000_new_maelstrom",
+      "breakpoints": true
+    }
+  ]
+}

package/packages/control-plane/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "@loki/control-plane",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "bun test ./test/",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "build:ui": "cd ui && bun install --frozen-lockfile && bun run build",
+    "build:server": "bun build src/server/serve.ts --target=bun --outfile dist/server.js",
+    "build:all": "bun run build:ui && bun run build:server",
+    "db:generate": "drizzle-kit generate --dialect sqlite --schema ./src/db/schema.ts --out ./drizzle"
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.3",
+    "hono": "^4.13.12"
+  },
+  "devDependencies": {
+    "drizzle-kit": "^0.31.11"
+  }
+}

package/packages/control-plane/src/db/migrate.ts

@@ -0,0 +1,20 @@
+import { Database } from "bun:sqlite";
+import { drizzle } from "drizzle-orm/bun-sqlite";
+import { migrate } from "drizzle-orm/bun-sqlite/migrator";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import * as schema from "./schema.ts";
+
+export type Db = ReturnType<typeof openDb>["db"];
+
+/** Opens the SQLite file (":memory:" for tests) and applies drizzle/ migrations. Runs on boot. */
+export function openDb(path: string) {
+  const sqlite = new Database(path, { create: true });
+  sqlite.exec("PRAGMA journal_mode = WAL; PRAGMA busy_timeout = 5000;");
+  const db = drizzle(sqlite, { schema });
+  // src/db/ (source) and dist/ (bundled server) sit at different depths under packages/control-plane
+  const migrationsFolder = [join(import.meta.dir, "../../drizzle"), join(import.meta.dir, "../drizzle")].find((d) => existsSync(join(d, "meta/_journal.json")));
+  if (!migrationsFolder) throw new Error("drizzle migrations folder not found");
+  migrate(db, { migrationsFolder });
+  return { db, sqlite };
+}

package/packages/control-plane/src/db/schema.ts

@@ -0,0 +1,54 @@
+import { index, integer, primaryKey, real, sqliteTable, text } from "drizzle-orm/sqlite-core";
+
+export const sources = sqliteTable("sources", {
+  id: text("id").primaryKey(),
+  firstSeen: text("first_seen").notNull(),
+  lastSeen: text("last_seen").notNull(),
+});
+
+export const events = sqliteTable("events", {
+  sourceId: text("source_id").notNull(),
+  runId: text("run_id").notNull(),
+  seq: integer("seq").notNull(),
+  ts: text("ts").notNull(),
+  type: text("type").notNull(),
+  stage: text("stage"),
+  data: text("data", { mode: "json" }).notNull(),
+  lineSha256: text("line_sha256").notNull(),
+  receivedAt: text("received_at").notNull(),
+}, (t) => [
+  primaryKey({ columns: [t.sourceId, t.runId, t.seq] }),
+  index("events_run_seq").on(t.runId, t.seq),
+  index("events_type_ts").on(t.type, t.ts),
+]);
+
+// A projection rebuilt from `events` by fold(); never written any other way.
+export const runs = sqliteTable("runs", {
+  sourceId: text("source_id").notNull(),
+  runId: text("run_id").notNull(),
+  originRepo: text("origin_repo"),
+  issueRef: text("issue_ref"),
+  taskSource: text("task_source"),
+  provider: text("provider"),
+  model: text("model"),
+  startedAt: text("started_at"),
+  endedAt: text("ended_at"),
+  verdict: text("verdict"),
+  prUrl: text("pr_url"),
+  prDraft: integer("pr_draft"),
+  costUsd: real("cost_usd"),
+  partialUsd: real("partial_usd").notNull(),
+  measuredSessions: integer("measured_sessions").notNull(),
+  totalSessions: integer("total_sessions").notNull(),
+  inputTokens: integer("input_tokens").notNull(),
+  outputTokens: integer("output_tokens").notNull(),
+  wallS: real("wall_s"),
+  lastSeq: integer("last_seq").notNull(),
+  lastEventAt: text("last_event_at"),
+  tampered: integer("tampered").notNull(),
+  conflict: integer("conflict").notNull().default(0),
+}, (t) => [
+  primaryKey({ columns: [t.sourceId, t.runId] }),
+  index("runs_started").on(t.startedAt),
+  index("runs_verdict").on(t.verdict),
+]);

package/packages/control-plane/src/server/app.ts

@@ -0,0 +1,63 @@
+import { existsSync, statSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
+import { Hono } from "hono";
+import { openDb } from "../db/migrate.ts";
+import { ingest } from "./ingest.ts";
+import { listRuns, runDetail } from "./runs.ts";
+
+const MAX_BODY = 1_000_000;
+
+/** The built UI: packages/control-plane/ui/dist, found from src/server (source run) or dist (bundled server). */
+const defaultUiDir = () => [join(import.meta.dir, "../../ui/dist"), join(import.meta.dir, "../ui/dist")].find((d) => existsSync(join(d, "index.html")));
+
+/** dbPath ":memory:" for tests. Migrations run here, so /ready is true as soon as this returns. uiDir overrides the built-UI location. */
+export function createApp(opts: { dbPath: string; uiDir?: string }) {
+  const uiDir = opts.uiDir ?? defaultUiDir();
+  const { db, sqlite } = openDb(opts.dbPath);
+  let ready = true;
+  const app = new Hono();
+
+  app.get("/health", (c) => c.json({ service: "loki-control", pid: process.pid, install_path: import.meta.dir }));
+  app.get("/ready", (c) => {
+    try { sqlite.query("select 1").get(); } catch { ready = false; }
+    return ready ? c.json({ ready: true }) : c.json({ ready: false }, 503);
+  });
+
+  app.post("/v1/ingest", async (c) => {
+    const text = await c.req.text();
+    if (text.length > MAX_BODY) return c.json({ error: "body over 1 MB" }, 413);
+    let body: unknown;
+    try { body = JSON.parse(text); } catch { return c.json({ error: "invalid JSON" }, 400); }
+    const r = ingest(db, body);
+    return c.json(r.body, r.status);
+  });
+
+  app.get("/v1/runs", (c) => {
+    const q = c.req.query();
+    return c.json(listRuns(db, { verdict: q.verdict, repo: q.repo, since: q.since, until: q.until, limit: q.limit ? Number(q.limit) : undefined, cursor: q.cursor }));
+  });
+  const detail = (c: { json: (b: unknown, s?: 404) => Response }, source: string, run: string) => {
+    const d = runDetail(db, source, run);
+    return d ? c.json(d) : c.json({ error: "run not found" }, 404);
+  };
+  app.get("/v1/runs/:source/:run", (c) => detail(c, c.req.param("source"), c.req.param("run")));
+  // :id is `source:run` (run ids never contain a colon)
+  app.get("/v1/runs/:id", (c) => {
+    const id = c.req.param("id");
+    const i = id.indexOf(":");
+    return i < 0 ? c.json({ error: "id must be source:run" }, 404) : detail(c, id.slice(0, i), id.slice(i + 1));
+  });
+
+  // Static UI with SPA fallback. Registered last so /v1, /health and /ready always win.
+  app.get("*", (c) => {
+    const p = decodeURIComponent(new URL(c.req.url).pathname);
+    if (!uiDir || p.startsWith("/v1/")) return c.json({ error: "not found" }, 404);
+    const root = resolve(uiDir);
+    const f = resolve(root, `.${p}`);
+    if (f.startsWith(root + sep) && existsSync(f) && statSync(f).isFile()) return new Response(Bun.file(f));
+    if (/\.[a-z0-9]+$/i.test(p)) return c.json({ error: "not found" }, 404); // a missing asset is a 404, not index.html
+    return new Response(Bun.file(join(root, "index.html")));
+  });
+
+  return { app, db, close: () => sqlite.close() };
+}

package/packages/control-plane/src/server/ingest.ts

@@ -0,0 +1,52 @@
+import { createHash } from "node:crypto";
+import { and, eq, sql } from "drizzle-orm";
+import { validateEnvelope } from "../../../../loki-ts/src/engine10/events.ts";
+import type { EventEnvelope } from "../../../../loki-ts/src/engine10/types.ts";
+import { redactSecrets } from "../../../../loki-ts/src/util/redact.ts";
+import type { Db } from "../db/migrate.ts";
+import { events, runs, sources } from "../db/schema.ts";
+import { rebuildRun } from "./runs.ts";
+
+export const MAX_EVENTS = 500;
+
+export type IngestResult =
+  | { status: 200; body: { accepted: number; duplicate: number; conflict: number; last_seq: number } }
+  | { status: 400; body: { error: string } }
+  | { status: 409; body: { accepted: number; duplicate: number; conflict: number; last_seq: number; error: string } };
+
+/** Body: {source, run_id, events: EventEnvelope[]}. Event id = source:run:seq; same id and same hash is a no-op, a different hash is a 409 that flags the run and never overwrites. */
+export function ingest(db: Db, body: unknown): IngestResult {
+  const b = body as { source?: unknown; source_id?: unknown; run_id?: unknown; events?: unknown } | null;
+  const sourceId = b?.source ?? b?.source_id;
+  if (typeof sourceId !== "string" || !sourceId || typeof b?.run_id !== "string" || !b.run_id) return { status: 400, body: { error: "source and run_id required" } };
+  const runId = b.run_id;
+  if (!Array.isArray(b.events) || b.events.length > MAX_EVENTS) return { status: 400, body: { error: `events must be an array of at most ${MAX_EVENTS}` } };
+
+  const rows: { e: EventEnvelope; json: string; sha: string }[] = [];
+  for (const [i, raw] of b.events.entries()) {
+    const bad = validateEnvelope(raw);
+    if (bad) return { status: 400, body: { error: `events[${i}]: ${bad}` } };
+    const e = JSON.parse(redactSecrets(JSON.stringify(raw))) as EventEnvelope; // redacted again server-side
+    if (e.run !== runId) return { status: 400, body: { error: `events[${i}]: run does not match run_id` } };
+    const json = JSON.stringify(e);
+    rows.push({ e, json, sha: createHash("sha256").update(json).digest("hex") });
+  }
+
+  const now = new Date().toISOString();
+  let accepted = 0, duplicate = 0, conflict = 0;
+  db.transaction((tx) => {
+    tx.insert(sources).values({ id: sourceId, firstSeen: now, lastSeen: now }).onConflictDoUpdate({ target: sources.id, set: { lastSeen: now } }).run();
+    for (const { e, sha } of rows) {
+      const prior = tx.select({ sha: events.lineSha256 }).from(events)
+        .where(and(eq(events.sourceId, sourceId), eq(events.runId, runId), eq(events.seq, e.seq))).get();
+      if (prior) { if (prior.sha === sha) duplicate++; else conflict++; continue; }
+      tx.insert(events).values({ sourceId, runId, seq: e.seq, ts: e.ts, type: e.type, stage: e.stage, data: e.data, lineSha256: sha, receivedAt: now }).run();
+      accepted++;
+    }
+    if (accepted > 0) rebuildRun(tx as unknown as Db, sourceId, runId);
+    if (conflict > 0) tx.update(runs).set({ conflict: 1 }).where(and(eq(runs.sourceId, sourceId), eq(runs.runId, runId))).run();
+  });
+  const last = db.select({ m: sql<number | null>`max(${events.seq})` }).from(events).where(and(eq(events.sourceId, sourceId), eq(events.runId, runId))).get()?.m ?? -1;
+  const out = { accepted, duplicate, conflict, last_seq: last };
+  return conflict > 0 ? { status: 409, body: { ...out, error: "conflicting content for an existing event id" } } : { status: 200, body: out };
+}