agentfeed 0.1.7 → 0.1.10

package/dist/cli.js

@@ -0,0 +1,129 @@
+import * as path from "node:path";
+import * as readline from "node:readline";
+import { execFileSync, spawn } from "node:child_process";
+import { existsSync, copyFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { createBackend } from "./backends/index.js";
+const ALL_BACKEND_TYPES = ["claude", "codex", "gemini"];
+const PROBE_TIMEOUT_MS = 10_000;
+export function getRequiredEnv(name) {
+    const value = process.env[name];
+    if (!value) {
+        console.error(`Required environment variable: ${name}`);
+        process.exit(1);
+    }
+    return value;
+}
+export 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);
+}
+export 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;
+}
+export function detectInstalledBackends() {
+    return ALL_BACKEND_TYPES.filter((type) => {
+        const backend = createBackend(type);
+        try {
+            execFileSync("which", [backend.binaryName], { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+export function probeBackend(type) {
+    const backend = createBackend(type);
+    // Minimal args to trigger auth check without heavy work
+    let args;
+    switch (type) {
+        case "claude":
+            args = ["-p", "say ok", "--output-format", "stream-json", "--max-turns", "1"];
+            break;
+        case "gemini":
+            args = ["say ok", "--output-format", "stream-json"];
+            break;
+        case "codex":
+            args = ["exec", "--json", "--skip-git-repo-check", "--full-auto", "say ok"];
+            break;
+    }
+    const env = backend.buildEnv({
+        PATH: process.env.PATH ?? "",
+        HOME: process.env.HOME ?? "",
+        USER: process.env.USER ?? "",
+        SHELL: process.env.SHELL ?? "/bin/sh",
+        LANG: process.env.LANG ?? "en_US.UTF-8",
+        TERM: process.env.TERM ?? "xterm-256color",
+    });
+    return new Promise((resolve) => {
+        try {
+            const proc = spawn(backend.binaryName, args, { env, stdio: "pipe" });
+            const timer = setTimeout(() => {
+                // Still alive after timeout = authenticated (API call in progress)
+                proc.kill("SIGTERM");
+                resolve(true);
+            }, PROBE_TIMEOUT_MS);
+            proc.on("error", () => {
+                clearTimeout(timer);
+                resolve(false);
+            });
+            proc.on("close", (code) => {
+                clearTimeout(timer);
+                // Quick exit with 0 = completed ok, non-zero = auth/config failure
+                resolve(code === 0);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+export 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");
+        });
+    });
+}
+export function migrateSessionFile(backendType) {
+    const dir = path.join(homedir(), ".agentfeed");
+    const legacyPath = path.join(dir, "sessions.json");
+    const newPath = path.join(dir, `sessions-${backendType}.json`);
+    if (!existsSync(newPath) && existsSync(legacyPath)) {
+        try {
+            copyFileSync(legacyPath, newPath);
+            console.log(`Migrated sessions.json → sessions-${backendType}.json`);
+        }
+        catch (err) {
+            console.warn(`Failed to migrate session file:`, err);
+        }
+    }
+}

package/dist/follow-store.d.ts

@@ -5,6 +5,7 @@ export declare class FollowStore extends PersistentStore {
     protected serialize(): string;
     protected deserialize(raw: string): void;
     has(postId: string): boolean;
+    private static readonly MAX_SIZE;
     add(postId: string): void;
     getAll(): string[];
 }

package/dist/follow-store.js

@@ -17,10 +17,22 @@ export class FollowStore extends PersistentStore {
     has(postId) {
         return this.posts.has(postId);
     }
+    static MAX_SIZE = 500;
     add(postId) {
         if (this.posts.has(postId))
             return;
         this.posts.add(postId);
+        // Evict oldest entries if over limit
+        if (this.posts.size > FollowStore.MAX_SIZE) {
+            const iter = this.posts.values();
+            while (this.posts.size > FollowStore.MAX_SIZE) {
+                const oldest = iter.next().value;
+                if (oldest !== undefined)
+                    this.posts.delete(oldest);
+                else
+                    break;
+            }
+        }
         this.save();
     }
     getAll() {

package/dist/index.js

@@ -1,74 +1,31 @@
-import * as readline from "node:readline";
+import * as path from "node:path";
+import { homedir } from "node:os";
 import { AgentFeedClient } from "./api-client.js";
 import { connectSSE } from "./sse-client.js";
-import { detectTrigger } from "./trigger.js";
-import { invokeAgent } from "./invoker.js";
+import { detectTriggers } from "./trigger.js";
 import { scanUnprocessed } from "./scanner.js";
 import { SessionStore } from "./session-store.js";
 import { FollowStore } from "./follow-store.js";
 import { QueueStore } from "./queue-store.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;
-}
-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");
-        });
-    });
-}
+import { PostSessionStore } from "./post-session-store.js";
+import { AgentRegistryStore } from "./agent-registry-store.js";
+import { createBackend } from "./backends/index.js";
+import { handleTriggers } from "./processor.js";
+import { getRequiredEnv, parsePermissionMode, parseAllowedTools, detectInstalledBackends, probeBackend, confirmYolo, migrateSessionFile, } from "./cli.js";
 const serverUrl = getRequiredEnv("AGENTFEED_URL");
 const apiKey = getRequiredEnv("AGENTFEED_API_KEY");
 const permissionMode = parsePermissionMode();
 const extraAllowedTools = parseAllowedTools();
+const baseName = process.env.AGENTFEED_AGENT_NAME ?? path.basename(process.cwd());
 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);
+const agentRegistry = new AgentRegistryStore(process.env.AGENTFEED_AGENT_REGISTRY_FILE);
+// Populated during init
+const backendAgentMap = new Map();
+let backendAgents = [];
 function shutdown() {
     console.log("\nShutting down...");
     sseConnection?.close();
@@ -76,6 +33,44 @@ function shutdown() {
 }
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);
+function isNamedSession(sessionName) {
+    // Named Sessions are explicitly created via @bot/session-name mentions.
+    // PostId-based sessions (ps_xxx) are internal CLI session tracking — not separate agents.
+    return sessionName !== "default" && !sessionName.startsWith("ps_");
+}
+async function ensureSessionAgent(sessionName, agentName, backendType) {
+    // Only Named Sessions get their own agent identity
+    if (!isNamedSession(sessionName)) {
+        const ba = backendAgentMap.get(backendType);
+        return ba?.agent.id ?? client.agentId;
+    }
+    const fullName = `${agentName}/${sessionName}`;
+    // Check registry first
+    const cachedId = agentRegistry.get(fullName);
+    if (cachedId)
+        return cachedId;
+    // Register a new session-agent
+    console.log(`Registering session agent: ${fullName}`);
+    const sessionAgent = await client.registerAgent(fullName, backendType);
+    agentRegistry.set(fullName, sessionAgent.id);
+    return sessionAgent.id;
+}
+function getProcessorDeps() {
+    return {
+        client,
+        apiKey,
+        serverUrl,
+        permissionMode,
+        extraAllowedTools,
+        backendAgentMap,
+        backendAgents,
+        followStore,
+        queueStore,
+        postSessionStore,
+        agentRegistry,
+        ensureSessionAgent,
+    };
+}
 async function main() {
     // Confirm yolo mode
     if (permissionMode === "yolo") {
@@ -85,36 +80,128 @@ async function main() {
             process.exit(0);
         }
     }
+    // Auto-detect installed backends and probe auth
+    const installedBackends = detectInstalledBackends();
+    if (installedBackends.length === 0) {
+        console.error("No supported CLI backends found. Install one of: claude, codex, gemini");
+        process.exit(1);
+    }
+    console.log(`Installed backends: ${installedBackends.join(", ")}. Probing auth...`);
+    const availableBackends = [];
+    for (const type of installedBackends) {
+        const ok = await probeBackend(type);
+        if (ok) {
+            availableBackends.push(type);
+            console.log(`  ${type}: ✓ authenticated`);
+        }
+        else {
+            console.log(`  ${type}: ✗ not authenticated, skipping`);
+        }
+    }
+    if (availableBackends.length === 0) {
+        console.error("No authenticated backends found. Please log in to at least one CLI.");
+        process.exit(1);
+    }
     const toolsInfo = extraAllowedTools.length > 0
         ? ` + ${extraAllowedTools.join(", ")}`
         : "";
-    console.log(`AgentFeed Worker starting... (permission: ${permissionMode}${toolsInfo})`);
-    // 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.");
+    console.log(`AgentFeed Worker starting... (backends: ${availableBackends.join(", ")}, permission: ${permissionMode}${toolsInfo})`);
+    // Register an agent for each available backend
+    for (const type of availableBackends) {
+        // Migrate legacy session file for first backend (usually claude)
+        migrateSessionFile(type);
+        const backend = createBackend(type);
+        const agentName = `${baseName}/${type}`;
+        const agent = await client.registerAgent(agentName, type);
+        if (!client.agentId)
+            client.setDefaultAgentId(agent.id);
+        const sessionStore = new SessionStore(path.join(homedir(), ".agentfeed", `sessions-${type}.json`));
+        const ba = { backendType: type, backend, agent, sessionStore };
+        // Fetch per-agent config from server (permission_mode, allowed_tools)
+        try {
+            const config = await client.getAgentConfig(agent.id);
+            ba.config = config;
+            console.log(`Agent: ${agent.name} (${agent.id}) [${type}] (server config: ${config.permission_mode}, tools: ${config.allowed_tools.length})`);
+        }
+        catch {
+            console.log(`Agent: ${agent.name} (${agent.id}) [${type}] (using CLI defaults)`);
+        }
+        backendAgentMap.set(type, ba);
+        agentRegistry.set(agentName, agent.id);
+    }
+    backendAgents = Array.from(backendAgentMap.values());
+    // Confirm yolo if any server config overrides to yolo (and CLI didn't already confirm)
+    if (permissionMode !== "yolo") {
+        const hasServerYolo = backendAgents.some((ba) => ba.config?.permission_mode === "yolo");
+        if (hasServerYolo) {
+            console.log("\nServer config has yolo permission for one or more agents.");
+            const confirmed = await confirmYolo();
+            if (!confirmed) {
+                console.log("Cancelled. Update agent permissions on the server to use safe mode.");
+                process.exit(0);
+            }
+        }
+    }
+    // Register Named Session agents for all backends
+    for (const ba of backendAgents) {
+        const namedSessions = ba.sessionStore.keys().filter(isNamedSession);
+        for (const sessionName of namedSessions) {
+            try {
+                await ensureSessionAgent(sessionName, ba.agent.name, ba.backendType);
+            }
+            catch (err) {
+                console.warn(`Failed to register session agent ${ba.agent.name}/${sessionName}:`, err);
+            }
+        }
+        if (namedSessions.length > 0) {
+            console.log(`Registered ${namedSessions.length} named session agent(s) for ${ba.backendType}`);
+        }
+    }
+    const deps = getProcessorDeps();
     // Step 1: Startup scan for unprocessed items
     console.log("Scanning for unprocessed items...");
-    const unprocessed = await scanUnprocessed(client, agent, followStore);
+    const ownAgentIds = agentRegistry.getAllIds();
+    const unprocessed = await scanUnprocessed(client, backendAgents, followStore, postSessionStore, ownAgentIds);
     if (unprocessed.length > 0) {
         console.log(`Found ${unprocessed.length} unprocessed item(s)`);
-        await handleTriggers(unprocessed, agent, skillMd);
+        handleTriggers(unprocessed, deps);
     }
     else {
         console.log("No unprocessed items found.");
     }
     // Step 2: Connect to global SSE stream
-    const sseUrl = `${serverUrl}/api/events/stream?author_type=human`;
+    const sseUrl = `${serverUrl}/api/events/stream`;
     console.log("Connecting to global event stream...");
-    sseConnection = connectSSE(sseUrl, apiKey, (rawEvent) => {
+    // Collect all backend agent IDs for online tracking via single SSE connection
+    const allAgentIds = backendAgents.map((ba) => ba.agent.id);
+    sseConnection = connectSSE(sseUrl, apiKey, allAgentIds, (rawEvent) => {
         if (rawEvent.type === "heartbeat")
             return;
+        // Handle session_deleted events directly
+        if (rawEvent.type === "session_deleted") {
+            try {
+                const data = JSON.parse(rawEvent.data);
+                const allIds = agentRegistry.getAllIds();
+                if (allIds.has(data.agent_id)) {
+                    // Delete from all backend session stores
+                    for (const ba of backendAgents) {
+                        ba.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, followStore);
-            if (trigger) {
-                handleTriggers([trigger], agent, skillMd);
+            const currentOwnIds = agentRegistry.getAllIds();
+            const triggers = detectTriggers(event, backendAgents, followStore, postSessionStore, currentOwnIds);
+            if (triggers.length > 0) {
+                handleTriggers(triggers, deps);
             }
         }
         catch (err) {
@@ -125,130 +212,6 @@ async function main() {
     });
     console.log("Worker ready. Listening for events...");
 }
-async function handleTriggers(triggers, agent, skillMd) {
-    // 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;
-    // Process queue until empty
-    await processQueue(agent, skillMd);
-}
-async function processQueue(agent, skillMd) {
-    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);
-        }
-        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}`);
-        // Report thinking status
-        await client.setAgentStatus({
-            status: "thinking",
-            feed_id: trigger.feedId,
-            post_id: trigger.postId,
-        });
-        let retries = 0;
-        let success = false;
-        try {
-            while (retries < MAX_CRASH_RETRIES) {
-                try {
-                    const result = await invokeAgent({
-                        agent,
-                        trigger,
-                        skillMd,
-                        apiKey,
-                        serverUrl,
-                        recentContext,
-                        permissionMode,
-                        extraAllowedTools,
-                        sessionId: sessionStore.get(trigger.postId),
-                    });
-                    if (result.sessionId) {
-                        sessionStore.set(trigger.postId, result.sessionId);
-                    }
-                    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.postId)) {
-                        console.log("Session may be stale, clearing and retrying as new session...");
-                        sessionStore.delete(trigger.postId);
-                    }
-                    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`);
-            }
-        }
-        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 agent2 = await client.getMe();
-            const newUnprocessed = await scanUnprocessed(client, agent2, followStore);
-            for (const t of newUnprocessed) {
-                queueStore.push(t);
-            }
-            if (newUnprocessed.length > 0) {
-                console.log(`Post-completion scan: ${newUnprocessed.length} item(s) added to queue`);
-            }
-        }
-        catch (err) {
-            console.error("Post-completion scan error:", err);
-        }
-        // Loop continues to process next item in queue
-    }
-}
-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

@@ -1,18 +1,19 @@
 import type { TriggerContext, AgentInfo, PermissionMode } from "./types.js";
-interface InvokeOptions {
+import type { CLIBackend } from "./backends/index.js";
+export interface InvokeOptions {
     agent: AgentInfo;
     trigger: TriggerContext;
-    skillMd: string;
     apiKey: string;
     serverUrl: string;
     recentContext: string;
     permissionMode: PermissionMode;
     extraAllowedTools?: string[];
     sessionId?: string;
+    agentId?: string;
+    timeoutMs?: number;
 }
-interface InvokeResult {
+export interface InvokeResult {
     exitCode: number;
     sessionId?: string;
 }
-export declare function invokeAgent(options: InvokeOptions): Promise<InvokeResult>;
-export {};
+export declare function invokeAgent(backend: CLIBackend, options: InvokeOptions): Promise<InvokeResult>;