doer-agent 0.5.7 → 0.5.9

package/dist/agent-session-rpc.js

@@ -1,5 +1,6 @@
 import { watch } from "node:fs";
-import { open, readdir, realpath, rm, rmdir, stat, unlink } from "node:fs/promises";
+import { open, mkdir, readdir, realpath, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import crypto from "node:crypto";
 import path from "node:path";
 import { StringCodec } from "nats";
 const sessionRpcCodec = StringCodec();
@@ -89,6 +90,84 @@ function buildInlineBlobMarker(value) {
     }
     return "[inline blob omitted]";
 }
+function extensionForImageMimeType(mimeType) {
+    const normalized = mimeType.trim().toLowerCase();
+    if (normalized === "image/jpeg" || normalized === "image/jpg")
+        return ".jpg";
+    if (normalized === "image/webp")
+        return ".webp";
+    if (normalized === "image/gif")
+        return ".gif";
+    if (normalized === "image/svg+xml")
+        return ".svg";
+    if (normalized === "image/bmp")
+        return ".bmp";
+    if (normalized === "image/avif")
+        return ".avif";
+    return ".png";
+}
+function decodeInlineImageDataUrl(value) {
+    const trimmed = value.trim();
+    const match = /^data:([^;,]+)(?:;[^,]*)?;base64,([\s\S]+)$/i.exec(trimmed);
+    if (!match) {
+        return null;
+    }
+    const mimeType = match[1]?.trim().toLowerCase() || "";
+    if (!mimeType.startsWith("image/")) {
+        return null;
+    }
+    const base64 = match[2]?.replace(/\s/g, "") || "";
+    if (!base64) {
+        return null;
+    }
+    try {
+        return {
+            bytes: Buffer.from(base64, "base64"),
+            mimeType,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeSessionPathSegment(value, fallback) {
+    return value.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || fallback;
+}
+function inferSessionIdFromSessionFilePath(filePath) {
+    const base = path.basename(filePath, path.extname(filePath));
+    const match = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)$/.exec(base);
+    const inferred = match?.[1]?.trim() || "";
+    return inferred || null;
+}
+async function materializeInlineSessionImage(args) {
+    const decoded = decodeInlineImageDataUrl(args.value);
+    if (!decoded || decoded.bytes.byteLength === 0) {
+        return null;
+    }
+    const inferredSessionId = inferSessionIdFromSessionFilePath(args.filePath);
+    const sessionBase = (args.sessionId ? sanitizeSessionPathSegment(args.sessionId, "") : "")
+        || (inferredSessionId ? sanitizeSessionPathSegment(inferredSessionId, "") : "")
+        || sanitizeSessionPathSegment(path.basename(args.filePath, path.extname(args.filePath)), "session");
+    const hash = crypto.createHash("sha256").update(decoded.bytes).digest("hex").slice(0, 16);
+    const ext = extensionForImageMimeType(decoded.mimeType);
+    const name = `line-${args.lineNumber}-${hash}${ext}`;
+    const relPath = path.posix.join(".doer-agent", "sessions", sessionBase, "outputs", name);
+    const absPath = path.resolve(args.workspaceRoot, relPath);
+    if (!(absPath === args.workspaceRoot || absPath.startsWith(args.workspaceRoot + path.sep))) {
+        return null;
+    }
+    await mkdir(path.dirname(absPath), { recursive: true });
+    const existing = await stat(absPath).catch(() => null);
+    if (!existing || !existing.isFile() || existing.size !== decoded.bytes.byteLength) {
+        await writeFile(absPath, decoded.bytes);
+    }
+    return {
+        relPath,
+        name,
+        size: decoded.bytes.byteLength,
+        mimeType: decoded.mimeType,
+    };
+}
 function getSessionRpcPayloadByteLength(value) {
     try {
         const serialized = typeof value === "string" ? value : JSON.stringify(value);
@@ -104,12 +183,12 @@ function buildSessionRpcTruncatedMarker(label, value) {
         ? `[${label} truncated for session RPC pagination]`
         : `[${label} truncated for session RPC pagination: ${byteLength} bytes omitted]`;
 }
-function sanitizeSessionRpcPayload(value) {
+async function sanitizeSessionRpcPayload(value, args) {
     if (typeof value === "string") {
         return value;
     }
     if (Array.isArray(value)) {
-        return value.map((entry) => sanitizeSessionRpcPayload(entry));
+        return Promise.all(value.map((entry) => sanitizeSessionRpcPayload(entry, args)));
     }
     if (!isObjectRecord(value)) {
         return value;
@@ -117,14 +196,25 @@ function sanitizeSessionRpcPayload(value) {
     const sanitized = {};
     for (const [key, entry] of Object.entries(value)) {
         if (SESSION_RPC_BLOB_KEYS.has(key) && typeof entry === "string" && isInlineBlobString(entry)) {
+            if (key === "image_url") {
+                const materialized = await materializeInlineSessionImage({ ...args, value: entry });
+                if (materialized) {
+                    sanitized[key] = materialized.relPath;
+                    sanitized.name = typeof value.name === "string" && value.name.trim() ? value.name : materialized.name;
+                    sanitized.size = typeof value.size === "number" && Number.isFinite(value.size) ? value.size : materialized.size;
+                    sanitized.mimeType =
+                        typeof value.mimeType === "string" && value.mimeType.trim() ? value.mimeType : materialized.mimeType;
+                    continue;
+                }
+            }
             sanitized[key] = buildInlineBlobMarker(entry);
             continue;
         }
-        sanitized[key] = sanitizeSessionRpcPayload(entry);
+        sanitized[key] = await sanitizeSessionRpcPayload(entry, args);
     }
     return sanitized;
 }
-function sanitizeSessionRpcRawLine(line) {
+async function sanitizeSessionRpcRawLine(line, args) {
     const trimmed = line.trim();
     if (!trimmed.startsWith("{")) {
         return line;
@@ -159,7 +249,7 @@ function sanitizeSessionRpcRawLine(line) {
         }
         return JSON.stringify({
             ...parsed,
-            payload: sanitizeSessionRpcPayload(parsed.payload),
+            payload: await sanitizeSessionRpcPayload(parsed.payload, args),
         });
     }
     catch {
@@ -279,33 +369,57 @@ function extractLastSessionMessage(candidateLines) {
     }
     return null;
 }
-async function readLastSessionMessage(fileHandle, fileSize) {
-    const chunkBytes = 16_384;
-    const maxScanBytes = 131_072;
-    if (fileSize <= 0) {
-        return null;
+function linePrefixContainsSessionMessageCandidate(prefix) {
+    return (/"type"\s*:\s*"event_msg"/.test(prefix) &&
+        /"type"\s*:\s*"(agent_message|user_message)"/.test(prefix));
+}
+async function readLineSpan(fileHandle, start, end) {
+    const readSize = Math.max(0, end - start);
+    if (readSize <= 0) {
+        return "";
     }
-    let position = fileSize;
-    let scanned = 0;
-    let carry = "";
-    while (position > 0 && scanned < maxScanBytes) {
-        const readSize = Math.min(chunkBytes, position, maxScanBytes - scanned);
-        position -= readSize;
-        scanned += readSize;
-        const buffer = Buffer.alloc(readSize);
-        const { bytesRead } = await fileHandle.read(buffer, 0, readSize, position);
+    const buffer = Buffer.alloc(readSize);
+    let totalBytesRead = 0;
+    while (totalBytesRead < readSize) {
+        const { bytesRead } = await fileHandle.read(buffer, totalBytesRead, readSize - totalBytesRead, start + totalBytesRead);
         if (bytesRead <= 0) {
             break;
         }
-        const merged = buffer.toString("utf8", 0, bytesRead) + carry;
-        const lines = merged.split(/\r?\n/);
-        carry = lines.shift() || "";
-        const found = extractLastSessionMessage(lines.reverse());
-        if (found) {
-            return found;
+        totalBytesRead += bytesRead;
+    }
+    return buffer.toString("utf8", 0, totalBytesRead).trim();
+}
+async function readLastSessionMessage(workspaceRoot, filePath) {
+    const index = await readSessionLineIndex(workspaceRoot, filePath);
+    const totalLines = index.lineStartOffsets.length;
+    if (totalLines <= 0 || index.size <= 0) {
+        return null;
+    }
+    const resolvedFile = resolveSessionFilePath(workspaceRoot, filePath);
+    const fileHandle = await open(resolvedFile, "r");
+    try {
+        for (let lineIndex = totalLines - 1; lineIndex >= 0; lineIndex -= 1) {
+            const start = index.lineStartOffsets[lineIndex] ?? index.size;
+            const end = lineIndex + 1 < totalLines ? (index.lineStartOffsets[lineIndex + 1] ?? index.size) : index.size;
+            const spanBytes = Math.max(0, end - start);
+            if (spanBytes <= 0) {
+                continue;
+            }
+            const prefixBytes = Math.min(spanBytes, 1024);
+            const prefix = await readLineSpan(fileHandle, start, start + prefixBytes);
+            if (!linePrefixContainsSessionMessageCandidate(prefix)) {
+                continue;
+            }
+            const found = extractLastSessionMessage([await readLineSpan(fileHandle, start, end)]);
+            if (found) {
+                return found;
+            }
         }
+        return null;
+    }
+    finally {
+        await fileHandle.close().catch(() => undefined);
     }
-    return extractLastSessionMessage([carry]);
 }
 function normalizeSessionMeta(rawMeta, filePath, mtimeMs) {
     const baseName = path.basename(filePath, path.extname(filePath));
@@ -321,13 +435,13 @@ function normalizeSessionMeta(rawMeta, filePath, mtimeMs) {
         filePath,
     };
 }
-async function readSessionSummary(filePath, mtimeMs) {
+async function readSessionSummary(workspaceRoot, filePath, mtimeMs) {
     let fileHandle = null;
     try {
         fileHandle = await open(filePath, "r");
         const entryStat = await fileHandle.stat();
         const firstLine = await readFirstLine(fileHandle, entryStat.size);
-        const tailSummary = await readLastSessionMessage(fileHandle, entryStat.size);
+        const tailSummary = await readLastSessionMessage(workspaceRoot, filePath);
         let normalized = normalizeSessionMeta({}, filePath, mtimeMs);
         if (firstLine) {
             try {
@@ -363,6 +477,7 @@ async function readSessionSummary(filePath, mtimeMs) {
     }
 }
 async function listAgentSessions(workspaceRoot) {
+    const maxSessionSummaries = 10;
     const sessionsRoot = getSessionsRootPath(workspaceRoot);
     let sessionsRootStat;
     try {
@@ -376,8 +491,23 @@ async function listAgentSessions(workspaceRoot) {
     }
     const files = await collectSessionJsonlFiles(workspaceRoot);
     files.sort((a, b) => b.mtimeMs - a.mtimeMs || a.filePath.localeCompare(b.filePath));
-    const sessions = await Promise.all(files.slice(0, 10).map((file) => readSessionSummary(file.filePath, file.mtimeMs)));
-    return sessions.sort((a, b) => toSortableTimestampMs(b.updatedAt) - toSortableTimestampMs(a.updatedAt) || b.filePath.localeCompare(a.filePath));
+    const sessions = [];
+    for (let index = 0; index < files.length; index += 1) {
+        const file = files[index];
+        sessions.push(await readSessionSummary(workspaceRoot, file.filePath, file.mtimeMs));
+        sessions.sort((a, b) => toSortableTimestampMs(b.updatedAt) - toSortableTimestampMs(a.updatedAt) || b.filePath.localeCompare(a.filePath));
+        if (sessions.length > maxSessionSummaries) {
+            sessions.length = maxSessionSummaries;
+        }
+        const nextFile = files[index + 1] ?? null;
+        const oldestSelectedSession = sessions[maxSessionSummaries - 1] ?? null;
+        if (nextFile &&
+            oldestSelectedSession &&
+            toSortableTimestampMs(oldestSelectedSession.updatedAt) >= nextFile.mtimeMs) {
+            break;
+        }
+    }
+    return sessions;
 }
 async function readSessionLineIndex(workspaceRoot, filePath) {
     const resolvedFile = resolveSessionFilePath(workspaceRoot, filePath);
@@ -442,6 +572,7 @@ async function readSessionLineIndex(workspaceRoot, filePath) {
 }
 async function getAgentSessionRawRows(args) {
     const resolvedFile = resolveSessionFilePath(args.workspaceRoot, args.filePath);
+    const effectiveSessionId = args.sessionId || await readSessionIdFromSessionFile(resolvedFile).catch(() => null);
     const index = await readSessionLineIndex(args.workspaceRoot, resolvedFile);
     const totalLines = index.lineStartOffsets.length;
     const sinceLine = Math.max(0, Math.floor(args.sinceLine));
@@ -555,7 +686,12 @@ async function getAgentSessionRawRows(args) {
         let lineNumber = startLineIndex + 1;
         for (const line of lines) {
             if (line.trim()) {
-                const sanitized = sanitizeSessionRpcRawLine(line);
+                const sanitized = await sanitizeSessionRpcRawLine(line, {
+                    workspaceRoot: args.workspaceRoot,
+                    filePath: resolvedFile,
+                    lineNumber,
+                    sessionId: effectiveSessionId,
+                });
                 rawRows.push({
                     id: lineNumber,
                     raw: sanitized,
@@ -573,7 +709,7 @@ async function getAgentSessionRawRows(args) {
     }
 }
 function resolveSessionUploadsDir(workspaceRoot, sessionId) {
-    const safeSessionId = sessionId.trim().replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "session";
+    const safeSessionId = sanitizeSessionPathSegment(sessionId, "session");
     return path.join(workspaceRoot, ".doer-agent", "sessions", safeSessionId);
 }
 async function deleteAgentSession(workspaceRoot, filePath, sessionId) {
@@ -695,6 +831,7 @@ async function handleSessionRpcMessage(args) {
             const result = await getAgentSessionRawRows({
                 workspaceRoot: args.workspaceRoot,
                 filePath: request.filePath ?? "",
+                sessionId: request.sessionId,
                 sinceLine: request.sinceLine,
                 beforeRowId: request.beforeRowId,
                 pageSize: request.pageSize,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doer-agent",
-  "version": "0.5.7",
+  "version": "0.5.9",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",