loki-mode 10.6.14 → 10.7.1

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

@@ -0,0 +1,437 @@
+{
+  "version": "6",
+  "dialect": "sqlite",
+  "id": "c1492d55-5d08-4208-940a-38fba6b33b3c",
+  "prevId": "2b4a930a-5fb1-4e32-8387-fac651ba5fca",
+  "tables": {
+    "audit": {
+      "name": "audit",
+      "columns": {
+        "id": {
+          "name": "id",
+          "type": "integer",
+          "primaryKey": true,
+          "notNull": true,
+          "autoincrement": true
+        },
+        "ts": {
+          "name": "ts",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "action": {
+          "name": "action",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "actor": {
+          "name": "actor",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        },
+        "detail": {
+          "name": "detail",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": true,
+          "autoincrement": false
+        }
+      },
+      "indexes": {},
+      "foreignKeys": {},
+      "compositePrimaryKeys": {},
+      "uniqueConstraints": {},
+      "checkConstraints": {}
+    },
+    "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
+        },
+        "group_id": {
+          "name": "group_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "unit_id": {
+          "name": "unit_id",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "attested": {
+          "name": "attested",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "integrity_reasons": {
+          "name": "integrity_reasons",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "sig_checked": {
+          "name": "sig_checked",
+          "type": "integer",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        },
+        "integrity_key_fp": {
+          "name": "integrity_key_fp",
+          "type": "text",
+          "primaryKey": false,
+          "notNull": false,
+          "autoincrement": false
+        }
+      },
+      "indexes": {
+        "runs_started": {
+          "name": "runs_started",
+          "columns": [
+            "started_at"
+          ],
+          "isUnique": false
+        },
+        "runs_verdict": {
+          "name": "runs_verdict",
+          "columns": [
+            "verdict"
+          ],
+          "isUnique": false
+        },
+        "runs_group": {
+          "name": "runs_group",
+          "columns": [
+            "group_id"
+          ],
+          "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

@@ -15,6 +15,20 @@
       "when": 1790956800000,
       "tag": "0001_group_id",
       "breakpoints": true
+    },
+    {
+      "idx": 2,
+      "version": "6",
+      "when": 1791046012148,
+      "tag": "0002_tiresome_fixer",
+      "breakpoints": true
+    },
+    {
+      "idx": 3,
+      "version": "6",
+      "when": 1791132412148,
+      "tag": "0003_integrity",
+      "breakpoints": true
     }
   ]
 }

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

@@ -12,8 +12,12 @@ 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")));
+  // source, the bundled server and the bundled CLI sit at different depths
+  const migrationsFolder = [
+    join(import.meta.dir, "../../drizzle"), // src/db (source checkout)
+    join(import.meta.dir, "../drizzle"), // packages/control-plane/dist (bundled server)
+    join(import.meta.dir, "../../packages/control-plane/drizzle"), // loki-ts/dist (bundled CLI; also an installed npm package)
+  ].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/prune.ts

@@ -0,0 +1,91 @@
+// Removal of runs from the control DB: shared by `loki control prune` (direct DB) and DELETE /v1/runs/:source/:run (server).
+// One transaction deletes the runs, their events, and any source left with neither. An audit row is written first, inside the same transaction.
+import { Database } from "bun:sqlite";
+
+export interface PruneFilter { repo?: string; before?: string }
+export interface PruneCounts { runs: number; events: number; sources: number }
+
+/** Strict ISO 8601 parse: YYYY-MM-DD or a date-time with an explicit Z/offset. Returns a normalized UTC instant or null. */
+export function parseBefore(s: string): string | null {
+  if (!/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2}))?$/.test(s)) return null;
+  const t = Date.parse(s);
+  if (Number.isNaN(t)) return null;
+  // reject rolled-over dates such as 2026-02-31
+  if (new Date(`${s.slice(0, 10)}T00:00:00Z`).toISOString().slice(0, 10) !== s.slice(0, 10)) return null;
+  return new Date(t).toISOString();
+}
+
+type Key = { source_id: string; run_id: string };
+
+function where(f: PruneFilter): { sql: string; args: string[] } {
+  const parts: string[] = [];
+  const args: string[] = [];
+  if (f.repo !== undefined) { parts.push("origin_repo = ?"); args.push(f.repo); }
+  if (f.before !== undefined) { parts.push("started_at IS NOT NULL AND julianday(started_at) < julianday(?)"); args.push(f.before); }
+  return { sql: parts.join(" AND "), args };
+}
+
+const n = (sqlite: Database, sql: string, ...args: string[]): number => (sqlite.query(sql).get(...args) as { n: number }).n;
+
+/** What deleting these runs would remove: runs, their events, and sources that would be left holding nothing. */
+function countFor(sqlite: Database, keys: Key[]): PruneCounts {
+  const bySource = new Map<string, string[]>();
+  for (const k of keys) bySource.set(k.source_id, [...(bySource.get(k.source_id) ?? []), k.run_id]);
+  let events = 0, sources = 0;
+  for (const [src, runIds] of bySource) {
+    let ev = 0;
+    for (const r of runIds) ev += n(sqlite, "select count(*) n from events where source_id = ? and run_id = ?", src, r);
+    events += ev;
+    const runsLeft = n(sqlite, "select count(*) n from runs where source_id = ?", src) - runIds.length;
+    const eventsLeft = n(sqlite, "select count(*) n from events where source_id = ?", src) - ev;
+    if (runsLeft <= 0 && eventsLeft <= 0 && sqlite.query("select 1 x from sources where id = ?").get(src)) sources++;
+  }
+  return { runs: keys.length, events, sources };
+}
+
+export function audit(sqlite: Database, action: string, actor: string, detail: unknown): void {
+  sqlite.query("insert into audit (ts, action, actor, detail) values (?, ?, ?, ?)").run(new Date().toISOString(), action, actor, JSON.stringify(detail));
+}
+
+/** Drops only the given sources, and only when they now hold neither runs nor events (matches what countFor reported). */
+const dropOrphanSources = (sqlite: Database, ids: Iterable<string>): void => {
+  for (const id of ids) sqlite.query("delete from sources where id = ? and not exists (select 1 from runs where source_id = ?) and not exists (select 1 from events where source_id = ?)").run(id, id, id);
+};
+
+/** Read-only handle for dry runs: no migrations, no journal-mode change, no writes. */
+export const openReadOnly = (path: string): Database => new Database(path, { readonly: true });
+
+/** Removes the matching runs. dryRun counts only and writes nothing. At least one filter is required. */
+export function pruneRuns(sqlite: Database, f: PruneFilter, opts: { dryRun?: boolean; actor?: string } = {}): PruneCounts {
+  if (f.repo === undefined && f.before === undefined) throw new Error("prune needs --repo or --before");
+  const w = where(f);
+  const select = (): Key[] => sqlite.query(`select source_id, run_id from runs where ${w.sql}`).all(...w.args) as Key[];
+  if (opts.dryRun) return countFor(sqlite, select());
+  let out: PruneCounts = { runs: 0, events: 0, sources: 0 };
+  sqlite.transaction(() => {
+    const keys = select();
+    if (keys.length === 0) return;
+    out = countFor(sqlite, keys);
+    audit(sqlite, "prune", opts.actor ?? "cli", { filter: f, counts: out });
+    for (const k of keys) {
+      sqlite.query("delete from events where source_id = ? and run_id = ?").run(k.source_id, k.run_id);
+      sqlite.query("delete from runs where source_id = ? and run_id = ?").run(k.source_id, k.run_id);
+    }
+    dropOrphanSources(sqlite, new Set(keys.map((k) => k.source_id)));
+  }).immediate();
+  return out;
+}
+
+/** Removes one run. Null when it does not exist (nothing audited, nothing deleted). Otherwise the counts removed. */
+export function removeRun(sqlite: Database, source: string, run: string, actor = "http"): PruneCounts | null {
+  let out: PruneCounts | null = null;
+  sqlite.transaction(() => {
+    if (!sqlite.query("select 1 x from runs where source_id = ? and run_id = ?").get(source, run)) return;
+    out = countFor(sqlite, [{ source_id: source, run_id: run }]);
+    audit(sqlite, "run.remove", actor, { source_id: source, run_id: run, counts: out });
+    sqlite.query("delete from events where source_id = ? and run_id = ?").run(source, run);
+    sqlite.query("delete from runs where source_id = ? and run_id = ?").run(source, run);
+    dropOrphanSources(sqlite, [source]);
+  }).immediate();
+  return out;
+}

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

@@ -49,9 +49,22 @@ export const runs = sqliteTable("runs", {
   conflict: integer("conflict").notNull().default(0),
   groupId: text("group_id"),
   unitId: text("unit_id"),
+  attested: integer("attested"), // EL-FC08b: null = never evaluated (reads as unattested)
+  sigChecked: integer("sig_checked"), // log seal signature verified against a configured key
+  integrityKeyFp: text("integrity_key_fp"), // key-set fingerprint the integrity result was computed under; a change triggers a boot recompute
+  integrityReasons: text("integrity_reasons"), // JSON string[]
 }, (t) => [
   primaryKey({ columns: [t.sourceId, t.runId] }),
   index("runs_started").on(t.startedAt),
   index("runs_verdict").on(t.verdict),
   index("runs_group").on(t.groupId),
 ]);
+
+// Append-only record of destructive operator actions (run removal, prune). Written before the delete runs.
+export const audit = sqliteTable("audit", {
+  id: integer("id").primaryKey({ autoIncrement: true }),
+  ts: text("ts").notNull(),
+  action: text("action").notNull(),
+  actor: text("actor").notNull(),
+  detail: text("detail", { mode: "json" }).notNull(),
+});

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

@@ -0,0 +1,60 @@
+// Start-a-run and repo-picker helpers for the UI. A run is started by spawning the same `loki start` path an operator would type (argv array, no shell).
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+const ISSUE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}\/[A-Za-z0-9._-]{1,100}#[1-9][0-9]{0,8}$/;
+// A free-text task: letters, digits, spaces and a small punctuation set. No colon, quotes, backticks, $, ;, &, |, <, >, parens, braces, backslash or control chars.
+const TASK = /^[A-Za-z0-9][A-Za-z0-9 .,_/#@+=-]{0,499}$/;
+const hasDotDot = (t: string): boolean => t.split(/[\\/ ]/).some((seg) => seg.startsWith(".."));
+
+/** Child env: the server's own secrets and bind config never reach a spawned run. */
+export function childEnv(env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  const e: NodeJS.ProcessEnv = { ...env, LOKI_NO_BROWSER: "1" };
+  for (const k of ["LOKI_CONTROL_TOKEN", "LOKI_CONTROL_DB", "LOKI_CONTROL_HOST", "PORT"]) delete e[k];
+  return e;
+}
+
+export type StartPlan = { ok: true; argv: string[]; cwd: string } | { ok: false; error: string };
+
+/** Registered project paths from ~/.loki/dashboard/projects.json (the `loki projects` registry), existing directories only. */
+export function registryRepos(env: NodeJS.ProcessEnv = process.env): string[] {
+  try {
+    const j = JSON.parse(readFileSync(join(env.HOME || homedir(), ".loki", "dashboard", "projects.json"), "utf8")) as { projects?: Record<string, { path?: unknown }> };
+    return Object.values(j.projects ?? {}).map((p) => (typeof p?.path === "string" ? p.path : "")).filter((p) => p && existsSync(p) && statSync(p).isDirectory());
+  } catch { return []; }
+}
+
+/** Validate a start request. The repo must be one the server already knows (registry or cwd), never an arbitrary path. */
+export function planStart(body: unknown, known: string[], bin = "loki"): StartPlan {
+  const b = (body && typeof body === "object" ? body : {}) as { target?: unknown; repo?: unknown };
+  if (typeof b.target !== "string") return { ok: false, error: "target must be a string" };
+  const target = b.target.trim();
+  const issue = ISSUE.test(target);
+  if (!issue && !TASK.test(target)) return { ok: false, error: "target must be owner/repo#N or a plain task (letters, digits, spaces, . , _ / # @ + = -)" };
+  if (hasDotDot(target)) return { ok: false, error: "target must not contain a .. path segment" };
+  let cwd = process.cwd();
+  if (b.repo !== undefined && b.repo !== "") {
+    if (typeof b.repo !== "string" || b.repo.includes("\0")) return { ok: false, error: "repo must be a path string" };
+    const want = resolve(b.repo);
+    const hit = known.map((k) => resolve(k)).find((k) => k === want);
+    if (!hit) return { ok: false, error: "repo is not a known project" };
+    cwd = hit;
+  }
+  // Free text goes as an explicit brief, never auto-detected as a PRD path.
+  return { ok: true, argv: issue ? [bin, "start", target] : [bin, "start", "--brief", target], cwd };
+}
+
+/** Spawn detached with no shell; resolves with the pid once the process exists, or an error if it cannot be launched. */
+export function spawnStart(argv: string[], cwd: string, onExit: () => void = () => {}): Promise<{ pid: number } | { error: string }> {
+  return new Promise((done) => {
+    try {
+      const [cmd, ...args] = argv;
+      const child = spawn(cmd!, args, { cwd, detached: true, stdio: "ignore", shell: false, env: childEnv() });
+      child.once("exit", onExit);
+      child.once("error", (e) => { onExit(); done({ error: `could not start loki: ${e.message}` }); });
+      child.once("spawn", () => { child.unref(); done({ pid: child.pid ?? 0 }); });
+    } catch (e) { done({ error: `could not start loki: ${(e as Error).message}` }); }
+  });
+}