doer-agent 0.5.8 → 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 {
@@ -482,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));
@@ -595,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,
@@ -613,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) {
@@ -735,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.8",
+  "version": "0.5.9",
   "description": "Reverse-polling agent runtime for doer",
   "type": "module",
   "main": "dist/agent.js",