@nopeek/agent-bridge 0.7.22 → 0.7.24

package/dist/backends.js

@@ -18,6 +18,7 @@ import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import { asHooks, stripAnsi } from "./brain.js";
 import { hermesHttpBrain, probeHermesApi } from "./hermes-http.js";
+import { parseHermesActivityLine } from "./tool-progress.js";
 const BRAIN_UNREACHABLE = "⚠️ I couldn't reach my brain just now — please try again in a moment.";
 // ------------------------------------------------------------------ souls ----
 /** Built-in personality template — personalized per bot by provisionSoul(). */
@@ -347,7 +348,15 @@ export function provisionHermesProfile(handle) {
 }
 // Chat chrome Hermes prints even in -Q mode: ruler lines, the echoed prompt
 // bubble (● …), the goodbye line, and session-info footers.
-const HERMES_CHROME = [/^[─━—-]{4,}\s*─*$/, /^●/, /^Goodbye!/, /^session(_| )?id:/i, /^↻/];
+const HERMES_CHROME = [
+    /^[─━—-]{4,}\s*─*$/,
+    /^●/,
+    /^Goodbye!/,
+    /^session(_| )?id:/i,
+    /^↻/,
+    /^[╭╰┌┐└┘]/,
+    /^[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/,
+];
 function isHermesChrome(line) {
     return HERMES_CHROME.some((re) => re.test(line));
 }
@@ -393,15 +402,17 @@ function detectHermesProfileMode(bin) {
     return hermesProfileMode;
 }
 function hermesCliBrain(cfg) {
-    const runOnce = (profile, text, sessionName, tag, onChunk) => new Promise((resolvePromise) => {
+    const runOnce = (profile, text, sessionName, tag, onChunk, onTool) => new Promise((resolvePromise) => {
         const bin = resolveBin("hermes", "HERMES_BIN");
         const mode = detectHermesProfileMode(bin);
         // v0.14+ takes the profile NAME via env; legacy took the PATH via flag.
         const profileName = basename(profile);
-        const args = mode === "flag" ? ["--profile", profile, "chat", "-Q"] : ["chat", "-Q"];
+        // Do NOT pass -Q. Quiet mode hides tool previews, so NoPeek looks dead
+        // while Hermes works. Telegram publishes those lines; we do the same.
+        const args = mode === "flag" ? ["--profile", profile, "chat"] : ["chat"];
         if (sessionName)
             args.push("--continue", sessionName);
-        args.push("-q", text);
+        args.push("--accept-hooks", "--source", "nopeek", "-q", text);
         const child = spawn(bin, args, {
             stdio: ["ignore", "pipe", "pipe"],
             // Hermes keys everything off $HOME; point it at the Hermes install.
@@ -452,6 +463,12 @@ function hermesCliBrain(cfg) {
             }
             if (noSession)
                 return; // swallow the "Use 'hermes sessions list'…" tail too
+            const activity = parseHermesActivityLine(line);
+            if (activity) {
+                sawContent = true;
+                onTool?.(activity);
+                return;
+            }
             sawContent = true;
             out += `${line}\n`;
             onChunk?.(`${line}\n`);
@@ -535,7 +552,7 @@ function hermesCliBrain(cfg) {
         });
     });
     return async (text, ctx, hooks) => {
-        const { onChunk } = asHooks(hooks);
+        const { onChunk, onTool } = asHooks(hooks);
         const handle = ctx.botHandle.replace(/^@/, "");
         const tag = `[brain:hermes:@${handle}]`;
         if (!resolveBin("hermes", "HERMES_BIN")) {
@@ -551,12 +568,12 @@ function hermesCliBrain(cfg) {
             return BRAIN_UNREACHABLE;
         }
         const sessionName = `nopeek-${ctx.channelId}`;
-        let run = await runOnce(profile, text, sessionName, tag, onChunk);
+        let run = await runOnce(profile, text, sessionName, tag, onChunk, onTool);
         if (run.noSession && !run.reply) {
             // First message in this channel: the named session doesn't exist yet.
             // Start fresh, then name the new session so the NEXT message continues it.
             console.log(`${tag} no session ${sessionName} yet — starting fresh`);
-            run = await runOnce(profile, text, null, tag, onChunk);
+            run = await runOnce(profile, text, null, tag, onChunk, onTool);
             if (run.sessionId) {
                 const bin = resolveBin("hermes", "HERMES_BIN");
                 const mode = detectHermesProfileMode(bin);

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,19 +688,44 @@ 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: () => ch.recall(s.messageId),
+                        cancel: async () => {
+                            // Do not recall() — that leaves "This message was deleted" / Message recalled.
+                            try {
+                                s.replace("…");
+                                await s.done("…");
+                            }
+                            catch {
+                                /* best-effort drop */
+                            }
+                        },
                     };
                 },
                 send: async (body) => {
-                    await ch.send({ text: body });
+                    await deliverOutbound(ch, body, mediaSent);
                 },
             }, {
                 stopTyping,
@@ -708,6 +734,7 @@ export class BotRunner {
                     this.logErr(`stream open failed (falling back to a single send): ${err.message}`);
                 },
             });
+            published.markStarted();
             const live = new ChannelTurn();
             this.turns.set(channelId, live);
             const prompt = interrupted ? wrapInterruptedFollowup(text) : text;

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.7.22";
+export declare const VERSION = "0.7.23";
 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.22";
+export const VERSION = "0.7.23";
 function hermesApiStatus(cfg) {
     const api = lastHermesApiHealth();
     return {

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/dist/tool-progress.d.ts

@@ -4,6 +4,13 @@ export type ToolProgressEvent = {
     label?: string;
     status?: string;
 };
+/** Shown the moment a turn starts so the chat is never silent like Telegram. */
+export declare const WORKING_LINE = "Working\u2026";
+/**
+ * Hermes CLI activity (`┊ 📋 plan  3 task(s)`). Used so the CLI brain can
+ * publish the same Telegram-style progress as the HTTP SSE path.
+ */
+export declare function parseHermesActivityLine(raw: string): ToolProgressEvent | null;
 /** One Telegram-style line. Running events only; completed is silent. */
 export declare function formatToolLine(ev: ToolProgressEvent): string | null;
 /** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
@@ -66,11 +73,14 @@ export declare class TurnPublisher {
     private startTimer;
     private gapTimer;
     private seen;
+    private started;
     private readonly startDelayMs;
     private readonly maxProgressLines;
     private readonly maxBubbleChars;
     private readonly bubbleGapMs;
     constructor(sink: TurnSink, opts: TurnPublisherOpts);
+    /** Open a live bubble immediately so HTTP and CLI turns never look dead. */
+    markStarted(): void;
     onChunk(delta: string): void;
     onTool(ev: ToolProgressEvent): void;
     finish(reply: string): Promise<TurnFinishKind>;

package/dist/tool-progress.js

@@ -27,6 +27,52 @@ const FALLBACK_EMOJI = {
     cronjob: "⏰",
     process: "⚙️",
 };
+/** Shown the moment a turn starts so the chat is never silent like Telegram. */
+export const WORKING_LINE = "Working…";
+const CLI_ACTIVITY = {
+    plan: { tool: "todo", emoji: "📋" },
+    read: { tool: "read_file", emoji: "📖" },
+    write: { tool: "write_file", emoji: "✍️" },
+    patch: { tool: "patch", emoji: "🔧" },
+    grep: { tool: "search_files", emoji: "🔎" },
+    find: { tool: "search_files", emoji: "🔎" },
+    $: { tool: "terminal", emoji: "💻" },
+    fetch: { tool: "web_extract", emoji: "📄" },
+    crawl: { tool: "web_crawl", emoji: "🕸️" },
+    memory: { tool: "memory", emoji: "🧠" },
+    recall: { tool: "session_search", emoji: "🔍" },
+    proc: { tool: "process", emoji: "⚙️" },
+    navigate: { tool: "browser_navigate", emoji: "🌐" },
+    snapshot: { tool: "browser_snapshot", emoji: "📸" },
+};
+/**
+ * Hermes CLI activity (`┊ 📋 plan  3 task(s)`). Used so the CLI brain can
+ * publish the same Telegram-style progress as the HTTP SSE path.
+ */
+export function parseHermesActivityLine(raw) {
+    const t = (raw || "").trim();
+    if (!t || !/^[┊│|]/.test(t))
+        return null;
+    const rest = t.replace(/^[┊│|]\s*/, "");
+    if (!rest || /^review\s+diff\b/i.test(rest))
+        return null;
+    const m = rest.match(/^(?:(\S+)\s+)?(\$|[A-Za-z_][\w.]*)\s*(.*)$/);
+    if (!m)
+        return null;
+    const maybeEmoji = m[1] || "";
+    const verb = (m[2] || "").replace(/:+$/, "");
+    if (!verb)
+        return null;
+    let label = (m[3] || "").replace(/\s+\d+(?:\.\d+)?s\s*$/, "").trim();
+    const mapped = CLI_ACTIVITY[verb];
+    const emoji = mapped?.emoji || (/^\p{Extended_Pictographic}/u.test(maybeEmoji) ? maybeEmoji : "⚡");
+    return {
+        tool: mapped?.tool || verb,
+        emoji,
+        ...(label ? { label } : {}),
+        status: "running",
+    };
+}
 /** One Telegram-style line. Running events only; completed is silent. */
 export function formatToolLine(ev) {
     if (ev.status && ev.status !== "running")
@@ -261,6 +307,7 @@ export class TurnPublisher {
     startTimer = null;
     gapTimer = null;
     seen = new Set();
+    started = false;
     startDelayMs;
     maxProgressLines;
     maxBubbleChars;
@@ -273,6 +320,13 @@ export class TurnPublisher {
         this.maxBubbleChars = opts.maxBubbleChars ?? DEFAULT_MAX_BUBBLE;
         this.bubbleGapMs = opts.bubbleGapMs ?? 2000;
     }
+    /** Open a live bubble immediately so HTTP and CLI turns never look dead. */
+    markStarted() {
+        if (this.started || this.toolsUsed || this.textP || this.progressP)
+            return;
+        this.started = true;
+        this.enqueue(() => this.addProgressLine(WORKING_LINE));
+    }
     onChunk(delta) {
         const chunk = stripDumps(delta);
         if (!chunk)
@@ -317,6 +371,9 @@ export class TurnPublisher {
                 const pending = this.held;
                 this.held = "";
                 await this.commitText(pending);
+                if (this.progressLines.length === 1 && this.progressLines[0] === WORKING_LINE) {
+                    this.progressLines = [];
+                }
             }
             await this.addProgressLine(line);
         });
@@ -531,7 +588,7 @@ export class TurnPublisher {
         this.progressLines = [];
         if (!s)
             return;
-        if (text)
+        if (text && text !== WORKING_LINE)
             await s.done(text).catch(() => { });
         else
             await s.cancel().catch(() => { });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.22",
+  "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"
   }
 }