@nopeek/agent-bridge 0.5.4 → 0.5.6

package/dist/backends.d.ts

@@ -33,9 +33,4 @@ export declare function hermesHome(): string;
  * stays authenticated from one login). Idempotent.
  */
 export declare function provisionHermesProfile(handle: string): string;
-/**
- * Hermes backend: per-bot profile (own soul + memories), one persistent
- * session per channel (`--continue nopeek-<channel>`), streaming cleaned
- * stdout lines to onChunk.
- */
 export declare function hermesBrain(cfg: BridgeConfig): Brain;

package/dist/backends.js

@@ -292,7 +292,7 @@ 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));
 }
@@ -301,26 +301,20 @@ function isHermesChrome(line) {
  * session per channel (`--continue nopeek-<channel>`), streaming cleaned
  * stdout lines to onChunk.
  */
+/** `hermes chat --continue <name>` FAILS (does not create) when the named
+ *  session doesn't exist yet — this is what its error looks like. */
+const HERMES_NO_SESSION = /^No session found matching/i;
+/** Session footer Hermes prints on exit; we filter it as chrome but capture
+ *  the id so a fresh session can be renamed for future --continue. */
+const HERMES_SESSION_ID = /^session(_| )?id:\s*(\S+)/i;
 export function hermesBrain(cfg) {
-    return (text, ctx, onChunk) => new Promise((resolvePromise) => {
-        const handle = ctx.botHandle.replace(/^@/, "");
-        const tag = `[brain:hermes:@${handle}]`;
+    const runOnce = (profile, text, sessionName, tag, onChunk) => new Promise((resolvePromise) => {
         const bin = resolveBin("hermes", "HERMES_BIN");
-        if (!bin) {
-            console.error(`${tag} hermes not found on PATH`);
-            resolvePromise(BRAIN_UNREACHABLE);
-            return;
-        }
-        let profile;
-        try {
-            profile = provisionHermesProfile(handle);
-        }
-        catch (err) {
-            console.error(`${tag} profile provisioning failed: ${err.message}`);
-            resolvePromise(BRAIN_UNREACHABLE);
-            return;
-        }
-        const child = spawn(bin, ["--profile", profile, "chat", "-Q", "--continue", `nopeek-${ctx.channelId}`, "-q", text], {
+        const args = ["--profile", profile, "chat", "-Q"];
+        if (sessionName)
+            args.push("--continue", sessionName);
+        args.push("-q", text);
+        const child = spawn(bin, args, {
             stdio: ["ignore", "pipe", "pipe"],
             // Hermes keys everything off $HOME; point it at the Hermes install.
             env: { ...process.env, HOME: hermesHome() },
@@ -330,12 +324,42 @@ export function hermesBrain(cfg) {
         let sawContent = false; // suppress leading blank lines
         let stderr = "";
         let settled = false;
+        let noSession = false;
+        let sessionId = null;
+        let bannerCont = false; // inside a wrapped "↻ Resumed session …" banner
         const handleLine = (raw) => {
             const line = stripAnsi(raw);
+            const sid = HERMES_SESSION_ID.exec(line);
+            if (sid)
+                sessionId = sid[2];
+            // The resume banner ("↻ Resumed session … (1 message, 2 total messages)")
+            // can wrap across lines; swallow continuations until the closing paren.
+            if (bannerCont) {
+                if (/\)\s*$/.test(line) || !line.trim())
+                    bannerCont = false;
+                return;
+            }
+            if (/^↻/.test(line.trim())) {
+                if (!/\)\s*$/.test(line.trim()))
+                    bannerCont = true;
+                return;
+            }
             if (isHermesChrome(line))
                 return;
             if (!sawContent && !line.trim())
                 return;
+            // Leading host warnings ("⚠ tirith security scanner…") are chrome,
+            // not reply. Only before real content — a ⚠ mid-reply is kept.
+            if (!sawContent && /^[⚠✗]/.test(line.trim()))
+                return;
+            // First content line saying "No session found" = the --continue miss,
+            // not a reply. Don't stream it to the chat; the caller retries fresh.
+            if (!sawContent && HERMES_NO_SESSION.test(line.trim())) {
+                noSession = true;
+                return;
+            }
+            if (noSession)
+                return; // swallow the "Use 'hermes sessions list'…" tail too
             sawContent = true;
             out += `${line}\n`;
             onChunk?.(`${line}\n`);
@@ -346,14 +370,18 @@ export function hermesBrain(cfg) {
             settled = true;
             if (lineBuf)
                 handleLine(lineBuf);
-            const reply = out.trim();
-            if (!reply) {
-                if (stderr.trim())
-                    console.error(`${tag} stderr: ${stderr.slice(0, 1000)}`);
-                resolvePromise("⚠️ My brain isn't reachable right now — Hermes has no authenticated provider on the host. Run 'hermes model' there, then message me again.");
-                return;
+            // The session footer lands on STDERR in -Q mode — scan there too.
+            if (!sessionId) {
+                for (const line of stderr.split("\n")) {
+                    const sid = HERMES_SESSION_ID.exec(stripAnsi(line).trim());
+                    if (sid)
+                        sessionId = sid[2];
+                }
             }
-            resolvePromise(reply);
+            // "No session found" can land on stderr in some hermes builds.
+            if (!out.trim() && HERMES_NO_SESSION.test(stderr.trim()))
+                noSession = true;
+            resolvePromise({ reply: out.trim(), noSession, sessionId, stderr });
         };
         const timer = setTimeout(() => {
             console.error(`${tag} timed out after ${cfg.brainTimeoutMs / 1000}s, killing`);
@@ -373,7 +401,7 @@ export function hermesBrain(cfg) {
             console.error(`${tag} spawn error: ${err.message}`);
             if (!settled) {
                 settled = true;
-                resolvePromise(BRAIN_UNREACHABLE);
+                resolvePromise({ reply: "", noSession: false, sessionId: null, stderr: err.message });
             }
         });
         child.on("close", () => {
@@ -381,4 +409,47 @@ export function hermesBrain(cfg) {
             finish();
         });
     });
+    return async (text, ctx, onChunk) => {
+        const handle = ctx.botHandle.replace(/^@/, "");
+        const tag = `[brain:hermes:@${handle}]`;
+        if (!resolveBin("hermes", "HERMES_BIN")) {
+            console.error(`${tag} hermes not found on PATH`);
+            return BRAIN_UNREACHABLE;
+        }
+        let profile;
+        try {
+            profile = provisionHermesProfile(handle);
+        }
+        catch (err) {
+            console.error(`${tag} profile provisioning failed: ${err.message}`);
+            return BRAIN_UNREACHABLE;
+        }
+        const sessionName = `nopeek-${ctx.channelId}`;
+        let run = await runOnce(profile, text, sessionName, tag, onChunk);
+        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);
+            if (run.sessionId) {
+                const bin = resolveBin("hermes", "HERMES_BIN");
+                const rn = spawn(bin, ["--profile", profile, "sessions", "rename", run.sessionId, sessionName], {
+                    stdio: "ignore",
+                    env: { ...process.env, HOME: hermesHome() },
+                });
+                rn.on("error", () => {
+                    /* best-effort — worst case the next message starts fresh again */
+                });
+            }
+            else {
+                console.error(`${tag} fresh session id not captured — next message will start fresh again`);
+            }
+        }
+        if (!run.reply) {
+            if (run.stderr.trim())
+                console.error(`${tag} stderr: ${run.stderr.slice(0, 1000)}`);
+            return "⚠️ My brain isn't reachable right now — Hermes has no authenticated provider on the host. Run 'hermes model' there, then message me again.";
+        }
+        return run.reply;
+    };
 }

package/dist/bot.d.ts

@@ -24,6 +24,8 @@ export declare class BotRunner {
     private allowed;
     private accessLoaded;
     private declined;
+    private chains;
+    private cantPost;
     private log;
     private logErr;
     constructor(info: BotInfo, cfg: BridgeConfig);
@@ -50,4 +52,7 @@ export declare class BotRunner {
     /** Bounded dedupe so a redelivered frame is never answered twice. */
     private remember;
     private handleMessage;
+    /** 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

@@ -28,6 +28,13 @@ export class BotRunner {
     allowed = new Set();
     accessLoaded = false;
     declined = new Set(); // (senderId) already told "not authorized" once
+    // Per-channel serialization: two messages in one channel must be answered in
+    // 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();
+    // 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();
     log;
     logErr;
     constructor(info, cfg) {
@@ -153,8 +160,15 @@ export class BotRunner {
             this.log(`received channel key for ${p.channelId} (welcome ceremony completed)`);
         }));
         np.on("message", ((m) => {
-            void this.handleMessage(m).catch((err) => {
+            const prev = this.chains.get(m.channelId) ?? Promise.resolve();
+            const next = prev.then(() => this.handleMessage(m).catch((err) => {
+                this.notePostFailure(m.channelId, err);
                 this.logErr(`handler error for ${m.messageId}: ${err.message}`);
+            }));
+            this.chains.set(m.channelId, next);
+            void next.finally(() => {
+                if (this.chains.get(m.channelId) === next)
+                    this.chains.delete(m.channelId);
             });
         }));
         await this.refreshAccess(); // load the allow list before we answer anyone
@@ -216,6 +230,8 @@ export class BotRunner {
         this.remember(m.messageId);
         if (m.senderUserId === this.info.userId)
             return; // never answer ourselves
+        if (this.cantPost.has(m.channelId))
+            return; // replies can't land here — don't burn a brain run
         if (m.decryptionFailed) {
             // Likely a missed welcome (message arrived before our key). Sync the key
             // so the NEXT message decrypts; this frame's plaintext is unrecoverable.
@@ -278,6 +294,7 @@ export class BotRunner {
                 }
                 streamRef.p = ch.stream();
                 streamRef.p.catch((err) => {
+                    this.notePostFailure(m.channelId, err);
                     this.logErr(`stream open failed (falling back to a single send): ${err.message}`);
                 });
             }
@@ -323,4 +340,14 @@ export class BotRunner {
         this.handled++;
         this.log(`${m.channelId} -> replied (${reply.trim().length} chars, handled=${this.handled})`);
     }
+    /** A FORBIDDEN post (broadcast channel, bot not an operator) fails for every
+     *  future message too — mute the channel so the brain stops running there. */
+    notePostFailure(channelId, err) {
+        if (!/only operators can post|FORBIDDEN/i.test(err.message))
+            return;
+        if (this.cantPost.has(channelId))
+            return;
+        this.cantPost.add(channelId);
+        this.log(`muting ${channelId} — bot cannot post here (${err.message.slice(0, 80)})`);
+    }
 }

package/dist/bridge.d.ts

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

package/dist/bridge.js

@@ -14,7 +14,7 @@ import { resolveBrain } from "./brain.js";
 import { provisionSoul, provisionHermesProfile } from "./backends.js";
 import { reportCapabilities } from "./capabilities.js";
 import { isBrainBackend } from "./config.js";
-export const VERSION = "0.5.4";
+export const VERSION = "0.5.6";
 /** How often to re-probe + report brain availability to the server. */
 const CAPABILITIES_INTERVAL_MS = 5 * 60_000;
 export class PairError extends Error {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Run your own agents as E2EE NoPeek bots. Pairs with a one-time code, runs every bot you own, and pipes messages to any command or webhook.",
   "type": "module",
   "license": "MIT",