@nopeek/agent-bridge 0.6.1 → 0.6.3

package/dist/bot.d.ts

@@ -25,6 +25,9 @@ export declare class BotRunner {
     private allowed;
     private accessLoaded;
     private declined;
+    private ownerPresence;
+    private mutedNoOwner;
+    private runtimeOwnerId;
     private chains;
     private cantPost;
     private log;
@@ -44,6 +47,14 @@ export declare class BotRunner {
     refreshAccess(): Promise<void>;
     /** Sender permitted to talk to this bot? Fail closed if access never loaded. */
     private isAllowed;
+    /** 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
+     *  keep the last-known answer; with no known answer we FAIL CLOSED. */
+    private ownerIsChannelMember;
     private run;
     private connectOnce;
     /** Runtime sessions expire; reconnect with a fresh one shortly before that. */

package/dist/bot.js

@@ -7,6 +7,9 @@ import { FALLBACK_REPLY, resolveBrain } from "./brain.js";
 import { FileStore } from "./storage.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
+// member.joined/left frame for the channel invalidates it immediately anyway.
+const OWNER_PRESENCE_TTL_MS = 60_000;
 // Refresh the bot session 5 min before it expires (clamped to a sane window).
 const REFRESH_MARGIN_MS = 5 * 60_000;
 const MAX_REFRESH_DELAY_MS = 6 * 24 * 60 * 60_000;
@@ -29,6 +32,17 @@ export class BotRunner {
     allowed = new Set();
     accessLoaded = false;
     declined = new Set(); // (senderId) already told "not authorized" once
+    // OWNER-PRESENT POLICY (multi-party channels): other users may interact with
+    // the bot in a group ONLY while the bot's owner is ALSO a member of that
+    // channel. Owner absent → the bot is silent there for everyone (no brain
+    // run, no decline), regardless of grants. Membership is checked against the
+    // 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;
     // 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.
@@ -97,6 +111,15 @@ export class BotRunner {
                 throw new Error(`access HTTP ${res.status}`);
             const j = (await res.json());
             this.allowed = new Set(j.allowedUserIds ?? []);
+            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.
+            if (j.ownerId) {
+                this.info.ownerId = j.ownerId;
+                this.info.ownerType = j.ownerType ?? this.info.ownerType;
+            }
             this.accessLoaded = true;
             this.log(`access: policy=${j.policy ?? "private"}, ${this.allowed.size} allowed sender(s)`);
         }
@@ -112,6 +135,41 @@ export class BotRunner {
             return false; // fail closed until we know the list
         return this.allowed.has(senderUserId);
     }
+    /** 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.effectiveOwnerId();
+        if (!ownerId)
+            return false; // unknown owner → fail closed
+        const cached = this.ownerPresence.get(channelId);
+        if (cached && Date.now() - cached.at < OWNER_PRESENCE_TTL_MS)
+            return cached.present;
+        try {
+            let present = false;
+            let cursor = "";
+            do {
+                const qs = `?limit=500${cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""}`;
+                const page = await this.np.api("GET", `/v1/apps/${this.pairing.appId}/channels/${channelId}/members${qs}`);
+                present = (page.members ?? []).some((m) => m.userId === ownerId);
+                cursor = present ? "" : (page.nextCursor ?? "");
+            } while (!present && cursor);
+            this.ownerPresence.set(channelId, { present, at: Date.now() });
+            return present;
+        }
+        catch (err) {
+            this.logErr(`owner-membership check failed for ${channelId}: ${err.message}`);
+            return cached ? cached.present : false; // stale-but-known beats guessing; else closed
+        }
+    }
     async run() {
         this.log(`starting (${this.info.userId}) brain=${this.brainKind}`);
         let delay = 2_000;
@@ -149,6 +207,7 @@ export class BotRunner {
         this.np = np;
         this.connected = true;
         this.channelCache.clear();
+        this.ownerPresence.clear();
         this.log(`connected, device ${np.deviceId} (platform=server), store ${store.file}`);
         np.on("connected", (() => {
             this.connected = true;
@@ -161,6 +220,20 @@ export class BotRunner {
         np.on("channelKeyReceived", ((p) => {
             this.log(`received channel key for ${p.channelId} (welcome ceremony completed)`);
         }));
+        // Roster changed → the cached owner-membership answer for that channel is
+        // stale. Invalidate so the very next message re-checks (owner joining
+        // un-mutes immediately; owner leaving mutes immediately).
+        const onRosterChange = ((p) => {
+            if (!p?.channelId)
+                return;
+            this.ownerPresence.delete(p.channelId);
+            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`);
+            }
+        });
+        np.on("member.joined", onRosterChange);
+        np.on("member.left", onRosterChange);
         np.on("message", ((m) => {
             const prev = this.chains.get(m.channelId) ?? Promise.resolve();
             const next = prev.then(() => this.handleMessage(m).catch((err) => {
@@ -248,6 +321,25 @@ export class BotRunner {
         }
         if (m.body?.type !== "text" || typeof m.body.text !== "string" || !m.body.text.trim())
             return;
+        // 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. 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 ${effOwner ?? "?"} is not a member (owner-present policy); staying silent`);
+                    }
+                    return;
+                }
+                this.mutedNoOwner.delete(m.channelId);
+            }
+        }
         // ACCESS CONTROL: a bot is private. If the sender isn't authorized (owner,
         // workspace member, or explicitly granted), the brain is NEVER invoked — so
         // a stranger who found the @handle can't make the owner's agent do anything.

package/dist/bridge.d.ts

@@ -1,5 +1,5 @@
 import type { BridgeConfig, Pairing, BrainSpec, BrainBackend } from "./config.js";
-export declare const VERSION = "0.6.0";
+export declare const VERSION = "0.6.3";
 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.0";
+export const VERSION = "0.6.3";
 /** 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.6.1",
+  "version": "0.6.3",
   "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.3"
+    "@nopeek/chat": "0.2.4"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",