@hamp10/agentforge 0.2.0 → 0.2.2

package/bin/agentforge.js

@@ -54,7 +54,7 @@ function saveConfig(config) {
 program
   .name('agentforge')
   .description('AgentForge worker - connect your machine to agentforge.ai')
-  .version('0.1.0');
+  .version('0.2.1');
 
 program
   .command('login')
@@ -274,9 +274,9 @@ program
     const worker = new AgentForgeWorker(config.token, wsUrl, config);
 
     // Graceful shutdown
-    process.on('SIGINT', () => { console.log('\n[SIGINT received]'); worker.shutdown(); });
-    process.on('SIGTERM', () => { console.log('\n[SIGTERM received]'); worker.shutdown(); });
-    process.on('SIGHUP', () => { console.log('\n[SIGHUP received — terminal closed]'); worker.shutdown(); });
+    process.on('SIGINT',  () => { console.log('\n[SIGINT received — stopping]');   worker.shutdown(0); }); // Ctrl+C: clean stop
+    process.on('SIGTERM', () => { console.log('\n[SIGTERM received — restarting]'); worker.shutdown(1); }); // kill: supervisor restarts
+    process.on('SIGHUP',  () => { console.log('\n[SIGHUP received — restarting]');  worker.shutdown(1); }); // terminal close: supervisor restarts
 
     try {
       await worker.initialize();
@@ -450,66 +450,276 @@ program
     console.log('');
   });
 
+program
+  .command('doctor')
+  .description('Check your AgentForge worker health — diagnose any issues')
+  .action(async () => {
+    console.log('');
+    console.log('🩺 AgentForge Doctor');
+    console.log('================================');
+    console.log('');
+
+    let allGood = true;
+
+    // 1. Authentication
+    const config = loadConfig();
+    if (config.token) {
+      console.log('✅ Authenticated');
+    } else {
+      console.log('❌ Not authenticated');
+      console.log('   Fix: agentforge login');
+      allGood = false;
+    }
+
+    // 2. Server reachability
+    const serverUrl = config.url || 'https://agentforgeai-production.up.railway.app';
+    try {
+      const res = await fetch(`${serverUrl}/api/wsstatus`, { signal: AbortSignal.timeout(5000) });
+      if (res.ok || res.status === 401 || res.status === 403) {
+        console.log(`✅ Server reachable (${serverUrl})`);
+      } else {
+        console.log(`⚠️  Server returned ${res.status}`);
+      }
+    } catch (err) {
+      console.log(`❌ Cannot reach server: ${err.message}`);
+      allGood = false;
+    }
+
+    // 3. AI Backend
+    if (config.provider === 'local') {
+      const localUrl = config.localUrl || 'http://localhost:11434';
+      try {
+        const res = await fetch(`${localUrl}/v1/models`, { signal: AbortSignal.timeout(5000) });
+        if (res.ok) {
+          const data = await res.json();
+          const models = (data.data ?? data.models ?? []).map(m => m.id || m.name);
+          const configured = config.localModel || '(not set)';
+          const found = models.includes(configured);
+          console.log(`✅ Local model server running (${localUrl})`);
+          console.log(`   Configured model: ${configured} ${found ? '✅' : '⚠️  (not found in model list)'}`);
+          if (!found && models.length > 0) {
+            console.log(`   Available models: ${models.slice(0, 5).join(', ')}`);
+            console.log(`   Fix: agentforge local --model ${models[0]}`);
+            allGood = false;
+          }
+        } else {
+          console.log(`❌ Local server at ${localUrl} returned ${res.status}`);
+          allGood = false;
+        }
+      } catch {
+        console.log(`❌ Local server not running at ${localUrl}`);
+        console.log(`   Make sure Ollama/LM Studio/Jan is running, then: agentforge start`);
+        allGood = false;
+      }
+    } else if (OpenClawCLI.isAvailable()) {
+      console.log('✅ openclaw backend available');
+    } else {
+      // Auto-detect Ollama
+      try {
+        const res = await fetch('http://localhost:11434/v1/models', { signal: AbortSignal.timeout(2000) });
+        if (res.ok) {
+          const data = await res.json();
+          const models = (data.data ?? data.models ?? []).map(m => m.id || m.name);
+          console.log(`⚠️  Ollama is running but not configured as your backend`);
+          if (models.length > 0) console.log(`   Models available: ${models.slice(0, 5).join(', ')}`);
+          console.log(`   Fix: agentforge local --model ${models[0] || 'llama3.1:8b'}`);
+          allGood = false;
+        }
+      } catch {
+        console.log('❌ No AI backend configured');
+        console.log('   Fix: install Ollama (https://ollama.ai) then: agentforge local --model llama3.1:8b');
+        allGood = false;
+      }
+    }
+
+    // 4. Worker running
+    const supervisorPidFile = path.join(CONFIG_DIR, 'supervisor.pid');
+    const workerPidFile = path.join(CONFIG_DIR, 'worker.pid');
+    if (fs.existsSync(supervisorPidFile)) {
+      const pid = parseInt(fs.readFileSync(supervisorPidFile, 'utf8').trim());
+      try {
+        process.kill(pid, 0);
+        const wpid = fs.existsSync(workerPidFile) ? fs.readFileSync(workerPidFile, 'utf8').trim() : null;
+        console.log(`✅ Worker running (supervisor PID ${pid}${wpid ? ', worker PID ' + wpid : ''})`);
+      } catch {
+        console.log('⚠️  Supervisor PID file exists but process is not running');
+        console.log('   Fix: agentforge start');
+        allGood = false;
+      }
+    } else {
+      console.log('⚠️  Worker not running');
+      console.log('   Fix: agentforge start');
+    }
+
+    console.log('');
+    if (allGood) {
+      console.log('✅ Everything looks healthy!');
+    } else {
+      console.log('Fix the issues above, then run: agentforge start');
+    }
+    console.log('');
+  });
+
 program
   .command('setup')
-  .description('Full device setup: AgentForge login + Anthropic auth + Tailscale')
+  .description('Interactive setup wizard — gets AgentForge running in minutes')
   .option('--tailscale-key <key>', 'Tailscale auth key (from tailscale.com/admin/settings/keys)')
   .action(async (options) => {
     const { execSync, spawnSync } = await import('child_process');
+    const readline = await import('readline');
+
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(resolve => rl.question(q, resolve));
 
     console.log('');
-    console.log('🚀 AgentForge Device Setup');
+    console.log('🚀 AgentForge Setup');
     console.log('================================');
-    console.log('');
+    console.log('Getting your machine ready to run AI agents.\n');
 
-    // Step 1: AgentForge login
-    console.log('Step 1/3: AgentForge authentication');
-    console.log('Run: agentforge login');
-    console.log('(Complete login, then come back here)');
-    console.log('');
+    // ── Step 1: Authentication ──────────────────────────────────────────────
+    const config = loadConfig();
+    if (config.token) {
+      console.log('✅ Step 1/2: Already logged in\n');
+    } else {
+      console.log('Step 1/2: Log in to AgentForge\n');
+      console.log('A browser window will open — log in there and come back.\n');
+      rl.close();
+
+      // Spawn login as a child process with inherited stdio so the interactive
+      // OAuth flow works (readline on stdin, browser opens, polling, etc.)
+      const { spawnSync: sp } = await import('child_process');
+      const loginResult = sp(process.execPath, [process.argv[1], 'login'], { stdio: 'inherit' });
+      if (loginResult.status !== 0) {
+        console.error('\n❌ Login failed — run: agentforge login');
+        process.exit(1);
+      }
 
-    // Step 2: openclaw + Anthropic token
-    console.log('Step 2/3: Anthropic token setup');
-    console.log('Run in a new terminal:  claude setup-token');
-    console.log('Then run:  agentforge refresh-token');
-    console.log('');
+      // Re-open readline for the rest of setup
+      const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+      Object.assign(rl, rl2); // replace for remaining ask() calls (won't be used further)
+      console.log('');
+    }
 
-    // Step 3: Tailscale
-    console.log('Step 3/3: Tailscale (remote access from any network)');
-    console.log('');
+    // ── Step 2: AI Backend ──────────────────────────────────────────────────
+    console.log('Step 2/2: AI Backend\n');
 
-    const tailscaleInstalled = spawnSync('which', ['tailscale'], { encoding: 'utf-8' }).status === 0;
+    const freshConfig = loadConfig();
 
-    if (tailscaleInstalled) {
-      console.log('✅ Tailscale already installed');
-    } else {
-      console.log('Installing Tailscale...');
+    if (freshConfig.provider === 'local') {
+      const localUrl = freshConfig.localUrl || 'http://localhost:11434';
       try {
-        execSync('brew install tailscale', { stdio: 'inherit' });
-        console.log('✅ Tailscale installed');
-      } catch (e) {
-        console.error('❌ Failed to install Tailscale. Install manually: https://tailscale.com/download');
+        const res = await fetch(`${localUrl}/v1/models`, { signal: AbortSignal.timeout(3000) });
+        if (res.ok) {
+          const data = await res.json();
+          const models = (data.data ?? data.models ?? []).map(m => m.id || m.name);
+          console.log(`✅ Already configured: ${localUrl} with model "${freshConfig.localModel}"`);
+          if (models.length > 0 && !models.includes(freshConfig.localModel)) {
+            console.log(`   ⚠️  Model "${freshConfig.localModel}" not found. Available: ${models.slice(0, 5).join(', ')}`);
+          }
+          console.log('');
+        }
+      } catch {
+        console.log(`⚠️  Configured local server at ${localUrl} is not reachable. Make sure it's running.\n`);
+      }
+    } else if (OpenClawCLI.isAvailable()) {
+      console.log('✅ openclaw detected and ready\n');
+    } else {
+      // Probe all common local model servers
+      const probes = [
+        { name: 'Ollama',     url: 'http://localhost:11434' },
+        { name: 'LM Studio',  url: 'http://localhost:1234' },
+        { name: 'Jan',        url: 'http://localhost:1337' },
+        { name: 'llama.cpp',  url: 'http://localhost:8080' },
+        { name: 'vLLM',       url: 'http://localhost:8000' },
+      ];
+
+      const found = [];
+      process.stdout.write('Detecting local model servers...');
+      for (const probe of probes) {
+        try {
+          const res = await fetch(`${probe.url}/v1/models`, { signal: AbortSignal.timeout(1500) });
+          if (res.ok) {
+            const data = await res.json();
+            const models = (data.data ?? data.models ?? []).map(m => m.id || m.name).filter(Boolean);
+            found.push({ ...probe, models });
+          }
+        } catch {}
+      }
+      console.log('');
+
+      if (found.length === 0) {
+        console.log('');
+        console.log('No local model server detected.\n');
+        console.log('AgentForge needs an AI model to power your agents. The easiest option is Ollama:\n');
+        console.log('  1. Go to https://ollama.ai and install it');
+        console.log('  2. Run: ollama pull llama3.1:8b');
+        console.log('  3. Run: agentforge setup   (come back here when done)');
+        console.log('');
+        console.log('You can also use LM Studio, Jan, llama.cpp, or openclaw.');
+        rl.close();
+        process.exit(0);
+      }
+
+      // Let user pick if multiple found, or auto-select if only one
+      let chosen = found[0];
+      if (found.length > 1) {
+        console.log('\nFound these model servers:\n');
+        found.forEach((b, i) => {
+          console.log(`  ${i + 1}. ${b.name} (${b.url}) — ${b.models.length} model(s): ${b.models.slice(0, 3).join(', ')}`);
+        });
+        const ans = await ask(`\nWhich one to use? [1]: `);
+        const idx = parseInt(ans.trim()) - 1;
+        chosen = found[isNaN(idx) || idx < 0 || idx >= found.length ? 0 : idx];
+      } else {
+        console.log(`\nFound: ${chosen.name} (${chosen.url}) with ${chosen.models.length} model(s)`);
       }
+
+      // Pick model
+      let model = chosen.models[0] || 'llama3.1:8b';
+      if (chosen.models.length > 1) {
+        console.log(`\nAvailable models: ${chosen.models.join(', ')}`);
+        const ans = await ask(`Model to use [${model}]: `);
+        if (ans.trim()) model = ans.trim();
+      } else if (chosen.models.length === 1) {
+        console.log(`Using model: ${model}`);
+      }
+
+      const newConfig = loadConfig();
+      newConfig.provider = 'local';
+      newConfig.localUrl = chosen.url;
+      newConfig.localModel = model;
+      saveConfig(newConfig);
+      console.log(`\n✅ Configured ${chosen.name} with model "${model}"\n`);
     }
 
+    rl.close();
+
+    // ── Optional: Tailscale (only shown if installed or key provided) ────────
+    const tailscaleInstalled = spawnSync('which', ['tailscale'], { encoding: 'utf-8' }).status === 0;
     if (options.tailscaleKey) {
       try {
         execSync(`sudo tailscale up --authkey=${options.tailscaleKey}`, { stdio: 'inherit' });
-        console.log('✅ Tailscale connected');
         const result = spawnSync('tailscale', ['ip', '--4'], { encoding: 'utf-8' });
-        if (result.stdout) console.log(`   Tailscale IP: ${result.stdout.trim()}`);
-      } catch (e) {
-        console.error('❌ Tailscale join failed. Run manually: sudo tailscale up');
+        console.log(`✅ Tailscale connected${result.stdout ? ' — IP: ' + result.stdout.trim() : ''}`);
+      } catch {
+        console.log('⚠️  Tailscale key failed — run: sudo tailscale up');
       }
-    } else {
-      console.log('To join your Tailscale network:');
-      console.log('  sudo tailscale up');
-      console.log('  (or: agentforge setup --tailscale-key <key>)');
-      console.log('  Get a key at: tailscale.com/admin/settings/keys');
+    } else if (tailscaleInstalled) {
+      console.log('✅ Tailscale installed (run "sudo tailscale up" to connect remotely)');
     }
 
     console.log('');
-    console.log('✅ Setup complete! Run: agentforge start');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+    console.log('✅  Setup complete!');
+    console.log('');
+    console.log('   Run this to start your worker:');
+    console.log('');
+    console.log('     agentforge start');
+    console.log('');
+    console.log('   Run this to check your health:');
+    console.log('');
+    console.log('     agentforge doctor');
+    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
     console.log('');
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/src/OllamaAgent.js

@@ -79,6 +79,28 @@ const TOOLS = [
         required: ['url']
       }
     }
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'take_screenshot',
+      description: 'Take a screenshot of the current screen or the agent browser (port 9223). Returns base64 image data you can analyze visually. Use this to check what a webpage looks like, verify a build result, or monitor a running process.',
+      parameters: {
+        type: 'object',
+        properties: {
+          target: {
+            type: 'string',
+            enum: ['screen', 'browser'],
+            description: 'screen = full screen capture. browser = screenshot of the agent browser (port 9223).'
+          },
+          url: {
+            type: 'string',
+            description: 'Optional: navigate the browser to this URL before taking the screenshot.'
+          }
+        },
+        required: ['target']
+      }
+    }
   }
 ];
 
@@ -146,25 +168,40 @@ export class OllamaAgent extends EventEmitter {
     console.log(`   Task: ${task}`);
     console.log(`   Working dir: ${workDir}`);
 
+    // Detect model capabilities
+    const isQwen3    = this.model.startsWith('qwen3');
+    const isVision   = /vl|vision|llava|minicpm-v|moondream/i.test(this.model);
+
     try {
       // Load conversation history from disk (session persistence)
       const history = this._loadHistory(agentId, workDir, sessionId);
 
+      const systemPrompt = [
+        `You are an AI agent running on AgentForge.ai.`,
+        `Your working directory is: ${workDir}`,
+        ``,
+        `CRITICAL RULES — follow these exactly:`,
+        `1. Use the provided tools to complete the task. Do NOT write Python code, pseudo-code, or code blocks to simulate tool calls.`,
+        `2. To run a command, call the "bash" tool. To read a file, call "read_file". To write, call "write_file". To take a screenshot, call "take_screenshot".`,
+        `3. Every action must be a real tool call — not described in text, not shown as code.`,
+        `4. When you take a screenshot, you will receive the actual image back and can see it.`,
+        `5. When you are done, write a clear summary of what you accomplished.`,
+        `6. Do not ask for clarification — make your best judgment and act.`,
+      ].join('\n');
+
       const messages = [
-        {
-          role: 'system',
-          content: [
-            `You are an AI agent running on AgentForge.ai.`,
-            `Your working directory is: ${workDir}`,
-            `Use the available tools to complete the task autonomously.`,
-            `When you are done, write a clear summary of what you accomplished.`,
-            `Do not ask for clarification — make your best judgment and act.`
-          ].join('\n')
-        },
+        { role: 'system', content: systemPrompt },
         ...history,
-        { role: 'user', content: task }
       ];
 
+      // Attach initial image to user message if provided
+      const userMessage = { role: 'user', content: task };
+      if (image && isVision) {
+        const base64 = image.replace(/^data:image\/\w+;base64,/, '');
+        userMessage.images = [base64];
+      }
+      messages.push(userMessage);
+
       let finalContent = '';
       const MAX_TURNS = 25;
 
@@ -175,18 +212,25 @@ export class OllamaAgent extends EventEmitter {
 
         let response;
         try {
-          // OpenAI-compatible endpoint — works with Ollama, LM Studio, Jan, llama.cpp, vLLM, etc.
+          const requestBody = {
+            model: this.model,
+            messages,
+            tools: TOOLS,
+            tool_choice: 'auto',
+            stream: true,
+          };
+
+          // Disable thinking mode for qwen3 — prevents 3-minute silent think phases
+          // and makes tool-call JSON output reliable.
+          if (isQwen3) {
+            requestBody.options = { think: false };
+          }
+
           response = await fetch(`${this.baseUrl}/v1/chat/completions`, {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             signal: controller.signal,
-            body: JSON.stringify({
-              model: this.model,
-              messages,
-              tools: TOOLS,
-              tool_choice: 'auto',
-              stream: false
-            })
+            body: JSON.stringify(requestBody)
           });
         } catch (fetchErr) {
           if (fetchErr.name === 'AbortError') break;
@@ -198,9 +242,86 @@ export class OllamaAgent extends EventEmitter {
           throw new Error(`Local model error ${response.status}: ${body}`);
         }
 
-        const data = await response.json();
-        // OpenAI-compat wraps in choices[0].message; Ollama native uses data.message
-        const message = data.choices?.[0]?.message ?? data.message;
+        // ── Stream the SSE response ──
+        // Accumulate content and tool calls from streaming deltas.
+        // Filter out <think>...</think> blocks (qwen3 chain-of-thought) — never show to user.
+        let streamContent = '';
+        let streamToolCalls = {};
+        let inThinkBlock = false;
+        let thinkBuffer = '';
+
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buf = '';
+
+        while (true) {
+          if (controller.signal.aborted) break;
+          const { done, value } = await reader.read();
+          if (done) break;
+
+          buf += decoder.decode(value, { stream: true });
+          const lines = buf.split('\n');
+          buf = lines.pop(); // keep incomplete line
+
+          for (const line of lines) {
+            if (!line.startsWith('data: ')) continue;
+            const payload = line.slice(6).trim();
+            if (payload === '[DONE]') continue;
+            let evt;
+            try { evt = JSON.parse(payload); } catch { continue; }
+
+            const delta = evt.choices?.[0]?.delta;
+            if (!delta) continue;
+
+            // Accumulate tool call deltas
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                if (!streamToolCalls[idx]) streamToolCalls[idx] = { id: tc.id || '', type: 'function', function: { name: '', arguments: '' } };
+                if (tc.id) streamToolCalls[idx].id = tc.id;
+                if (tc.function?.name) streamToolCalls[idx].function.name += tc.function.name;
+                if (tc.function?.arguments) streamToolCalls[idx].function.arguments += tc.function.arguments;
+              }
+            }
+
+            // Stream content tokens, filtering <think>...</think> blocks
+            if (delta.content) {
+              thinkBuffer += delta.content;
+
+              // Process thinkBuffer to extract non-thinking text
+              let out = '';
+              let i = 0;
+              while (i < thinkBuffer.length) {
+                if (!inThinkBlock) {
+                  const thinkStart = thinkBuffer.indexOf('<think>', i);
+                  if (thinkStart === -1) {
+                    out += thinkBuffer.slice(i);
+                    i = thinkBuffer.length;
+                  } else {
+                    out += thinkBuffer.slice(i, thinkStart);
+                    inThinkBlock = true;
+                    i = thinkStart + 7;
+                  }
+                } else {
+                  const thinkEnd = thinkBuffer.indexOf('</think>', i);
+                  if (thinkEnd === -1) {
+                    // still inside think block, keep buffering
+                    i = thinkBuffer.length;
+                  } else {
+                    inThinkBlock = false;
+                    i = thinkEnd + 8;
+                  }
+                }
+              }
+              thinkBuffer = inThinkBlock ? thinkBuffer.slice(thinkBuffer.lastIndexOf('<think>')) : '';
+
+              streamContent += out;
+              if (out) {
+                this.emit('agent_output', { agentId, output: out });
+              }
+            }
+          }
+        }
 
         this.emit('tool_activity', {
           agentId,
@@ -208,6 +329,14 @@ export class OllamaAgent extends EventEmitter {
           description: `✅ Ollama responded`
         });
 
+        // Reconstruct message from streamed parts
+        const toolCallsArray = Object.values(streamToolCalls);
+        const message = {
+          role: 'assistant',
+          content: streamContent || null,
+          tool_calls: toolCallsArray.length > 0 ? toolCallsArray : undefined
+        };
+
         messages.push(message);
 
         // ── Handle tool calls ──
@@ -236,23 +365,36 @@ export class OllamaAgent extends EventEmitter {
               description: `✓ ${name}`
             });
 
-            messages.push({ role: 'tool', content: String(result) });
+            // If the tool returned an image (base64), push it as a vision message
+            // so the model can actually see what was captured.
+            const isImageResult = typeof result === 'string' && result.startsWith('data:image/');
+            if (isImageResult && isVision) {
+              messages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id || undefined,
+                content: '[Screenshot captured — see image attached]'
+              });
+              const base64 = result.replace(/^data:image\/\w+;base64,/, '');
+              messages.push({
+                role: 'user',
+                content: 'Here is the screenshot:',
+                images: [base64]
+              });
+            } else {
+              messages.push({
+                role: 'tool',
+                tool_call_id: toolCall.id || undefined,
+                content: isImageResult ? '[Screenshot captured — install a vision model to analyze images]' : String(result)
+              });
+            }
           }
           // Loop back — model will respond to the tool results
           continue;
         }
 
-        // ── No tool calls: this is the final answer ──
-        if (message.content) {
-          finalContent = message.content;
-          // Stream the response in chunks so the UI feels live
-          const words = message.content.split(' ');
-          const CHUNK_SIZE = 8;
-          for (let i = 0; i < words.length; i += CHUNK_SIZE) {
-            if (controller.signal.aborted) break;
-            const chunk = words.slice(i, i + CHUNK_SIZE).join(' ') + (i + CHUNK_SIZE < words.length ? ' ' : '');
-            this.emit('agent_output', { agentId, output: chunk });
-          }
+        // ── No tool calls: final answer already streamed above ──
+        if (streamContent) {
+          finalContent = streamContent;
         }
         break;
       }
@@ -357,6 +499,22 @@ export class OllamaAgent extends EventEmitter {
           return text.slice(0, 4000) + (text.length > 4000 ? '\n...(truncated)' : '');
         }
 
+        case 'take_screenshot': {
+          const target = args.target || 'screen';
+          const tmpFile = `/tmp/af_screenshot_${Date.now()}.png`;
+
+          if (target === 'browser') {
+            // Navigate + screenshot via CDP on agent browser (port 9223)
+            return await this._cdpScreenshot(args.url, tmpFile);
+          } else {
+            // Full screen capture
+            await execAsync(`screencapture -x "${tmpFile}"`);
+            const data = readFileSync(tmpFile).toString('base64');
+            try { await execAsync(`rm -f "${tmpFile}"`); } catch {}
+            return `data:image/png;base64,${data}`;
+          }
+        }
+
         default:
           return `Unknown tool: ${name}`;
       }
@@ -365,6 +523,69 @@ export class OllamaAgent extends EventEmitter {
     }
   }
 
+  // ─── CDP browser screenshot ───────────────────────────────────────────────
+
+  async _cdpScreenshot(navigateUrl, tmpFile) {
+    const CDP_PORT = 9223;
+    let tabId;
+
+    // Get or create a tab
+    const tabsRes = await fetch(`http://127.0.0.1:${CDP_PORT}/json`);
+    const tabs = await tabsRes.json();
+    const usable = tabs.find(t => t.type === 'page' && t.webSocketDebuggerUrl);
+
+    if (!usable) {
+      // Create new tab
+      const newTab = await fetch(`http://127.0.0.1:${CDP_PORT}/json/new`, { method: 'PUT' });
+      const newTabData = await newTab.json();
+      tabId = newTabData.id;
+    } else {
+      tabId = usable.id;
+    }
+
+    return new Promise((resolve, reject) => {
+      // Inline WebSocket CDP — no ws package dependency needed (Node 22 has WebSocket built in)
+      const ws = new WebSocket(`ws://127.0.0.1:${CDP_PORT}/devtools/page/${tabId}`);
+      let msgId = 1;
+      const pending = new Map();
+
+      const send = (method, params = {}) => new Promise((res, rej) => {
+        const id = msgId++;
+        pending.set(id, { resolve: res, reject: rej });
+        ws.send(JSON.stringify({ id, method, params }));
+      });
+
+      ws.addEventListener('message', (evt) => {
+        const msg = JSON.parse(evt.data);
+        if (msg.id && pending.has(msg.id)) {
+          const { resolve: res, reject: rej } = pending.get(msg.id);
+          pending.delete(msg.id);
+          if (msg.error) rej(new Error(msg.error.message));
+          else res(msg.result);
+        }
+      });
+
+      ws.addEventListener('open', async () => {
+        try {
+          if (navigateUrl) {
+            await send('Page.navigate', { url: navigateUrl });
+            // Wait for load
+            await new Promise(r => setTimeout(r, 3000));
+          }
+          const { data } = await send('Page.captureScreenshot', { format: 'png' });
+          ws.close();
+          resolve(`data:image/png;base64,${data}`);
+        } catch (err) {
+          ws.close();
+          reject(err);
+        }
+      });
+
+      ws.addEventListener('error', (err) => reject(new Error(`CDP WebSocket error: ${err.message}`)));
+      setTimeout(() => { ws.close(); reject(new Error('CDP screenshot timeout')); }, 20000);
+    });
+  }
+
   _resolvePath(p, workDir) {
     return path.isAbsolute(p) ? p : path.join(workDir, p);
   }
@@ -382,6 +603,8 @@ export class OllamaAgent extends EventEmitter {
       case 'web_fetch': {
         try { return `Fetching ${new URL(args.url).hostname}`; } catch { return 'Fetching URL'; }
       }
+      case 'take_screenshot':
+        return `Screenshot: ${args.url || args.target}`;
       default:
         return name;
     }

package/src/supervisor.js

@@ -39,11 +39,18 @@ function removePid(file) {
 export async function runSupervisor(innerArgv) {
   writePid(PID_FILE, process.pid);
 
+  // SIGTERM on supervisor = intentional stop (from agentforge stop command)
   process.on('SIGTERM', () => {
     console.log('[supervisor] Received SIGTERM — shutting down');
     removePid(PID_FILE);
     process.exit(0);
   });
+  // SIGINT = Ctrl+C in foreground terminal = intentional stop
+  process.on('SIGINT', () => {
+    console.log('[supervisor] Received SIGINT — shutting down');
+    removePid(PID_FILE);
+    process.exit(0);
+  });
 
   let consecutiveCrashes = 0;
 

package/src/worker.js

@@ -1756,12 +1756,12 @@ Review and add specific steps, pitfalls, and patterns that helped succeed.
     });
   }
 
-  async shutdown() {
+  async shutdown(code = 1) {
     console.log('🛑 Shutting down worker...');
     if (this.ws) {
       this.ws.close();
     }
-    process.exit(0);
+    process.exit(code);
   }
 
   // Find the AgentForge git repo root, regardless of whether worker is globally installed or run from source