@hamp10/agentforge 0.2.0 → 0.2.1

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')
@@ -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.1",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {

package/src/OllamaAgent.js

@@ -185,7 +185,7 @@ export class OllamaAgent extends EventEmitter {
               messages,
               tools: TOOLS,
               tool_choice: 'auto',
-              stream: false
+              stream: true
             })
           });
         } catch (fetchErr) {
@@ -198,9 +198,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 +285,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 ──
@@ -242,17 +327,9 @@ export class OllamaAgent extends EventEmitter {
           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;
       }