humanish 0.112.0 → 0.114.0

package/dist/observer/run-routes.js

@@ -9,6 +9,7 @@ import { listRuns } from "../run/stored-runs.js";
 import { readAnalysisAccounting } from "../run/costs.js";
 import { bindExistingRunArtifactPaths, isPathInside, isSafeRunIdSegment, } from "../run/paths.js";
 import { isRunOutcome } from "../run/bundle-shape.js";
+import { decodeRunNote, listNoteEntries, MAX_NOTE_FILE_BYTES, noteListing, RUN_NOTES_DIR, runNoteFile, } from "../run/note-files.js";
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
 import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
@@ -16,7 +17,7 @@ import { buildObserverData, recordedStreamEmbed, withObserverEndings, } from "./
 import { buildArtifactSecurityHeaders } from "./http.js";
 import { assertPinnedDirectory, openContainedFile, pinDirectChildDirectory, readContainedFile, relativeToRoot, sha256OfOpenedFile, } from "./pinned-files.js";
 /** The run's artifact paths, only when they are still the pinned directory being served. */
-async function servedRunPaths(runRoot) {
+export async function servedRunPaths(runRoot) {
     const runId = path.basename(runRoot.physicalPath);
     const cwd = path.dirname(path.dirname(path.dirname(runRoot.physicalPath)));
     const prepared = await bindExistingRunArtifactPaths(cwd, runId);
@@ -57,8 +58,40 @@ async function readServedAnalysisSpend(runRoot) {
         return undefined;
     }
 }
-/** internal: consumed by src/observer/serve.ts */
-export async function serveRunPath(runRoot, relativePath, response, runtimeStreamUrls = [], request) {
+/**
+ * The run's reviewer notes as served: notes/ listed, and each note file read within
+ * MAX_NOTE_FILE_BYTES through the root's checks, so a --safe root's admission and hash checks
+ * apply to every note. A file that is not a readable note of the run is skipped and counted.
+ */
+async function readServedNotes(runRoot) {
+    const runId = path.basename(runRoot.physicalPath);
+    let listing;
+    try {
+        await assertPinnedDirectory(runRoot);
+        listing = await listNoteEntries(path.join(runRoot.physicalPath, RUN_NOTES_DIR));
+    }
+    catch {
+        return { runId, notes: [], skipped: [`${RUN_NOTES_DIR} is not a plain folder.`] };
+    }
+    if (listing === null)
+        return { runId, notes: [], skipped: [] };
+    const { ids, skipped } = noteListing(listing);
+    const notes = [];
+    for (const id of ids) {
+        const bytes = await readContainedFile(runRoot, path.join(runRoot.physicalPath, runNoteFile(id)), { maxBytes: MAX_NOTE_FILE_BYTES });
+        const note = bytes === null ? null : decodeRunNote(bytes, runId, id);
+        if (note === null)
+            skipped.push(`${runNoteFile(id)} was skipped.`);
+        else
+            notes.push(note);
+    }
+    return { runId, notes, skipped };
+}
+/**
+ * internal: consumed by src/observer/serve.ts. `notesToken` goes into the run's Observer page so
+ * it can add notes; a server passes it only for a run it takes notes for.
+ */
+export async function serveRunPath(runRoot, relativePath, response, runtimeStreamUrls = [], request, notesToken) {
     const root = runRoot.physicalPath;
     const filePath = path.resolve(root, relativePath === "" ? "observer/index.html" : relativePath);
     if (!isPathInside(root, filePath)) {
@@ -87,7 +120,12 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
             return;
         }
         const analysis = await readObserverAnalysis(runRoot);
-        writeResponse(response, 200, renderObserverHtml(observerData, { analysis }), "text/html; charset=utf-8");
+        const notes = await readServedNotes(runRoot);
+        writeResponse(response, 200, renderObserverHtml(observerData, {
+            analysis,
+            notes,
+            ...(notesToken === undefined ? {} : { notesToken }),
+        }), "text/html; charset=utf-8");
         return;
     }
     if (cleanedRelativePath === "observer/observer-data.json") {
@@ -103,7 +141,10 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
         writeResponse(response, 200, JSON.stringify(await readObserverAnalysis(runRoot)), "application/json; charset=utf-8");
         return;
     }
-    if (path.extname(filePath).toLowerCase() === ".mp4") {
+    // Every file under notes/ is read within the note limit, whatever its name, so media handling
+    // never streams one.
+    const notePath = derivedRoot === RUN_NOTES_DIR;
+    if (!notePath && path.extname(filePath).toLowerCase() === ".mp4") {
         await serveContainedMedia(runRoot, filePath, response, request);
         return;
     }
@@ -112,7 +153,7 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
         return;
     }
     try {
-        const body = await readContainedFile(runRoot, filePath);
+        const body = await readContainedFile(runRoot, filePath, notePath ? { maxBytes: MAX_NOTE_FILE_BYTES } : {});
         if (!body) {
             writeResponse(response, 404, "Not found", "text/plain; charset=utf-8");
             return;

package/dist/observer/serve.d.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from "node:http";
+import { type NotesWriter } from "./notes-route.js";
 import type { PinnedDirectory } from "./pinned-files.js";
 import { type AdmittedRun } from "./run-inventory.js";
 import type { LibraryHistory } from "./library.js";
@@ -70,6 +71,8 @@ export declare function createShareSafetyAdmission(cwd: string, options?: {
 }): ShareSafetyAdmission;
 export interface ServeRequestHandlerOptions {
     proofRoot: PinnedDirectory;
+    /** Takes reviewer notes on loopback; without it the library refuses them. */
+    notes?: NotesWriter;
     safe: boolean;
     admit: (runId: string) => Promise<AdmittedRun | null>;
     hostAllowlist: ReadonlySet<string>;

package/dist/observer/serve.js

@@ -3,7 +3,9 @@ import { runNotFoundMessage } from "../run/run-not-found.js";
 import { createServer } from "node:http";
 import path from "node:path";
 import { pinDirectChildDirectory, pinDirectory } from "./pinned-files.js";
-import { buildHistoryIndex, matchRunRoute, serveRunPath } from "./run-routes.js";
+import { createNotesWriter, NOTES_PATH } from "./notes-route.js";
+import { renderObserver } from "./render.js";
+import { buildHistoryIndex, matchRunRoute, servedRunPaths, serveRunPath } from "./run-routes.js";
 import { hashRunInventory, inventoryRoot, readRunInventory, } from "./run-inventory.js";
 import { renderLibraryHtml } from "./library.js";
 import { buildServeSecurityHeaders, hostAllowed, parsePublicOrigin, } from "./http.js";
@@ -104,6 +106,13 @@ export function createServeRequestHandler(options) {
             for (const [name, value] of Object.entries(buildServeSecurityHeaders())) {
                 response.setHeader(name, value);
             }
+            if (new URL(request.url ?? "/", "http://127.0.0.1").pathname === NOTES_PATH) {
+                if (options.notes)
+                    await options.notes.handle(request, response);
+                else
+                    writeText(response, 405, "Method Not Allowed");
+                return;
+            }
             const method = request.method ?? "GET";
             if (method !== "GET" && method !== "HEAD") {
                 writeText(response, 405, "Method Not Allowed");
@@ -161,7 +170,7 @@ export function createServeRequestHandler(options) {
                 }
                 // The explicit empty runtimeStreamUrls keeps a future refactor from
                 // reintroducing auth-keyed stream injection on the serve surface.
-                await serveRunPath(targetRoot, runRoute.relativePath || "observer/index.html", response, [], request);
+                await serveRunPath(targetRoot, runRoute.relativePath || "observer/index.html", response, [], request, options.notes?.pageToken(request));
                 return;
             }
             writeText(response, 404, "Not found");
@@ -260,8 +269,24 @@ export async function serveObserverLibrary(cwdInput, options) {
     }
     const declaredOrigin = options.publicOrigin ? parsePublicOrigin(options.publicOrigin) : null;
     const hostAllowlist = new Set();
+    let port = 0;
+    const notes = createNotesWriter({
+        exposed: mode !== "loopback",
+        port: () => port,
+        resolveRun: async (runId) => {
+            const pinned = await pinDirectChildDirectory(proofRoot, runId);
+            if (!pinned || (options.safe && (await admission.admit(runId)) === null))
+                return null;
+            return servedRunPaths(pinned);
+        },
+        refresh: (prepared) => renderObserver(cwd, path.basename(prepared.physicalRunRoot), {
+            open: false,
+            expectedRun: prepared,
+        }),
+    });
     const handler = createServeRequestHandler({
         proofRoot,
+        notes,
         safe: options.safe,
         admit: (runId) => admission.admit(runId),
         hostAllowlist,
@@ -276,7 +301,6 @@ export async function serveObserverLibrary(cwdInput, options) {
     const server = createServer((request, response) => {
         void handler(request, response);
     });
-    let port;
     try {
         port = await listenOnLoopback(server, options.port);
     }
@@ -314,6 +338,7 @@ export async function serveObserverLibrary(cwdInput, options) {
                 hostAllowlist.add(parsed.host);
             },
             close: async () => {
+                await notes.settled();
                 const closed = closeServer(server);
                 // Keep-alive sockets would otherwise keep close() pending past the point
                 // the operator believes Ctrl-C tore the server down.