@nopeek/agent-bridge 0.7.11 → 0.7.15

package/README.md

@@ -41,9 +41,9 @@ The `npr_…` code comes from Settings → Connect your computer (bots) in the a
 
 Hermes brains prefer the local agent API (`HERMES_API_URL`, default
 `http://127.0.0.1:8642`) when `/health` is up, and fall back to `hermes chat`.
-While Hermes is working, the bot posts Telegram-style tool lines a few at a
-time (read file, patch, skill, memory). A quiet gap starts a new message.
-The final reply is the answer plus a short recap when tools were used.
+While Hermes is working, the bot edits one Telegram-style progress bubble
+(read file, patch, skill, memory). New tools update that bubble instead of
+stacking under a running summary. The recap is a separate message underneath.
 Idle kill waits for **no output and no CPU** (default 15 min). Authenticated
 `GET /status` includes `bridge`, `bots[]` (each with `lastTurn`), `hermesApi`,
 and `lastTurn`. See `docs/HERMES-BRAIN-PLAN.md`.
@@ -79,6 +79,7 @@ Context is passed as environment variables:
 | `NOPEEK_BOT_USER_ID` | user id of the bot |
 | `NOPEEK_CHANNEL_ID` | channel the message arrived in |
 | `NOPEEK_SENDER_USER_ID` | who sent the message |
+| `NOPEEK_FILES` | JSON array of decrypted inbound files (`path`, `name`, `contentType`, `size`, `kind`) |
 
 Examples:
 
@@ -109,7 +110,8 @@ Content-Type: application/json
   "botHandle": "weatherbot",
   "botUserId": "usr_…",
   "channelId": "ch_…",
-  "senderUserId": "usr_…"
+  "senderUserId": "usr_…",
+  "files": []
 }
 ```
 

package/dist/bot.d.ts

@@ -38,6 +38,7 @@ export declare class BotRunner {
     private channelModes;
     private mutedOff;
     private chains;
+    private turns;
     private cantPost;
     private log;
     private logErr;
@@ -102,6 +103,9 @@ export declare class BotRunner {
     /** Bounded dedupe so a redelivered frame is never answered twice. */
     private remember;
     private handleMessage;
+    private runBrainTurn;
+    private collectFollowups;
+    private ingestFollowup;
     /** A FORBIDDEN post (broadcast channel, bot not an operator) fails for every
      *  future message too — mute the channel so the brain stops running there. */
     private notePostFailure;

package/dist/bot.js

@@ -7,7 +7,9 @@ import { isChannelMode } from "./control.js";
 import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
-import { ToolProgressFlusher } from "./tool-progress.js";
+import { TurnPublisher } from "./tool-progress.js";
+import { ChannelTurn, coalesceFollowups, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
+import { buildInboundPrompt, describeStructured, hasInboundWork, isControlType, parseAttachments, saveInboundFiles, } from "./inbound-files.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 const MAX_BACKOFF_MS = 60_000;
 // Owner-membership answers are cached per channel for a short window; a
@@ -73,6 +75,9 @@ export class BotRunner {
     // order, one at a time — concurrent brain runs against the same agent session
     // (e.g. one Hermes session per channel) deadlock or reply out of order.
     chains = new Map();
+    // Live brain turn per channel so a follow-up can abort Hermes immediately
+    // instead of waiting for the current 30-minute job to finish.
+    turns = new Map();
     // Channels the bot can't post to (e.g. broadcast, non-operator): after the
     // first FORBIDDEN, skip the brain entirely — replies there can never land.
     cantPost = new Set();
@@ -373,6 +378,12 @@ export class BotRunner {
         np.on("member.joined", onRosterChange);
         np.on("member.left", onRosterChange);
         np.on("message", ((m) => {
+            const live = this.turns.get(m.channelId);
+            if (live?.active) {
+                live.interrupt({ id: m.messageId, message: m });
+                this.log(`${m.channelId} mid-turn interrupt from ${m.senderUserId}: ${String(m.body && "text" in m.body ? m.body.text : "").slice(0, 80)}`);
+                return;
+            }
             const prev = this.chains.get(m.channelId) ?? Promise.resolve();
             const next = prev.then(() => this.handleMessage(m).catch((err) => {
                 this.notePostFailure(m.channelId, err);
@@ -457,8 +468,11 @@ export class BotRunner {
             }
             return;
         }
-        if (m.body?.type !== "text" || typeof m.body.text !== "string" || !m.body.text.trim())
+        const body = m.body;
+        if (!body || isControlType(body.type) || !hasInboundWork(body))
             return;
+        const attachments = parseAttachments(body);
+        const caption = typeof body.text === "string" ? body.text : "";
         // OWNER-PRESENT POLICY: in a multi-party channel (anything but a direct
         // chat), a non-owner sender may use the bot ONLY while the bot's owner is
         // also a member of that channel. Owner absent → completely silent (no
@@ -516,7 +530,7 @@ export class BotRunner {
         // predictable: mention-only means even the owner must @mention there.
         // DIRECT channels always behave as "everyone" (a DM with the bot is always
         // for the bot).
-        let text = m.body.text;
+        let text = caption;
         if (ch.record.kind !== "direct" && ch.record.kind !== "dm") {
             const mode = this.channelModes.get(m.channelId) ?? "everyone";
             if (mode === "off") {
@@ -534,101 +548,218 @@ export class BotRunner {
                 text = stripped;
             }
         }
+        let files = [];
+        const failures = [];
+        const previews = [];
+        if (attachments.length) {
+            const saved = await saveInboundFiles(async (att) => {
+                const blob = await ch.fetchAttachment(att);
+                return Buffer.from(await blob.arrayBuffer());
+            }, attachments, m.messageId);
+            files = saved.files;
+            failures.push(...saved.failures);
+            previews.push(...saved.previews);
+            this.log(`${m.channelId} inbound ${body.type}: ${files.length} file(s) saved` +
+                (failures.length ? `, ${failures.length} failed` : ""));
+        }
+        const structured = describeStructured(body);
+        text = buildInboundPrompt({ caption: text, files, structured, failures });
+        if (previews.length)
+            text = `${previews.join("\n\n")}\n\n${text}`;
+        if (!text.trim())
+            return;
         this.log(`${m.channelId} <- ${m.senderUserId}: ${text.slice(0, 120)}`);
         ch.markRead(m.messageId).catch(() => { });
-        try {
-            ch.typing(true);
-        }
-        catch {
-            /* typing is best-effort */
-        }
-        // Resolve the brain PER MESSAGE: the NoPeek app can change it live over the
-        // local API (PUT /brains) and the very next message uses the new one.
-        const resolved = resolveBrain(this.cfg, this.info.handle);
-        this.brainKind = resolved.kind;
-        // Streaming: if the brain emits chunks, open a streaming message on the
-        // FIRST chunk and forward deltas into it (typing indicator stays on until
-        // then). Deltas can arrive before the placeholder lands — chaining every
-        // append onto the open promise keeps them ordered and loses none.
-        // (Ref object rather than a `let`: TS can't see closure assignments.)
-        const streamRef = { p: null };
-        const stopTyping = () => {
+        await this.runBrainTurn({
+            ch,
+            channelId: m.channelId,
+            senderUserId: m.senderUserId,
+            text,
+            files,
+            interrupted: false,
+        });
+    }
+    async runBrainTurn(args) {
+        const { ch, channelId, senderUserId } = args;
+        let text = args.text;
+        let files = args.files;
+        let interrupted = args.interrupted;
+        while (true) {
+            if (!interrupted && isStopRequest(text)) {
+                this.log(`${channelId} stop with nothing running`);
+                try {
+                    await ch.send({ text: "Nothing is running." });
+                }
+                catch (err) {
+                    this.notePostFailure(channelId, err);
+                }
+                this.handled++;
+                return;
+            }
             try {
-                ch.typing(false);
+                ch.typing(true);
             }
             catch {
-                /* best-effort */
+                /* typing is best-effort */
             }
-        };
-        const onChunk = (delta) => {
-            if (!delta)
-                return;
-            void progress.flush();
-            if (!streamRef.p) {
-                stopTyping();
-                streamRef.p = ch.stream();
-                streamRef.p.catch((err) => {
-                    this.notePostFailure(m.channelId, err);
+            const resolved = resolveBrain(this.cfg, this.info.handle);
+            this.brainKind = resolved.kind;
+            const stopTyping = () => {
+                try {
+                    ch.typing(false);
+                }
+                catch {
+                    /* best-effort */
+                }
+            };
+            const published = new TurnPublisher({
+                stream: () => ch.stream(),
+                send: async (body) => {
+                    await ch.send({ text: body });
+                },
+            }, {
+                stopTyping,
+                onStreamError: (err) => {
+                    this.notePostFailure(channelId, err);
                     this.logErr(`stream open failed (falling back to a single send): ${err.message}`);
+                },
+            });
+            const live = new ChannelTurn();
+            this.turns.set(channelId, live);
+            const prompt = interrupted ? wrapInterruptedFollowup(text) : text;
+            let reply = "";
+            const stat = beginTurn(this.info.handle, channelId, resolved.kind);
+            try {
+                reply = await resolved.brain(prompt, {
+                    botHandle: this.info.handle,
+                    botUserId: this.info.userId,
+                    channelId,
+                    senderUserId,
+                    signal: live.abort.signal,
+                    ...(files.length ? { files } : {}),
+                }, { onChunk: (delta) => published.onChunk(delta), onTool: (ev) => published.onTool(ev) });
+                if (live.abort.signal.aborted) {
+                    finishTurn(stat, { ok: true, chars: 0, error: "interrupted" });
+                    await published.finish("").catch(() => { });
+                    const next = await this.collectFollowups(channelId, live, ch);
+                    if (!next)
+                        return;
+                    text = next.text;
+                    files = next.files;
+                    interrupted = true;
+                    continue;
+                }
+                const trimmed = reply.trim();
+                const timedOut = /went quiet for over \d+s/i.test(trimmed);
+                finishTurn(stat, {
+                    ok: Boolean(trimmed) && !trimmed.startsWith("⚠️"),
+                    chars: trimmed.length,
+                    timedOut,
+                    error: !trimmed ? "empty reply" : trimmed.startsWith("⚠️") ? trimmed.slice(0, 180) : null,
                 });
             }
-            streamRef.p.then((s) => s.append(delta)).catch(() => { });
-        };
-        const progress = new ToolProgressFlusher(async (body) => {
-            stopTyping();
-            await ch.send({ text: body });
-        });
-        let reply = "";
-        const turn = beginTurn(this.info.handle, m.channelId, resolved.kind);
-        try {
-            reply = await resolved.brain(text, {
-                botHandle: this.info.handle,
-                botUserId: this.info.userId,
-                channelId: m.channelId,
-                senderUserId: m.senderUserId,
-            }, { onChunk, onTool: (ev) => progress.push(ev) });
-            const trimmed = reply.trim();
-            const timedOut = /went quiet for over \d+s/i.test(trimmed);
-            finishTurn(turn, {
-                ok: Boolean(trimmed) && !trimmed.startsWith("⚠️"),
-                chars: trimmed.length,
-                timedOut,
-                error: !trimmed ? "empty reply" : trimmed.startsWith("⚠️") ? trimmed.slice(0, 180) : null,
-            });
+            catch (err) {
+                finishTurn(stat, { ok: false, error: err.message, timedOut: false });
+                await published.fail(FALLBACK_REPLY).catch(() => { });
+                throw err;
+            }
+            finally {
+                if (this.turns.get(channelId) === live) {
+                    live.finish();
+                    this.turns.delete(channelId);
+                }
+                try {
+                    ch.typing(false);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            const how = await published.finish(reply.trim());
+            if (how === "empty") {
+                this.log(`brain returned empty reply — ignoring`);
+                return;
+            }
+            this.handled++;
+            this.log(`${channelId} -> ${how} reply (${reply.trim().length} chars, handled=${this.handled})`);
+            return;
         }
-        catch (err) {
-            finishTurn(turn, { ok: false, error: err.message, timedOut: false });
-            // Brain blew up mid-stream: finalize the partial bubble with an honest
-            // error line instead of leaving a forever-blinking cursor.
-            await progress.flush();
-            const stream = streamRef.p ? await streamRef.p.catch(() => null) : null;
-            if (stream)
-                await stream.fail(FALLBACK_REPLY).catch(() => { });
-            throw err;
+    }
+    async collectFollowups(channelId, live, ch) {
+        await new Promise((r) => setTimeout(r, 180));
+        const queued = live.takeIncoming();
+        live.finish();
+        if (this.turns.get(channelId) === live)
+            this.turns.delete(channelId);
+        const prepared = [];
+        for (const item of queued) {
+            const got = await this.ingestFollowup(item.message);
+            if (!got)
+                continue;
+            ch.markRead(item.message.messageId).catch(() => { });
+            prepared.push(got);
         }
-        finally {
+        if (!prepared.length) {
+            this.log(`${channelId} interrupted with no usable follow-up`);
+            return null;
+        }
+        const decision = coalesceFollowups(prepared.map((p) => p.text));
+        if (decision.action === "stop") {
+            this.log(`${channelId} stopped by user (${prepared.length} follow-up(s))`);
             try {
-                ch.typing(false);
+                await ch.send({ text: "Stopped." });
             }
-            catch {
-                /* best-effort */
+            catch (err) {
+                this.notePostFailure(channelId, err);
             }
-        }
-        await progress.flush();
-        const stream = streamRef.p ? await streamRef.p.catch(() => null) : null;
-        if (stream) {
-            await stream.done(reply.trim() || undefined);
             this.handled++;
-            this.log(`${m.channelId} -> streamed reply (${reply.trim().length} chars, handled=${this.handled})`);
-            return;
+            return null;
         }
-        if (!reply || !reply.trim()) {
-            this.log(`brain returned empty reply — ignoring`);
-            return;
+        this.log(`${channelId} folding ${prepared.length} follow-up(s) into the same session`);
+        return {
+            text: decision.text,
+            files: prepared.flatMap((p) => p.files),
+        };
+    }
+    async ingestFollowup(m) {
+        if (m.senderUserId === this.info.userId)
+            return null;
+        if (this.cantPost.has(m.channelId))
+            return null;
+        if (m.decryptionFailed)
+            return null;
+        if (!this.isAllowed(m.senderUserId))
+            return null;
+        const body = m.body;
+        if (!body || isControlType(body.type) || !hasInboundWork(body))
+            return null;
+        const attachments = parseAttachments(body);
+        let text = typeof body.text === "string" ? body.text : "";
+        let files = [];
+        const failures = [];
+        const previews = [];
+        if (attachments.length) {
+            try {
+                const ch = await this.getChannel(m.channelId);
+                const saved = await saveInboundFiles(async (att) => {
+                    const blob = await ch.fetchAttachment(att);
+                    return Buffer.from(await blob.arrayBuffer());
+                }, attachments, m.messageId);
+                files = saved.files;
+                failures.push(...saved.failures);
+                previews.push(...saved.previews);
+            }
+            catch (err) {
+                this.logErr(`follow-up ingest failed for ${m.messageId}: ${err.message}`);
+            }
         }
-        await ch.send({ text: reply.trim() });
-        this.handled++;
-        this.log(`${m.channelId} -> replied (${reply.trim().length} chars, handled=${this.handled})`);
+        const structured = describeStructured(body);
+        text = buildInboundPrompt({ caption: text, files, structured, failures });
+        if (previews.length)
+            text = `${previews.join("\n\n")}\n\n${text}`;
+        if (!text.trim())
+            return null;
+        return { text, files };
     }
     /** A FORBIDDEN post (broadcast channel, bot not an operator) fails for every
      *  future message too — mute the channel so the brain stops running there. */

package/dist/brain.d.ts

@@ -1,10 +1,22 @@
 import type { BridgeConfig } from "./config.js";
 import type { ToolProgressEvent } from "./tool-progress.js";
+/** A decrypted inbound file written onto the Hermes cache for this turn. */
+export interface BrainFile {
+    path: string;
+    name: string;
+    contentType: string;
+    size: number;
+    kind: "image" | "video" | "audio" | "document";
+}
 export interface BrainContext {
     botHandle: string;
     botUserId: string;
     channelId: string;
     senderUserId: string;
+    /** Local paths of photos / video / PDFs / any file the human just sent. */
+    files?: BrainFile[];
+    /** Abort the in-flight brain when a later message interrupts this turn. */
+    signal?: AbortSignal;
 }
 /**
  * A brain answers one message. If it can stream, it calls `onChunk(delta)` as

package/dist/brain.js

@@ -40,6 +40,7 @@ function cmdBrain(cmd, timeoutMs) {
                 NOPEEK_BOT_USER_ID: ctx.botUserId,
                 NOPEEK_CHANNEL_ID: ctx.channelId,
                 NOPEEK_SENDER_USER_ID: ctx.senderUserId,
+                ...(ctx.files?.length ? { NOPEEK_FILES: JSON.stringify(ctx.files) } : {}),
             },
         });
         let stdout = "";
@@ -113,6 +114,7 @@ function urlBrain(url, timeoutMs) {
                     botUserId: ctx.botUserId,
                     channelId: ctx.channelId,
                     senderUserId: ctx.senderUserId,
+                    ...(ctx.files?.length ? { files: ctx.files } : {}),
                 }),
             });
             if (!res.ok) {

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.10";
+export declare const VERSION = "0.7.14";
 export interface PairRequest {
     pairingSecret: string;
     appId: string;

package/dist/bridge.js

@@ -19,7 +19,7 @@ import { reportCapabilities } from "./capabilities.js";
 import { lastHermesApiHealth, probeHermesApi } from "./hermes-http.js";
 import { lastTurnGlobal, turnSnapshot } from "./last-turn.js";
 import { isBrainBackend } from "./config.js";
-export const VERSION = "0.7.10";
+export const VERSION = "0.7.14";
 function hermesApiStatus(cfg) {
     const api = lastHermesApiHealth();
     return {

package/dist/hermes-http.d.ts

@@ -10,6 +10,7 @@ export declare function lastHermesApiHealth(): HermesApiHealth | null;
 export declare function probeHermesApi(cfg: BridgeConfig, force?: boolean): Promise<HermesApiHealth>;
 /**
  * Stream one turn through Hermes' OpenAI-compatible chat completions.
- * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ * Session continuity: X-Hermes-Session-Id + Key = nopeek-<channelId>
+ * so follow-ups share history instead of starting a blank api-* job.
  */
 export declare function hermesHttpBrain(cfg: BridgeConfig): Brain;

package/dist/hermes-http.js

@@ -1,5 +1,31 @@
+import { readFileSync } from "node:fs";
 import { asHooks } from "./brain.js";
+import { hermesSessionHeaders } from "./mid-turn.js";
 import { RECAP_HINT } from "./tool-progress.js";
+/** Skip data-URL vision parts above this so a gallery cannot blow the POST. */
+const MAX_IMAGE_DATA_URL_BYTES = 8 * 1024 * 1024;
+const MAX_IMAGE_DATA_URL_TOTAL = 20 * 1024 * 1024;
+function userContent(text, files) {
+    const images = (files ?? []).filter((f) => f.kind === "image" && f.size > 0 && f.size <= MAX_IMAGE_DATA_URL_BYTES);
+    if (!images.length)
+        return text;
+    const parts = [{ type: "text", text }];
+    let used = 0;
+    for (const img of images) {
+        if (used + img.size > MAX_IMAGE_DATA_URL_TOTAL)
+            break;
+        try {
+            const b64 = readFileSync(img.path).toString("base64");
+            const mime = img.contentType.startsWith("image/") ? img.contentType : "image/jpeg";
+            parts.push({ type: "image_url", image_url: { url: `data:${mime};base64,${b64}` } });
+            used += img.size;
+        }
+        catch (err) {
+            console.error(`[brain:hermes-http] could not attach ${img.path}: ${err.message}`);
+        }
+    }
+    return parts.length > 1 ? parts : text;
+}
 let lastHealth = null;
 const HEALTH_TTL_MS = 15_000;
 export function lastHermesApiHealth() {
@@ -34,7 +60,8 @@ export async function probeHermesApi(cfg, force = false) {
 }
 /**
  * Stream one turn through Hermes' OpenAI-compatible chat completions.
- * Session continuity: X-Hermes-Session-Key = nopeek-<channelId> (stable per chat).
+ * Session continuity: X-Hermes-Session-Id + Key = nopeek-<channelId>
+ * so follow-ups share history instead of starting a blank api-* job.
  */
 export function hermesHttpBrain(cfg) {
     return async (text, ctx, hooks) => {
@@ -44,17 +71,19 @@ export function hermesHttpBrain(cfg) {
         const url = cfg.hermesApiUrl.replace(/\/+$/, "");
         const headers = {
             "content-type": "application/json",
+            ...hermesSessionHeaders(cfg.hermesApiKey ?? "", ctx.channelId),
         };
-        // Hermes rejects X-Hermes-Session-Key with 403 unless API_SERVER_KEY is set.
-        // Without a key, skip the header so the turn still runs (no session memory).
-        if (cfg.hermesApiKey) {
-            headers.authorization = `Bearer ${cfg.hermesApiKey}`;
-            headers["X-Hermes-Session-Key"] = `nopeek-${ctx.channelId}`;
-        }
         // Idle abort — same rule as the CLI path. A wall-clock timeout on the
         // whole POST would kill a healthy 20-minute agentic turn. Any SSE byte
         // (token, keepalive, tool-progress) resets the idle timer.
+        // ctx.signal aborts immediately when the user sends a mid-turn follow-up.
         const controller = new AbortController();
+        if (ctx.signal) {
+            if (ctx.signal.aborted)
+                controller.abort();
+            else
+                ctx.signal.addEventListener("abort", () => controller.abort(), { once: true });
+        }
         let idle;
         const armIdle = () => {
             clearTimeout(idle);
@@ -74,7 +103,7 @@ export function hermesHttpBrain(cfg) {
                     stream: true,
                     messages: [
                         { role: "system", content: RECAP_HINT },
-                        { role: "user", content: text },
+                        { role: "user", content: userContent(text, ctx.files) },
                     ],
                 }),
                 signal: controller.signal,
@@ -145,6 +174,8 @@ export function hermesHttpBrain(cfg) {
         catch (err) {
             const msg = err.message || "";
             if (controller.signal.aborted) {
+                if (ctx.signal?.aborted)
+                    return "";
                 return `⚠️ My brain went quiet for over ${Math.round(cfg.brainTimeoutMs / 1000)}s with no output and I had to give up on that turn — a long tool-use step or a very slow provider response can trigger this. Try messaging me again.`;
             }
             console.error(`${tag} stream error: ${msg}`);

package/dist/inbound-files.d.ts

@@ -0,0 +1,36 @@
+import type { BrainFile } from "./brain.js";
+export declare const CONTROL_TYPES: Set<string>;
+export declare const MAX_ATTACHMENT_BYTES: number;
+export declare const MAX_ATTACHMENTS = 20;
+export declare const MAX_TEXT_INJECT_BYTES: number;
+export type EncryptedAtt = {
+    blobUrl: string;
+    contentKey: string;
+    iv: string;
+    name?: string;
+    contentType?: string;
+    size?: number;
+};
+export type FileKind = BrainFile["kind"];
+export declare function isControlType(type?: string | null): boolean;
+export declare function parseAttachments(body: unknown): EncryptedAtt[];
+export declare function hasInboundWork(body: unknown): boolean;
+export declare function safeFileName(name: string | undefined, fallback: string): string;
+export declare function classifyKind(contentType: string | undefined, name: string): FileKind;
+export declare function inferContentType(name: string, contentType?: string): string;
+export declare function cacheDirFor(kind: FileKind, home?: string): string;
+export declare function describeStructured(body: Record<string, unknown> | null | undefined): string;
+export declare function fileNote(file: BrainFile): string;
+export declare function buildInboundPrompt(opts: {
+    caption: string;
+    files: BrainFile[];
+    structured?: string;
+    failures?: string[];
+}): string;
+export declare function injectTextPreview(file: BrainFile, bytes: Buffer): string | null;
+export type AttachmentFetcher = (att: EncryptedAtt) => Promise<Buffer>;
+export declare function saveInboundFiles(fetchAtt: AttachmentFetcher, attachments: EncryptedAtt[], messageId: string, home?: string): Promise<{
+    files: BrainFile[];
+    failures: string[];
+    previews: string[];
+}>;