agentfeed 0.1.12 → 0.1.14

package/dist/api-client.d.ts

@@ -30,4 +30,8 @@ export declare class AgentFeedClient {
     }, agentId?: string): Promise<void>;
     getAgentConfig(agentId: string): Promise<AgentConfig>;
     reportSession(sessionName: string, claudeSessionId: string, agentId?: string): Promise<void>;
+    getSettings(): Promise<{
+        bot_mention_limit: number;
+        bot_mention_window_minutes: number;
+    }>;
 }

package/dist/api-client.js

@@ -112,4 +112,7 @@ export class AgentFeedClient {
             agentId,
         });
     }
+    async getSettings() {
+        return this.request("/api/settings");
+    }
 }

package/dist/index.js

@@ -10,7 +10,7 @@ import { QueueStore } from "./queue-store.js";
 import { PostSessionStore } from "./post-session-store.js";
 import { AgentRegistryStore } from "./agent-registry-store.js";
 import { createBackend } from "./backends/index.js";
-import { handleTriggers } from "./processor.js";
+import { handleTriggers, loadSettings } from "./processor.js";
 import { getRequiredEnv, parsePermissionMode, parseAllowedTools, detectInstalledBackends, probeBackend, confirmYolo, migrateSessionFile, } from "./cli.js";
 const serverUrl = getRequiredEnv("AGENTFEED_URL");
 const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
@@ -131,16 +131,12 @@ async function main() {
         agentRegistry.set(agentName, agent.id);
     }
     backendAgents = Array.from(backendAgentMap.values());
-    // Confirm yolo if any server config overrides to yolo (and CLI didn't already confirm)
+    // Server config yolo is pre-authorized by admin — no confirmation needed
+    // Only confirm if CLI explicitly requests yolo via --permission flag
     if (permissionMode !== "yolo") {
         const hasServerYolo = backendAgents.some((ba) => ba.config?.permission_mode === "yolo");
         if (hasServerYolo) {
-            console.log("\nServer config has yolo permission for one or more agents.");
-            const confirmed = await confirmYolo();
-            if (!confirmed) {
-                console.log("Cancelled. Update agent permissions on the server to use safe mode.");
-                process.exit(0);
-            }
+            console.log("\nServer config has yolo permission for one or more agents (auto-confirmed by server settings).");
         }
     }
     // Register Named Session agents for all backends
@@ -159,6 +155,12 @@ async function main() {
         }
     }
     const deps = getProcessorDeps();
+    // Load bot mention limit settings from server
+    await loadSettings(client);
+    // Refresh settings every 5 minutes
+    setInterval(async () => {
+        await loadSettings(client);
+    }, 5 * 60 * 1000);
     // Step 1: Startup scan for unprocessed items
     console.log("Scanning for unprocessed items...");
     const ownAgentIds = agentRegistry.getAllIds();

package/dist/invoker.js

@@ -84,6 +84,7 @@ export function invokeAgent(backend, options) {
                     const sid = backend.parseSessionId(line);
                     if (sid) {
                         sessionId = sid;
+                        console.log(`Session ID parsed: ${sid}`);
                     }
                     // Try to extract displayable text
                     const text = backend.parseStreamText(line);

package/dist/post-session-store.d.ts

@@ -11,10 +11,14 @@ export declare class PostSessionStore extends PersistentStore {
     protected deserialize(raw: string): void;
     /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId: string): string | undefined;
-    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    /** Get both backendType and sessionName for first entry (legacy compat) */
     getWithType(postId: string): PostSessionInfo | undefined;
+    /** Get all backend sessions for a post */
+    getAll(postId: string): PostSessionInfo[];
     private static readonly MAX_SIZE;
-    /** Store as "backendType:sessionName" */
+    /** Add backend session (legacy compat: set = add) */
     set(postId: string, backendType: BackendType, sessionName: string): void;
+    /** Add backend session to post (prevents duplicates) */
+    add(postId: string, backendType: BackendType, sessionName: string): void;
     removeBySessionName(sessionName: string): void;
 }

package/dist/post-session-store.js

@@ -11,37 +11,56 @@ export class PostSessionStore extends PersistentStore {
     deserialize(raw) {
         const data = JSON.parse(raw);
         for (const [k, v] of Object.entries(data)) {
-            this.map.set(k, v);
+            // Support both legacy single value and new array format
+            this.map.set(k, Array.isArray(v) ? v : [v]);
         }
     }
     /** Get raw sessionName (legacy compat — for callers that don't need backendType) */
     get(postId) {
-        const raw = this.map.get(postId);
-        if (!raw)
+        const raws = this.map.get(postId);
+        if (!raws || raws.length === 0)
             return undefined;
-        // Parse "backendType:sessionName" or plain "sessionName"
-        const colonIdx = raw.indexOf(":");
-        return colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
+        // Return first sessionName
+        const first = raws[0];
+        const colonIdx = first.indexOf(":");
+        return colonIdx >= 0 ? first.slice(colonIdx + 1) : first;
     }
-    /** Get both backendType and sessionName. Legacy values without colon default to claude. */
+    /** Get both backendType and sessionName for first entry (legacy compat) */
     getWithType(postId) {
-        const raw = this.map.get(postId);
-        if (!raw)
-            return undefined;
-        const colonIdx = raw.indexOf(":");
-        if (colonIdx >= 0) {
-            return {
-                backendType: raw.slice(0, colonIdx),
-                sessionName: raw.slice(colonIdx + 1),
-            };
-        }
-        // Legacy: no colon → assume claude
-        return { backendType: "claude", sessionName: raw };
+        const all = this.getAll(postId);
+        return all.length > 0 ? all[0] : undefined;
+    }
+    /** Get all backend sessions for a post */
+    getAll(postId) {
+        const raws = this.map.get(postId);
+        if (!raws)
+            return [];
+        return raws.map((raw) => {
+            const colonIdx = raw.indexOf(":");
+            if (colonIdx >= 0) {
+                return {
+                    backendType: raw.slice(0, colonIdx),
+                    sessionName: raw.slice(colonIdx + 1),
+                };
+            }
+            // Legacy: no colon → assume claude
+            return { backendType: "claude", sessionName: raw };
+        });
     }
     static MAX_SIZE = 1000;
-    /** Store as "backendType:sessionName" */
+    /** Add backend session (legacy compat: set = add) */
     set(postId, backendType, sessionName) {
-        this.map.set(postId, `${backendType}:${sessionName}`);
+        this.add(postId, backendType, sessionName);
+    }
+    /** Add backend session to post (prevents duplicates) */
+    add(postId, backendType, sessionName) {
+        const entry = `${backendType}:${sessionName}`;
+        const existing = this.map.get(postId) ?? [];
+        // Prevent duplicates
+        if (!existing.includes(entry)) {
+            existing.push(entry);
+            this.map.set(postId, existing);
+        }
         // Evict oldest entries if over limit
         if (this.map.size > PostSessionStore.MAX_SIZE) {
             const iter = this.map.keys();
@@ -57,12 +76,19 @@ export class PostSessionStore extends PersistentStore {
     }
     removeBySessionName(sessionName) {
         let changed = false;
-        for (const [postId, raw] of this.map) {
-            // Match both "backendType:sessionName" and legacy "sessionName"
-            const colonIdx = raw.indexOf(":");
-            const name = colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
-            if (name === sessionName) {
-                this.map.delete(postId);
+        for (const [postId, raws] of this.map) {
+            const filtered = raws.filter((raw) => {
+                const colonIdx = raw.indexOf(":");
+                const name = colonIdx >= 0 ? raw.slice(colonIdx + 1) : raw;
+                return name !== sessionName;
+            });
+            if (filtered.length !== raws.length) {
+                if (filtered.length === 0) {
+                    this.map.delete(postId);
+                }
+                else {
+                    this.map.set(postId, filtered);
+                }
                 changed = true;
             }
         }

package/dist/processor.d.ts

@@ -18,4 +18,5 @@ export interface ProcessorDeps {
     agentRegistry: AgentRegistryStore;
     ensureSessionAgent: (sessionName: string, agentName: string, backendType: BackendType) => Promise<string>;
 }
+export declare function loadSettings(client: AgentFeedClient): Promise<void>;
 export declare function handleTriggers(triggers: TriggerContext[], deps: ProcessorDeps): void;

package/dist/processor.js

@@ -4,27 +4,58 @@ const MAX_WAKE_ATTEMPTS = 3;
 const MAX_CRASH_RETRIES = 3;
 const AGENT_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 const MAX_CONCURRENT = 5;
-const MAX_BOT_MENTIONS_PER_POST = 4;
+// Time-window based bot mention limits (loaded from server)
+let botMentionLimit = 4;
+let botMentionWindowMs = 5 * 60 * 1000; // 5 minutes
 const wakeAttempts = new Map();
-const botMentionCounts = new Map();
+const botMentionTimestamps = new Map();
 const runningKeys = new Set();
 let retryTimer = null;
 const RETRY_DELAY_MS = 3000;
 // Periodic cleanup to prevent memory growth
-setInterval(() => { wakeAttempts.clear(); botMentionCounts.clear(); }, 10 * 60 * 1000);
+setInterval(() => {
+    wakeAttempts.clear();
+    // Clean up old timestamps beyond the window
+    const now = Date.now();
+    for (const [postId, timestamps] of botMentionTimestamps.entries()) {
+        const recent = timestamps.filter((ts) => now - ts < botMentionWindowMs);
+        if (recent.length === 0) {
+            botMentionTimestamps.delete(postId);
+        }
+        else {
+            botMentionTimestamps.set(postId, recent);
+        }
+    }
+}, 10 * 60 * 1000);
 function triggerKey(t) {
     return `${t.backendType}:${t.sessionName}`;
 }
+export async function loadSettings(client) {
+    try {
+        const settings = await client.getSettings();
+        botMentionLimit = settings.bot_mention_limit;
+        botMentionWindowMs = settings.bot_mention_window_minutes * 60 * 1000;
+        console.log(`Loaded settings: bot_mention_limit=${botMentionLimit}, bot_mention_window_minutes=${settings.bot_mention_window_minutes}`);
+    }
+    catch (err) {
+        console.error("Failed to load settings from server, using defaults:", err);
+    }
+}
 export function handleTriggers(triggers, deps) {
+    const now = Date.now();
     for (const t of triggers) {
-        // Prevent bot-to-bot mention loops
+        // Prevent bot-to-bot mention loops (time-window based)
         if (t.authorIsBot && t.triggerType === "mention") {
-            const count = botMentionCounts.get(t.postId) ?? 0;
-            if (count >= MAX_BOT_MENTIONS_PER_POST) {
-                console.log(`Skipping bot mention on ${t.postId}: loop limit (${MAX_BOT_MENTIONS_PER_POST}) reached`);
+            const timestamps = botMentionTimestamps.get(t.postId) ?? [];
+            // Filter timestamps within the current window
+            const recentTimestamps = timestamps.filter((ts) => now - ts < botMentionWindowMs);
+            if (recentTimestamps.length >= botMentionLimit) {
+                console.log(`Skipping bot mention on ${t.postId}: loop limit (${botMentionLimit} mentions in ${botMentionWindowMs / 1000 / 60} minutes) reached`);
                 continue;
             }
-            botMentionCounts.set(t.postId, count + 1);
+            // Record this mention
+            recentTimestamps.push(now);
+            botMentionTimestamps.set(t.postId, recentTimestamps);
         }
         deps.queueStore.push(t);
         console.log(`Queued trigger: ${t.triggerType} on ${t.postId} [${t.backendType}] (queue size: ${deps.queueStore.size})`);
@@ -122,10 +153,14 @@ async function processItem(trigger, deps) {
                     if (result.sessionId) {
                         ba.sessionStore.set(trigger.sessionName, result.sessionId);
                         deps.postSessionStore.set(trigger.postId, trigger.backendType, trigger.sessionName);
+                        console.log(`Saved post-session mapping: ${trigger.postId} → [${trigger.backendType}] ${trigger.sessionName}`);
                         await deps.client.reportSession(trigger.sessionName, result.sessionId, sessionAgentId).catch((err) => {
                             console.warn("Failed to report session:", err);
                         });
                     }
+                    else {
+                        console.warn(`No session ID returned by ${trigger.backendType}, post-session mapping not saved`);
+                    }
                     if (result.exitCode === 0) {
                         success = true;
                         break;

package/dist/trigger.js

@@ -45,19 +45,36 @@ export function detectTriggers(event, backendAgents, followStore, postSessionSto
             return mentions;
         // Trigger 3: Comment in a followed thread (human-authored only — prevents bot loop)
         if (!authorIsOwnBot && followStore?.has(event.post_id)) {
-            const postSession = postSessionStore?.getWithType(event.post_id);
-            return [{
-                    triggerType: "thread_follow_up",
-                    eventId: event.id,
-                    feedId: event.feed_id,
-                    feedName: "",
-                    postId: event.post_id,
-                    content: event.content,
-                    authorName: event.author_name,
-                    authorIsBot: event.author_type === "bot",
-                    sessionName: postSession?.sessionName ?? "default",
-                    backendType: postSession?.backendType ?? defaultBackendType,
-                }];
+            const postSessions = postSessionStore?.getAll(event.post_id) ?? [];
+            if (postSessions.length === 0) {
+                console.log(`Thread follow-up on ${event.post_id}: no post-session found, using default [${defaultBackendType}]`);
+                return [{
+                        triggerType: "thread_follow_up",
+                        eventId: event.id,
+                        feedId: event.feed_id,
+                        feedName: "",
+                        postId: event.post_id,
+                        content: event.content,
+                        authorName: event.author_name,
+                        authorIsBot: event.author_type === "bot",
+                        sessionName: "default",
+                        backendType: defaultBackendType,
+                    }];
+            }
+            // Trigger ALL backends that participated in this thread
+            console.log(`Thread follow-up on ${event.post_id}: triggering ${postSessions.length} backend(s) [${postSessions.map(s => s.backendType).join(", ")}]`);
+            return postSessions.map((ps) => ({
+                triggerType: "thread_follow_up",
+                eventId: `${event.id}:${ps.backendType}`,
+                feedId: event.feed_id,
+                feedName: "",
+                postId: event.post_id,
+                content: event.content,
+                authorName: event.author_name,
+                authorIsBot: event.author_type === "bot",
+                sessionName: ps.sessionName,
+                backendType: ps.backendType,
+            }));
         }
     }
     if (event.type === "post_created") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {