@surething/cockpit 1.0.266 → 1.0.268

package/bin/updater.mjs

@@ -18,7 +18,7 @@
 // losing the token would silently turn a tunnel-exposed instance into an open
 // one, so it must never be re-derived from defaults.
 import { spawn, spawnSync } from 'child_process';
-import { appendFileSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'fs';
+import { appendFileSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, writeFileSync } from 'fs';
 import { createServer } from 'http';
 import { createRequire } from 'module';
 import { dirname, join } from 'path';
@@ -152,9 +152,9 @@ function pidAlive(pid) {
 }
 
 /**
- * Whether the Claude SDK's platform-specific native binary resolves.
+ * Which bundled agent CLIs are missing their platform-specific native binary.
  *
- * DUPLICATED from scripts/claudeBinary.mjs — change both together. This file
+ * DUPLICATED from scripts/agentBinaries.mjs — change both together. This file
  * cannot import it: it runs from <cockpitHome>/updater/ precisely because
  * `npm i -g` deletes the install directory mid-run (see the header).
  *
@@ -164,21 +164,50 @@ function pidAlive(pid) {
  * single time — which, given what the caller does about it, would mean
  * uninstalling and reinstalling cockpit on every update.
  */
-function hasClaudeBinary() {
+function missingAgentBinaries() {
+  const missing = [];
+  let req;
   try {
-    const req = createRequire(join(installRoot, 'package.json'));
-    const base = `${process.platform}-${process.arch}`;
-    // linux ships glibc and musl variants under distinct package names.
-    const variants = process.platform === 'linux' ? [base, `${base}-musl`] : [base];
-    for (const variant of variants) {
-      try {
-        const pkgJson = req.resolve(`@anthropic-ai/claude-agent-sdk-${variant}/package.json`);
-        const bin = join(dirname(pkgJson), 'claude');
-        if (existsSync(bin) || existsSync(`${bin}.exe`)) return true;
-      } catch { /* this variant's sub-package isn't installed */ }
+    req = createRequire(join(installRoot, 'package.json'));
+  } catch {
+    // Install tree unreadable — same answer as everything missing.
+    return ['Claude', 'Codex'];
+  }
+
+  const dirOf = (name) => {
+    try {
+      return dirname(req.resolve(`${name}/package.json`));
+    } catch {
+      return null;
     }
-  } catch { /* install tree unreadable — same answer as missing */ }
-  return false;
+  };
+
+  const base = `${process.platform}-${process.arch}`;
+  // linux ships glibc and musl variants of the Claude binary under distinct package names.
+  const claudeVariants = process.platform === 'linux' ? [base, `${base}-musl`] : [base];
+  const hasClaude = claudeVariants.some((variant) => {
+    const dir = dirOf(`@anthropic-ai/claude-agent-sdk-${variant}`);
+    if (!dir) return false;
+    const bin = join(dir, 'claude');
+    return existsSync(bin) || existsSync(`${bin}.exe`);
+  });
+  if (!hasClaude) missing.push('Claude');
+
+  // Codex nests its binary under a Rust target triple; scan vendor/ rather than
+  // reproducing codex-sdk's private platform->triple table. No musl split here.
+  let hasCodex = false;
+  const codexDir = dirOf(`@openai/codex-${base}`);
+  if (codexDir) {
+    try {
+      hasCodex = readdirSync(join(codexDir, 'vendor')).some((target) => {
+        const bin = join(codexDir, 'vendor', target, 'bin', 'codex');
+        return existsSync(bin) || existsSync(`${bin}.exe`);
+      });
+    } catch { /* no vendor dir — same answer as missing */ }
+  }
+  if (!hasCodex) missing.push('Codex');
+
+  return missing;
 }
 
 function readInstalledVersion() {
@@ -282,15 +311,19 @@ function startServer() {
 const MANUAL_FIX = `npm uninstall -g ${PKG} && npm install -g ${PKG}`;
 
 /**
- * Make sure the SDK's platform-specific native binary survived the install.
+ * Make sure the agents' platform-specific native binaries survived the install.
  *
- * It ships as an OPTIONAL dependency, and npm skips it often enough during an
+ * They ship as OPTIONAL dependencies, and npm skips them often enough during an
  * in-place `npm i -g` that cock-service.mjs guards the offline path the same
  * way. Nothing else notices: the install exits 0, the server comes back, and
  * chat dies at the first message with "Native CLI binary not found". This path
  * — the UI button — had no guard at all, so it reported "update complete" and
  * handed back a Cockpit that could not chat.
  *
+ * Codex fails more quietly than Claude: rather than throwing, its engine falls
+ * back to whatever `codex` is on PATH — an unpinned build the SDK was never
+ * paired with. That is why both are checked here, not just Claude.
+ *
  * Escalates deliberately. The clean uninstall is the only thing that reliably
  * makes npm refetch a skipped optional dep, but it DELETES a working install,
  * so it runs only after --force has failed. If the reinstall then fails we are
@@ -298,15 +331,16 @@ const MANUAL_FIX = `npm uninstall -g ${PKG} && npm install -g ${PKG}`;
  * resort — and why the status port matters here: with no server, that card is
  * the only channel left to tell the user what to run.
  */
-async function repairClaudeBinary() {
-  if (hasClaudeBinary()) return { ok: true };
+async function repairAgentBinaries() {
+  let missing = missingAgentBinaries();
+  if (!missing.length) return { ok: true };
 
-  log('native claude binary missing after install — repairing');
+  log(`native ${missing.join(' and ')} binary missing after install — repairing`);
   writeState({ ...currentState, phase: 'repairing' });
 
   // Non-destructive first: --force re-reifies the tree without removing it.
   await runNpm(['install', '-g', `${PKG}@${target}`, '--include=optional', '--force']);
-  if (hasClaudeBinary()) {
+  if (!missingAgentBinaries().length) {
     log('repaired with --force');
     return { ok: true };
   }
@@ -321,11 +355,15 @@ async function repairClaudeBinary() {
     }
     return { ok: false, reason: `reinstall failed: ${reinstall.reason}` };
   }
-  if (hasClaudeBinary()) {
+  missing = missingAgentBinaries();
+  if (!missing.length) {
     log('repaired with uninstall + reinstall');
     return { ok: true };
   }
-  return { ok: false, reason: 'the native Claude binary is still missing; chat will not work' };
+  return {
+    ok: false,
+    reason: `the native ${missing.join(' and ')} binary is still missing; ${missing.length > 1 ? 'those engines' : 'that engine'} will not work`,
+  };
 }
 
 async function main() {
@@ -403,8 +441,8 @@ async function main() {
     return;
   }
 
-  // 3b. Installed — but not necessarily complete. See repairClaudeBinary.
-  const repair = await repairClaudeBinary();
+  // 3b. Installed — but not necessarily complete. See repairAgentBinaries.
+  const repair = await repairAgentBinaries();
 
   const installed = readInstalledVersion();
   log(`installed version now: ${installed} (install took ${installMs}ms)`);

package/dist/{chunk-FBAFMLUC.mjs → chunk-6EMR3NZV.mjs}

@@ -14,7 +14,7 @@ import {
   readJsonFile,
   withFileLock,
   writeJsonFile
-} from "./chunk-ZE2JXL6E.mjs";
+} from "./chunk-ETYX2YQF.mjs";
 
 // packages/feature/agent/src/server/state/globalState.ts
 import { createReadStream, existsSync, statSync } from "fs";
@@ -166,7 +166,7 @@ function truncate(s) {
   const chars = [...s];
   return chars.length <= MAX_TEXT_LEN ? s : chars.slice(0, MAX_TEXT_LEN).join("") + "\u2026";
 }
-async function updateGlobalState(cwd, sessionId, status, title, lastUserMessage) {
+async function updateGlobalState(cwd, sessionId, status, title, lastUserMessage, engine) {
   if (!existsSync(cwd)) {
     return;
   }
@@ -190,7 +190,10 @@ async function updateGlobalState(cwd, sessionId, status, title, lastUserMessage)
       lastActive: Date.now(),
       status,
       title: truncate(title || existing?.title),
-      lastUserMessage: truncate(lastUserMessage || existing?.lastUserMessage)
+      lastUserMessage: truncate(lastUserMessage || existing?.lastUserMessage),
+      // Carried like title/lastUserMessage: status-only updates (the client's
+      // /api/global-state PATCH) pass no engine and must not erase it.
+      engine: engine || existing?.engine
     };
     if (existingIndex >= 0) {
       state.sessions[existingIndex] = newSession;
@@ -318,7 +321,7 @@ async function attachEngines(sessions) {
   };
   return Promise.all(
     sessions.map(async (session) => {
-      const engine = (await enginesFor(session.cwd))[session.sessionId];
+      const engine = session.engine ?? (await enginesFor(session.cwd))[session.sessionId];
       return engine ? { ...session, engine } : session;
     })
   );
@@ -603,6 +606,7 @@ function startRun(key, cwd, promptText, runId) {
     seq: prevSeq,
     events: [],
     startedAt,
+    ...runId ? { runId } : {},
     updatedAt: startedAt
   });
   if (promptText) {
@@ -662,7 +666,7 @@ function markRunIdle(key, status = "idle") {
 function getRunSnapshot(key) {
   const r = registry.get(key);
   if (!r) return null;
-  return { status: r.status, seq: r.seq, events: r.events.slice(), startedAt: r.startedAt, outputTokens: r.outputTokens };
+  return { status: r.status, seq: r.seq, events: r.events.slice(), startedAt: r.startedAt, runId: r.runId, outputTokens: r.outputTokens };
 }
 function isRunActive(key) {
   return registry.get(key)?.status === "running";

package/dist/{chunk-ZE2JXL6E.mjs → chunk-ETYX2YQF.mjs}

@@ -6812,67 +6812,67 @@ var Or = (self, that) => {
   });
   return error;
 };
-var InvalidData = (path, message, options = {
+var InvalidData = (path2, message, options = {
   pathDelim: "."
 }) => {
   const error = Object.create(proto2);
   error._op = OP_INVALID_DATA;
-  error.path = path;
+  error.path = path2;
   error.message = message;
   Object.defineProperty(error, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join(options.pathDelim));
-      return `(Invalid data at ${path2}: "${this.message}")`;
+      const path3 = pipe(this.path, join(options.pathDelim));
+      return `(Invalid data at ${path3}: "${this.message}")`;
     }
   });
   return error;
 };
-var MissingData = (path, message, options = {
+var MissingData = (path2, message, options = {
   pathDelim: "."
 }) => {
   const error = Object.create(proto2);
   error._op = OP_MISSING_DATA;
-  error.path = path;
+  error.path = path2;
   error.message = message;
   Object.defineProperty(error, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join(options.pathDelim));
-      return `(Missing data at ${path2}: "${this.message}")`;
+      const path3 = pipe(this.path, join(options.pathDelim));
+      return `(Missing data at ${path3}: "${this.message}")`;
     }
   });
   return error;
 };
-var SourceUnavailable = (path, message, cause3, options = {
+var SourceUnavailable = (path2, message, cause3, options = {
   pathDelim: "."
 }) => {
   const error = Object.create(proto2);
   error._op = OP_SOURCE_UNAVAILABLE;
-  error.path = path;
+  error.path = path2;
   error.message = message;
   error.cause = cause3;
   Object.defineProperty(error, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join(options.pathDelim));
-      return `(Source unavailable at ${path2}: "${this.message}")`;
+      const path3 = pipe(this.path, join(options.pathDelim));
+      return `(Source unavailable at ${path3}: "${this.message}")`;
     }
   });
   return error;
 };
-var Unsupported = (path, message, options = {
+var Unsupported = (path2, message, options = {
   pathDelim: "."
 }) => {
   const error = Object.create(proto2);
   error._op = OP_UNSUPPORTED;
-  error.path = path;
+  error.path = path2;
   error.message = message;
   Object.defineProperty(error, "toString", {
     enumerable: false,
     value() {
-      const path2 = pipe(this.path, join(options.pathDelim));
-      return `(Unsupported operation at ${path2}: "${this.message}")`;
+      const path3 = pipe(this.path, join(options.pathDelim));
+      return `(Unsupported operation at ${path3}: "${this.message}")`;
     }
   });
   return error;
@@ -6987,9 +6987,9 @@ var isMissingDataOnly = (self) => reduceWithContext2(self, void 0, IsMissingData
 var empty17 = {
   _tag: "Empty"
 };
-var patch5 = /* @__PURE__ */ dual(2, (path, patch9) => {
+var patch5 = /* @__PURE__ */ dual(2, (path2, patch9) => {
   let input = of3(patch9);
-  let output = path;
+  let output = path2;
   while (isCons(input)) {
     const patch10 = input.head;
     switch (patch10._tag) {
@@ -7056,7 +7056,7 @@ var make20 = (options) => ({
 var makeFlat = (options) => ({
   [FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
   patch: options.patch,
-  load: (path, config2, split3 = true) => options.load(path, config2, split3),
+  load: (path2, config2, split3 = true) => options.load(path2, config2, split3),
   enumerateChildren: options.enumerateChildren
 });
 var fromFlat = (flat) => make20({
@@ -7074,29 +7074,29 @@ var fromEnv = (options) => {
     pathDelim: "_",
     seqDelim: ","
   }, options);
-  const makePathString = (path) => pipe(path, join(pathDelim));
+  const makePathString = (path2) => pipe(path2, join(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {};
-  const load = (path, primitive3, split3 = true) => {
-    const pathString = makePathString(path);
+  const load = (path2, primitive3, split3 = true) => {
+    const pathString = makePathString(path2);
     const current2 = getEnv();
     const valueOpt = pathString in current2 ? some2(current2[pathString]) : none2();
-    return pipe(valueOpt, mapError(() => MissingData(path, `Expected ${pathString} to exist in the process context`)), flatMap8((value) => parsePrimitive(value, path, primitive3, seqDelim, split3)));
+    return pipe(valueOpt, mapError(() => MissingData(path2, `Expected ${pathString} to exist in the process context`)), flatMap8((value) => parsePrimitive(value, path2, primitive3, seqDelim, split3)));
   };
-  const enumerateChildren = (path) => sync(() => {
+  const enumerateChildren = (path2) => sync(() => {
     const current2 = getEnv();
     const keys5 = Object.keys(current2);
     const keyPaths = keys5.map((value) => unmakePathString(value.toUpperCase()));
     const filteredKeyPaths = keyPaths.filter((keyPath) => {
-      for (let i = 0; i < path.length; i++) {
-        const pathComponent = pipe(path, unsafeGet(i));
+      for (let i = 0; i < path2.length; i++) {
+        const pathComponent = pipe(path2, unsafeGet(i));
         const currentElement = keyPath[i];
         if (currentElement === void 0 || pathComponent !== currentElement) {
           return false;
         }
       }
       return true;
-    }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1));
+    }).flatMap((keyPath) => keyPath.slice(path2.length, path2.length + 1));
     return fromIterable6(filteredKeyPaths);
   });
   return fromFlat(makeFlat({
@@ -7112,17 +7112,17 @@ var extend = (leftDef, rightDef, left3, right3) => {
   const rightExtension = concat(right3, rightPad);
   return [leftExtension, rightExtension];
 };
-var appendConfigPath = (path, config2) => {
+var appendConfigPath = (path2, config2) => {
   let op = config2;
   if (op._tag === "Nested") {
-    const out = path.slice();
+    const out = path2.slice();
     while (op._tag === "Nested") {
       out.push(op.name);
       op = op.config;
     }
     return out;
   }
-  return path;
+  return path2;
 };
 var fromFlatLoop = (flat, prefix, config2, split3) => {
   const op = config2;
@@ -7198,8 +7198,8 @@ var fromFlatLoop = (flat, prefix, config2, split3) => {
           return fail2(right3.left);
         }
         if (isRight2(left3) && isRight2(right3)) {
-          const path = pipe(prefix, join("."));
-          const fail20 = fromFlatLoopFail(prefix, path);
+          const path2 = pipe(prefix, join("."));
+          const fail20 = fromFlatLoopFail(prefix, path2);
           const [lefts, rights] = extend(fail20, fail20, pipe(left3.right, map3(right2)), pipe(right3.right, map3(right2)));
           return pipe(lefts, zip(rights), forEachSequential(([left4, right4]) => pipe(zip2(left4, right4), map10(([left5, right5]) => op.zip(left5, right5)))));
         }
@@ -7208,19 +7208,19 @@ var fromFlatLoop = (flat, prefix, config2, split3) => {
     }
   }
 };
-var fromFlatLoopFail = (prefix, path) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path}" was missing`));
+var fromFlatLoopFail = (prefix, path2) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path2}" was missing`));
 var splitPathString = (text, delim) => {
   const split3 = text.split(new RegExp(`\\s*${escape(delim)}\\s*`));
   return split3;
 };
-var parsePrimitive = (text, path, primitive3, delimiter, split3) => {
+var parsePrimitive = (text, path2, primitive3, delimiter, split3) => {
   if (!split3) {
     return pipe(primitive3.parse(text), mapBoth({
-      onFailure: prefixed(path),
+      onFailure: prefixed(path2),
       onSuccess: of
     }));
   }
-  return pipe(splitPathString(text, delimiter), forEachSequential((char) => primitive3.parse(char.trim())), mapError(prefixed(path)));
+  return pipe(splitPathString(text, delimiter), forEachSequential((char) => primitive3.parse(char.trim())), mapError(prefixed(path2)));
 };
 var transpose = (array6) => {
   return Object.keys(array6[0]).map((column) => array6.map((row) => row[column]));
@@ -28601,10 +28601,10 @@ function serializeValue(val) {
     };
   }
   if (val && typeof val === "object" && "segments" in val) {
-    const path = val;
+    const path2 = val;
     return {
       _type: "path",
-      segments: path.segments.map((s) => ({
+      segments: path2.segments.map((s) => ({
         start: serializeValue(s.start),
         relationship: serializeValue(s.relationship),
         end: serializeValue(s.end)
@@ -28629,14 +28629,14 @@ import { execSync } from "child_process";
 
 // packages/shared/utils/src/encodePath.ts
 var CLAUDE_ENCODED_MAX_LEN = 200;
-function claudePathHash(path) {
+function claudePathHash(path2) {
   let h = 0;
-  for (let i = 0; i < path.length; i++) h = (h << 5) - h + path.charCodeAt(i) | 0;
+  for (let i = 0; i < path2.length; i++) h = (h << 5) - h + path2.charCodeAt(i) | 0;
   return Math.abs(h).toString(36);
 }
-function encodePath(path) {
-  const encoded = path.replace(/[^a-zA-Z0-9]/g, "-");
-  return encoded.length <= CLAUDE_ENCODED_MAX_LEN ? encoded : `${encoded.slice(0, CLAUDE_ENCODED_MAX_LEN)}-${claudePathHash(path)}`;
+function encodePath(path2) {
+  const encoded = path2.replace(/[^a-zA-Z0-9]/g, "-");
+  return encoded.length <= CLAUDE_ENCODED_MAX_LEN ? encoded : `${encoded.slice(0, CLAUDE_ENCODED_MAX_LEN)}-${claudePathHash(path2)}`;
 }
 
 // packages/shared/utils/src/paths.ts
@@ -29976,6 +29976,28 @@ import { execFile } from "child_process";
 import { createHash } from "crypto";
 import { mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2, readdir, rm, stat, rename } from "fs/promises";
 import { basename, join as join5, isAbsolute, relative, sep } from "path";
+
+// packages/feature/explorer/src/server/files/shared.ts
+import path from "path";
+var MAX_TEXT_SIZE = 10 * 1024 * 1024;
+var MAX_IMAGE_SIZE = 50 * 1024 * 1024;
+var MAX_PDF_SIZE = 100 * 1024 * 1024;
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".svg",
+  ".ico",
+  ".bmp",
+  ".avif"
+]);
+function isImagePath(filePath) {
+  return IMAGE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+
+// packages/feature/agent/src/effect/snapshotLive.ts
 var BUILTIN_EXCLUDES = [
   ".git/",
   "node_modules/",
@@ -30052,6 +30074,7 @@ var commitFromLogRecord = (record) => {
     timestamp: Number(ts) || 0,
     subject: body.split("\n")[0] ?? "",
     sessionKey: trailers["Session"] ?? null,
+    runId: trailers["Run-Id"] ?? null,
     toolId: trailers["Tool-Id"] ?? null,
     toolName: trailers["Tool"] ?? null,
     toolFiles,
@@ -30227,12 +30250,17 @@ Cockpit-Kind: baseline`
   yield* runGitOk(repoDir, cwd, ["symbolic-ref", "HEAD", branch]);
 });
 var sanitizeSubject = (s) => s.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim().slice(0, 80);
+var sanitizeTrailerValue = (s) => s.replace(/[\u0000-\u001f\u007f]+/g, " ").trim().slice(0, 128);
 var buildCommitMessage = (trigger, relFiles, kind) => {
   const detail = relFiles.length > 0 ? relFiles.length === 1 ? relFiles[0] : `${relFiles[0]} +${relFiles.length - 1}` : trigger.toolDetail ?? "";
   const subject = kind === "baseline" ? "baseline" : sanitizeSubject(`[${trigger.toolName ?? "tool"}] ${detail}`);
   const trailers = [
     `Cockpit-Kind: ${kind}`,
     `Cockpit-Session: ${trigger.sessionKey}`,
+    // Scopes the tool id to ONE dispatch. Required because codex restarts its
+    // live `item_N` counter every turn, so the tool id alone (and even
+    // tool id + session) matches earlier turns of the same session.
+    ...trigger.runId ? [`Cockpit-Run-Id: ${sanitizeTrailerValue(trigger.runId)}`] : [],
     `Cockpit-Provider: ${trigger.provider}`,
     ...trigger.toolId ? [`Cockpit-Tool-Id: ${trigger.toolId}`] : [],
     ...trigger.toolName ? [`Cockpit-Tool: ${trigger.toolName}`] : [],
@@ -30279,10 +30307,10 @@ var snapshotOnce = (snapshotsRoot, maxFileBytes, trigger, kind) => Effect_export
     const addPaths = [];
     const rmPaths = [];
     for (const e of entries2) {
-      const path = e.slice(3);
-      if (!path) continue;
-      if (e[0] === "D" || e[1] === "D") rmPaths.push(path);
-      else addPaths.push(path);
+      const path2 = e.slice(3);
+      if (!path2) continue;
+      if (e[0] === "D" || e[1] === "D") rmPaths.push(path2);
+      else addPaths.push(path2);
     }
     const sizes = yield* Effect_exports.all(
       addPaths.map(
@@ -30363,7 +30391,7 @@ var snapshotOnce = (snapshotsRoot, maxFileBytes, trigger, kind) => Effect_export
     attributes: { cwd: trigger.cwd, tool: trigger.toolName ?? kind }
   })
 );
-var listByToolIdsImpl = (snapshotsRoot, cwd, toolIds, sessionKey) => Effect_exports.gen(function* () {
+var listByToolIdsImpl = (snapshotsRoot, cwd, toolIds, sessionKey, runId) => Effect_exports.gen(function* () {
   if (toolIds.length === 0) return [];
   const repoDir = yield* resolveRepoDir(snapshotsRoot, cwd);
   const headExists = yield* fsTry(
@@ -30381,13 +30409,57 @@ var listByToolIdsImpl = (snapshotsRoot, cwd, toolIds, sessionKey) => Effect_expo
   if (log3.code !== 0) return [];
   const wanted = new Set(toolIds);
   return log3.stdout.split("").filter(Boolean).map(commitFromLogRecord).filter(
-    (c) => !!c && !!c.toolId && wanted.has(c.toolId) && (!sessionKey || c.sessionKey === sessionKey)
+    (c) => !!c && !!c.toolId && wanted.has(c.toolId) && (!sessionKey || c.sessionKey === sessionKey) && // Run-scoping EXCLUDES, it does not require: a commit with no
+    // Cockpit-Run-Id predates run-scoping, and dropping it would make
+    // existing history disappear from the diff viewer. Only a commit
+    // that names a DIFFERENT run is a proven foreign match.
+    (!runId || !c.runId || c.runId === runId)
   );
 }).pipe(Effect_exports.withSpan("snapshot.listByToolIds", { attributes: { cwd } }));
-var showFile = (repoDir, cwd, rev, path) => runGit(repoDir, cwd, ["show", `${rev}:${path}`]).pipe(
+var showFile = (repoDir, cwd, rev, path2) => runGit(repoDir, cwd, ["show", `${rev}:${path2}`]).pipe(
   Effect_exports.map((r) => r.code === 0 ? r.stdout : null),
   Effect_exports.orElseSucceed(() => null)
 );
+var gitShowBytes = (repoDir, cwd, rev, path2) => Effect_exports.tryPromise({
+  try: () => new Promise((resolve2, reject) => {
+    execFile(
+      "git",
+      ["show", `${rev}:${path2}`],
+      {
+        env: {
+          ...process.env,
+          GIT_DIR: repoDir,
+          GIT_WORK_TREE: cwd,
+          GIT_TERMINAL_PROMPT: "0",
+          LC_ALL: "C",
+          GIT_INDEX_FILE: join5(repoDir, "index")
+        },
+        cwd,
+        // Over-cap images fail the exec (maxBuffer) → 404 → the client's
+        // per-side "image failed to load" state.
+        maxBuffer: MAX_IMAGE_SIZE,
+        encoding: "buffer"
+      },
+      (err, stdout) => err ? reject(err) : resolve2(stdout)
+    );
+  }),
+  // A miss is ordinary: the path simply doesn't exist at that revision.
+  catch: () => new NotFoundError({ resource: "snapshot-blob", id: `${rev}:${path2}` })
+});
+var blobImpl = (snapshotsRoot, cwd, rev, file) => Effect_exports.gen(function* () {
+  if (!/^[0-9a-f]{6,40}$/i.test(rev)) {
+    return yield* Effect_exports.fail(new ValidationError({ field: "rev", reason: "invalid commit hash" }));
+  }
+  if (!file || isAbsolute(file) || file.split("/").includes("..")) {
+    return yield* Effect_exports.fail(new ValidationError({ field: "file", reason: "invalid path" }));
+  }
+  if (!isImagePath(file)) {
+    return yield* Effect_exports.fail(new ValidationError({ field: "file", reason: "not an image" }));
+  }
+  const repoDir = yield* resolveRepoDir(snapshotsRoot, cwd);
+  const bytes = yield* gitShowBytes(repoDir, cwd, rev, file);
+  return new Uint8Array(bytes);
+}).pipe(Effect_exports.withSpan("snapshot.blob", { attributes: { cwd, rev } }));
 var diffImpl = (snapshotsRoot, cwd, commitHash) => Effect_exports.gen(function* () {
   if (!/^[0-9a-f]{6,40}$/i.test(commitHash)) {
     return yield* Effect_exports.fail(new ValidationError({ field: "commit", reason: "invalid commit hash" }));
@@ -30444,28 +30516,37 @@ var diffImpl = (snapshotsRoot, cwd, commitHash) => Effect_exports.gen(function*
   const files = [];
   for (let i = 0; i + 1 < tokens.length && files.length < MAX_DIFF_FILES; i += 2) {
     const st = tokens[i];
-    const path = tokens[i + 1];
+    const path2 = tokens[i + 1];
     const status3 = st === "A" ? "added" : st === "D" ? "deleted" : "modified";
-    const binary = binarySet.has(path);
+    const binary = binarySet.has(path2);
     let oldContent = null;
     let newContent = null;
     if (!binary) {
-      if (status3 !== "added") oldContent = yield* showFile(repoDir, cwd, base, path);
-      if (status3 !== "deleted") newContent = yield* showFile(repoDir, cwd, commit3.hash, path);
+      if (status3 !== "added") oldContent = yield* showFile(repoDir, cwd, base, path2);
+      if (status3 !== "deleted") newContent = yield* showFile(repoDir, cwd, commit3.hash, path2);
       if ((oldContent?.length ?? 0) > MAX_DIFF_CONTENT_BYTES || (newContent?.length ?? 0) > MAX_DIFF_CONTENT_BYTES) {
         oldContent = null;
         newContent = null;
       }
     }
-    const stats = lineStats.get(path);
+    const stats = lineStats.get(path2);
+    const isImage = binary && isImagePath(path2);
     files.push({
-      path,
+      path: path2,
       status: status3,
       binary,
       additions: stats?.additions ?? 0,
       deletions: stats?.deletions ?? 0,
       oldContent,
-      newContent
+      newContent,
+      ...isImage ? {
+        isImage: true,
+        // A parentless day-root commit diffs against the empty tree, so
+        // every path comes back "added" — `base` is never handed out as
+        // a revision the client could ask for.
+        oldRev: status3 === "added" ? null : base,
+        newRev: status3 === "deleted" ? null : commit3.hash
+      } : {}
     });
   }
   const truncated = tokens.length / 2 > files.length;
@@ -30591,9 +30672,10 @@ var SnapshotServiceLive = Layer_exports.scoped(
     );
     return SnapshotService.of({
       record: (trigger) => snapshotOnce(snapshotsRoot, maxFileBytes, trigger, "tool"),
-      baseline: (cwd, sessionKey, provider) => snapshotOnce(snapshotsRoot, maxFileBytes, { cwd, sessionKey, provider }, "baseline"),
-      listByToolIds: (cwd, toolIds, sessionKey) => listByToolIdsImpl(snapshotsRoot, cwd, toolIds, sessionKey),
+      baseline: (cwd, sessionKey, provider, runId) => snapshotOnce(snapshotsRoot, maxFileBytes, { cwd, sessionKey, provider, runId }, "baseline"),
+      listByToolIds: (cwd, toolIds, sessionKey, runId) => listByToolIdsImpl(snapshotsRoot, cwd, toolIds, sessionKey, runId),
       diff: (cwd, commitHash) => diffImpl(snapshotsRoot, cwd, commitHash),
+      blob: (cwd, rev, file) => blobImpl(snapshotsRoot, cwd, rev, file),
       cleanup
     });
   })

package/dist/{chunk-H6AI4XJC.mjs → chunk-SGUW2QJI.mjs}

@@ -14,7 +14,7 @@ import {
   readJsonFile,
   sanitizedSpawnEnv,
   writeJsonFile
-} from "./chunk-ZE2JXL6E.mjs";
+} from "./chunk-ETYX2YQF.mjs";
 
 // packages/feature/console/src/server/plugins/browser/BrowserBridge.ts
 import { WebSocket } from "ws";

package/dist/httpApi.mjs

@@ -22,10 +22,10 @@ import {
   unregisterBrowser,
   unregisterTerminal,
   writeStdinToCommand
-} from "./chunk-H6AI4XJC.mjs";
+} from "./chunk-SGUW2QJI.mjs";
 import {
   getTerminalHistoryPath
-} from "./chunk-ZE2JXL6E.mjs";
+} from "./chunk-ETYX2YQF.mjs";
 import "./chunk-7P6ASYW6.mjs";
 
 // src/lib/httpApi.ts