@nopeek/agent-bridge 0.7.21 → 0.7.23

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.d.ts

@@ -64,6 +64,8 @@ export declare class BotRunner {
     /** Fire-and-forget: runs the connect loop in the background, isolated. */
     start(): void;
     stop(): void;
+    /** Crash/restart must not leave Hermes running against a dead socket. */
+    private abortLiveTurns;
     private mintSession;
     /** Fetch (or refresh) the set of users allowed to talk to this bot. Called on
      *  connect and whenever a grant changes. Best-effort: on failure we keep the
@@ -96,6 +98,13 @@ export declare class BotRunner {
     private ownerIsChannelMember;
     private run;
     private connectOnce;
+    /**
+     * A bridge restart mid-stream leaves `{streaming:true}` bubbles with a live
+     * caret forever. On connect, finalize our own orphan streams and tell the
+     * human we got cut off — Telegram never sits on a typing caret for hours.
+     */
+    private settleAllOrphans;
+    private settleOrphanStreams;
     /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
     private scheduleRefresh;
     private reconnect;

package/dist/bot.js

@@ -8,7 +8,7 @@ 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, isStopRequest, wrapInterruptedFollowup, } from "./mid-turn.js";
+import { ChannelTurn, coalesceFollowups, isBotEcho, isPlaceholderText, 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;
@@ -116,6 +116,7 @@ export class BotRunner {
         if (this.stopped)
             return; // truly stopped (unpair) — never resurrect
         this.lastForcedRestart = Date.now();
+        this.abortLiveTurns();
         if (this.refreshTimer)
             clearTimeout(this.refreshTimer);
         this.refreshTimer = null;
@@ -143,6 +144,7 @@ export class BotRunner {
     }
     stop() {
         this.stopped = true;
+        this.abortLiveTurns();
         if (this.refreshTimer)
             clearTimeout(this.refreshTimer);
         try {
@@ -154,6 +156,13 @@ export class BotRunner {
         this.np = null;
         this.connected = false;
     }
+    /** Crash/restart must not leave Hermes running against a dead socket. */
+    abortLiveTurns() {
+        for (const turn of this.turns.values()) {
+            if (turn.active)
+                turn.abort.abort();
+        }
+    }
     async mintSession() {
         const res = await fetch(`${this.pairing.apiUrl}/v1/apps/${this.pairing.appId}/bots/${this.info.userId}/runtime-session`, {
             method: "POST",
@@ -401,6 +410,68 @@ export class BotRunner {
         }));
         await this.refreshAccess(); // load the allow list before we answer anyone
         this.scheduleRefresh(session.expiresAt);
+        void this.settleAllOrphans();
+    }
+    /**
+     * A bridge restart mid-stream leaves `{streaming:true}` bubbles with a live
+     * caret forever. On connect, finalize our own orphan streams and tell the
+     * human we got cut off — Telegram never sits on a typing caret for hours.
+     */
+    async settleAllOrphans() {
+        if (!this.np || this.stopped)
+            return;
+        let channels;
+        try {
+            channels = await this.np.channels.list();
+        }
+        catch (err) {
+            this.logErr(`orphan scan list failed: ${err.message}`);
+            return;
+        }
+        for (const ch of channels) {
+            if (this.stopped)
+                return;
+            if (this.turns.get(ch.channelId)?.active)
+                continue;
+            try {
+                const n = await this.settleOrphanStreams(ch);
+                if (n > 0) {
+                    this.log(`${ch.channelId} finalized ${n} orphan stream(s)`);
+                    await ch.send({
+                        text: "I got cut off mid-turn. Send another message and I'll pick up.",
+                    }).catch((err) => this.notePostFailure(ch.channelId, err));
+                }
+            }
+            catch (err) {
+                this.logErr(`orphan settle ${ch.channelId}: ${err.message}`);
+            }
+        }
+    }
+    async settleOrphanStreams(ch) {
+        try {
+            await ch.ensureKey();
+        }
+        catch {
+            return 0;
+        }
+        const recent = await ch.history({ limit: 40 });
+        let n = 0;
+        for (const m of recent) {
+            if (m.senderUserId !== this.info.userId)
+                continue;
+            const body = m.body;
+            if (!body || body.streaming !== true)
+                continue;
+            const text = typeof body.text === "string" ? body.text : "";
+            if (!text.trim() || isPlaceholderText(text)) {
+                await ch.recall(m.messageId).catch(() => { });
+            }
+            else {
+                await ch.edit(m.messageId, { text, streaming: false }).catch(() => { });
+            }
+            n += 1;
+        }
+        return n;
     }
     /** Runtime sessions expire; reconnect with a fresh one shortly before that. */
     scheduleRefresh(expiresAt) {
@@ -624,7 +695,16 @@ export class BotRunner {
                         replace: (full) => s.replace(full),
                         done: (final) => s.done(final),
                         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) => {
@@ -637,6 +717,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.21";
+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.21";
+export const VERSION = "0.7.23";
 function hermesApiStatus(cfg) {
     const api = lastHermesApiHealth();
     return {

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.21",
+  "version": "0.7.23",
   "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",