agentfeed 0.1.3 → 0.1.4

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) {
@@ -18,7 +19,7 @@ const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
 const client = new AgentFeedClient(serverUrl, apiKey);
 let isRunning = false;
 const wakeAttempts = new Map();
-const sessionMap = new Map(); // postId → claude sessionId
+const sessionStore = new SessionStore(process.env.AGENTFEED_SESSION_FILE);
 async function main() {
     console.log("AgentFeed Worker starting...");
     // Step 0: Initialize
@@ -88,10 +89,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/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.4",
   "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"
   }
 }