agentfeed 0.1.7 → 0.1.10

package/bin/mcp-server.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+import { AgentFeedClient } from "../dist/api-client.js";
+import { startMCPServer } from "../dist/mcp-server.js";
+
+const serverUrl = process.env.AGENTFEED_BASE_URL?.replace(/\/api$/, "") || "http://localhost:3000";
+const apiKey = process.env.AGENTFEED_API_KEY;
+
+if (!apiKey) {
+  console.error("AGENTFEED_API_KEY environment variable is required");
+  process.exit(1);
+}
+
+const client = new AgentFeedClient(serverUrl, apiKey);
+
+// Set agent ID if provided
+if (process.env.AGENTFEED_AGENT_ID) {
+  client["_agentId"] = process.env.AGENTFEED_AGENT_ID;
+}
+
+startMCPServer({ client, serverUrl });

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,10 +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 {
-    private baseUrl;
-    private apiKey;
+    readonly baseUrl: string;
+    readonly apiKey: string;
+    private _agentId;
     constructor(baseUrl: string, apiKey: string);
+    get agentId(): string | undefined;
+    setDefaultAgentId(id: string): void;
     private request;
-    getMe(): 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?: {
@@ -23,5 +27,7 @@ export declare class AgentFeedClient {
         status: "thinking" | "idle";
         feed_id: string;
         post_id: 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

@@ -1,16 +1,32 @@
 export class AgentFeedClient {
     baseUrl;
     apiKey;
+    _agentId;
     constructor(baseUrl, apiKey) {
         this.baseUrl = baseUrl;
         this.apiKey = apiKey;
     }
+    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 (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: {
-                Authorization: `Bearer ${this.apiKey}`,
-                ...options?.headers,
+                ...headers,
+                ...fetchOptions?.headers,
             },
         });
         if (!res.ok) {
@@ -18,8 +34,18 @@ export class AgentFeedClient {
         }
         return res.json();
     }
-    async getMe() {
-        return this.request("/api/auth/me");
+    async registerAgent(name, type) {
+        const result = await this.request("/api/agents/register", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ name, type, cwd: process.cwd() }),
+        });
+        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`);
@@ -58,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) {
@@ -71,4 +98,18 @@ export class AgentFeedClient {
             console.warn("Failed to set agent status:", err);
         }
     }
+    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" },
+            body: JSON.stringify({
+                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,92 @@
+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 } = options;
+        const args = [
+            "-p", prompt,
+            "--append-system-prompt", systemPrompt,
+            "--mcp-config", this.mcpConfigPath,
+        ];
+        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,69 @@
+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 } = options;
+        const args = ["exec"];
+        // 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,102 @@
+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 } = 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 (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,23 @@
+import type { PermissionMode, BackendType } from "../types.js";
+export type { BackendType };
+export interface BuildArgsOptions {
+    prompt: string;
+    systemPrompt: string;
+    sessionId?: string;
+    permissionMode: PermissionMode;
+    extraAllowedTools?: 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;