@nopeek/agent-bridge 0.7.23 → 0.7.24

package/dist/bot.js

@@ -10,6 +10,7 @@ import { FileStore } from "./storage.js";
 import { TurnPublisher } from "./tool-progress.js";
 import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
 import { buildInboundPrompt, describeStructured, hasInboundWork, isControlType, parseAttachments, saveInboundFiles, } from "./inbound-files.js";
+import { deliverOutbound, extractMedia, attachMediaFiles, stripMediaTags } from "./outbound-media.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
@@ -687,13 +688,29 @@ export class BotRunner {
                     /* best-effort */
                 }
             };
+            const mediaSent = new Set();
             const published = new TurnPublisher({
                 stream: async () => {
                     const s = await ch.stream();
                     return {
                         append: (chunk) => s.append(chunk),
-                        replace: (full) => s.replace(full),
-                        done: (final) => s.done(final),
+                        replace: (full) => s.replace(stripMediaTags(full) || full),
+                        done: async (final) => {
+                            const raw = typeof final === "string" ? final : "";
+                            const { cleaned, paths } = extractMedia(raw);
+                            if (cleaned.trim())
+                                await s.done(cleaned);
+                            else {
+                                try {
+                                    s.replace("…");
+                                    await s.done("…");
+                                }
+                                catch {
+                                    await s.done("");
+                                }
+                            }
+                            await attachMediaFiles(ch, paths, mediaSent);
+                        },
                         fail: (text) => s.fail(text),
                         cancel: async () => {
                             // Do not recall() — that leaves "This message was deleted" / Message recalled.
@@ -708,7 +725,7 @@ export class BotRunner {
                     };
                 },
                 send: async (body) => {
-                    await ch.send({ text: body });
+                    await deliverOutbound(ch, body, mediaSent);
                 },
             }, {
                 stopTyping,

package/dist/outbound-media.d.ts

@@ -0,0 +1,34 @@
+import type { AttachmentInput } from "@nopeek/chat";
+export type ExtractedMedia = {
+    cleaned: string;
+    paths: string[];
+};
+export declare function extractMedia(text: string): ExtractedMedia;
+export declare function unwrapPath(raw: string): string;
+export declare function mediaAllowRoots(home?: string): string[];
+export declare function resolveMediaPath(raw: string, roots?: string[]): string | null;
+export declare function loadAttachment(path: string): AttachmentInput;
+export type MediaChannel = {
+    send: (body: {
+        text: string;
+    }) => Promise<unknown>;
+    sendAttachment: (a: AttachmentInput, opts?: {
+        caption?: string;
+    }) => Promise<unknown>;
+};
+export declare function attachMediaFiles(ch: Pick<MediaChannel, "sendAttachment">, paths: string[], alreadySent?: Set<string>): Promise<{
+    sent: string[];
+    failed: string[];
+}>;
+/**
+ * Post cleaned text, then each MEDIA file as a native image/video/audio/file
+ * bubble. Skips paths already sent this turn so stream.done + send cannot
+ * double-attach the same PDF.
+ */
+export declare function deliverOutbound(ch: MediaChannel, text: string, alreadySent?: Set<string>): Promise<{
+    cleaned: string;
+    sent: string[];
+    failed: string[];
+}>;
+/** Strip MEDIA tags for a live stream bubble without attaching yet. */
+export declare function stripMediaTags(text: string): string;

package/dist/outbound-media.js

@@ -0,0 +1,187 @@
+// Turn Hermes `MEDIA:/path/to/file.pdf` tags into real NoPeek attachments.
+// Telegram's gateway already does this; the bridge used to post the tag as text.
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, sep } from "node:path";
+import { hermesHome } from "./backends.js";
+import { inferContentType, MAX_ATTACHMENT_BYTES, safeFileName } from "./inbound-files.js";
+const MEDIA_EXTS = "png|jpe?g|gif|webp|bmp|tiff?|heic|heif|svg|mp4|mov|m4v|avi|mkv|webm|ogg|opus|mp3|wav|m4a|aac|flac|epub|pdf|zip|rar|7z|docx?|xlsx?|pptx?|txt|md|csv|json|html?|apk|ipa|log";
+// Mirrors Hermes gateway extract_media: MEDIA:<path>, optional quotes/backticks,
+// optional space after the colon, absolute or ~/ paths.
+const MEDIA_RE = new RegExp(String.raw `[\`"']?MEDIA:\s*(?<path>\`[^\`\n]+\`|"[^"\n]+"|'[^'\n]+'|(?:~/|/)\S+?\.(?:${MEDIA_EXTS}))[\`"']?`, "gi");
+const CACHE_SUBS = [
+    "cache",
+    "cache/images",
+    "cache/videos",
+    "cache/audio",
+    "cache/documents",
+    "cache/screenshots",
+    "audio_cache",
+    "image_cache",
+    "video_cache",
+    "document_cache",
+    "browser_screenshots",
+];
+export function extractMedia(text) {
+    if (!text)
+        return { cleaned: "", paths: [] };
+    MEDIA_RE.lastIndex = 0;
+    const paths = [];
+    const cleaned = text
+        .replace(MEDIA_RE, (_full, path) => {
+        const raw = unwrapPath(path);
+        if (raw)
+            paths.push(raw);
+        return "";
+    })
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+    return { cleaned, paths: dedupe(paths) };
+}
+export function unwrapPath(raw) {
+    let path = (raw || "").trim();
+    if (path.length >= 2 && path[0] === path[path.length - 1] && `\`"'`.includes(path[0])) {
+        path = path.slice(1, -1).trim();
+    }
+    path = path.replace(/^[`"']+/, "").replace(/[`"']+$/, "");
+    path = path.replace(/[.,;:)}]+$/, "");
+    if (path.startsWith("~/"))
+        path = join(homedir(), path.slice(2));
+    return path.trim();
+}
+export function mediaAllowRoots(home = hermesHome()) {
+    const bases = [home, join(homedir(), ".hermes")];
+    if (homedir() !== "/Users/jarvis")
+        bases.push("/Users/jarvis/.hermes");
+    const roots = [];
+    for (const base of bases) {
+        for (const sub of CACHE_SUBS)
+            roots.push(join(base, sub));
+    }
+    const extra = process.env.HERMES_MEDIA_ALLOW_DIRS || "";
+    for (const chunk of extra.split(/[: ,]+/)) {
+        const root = chunk.trim();
+        if (root.startsWith("/") || root.startsWith("~/"))
+            roots.push(unwrapPath(root));
+    }
+    return dedupe(roots);
+}
+export function resolveMediaPath(raw, roots = mediaAllowRoots()) {
+    const candidate = unwrapPath(raw);
+    if (!candidate.startsWith("/"))
+        return null;
+    if (!existsSync(candidate))
+        return null;
+    let resolved;
+    try {
+        resolved = realpathSync(candidate);
+    }
+    catch {
+        return null;
+    }
+    try {
+        if (!lstatSync(resolved).isFile())
+            return null;
+    }
+    catch {
+        return null;
+    }
+    for (const root of roots) {
+        if (!root)
+            continue;
+        let resolvedRoot = root;
+        try {
+            if (existsSync(root))
+                resolvedRoot = realpathSync(root);
+        }
+        catch {
+            continue;
+        }
+        if (isWithin(resolved, resolvedRoot))
+            return resolved;
+    }
+    return null;
+}
+export function loadAttachment(path) {
+    const st = statSync(path);
+    if (st.size > MAX_ATTACHMENT_BYTES) {
+        throw new Error(`${basename(path)} is over the ${MAX_ATTACHMENT_BYTES} byte limit`);
+    }
+    const buf = readFileSync(path);
+    const name = safeFileName(basename(path), "file");
+    return {
+        bytes: toArrayBuffer(buf),
+        name,
+        contentType: inferContentType(name),
+    };
+}
+export async function attachMediaFiles(ch, paths, alreadySent = new Set()) {
+    const failed = [];
+    const sent = [];
+    for (const raw of paths) {
+        const resolved = resolveMediaPath(raw);
+        if (!resolved) {
+            failed.push(basename(unwrapPath(raw)) || raw);
+            continue;
+        }
+        if (alreadySent.has(resolved))
+            continue;
+        try {
+            const att = loadAttachment(resolved);
+            await ch.sendAttachment(att);
+            alreadySent.add(resolved);
+            sent.push(resolved);
+        }
+        catch (err) {
+            failed.push(`${basename(resolved)} (${err.message})`);
+        }
+    }
+    return { sent, failed };
+}
+function failNote(failed) {
+    if (!failed.length)
+        return "";
+    if (failed.length === 1)
+        return `Couldn't attach ${failed[0]}.`;
+    return `Couldn't attach ${failed.length} files.`;
+}
+/**
+ * Post cleaned text, then each MEDIA file as a native image/video/audio/file
+ * bubble. Skips paths already sent this turn so stream.done + send cannot
+ * double-attach the same PDF.
+ */
+export async function deliverOutbound(ch, text, alreadySent = new Set()) {
+    const extracted = extractMedia(text);
+    const body = extracted.cleaned;
+    if (body.trim())
+        await ch.send({ text: body });
+    const { sent, failed } = await attachMediaFiles(ch, extracted.paths, alreadySent);
+    if (failed.length && !sent.length && !body.trim()) {
+        await ch.send({ text: failNote(failed) });
+    }
+    return { cleaned: body, sent, failed };
+}
+/** Strip MEDIA tags for a live stream bubble without attaching yet. */
+export function stripMediaTags(text) {
+    return extractMedia(text).cleaned;
+}
+function isWithin(path, root) {
+    const p = path.endsWith(sep) ? path.slice(0, -1) : path;
+    const r = root.endsWith(sep) ? root.slice(0, -1) : root;
+    return p === r || p.startsWith(r + sep);
+}
+function toArrayBuffer(buf) {
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+}
+function dedupe(items) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        if (!item || seen.has(item))
+            continue;
+        seen.add(item);
+        out.push(item);
+    }
+    return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.23",
+  "version": "0.7.24",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with one-time codes (multiple accounts per computer), runs every bot each account owns, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",
@@ -46,6 +46,6 @@
     "start": "node dist/cli.js",
     "dev": "tsx src/cli.ts",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts"
+    "test": "tsx --test --test-concurrency=1 src/tool-progress.test.ts src/inbound-files.test.ts src/mid-turn.test.ts src/outbound-media.test.ts"
   }
 }