ahp-inspector 1.4.2 → 1.5.0

package/dist/index.js

@@ -464,6 +464,13 @@ function objectChild(parent, key) {
   return typeof child === "object" && child !== null ? child : null;
 }
 function candidateObjects(p) {
+  if (Array.isArray(p)) {
+    const items = [];
+    for (const item of p) {
+      if (typeof item === "object" && item !== null) items.push(item);
+    }
+    return items;
+  }
   const out = [p];
   const action = objectChild(p, "action");
   if (action) out.push(action);
@@ -478,7 +485,25 @@ function sessionFromObject(p) {
     const uri = session.uri;
     if (typeof uri === "string") return uri;
   }
-  return asString(p.sessionId);
+  const sessionId = asString(p.sessionId);
+  if (sessionId) return sessionId;
+  const channel = asString(p.channel);
+  if (channel) return channel;
+  const terminal = asString(p.terminal);
+  if (terminal) return terminal;
+  const resource = asString(p.resource);
+  if (resource) return resource;
+  const external = asString(p.external);
+  if (external) return external;
+  const scheme = asString(p.scheme);
+  const path = asString(p.path);
+  if (scheme && path) return `${scheme}:${path}`;
+  const summary = p.summary;
+  if (typeof summary === "object" && summary !== null) {
+    const summaryResource = asString(summary.resource);
+    if (summaryResource) return summaryResource;
+  }
+  return null;
 }
 function turnFromObject(p) {
   const fromTop = asString(p.turnId);
@@ -2639,6 +2664,7 @@ import { Buffer as Buffer2 } from "buffer";
 import { basename as basename6 } from "path";
 
 // ../core/src/correlator.ts
+var MAX_PENDING = 1e4;
 var Correlator = class {
   #store;
   #pendingRequests = /* @__PURE__ */ new Map();
@@ -2652,6 +2678,14 @@ var Correlator = class {
     this.#store = store;
     this.#unsubscribe = store.subscribe((range) => this.#onAppend(range));
   }
+  /** Outstanding requests awaiting a response (bounded by {@link MAX_PENDING}). */
+  get pendingRequestCount() {
+    return this.#pendingRequests.size;
+  }
+  /** Out-of-order responses awaiting a request (bounded by {@link MAX_PENDING}). */
+  get pendingResponseCount() {
+    return this.#pendingResponses.size;
+  }
   pairOf(idx) {
     const v = this.pairIdx[idx];
     return v === void 0 || v < 0 ? null : v;
@@ -2723,6 +2757,16 @@ var Correlator = class {
     if (displaced !== void 0) {
       this.status[displaced] = "orphan";
       this.#changedIndexes.add(displaced);
+    } else if (this.#pendingRequests.size >= MAX_PENDING) {
+      const oldestKey = this.#pendingRequests.keys().next().value;
+      if (oldestKey !== void 0) {
+        const oldIdx = this.#pendingRequests.get(oldestKey);
+        this.#pendingRequests.delete(oldestKey);
+        if (oldIdx !== void 0) {
+          this.status[oldIdx] = "unmatched";
+          this.#changedIndexes.add(oldIdx);
+        }
+      }
     }
     this.#pendingRequests.set(key, idx);
     this.status[idx] = "pending";
@@ -2740,6 +2784,9 @@ var Correlator = class {
     if (displaced !== void 0) {
       this.status[displaced] = "orphan";
       this.#changedIndexes.add(displaced);
+    } else if (this.#pendingResponses.size >= MAX_PENDING) {
+      const oldestKey = this.#pendingResponses.keys().next().value;
+      if (oldestKey !== void 0) this.#pendingResponses.delete(oldestKey);
     }
     this.#pendingResponses.set(key, idx);
   }
@@ -3000,7 +3047,7 @@ function refreshSummaryStatus(state) {
   }
   return { ...state, summary: { ...state.summary, status } };
 }
-function endTurn(state, turnId, turnState, terminalStatus, error) {
+function endTurn(state, turnId, turnState, terminalStatus, error, now = Date.now) {
   if (!state.activeTurn || state.activeTurn.id !== turnId) {
     return state;
   }
@@ -3036,7 +3083,7 @@ function endTurn(state, turnId, turnState, terminalStatus, error) {
     ...state,
     turns: [...state.turns, turn],
     activeTurn: void 0,
-    summary: { ...state.summary, modifiedAt: Date.now() }
+    summary: { ...state.summary, modifiedAt: now() }
   };
   delete next.inputRequests;
   return {
@@ -3044,7 +3091,7 @@ function endTurn(state, turnId, turnState, terminalStatus, error) {
     summary: { ...next.summary, status: summaryStatus(next, terminalStatus) }
   };
 }
-function upsertInputRequest(state, request) {
+function upsertInputRequest(state, request, now = Date.now) {
   const existing = state.inputRequests ?? [];
   const idx = existing.findIndex((r) => r.id === request.id);
   const inputRequests = [...existing];
@@ -3060,7 +3107,7 @@ function upsertInputRequest(state, request) {
     summary: {
       ...next.summary,
       status: withStatusFlag(summaryStatus(next), 32 /* IsRead */, false),
-      modifiedAt: Date.now()
+      modifiedAt: now()
     }
   };
 }
@@ -3113,7 +3160,7 @@ function updateResponsePart(state, turnId, partId, updater) {
     activeTurn: { ...activeTurn, responseParts }
   };
 }
-function sessionReducer(state, action, log) {
+function sessionReducer(state, action, log, now = Date.now) {
   switch (action.type) {
     // ── Lifecycle ──────────────────────────────────────────────────────────
     case "session/ready" /* SessionReady */:
@@ -3144,7 +3191,7 @@ function sessionReducer(state, action, log) {
         summary: {
           ...next.summary,
           status: withStatusFlag(summaryStatus(next), 32 /* IsRead */, false),
-          modifiedAt: Date.now()
+          modifiedAt: now()
         }
       };
       if (action.queuedMessageId) {
@@ -3177,11 +3224,11 @@ function sessionReducer(state, action, log) {
         }
       };
     case "session/turnComplete" /* SessionTurnComplete */:
-      return endTurn(state, action.turnId, "complete" /* Complete */);
+      return endTurn(state, action.turnId, "complete" /* Complete */, void 0, void 0, now);
     case "session/turnCancelled" /* SessionTurnCancelled */:
-      return endTurn(state, action.turnId, "cancelled" /* Cancelled */);
+      return endTurn(state, action.turnId, "cancelled" /* Cancelled */, void 0, void 0, now);
     case "session/error" /* SessionError */:
-      return endTurn(state, action.turnId, "error" /* Error */, 2 /* Error */, action.error);
+      return endTurn(state, action.turnId, "error" /* Error */, 2 /* Error */, action.error, now);
     // ── Tool Call State Machine ───────────────────────────────────────────
     case "session/toolCallStart" /* SessionToolCallStart */:
       if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
@@ -3353,7 +3400,7 @@ function sessionReducer(state, action, log) {
     case "session/titleChanged" /* SessionTitleChanged */:
       return {
         ...state,
-        summary: { ...state.summary, title: action.title, modifiedAt: Date.now() }
+        summary: { ...state.summary, title: action.title, modifiedAt: now() }
       };
     case "session/usage" /* SessionUsage */:
       if (!state.activeTurn || state.activeTurn.id !== action.turnId) {
@@ -3373,7 +3420,7 @@ function sessionReducer(state, action, log) {
     case "session/modelChanged" /* SessionModelChanged */:
       return {
         ...state,
-        summary: { ...state.summary, model: action.model, modifiedAt: Date.now() }
+        summary: { ...state.summary, model: action.model, modifiedAt: now() }
       };
     case "session/isReadChanged" /* SessionIsReadChanged */:
       return {
@@ -3414,7 +3461,7 @@ function sessionReducer(state, action, log) {
           },
           summary: {
             ...state.summary,
-            modifiedAt: Date.now()
+            modifiedAt: now()
           }
         };
       }
@@ -3432,7 +3479,7 @@ function sessionReducer(state, action, log) {
         },
         summary: {
           ...state.summary,
-          modifiedAt: Date.now()
+          modifiedAt: now()
         }
       };
     }
@@ -3515,7 +3562,7 @@ function sessionReducer(state, action, log) {
         ...state,
         turns,
         activeTurn: void 0,
-        summary: { ...state.summary, modifiedAt: Date.now() }
+        summary: { ...state.summary, modifiedAt: now() }
       };
       delete next.inputRequests;
       return {
@@ -3525,7 +3572,7 @@ function sessionReducer(state, action, log) {
     }
     // ── Session Input Requests ─────────────────────────────────────────────
     case "session/inputRequested" /* SessionInputRequested */:
-      return upsertInputRequest(state, action.request);
+      return upsertInputRequest(state, action.request, now);
     case "session/inputAnswerChanged" /* SessionInputAnswerChanged */: {
       const existing = state.inputRequests;
       const idx = existing?.findIndex((request2) => request2.id === action.requestId) ?? -1;
@@ -3547,7 +3594,7 @@ function sessionReducer(state, action, log) {
       return {
         ...state,
         inputRequests: updated,
-        summary: { ...state.summary, modifiedAt: Date.now() }
+        summary: { ...state.summary, modifiedAt: now() }
       };
     }
     case "session/inputCompleted" /* SessionInputCompleted */: {
@@ -3566,7 +3613,7 @@ function sessionReducer(state, action, log) {
       }
       return {
         ...next,
-        summary: { ...next.summary, status: summaryStatus(next), modifiedAt: Date.now() }
+        summary: { ...next.summary, status: summaryStatus(next), modifiedAt: now() }
       };
     }
     // ── Pending Messages ──────────────────────────────────────────────────
@@ -3979,15 +4026,20 @@ function applyEnvelope(ctx, envelope, eventIdx, eventTs) {
       details: { actionType: actionTypeOf(envelope.action) }
     });
   };
-  resource.state = withEventTime(eventTs, () => {
+  resource.state = (() => {
     if (target.kind === "root") {
       return rootReducer(resource.state, envelope.action, log);
     }
     if (target.kind === "session") {
-      return sessionReducer(resource.state, envelope.action, log);
+      return sessionReducer(
+        resource.state,
+        envelope.action,
+        log,
+        () => eventTs
+      );
     }
     return terminalReducer(resource.state, envelope.action, log);
-  });
+  })();
   resource.lastAppliedEventIdx = eventIdx;
   resource.lastServerSeq = envelope.serverSeq;
   linkAcceptedIntent(ctx, envelope);
@@ -4063,15 +4115,6 @@ function linkAcceptedIntent(ctx, envelope) {
   }
   ctx.intents[idx] = { ...intent, acceptedByServerSeq: envelope.serverSeq };
 }
-function withEventTime(eventTs, fn) {
-  const original = Date.now;
-  Date.now = () => eventTs;
-  try {
-    return fn();
-  } finally {
-    Date.now = original;
-  }
-}
 function readSnapshot(value) {
   if (!isRecord(value) || typeof value.resource !== "string" || typeof value.fromSeq !== "number") {
     return null;
@@ -4653,9 +4696,17 @@ function formatTs(ms) {
   )}`;
 }
 function formatSessionShort(sessionId) {
-  const parts = sessionId.split(/[/:]+/).filter(Boolean);
-  let label = parts.at(-1) ?? sessionId;
-  label = label.replace(/^session[-_:]?/i, "");
+  const watched = formatResourceWatchChannel(sessionId);
+  if (watched) return watched;
+  return shortenIdLabel(sessionId, /^session[-_:]?/i);
+}
+function formatTurnShort(turnId) {
+  return shortenIdLabel(turnId, /^turn[-_:]?/i);
+}
+function shortenIdLabel(id, stripPrefix) {
+  const parts = id.split(/[/:]+/).filter(Boolean);
+  let label = parts.at(-1) ?? id;
+  label = label.replace(stripPrefix, "");
   label = label.replace(/[-_]\d{4}[-_]\d{2}[-_]\d{2}$/u, "");
   if (/^[0-9a-f]{16,}$/iu.test(label)) return label.slice(-8);
   const uuidFirstSegment = label.match(/^[0-9a-f]{8}(?=-[0-9a-f]{4}-)/iu)?.[0];
@@ -4663,6 +4714,24 @@ function formatSessionShort(sessionId) {
   if (label.length <= 18) return label;
   return `${label.slice(0, 17)}\u2026`;
 }
+function formatResourceWatchChannel(sessionId) {
+  const match2 = sessionId.match(/^ahp-resource-watch:\/\/[^/]*\/(.+)$/u);
+  if (!match2) return null;
+  const encoded = match2[1];
+  if (!encoded) return null;
+  try {
+    const normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+    const json = atob(normalized);
+    const parsed = JSON.parse(json);
+    const root = parsed.root ?? parsed.uri ?? parsed.resource;
+    if (typeof root !== "string") return null;
+    const tail = root.split(/[/\\]/u).filter(Boolean).at(-1) ?? root;
+    const name = decodeURIComponent(tail);
+    return `watch:${name.length <= 24 ? name : `${name.slice(0, 23)}\u2026`}`;
+  } catch {
+    return null;
+  }
+}
 function payloadPreviewOf(raw2) {
   if (raw2 === void 0 || raw2 === null) return "";
   let src = raw2;
@@ -4743,7 +4812,7 @@ function projectRow(event, idx, status, latencyMs, extras = DEFAULT_EXTRAS, pair
     sessionId: session,
     sessionShort: session ? formatSessionShort(session) : null,
     turnId: turn,
-    turnShort: turn ? turn.slice(-6) : null,
+    turnShort: turn ? formatTurnShort(turn) : null,
     keyId: idStr ? idStr.length > 12 ? idStr.slice(0, 12) : idStr : null,
     status,
     latencyMs,
@@ -5137,25 +5206,44 @@ async function createAppState(opts) {
   };
 }
 
+// ../server/src/origin.ts
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "localhost", "::1", "[::1]"]);
+function isAllowedOrigin(origin) {
+  if (origin === void 0 || origin === null || origin === "") return true;
+  if (origin === "null") return true;
+  if (origin.startsWith("vscode-webview://")) return true;
+  let url;
+  try {
+    url = new URL(origin);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  return LOOPBACK_HOSTS.has(url.hostname);
+}
+
 // ../server/src/cors.ts
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "PATCH", "DELETE"]);
 var corsMiddleware = async (c, next) => {
   const origin = c.req.header("origin");
+  const allowed = isAllowedOrigin(origin);
   if (c.req.method === "OPTIONS") {
     const reqHeaders = c.req.header("access-control-request-headers") ?? "*";
     const reqMethod = c.req.header("access-control-request-method") ?? "GET";
-    return new Response(null, {
-      status: 204,
-      headers: {
-        "access-control-allow-origin": origin ?? "*",
-        "access-control-allow-methods": `${reqMethod}, GET, POST, OPTIONS`,
-        "access-control-allow-headers": reqHeaders,
-        "access-control-max-age": "600",
-        vary: "Origin"
-      }
-    });
+    const headers = {
+      "access-control-allow-methods": `${reqMethod}, GET, POST, OPTIONS`,
+      "access-control-allow-headers": reqHeaders,
+      "access-control-max-age": "600",
+      vary: "Origin"
+    };
+    if (allowed) headers["access-control-allow-origin"] = origin ?? "*";
+    return new Response(null, { status: 204, headers });
+  }
+  if (origin !== void 0 && !allowed && MUTATING_METHODS.has(c.req.method)) {
+    return c.json({ code: "forbidden-origin", message: "forbidden-origin" }, 403);
   }
   await next();
-  if (origin) {
+  if (allowed && origin !== void 0) {
     c.res.headers.set("access-control-allow-origin", origin);
     c.res.headers.append("vary", "Origin");
   }
@@ -7928,7 +8016,7 @@ function registerSearchRoutes(app, sessions) {
 // ../server/src/session-routes.ts
 function registerSessionRoutes(app, sessions) {
   app.get("/api/sessions/discover", async (c) => {
-    const r = await discoverVsCodeLogs();
+    const r = await sessions.discover();
     return c.json({ candidates: r.candidates, truncated: r.truncated });
   });
   app.post("/api/sessions/open", async (c) => {
@@ -8122,7 +8210,9 @@ var streamSSE = (c, cb, onError) => {
 // ../server/src/sse-routes.ts
 var SNAPSHOT_CHUNK = 2e3;
 var PING_INTERVAL_MS = 2e4;
+var MAX_SSE_CONNECTIONS = 8;
 function registerLogRoutes(app, sessions) {
+  let activeStreams = 0;
   app.get("/api/log/meta", (c) => {
     const a = sessions.current();
     if (!a) return c.body(null, 204);
@@ -8133,127 +8223,135 @@ function registerLogRoutes(app, sessions) {
     if (!initial) {
       return c.json({ code: "no-active-log" }, 409);
     }
+    if (activeStreams >= MAX_SSE_CONNECTIONS) {
+      return c.json({ code: "too-many-streams" }, 503);
+    }
+    activeStreams++;
     return streamSSE(c, async (stream2) => {
-      const a = initial;
-      const queue = [];
-      let queueStart = 0;
-      let pumping = false;
-      let snapshotStreaming = true;
-      const queuedFrameCount = () => queue.length - queueStart;
-      const pump = async () => {
-        if (pumping || snapshotStreaming) return;
-        pumping = true;
-        try {
-          while (queuedFrameCount() > 0 && !stream2.aborted && !stream2.closed) {
-            const msg = queue[queueStart++];
-            if (!msg) break;
-            try {
-              await stream2.writeSSE({ event: msg.kind, data: JSON.stringify(msg) });
-            } catch {
-              return;
+      try {
+        const a = initial;
+        const queue = [];
+        let queueStart = 0;
+        let pumping = false;
+        let snapshotStreaming = true;
+        const queuedFrameCount = () => queue.length - queueStart;
+        const pump = async () => {
+          if (pumping || snapshotStreaming) return;
+          pumping = true;
+          try {
+            while (queuedFrameCount() > 0 && !stream2.aborted && !stream2.closed) {
+              const msg = queue[queueStart++];
+              if (!msg) break;
+              try {
+                await stream2.writeSSE({ event: msg.kind, data: JSON.stringify(msg) });
+              } catch {
+                return;
+              }
             }
+          } finally {
+            if (queueStart === queue.length) {
+              queue.length = 0;
+              queueStart = 0;
+            }
+            pumping = false;
           }
-        } finally {
-          if (queueStart === queue.length) {
-            queue.length = 0;
-            queueStart = 0;
+        };
+        const off = a.appState.subscribe((msg) => {
+          queue.push(msg);
+          void pump();
+        });
+        const snap = a.appState.snapshot();
+        await stream2.writeSSE({
+          event: "snapshot-begin",
+          data: JSON.stringify({ meta: snap.meta, total: snap.rows.length })
+        });
+        for (let i = 0; i < snap.rows.length; i += SNAPSHOT_CHUNK) {
+          if (stream2.aborted || stream2.closed) {
+            off();
+            return;
           }
-          pumping = false;
+          const chunk = snap.rows.slice(i, i + SNAPSHOT_CHUNK);
+          await stream2.writeSSE({
+            event: "snapshot-chunk",
+            data: JSON.stringify({ rows: chunk, from: i })
+          });
+          await stream2.sleep(0);
         }
-      };
-      const off = a.appState.subscribe((msg) => {
-        queue.push(msg);
-        void pump();
-      });
-      const snap = a.appState.snapshot();
-      await stream2.writeSSE({
-        event: "snapshot-begin",
-        data: JSON.stringify({ meta: snap.meta, total: snap.rows.length })
-      });
-      for (let i = 0; i < snap.rows.length; i += SNAPSHOT_CHUNK) {
         if (stream2.aborted || stream2.closed) {
           off();
           return;
         }
-        const chunk = snap.rows.slice(i, i + SNAPSHOT_CHUNK);
-        await stream2.writeSSE({
-          event: "snapshot-chunk",
-          data: JSON.stringify({ rows: chunk, from: i })
-        });
-        await stream2.sleep(0);
-      }
-      if (stream2.aborted || stream2.closed) {
-        off();
-        return;
-      }
-      await stream2.writeSSE({ event: "snapshot-end", data: "{}" });
-      if (snap.loadProgress.phase !== "idle") {
-        await stream2.writeSSE({
-          event: snap.loadProgress.kind,
-          data: JSON.stringify(snap.loadProgress)
+        await stream2.writeSSE({ event: "snapshot-end", data: "{}" });
+        if (snap.loadProgress.phase !== "idle") {
+          await stream2.writeSSE({
+            event: snap.loadProgress.kind,
+            data: JSON.stringify(snap.loadProgress)
+          });
+        }
+        snapshotStreaming = false;
+        if (queuedFrameCount() > 0) {
+          const queuedRows = queue.slice(queueStart).reduce((total, msg) => total + (msg.kind === "append" ? msg.rows.length : 0), 0);
+          const backlog = {
+            kind: "stream-backlog",
+            queuedFrames: queuedFrameCount(),
+            queuedRows
+          };
+          await stream2.writeSSE({ event: backlog.kind, data: JSON.stringify(backlog) });
+          await pump();
+          const clearedBacklog = {
+            kind: "stream-backlog",
+            queuedFrames: 0,
+            queuedRows: 0
+          };
+          await stream2.writeSSE({
+            event: clearedBacklog.kind,
+            data: JSON.stringify(clearedBacklog)
+          });
+        } else {
+          await pump();
+        }
+        let endRequested = false;
+        const offChange = sessions.onChange(async () => {
+          if (endRequested) return;
+          endRequested = true;
+          try {
+            await stream2.writeSSE({ event: "log-reset", data: "{}" });
+          } catch {
+          }
         });
-      }
-      snapshotStreaming = false;
-      if (queuedFrameCount() > 0) {
-        const queuedRows = queue.slice(queueStart).reduce((total, msg) => total + (msg.kind === "append" ? msg.rows.length : 0), 0);
-        const backlog = {
-          kind: "stream-backlog",
-          queuedFrames: queuedFrameCount(),
-          queuedRows
-        };
-        await stream2.writeSSE({ event: backlog.kind, data: JSON.stringify(backlog) });
-        await pump();
-        const clearedBacklog = {
-          kind: "stream-backlog",
-          queuedFrames: 0,
-          queuedRows: 0
-        };
-        await stream2.writeSSE({
-          event: clearedBacklog.kind,
-          data: JSON.stringify(clearedBacklog)
+        const pinger = setInterval(() => {
+          if (stream2.aborted || stream2.closed) return;
+          stream2.writeSSE({ event: "ping", data: "{}" }).catch(() => {
+          });
+        }, PING_INTERVAL_MS);
+        await new Promise((resolveWait) => {
+          if (stream2.aborted || stream2.closed) {
+            resolveWait();
+            return;
+          }
+          stream2.onAbort(() => resolveWait());
+          const tick = setInterval(() => {
+            if (endRequested) {
+              clearInterval(tick);
+              resolveWait();
+            }
+          }, 50);
         });
-      } else {
-        await pump();
-      }
-      let endRequested = false;
-      const offChange = sessions.onChange(async () => {
-        if (endRequested) return;
-        endRequested = true;
+        clearInterval(pinger);
         try {
-          await stream2.writeSSE({ event: "log-reset", data: "{}" });
+          off();
         } catch {
         }
-      });
-      const pinger = setInterval(() => {
-        if (stream2.aborted || stream2.closed) return;
-        stream2.writeSSE({ event: "ping", data: "{}" }).catch(() => {
-        });
-      }, PING_INTERVAL_MS);
-      await new Promise((resolveWait) => {
-        if (stream2.aborted || stream2.closed) {
-          resolveWait();
-          return;
+        try {
+          offChange();
+        } catch {
         }
-        stream2.onAbort(() => resolveWait());
-        const tick = setInterval(() => {
-          if (endRequested) {
-            clearInterval(tick);
-            resolveWait();
-          }
-        }, 50);
-      });
-      clearInterval(pinger);
-      try {
-        off();
-      } catch {
-      }
-      try {
-        offChange();
-      } catch {
-      }
-      try {
-        await stream2.writeSSE({ event: "bye", data: "{}" });
-      } catch {
+        try {
+          await stream2.writeSSE({ event: "bye", data: "{}" });
+        } catch {
+        }
+      } finally {
+        activeStreams--;
       }
     });
   });
@@ -8608,6 +8706,41 @@ import { tmpdir } from "os";
 import { extname as extname2, join as join6, basename as pathBasename } from "path";
 var MAX_UPLOAD_BYTES = 100 * 1024 * 1024;
 var UPLOAD_DIR_PREFIX = "ahp-inspector-upload-";
+var BodyTooLargeError = class extends Error {
+};
+async function readBodyCapped(body, maxBytes) {
+  if (!body) return new Uint8Array(0);
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    let result;
+    try {
+      result = await reader.read();
+    } catch {
+      reader.releaseLock();
+      throw new Error("read-failed");
+    }
+    if (result.done) break;
+    const value = result.value;
+    if (!value) continue;
+    total += value.byteLength;
+    if (total > maxBytes) {
+      await reader.cancel().catch(() => {
+      });
+      throw new BodyTooLargeError();
+    }
+    chunks.push(value);
+  }
+  reader.releaseLock();
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out;
+}
 function sanitizeFilename(raw2) {
   let decoded;
   try {
@@ -8658,8 +8791,9 @@ function createUploadStore() {
   }
   return { write, cleanupAllExcept, disposeAll };
 }
-function registerUploadRoutes(app, sessions) {
+function registerUploadRoutes(app, sessions, opts) {
   const store = createUploadStore();
+  const maxBytes = opts?.maxUploadBytes ?? MAX_UPLOAD_BYTES;
   const unsubscribe = sessions.onChange((active) => {
     if (active === null) {
       void store.disposeAll();
@@ -8680,24 +8814,24 @@ function registerUploadRoutes(app, sessions) {
     }
     const lengthHeader = c.req.header("content-length");
     const declaredLength = lengthHeader ? Number.parseInt(lengthHeader, 10) : Number.NaN;
-    if (Number.isFinite(declaredLength) && declaredLength > MAX_UPLOAD_BYTES) {
+    if (Number.isFinite(declaredLength) && declaredLength > maxBytes) {
       return c.json({ code: "too-large", message: "too-large" }, 413);
     }
-    let buf;
+    let bytes;
     try {
-      buf = await c.req.arrayBuffer();
-    } catch {
+      bytes = await readBodyCapped(c.req.raw.body, maxBytes);
+    } catch (err) {
+      if (err instanceof BodyTooLargeError) {
+        return c.json({ code: "too-large", message: "too-large" }, 413);
+      }
       return c.json({ code: "bad-request", message: "could not read body" }, 400);
     }
-    if (buf.byteLength === 0) {
+    if (bytes.byteLength === 0) {
       return c.json({ code: "bad-request", message: "empty body" }, 400);
     }
-    if (buf.byteLength > MAX_UPLOAD_BYTES) {
-      return c.json({ code: "too-large", message: "too-large" }, 413);
-    }
     let tempPath;
     try {
-      tempPath = await store.write(safeName, new Uint8Array(buf));
+      tempPath = await store.write(safeName, bytes);
     } catch {
       return c.json({ code: "io-error", message: "io-error" }, 500);
     }
@@ -8830,6 +8964,7 @@ function createLogSessionManager(opts) {
   }
   return {
     current: () => active,
+    discover: () => opts.host.discoverLogs(),
     async open(input) {
       const next = chain.then(async () => {
         if ("path" in input) return doOpen(input.path);