@nopeek/agent-bridge 0.7.23 → 0.7.25

package/dist/bot.js

@@ -8,8 +8,9 @@ import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { beginTurn, finishTurn, lastTurnFor } from "./last-turn.js";
 import { FileStore } from "./storage.js";
 import { TurnPublisher } from "./tool-progress.js";
-import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
+import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, isStopRequest, wrapInterruptedFollowup, wrapUserTurn, } 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,
@@ -720,7 +737,7 @@ export class BotRunner {
             published.markStarted();
             const live = new ChannelTurn();
             this.turns.set(channelId, live);
-            const prompt = interrupted ? wrapInterruptedFollowup(text) : text;
+            const prompt = interrupted ? wrapInterruptedFollowup(text) : wrapUserTurn(text);
             let reply = "";
             const stat = beginTurn(this.info.handle, channelId, resolved.kind);
             try {

package/dist/bridge.d.ts

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

package/dist/hermes-http.js

@@ -1,6 +1,7 @@
 import { readFileSync } from "node:fs";
 import { asHooks } from "./brain.js";
 import { hermesSessionHeaders } from "./mid-turn.js";
+import { rememberHermesSessionId } from "./hermes-session-store.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;
@@ -120,6 +121,7 @@ export function hermesHttpBrain(cfg) {
             console.error(`${tag} HTTP ${res.status}: ${body.slice(0, 300)}`);
             return "";
         }
+        rememberHermesSessionId(ctx.channelId, res.headers.get("X-Hermes-Session-Id"));
         if (!res.body) {
             clearTimeout(idle);
             console.error(`${tag} empty body`);

package/dist/hermes-session-store.d.ts

@@ -0,0 +1,5 @@
+/** Test-only. Pass null to restore the real bridge home. */
+export declare function setBridgeHomeForTests(dir: string | null): void;
+export declare function resolvedHermesSessionId(channelId: string): string;
+export declare function rememberHermesSessionId(channelId: string, returnedId: string | null | undefined): void;
+export declare function forgetHermesSessionId(channelId: string): void;

package/dist/hermes-session-store.js

@@ -0,0 +1,65 @@
+// Hermes compression rotates X-Hermes-Session-Id (parent → 20260821_…).
+// The bridge used to keep sending the original nopeek-<channel> id, so every
+// turn reloaded the uncompressed parent (301 mixed messages) and Olie snapped
+// back to an old NoPeek backlog. Persist the returned id per channel.
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+function fallbackId(channelId) {
+    return `nopeek-${channelId}`;
+}
+let homeOverride = null;
+/** Test-only. Pass null to restore the real bridge home. */
+export function setBridgeHomeForTests(dir) {
+    homeOverride = dir;
+}
+function storePath() {
+    const home = homeOverride || process.env.NOPEEK_BRIDGE_HOME || join(homedir(), ".nopeek-bridge");
+    return join(home, "hermes-sessions.json");
+}
+function readMap() {
+    const path = storePath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object")
+            return {};
+        const out = {};
+        for (const [k, v] of Object.entries(parsed)) {
+            if (typeof v === "string" && v.trim())
+                out[k] = v.trim();
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+function writeMap(map) {
+    const path = storePath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    writeFileSync(tmp, JSON.stringify(map, null, 2));
+    renameSync(tmp, path);
+}
+export function resolvedHermesSessionId(channelId) {
+    return readMap()[channelId] || fallbackId(channelId);
+}
+export function rememberHermesSessionId(channelId, returnedId) {
+    const next = (returnedId || "").trim();
+    if (!next)
+        return;
+    const map = readMap();
+    if (map[channelId] === next)
+        return;
+    map[channelId] = next;
+    writeMap(map);
+}
+export function forgetHermesSessionId(channelId) {
+    const map = readMap();
+    if (!(channelId in map))
+        return;
+    delete map[channelId];
+    writeMap(map);
+}

package/dist/mid-turn.d.ts

@@ -20,6 +20,9 @@ export declare function isBotEcho(m: {
     } | null;
 }, botUserId: string): boolean;
 export declare function coalesceFollowups(texts: string[]): FollowupDecision;
+/** Pinned on every turn so compaction leftovers cannot become the job. */
+export declare const JOB_PIN: string;
+export declare function wrapUserTurn(text: string): string;
 export declare function wrapInterruptedFollowup(text: string): string;
 export declare function hermesSessionId(channelId: string): string;
 export declare function hermesSessionHeaders(apiKey: string, channelId: string): Record<string, string>;

package/dist/mid-turn.js

@@ -7,6 +7,7 @@
 //
 // This module is the shared policy: detect stop, coalesce a burst, abort the
 // in-flight turn, and keep one stable Hermes session per channel.
+import { resolvedHermesSessionId } from "./hermes-session-store.js";
 const STOP_RE = /^(?:\/)?(?:please\s+)?stop(?:\s+please)?[.!]?$/i;
 export function isStopRequest(text) {
     return STOP_RE.test((text || "").trim());
@@ -41,11 +42,28 @@ export function coalesceFollowups(texts) {
     const kept = cleaned.filter((t) => !isStopRequest(t));
     return { action: "continue", text: kept.join("\n\n") };
 }
+/**
+ * Keep this marker. Hermes api_server `is_mid_task_followup` looks for it and
+ * otherwise prepends its own "ONE combined task" note — that is what made
+ * "do all 5" merge with a compacted NoPeek backlog.
+ */
+const INTERRUPT_MARKER = "[System note: You were already working on a task";
+/** Pinned on every turn so compaction leftovers cannot become the job. */
+export const JOB_PIN = "[System note: The message below is the only live job. " +
+    "Do not resume older unfinished todos, numbered lists, or other products " +
+    "from compacted history unless this message clearly continues that same job. " +
+    '"Do all 5" means the list in YOUR LAST REPLY, not an older backlog. ' +
+    "Latest user message wins.]";
+export function wrapUserTurn(text) {
+    return `${JOB_PIN}\n\n${text}`;
+}
 export function wrapInterruptedFollowup(text) {
-    return ("[System note: You were already working on a task. The user interrupted. " +
-        "Reassess the previous work together with this new message and continue as " +
-        "ONE combined task. Do not start a separate independent job. If the new " +
-        "message replaces the old task, switch to it.]\n\n" +
+    return (`${INTERRUPT_MARKER}. The user interrupted. ` +
+        "The new message below REPLACES the in-flight task unless it is a small " +
+        'add-on to the same job (e.g. "also add X"). Do not resume older unfinished ' +
+        "todos or other products from compacted history. " +
+        '"Do all 5" means the list in your last reply, not an older backlog. ' +
+        "Latest user message wins.]\n\n" +
         text);
 }
 export function hermesSessionId(channelId) {
@@ -55,10 +73,11 @@ export function hermesSessionHeaders(apiKey, channelId) {
     const headers = {};
     if (!apiKey)
         return headers;
-    const sid = hermesSessionId(channelId);
+    // Key stays the channel. Id follows compression rotations so we do not
+    // reload the uncompressed parent every turn.
     headers.authorization = `Bearer ${apiKey}`;
-    headers["X-Hermes-Session-Id"] = sid;
-    headers["X-Hermes-Session-Key"] = sid;
+    headers["X-Hermes-Session-Id"] = resolvedHermesSessionId(channelId);
+    headers["X-Hermes-Session-Key"] = hermesSessionId(channelId);
     return headers;
 }
 export class ChannelTurn {

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

@@ -14,7 +14,7 @@ export declare function parseHermesActivityLine(raw: string): ToolProgressEvent
 /** 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. */
-export declare const RECAP_HINT = "When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+export declare const RECAP_HINT = "The latest user message is the only live job. Do not resume compacted leftovers or an older numbered list from another product. When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
 /** Posted when tools ran but the model never wrote a human recap. */
 export declare const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 export interface StreamHandle {

package/dist/tool-progress.js

@@ -95,7 +95,7 @@ function tidyLabel(raw) {
     return s.length > 80 ? `${s.slice(0, 77)}...` : s;
 }
 /** Hint so Hermes ends a tool-using turn with a recap, like Telegram. */
-export const RECAP_HINT = "When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
+export const RECAP_HINT = "The latest user message is the only live job. Do not resume compacted leftovers or an older numbered list from another product. When this turn used tools, your LAST message must be ONE phone briefing (not split). Use **bold** labels and blank lines like Telegram: **What was wrong**, **What I did**, **Current state**. Put copyable commands in ``` fences. Never end on a tool list, a diff, or \"tasks completed\". Skip the briefing only for simple chat with no tools. No em dashes.";
 /** Posted when tools ran but the model never wrote a human recap. */
 export const MISSING_BRIEFING = "Done. I finished that work. Ask if you want the recap: what was wrong, what I did, and where things stand.";
 /** Text in `full` that has not already been posted as commentary. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.7.23",
+  "version": "0.7.25",
   "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 src/hermes-session-store.test.ts"
   }
 }