@songsid/agend 2.0.11-beta.3 → 2.0.11-beta.5

package/dist/fleet-manager.js

@@ -33,6 +33,7 @@ import { TopicArchiver } from "./topic-archiver.js";
 import { StatuslineWatcher } from "./statusline-watcher.js";
 import { outboundHandlers } from "./outbound-handlers.js";
 import { handleWebRequest, broadcastSseEvent } from "./web-api.js";
+import { handleViewRequest, isViewPath } from "./view-api.js";
 import { handleAgentRequest } from "./agent-endpoint.js";
 import { ClassicChannelManager, classicInstanceName } from "./classic-channel-manager.js";
 import { getTmuxSession } from "./config.js";
@@ -65,6 +66,9 @@ export class FleetManager {
     adapters = new Map(); // derived view for backward compat
     /** Track which world each instance is bound to */
     instanceWorldBinding = new Map();
+    // Dedup inbound messages seen by more than one adapter (e.g. two DC bots in the
+    // same guild both receive every message). Bounded FIFO of recent message keys.
+    recentMessageIds = new Set();
     accessManager = null;
     /** Primary world (first adapter) — used for fleet-level notifications */
     get primaryWorld() { return this.worlds.values().next().value; }
@@ -115,6 +119,7 @@ export class FleetManager {
     // Web UI: SSE clients + auth token
     sseClients = new Set();
     webToken = null;
+    viewToken = null;
     constructor(dataDir) {
         this.dataDir = dataDir;
         this.lifecycle = new InstanceLifecycle(this);
@@ -221,9 +226,16 @@ export class FleetManager {
         const world = this.getWorldForInstance(name);
         return world?.groupId ?? String(this.fleetConfig?.channel?.group_id ?? "");
     }
-    /** Bind an instance to a specific world. fromInbound=true skips general_topic to prevent overwrite. */
+    /**
+     * Bind an instance to a specific world (the bot that answers for it).
+     * fromInbound=true (binding inferred from which adapter received a message)
+     * must not override a configured identity: skip when the instance is a general
+     * or has an explicit channel_id — otherwise a persona instance whose message
+     * was also seen by the main bot would get rebound to the wrong bot.
+     */
     bindInstanceAdapter(name, adapterId, fromInbound = false) {
-        if (fromInbound && this.fleetConfig?.instances[name]?.general_topic)
+        const cfg = this.fleetConfig?.instances[name];
+        if (fromInbound && (cfg?.general_topic || cfg?.channel_id))
             return;
         this.instanceWorldBinding.set(name, adapterId);
     }
@@ -606,12 +618,19 @@ export class FleetManager {
             catch (err) {
                 this.logger.error({ err }, "startSharedAdapter failed — fleet continues without some adapters");
             }
-            // Pre-bind general instances to their corresponding adapter
+            // Bind instances to their adapter (which bot answers on their behalf).
+            // An explicit channel_id is authoritative — this is how a persona instance
+            // picks its bot when several share one guild. Generals without a channel_id
+            // fall back to a name-contains-adapterId heuristic.
+            const channelConfigsForBind = fleet.channels ?? (fleet.channel ? [fleet.channel] : []);
             for (const [name, config] of Object.entries(fleet.instances)) {
+                if (config.channel_id) {
+                    this.bindInstanceAdapter(name, config.channel_id);
+                    continue;
+                }
                 if (!config.general_topic)
                     continue;
-                const channelConfigs = fleet.channels ?? (fleet.channel ? [fleet.channel] : []);
-                for (const ch of channelConfigs) {
+                for (const ch of channelConfigsForBind) {
                     const id = ch.id ?? ch.type;
                     if (name.includes(id)) {
                         this.bindInstanceAdapter(name, id);
@@ -741,11 +760,16 @@ export class FleetManager {
         const channelConfigs = fleet.channels ?? (fleet.channel ? [fleet.channel] : []);
         if (channelConfigs.length === 0)
             return;
-        // Start primary adapter (first channel) — this.adapter for backward compat
+        // Start primary adapter (first channel) — this.adapter for backward compat.
+        // The primary owns the guild's slash commands.
         await this.startSingleAdapter(fleet, channelConfigs[0]);
-        // Start additional adapters
+        const primaryGroup = String(channelConfigs[0].group_id ?? "");
+        // Start additional adapters. A secondary bot in the SAME guild as the primary
+        // must not re-register the guild's slash commands (they'd appear twice); a bot
+        // in a different guild still registers its own.
         for (let i = 1; i < channelConfigs.length; i++) {
-            await this.startAdditionalAdapter(channelConfigs[i]);
+            const sameGuild = String(channelConfigs[i].group_id ?? "") === primaryGroup;
+            await this.startAdditionalAdapter(channelConfigs[i], !sameGuild);
         }
     }
     /** Start the primary adapter (backward-compatible, sets this.adapter) */
@@ -1015,7 +1039,7 @@ export class FleetManager {
         }, 5 * 60 * 1000);
     }
     /** Start an additional (non-primary) adapter */
-    async startAdditionalAdapter(channelConfig) {
+    async startAdditionalAdapter(channelConfig, registerCommands = true) {
         const adapterId = channelConfig.id ?? channelConfig.type;
         const botToken = process.env[channelConfig.bot_token_env];
         if (!botToken) {
@@ -1032,6 +1056,7 @@ export class FleetManager {
             botToken,
             accessManager,
             inboxDir,
+            registerCommands,
         });
         const world = new AdapterWorld(adapterId, adapter, accessManager, channelConfig);
         this.worlds.set(adapterId, world);
@@ -1451,6 +1476,25 @@ export class FleetManager {
     async handleInboundMessage(msg) {
         const threadId = msg.threadId || undefined;
         this.logger.debug({ source: msg.source, chatId: msg.chatId, threadId, userId: msg.userId, isBotMessage: msg.isBotMessage, textLen: (msg.text ?? "").length, text: (msg.text ?? "").slice(0, 80) }, "handleInboundMessage entry");
+        // Multi-adapter dedup: when several bots share a guild, each adapter fires
+        // its own "message" event for the same underlying message. Process it once.
+        // Routing (by topic/channel) and reply-adapter selection (by channel_id
+        // binding) are adapter-independent, so it's safe to let whichever adapter
+        // arrives first handle it.
+        if (msg.messageId) {
+            const dedupKey = `${msg.source}:${msg.chatId}:${msg.messageId}`;
+            if (this.recentMessageIds.has(dedupKey)) {
+                this.logger.debug({ dedupKey, adapterId: msg.adapterId }, "Duplicate inbound across adapters — skipping");
+                return;
+            }
+            this.recentMessageIds.add(dedupKey);
+            if (this.recentMessageIds.size > 1000) {
+                // Set preserves insertion order — drop the oldest key.
+                const oldest = this.recentMessageIds.values().next().value;
+                if (oldest !== undefined)
+                    this.recentMessageIds.delete(oldest);
+            }
+        }
         // Bot messages: only allow in collab channels or TG classic with @mention
         if (msg.isBotMessage) {
             if (!threadId) {
@@ -3955,6 +3999,15 @@ When users create specialized instances, suggest these configurations:
         catch {
             // best-effort
         }
+        // Separate read-only token for the /view page: grants terminal-view + profile
+        // read, but never write (POSTs still require the full web token).
+        this.viewToken = randomBytes(24).toString("hex");
+        const viewTokenPath = join(this.dataDir, "view.token");
+        writeFileSync(viewTokenPath, this.viewToken, { mode: 0o600 });
+        try {
+            chmodSync(viewTokenPath, 0o600);
+        }
+        catch { /* best-effort */ }
         this.healthServer = createServer((req, res) => {
             res.setHeader("Content-Type", "application/json");
             // Public health probe — no auth required.
@@ -3964,6 +4017,10 @@ When users create specialized instances, suggest these configurations:
             else if (req.method === "POST" && req.url === "/agent") {
                 // /agent handles its own instance-level auth via X-Agend-Instance-Token
             }
+            else if (isViewPath(new URL(req.url ?? "/", `http://localhost:${port}`).pathname)) {
+                // /view routes accept the read-only view.token (or web.token) and do
+                // their own per-method auth in view-api.ts — skip the web-token gate.
+            }
             else {
                 // All other endpoints require a valid token (query ?token= or X-Agend-Token header).
                 // /ui/* will also re-check in web-api.ts, which is harmless.
@@ -4147,6 +4204,8 @@ When users create specialized instances, suggest these configurations:
             }
             // ── Web UI endpoints (delegated to web-api.ts) ─────
             const url = new URL(req.url ?? "/", `http://localhost:${port}`);
+            if (handleViewRequest(req, res, url, this))
+                return;
             if (handleWebRequest(req, res, url, this))
                 return;
             res.writeHead(404);
@@ -4188,6 +4247,7 @@ When users create specialized instances, suggest these configurations:
             this.logger.info({ port }, "Health endpoint listening");
         });
         this.logger.info({ url: `http://localhost:${port}/ui?token=${this.webToken}` }, "Web UI available");
+        this.logger.info({ url: `http://localhost:${port}/view?token=${this.viewToken}` }, "Web View available");
     }
     getUiStatus() {
         const instances = Object.keys(this.fleetConfig?.instances ?? {}).map(name => {