agentfeed 0.1.6 → 0.1.8

package/bin/mcp-server.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { AgentFeedClient } from "../dist/api-client.js";
+import { startMCPServer } from "../dist/mcp-server.js";
+
+const serverUrl = process.env.AGENTFEED_BASE_URL?.replace(/\/api$/, "") || "http://localhost:3000";
+const apiKey = process.env.AGENTFEED_API_KEY;
+
+if (!apiKey) {
+  console.error("AGENTFEED_API_KEY environment variable is required");
+  process.exit(1);
+}
+
+const client = new AgentFeedClient(serverUrl, apiKey);
+
+// Set agent ID if provided
+if (process.env.AGENTFEED_AGENT_ID) {
+  client["_agentId"] = process.env.AGENTFEED_AGENT_ID;
+}
+
+startMCPServer({ client, serverUrl });

package/dist/api-client.d.ts

@@ -1,12 +1,17 @@
-import type { AgentInfo, FeedItem, FeedCommentItem, CommentItem, PaginatedResponse } from "./types.js";
+import type { AgentInfo, FeedItem, FeedCommentItem, CommentItem, PostItem, PaginatedResponse } from "./types.js";
 export declare class AgentFeedClient {
-    private baseUrl;
-    private apiKey;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    private _agentId;
     constructor(baseUrl: string, apiKey: string);
+    get agentId(): string | undefined;
     private request;
-    getMe(): Promise<AgentInfo>;
+    register(name: string): Promise<AgentInfo>;
     getSkillMd(): Promise<string>;
     getFeeds(): Promise<FeedItem[]>;
+    getFeedPosts(feedId: string, options?: {
+        limit?: number;
+    }): Promise<PaginatedResponse<PostItem>>;
     getFeedComments(feedId: string, options?: {
         author_type?: string;
         limit?: number;
@@ -16,4 +21,10 @@ export declare class AgentFeedClient {
         author_type?: string;
         limit?: number;
     }): Promise<PaginatedResponse<CommentItem>>;
+    setAgentStatus(params: {
+        status: "thinking" | "idle";
+        feed_id: string;
+        post_id: string;
+    }): Promise<void>;
+    reportSession(sessionName: string, claudeSessionId: string): Promise<void>;
 }

package/dist/api-client.js

@@ -1,21 +1,41 @@
 export class AgentFeedClient {
     baseUrl;
     apiKey;
+    _agentId;
     constructor(baseUrl, apiKey) {
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
     }
-    async request(path) {
+    get agentId() {
+        return this._agentId;
+    }
+    async request(path, options) {
+        const headers = {
+            Authorization: `Bearer ${this.apiKey}`,
+        };
+        if (this._agentId) {
+            headers["X-Agent-Id"] = this._agentId;
+        }
         const res = await fetch(`${this.baseUrl}${path}`, {
-            headers: { Authorization: `Bearer ${this.apiKey}` },
+            ...options,
+            headers: {
+                ...headers,
+                ...options?.headers,
+            },
         });
         if (!res.ok) {
             throw new Error(`API error ${res.status}: ${await res.text()}`);
         }
         return res.json();
     }
-    async getMe() {
-        return this.request("/api/auth/me");
+    async register(name) {
+        const result = await this.request("/api/agents/register", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name }),
+        });
+        this._agentId = result.id;
+        return { id: result.id, name: result.name, type: "api" };
     }
     async getSkillMd() {
         const res = await fetch(`${this.baseUrl}/skill.md`);
@@ -27,6 +47,13 @@ export class AgentFeedClient {
     async getFeeds() {
         return this.request("/api/feeds");
     }
+    async getFeedPosts(feedId, options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const qs = params.toString();
+        return this.request(`/api/feeds/${feedId}/posts${qs ? `?${qs}` : ""}`);
+    }
     async getFeedComments(feedId, options) {
         const params = new URLSearchParams();
         if (options?.author_type)
@@ -47,4 +74,27 @@ export class AgentFeedClient {
         const qs = params.toString();
         return this.request(`/api/posts/${postId}/comments${qs ? `?${qs}` : ""}`);
     }
+    async setAgentStatus(params) {
+        try {
+            await this.request("/api/agents/status", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(params),
+            });
+        }
+        catch (err) {
+            // Non-critical: don't throw, just log
+            console.warn("Failed to set agent status:", err);
+        }
+    }
+    async reportSession(sessionName, claudeSessionId) {
+        await this.request("/api/agents/sessions", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                session_name: sessionName,
+                claude_session_id: claudeSessionId,
+            }),
+        });
+    }
 }

package/dist/follow-store.d.ts

@@ -0,0 +1,10 @@
+import { PersistentStore } from "./persistent-store.js";
+export declare class FollowStore extends PersistentStore {
+    private posts;
+    constructor(filePath?: string);
+    protected serialize(): string;
+    protected deserialize(raw: string): void;
+    has(postId: string): boolean;
+    add(postId: string): void;
+    getAll(): string[];
+}

package/dist/follow-store.js

@@ -0,0 +1,29 @@
+import { PersistentStore } from "./persistent-store.js";
+export class FollowStore extends PersistentStore {
+    posts = new Set();
+    constructor(filePath) {
+        super("followed-posts.json", filePath);
+        this.load();
+    }
+    serialize() {
+        return JSON.stringify(Array.from(this.posts), null, 2);
+    }
+    deserialize(raw) {
+        const data = JSON.parse(raw);
+        for (const id of data) {
+            this.posts.add(id);
+        }
+    }
+    has(postId) {
+        return this.posts.has(postId);
+    }
+    add(postId) {
+        if (this.posts.has(postId))
+            return;
+        this.posts.add(postId);
+        this.save();
+    }
+    getAll() {
+        return Array.from(this.posts);
+    }
+}

package/dist/index.js

@@ -1,9 +1,14 @@
+import * as path from "node:path";
+import * as readline from "node:readline";
 import { AgentFeedClient } from "./api-client.js";
 import { connectSSE } from "./sse-client.js";
 import { detectTrigger } from "./trigger.js";
 import { invokeAgent } from "./invoker.js";
 import { scanUnprocessed } from "./scanner.js";
 import { SessionStore } from "./session-store.js";
+import { FollowStore } from "./follow-store.js";
+import { QueueStore } from "./queue-store.js";
+import { PostSessionStore } from "./post-session-store.js";
 const MAX_WAKE_ATTEMPTS = 3;
 const MAX_CRASH_RETRIES = 3;
 function getRequiredEnv(name) {
@@ -14,13 +19,59 @@ function getRequiredEnv(name) {
     }
     return value;
 }
+function parsePermissionMode() {
+    const idx = process.argv.indexOf("--permission");
+    if (idx === -1)
+        return "safe";
+    const value = process.argv[idx + 1];
+    if (value === "yolo")
+        return "yolo";
+    if (value === "safe")
+        return "safe";
+    console.error(`Unknown permission mode: "${value}". Use "safe" (default) or "yolo".`);
+    process.exit(1);
+}
+function parseAllowedTools() {
+    const tools = [];
+    for (let i = 0; i < process.argv.length; i++) {
+        if (process.argv[i] === "--allowed-tools") {
+            // Collect all following args until the next flag (starts with --)
+            for (let j = i + 1; j < process.argv.length; j++) {
+                if (process.argv[j].startsWith("--"))
+                    break;
+                tools.push(process.argv[j]);
+            }
+            break;
+        }
+    }
+    return tools;
+}
+function confirmYolo() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        console.log("");
+        console.log("  \x1b[33m⚠️  YOLO mode enabled. The agent can do literally anything.\x1b[0m");
+        console.log("  \x1b[33m   No prompt sandboxing. No trust boundaries.\x1b[0m");
+        console.log("  \x1b[33m   Prompt injection? Not your problem today.\x1b[0m");
+        console.log("");
+        rl.question("  Continue? (y/N): ", (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === "y");
+        });
+    });
+}
 const serverUrl = getRequiredEnv("AGENTFEED_URL");
 const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
+const permissionMode = parsePermissionMode();
+const extraAllowedTools = parseAllowedTools();
 const client = new AgentFeedClient(serverUrl, apiKey);
 let isRunning = false;
 let sseConnection = null;
 const wakeAttempts = new Map();
 const sessionStore = new SessionStore(process.env.AGENTFEED_SESSION_FILE);
+const followStore = new FollowStore(process.env.AGENTFEED_FOLLOW_FILE);
+const queueStore = new QueueStore(process.env.AGENTFEED_QUEUE_FILE);
+const postSessionStore = new PostSessionStore(process.env.AGENTFEED_POST_SESSION_FILE);
 function shutdown() {
     console.log("\nShutting down...");
     sseConnection?.close();
@@ -29,18 +80,29 @@ function shutdown() {
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
 async function main() {
-    console.log("AgentFeed Worker starting...");
-    // Step 0: Initialize
-    const agent = await client.getMe();
+    // Confirm yolo mode
+    if (permissionMode === "yolo") {
+        const confirmed = await confirmYolo();
+        if (!confirmed) {
+            console.log("Cancelled. Run without --permission yolo for safe mode.");
+            process.exit(0);
+        }
+    }
+    const toolsInfo = extraAllowedTools.length > 0
+        ? ` + ${extraAllowedTools.join(", ")}`
+        : "";
+    console.log(`AgentFeed Worker starting... (permission: ${permissionMode}${toolsInfo})`);
+    // Step 0: Register agent
+    const projectName = process.env.AGENTFEED_AGENT_NAME ?? path.basename(process.cwd());
+    const agent = await client.register(projectName);
     console.log(`Agent: ${agent.name} (${agent.id})`);
-    const skillMd = await client.getSkillMd();
-    console.log("Skill document cached.");
+    console.log("MCP mode enabled.");
     // Step 1: Startup scan for unprocessed items
     console.log("Scanning for unprocessed items...");
-    const unprocessed = await scanUnprocessed(client, agent);
+    const unprocessed = await scanUnprocessed(client, agent, followStore, postSessionStore);
     if (unprocessed.length > 0) {
         console.log(`Found ${unprocessed.length} unprocessed item(s)`);
-        await handleTriggers(unprocessed, agent, skillMd);
+        await handleTriggers(unprocessed, agent);
     }
     else {
         console.log("No unprocessed items found.");
@@ -48,14 +110,29 @@ async function main() {
     // Step 2: Connect to global SSE stream
     const sseUrl = `${serverUrl}/api/events/stream?author_type=human`;
     console.log("Connecting to global event stream...");
-    sseConnection = connectSSE(sseUrl, apiKey, (rawEvent) => {
+    sseConnection = connectSSE(sseUrl, apiKey, client.agentId, (rawEvent) => {
         if (rawEvent.type === "heartbeat")
             return;
+        // Handle session_deleted events directly
+        if (rawEvent.type === "session_deleted") {
+            try {
+                const data = JSON.parse(rawEvent.data);
+                if (data.agent_id === client.agentId) {
+                    sessionStore.delete(data.session_name);
+                    postSessionStore.removeBySessionName(data.session_name);
+                    console.log(`Session deleted: ${data.session_name}`);
+                }
+            }
+            catch (err) {
+                console.error("Failed to handle session_deleted event:", err);
+            }
+            return;
+        }
         try {
             const event = JSON.parse(rawEvent.data);
-            const trigger = detectTrigger(event, agent);
+            const trigger = detectTrigger(event, agent, followStore, postSessionStore);
             if (trigger) {
-                handleTriggers([trigger], agent, skillMd);
+                handleTriggers([trigger], agent);
             }
         }
         catch (err) {
@@ -66,73 +143,121 @@ async function main() {
     });
     console.log("Worker ready. Listening for events...");
 }
-async function handleTriggers(triggers, agent, skillMd) {
+async function handleTriggers(triggers, agent) {
+    // Queue all incoming triggers (persisted to disk)
+    for (const t of triggers) {
+        queueStore.push(t);
+        console.log(`Queued trigger: ${t.triggerType} on ${t.postId} (queue size: ${queueStore.size})`);
+    }
     if (isRunning)
         return;
-    // Filter by wake attempt limit
-    const eligible = triggers.filter((t) => {
-        const attempts = wakeAttempts.get(t.eventId) ?? 0;
-        if (attempts >= MAX_WAKE_ATTEMPTS) {
-            console.log(`Skipping ${t.eventId}: max wake attempts reached`);
-            return false;
+    // Process queue until empty
+    await processQueue(agent);
+}
+async function processQueue(agent) {
+    while (true) {
+        const queued = queueStore.drain();
+        if (queued.length === 0)
+            break;
+        // Filter by wake attempt limit
+        const eligible = queued.filter((t) => {
+            const attempts = wakeAttempts.get(t.eventId) ?? 0;
+            if (attempts >= MAX_WAKE_ATTEMPTS) {
+                console.log(`Skipping ${t.eventId}: max wake attempts reached`);
+                return false;
+            }
+            return true;
+        });
+        if (eligible.length === 0)
+            break;
+        isRunning = true;
+        const trigger = eligible[0];
+        // Re-queue remaining items
+        for (const t of eligible.slice(1)) {
+            queueStore.push(t);
         }
-        return true;
-    });
-    if (eligible.length === 0)
-        return;
-    isRunning = true;
-    const trigger = eligible[0];
-    wakeAttempts.set(trigger.eventId, (wakeAttempts.get(trigger.eventId) ?? 0) + 1);
-    // Fetch recent context for the prompt
-    const recentContext = await fetchContext(trigger);
-    console.log(`Waking agent for: ${trigger.triggerType} on ${trigger.postId}`);
-    let retries = 0;
-    let success = false;
-    while (retries < MAX_CRASH_RETRIES) {
+        wakeAttempts.set(trigger.eventId, (wakeAttempts.get(trigger.eventId) ?? 0) + 1);
+        // Auto-follow thread on mention (so future comments trigger without re-mention)
+        if (trigger.triggerType === "mention") {
+            followStore.add(trigger.postId);
+            console.log(`Following thread: ${trigger.postId}`);
+        }
+        // Fetch recent context for the prompt
+        const recentContext = await fetchContext(trigger);
+        console.log(`Waking agent for: ${trigger.triggerType} on ${trigger.postId} (session: ${trigger.sessionName})`);
+        // Report thinking status
+        await client.setAgentStatus({
+            status: "thinking",
+            feed_id: trigger.feedId,
+            post_id: trigger.postId,
+        });
+        let retries = 0;
+        let success = false;
         try {
-            const result = await invokeAgent({
-                agent,
-                trigger,
-                skillMd,
-                apiKey,
-                serverUrl,
-                recentContext,
-                sessionId: sessionStore.get(trigger.postId),
-            });
-            if (result.sessionId) {
-                sessionStore.set(trigger.postId, result.sessionId);
+            while (retries < MAX_CRASH_RETRIES) {
+                try {
+                    const result = await invokeAgent({
+                        agent,
+                        trigger,
+                        apiKey,
+                        serverUrl,
+                        recentContext,
+                        permissionMode,
+                        extraAllowedTools,
+                        sessionId: sessionStore.get(trigger.sessionName),
+                        agentId: client.agentId,
+                    });
+                    if (result.sessionId) {
+                        sessionStore.set(trigger.sessionName, result.sessionId);
+                        postSessionStore.set(trigger.postId, trigger.sessionName);
+                        // Report session to server
+                        await client.reportSession(trigger.sessionName, result.sessionId).catch((err) => {
+                            console.warn("Failed to report session:", err);
+                        });
+                    }
+                    if (result.exitCode === 0) {
+                        success = true;
+                        break;
+                    }
+                    // If resume failed (stale session), clear it and retry as new session
+                    if (result.exitCode !== 0 && sessionStore.get(trigger.sessionName)) {
+                        console.log("Session may be stale, clearing and retrying as new session...");
+                        sessionStore.delete(trigger.sessionName);
+                    }
+                    console.error(`Agent exited with code ${result.exitCode}, retry ${retries + 1}/${MAX_CRASH_RETRIES}`);
+                }
+                catch (err) {
+                    console.error("Agent invocation error:", err);
+                }
+                retries++;
             }
-            if (result.exitCode === 0) {
-                success = true;
-                break;
+            if (!success) {
+                console.error(`Agent failed after ${MAX_CRASH_RETRIES} retries`);
             }
-            // If resume failed (stale session), clear it and retry as new session
-            if (result.exitCode !== 0 && sessionStore.get(trigger.postId)) {
-                console.log("Session may be stale, clearing and retrying as new session...");
-                sessionStore.delete(trigger.postId);
+        }
+        finally {
+            // Always report idle when done
+            await client.setAgentStatus({
+                status: "idle",
+                feed_id: trigger.feedId,
+                post_id: trigger.postId,
+            });
+        }
+        isRunning = false;
+        // Post-completion: re-scan for items that arrived during execution and add to queue
+        try {
+            const newUnprocessed = await scanUnprocessed(client, agent, followStore, postSessionStore);
+            for (const t of newUnprocessed) {
+                queueStore.push(t);
+            }
+            if (newUnprocessed.length > 0) {
+                console.log(`Post-completion scan: ${newUnprocessed.length} item(s) added to queue`);
             }
-            console.error(`Agent exited with code ${result.exitCode}, retry ${retries + 1}/${MAX_CRASH_RETRIES}`);
         }
         catch (err) {
-            console.error("Agent invocation error:", err);
+            console.error("Post-completion scan error:", err);
         }
-        retries++;
-    }
-    if (!success) {
-        console.error(`Agent failed after ${MAX_CRASH_RETRIES} retries`);
-    }
-    isRunning = false;
-    // Post-completion: re-scan for items that arrived during execution
-    try {
-        const agent2 = await client.getMe();
-        const newUnprocessed = await scanUnprocessed(client, agent2);
-        if (newUnprocessed.length > 0) {
-            console.log(`Post-completion: ${newUnprocessed.length} unprocessed item(s) found`);
-            await handleTriggers(newUnprocessed, agent, skillMd);
-        }
-    }
-    catch (err) {
-        console.error("Post-completion scan error:", err);
+        // Loop continues to process next item in queue
     }
 }
 async function fetchContext(trigger) {

package/dist/invoker.d.ts

@@ -1,12 +1,14 @@
-import type { TriggerContext, AgentInfo } from "./types.js";
+import type { TriggerContext, AgentInfo, PermissionMode } from "./types.js";
 interface InvokeOptions {
     agent: AgentInfo;
     trigger: TriggerContext;
-    skillMd: string;
     apiKey: string;
     serverUrl: string;
     recentContext: string;
+    permissionMode: PermissionMode;
+    extraAllowedTools?: string[];
     sessionId?: string;
+    agentId?: string;
 }
 interface InvokeResult {
     exitCode: number;