agentfeed 0.1.8 → 0.1.11

package/dist/trigger.js

@@ -1,64 +1,91 @@
-import { parseMention } from "./utils.js";
-export function detectTrigger(event, agent, followStore, postSessionStore) {
+import { parseMention, isBotAuthor } from "./utils.js";
+export function detectTriggers(event, backendAgents, followStore, postSessionStore, ownAgentIds) {
+    const isOwnAgent = (id) => id !== null && (ownAgentIds ? ownAgentIds.has(id) : false);
+    const defaultBackendType = backendAgents[0]?.backendType ?? "claude";
     if (event.type === "comment_created") {
-        // Trigger 1: Comment on own post
-        if (event.post_created_by === agent.id) {
-            return {
-                triggerType: "own_post_comment",
-                eventId: event.id,
-                feedId: event.feed_id,
-                feedName: "",
-                postId: event.post_id,
-                content: event.content,
-                authorName: event.author_name,
-                sessionName: postSessionStore?.get(event.post_id) ?? "default",
-            };
-        }
-        // Trigger 2: @mention in comment
-        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,
-                content: event.content,
-                authorName: event.author_name,
-                sessionName: mention.sessionName,
-            };
-        }
-        // Trigger 3: Comment in a followed thread
-        if (followStore?.has(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,
-                sessionName: postSessionStore?.get(event.post_id) ?? "default",
-            };
+        const authorIsOwnBot = isOwnAgent(event.created_by);
+        // Trigger 1: Comment on own post (human-authored only — prevents bot loop)
+        if (!authorIsOwnBot && isOwnAgent(event.post_created_by)) {
+            const postSession = postSessionStore?.getWithType(event.post_id);
+            return [{
+                    triggerType: "own_post_comment",
+                    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,
+                }];
         }
-    }
-    if (event.type === "post_created") {
-        // @mention in post content
-        if (event.content) {
-            const mention = parseMention(event.content, agent.name);
+        // Trigger 2: @mention in comment — collect ALL matching agents
+        const mentions = [];
+        for (const ba of backendAgents) {
+            if (event.created_by === ba.agent.id)
+                continue; // skip self-mention
+            const mention = parseMention(event.content, ba.agent.name);
             if (mention.mentioned) {
-                return {
+                mentions.push({
                     triggerType: "mention",
-                    eventId: event.id,
+                    eventId: `${event.id}:${ba.backendType}`,
                     feedId: event.feed_id,
-                    feedName: event.feed_name,
-                    postId: event.id,
+                    feedName: "",
+                    postId: event.post_id,
                     content: event.content,
                     authorName: event.author_name,
+                    authorIsBot: event.author_type === "bot",
                     sessionName: mention.sessionName,
-                };
+                    backendType: ba.backendType,
+                });
+            }
+        }
+        if (mentions.length > 0)
+            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,
+                }];
+        }
+    }
+    if (event.type === "post_created") {
+        // @mention in post content — collect ALL matching agents
+        if (event.content) {
+            const mentions = [];
+            for (const ba of backendAgents) {
+                if (event.created_by === ba.agent.id)
+                    continue;
+                const mention = parseMention(event.content, ba.agent.name);
+                if (mention.mentioned) {
+                    mentions.push({
+                        triggerType: "mention",
+                        eventId: `${event.id}:${ba.backendType}`,
+                        feedId: event.feed_id,
+                        feedName: event.feed_name,
+                        postId: event.id,
+                        content: event.content,
+                        authorName: event.author_name,
+                        authorIsBot: isBotAuthor(event.created_by),
+                        sessionName: mention.sessionName,
+                        backendType: ba.backendType,
+                    });
+                }
             }
+            if (mentions.length > 0)
+                return mentions;
         }
     }
-    return null;
+    return [];
 }

package/dist/types.d.ts

@@ -1,8 +1,22 @@
+import type { CLIBackend } from "./backends/types.js";
+import type { SessionStore } from "./session-store.js";
 export interface AgentInfo {
     id: string;
     name: string;
     type: string;
 }
+export interface AgentConfig {
+    permission_mode: PermissionMode;
+    allowed_tools: string[];
+    model: string | null;
+}
+export interface BackendAgent {
+    backendType: BackendType;
+    backend: CLIBackend;
+    agent: AgentInfo;
+    sessionStore: SessionStore;
+    config?: AgentConfig;
+}
 export interface GlobalPostEvent {
     type: "post_created";
     id: string;
@@ -40,7 +54,9 @@ export interface TriggerContext {
     postId: string;
     content: string;
     authorName: string | null;
+    authorIsBot: boolean;
     sessionName: string;
+    backendType: BackendType;
 }
 export interface FeedItem {
     id: string;
@@ -80,3 +96,4 @@ export interface PaginatedResponse<T> {
     has_more: boolean;
 }
 export type PermissionMode = "safe" | "yolo";
+export type BackendType = "claude" | "codex" | "gemini";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.8",
+  "version": "0.1.11",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {
@@ -14,6 +14,19 @@
     "build": "tsc",
     "dev": "tsx --env-file=../../.env.local src/index.ts"
   },
+  "keywords": [
+    "ai-agent",
+    "feed",
+    "claude",
+    "mcp",
+    "sse"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/daige-st/agentfeed.git",
+    "directory": "packages/worker"
+  },
   "engines": {
     "node": ">=18"
   },

package/dist/mcp-config.d.ts

@@ -1,11 +0,0 @@
-export interface MCPConfig {
-    mcpServers: {
-        agentfeed: {
-            command: string;
-            args: string[];
-            env?: Record<string, string>;
-        };
-    };
-}
-export declare function generateMCPConfig(env: Record<string, string>): MCPConfig;
-export declare function writeMCPConfig(config: MCPConfig): string;

package/dist/mcp-config.js

@@ -1,25 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-export function generateMCPConfig(env) {
-    // Path to the MCP server binary
-    const mcpServerPath = path.resolve(path.dirname(new URL(import.meta.url).pathname), "../bin/mcp-server.js");
-    return {
-        mcpServers: {
-            agentfeed: {
-                command: "node",
-                args: [mcpServerPath],
-                env,
-            },
-        },
-    };
-}
-export function writeMCPConfig(config) {
-    const configDir = path.join(os.homedir(), ".agentfeed");
-    if (!fs.existsSync(configDir)) {
-        fs.mkdirSync(configDir, { recursive: true });
-    }
-    const configPath = path.join(configDir, "mcp-config.json");
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
-    return configPath;
-}