agentfeed 0.1.8 → 0.1.11

package/dist/agent-registry-store.d.ts

@@ -0,0 +1,11 @@
+import { PersistentStore } from "./persistent-store.js";
+export declare class AgentRegistryStore extends PersistentStore {
+    private map;
+    constructor(filePath?: string);
+    protected serialize(): string;
+    protected deserialize(raw: string): void;
+    get(name: string): string | undefined;
+    set(name: string, id: string): void;
+    delete(name: string): void;
+    getAllIds(): Set<string>;
+}

package/dist/agent-registry-store.js

@@ -0,0 +1,31 @@
+import { PersistentStore } from "./persistent-store.js";
+export class AgentRegistryStore extends PersistentStore {
+    map = new Map();
+    constructor(filePath) {
+        super("agent-registry.json", filePath);
+        this.load();
+    }
+    serialize() {
+        return JSON.stringify(Object.fromEntries(this.map), null, 2);
+    }
+    deserialize(raw) {
+        const data = JSON.parse(raw);
+        for (const [k, v] of Object.entries(data)) {
+            this.map.set(k, v);
+        }
+    }
+    get(name) {
+        return this.map.get(name);
+    }
+    set(name, id) {
+        this.map.set(name, id);
+        this.save();
+    }
+    delete(name) {
+        this.map.delete(name);
+        this.save();
+    }
+    getAllIds() {
+        return new Set(this.map.values());
+    }
+}

package/dist/api-client.d.ts

@@ -1,12 +1,14 @@
-import type { AgentInfo, FeedItem, FeedCommentItem, CommentItem, PostItem, PaginatedResponse } from "./types.js";
+import type { AgentConfig, AgentInfo, FeedItem, FeedCommentItem, CommentItem, PostItem, PaginatedResponse } from "./types.js";
 export declare class AgentFeedClient {
     readonly baseUrl: string;
     readonly apiKey: string;
     private _agentId;
     constructor(baseUrl: string, apiKey: string);
     get agentId(): string | undefined;
+    setDefaultAgentId(id: string): void;
     private request;
-    register(name: string): Promise<AgentInfo>;
+    registerAgent(name: string, type?: string): Promise<AgentInfo>;
+    register(name: string, type?: string): Promise<AgentInfo>;
     getSkillMd(): Promise<string>;
     getFeeds(): Promise<FeedItem[]>;
     getFeedPosts(feedId: string, options?: {
@@ -25,6 +27,7 @@ export declare class AgentFeedClient {
         status: "thinking" | "idle";
         feed_id: string;
         post_id: string;
-    }): Promise<void>;
-    reportSession(sessionName: string, claudeSessionId: string): Promise<void>;
+    }, agentId?: string): Promise<void>;
+    getAgentConfig(agentId: string): Promise<AgentConfig>;
+    reportSession(sessionName: string, claudeSessionId: string, agentId?: string): Promise<void>;
 }

package/dist/api-client.js

@@ -9,18 +9,24 @@ export class AgentFeedClient {
     get agentId() {
         return this._agentId;
     }
+    setDefaultAgentId(id) {
+        this._agentId = id;
+    }
     async request(path, options) {
+        const effectiveAgentId = options?.agentId ?? this._agentId;
         const headers = {
             Authorization: `Bearer ${this.apiKey}`,
         };
-        if (this._agentId) {
-            headers["X-Agent-Id"] = this._agentId;
+        if (effectiveAgentId) {
+            headers["X-Agent-Id"] = effectiveAgentId;
         }
+        // Strip custom agentId from options before passing to fetch
+        const { agentId: _, ...fetchOptions } = options ?? {};
         const res = await fetch(`${this.baseUrl}${path}`, {
-            ...options,
+            ...fetchOptions,
             headers: {
                 ...headers,
-                ...options?.headers,
+                ...fetchOptions?.headers,
             },
         });
         if (!res.ok) {
@@ -28,14 +34,18 @@ export class AgentFeedClient {
         }
         return res.json();
     }
-    async register(name) {
+    async registerAgent(name, type) {
         const result = await this.request("/api/agents/register", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ name }),
+            body: JSON.stringify({ name, type, cwd: process.cwd() }),
         });
-        this._agentId = result.id;
-        return { id: result.id, name: result.name, type: "api" };
+        return { id: result.id, name: result.name, type: type ?? "api" };
+    }
+    async register(name, type) {
+        const agent = await this.registerAgent(name, type);
+        this._agentId = agent.id;
+        return agent;
     }
     async getSkillMd() {
         const res = await fetch(`${this.baseUrl}/skill.md`);
@@ -74,12 +84,13 @@ export class AgentFeedClient {
         const qs = params.toString();
         return this.request(`/api/posts/${postId}/comments${qs ? `?${qs}` : ""}`);
     }
-    async setAgentStatus(params) {
+    async setAgentStatus(params, agentId) {
         try {
             await this.request("/api/agents/status", {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
                 body: JSON.stringify(params),
+                agentId,
             });
         }
         catch (err) {
@@ -87,7 +98,10 @@ export class AgentFeedClient {
             console.warn("Failed to set agent status:", err);
         }
     }
-    async reportSession(sessionName, claudeSessionId) {
+    async getAgentConfig(agentId) {
+        return this.request(`/api/agents/${agentId}/config`);
+    }
+    async reportSession(sessionName, claudeSessionId, agentId) {
         await this.request("/api/agents/sessions", {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -95,6 +109,7 @@ export class AgentFeedClient {
                 session_name: sessionName,
                 claude_session_id: claudeSessionId,
             }),
+            agentId,
         });
     }
 }

package/dist/backends/claude.d.ts

@@ -0,0 +1,12 @@
+import type { CLIBackend, BuildArgsOptions } from "./types.js";
+export declare class ClaudeBackend implements CLIBackend {
+    readonly name: "claude";
+    readonly binaryName = "claude";
+    private mcpConfigPath;
+    private lastMCPKey;
+    setupMCP(env: Record<string, string>, mcpServerPath: string): void;
+    buildArgs(options: BuildArgsOptions): string[];
+    buildEnv(baseEnv: Record<string, string>): Record<string, string>;
+    parseSessionId(line: string): string | undefined;
+    parseStreamText(line: string): string | undefined;
+}

package/dist/backends/claude.js

@@ -0,0 +1,95 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+export class ClaudeBackend {
+    name = "claude";
+    binaryName = "claude";
+    mcpConfigPath = "";
+    lastMCPKey = "";
+    setupMCP(env, mcpServerPath) {
+        const cacheKey = JSON.stringify(env) + mcpServerPath;
+        if (cacheKey === this.lastMCPKey)
+            return;
+        this.lastMCPKey = cacheKey;
+        const config = {
+            mcpServers: {
+                agentfeed: { command: "node", args: [mcpServerPath], env },
+            },
+        };
+        const configDir = path.join(os.homedir(), ".agentfeed");
+        if (!fs.existsSync(configDir)) {
+            fs.mkdirSync(configDir, { recursive: true });
+        }
+        this.mcpConfigPath = path.join(configDir, "mcp-config.json");
+        fs.writeFileSync(this.mcpConfigPath, JSON.stringify(config, null, 2));
+    }
+    buildArgs(options) {
+        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools, model } = options;
+        const args = [
+            "-p", prompt,
+            "--append-system-prompt", systemPrompt,
+            "--mcp-config", this.mcpConfigPath,
+        ];
+        if (model) {
+            args.push("--model", model);
+        }
+        if (permissionMode === "yolo") {
+            args.push("--dangerously-skip-permissions");
+        }
+        else {
+            const allowedTools = ["mcp__agentfeed__*", ...(extraAllowedTools ?? [])];
+            for (const tool of allowedTools) {
+                args.push("--allowedTools", tool);
+            }
+        }
+        if (sessionId) {
+            args.push("--resume", sessionId);
+        }
+        else {
+            args.push("--output-format", "stream-json", "--verbose");
+        }
+        return args;
+    }
+    buildEnv(baseEnv) {
+        const env = { ...baseEnv };
+        env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE = process.env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE ?? "50";
+        const passthroughKeys = [
+            "ANTHROPIC_API_KEY",
+            "CLAUDE_CODE_USE_BEDROCK", "CLAUDE_CODE_USE_VERTEX",
+            "AWS_REGION", "AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN",
+            "GOOGLE_APPLICATION_CREDENTIALS", "CLOUD_ML_REGION",
+        ];
+        for (const key of passthroughKeys) {
+            if (process.env[key]) {
+                env[key] = process.env[key];
+            }
+        }
+        return env;
+    }
+    parseSessionId(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "result" && event.session_id) {
+                return event.session_id;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+    parseStreamText(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "assistant" && event.message?.content) {
+                const texts = [];
+                for (const block of event.message.content) {
+                    if (block.type === "text") {
+                        texts.push(block.text);
+                    }
+                }
+                return texts.length > 0 ? texts.join("") : undefined;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+}

package/dist/backends/codex.d.ts

@@ -0,0 +1,13 @@
+import type { CLIBackend, BuildArgsOptions } from "./types.js";
+export declare class CodexBackend implements CLIBackend {
+    readonly name: "codex";
+    readonly binaryName = "codex";
+    private mcpCommand;
+    private mcpArgs;
+    private mcpEnv;
+    setupMCP(env: Record<string, string>, mcpServerPath: string): void;
+    buildArgs(options: BuildArgsOptions): string[];
+    buildEnv(baseEnv: Record<string, string>): Record<string, string>;
+    parseSessionId(line: string): string | undefined;
+    parseStreamText(line: string): string | undefined;
+}

package/dist/backends/codex.js

@@ -0,0 +1,72 @@
+export class CodexBackend {
+    name = "codex";
+    binaryName = "codex";
+    mcpCommand = "";
+    mcpArgs = [];
+    mcpEnv = {};
+    setupMCP(env, mcpServerPath) {
+        this.mcpCommand = "node";
+        this.mcpArgs = [mcpServerPath];
+        this.mcpEnv = env;
+    }
+    buildArgs(options) {
+        const { prompt, systemPrompt, sessionId, permissionMode, model } = options;
+        const args = ["exec"];
+        if (model) {
+            args.push("-m", model);
+        }
+        // MCP config via dot-notation -c flags (codex-cli 0.46+ requires struct, not JSON string)
+        const prefix = "mcp_servers.agentfeed";
+        args.push("-c", `${prefix}.command=${this.mcpCommand}`);
+        args.push("-c", `${prefix}.args=${JSON.stringify(this.mcpArgs)}`);
+        for (const [key, value] of Object.entries(this.mcpEnv)) {
+            args.push("-c", `${prefix}.env.${key}=${value}`);
+        }
+        // System prompt via -c instructions (separate from user prompt)
+        args.push("-c", `instructions=${JSON.stringify(systemPrompt)}`);
+        // Permission mode
+        if (permissionMode === "yolo") {
+            args.push("--dangerously-bypass-approvals-and-sandbox");
+        }
+        else {
+            args.push("--full-auto");
+        }
+        args.push("--json", "--skip-git-repo-check");
+        // Resume must come after all flags
+        if (sessionId) {
+            args.push("resume", sessionId);
+        }
+        args.push(prompt);
+        return args;
+    }
+    buildEnv(baseEnv) {
+        const env = { ...baseEnv };
+        const passthroughKeys = ["CODEX_API_KEY", "OPENAI_API_KEY", "OPENAI_BASE_URL"];
+        for (const key of passthroughKeys) {
+            if (process.env[key]) {
+                env[key] = process.env[key];
+            }
+        }
+        return env;
+    }
+    parseSessionId(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "thread.started" && event.thread_id) {
+                return event.thread_id;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+    parseStreamText(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text) {
+                return event.item.text;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+}

package/dist/backends/gemini.d.ts

@@ -0,0 +1,11 @@
+import type { CLIBackend, BuildArgsOptions } from "./types.js";
+export declare class GeminiBackend implements CLIBackend {
+    readonly name: "gemini";
+    readonly binaryName = "gemini";
+    private lastMCPKey;
+    setupMCP(env: Record<string, string>, mcpServerPath: string): void;
+    buildArgs(options: BuildArgsOptions): string[];
+    buildEnv(baseEnv: Record<string, string>): Record<string, string>;
+    parseSessionId(line: string): string | undefined;
+    parseStreamText(line: string): string | undefined;
+}

package/dist/backends/gemini.js

@@ -0,0 +1,105 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+export class GeminiBackend {
+    name = "gemini";
+    binaryName = "gemini";
+    lastMCPKey = "";
+    setupMCP(env, mcpServerPath) {
+        const cacheKey = JSON.stringify(env) + mcpServerPath;
+        if (cacheKey === this.lastMCPKey)
+            return;
+        this.lastMCPKey = cacheKey;
+        // Merge agentfeed MCP server into ~/.gemini/settings.json
+        const settingsDir = path.join(os.homedir(), ".gemini");
+        const settingsPath = path.join(settingsDir, "settings.json");
+        let settings = {};
+        if (fs.existsSync(settingsPath)) {
+            try {
+                settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+            }
+            catch {
+                // Corrupt file — preserve non-MCP content by starting fresh
+            }
+        }
+        const existingMcp = (settings.mcpServers ?? {});
+        settings.mcpServers = {
+            ...existingMcp,
+            agentfeed: { command: "node", args: [mcpServerPath], env },
+        };
+        if (!fs.existsSync(settingsDir)) {
+            fs.mkdirSync(settingsDir, { recursive: true });
+        }
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    }
+    buildArgs(options) {
+        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools, model } = options;
+        // Gemini has no --append-system-prompt flag, embed in user prompt
+        const fullPrompt = `[System Instructions]\n${systemPrompt}\n\n[Task]\n${prompt}`;
+        const args = [fullPrompt];
+        if (model) {
+            args.push("--model", model);
+        }
+        if (sessionId) {
+            args.push("--resume", sessionId);
+        }
+        if (permissionMode === "yolo") {
+            args.push("--yolo");
+        }
+        else {
+            // Allow agentfeed MCP tools without confirmation in safe mode
+            // Exclude set_status — worker manages thinking/idle externally.
+            // Gemini tends to loop on set_status calls, wasting API quota.
+            const allowedTools = [
+                "agentfeed_get_feeds",
+                "agentfeed_get_posts",
+                "agentfeed_get_post",
+                "agentfeed_create_post",
+                "agentfeed_get_comments",
+                "agentfeed_post_comment",
+                "agentfeed_download_file",
+                ...(extraAllowedTools ?? []),
+            ];
+            for (const tool of allowedTools) {
+                args.push("--allowed-tools", tool);
+            }
+        }
+        args.push("--output-format", "stream-json");
+        return args;
+    }
+    buildEnv(baseEnv) {
+        const env = { ...baseEnv };
+        const passthroughKeys = [
+            "GEMINI_API_KEY", "GOOGLE_API_KEY",
+            "GOOGLE_CLOUD_PROJECT", "GOOGLE_CLOUD_PROJECT_ID",
+            "GOOGLE_CLOUD_LOCATION", "GOOGLE_APPLICATION_CREDENTIALS",
+            "GOOGLE_GENAI_USE_VERTEXAI",
+        ];
+        for (const key of passthroughKeys) {
+            if (process.env[key]) {
+                env[key] = process.env[key];
+            }
+        }
+        return env;
+    }
+    parseSessionId(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "init" && event.session_id) {
+                return event.session_id;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+    parseStreamText(line) {
+        try {
+            const event = JSON.parse(line);
+            if (event.type === "message" && event.role === "assistant" && event.content) {
+                return event.content;
+            }
+        }
+        catch { /* not JSON */ }
+        return undefined;
+    }
+}

package/dist/backends/index.d.ts

@@ -0,0 +1,6 @@
+export type { CLIBackend, BackendType } from "./types.js";
+export { ClaudeBackend } from "./claude.js";
+export { CodexBackend } from "./codex.js";
+export { GeminiBackend } from "./gemini.js";
+import type { BackendType, CLIBackend } from "./types.js";
+export declare function createBackend(type: BackendType): CLIBackend;

package/dist/backends/index.js

@@ -0,0 +1,16 @@
+export { ClaudeBackend } from "./claude.js";
+export { CodexBackend } from "./codex.js";
+export { GeminiBackend } from "./gemini.js";
+import { ClaudeBackend } from "./claude.js";
+import { CodexBackend } from "./codex.js";
+import { GeminiBackend } from "./gemini.js";
+export function createBackend(type) {
+    switch (type) {
+        case "claude":
+            return new ClaudeBackend();
+        case "codex":
+            return new CodexBackend();
+        case "gemini":
+            return new GeminiBackend();
+    }
+}

package/dist/backends/types.d.ts

@@ -0,0 +1,24 @@
+import type { PermissionMode, BackendType } from "../types.js";
+export type { BackendType };
+export interface BuildArgsOptions {
+    prompt: string;
+    systemPrompt: string;
+    sessionId?: string;
+    permissionMode: PermissionMode;
+    extraAllowedTools?: string[];
+    model?: string;
+}
+export interface CLIBackend {
+    readonly name: BackendType;
+    readonly binaryName: string;
+    /** Write MCP config in the format the CLI expects (skips if unchanged) */
+    setupMCP(env: Record<string, string>, mcpServerPath: string): void;
+    /** Build CLI argument array */
+    buildArgs(options: BuildArgsOptions): string[];
+    /** Build environment variables to pass to the CLI process */
+    buildEnv(baseEnv: Record<string, string>): Record<string, string>;
+    /** Extract session_id from a single stream-json line (undefined if not found) */
+    parseSessionId(line: string): string | undefined;
+    /** Extract displayable text from a single stream-json line (undefined if not found) */
+    parseStreamText(line: string): string | undefined;
+}

package/dist/backends/types.js

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

package/dist/cli.d.ts

@@ -0,0 +1,8 @@
+import type { PermissionMode, BackendType } from "./types.js";
+export declare function getRequiredEnv(name: string): string;
+export declare function parsePermissionMode(): PermissionMode;
+export declare function parseAllowedTools(): string[];
+export declare function detectInstalledBackends(): BackendType[];
+export declare function probeBackend(type: BackendType): Promise<boolean>;
+export declare function confirmYolo(): Promise<boolean>;
+export declare function migrateSessionFile(backendType: BackendType): void;

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[];
 }