@nopeek/agent-bridge 0.6.2 → 0.7.0

package/dist/bot.d.ts

@@ -1,4 +1,5 @@
 import type { BridgeConfig, Pairing, BrainBackend } from "./config.js";
+import { type ChannelMode } from "./control.js";
 export interface BotInfo {
     userId: string;
     handle: string;
@@ -27,6 +28,9 @@ export declare class BotRunner {
     private declined;
     private ownerPresence;
     private mutedNoOwner;
+    private runtimeOwnerId;
+    private channelModes;
+    private mutedOff;
     private chains;
     private cantPost;
     private log;
@@ -46,6 +50,20 @@ export declare class BotRunner {
     refreshAccess(): Promise<void>;
     /** Sender permitted to talk to this bot? Fail closed if access never loaded. */
     private isAllowed;
+    /** Merge live per-channel reply-mode updates (from a bot_config_changed
+     *  control frame). Additive: only the listed channels change. */
+    applyChannelModes(modes: Record<string, ChannelMode>): void;
+    /** Regex matching an @-mention of this bot: the exact @handle (word-boundary,
+     *  case-insensitive) plus the display nickname when we have one. The
+     *  lookbehind keeps "user@handle.com" from counting as a mention. */
+    private mentionRegex;
+    /** "mention" mode: returns the text with the mention token(s) stripped (so
+     *  prompts read naturally), or null when the bot is not mentioned. A message
+     *  that is ONLY the mention ("@bot") passes through unstripped. */
+    private extractMention;
+    /** The USER whose presence the owner-present policy requires: the bot's
+     *  owner for user-owned bots, else the user who paired this runtime. */
+    private effectiveOwnerId;
     /** Is the bot's owner currently a member of this channel? Server-checked via
      *  the channel roster (the bot is a member, so it may list members), cached
      *  for a short TTL, invalidated by member.joined/left. On a fetch failure we

package/dist/bot.js

@@ -3,6 +3,7 @@
 // for decrypted messages and answers through the resolved brain. Failures are
 // isolated — a broken bot retries with backoff and never takes down its peers.
 import { NoPeek } from "@nopeek/chat";
+import { isChannelMode } from "./control.js";
 import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { FileStore } from "./storage.js";
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
@@ -39,6 +40,16 @@ export class BotRunner {
     // server per channel and cached briefly; member.joined/left invalidate it.
     ownerPresence = new Map();
     mutedNoOwner = new Set(); // channels already logged as owner-absent
+    // For a workspace-owned bot there is no single owner USER — the accountable
+    // human is whoever paired the runtime that runs it. The access endpoint
+    // reports that as runtimeOwnerUserId; the owner-present policy uses it.
+    runtimeOwnerId;
+    // CHANNEL REPLY MODES (groups): per-channel "everyone" | "mention" | "off",
+    // loaded from the access endpoint and merged live from bot_config_changed
+    // frames. A channel absent from the map is "everyone". DIRECT channels always
+    // behave as "everyone" — a DM with the bot is always for the bot.
+    channelModes = new Map();
+    mutedOff = new Set(); // channels already logged as mode=off
     // 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.
@@ -107,6 +118,16 @@ export class BotRunner {
                 throw new Error(`access HTTP ${res.status}`);
             const j = (await res.json());
             this.allowed = new Set(j.allowedUserIds ?? []);
+            // Channel reply modes: the access response is a full snapshot — replace
+            // the map (a channel the server no longer lists reverts to "everyone").
+            const modes = new Map();
+            for (const [channelId, mode] of Object.entries(j.channelModes ?? {})) {
+                if (isChannelMode(mode))
+                    modes.set(channelId, mode);
+            }
+            this.channelModes = modes;
+            if (j.runtimeOwnerUserId)
+                this.runtimeOwnerId = j.runtimeOwnerUserId;
             // The access response is authoritative on ownership — adopt it so the
             // owner-present policy always knows who the owner is, even when the
             // runtime/bots listing omitted the fields.
@@ -115,7 +136,7 @@ export class BotRunner {
                 this.info.ownerType = j.ownerType ?? this.info.ownerType;
             }
             this.accessLoaded = true;
-            this.log(`access: policy=${j.policy ?? "private"}, ${this.allowed.size} allowed sender(s)`);
+            this.log(`access: policy=${j.policy ?? "private"}, ${this.allowed.size} allowed sender(s), ${this.channelModes.size} channel mode(s)`);
         }
         catch (err) {
             this.logErr(`access refresh failed: ${err.message} (keeping last-known allow list)`);
@@ -129,12 +150,66 @@ export class BotRunner {
             return false; // fail closed until we know the list
         return this.allowed.has(senderUserId);
     }
+    /** Merge live per-channel reply-mode updates (from a bot_config_changed
+     *  control frame). Additive: only the listed channels change. */
+    applyChannelModes(modes) {
+        for (const [channelId, mode] of Object.entries(modes)) {
+            if (!isChannelMode(mode))
+                continue;
+            const prev = this.channelModes.get(channelId) ?? "everyone";
+            if (mode === "everyone")
+                this.channelModes.delete(channelId); // absent = everyone
+            else
+                this.channelModes.set(channelId, mode);
+            if (prev !== mode) {
+                this.mutedOff.delete(channelId); // transitioning into "off" re-logs once
+                this.log(`reply mode for ${channelId}: ${prev} -> ${mode}`);
+            }
+        }
+    }
+    /** Regex matching an @-mention of this bot: the exact @handle (word-boundary,
+     *  case-insensitive) plus the display nickname when we have one. The
+     *  lookbehind keeps "user@handle.com" from counting as a mention. */
+    mentionRegex() {
+        const names = [this.info.handle, this.info.nickname]
+            .filter((n) => typeof n === "string" && !!n.trim())
+            .map((n) => n.trim().replace(/^@/, ""))
+            .map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+        if (names.length === 0)
+            return null;
+        return new RegExp(`(?<![\\w@])@(?:${names.join("|")})\\b`, "gi");
+    }
+    /** "mention" mode: returns the text with the mention token(s) stripped (so
+     *  prompts read naturally), or null when the bot is not mentioned. A message
+     *  that is ONLY the mention ("@bot") passes through unstripped. */
+    extractMention(text) {
+        const re = this.mentionRegex();
+        if (!re)
+            return null;
+        if (!re.test(text))
+            return null;
+        re.lastIndex = 0;
+        const stripped = text
+            .replace(re, " ")
+            .replace(/^[\s,:;!—–-]+/, "")
+            .replace(/[ \t]+([,.:;!?])/g, "$1")
+            .replace(/[ \t]{2,}/g, " ")
+            .trim();
+        return stripped || text.trim();
+    }
+    /** The USER whose presence the owner-present policy requires: the bot's
+     *  owner for user-owned bots, else the user who paired this runtime. */
+    effectiveOwnerId() {
+        if (this.info.ownerType === "workspace")
+            return this.runtimeOwnerId;
+        return this.info.ownerId ?? this.runtimeOwnerId;
+    }
     /** Is the bot's owner currently a member of this channel? Server-checked via
      *  the channel roster (the bot is a member, so it may list members), cached
      *  for a short TTL, invalidated by member.joined/left. On a fetch failure we
      *  keep the last-known answer; with no known answer we FAIL CLOSED. */
     async ownerIsChannelMember(channelId) {
-        const ownerId = this.info.ownerId;
+        const ownerId = this.effectiveOwnerId();
         if (!ownerId)
             return false; // unknown owner → fail closed
         const cached = this.ownerPresence.get(channelId);
@@ -214,7 +289,7 @@ export class BotRunner {
             if (!p?.channelId)
                 return;
             this.ownerPresence.delete(p.channelId);
-            if (p.userId && p.userId === this.info.ownerId) {
+            if (p.userId && p.userId === this.effectiveOwnerId()) {
                 this.mutedNoOwner.delete(p.channelId); // re-log if the owner leaves again later
                 this.log(`owner membership changed in ${p.channelId} — presence cache invalidated`);
             }
@@ -311,15 +386,16 @@ export class BotRunner {
         // OWNER-PRESENT POLICY: in a multi-party channel (anything but a direct
         // chat), a non-owner sender may use the bot ONLY while the bot's owner is
         // also a member of that channel. Owner absent → completely silent (no
-        // brain run, not even the decline notice), regardless of grants. Workspace
-        // bots are exempt — they have no single owner user to require present.
-        if (m.senderUserId !== this.info.ownerId && this.info.ownerType !== "workspace") {
+        // brain run, not even the decline notice), regardless of grants. For a
+        // workspace bot "owner" means the user who paired this runtime.
+        const effOwner = this.effectiveOwnerId();
+        if (m.senderUserId !== effOwner) {
             const ch = await this.getChannel(m.channelId);
             if (ch.record.kind !== "direct") {
                 if (!(await this.ownerIsChannelMember(m.channelId))) {
                     if (!this.mutedNoOwner.has(m.channelId)) {
                         this.mutedNoOwner.add(m.channelId);
-                        this.log(`muting ${m.channelId} — owner ${this.info.ownerId ?? "?"} is not a member (owner-present policy); staying silent`);
+                        this.log(`muting ${m.channelId} — owner ${effOwner ?? "?"} is not a member (owner-present policy); staying silent`);
                     }
                     return;
                 }
@@ -342,9 +418,32 @@ export class BotRunner {
             }
             return;
         }
-        const text = m.body.text;
-        this.log(`${m.channelId} <- ${m.senderUserId}: ${text.slice(0, 120)}`);
         const ch = await this.getChannel(m.channelId);
+        // CHANNEL REPLY MODE (after the owner-present + access gates): the owner
+        // picks per group whether the bot answers everyone, only @mentions, or
+        // nobody. The rules apply to ALL allowed senders including the owner —
+        // predictable: mention-only means even the owner must @mention there.
+        // DIRECT channels always behave as "everyone" (a DM with the bot is always
+        // for the bot).
+        let text = m.body.text;
+        if (ch.record.kind !== "direct" && ch.record.kind !== "dm") {
+            const mode = this.channelModes.get(m.channelId) ?? "everyone";
+            if (mode === "off") {
+                if (!this.mutedOff.has(m.channelId)) {
+                    this.mutedOff.add(m.channelId);
+                    this.log(`muting ${m.channelId} — reply mode is "off"; staying silent (no brain runs)`);
+                }
+                return;
+            }
+            this.mutedOff.delete(m.channelId);
+            if (mode === "mention") {
+                const stripped = this.extractMention(text);
+                if (stripped === null)
+                    return; // not addressed to the bot — silent, no brain run
+                text = stripped;
+            }
+        }
+        this.log(`${m.channelId} <- ${m.senderUserId}: ${text.slice(0, 120)}`);
         ch.markRead(m.messageId).catch(() => { });
         try {
             ch.typing(true);

package/dist/bridge.d.ts

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

package/dist/bridge.js

@@ -17,7 +17,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.6.2";
+export const VERSION = "0.7.0";
 /** How often to re-probe + report brain availability to the server. */
 const CAPABILITIES_INTERVAL_MS = 5 * 60_000;
 export class PairError extends Error {
@@ -90,18 +90,24 @@ class PairingRuntime {
                     void runner.refreshAccess();
             },
             onBotConfig: (f) => {
-                // The owner changed this bot's brain from the phone. Record the server
-                // backend and re-resolve live — the runner resolves per message off the
-                // shared cfg, so the NEXT message already uses it; we also refresh the
-                // cached kind so status reflects it immediately. A running bot is keyed
-                // by userId; map it to a handle via its runner.
+                // The owner changed this bot's config from the phone. A running bot is
+                // keyed by userId; map it to a handle via its runner.
                 const runner = this.bots.get(f.botUserId);
                 if (!runner) {
                     console.log(`${this.tag} bot_config_changed for ${f.botUserId} not running yet — applied on next sync/adopt`);
                     return;
                 }
-                this.app.applyServerBackend(runner.info.handle, f.backend);
-                runner.refreshBrainKind();
+                if (f.backend) {
+                    // Record the server backend and re-resolve live — the runner resolves
+                    // per message off the shared cfg, so the NEXT message already uses
+                    // it; also refresh the cached kind so status reflects it immediately.
+                    this.app.applyServerBackend(runner.info.handle, f.backend);
+                    runner.refreshBrainKind();
+                }
+                // Per-channel reply modes ride the same frame (additive) — merge them
+                // into the runner so the very next message obeys the new mode.
+                if (f.channelModes)
+                    runner.applyChannelModes(f.channelModes);
             },
         });
         // Bots first (so a control-socket hiccup doesn't delay serving), then the

package/dist/control.d.ts

@@ -8,10 +8,16 @@ export interface AdoptBotFrame {
     /** Server-mediated backend picked from the phone (optional). */
     backend?: BrainBackend;
 }
+/** Per-channel reply mode for a bot in a group. Absent channel = "everyone". */
+export type ChannelMode = "everyone" | "mention" | "off";
+export declare function isChannelMode(v: unknown): v is ChannelMode;
 export interface BotConfigChangedFrame {
     type: "bot_config_changed";
     botUserId: string;
-    backend: BrainBackend;
+    /** Brain backend change (may be absent when only channelModes changed). */
+    backend?: BrainBackend;
+    /** Additive per-channel reply-mode updates: {channelId: mode}. */
+    channelModes?: Record<string, ChannelMode>;
 }
 export interface BotGrantChangedFrame {
     type: "bot_grant_changed";

package/dist/control.js

@@ -1,4 +1,7 @@
 import { isBrainBackend } from "./config.js";
+export function isChannelMode(v) {
+    return v === "everyone" || v === "mention" || v === "off";
+}
 export class ControlSocket {
     connected = false;
     runtimeId = null;
@@ -86,11 +89,19 @@ export class ControlSocket {
             }
             case "bot_config_changed": {
                 const f = frame;
-                if (!isBrainBackend(f.backend)) {
-                    console.error(`${this.tag} bot_config_changed with invalid backend "${String(f.backend)}" ignored`);
-                    return;
+                // backend and channelModes are each optional and additive — drop
+                // whichever is invalid, forward the frame if anything useful remains.
+                if (f.backend !== undefined && !isBrainBackend(f.backend)) {
+                    console.error(`${this.tag} bot_config_changed with invalid backend "${String(f.backend)}" — backend ignored`);
+                    delete f.backend;
+                }
+                if (f.channelModes !== undefined && (typeof f.channelModes !== "object" || f.channelModes === null || Array.isArray(f.channelModes))) {
+                    console.error(`${this.tag} bot_config_changed with malformed channelModes ignored`);
+                    delete f.channelModes;
                 }
-                console.log(`${this.tag} bot_config_changed bot=${f.botUserId} backend=${f.backend}`);
+                if (f.backend === undefined && f.channelModes === undefined)
+                    return; // nothing valid left
+                console.log(`${this.tag} bot_config_changed bot=${f.botUserId}${f.backend ? ` backend=${f.backend}` : ""}${f.channelModes ? ` channelModes(${Object.keys(f.channelModes).length})` : ""}`);
                 this.handlers.onBotConfig(f);
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nopeek/agent-bridge",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "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",
@@ -23,7 +23,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@nopeek/chat": "0.2.4"
+    "@nopeek/chat": "0.2.5"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",