agentfeed 0.1.3 → 0.1.5

package/dist/index.js

@@ -3,6 +3,7 @@ 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";
 const MAX_WAKE_ATTEMPTS = 3;
 const MAX_CRASH_RETRIES = 3;
 function getRequiredEnv(name) {
@@ -17,8 +18,16 @@ const serverUrl = getRequiredEnv("AGENTFEED_URL");
 const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
 const client = new AgentFeedClient(serverUrl, apiKey);
 let isRunning = false;
+let sseConnection = null;
 const wakeAttempts = new Map();
-const sessionMap = new Map(); // postId → claude sessionId
+const sessionStore = new SessionStore(process.env.AGENTFEED_SESSION_FILE);
+function shutdown() {
+    console.log("\nShutting down...");
+    sseConnection?.close();
+    process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
 async function main() {
     console.log("AgentFeed Worker starting...");
     // Step 0: Initialize
@@ -39,7 +48,7 @@ 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...");
-    connectSSE(sseUrl, apiKey, (rawEvent) => {
+    sseConnection = connectSSE(sseUrl, apiKey, (rawEvent) => {
         if (rawEvent.type === "heartbeat")
             return;
         try {
@@ -88,10 +97,10 @@ async function handleTriggers(triggers, agent, skillMd) {
                 apiKey,
                 serverUrl,
                 recentContext,
-                sessionId: sessionMap.get(trigger.postId),
+                sessionId: sessionStore.get(trigger.postId),
             });
             if (result.sessionId) {
-                sessionMap.set(trigger.postId, result.sessionId);
+                sessionStore.set(trigger.postId, result.sessionId);
             }
             if (result.exitCode === 0) {
                 success = true;

package/dist/invoker.js

@@ -3,12 +3,16 @@ export function invokeAgent(options) {
     return new Promise((resolve, reject) => {
         const prompt = buildPrompt(options);
         const isNewSession = !options.sessionId;
-        const args = ["-p", prompt, "--append-system-prompt", options.skillMd];
+        const args = [
+            "-p", prompt,
+            "--append-system-prompt", options.skillMd,
+            "--allowedTools", "Bash(curl:*)",
+        ];
         if (options.sessionId) {
             args.push("--resume", options.sessionId);
         }
         if (isNewSession) {
-            args.push("--output-format", "json");
+            args.push("--output-format", "stream-json");
         }
         const env = {
             ...process.env,
@@ -16,14 +20,41 @@ export function invokeAgent(options) {
             AGENTFEED_API_KEY: options.apiKey,
             CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE ?? "50",
         };
+        console.log("Invoking claude...");
         const child = spawn("claude", args, {
             env,
             stdio: isNewSession ? ["inherit", "pipe", "inherit"] : "inherit",
         });
-        let stdout = "";
+        let sessionId;
         if (isNewSession && child.stdout) {
+            let buffer = "";
             child.stdout.on("data", (chunk) => {
-                stdout += chunk.toString();
+                buffer += chunk.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() ?? "";
+                for (const line of lines) {
+                    if (!line.trim())
+                        continue;
+                    try {
+                        const event = JSON.parse(line);
+                        // Show assistant text as it streams
+                        if (event.type === "assistant" &&
+                            event.message?.content) {
+                            for (const block of event.message.content) {
+                                if (block.type === "text") {
+                                    process.stdout.write(block.text);
+                                }
+                            }
+                        }
+                        // Capture session_id from result event
+                        if (event.type === "result" && event.session_id) {
+                            sessionId = event.session_id;
+                        }
+                    }
+                    catch {
+                        // Not valid JSON, skip
+                    }
+                }
             });
         }
         child.on("error", (err) => {
@@ -35,16 +66,9 @@ export function invokeAgent(options) {
             }
         });
         child.on("close", (code) => {
-            let sessionId;
-            if (isNewSession && stdout) {
-                try {
-                    const parsed = JSON.parse(stdout);
-                    sessionId = parsed.session_id;
-                }
-                catch {
-                    // JSON parse failed, ignore
-                }
-            }
+            if (isNewSession)
+                process.stdout.write("\n");
+            console.log(`Agent exited (code ${code ?? "unknown"})`);
             resolve({ exitCode: code ?? 1, sessionId: sessionId ?? options.sessionId });
         });
     });

package/dist/session-store.d.ts

@@ -0,0 +1,9 @@
+export declare class SessionStore {
+    private map;
+    private filePath;
+    constructor(filePath?: string);
+    get(postId: string): string | undefined;
+    set(postId: string, sessionId: string): void;
+    private load;
+    private save;
+}

package/dist/session-store.js

@@ -0,0 +1,41 @@
+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 {
+    map = new Map();
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath ?? join(DEFAULT_DIR, "sessions.json");
+        this.load();
+    }
+    get(postId) {
+        return this.map.get(postId);
+    }
+    set(postId, sessionId) {
+        this.map.set(postId, sessionId);
+        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.js

@@ -1,100 +1,31 @@
-import http from "node:http";
-import https from "node:https";
+import { EventSource } from "eventsource";
+const EVENT_TYPES = ["heartbeat", "post_created", "comment_created"];
 export function connectSSE(url, apiKey, onEvent, onError) {
-    let aborted = false;
-    let reconnecting = false;
-    let currentReq = null;
-    const connect = () => {
-        if (aborted)
-            return;
-        reconnecting = false;
-        const parsed = new URL(url);
-        const isHttps = parsed.protocol === "https:";
-        const options = {
-            hostname: parsed.hostname,
-            port: parsed.port || (isHttps ? 443 : 80),
-            path: parsed.pathname + parsed.search,
-            method: "GET",
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                Accept: "text/event-stream",
-                "Cache-Control": "no-cache",
-                Connection: "keep-alive",
-            },
-            // Disable connection pooling to avoid agent timeouts
-            agent: false,
-        };
-        const mod = isHttps ? https : http;
-        const req = mod.request(options, (res) => {
-            if (res.statusCode !== 200) {
-                res.resume();
-                onError(new Error(`SSE connect failed: ${res.statusCode}`));
-                scheduleReconnect();
-                return;
-            }
-            // Keep TCP connection alive
-            res.socket?.setKeepAlive(true, 10000);
-            res.socket?.setTimeout(0);
-            res.setEncoding("utf-8");
-            let buffer = "";
-            let currentEvent = { type: "message", data: "" };
-            res.on("data", (chunk) => {
-                buffer += chunk;
-                const lines = buffer.split("\n");
-                buffer = lines.pop() ?? "";
-                for (const line of lines) {
-                    if (line.startsWith("event: ")) {
-                        currentEvent.type = line.slice(7);
-                    }
-                    else if (line.startsWith("data: ")) {
-                        currentEvent.data = line.slice(6);
-                    }
-                    else if (line.startsWith("id: ")) {
-                        currentEvent.id = line.slice(4);
-                    }
-                    else if (line === "") {
-                        if (currentEvent.data || currentEvent.type === "heartbeat") {
-                            onEvent({ ...currentEvent });
-                        }
-                        currentEvent = { type: "message", data: "" };
-                    }
-                }
-            });
-            res.on("end", () => {
-                if (!aborted) {
-                    console.log("SSE stream ended, reconnecting...");
-                    scheduleReconnect();
-                }
-            });
-            res.on("error", (err) => {
-                if (!aborted) {
-                    onError(err);
-                    scheduleReconnect();
-                }
-            });
-        });
-        req.on("error", (err) => {
-            if (!aborted) {
-                onError(err);
-                scheduleReconnect();
-            }
-        });
-        // Disable request timeout
-        req.setTimeout(0);
-        req.end();
-        currentReq = req;
+    const es = new EventSource(url, {
+        fetch: (input, init) => fetch(input, {
+            ...init,
+            headers: { ...init.headers, Authorization: `Bearer ${apiKey}` },
+        }),
+    });
+    es.onopen = () => {
+        console.log("SSE connected.");
     };
-    const scheduleReconnect = () => {
-        if (aborted || reconnecting)
-            return;
-        reconnecting = true;
-        setTimeout(connect, 5000);
+    es.onerror = (err) => {
+        if (es.readyState === EventSource.CLOSED) {
+            onError(new Error(err.message ?? "SSE connection closed"));
+        }
+        // CONNECTING state = auto-reconnecting, no action needed
     };
-    connect();
+    for (const eventType of EVENT_TYPES) {
+        es.addEventListener(eventType, (e) => {
+            onEvent({
+                type: eventType,
+                data: e.data,
+                id: e.lastEventId || undefined,
+            });
+        });
+    }
     return {
-        close: () => {
-            aborted = true;
-            currentReq?.destroy();
-        },
+        close: () => es.close(),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {
@@ -21,5 +21,8 @@
     "@types/node": "^22",
     "tsx": "^4",
     "typescript": "^5"
+  },
+  "dependencies": {
+    "eventsource": "^4.1.0"
   }
 }