loki-mode 10.10.2 → 10.10.3

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

@@ -0,0 +1,77 @@
+// Changed files for a finished run when its events carry no diff: the run's receipt.json names base_sha and head_sha, and
+// `git diff --numstat base head` in the run's discovered repo gives the per-file counts. Shas are validated as hex, git is
+// spawned without a shell and with an explicit env, and a failure of any step reads as null (unmeasured), never as zero files.
+import { execFileSync } from "node:child_process";
+import { closeSync, fstatSync, openSync, readSync, realpathSync } from "node:fs";
+import { join, sep } from "node:path";
+import { and, eq } from "drizzle-orm";
+import type { Db } from "../db/migrate.ts";
+import { localRepos } from "../db/schema.ts";
+
+export interface DiffStat {
+  base: string;
+  head: string;
+  files: { path: string; added: number | null; removed: number | null }[];
+  added: number;
+  removed: number;
+  source: "git";
+}
+
+const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const SHA = /^[0-9a-f]{40,64}$/;
+const MAX_RECEIPT_BYTES = 1024 * 1024;
+const GIT_TIMEOUT_MS = 5000;
+const cache = new Map<string, DiffStat>();
+
+const gitEnv = (): NodeJS.ProcessEnv => ({ PATH: process.env.PATH ?? "", HOME: process.env.HOME ?? "", LC_ALL: "C", GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0" });
+
+/** Parses `git diff --numstat` output; a binary file ("-\t-") keeps null counts. */
+export function parseNumstat(out: string): DiffStat["files"] {
+  const files: DiffStat["files"] = [];
+  for (const line of out.split("\n")) {
+    const m = /^(\d+|-)\t(\d+|-)\t(.+)$/.exec(line);
+    if (!m) continue;
+    files.push({ path: m[3]!, added: m[1] === "-" ? null : Number(m[1]), removed: m[2] === "-" ? null : Number(m[2]) });
+  }
+  return files;
+}
+
+function readReceipt(runDir: string): { base_sha?: unknown; head_sha?: unknown } | null {
+  let fd: number;
+  try { fd = openSync(join(runDir, "receipt.json"), "r"); } catch { return null; }
+  try {
+    const st = fstatSync(fd);
+    if (!st.isFile() || st.size > MAX_RECEIPT_BYTES) return null;
+    const buf = Buffer.alloc(st.size);
+    readSync(fd, buf, 0, st.size, 0);
+    const j = JSON.parse(buf.toString("utf8"));
+    return j && typeof j === "object" ? j : null;
+  } catch { return null; } finally { closeSync(fd); }
+}
+
+/** Null when the run is unknown, has no local repo or receipt, has no valid shas, or git cannot answer. Only successes are cached (a finished run's range never changes). */
+export function diffStatFor(db: Db, source: string, run: string): DiffStat | null {
+  if (!ID.test(source) || !ID.test(run) || source.includes("..") || run.includes("..")) return null;
+  const key = `${source}/${run}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const repo = db.select({ p: localRepos.realpath }).from(localRepos).where(and(eq(localRepos.sourceId, source))).get();
+  if (!repo) return null;
+  let repoReal: string, runsRoot: string, runDir: string;
+  try {
+    repoReal = realpathSync(repo.p);
+    runsRoot = realpathSync(join(repoReal, ".loki", "runs"));
+    runDir = realpathSync(join(runsRoot, run));
+  } catch { return null; }
+  if (runDir !== join(runsRoot, run) || !runDir.startsWith(runsRoot + sep)) return null;
+  const r = readReceipt(runDir);
+  const base = typeof r?.base_sha === "string" ? r.base_sha : "", head = typeof r?.head_sha === "string" ? r.head_sha : "";
+  if (!SHA.test(base) || !SHA.test(head)) return null;
+  try {
+    const out = execFileSync("git", ["-C", repoReal, "-c", "core.quotePath=false", "diff", "--numstat", "--no-renames", `${base}..${head}`, "--"], { env: gitEnv(), timeout: GIT_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    const files = parseNumstat(out);
+    const stat: DiffStat = { base, head, files, added: files.reduce((n, f) => n + (f.added ?? 0), 0), removed: files.reduce((n, f) => n + (f.removed ?? 0), 0), source: "git" };
+    cache.set(key, stat);
+    return stat;
+  } catch { return null; }
+}

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

@@ -1,5 +1,6 @@
 // local_repos: the server-side map from source_id to a real repo path. Filled only by local discovery (never by /v1/ingest);
 // the path never leaves the server. The API exposes display names only.
+import { basename, resolve } from "node:path";
 import type { Hono } from "hono";
 import type { Db } from "../db/migrate.ts";
 import { localRepos } from "../db/schema.ts";
@@ -22,6 +23,8 @@ export function repoNames(db: Db): string[] {
 }
 
 /** GET /v1/repos. `act` is the loopback-only router; `peerIsLoopback` checks the real socket address. */
-export function mountRepos(act: Hono, db: Db, peerIsLoopback: (c: Parameters<Parameters<Hono["get"]>[1]>[0]) => boolean): void {
-  act.get("/v1/repos", (c) => peerIsLoopback(c) ? c.json({ repos: repoNames(db) }) : c.json({ error: "loopback only" }, 403));
+export function mountRepos(act: Hono, db: Db, peerIsLoopback: (c: Parameters<Parameters<Hono["get"]>[1]>[0]) => boolean, repoDir?: string): void {
+  // default_repo is the folder name of the directory the service was launched from (what a run with no repo chip uses); the path itself is never sent.
+  const defaultRepo = repoDir ? basename(resolve(repoDir)) || null : null;
+  act.get("/v1/repos", (c) => peerIsLoopback(c) ? c.json({ repos: repoNames(db), default_repo: defaultRepo }) : c.json({ error: "loopback only" }, 403));
 }

package/packages/control-plane/src/server/routes/index.ts

@@ -46,7 +46,7 @@ export interface RouteCtx {
 export const routeModules: ReadonlyArray<(ctx: RouteCtx) => void> = [artifacts, stream, start, control, stats, cost, costLedger, fleet, metrics, checkpoints, memory, sessionControl, config, providers, verify, integrations, notify, audit, mergeRisk];
 
 export function registerRoutes(ctx: RouteCtx): void {
-  mountRepos(ctx.act, ctx.db, ctx.peerIsLoopback);
+  mountRepos(ctx.act, ctx.db, ctx.peerIsLoopback, ctx.repoDir);
   for (const m of routeModules) m(ctx);
 }
 

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

@@ -4,6 +4,7 @@ import type { EventEnvelope } from "../../../../loki-ts/src/engine10/types.ts";
 import type { Db } from "../db/migrate.ts";
 import { events, runs } from "../db/schema.ts";
 import { blockedQuestion } from "./answer.ts";
+import { diffStatFor } from "./diffstat.ts";
 import { effectiveVerdict, pubkeysFromEnv, sealedPrefix, SUCCESS_VERDICTS, verifyRunIntegrity } from "./integrity.ts";
 
 const str = (x: unknown): string | null => (typeof x === "string" ? x : null);
@@ -65,7 +66,8 @@ export function taskTitle(db: Db, sourceId: string, runId: string): string | nul
 // A run with no run.completed yet is running: add its live fields (stage, files) from the stored events.
 const withLive = (db: Db, r: typeof runs.$inferSelect) => {
   const p = { ...parseRun(r), title: taskTitle(db, r.sourceId, r.runId) };
-  return r.endedAt ? { ...p, current_stage: null, files_touched: [] as string[] } : { ...p, ...liveInfo(loadEvents(db, r.sourceId, r.runId)) };
+  // A finished run's events carry no diff; its receipt's base and head give one (git numstat, null when unmeasurable).
+  return r.endedAt ? { ...p, current_stage: null, files_touched: [] as string[], diff_stat: diffStatFor(db, r.sourceId, r.runId) } : { ...p, ...liveInfo(loadEvents(db, r.sourceId, r.runId)), diff_stat: null };
 };
 
 /** Live view of one run from its events so far: current stage, files touched. Elapsed is computed per request. */