agentfeed 0.1.0

package/bin/cli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/api-client.d.ts

@@ -0,0 +1,19 @@
+import type { AgentInfo, FeedItem, FeedCommentItem, CommentItem, PaginatedResponse } from "./types.js";
+export declare class AgentFeedClient {
+    private baseUrl;
+    private apiKey;
+    constructor(baseUrl: string, apiKey: string);
+    private request;
+    getMe(): Promise<AgentInfo>;
+    getSkillMd(): Promise<string>;
+    getFeeds(): Promise<FeedItem[]>;
+    getFeedComments(feedId: string, options?: {
+        author_type?: string;
+        limit?: number;
+    }): Promise<PaginatedResponse<FeedCommentItem>>;
+    getPostComments(postId: string, options?: {
+        since?: string;
+        author_type?: string;
+        limit?: number;
+    }): Promise<PaginatedResponse<CommentItem>>;
+}

package/dist/api-client.js

@@ -0,0 +1,50 @@
+export class AgentFeedClient {
+    baseUrl;
+    apiKey;
+    constructor(baseUrl, apiKey) {
+        this.baseUrl = baseUrl;
+        this.apiKey = apiKey;
+    }
+    async request(path) {
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+        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 getSkillMd() {
+        const res = await fetch(`${this.baseUrl}/skill.md`);
+        if (!res.ok) {
+            throw new Error(`Failed to fetch skill.md: ${res.status}`);
+        }
+        return res.text();
+    }
+    async getFeeds() {
+        return this.request("/api/feeds");
+    }
+    async getFeedComments(feedId, options) {
+        const params = new URLSearchParams();
+        if (options?.author_type)
+            params.set("author_type", options.author_type);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const qs = params.toString();
+        return this.request(`/api/feeds/${feedId}/comments${qs ? `?${qs}` : ""}`);
+    }
+    async getPostComments(postId, options) {
+        const params = new URLSearchParams();
+        if (options?.since)
+            params.set("since", options.since);
+        if (options?.author_type)
+            params.set("author_type", options.author_type);
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const qs = params.toString();
+        return this.request(`/api/posts/${postId}/comments${qs ? `?${qs}` : ""}`);
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,133 @@
+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";
+const MAX_WAKE_ATTEMPTS = 3;
+const MAX_CRASH_RETRIES = 3;
+function getRequiredEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Required environment variable: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+const serverUrl = getRequiredEnv("AGENTFEED_URL");
+const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
+const client = new AgentFeedClient(serverUrl, apiKey);
+let isRunning = false;
+const wakeAttempts = new Map();
+async function main() {
+    console.log("AgentFeed Worker starting...");
+    // Step 0: Initialize
+    const agent = await client.getMe();
+    console.log(`Agent: ${agent.name} (${agent.id})`);
+    const skillMd = await client.getSkillMd();
+    console.log("Skill document cached.");
+    // Step 1: Startup scan for unprocessed items
+    console.log("Scanning for unprocessed items...");
+    const unprocessed = await scanUnprocessed(client, agent);
+    if (unprocessed.length > 0) {
+        console.log(`Found ${unprocessed.length} unprocessed item(s)`);
+        await handleTriggers(unprocessed, agent, skillMd);
+    }
+    else {
+        console.log("No unprocessed items found.");
+    }
+    // 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) => {
+        if (rawEvent.type === "heartbeat")
+            return;
+        try {
+            const event = JSON.parse(rawEvent.data);
+            const trigger = detectTrigger(event, agent);
+            if (trigger) {
+                handleTriggers([trigger], agent, skillMd);
+            }
+        }
+        catch (err) {
+            console.error("Failed to parse event:", err);
+        }
+    }, (err) => {
+        console.error("SSE error, reconnecting...", err.message);
+    });
+    console.log("Worker ready. Listening for events...");
+}
+async function handleTriggers(triggers, agent, skillMd) {
+    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;
+        }
+        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) {
+        try {
+            const result = await invokeAgent({
+                agent,
+                trigger,
+                skillMd,
+                apiKey,
+                serverUrl,
+                recentContext,
+            });
+            if (result.exitCode === 0) {
+                success = true;
+                break;
+            }
+            console.error(`Agent exited with code ${result.exitCode}, retry ${retries + 1}/${MAX_CRASH_RETRIES}`);
+        }
+        catch (err) {
+            console.error("Agent invocation 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);
+    }
+}
+async function fetchContext(trigger) {
+    try {
+        const comments = await client.getPostComments(trigger.postId, { limit: 10 });
+        return comments.data
+            .map((c) => `[${c.author_type}${c.author_name ? ` (${c.author_name})` : ""}] ${c.content}`)
+            .join("\n");
+    }
+    catch {
+        return "";
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/invoker.d.ts

@@ -0,0 +1,13 @@
+import type { TriggerContext, AgentInfo } from "./types.js";
+interface InvokeOptions {
+    agent: AgentInfo;
+    trigger: TriggerContext;
+    skillMd: string;
+    apiKey: string;
+    serverUrl: string;
+    recentContext: string;
+}
+export declare function invokeAgent(options: InvokeOptions): Promise<{
+    exitCode: number;
+}>;
+export {};

package/dist/invoker.js

@@ -0,0 +1,49 @@
+import { spawn } from "node:child_process";
+export function invokeAgent(options) {
+    return new Promise((resolve, reject) => {
+        const prompt = buildPrompt(options);
+        const child = spawn("claude", [
+            "-p",
+            prompt,
+            "--append-system-prompt",
+            options.skillMd,
+        ], {
+            env: {
+                ...process.env,
+                AGENTFEED_BASE_URL: `${options.serverUrl}/api`,
+                AGENTFEED_API_KEY: options.apiKey,
+            },
+            stdio: "inherit",
+        });
+        child.on("error", (err) => {
+            if (err.code === "ENOENT") {
+                reject(new Error("'claude' command not found. Install Claude Code: https://claude.ai/claude-code"));
+            }
+            else {
+                reject(err);
+            }
+        });
+        child.on("close", (code) => {
+            resolve({ exitCode: code ?? 1 });
+        });
+    });
+}
+function buildPrompt(options) {
+    const { agent, trigger, recentContext } = options;
+    const triggerLabel = trigger.triggerType === "own_post_comment"
+        ? "Comment on your post"
+        : "@mention";
+    return `You are ${agent.name}.
+
+[Trigger]
+- Type: ${triggerLabel}
+- Author: ${trigger.authorName ?? "unknown"}
+- Feed: ${trigger.feedName || trigger.feedId}
+- Post: ${trigger.postTitle ?? "(untitled)"} (${trigger.postId})
+- Content: ${trigger.content}
+
+[Recent Context]
+${recentContext || "(no prior context)"}
+
+Respond to all pending comments and posts. Use the AgentFeed API (available via environment variables AGENTFEED_BASE_URL and AGENTFEED_API_KEY) to read context and post responses.`;
+}

package/dist/scanner.d.ts

@@ -0,0 +1,3 @@
+import type { AgentInfo, TriggerContext } from "./types.js";
+import type { AgentFeedClient } from "./api-client.js";
+export declare function scanUnprocessed(client: AgentFeedClient, agent: AgentInfo): Promise<TriggerContext[]>;

package/dist/scanner.js

@@ -0,0 +1,50 @@
+export async function scanUnprocessed(client, agent) {
+    const triggers = [];
+    const feeds = await client.getFeeds();
+    for (const feed of feeds) {
+        const comments = await client.getFeedComments(feed.id, {
+            author_type: "human",
+            limit: 50,
+        });
+        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";
+            }
+            // Check for @mentions
+            if (containsMention(comment.content, agent.name)) {
+                shouldTrigger = true;
+                triggerType = "mention";
+            }
+            if (!shouldTrigger)
+                continue;
+            // Check if there's already a bot reply after this comment
+            const replies = await client.getPostComments(comment.post_id, {
+                since: comment.created_at,
+                author_type: "bot",
+                limit: 1,
+            });
+            if (replies.data.length === 0) {
+                triggers.push({
+                    triggerType,
+                    eventId: comment.id,
+                    feedId: feed.id,
+                    feedName: feed.name,
+                    postId: comment.post_id,
+                    postTitle: comment.post_title,
+                    content: comment.content,
+                    authorName: comment.author_name,
+                });
+            }
+        }
+    }
+    return triggers;
+}
+function containsMention(text, agentName) {
+    const escaped = agentName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const regex = new RegExp(`@${escaped}\\b`, "i");
+    return regex.test(text);
+}

package/dist/sse-client.d.ts

@@ -0,0 +1,9 @@
+export interface SSEEvent {
+    type: string;
+    data: string;
+    id?: string;
+}
+export interface SSEConnection {
+    close: () => void;
+}
+export declare function connectSSE(url: string, apiKey: string, onEvent: (event: SSEEvent) => void, onError: (error: Error) => void): SSEConnection;

package/dist/sse-client.js

@@ -0,0 +1,60 @@
+export function connectSSE(url, apiKey, onEvent, onError) {
+    let aborted = false;
+    const controller = new AbortController();
+    const run = async () => {
+        while (!aborted) {
+            try {
+                const res = await fetch(url, {
+                    headers: { Authorization: `Bearer ${apiKey}` },
+                    signal: controller.signal,
+                });
+                if (!res.ok || !res.body) {
+                    throw new Error(`SSE connect failed: ${res.status}`);
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let currentEvent = { type: "message", data: "" };
+                while (!aborted) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    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) {
+                                onEvent({ ...currentEvent });
+                            }
+                            currentEvent = { type: "message", data: "" };
+                        }
+                    }
+                }
+            }
+            catch (err) {
+                if (aborted)
+                    return;
+                onError(err instanceof Error ? err : new Error(String(err)));
+                // Reconnect after delay
+                await new Promise((r) => setTimeout(r, 5000));
+            }
+        }
+    };
+    run();
+    return {
+        close: () => {
+            aborted = true;
+            controller.abort();
+        },
+    };
+}

package/dist/trigger.d.ts

@@ -0,0 +1,2 @@
+import type { GlobalEvent, TriggerContext, AgentInfo } from "./types.js";
+export declare function detectTrigger(event: GlobalEvent, agent: AgentInfo): TriggerContext | null;

package/dist/trigger.js

@@ -0,0 +1,52 @@
+export function detectTrigger(event, agent) {
+    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,
+                postTitle: event.post_title,
+                content: event.content,
+                authorName: event.author_name,
+            };
+        }
+        // Trigger 2: @mention in comment
+        if (containsMention(event.content, agent.name)) {
+            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,
+            };
+        }
+    }
+    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)) {
+            return {
+                triggerType: "mention",
+                eventId: event.id,
+                feedId: event.feed_id,
+                feedName: event.feed_name,
+                postId: event.id,
+                postTitle: event.title,
+                content: event.content ?? "",
+                authorName: event.author_name,
+            };
+        }
+    }
+    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

@@ -0,0 +1,69 @@
+export interface AgentInfo {
+    id: string;
+    name: string;
+    type: string;
+}
+export interface GlobalPostEvent {
+    type: "post_created";
+    id: string;
+    feed_id: string;
+    feed_name: string;
+    title: string | null;
+    content: string | null;
+    created_by: string | null;
+    author_name: string | null;
+    created_at: string;
+}
+export interface GlobalCommentEvent {
+    type: "comment_created";
+    id: string;
+    post_id: string;
+    feed_id: string;
+    content: string;
+    author_type: "human" | "bot";
+    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 TriggerContext {
+    triggerType: "own_post_comment" | "mention";
+    eventId: string;
+    feedId: string;
+    feedName: string;
+    postId: string;
+    postTitle: string | null;
+    content: string;
+    authorName: string | null;
+}
+export interface FeedItem {
+    id: string;
+    name: string;
+}
+export interface FeedCommentItem {
+    id: string;
+    post_id: string;
+    content: string;
+    author_type: "human" | "bot";
+    created_by: string | null;
+    author_name: string | null;
+    created_at: string;
+    post_title: string | null;
+    post_created_by: string | null;
+}
+export interface CommentItem {
+    id: string;
+    post_id: string;
+    content: string;
+    author_type: "human" | "bot";
+    created_by: string | null;
+    author_name: string | null;
+    created_at: string;
+}
+export interface PaginatedResponse<T> {
+    data: T[];
+    next_cursor: string | null;
+    has_more: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "agentfeed",
+  "version": "0.1.0",
+  "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
+  "type": "module",
+  "bin": {
+    "agentfeed": "./bin/cli.js"
+  },
+  "files": [
+    "bin/",
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "tsx": "^4",
+    "typescript": "^5"
+  }
+}