@ouro.bot/cli 0.1.0-alpha.83 → 0.1.0-alpha.831

package/dist/senses/{bluebubbles-session-cleanup.js → bluebubbles/session-cleanup.js}

@@ -36,7 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findObsoleteBlueBubblesThreadSessions = findObsoleteBlueBubblesThreadSessions;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const runtime_1 = require("../nerves/runtime");
+const runtime_1 = require("../../nerves/runtime");
 function findObsoleteBlueBubblesThreadSessions(trunkSessionPath) {
     const normalized = trunkSessionPath.trim();
     if (!normalized.endsWith(".json"))

package/dist/senses/bluebubbles/webhook-registration.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS = void 0;
+exports.blueBubblesWebhookOwnerToken = blueBubblesWebhookOwnerToken;
+exports.buildBlueBubblesWebhookCallbackUrl = buildBlueBubblesWebhookCallbackUrl;
+exports.sanitizeBlueBubblesWebhookText = sanitizeBlueBubblesWebhookText;
+exports.inspectBlueBubblesWebhookRegistration = inspectBlueBubblesWebhookRegistration;
+exports.reconcileBlueBubblesWebhookRegistration = reconcileBlueBubblesWebhookRegistration;
+exports.createBlueBubblesWebhookReconciler = createBlueBubblesWebhookReconciler;
+const crypto_1 = require("crypto");
+const runtime_1 = require("../../nerves/runtime");
+exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS = 180_000;
+function result(state, detail, counts = {}) {
+    return {
+        ok: state === "exact",
+        state,
+        changed: counts.changed ?? false,
+        ownedCount: counts.ownedCount ?? 0,
+        exactCount: counts.exactCount ?? 0,
+        detail,
+    };
+}
+function blueBubblesWebhookOwnerToken(agentName, machineId) {
+    return `v1_${(0, crypto_1.createHash)("sha256").update(`ouro-bluebubbles-webhook\0${agentName}\0${machineId}`).digest("hex").slice(0, 32)}`;
+}
+function buildBlueBubblesWebhookCallbackUrl(input) {
+    const callback = new URL(`http://127.0.0.1:${input.callbackPort}`);
+    callback.pathname = input.callbackPath.startsWith("/") ? input.callbackPath : `/${input.callbackPath}`;
+    callback.searchParams.set("password", input.password);
+    callback.searchParams.set("ouroWebhook", blueBubblesWebhookOwnerToken(input.agentName, input.machineId));
+    return callback.toString();
+}
+function apiUrl(input, id) {
+    const base = `${input.serverUrl.replace(/\/+$/, "")}/api/v1/webhook${id === undefined ? "" : `/${id}`}`;
+    const url = new URL(base);
+    url.searchParams.set("password", input.password);
+    return url.toString();
+}
+function sanitizeBlueBubblesWebhookText(text, input) {
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    return text
+        .replaceAll(input.password, "[redacted]")
+        .replaceAll(owner, "[redacted]")
+        .replace(/(https?:\/\/[^\s?]+)\?[^\s]*/g, "$1?[redacted]");
+}
+function isWebhook(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const row = value;
+    return Number.isInteger(row.id)
+        && typeof row.url === "string"
+        && Array.isArray(row.events)
+        && row.events.every((event) => typeof event === "string");
+}
+function ownedBy(urlText, owner) {
+    try {
+        return new URL(urlText).searchParams.get("ouroWebhook") === owner;
+    }
+    catch {
+        return false;
+    }
+}
+function exactUnmarked(urlText, desiredUrl) {
+    try {
+        const candidate = new URL(urlText);
+        const desired = new URL(desiredUrl);
+        if (candidate.searchParams.has("ouroWebhook"))
+            return false;
+        desired.searchParams.delete("ouroWebhook");
+        return candidate.toString() === desired.toString();
+    }
+    catch {
+        return false;
+    }
+}
+function exactHook(hook, desiredUrl) {
+    return hook.url === desiredUrl && hook.events.length === 1 && hook.events[0] === "*";
+}
+async function request(input, fetchImpl, method, id, body, signal) {
+    const timeoutSignal = AbortSignal.timeout(input.requestTimeoutMs);
+    return fetchImpl(apiUrl(input, id), {
+        method,
+        ...(body === undefined ? {} : {
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        }),
+        signal: signal ? AbortSignal.any([timeoutSignal, signal]) : timeoutSignal,
+    });
+}
+async function readHooks(input, fetchImpl, signal) {
+    try {
+        const response = await request(input, fetchImpl, "GET", undefined, undefined, signal);
+        if (response.status === 401 || response.status === 403) {
+            return result("auth-failed", `BlueBubbles rejected webhook credentials (HTTP ${response.status})`);
+        }
+        if (!response.ok)
+            return result("api-unreachable", `BlueBubbles webhook API returned HTTP ${response.status}`);
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            return result("malformed", "BlueBubbles webhook API returned invalid JSON");
+        }
+        const data = payload && typeof payload === "object" ? payload.data : undefined;
+        if (!Array.isArray(data) || !data.every(isWebhook)) {
+            return result("malformed", "BlueBubbles webhook API returned an invalid webhook list");
+        }
+        return { hooks: data };
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        return result("api-unreachable", sanitizeBlueBubblesWebhookText(detail, input));
+    }
+}
+function inspectHooks(hooks, input) {
+    const desired = buildBlueBubblesWebhookCallbackUrl(input);
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    const owned = hooks.filter((hook) => ownedBy(hook.url, owner));
+    const exact = owned.filter((hook) => exactHook(hook, desired));
+    if (owned.length === 1 && exact.length === 1) {
+        return result("exact", "one exact Ouro-owned BlueBubbles webhook is registered", {
+            ownedCount: 1,
+            exactCount: 1,
+        });
+    }
+    return result(owned.length === 0 ? "missing" : "drifted", owned.length === 0
+        ? "the Ouro-owned BlueBubbles webhook is missing"
+        : "the Ouro-owned BlueBubbles webhook registration is drifted", {
+        ownedCount: owned.length,
+        exactCount: exact.length,
+    });
+}
+async function inspectBlueBubblesWebhookRegistration(input, deps = {}) {
+    if (!input.listenerReady)
+        return result("listener-not-ready", "the local BlueBubbles listener is not ready");
+    const listed = await readHooks(input, deps.fetchImpl ?? fetch, deps.signal);
+    return "hooks" in listed ? inspectHooks(listed.hooks, input) : listed;
+}
+async function mutate(input, fetchImpl, method, id, signal) {
+    try {
+        const response = await request(input, fetchImpl, method, id, method === "POST" ? { url: buildBlueBubblesWebhookCallbackUrl(input), events: ["*"] } : undefined, signal);
+        if (!response.ok)
+            return { ok: false, detail: `HTTP ${response.status}` };
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, detail: sanitizeBlueBubblesWebhookText(error instanceof Error ? error.message : String(error), input) };
+    }
+}
+async function reconcileBlueBubblesWebhookRegistration(input, deps = {}) {
+    if (!input.listenerReady)
+        return result("listener-not-ready", "the local BlueBubbles listener is not ready");
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const listed = await readHooks(input, fetchImpl, deps.signal);
+    if (!("hooks" in listed))
+        return listed;
+    const desired = buildBlueBubblesWebhookCallbackUrl(input);
+    const owner = blueBubblesWebhookOwnerToken(input.agentName, input.machineId);
+    const owned = listed.hooks.filter((hook) => ownedBy(hook.url, owner));
+    const exact = owned.filter((hook) => exactHook(hook, desired));
+    const keep = exact[0];
+    const stale = owned.filter((hook) => hook !== keep);
+    const adopt = keep ? [] : listed.hooks.filter((hook) => exactUnmarked(hook.url, desired)).slice(0, 1);
+    let changed = false;
+    if (!keep) {
+        const created = await mutate(input, fetchImpl, "POST", undefined, deps.signal);
+        if (!created.ok) {
+            return result(owned.length === 0 ? "missing" : "drifted", `could not create the desired webhook: ${created.detail}`, {
+                ownedCount: owned.length,
+                exactCount: exact.length,
+            });
+        }
+        changed = true;
+    }
+    for (const hook of [...stale, ...adopt]) {
+        const deleted = await mutate(input, fetchImpl, "DELETE", hook.id, deps.signal);
+        if (!deleted.ok) {
+            return result("drifted", `could not remove 1 stale owned registration: ${deleted.detail}`, {
+                ownedCount: owned.length,
+                exactCount: exact.length,
+                changed,
+            });
+        }
+        changed = true;
+    }
+    if (!changed)
+        return inspectHooks(listed.hooks, input);
+    const verified = await readHooks(input, fetchImpl, deps.signal);
+    if (!("hooks" in verified))
+        return { ...verified, changed };
+    return { ...inspectHooks(verified.hooks, input), changed };
+}
+function createBlueBubblesWebhookReconciler(input, deps = {}) {
+    const setIntervalImpl = deps.setIntervalImpl ?? ((callback, intervalMs) => setInterval(callback, intervalMs));
+    const clearIntervalImpl = deps.clearIntervalImpl ?? ((timer) => clearInterval(timer));
+    let closed = false;
+    let active = null;
+    const abortController = new AbortController();
+    const reconcileNow = () => {
+        if (closed)
+            return Promise.resolve(result("listener-not-ready", "the BlueBubbles webhook reconciler is closed"));
+        if (active)
+            return active;
+        active = reconcileBlueBubblesWebhookRegistration(input, { ...deps, signal: abortController.signal }).finally(() => { active = null; });
+        return active;
+    };
+    const timer = setIntervalImpl(() => { void reconcileNow(); }, exports.BLUEBUBBLES_WEBHOOK_RECONCILE_INTERVAL_MS);
+    void reconcileNow().then((outcome) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "senses",
+            event: "senses.bluebubbles_webhook_reconciled",
+            level: outcome.ok ? "info" : "warn",
+            message: "reconciled BlueBubbles webhook registration",
+            meta: { state: outcome.state, changed: outcome.changed },
+        });
+    });
+    return {
+        reconcileNow,
+        close: () => {
+            if (closed)
+                return;
+            closed = true;
+            clearIntervalImpl(timer);
+            abortController.abort(new Error("BlueBubbles webhook reconciliation closed"));
+        },
+    };
+}

package/dist/senses/bluebubbles-meta-guard.js

@@ -0,0 +1,39 @@
+"use strict";
+// Outbound BlueBubbles meta-content guard.
+//
+// Blocks accidental delivery of internal/meta text — pipeline section markers,
+// surfacing-mechanics prefixes, reasoning tags — to the live iMessage channel.
+// Failure mode is "drop and log", never queue for later delivery.
+//
+// Patterns are deliberately narrow: bracketed system markers and angle-bracket
+// reasoning tags. Plain prose mentioning related concepts is NOT blocked, so
+// user-facing replies that legitimately discuss those concepts still pass.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.containsInternalMetaMarkers = containsInternalMetaMarkers;
+exports.emitBluebubblesMetaBlocked = emitBluebubblesMetaBlocked;
+const runtime_1 = require("../nerves/runtime");
+const META_CONTENT_PATTERNS = [
+    /\[surfaced from inner dialog\]/i,
+    /\[pending from [^\]]+\]:/i,
+    /\[conversation scope:/i,
+    /\[recent active lanes\]/i,
+    /\[routing control:/i,
+    /<\/?think>/i,
+];
+function containsInternalMetaMarkers(text) {
+    if (!text)
+        return false;
+    return META_CONTENT_PATTERNS.some((pattern) => pattern.test(text));
+}
+function emitBluebubblesMetaBlocked(options) {
+    (0, runtime_1.emitNervesEvent)({
+        level: "warn",
+        component: "senses",
+        event: "senses.bluebubbles_meta_blocked",
+        message: options.message,
+        meta: {
+            site: options.site,
+            ...options.meta,
+        },
+    });
+}

package/dist/senses/cli/bracketed-paste.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BracketedPasteHandler = void 0;
+/**
+ * Bracketed paste mode handler for the TUI.
+ *
+ * Detects \x1b[200~ (paste start) and \x1b[201~ (paste end) markers in
+ * raw stdin data. Buffers paste content between markers and emits it as
+ * a single "paste" event. Non-paste data is emitted as "data" unchanged.
+ *
+ * Works alongside Ink's stdin handling by intercepting raw data events.
+ */
+const events_1 = require("events");
+const runtime_1 = require("../../nerves/runtime");
+const PASTE_START = "\x1b[200~";
+const PASTE_END = "\x1b[201~";
+class BracketedPasteHandler extends events_1.EventEmitter {
+    stdin;
+    stdout;
+    pasting = false;
+    buffer = "";
+    dataHandler;
+    constructor(stdin, stdout) {
+        super();
+        this.stdin = stdin;
+        this.stdout = stdout;
+        // Enable bracketed paste mode
+        stdout.write("\x1b[?2004h");
+        this.dataHandler = (chunk) => {
+            this.processChunk(chunk.toString());
+        };
+        stdin.prependListener("data", this.dataHandler);
+    }
+    processChunk(data) {
+        let remaining = data;
+        while (remaining.length > 0) {
+            if (this.pasting) {
+                // Look for end marker in buffer + remaining
+                const combined = this.buffer + remaining;
+                const endIdx = combined.indexOf(PASTE_END);
+                if (endIdx !== -1) {
+                    // Found end marker -- emit paste content
+                    const pasteContent = combined.slice(0, endIdx);
+                    (0, runtime_1.emitNervesEvent)({ component: "senses", event: "senses.bracketed_paste", message: "bracketed paste received", meta: { length: pasteContent.length } });
+                    this.emit("paste", pasteContent);
+                    this.buffer = "";
+                    this.pasting = false;
+                    // Process remaining data after end marker
+                    remaining = combined.slice(endIdx + PASTE_END.length);
+                    continue;
+                }
+                // No end marker yet -- buffer everything so far
+                this.buffer = combined;
+                return;
+            }
+            // Not pasting -- look for start marker
+            const startIdx = remaining.indexOf(PASTE_START);
+            if (startIdx !== -1) {
+                // Emit any data before the start marker
+                const before = remaining.slice(0, startIdx);
+                if (before.length > 0) {
+                    this.emit("data", before);
+                }
+                // Enter paste mode
+                this.pasting = true;
+                this.buffer = "";
+                remaining = remaining.slice(startIdx + PASTE_START.length);
+                continue;
+            }
+            // No start marker -- emit as regular data
+            this.emit("data", remaining);
+            return;
+        }
+    }
+    /** Disable bracketed paste mode and remove listeners. */
+    destroy() {
+        this.stdout.write("\x1b[?2004l");
+        this.stdin.removeListener("data", this.dataHandler);
+        this.removeAllListeners();
+    }
+}
+exports.BracketedPasteHandler = BracketedPasteHandler;

package/dist/senses/cli/image-paste.js

@@ -0,0 +1,287 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMAGE_EXTENSION_REGEX = void 0;
+exports.isImagePath = isImagePath;
+exports.unescapePath = unescapePath;
+exports.tryReadImage = tryReadImage;
+exports.formatImageRef = formatImageRef;
+exports.replacePathsWithRefs = replacePathsWithRefs;
+exports.processSubmitInput = processSubmitInput;
+exports.resolveImageContent = resolveImageContent;
+/**
+ * Image paste detection and resolution for the TUI.
+ *
+ * When a user drags an image file onto the terminal, macOS pastes the absolute
+ * path (often with backslash-escaped spaces). This module detects image paths
+ * in the input text, replaces them with `[Image #N]` references, reads the
+ * files, registers them as shared attachments, and produces OpenAI-compatible
+ * `image_url` content blocks.
+ */
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("fs/promises");
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const identity_1 = require("../../heart/identity");
+const render_1 = require("../../heart/attachments/render");
+const store_1 = require("../../heart/attachments/store");
+const materialize_1 = require("../../heart/attachments/materialize");
+const cli_local_file_1 = require("../../heart/attachments/sources/cli-local-file");
+/** Matches image file extensions (case-insensitive) */
+exports.IMAGE_EXTENSION_REGEX = /\.(png|jpe?g|gif|webp)$/i;
+/** Check whether a string (possibly backslash-escaped) ends with an image extension */
+function isImagePath(str) {
+    return exports.IMAGE_EXTENSION_REGEX.test(unescapePath(str));
+}
+/** Strip shell escape backslashes from a path (macOS/Linux drag-drop format) */
+function unescapePath(str) {
+    // Handle double-backslashes first (actual backslash in filename)
+    // then remove single escape backslashes
+    return str.replace(/\\(.)/g, "$1");
+}
+/** Detect temp screenshot paths from macOS screencapture */
+const TEMP_SCREENSHOT_RE = /\/TemporaryItems\/.*screencaptureui.*\/Screenshot/i;
+/** Map file extension to MIME media type */
+function extensionToMediaType(ext) {
+    switch (ext.toLowerCase()) {
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".png":
+            return "image/png";
+        case ".gif":
+            return "image/gif";
+        case ".webp":
+            return "image/webp";
+        default:
+            return "image/png";
+    }
+}
+/**
+ * Read an image file and return base64 + media type.
+ * Falls back to clipboard for temp screenshot paths (macOS screencapture
+ * creates ephemeral files in TemporaryItems that are cleaned up quickly).
+ * Returns null on any error.
+ */
+async function tryReadImage(absolutePath) {
+    // Try reading the file directly first
+    try {
+        const buffer = await (0, promises_1.readFile)(absolutePath);
+        if (buffer.length > 0) {
+            const ext = path.extname(absolutePath);
+            return {
+                buffer: Buffer.from(buffer),
+                base64: Buffer.from(buffer).toString("base64"),
+                mediaType: extensionToMediaType(ext),
+                fromClipboard: false,
+            };
+        }
+    }
+    catch {
+        // File not found or permission denied — try clipboard fallback
+    }
+    // Clipboard fallback for macOS temp screenshots
+    /* v8 ignore start -- clipboard fallback requires real macOS screencapture @preserve */
+    if (process.platform === "darwin" && TEMP_SCREENSHOT_RE.test(absolutePath)) {
+        const clipboardImage = await getImageFromClipboard();
+        if (clipboardImage)
+            return clipboardImage;
+    }
+    /* v8 ignore stop */
+    (0, runtime_1.emitNervesEvent)({
+        component: "senses",
+        event: "senses.image_read_error",
+        message: `Failed to read image: ${absolutePath}`,
+        meta: { path: absolutePath },
+    });
+    return null;
+}
+/**
+ * Read image data from macOS clipboard via osascript.
+ * Used as fallback when temp screenshot files are already cleaned up.
+ */
+/* v8 ignore start -- macOS clipboard integration @preserve */
+async function getImageFromClipboard() {
+    const tmpPath = "/tmp/ouro_clipboard_image.png";
+    try {
+        // Check if clipboard has image data
+        (0, child_process_1.execFileSync)("osascript", ["-e", "the clipboard as «class PNGf»"], { stdio: "pipe" });
+        // Save clipboard image to temp file
+        (0, child_process_1.execFileSync)("osascript", [
+            "-e", "set png_data to (the clipboard as «class PNGf»)",
+            "-e", `set fp to open for access POSIX file "${tmpPath}" with write permission`,
+            "-e", "write png_data to fp",
+            "-e", "close access fp",
+        ], { stdio: "pipe" });
+        const buffer = await (0, promises_1.readFile)(tmpPath);
+        void (0, promises_1.unlink)(tmpPath).catch(() => { });
+        if (buffer.length === 0)
+            return null;
+        return {
+            buffer: Buffer.from(buffer),
+            base64: Buffer.from(buffer).toString("base64"),
+            mediaType: "image/png",
+            fromClipboard: true,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/* v8 ignore stop */
+/** Format an image reference placeholder */
+function formatImageRef(n) {
+    return `[Image #${n}]`;
+}
+/**
+ * Scan input for absolute image file paths and replace with [Image #N] references.
+ * Handles backslash-escaped characters (macOS drag-drop) and paths with spaces.
+ */
+function replacePathsWithRefs(input) {
+    const images = new Map();
+    // Match absolute paths: start with /, contain non-whitespace or backslash-escaped chars,
+    // end with an image extension. The (?:\\.|\S) alternation allows `\ ` sequences.
+    const pathRegex = /(?:\/(?:\\.|[^\s])+\.(?:png|jpe?g|gif|webp))/gi;
+    let counter = 0;
+    const text = input.replace(pathRegex, (match) => {
+        counter++;
+        images.set(counter, unescapePath(match));
+        return formatImageRef(counter);
+    });
+    return { text, images };
+}
+/**
+ * Process submit input: detect image paths, replace with refs, return map.
+ * This is the entry point called by InputArea on submit.
+ */
+function processSubmitInput(text) {
+    return replacePathsWithRefs(text);
+}
+function extensionForMediaType(mediaType) {
+    switch (mediaType) {
+        case "image/jpeg":
+            return ".jpg";
+        case "image/gif":
+            return ".gif";
+        case "image/webp":
+            return ".webp";
+        default:
+            return ".png";
+    }
+}
+async function pathExists(targetPath) {
+    try {
+        await (0, promises_1.access)(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function persistClipboardImage(agentRoot, originalPath, image) {
+    const hash = (0, node_crypto_1.createHash)("sha1").update(originalPath).digest("hex").slice(0, 16);
+    const targetPath = path.join(agentRoot, "state", "attachments", "imports", "cli", `${hash}${extensionForMediaType(image.mediaType)}`);
+    await (0, promises_1.mkdir)(path.dirname(targetPath), { recursive: true });
+    await (0, promises_1.writeFile)(targetPath, image.buffer);
+    return targetPath;
+}
+/**
+ * Build OpenAI content parts from text + image map.
+ * For each image in the map, reads the file and creates an `image_url` content part.
+ * Images that fail to read are silently skipped.
+ * Returns `[{ type: "text", text }]` when no images resolve.
+ */
+async function resolveImageContent(text, images) {
+    if (images.size === 0) {
+        return [{ type: "text", text }];
+    }
+    const agentName = (0, identity_1.getAgentName)();
+    const agentRoot = (0, identity_1.getAgentRoot)(agentName);
+    const parts = [];
+    const cachedAttachments = [];
+    // Read all images in parallel
+    const entries = Array.from(images.entries());
+    const results = await Promise.all(entries.map(async ([, absolutePath]) => {
+        const image = await tryReadImage(absolutePath);
+        if (!image)
+            return null;
+        const sourcePath = image.fromClipboard || !await pathExists(absolutePath)
+            ? await persistClipboardImage(agentRoot, absolutePath, image)
+            : absolutePath;
+        const attachment = (0, store_1.cacheRecentAttachment)(agentName, (0, cli_local_file_1.buildCliLocalFileAttachmentRecord)({
+            path: sourcePath,
+            mimeType: image.mediaType,
+            byteCount: image.buffer.length,
+        }), agentRoot);
+        cachedAttachments.push(attachment);
+        try {
+            const materialized = await (0, materialize_1.materializeAttachment)(agentName, attachment.id, {
+                agentRoot,
+                variant: "vision_safe",
+            });
+            const normalizedBuffer = await (0, promises_1.readFile)(materialized.path);
+            return {
+                attachment,
+                mediaType: materialized.mimeType ?? image.mediaType,
+                base64: Buffer.from(normalizedBuffer).toString("base64"),
+            };
+        }
+        catch {
+            return {
+                attachment,
+                mediaType: image.mediaType,
+                base64: image.base64,
+            };
+        }
+    }));
+    for (const result of results) {
+        if (result) {
+            parts.push({
+                type: "image_url",
+                image_url: { url: `data:${result.mediaType};base64,${result.base64}` },
+            });
+        }
+    }
+    // Always include the text part
+    const attachmentBlock = (0, render_1.renderAttachmentBlock)(cachedAttachments);
+    const textWithAttachments = [text, attachmentBlock].filter(Boolean).join("\n");
+    parts.push({ type: "text", text: textWithAttachments || text });
+    // If no images resolved, return just text
+    if (parts.length === 1) {
+        return [{ type: "text", text }];
+    }
+    return parts;
+}