agentfeed 0.1.6 → 0.1.8

package/dist/scanner.js

@@ -1,50 +1,104 @@
-export async function scanUnprocessed(client, agent) {
+import { parseMention, isBotAuthor } from "./utils.js";
+export async function scanUnprocessed(client, agent, followStore, postSessionStore) {
     const triggers = [];
     const feeds = await client.getFeeds();
+    const processedPostIds = new Set();
     for (const feed of feeds) {
+        // --- Scan comments (existing logic) ---
         const comments = await client.getFeedComments(feed.id, {
             author_type: "human",
             limit: 50,
         });
+        // Group comments by post to find the last human comment per post
+        const byPost = new Map();
         for (const comment of comments.data) {
-            let shouldTrigger = false;
-            let triggerType = "own_post_comment";
-            // Check if this is on an agent-owned post
-            if (comment.post_created_by === agent.id) {
-                shouldTrigger = true;
-                triggerType = "own_post_comment";
+            const list = byPost.get(comment.post_id) ?? [];
+            list.push(comment);
+            byPost.set(comment.post_id, list);
+        }
+        for (const [postId, postComments] of byPost) {
+            // Determine the best trigger type for this post
+            let bestTriggerType = null;
+            let bestComment = null;
+            let bestSessionName = "default";
+            for (const comment of postComments) {
+                // Check for @mentions (highest priority)
+                const mention = parseMention(comment.content, agent.name);
+                if (mention.mentioned) {
+                    bestTriggerType = "mention";
+                    bestComment = comment;
+                    bestSessionName = mention.sessionName;
+                }
+                // Check if this is on an agent-owned post
+                if (!bestTriggerType && comment.post_created_by === agent.id) {
+                    bestTriggerType = "own_post_comment";
+                    bestComment = comment;
+                    bestSessionName = postSessionStore?.get(postId) ?? "default";
+                }
             }
-            // Check for @mentions
-            if (containsMention(comment.content, agent.name)) {
-                shouldTrigger = true;
-                triggerType = "mention";
+            // Check if this is in a followed thread
+            if (!bestTriggerType && followStore?.has(postId)) {
+                bestTriggerType = "thread_follow_up";
+                // Use the last human comment as the trigger
+                bestComment = postComments[postComments.length - 1] ?? null;
+                bestSessionName = postSessionStore?.get(postId) ?? "default";
             }
-            if (!shouldTrigger)
+            if (!bestTriggerType || !bestComment)
                 continue;
-            // Check if there's already a bot reply after this comment
-            const replies = await client.getPostComments(comment.post_id, {
-                since: comment.created_at,
+            // Check if there's a bot reply after the LAST human comment in this post
+            const lastHumanComment = postComments[postComments.length - 1];
+            const replies = await client.getPostComments(postId, {
+                since: lastHumanComment.created_at,
                 author_type: "bot",
                 limit: 1,
             });
             if (replies.data.length === 0) {
                 triggers.push({
-                    triggerType,
-                    eventId: comment.id,
+                    triggerType: bestTriggerType,
+                    eventId: bestComment.id,
                     feedId: feed.id,
                     feedName: feed.name,
-                    postId: comment.post_id,
-                    postTitle: comment.post_title,
-                    content: comment.content,
-                    authorName: comment.author_name,
+                    postId,
+                    content: bestComment.content,
+                    authorName: bestComment.author_name,
+                    sessionName: bestSessionName,
+                });
+                processedPostIds.add(postId);
+            }
+        }
+        // --- Scan post bodies for @mentions ---
+        const posts = await client.getFeedPosts(feed.id, { limit: 50 });
+        for (const post of posts.data) {
+            // Skip posts already handled by comment scan
+            if (processedPostIds.has(post.id))
+                continue;
+            // Skip bot-authored posts
+            if (isBotAuthor(post.created_by))
+                continue;
+            // Skip posts without content
+            if (!post.content)
+                continue;
+            const mention = parseMention(post.content, agent.name);
+            if (!mention.mentioned)
+                continue;
+            // Check if there's any bot reply on this post
+            const botReplies = await client.getPostComments(post.id, {
+                author_type: "bot",
+                limit: 1,
+            });
+            if (botReplies.data.length === 0) {
+                triggers.push({
+                    triggerType: "mention",
+                    eventId: post.id,
+                    feedId: feed.id,
+                    feedName: feed.name,
+                    postId: post.id,
+                    content: post.content,
+                    authorName: post.author_name,
+                    sessionName: mention.sessionName,
                 });
             }
         }
     }
     return triggers;
 }
-function containsMention(text, agentName) {
-    const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`@${escaped}\\b`, "i");
-    return regex.test(text);
-}

package/dist/session-store.d.ts

@@ -1,10 +1,10 @@
-export declare class SessionStore {
+import { PersistentStore } from "./persistent-store.js";
+export declare class SessionStore extends PersistentStore {
     private map;
-    private filePath;
     constructor(filePath?: string);
+    protected serialize(): string;
+    protected deserialize(raw: string): void;
     get(postId: string): string | undefined;
     set(postId: string, sessionId: string): void;
     delete(postId: string): void;
-    private load;
-    private save;
 }

package/dist/session-store.js

@@ -1,14 +1,19 @@
-import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-const DEFAULT_DIR = join(homedir(), ".agentfeed");
-export class SessionStore {
+import { PersistentStore } from "./persistent-store.js";
+export class SessionStore extends PersistentStore {
     map = new Map();
-    filePath;
     constructor(filePath) {
-        this.filePath = filePath ?? join(DEFAULT_DIR, "sessions.json");
+        super("sessions.json", filePath);
         this.load();
     }
+    serialize() {
+        return JSON.stringify(Object.fromEntries(this.map), null, 2);
+    }
+    deserialize(raw) {
+        const data = JSON.parse(raw);
+        for (const [k, v] of Object.entries(data)) {
+            this.map.set(k, v);
+        }
+    }
     get(postId) {
         return this.map.get(postId);
     }
@@ -20,26 +25,4 @@ export class SessionStore {
         this.map.delete(postId);
         this.save();
     }
-    load() {
-        try {
-            const raw = readFileSync(this.filePath, "utf-8");
-            const data = JSON.parse(raw);
-            for (const [k, v] of Object.entries(data)) {
-                this.map.set(k, v);
-            }
-        }
-        catch {
-            // File doesn't exist or invalid JSON — start fresh
-        }
-    }
-    save() {
-        try {
-            mkdirSync(dirname(this.filePath), { recursive: true });
-            const data = Object.fromEntries(this.map);
-            writeFileSync(this.filePath, JSON.stringify(data, null, 2), "utf-8");
-        }
-        catch (err) {
-            console.error("Failed to save sessions:", err);
-        }
-    }
 }

package/dist/sse-client.d.ts

@@ -6,4 +6,4 @@ export interface SSEEvent {
 export interface SSEConnection {
     close: () => void;
 }
-export declare function connectSSE(url: string, apiKey: string, onEvent: (event: SSEEvent) => void, onError: (error: Error) => void): SSEConnection;
+export declare function connectSSE(url: string, apiKey: string, agentId: string | undefined, onEvent: (event: SSEEvent) => void, onError: (error: Error) => void): SSEConnection;

package/dist/sse-client.js

@@ -1,31 +1,94 @@
 import { EventSource } from "eventsource";
-const EVENT_TYPES = ["heartbeat", "post_created", "comment_created"];
-export function connectSSE(url, apiKey, onEvent, onError) {
-    const es = new EventSource(url, {
-        fetch: (input, init) => fetch(input, {
-            ...init,
-            headers: { ...init.headers, Authorization: `Bearer ${apiKey}` },
-        }),
-    });
-    es.onopen = () => {
-        console.log("SSE connected.");
-    };
-    es.onerror = (err) => {
-        if (es.readyState === EventSource.CLOSED) {
-            onError(new Error(err.message ?? "SSE connection closed"));
-        }
-        // CONNECTING state = auto-reconnecting, no action needed
-    };
-    for (const eventType of EVENT_TYPES) {
-        es.addEventListener(eventType, (e) => {
-            onEvent({
-                type: eventType,
-                data: e.data,
-                id: e.lastEventId || undefined,
-            });
+const EVENT_TYPES = ["heartbeat", "post_created", "comment_created", "session_deleted"];
+const BACKOFF_INITIAL_MS = 1_000;
+const BACKOFF_MAX_MS = 60_000;
+const BACKOFF_RESET_AFTER_MS = 30_000;
+export function connectSSE(url, apiKey, agentId, onEvent, onError) {
+    let closed = false;
+    let currentEs = null;
+    let backoffMs = BACKOFF_INITIAL_MS;
+    let reconnectTimer = null;
+    let lastConnectedAt = 0;
+    let processedEventIds = new Set();
+    let eventIdCleanupTimer = null;
+    function connect() {
+        if (closed)
+            return;
+        const es = new EventSource(url, {
+            fetch: (input, init) => fetch(input, {
+                ...init,
+                headers: {
+                    ...init.headers,
+                    Authorization: `Bearer ${apiKey}`,
+                    ...(agentId ? { "X-Agent-Id": agentId } : {}),
+                },
+            }),
         });
+        currentEs = es;
+        es.onopen = () => {
+            const now = Date.now();
+            const isFirstConnect = lastConnectedAt === 0;
+            // Only reset backoff if previous connection was stable (lasted > 30s)
+            if (!isFirstConnect && now - lastConnectedAt > BACKOFF_RESET_AFTER_MS) {
+                backoffMs = BACKOFF_INITIAL_MS;
+            }
+            if (isFirstConnect) {
+                console.log("SSE connected.");
+            }
+            else {
+                console.log("SSE reconnected.");
+            }
+            lastConnectedAt = now;
+        };
+        es.onerror = (err) => {
+            // EventSource auto-reconnects on its own, but we want manual control
+            // Close the current one and reconnect with backoff
+            es.close();
+            currentEs = null;
+            if (closed)
+                return;
+            if (es.readyState === EventSource.CLOSED) {
+                onError(new Error(err.message ?? "SSE connection closed"));
+            }
+            console.log(`SSE disconnected. Reconnecting in ${backoffMs / 1000}s...`);
+            reconnectTimer = setTimeout(() => {
+                reconnectTimer = null;
+                connect();
+            }, backoffMs);
+            // Exponential backoff: 1s -> 2s -> 4s -> 8s -> ... -> 60s
+            backoffMs = Math.min(backoffMs * 2, BACKOFF_MAX_MS);
+        };
+        for (const eventType of EVENT_TYPES) {
+            es.addEventListener(eventType, (e) => {
+                // Deduplicate events by ID
+                const eventId = e.lastEventId || undefined;
+                if (eventId) {
+                    if (processedEventIds.has(eventId))
+                        return;
+                    processedEventIds.add(eventId);
+                }
+                onEvent({
+                    type: eventType,
+                    data: e.data,
+                    id: eventId,
+                });
+            });
+        }
     }
+    // Periodically clean old event IDs to prevent memory growth
+    eventIdCleanupTimer = setInterval(() => {
+        processedEventIds = new Set();
+    }, 5 * 60 * 1000);
+    connect();
     return {
-        close: () => es.close(),
+        close: () => {
+            closed = true;
+            if (reconnectTimer)
+                clearTimeout(reconnectTimer);
+            if (eventIdCleanupTimer)
+                clearInterval(eventIdCleanupTimer);
+            currentEs?.close();
+            currentEs = null;
+        },
     };
 }

package/dist/trigger.d.ts

@@ -1,2 +1,4 @@
+import type { FollowStore } from "./follow-store.js";
+import type { PostSessionStore } from "./post-session-store.js";
 import type { GlobalEvent, TriggerContext, AgentInfo } from "./types.js";
-export declare function detectTrigger(event: GlobalEvent, agent: AgentInfo): TriggerContext | null;
+export declare function detectTrigger(event: GlobalEvent, agent: AgentInfo, followStore?: FollowStore, postSessionStore?: PostSessionStore): TriggerContext | null;

package/dist/trigger.js

@@ -1,4 +1,5 @@
-export function detectTrigger(event, agent) {
+import { parseMention } from "./utils.js";
+export function detectTrigger(event, agent, followStore, postSessionStore) {
     if (event.type === "comment_created") {
         // Trigger 1: Comment on own post
         if (event.post_created_by === agent.id) {
@@ -8,45 +9,56 @@ export function detectTrigger(event, agent) {
                 feedId: event.feed_id,
                 feedName: "",
                 postId: event.post_id,
-                postTitle: event.post_title,
                 content: event.content,
                 authorName: event.author_name,
+                sessionName: postSessionStore?.get(event.post_id) ?? "default",
             };
         }
         // Trigger 2: @mention in comment
-        if (containsMention(event.content, agent.name)) {
+        const mention = parseMention(event.content, agent.name);
+        if (mention.mentioned) {
             return {
                 triggerType: "mention",
                 eventId: event.id,
                 feedId: event.feed_id,
                 feedName: "",
                 postId: event.post_id,
-                postTitle: event.post_title,
                 content: event.content,
                 authorName: event.author_name,
+                sessionName: mention.sessionName,
             };
         }
-    }
-    if (event.type === "post_created") {
-        // Trigger 2: @mention in post title or content
-        const text = [event.title, event.content].filter(Boolean).join(" ");
-        if (containsMention(text, agent.name)) {
+        // Trigger 3: Comment in a followed thread
+        if (followStore?.has(event.post_id)) {
             return {
-                triggerType: "mention",
+                triggerType: "thread_follow_up",
                 eventId: event.id,
                 feedId: event.feed_id,
-                feedName: event.feed_name,
-                postId: event.id,
-                postTitle: event.title,
-                content: event.content ?? "",
+                feedName: "",
+                postId: event.post_id,
+                content: event.content,
                 authorName: event.author_name,
+                sessionName: postSessionStore?.get(event.post_id) ?? "default",
             };
         }
     }
+    if (event.type === "post_created") {
+        // @mention in post content
+        if (event.content) {
+            const mention = parseMention(event.content, agent.name);
+            if (mention.mentioned) {
+                return {
+                    triggerType: "mention",
+                    eventId: event.id,
+                    feedId: event.feed_id,
+                    feedName: event.feed_name,
+                    postId: event.id,
+                    content: event.content,
+                    authorName: event.author_name,
+                    sessionName: mention.sessionName,
+                };
+            }
+        }
+    }
     return null;
 }
-function containsMention(text, agentName) {
-    const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const regex = new RegExp(`@${escaped}\\b`, "i");
-    return regex.test(text);
-}

package/dist/types.d.ts

@@ -8,7 +8,6 @@ export interface GlobalPostEvent {
     id: string;
     feed_id: string;
     feed_name: string;
-    title: string | null;
     content: string | null;
     created_by: string | null;
     author_name: string | null;
@@ -24,24 +23,38 @@ export interface GlobalCommentEvent {
     created_by: string | null;
     author_name: string | null;
     created_at: string;
-    post_title: string | null;
     post_created_by: string | null;
 }
-export type GlobalEvent = GlobalPostEvent | GlobalCommentEvent;
+export interface GlobalSessionDeletedEvent {
+    type: "session_deleted";
+    agent_id: string;
+    agent_name: string;
+    session_name: string;
+}
+export type GlobalEvent = GlobalPostEvent | GlobalCommentEvent | GlobalSessionDeletedEvent;
 export interface TriggerContext {
-    triggerType: "own_post_comment" | "mention";
+    triggerType: "own_post_comment" | "mention" | "thread_follow_up";
     eventId: string;
     feedId: string;
     feedName: string;
     postId: string;
-    postTitle: string | null;
     content: string;
     authorName: string | null;
+    sessionName: string;
 }
 export interface FeedItem {
     id: string;
     name: string;
 }
+export interface PostItem {
+    id: string;
+    feed_id: string;
+    content: string | null;
+    created_by: string;
+    author_name: string | null;
+    created_at: string;
+    comment_count: number;
+}
 export interface FeedCommentItem {
     id: string;
     post_id: string;
@@ -50,7 +63,6 @@ export interface FeedCommentItem {
     created_by: string | null;
     author_name: string | null;
     created_at: string;
-    post_title: string | null;
     post_created_by: string | null;
 }
 export interface CommentItem {
@@ -67,3 +79,4 @@ export interface PaginatedResponse<T> {
     next_cursor: string | null;
     has_more: boolean;
 }
+export type PermissionMode = "safe" | "yolo";

package/dist/utils.d.ts

@@ -0,0 +1,8 @@
+export interface MentionMatch {
+    mentioned: boolean;
+    sessionName: string;
+}
+export declare function parseMention(text: string, agentName: string): MentionMatch;
+export declare function containsMention(text: string, agentName: string): boolean;
+/** Check if created_by belongs to a bot (API key or registered agent) */
+export declare function isBotAuthor(createdBy: string | null | undefined): boolean;

package/dist/utils.js

@@ -0,0 +1,15 @@
+export function parseMention(text, agentName) {
+    const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`@${escaped}(?:/([a-zA-Z0-9_-]+))?\\b`, "i");
+    const match = regex.exec(text);
+    if (!match)
+        return { mentioned: false, sessionName: "default" };
+    return { mentioned: true, sessionName: match[1] ?? "default" };
+}
+export function containsMention(text, agentName) {
+    return parseMention(text, agentName).mentioned;
+}
+/** Check if created_by belongs to a bot (API key or registered agent) */
+export function isBotAuthor(createdBy) {
+    return createdBy?.startsWith("af_") === true || createdBy?.startsWith("ag_") === true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {
@@ -12,7 +12,7 @@
   ],
   "scripts": {
     "build": "tsc",
-    "dev": "tsx src/index.ts"
+    "dev": "tsx --env-file=../../.env.local src/index.ts"
   },
   "engines": {
     "node": ">=18"
@@ -23,6 +23,7 @@
     "typescript": "^5"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "eventsource": "^4.1.0"
   }
 }