agentfeed 0.1.10 → 0.1.12

package/dist/backends/claude.js

@@ -24,17 +24,26 @@ export class ClaudeBackend {
         fs.writeFileSync(this.mcpConfigPath, JSON.stringify(config, null, 2));
     }
     buildArgs(options) {
-        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools } = options;
+        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools, model, chrome } = options;
         const args = [
             "-p", prompt,
             "--append-system-prompt", systemPrompt,
             "--mcp-config", this.mcpConfigPath,
         ];
+        if (model) {
+            args.push("--model", model);
+        }
+        if (chrome) {
+            args.push("--chrome");
+        }
         if (permissionMode === "yolo") {
             args.push("--dangerously-skip-permissions");
         }
         else {
             const allowedTools = ["mcp__agentfeed__*", ...(extraAllowedTools ?? [])];
+            if (chrome) {
+                allowedTools.push("mcp__claude-in-chrome__*");
+            }
             for (const tool of allowedTools) {
                 args.push("--allowedTools", tool);
             }

package/dist/backends/codex.js

@@ -10,8 +10,11 @@ export class CodexBackend {
         this.mcpEnv = env;
     }
     buildArgs(options) {
-        const { prompt, systemPrompt, sessionId, permissionMode } = 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}`);

package/dist/backends/gemini.js

@@ -33,10 +33,13 @@ export class GeminiBackend {
         fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     }
     buildArgs(options) {
-        const { prompt, systemPrompt, sessionId, permissionMode, extraAllowedTools } = 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);
         }

package/dist/backends/types.d.ts

@@ -6,6 +6,8 @@ export interface BuildArgsOptions {
     sessionId?: string;
     permissionMode: PermissionMode;
     extraAllowedTools?: string[];
+    model?: string;
+    chrome?: boolean;
 }
 export interface CLIBackend {
     readonly name: BackendType;

package/dist/cli.js

@@ -100,6 +100,16 @@ export function probeBackend(type) {
     });
 }
 export function confirmYolo() {
+    // --yes flag skips the interactive confirmation
+    if (process.argv.includes("--yes") || process.argv.includes("-y")) {
+        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("");
+        console.log("  Continue? (y/N): y (auto-confirmed via --yes)");
+        return Promise.resolve(true);
+    }
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
         console.log("");

package/dist/index.js

@@ -121,7 +121,8 @@ async function main() {
         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})`);
+            const modelLabel = config.model ? `, model: ${config.model}` : "";
+            console.log(`Agent: ${agent.name} (${agent.id}) [${type}] (server config: ${config.permission_mode}, tools: ${config.allowed_tools.length}${modelLabel})`);
         }
         catch {
             console.log(`Agent: ${agent.name} (${agent.id}) [${type}] (using CLI defaults)`);

package/dist/invoker.d.ts

@@ -8,6 +8,8 @@ export interface InvokeOptions {
     recentContext: string;
     permissionMode: PermissionMode;
     extraAllowedTools?: string[];
+    model?: string;
+    chrome?: boolean;
     sessionId?: string;
     agentId?: string;
     timeoutMs?: number;
@@ -15,5 +17,6 @@ export interface InvokeOptions {
 export interface InvokeResult {
     exitCode: number;
     sessionId?: string;
+    timedOut: boolean;
 }
 export declare function invokeAgent(backend: CLIBackend, options: InvokeOptions): Promise<InvokeResult>;

package/dist/invoker.js

@@ -41,6 +41,8 @@ export function invokeAgent(backend, options) {
             sessionId: options.sessionId,
             permissionMode: options.permissionMode,
             extraAllowedTools: options.extraAllowedTools,
+            model: options.model,
+            chrome: options.chrome,
         });
         const env = backend.buildEnv({
             ...agentfeedEnv,
@@ -54,12 +56,14 @@ export function invokeAgent(backend, options) {
         console.log(`Invoking ${backend.name}...`);
         const child = spawn(backend.binaryName, args, {
             env,
-            stdio: isNewSession ? ["inherit", "pipe", "inherit"] : "inherit",
+            stdio: isNewSession ? ["ignore", "pipe", "inherit"] : ["ignore", "inherit", "inherit"],
         });
         // Timeout watchdog
         let killTimer = null;
+        let timedOut = false;
         if (options.timeoutMs) {
             killTimer = setTimeout(() => {
+                timedOut = true;
                 console.warn(`Agent timed out after ${options.timeoutMs / 1000}s, killing process...`);
                 child.kill("SIGTERM");
                 setTimeout(() => { if (!child.killed)
@@ -103,7 +107,7 @@ export function invokeAgent(backend, options) {
             if (isNewSession)
                 process.stdout.write("\n");
             console.log(`Agent exited (code ${code ?? "unknown"})`);
-            resolve({ exitCode: code ?? 1, sessionId: sessionId ?? options.sessionId });
+            resolve({ exitCode: code ?? 1, sessionId: sessionId ?? options.sessionId, timedOut });
         });
     });
 }
@@ -137,7 +141,15 @@ function buildSystemPrompt(options) {
 - agentfeed_create_post - Create a new post in a feed
 - agentfeed_get_comments - Get comments on a post (use since/author_type filters)
 - agentfeed_post_comment - Post a comment (Korean and emoji supported!)
-- agentfeed_download_file - Download and view uploaded files (images, etc.)${statusTool}`;
+- agentfeed_download_file - Download and view uploaded files (images, etc.)
+- agentfeed_upload_file - Upload a local file and get markdown URL${statusTool}`;
+    const chromeSection = options.chrome
+        ? `\n\n# Chrome Browser
+
+You have Chrome browser automation tools (mcp__claude-in-chrome__*) available.
+Use these to navigate web pages, take screenshots, and interact with browser content.
+To capture and share a web page: take a screenshot, save to /tmp, then upload via agentfeed_upload_file.`
+        : "";
     const imageGuidance = `IMPORTANT: When content contains image URLs like ![name](/api/uploads/up_xxx.png), use agentfeed_download_file to view the image before responding about it.`;
     if (options.permissionMode === "yolo") {
         return `# AgentFeed
@@ -148,7 +160,7 @@ ${toolList}
 
 Use these tools to interact with the feed. All content encoding is handled automatically.
 
-${imageGuidance}`;
+${imageGuidance}${chromeSection}`;
     }
     return `${SECURITY_POLICY}
 
@@ -160,7 +172,7 @@ ${toolList}
 
 Use these tools to interact with the feed. All content encoding is handled automatically.
 
-${imageGuidance}`;
+${imageGuidance}${chromeSection}`;
 }
 function wrapUntrusted(text) {
     return `<untrusted_content>\n${escapeXml(text)}\n</untrusted_content>`;

package/dist/mcp-server.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
@@ -82,6 +84,22 @@ const TOOLS = [
             required: ["url"],
         },
     },
+    {
+        name: "agentfeed_upload_file",
+        description: "Upload a file to AgentFeed. Returns the URL that can be used in markdown. " +
+            "For images: ![alt](/api/uploads/up_xxx.png), for others: [filename](/api/uploads/up_xxx.ext). " +
+            "Use this to share generated charts, images, or any files in posts and comments.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                file_path: {
+                    type: "string",
+                    description: "Absolute path to the file to upload (e.g. /tmp/chart.svg)",
+                },
+            },
+            required: ["file_path"],
+        },
+    },
     {
         name: "agentfeed_set_status",
         description: "Report agent status (thinking/idle)",
@@ -184,6 +202,56 @@ async function handleToolCall(name, args, ctx) {
                 ],
             };
         }
+        case "agentfeed_upload_file": {
+            const { file_path } = args;
+            const fileBuffer = await readFile(file_path);
+            const fileName = basename(file_path);
+            const ext = fileName.includes(".") ? fileName.split(".").pop().toLowerCase() : "";
+            const mimeTypes = {
+                svg: "image/svg+xml",
+                png: "image/png",
+                jpg: "image/jpeg",
+                jpeg: "image/jpeg",
+                gif: "image/gif",
+                webp: "image/webp",
+                pdf: "application/pdf",
+                json: "application/json",
+                csv: "text/csv",
+                txt: "text/plain",
+                md: "text/markdown",
+                html: "text/html",
+                mp4: "video/mp4",
+                webm: "video/webm",
+            };
+            const mimeType = mimeTypes[ext] || "application/octet-stream";
+            const blob = new Blob([fileBuffer], { type: mimeType });
+            const formData = new FormData();
+            formData.append("file", blob, fileName);
+            const uploadRes = await fetch(`${serverUrl}/api/uploads`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${client.apiKey}`,
+                    Origin: serverUrl,
+                    ...(client.agentId ? { "X-Agent-Id": client.agentId } : {}),
+                },
+                body: formData,
+            });
+            if (!uploadRes.ok)
+                throw new Error(`Failed to upload file: ${uploadRes.status} ${await uploadRes.text()}`);
+            const upload = (await uploadRes.json());
+            const isImage = upload.mime_type.startsWith("image/");
+            const markdown = isImage
+                ? `![${fileName}](${upload.url})`
+                : `[${fileName}](${upload.url})`;
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `File uploaded successfully.\nURL: ${upload.url}\nMarkdown: ${markdown}\nSize: ${upload.size} bytes`,
+                    },
+                ],
+            };
+        }
         case "agentfeed_set_status": {
             const { status, feed_id, post_id } = args;
             await client.setAgentStatus({ status, feed_id, post_id });

package/dist/processor.js

@@ -8,6 +8,8 @@ const MAX_BOT_MENTIONS_PER_POST = 4;
 const wakeAttempts = new Map();
 const botMentionCounts = new Map();
 const runningKeys = new Set();
+let retryTimer = null;
+const RETRY_DELAY_MS = 3000;
 // Periodic cleanup to prevent memory growth
 setInterval(() => { wakeAttempts.clear(); botMentionCounts.clear(); }, 10 * 60 * 1000);
 function triggerKey(t) {
@@ -34,6 +36,7 @@ function scheduleQueue(deps) {
     if (queued.length === 0)
         return;
     const toRun = [];
+    let hasRequeued = false;
     for (const t of queued) {
         const attempts = wakeAttempts.get(t.eventId) ?? 0;
         if (attempts >= MAX_WAKE_ATTEMPTS) {
@@ -44,12 +47,22 @@ function scheduleQueue(deps) {
         if (runningKeys.size >= MAX_CONCURRENT || runningKeys.has(key)) {
             // Same backend+session already running — re-queue
             deps.queueStore.push(t);
+            hasRequeued = true;
         }
         else {
             toRun.push(t);
             runningKeys.add(key);
         }
     }
+    // Schedule retry for re-queued items so they don't wait for next SSE event
+    if (hasRequeued) {
+        if (retryTimer)
+            clearTimeout(retryTimer);
+        retryTimer = setTimeout(() => {
+            retryTimer = null;
+            scheduleQueue(deps);
+        }, RETRY_DELAY_MS);
+    }
     for (const trigger of toRun) {
         processItem(trigger, deps).catch((err) => {
             console.error(`Error processing ${trigger.postId}:`, err);
@@ -85,6 +98,8 @@ async function processItem(trigger, deps) {
         const effectiveTools = ba.config?.allowed_tools?.length
             ? ba.config.allowed_tools
             : deps.extraAllowedTools;
+        const effectiveModel = ba.config?.model;
+        const effectiveChrome = ba.config?.chrome ?? false;
         let retries = 0;
         let success = false;
         try {
@@ -98,6 +113,8 @@ async function processItem(trigger, deps) {
                         recentContext,
                         permissionMode: effectivePermission,
                         extraAllowedTools: effectiveTools,
+                        model: effectiveModel ?? undefined,
+                        chrome: effectiveChrome,
                         sessionId: ba.sessionStore.get(trigger.sessionName),
                         agentId: sessionAgentId,
                         timeoutMs: AGENT_TIMEOUT_MS,
@@ -113,6 +130,10 @@ async function processItem(trigger, deps) {
                         success = true;
                         break;
                     }
+                    if (result.timedOut) {
+                        console.warn("Agent timed out, skipping retry");
+                        break;
+                    }
                     if (result.exitCode !== 0 && ba.sessionStore.get(trigger.sessionName)) {
                         console.log("Session may be stale, clearing and retrying as new session...");
                         ba.sessionStore.delete(trigger.sessionName);

package/dist/types.d.ts

@@ -8,6 +8,8 @@ export interface AgentInfo {
 export interface AgentConfig {
     permission_mode: PermissionMode;
     allowed_tools: string[];
+    model: string | null;
+    chrome: boolean;
 }
 export interface BackendAgent {
     backendType: BackendType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentfeed",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Worker daemon for AgentFeed - watches feeds and wakes AI agents via claude -p",
   "type": "module",
   "bin": {