@hamp10/agentforge 0.1.1 → 0.2.1

package/bin/agentforge.js

@@ -8,6 +8,8 @@ import open from 'open';
 import { execSync, spawn } from 'child_process';
 import { AgentForgeWorker } from '../src/worker.js';
 import { OpenClawCLI } from '../src/OpenClawCLI.js';
+import { checkAndUpdate } from '../src/selfUpdate.js';
+import { runSupervisor, detachSupervisor, stopSupervisor } from '../src/supervisor.js';
 
 const CONFIG_DIR = path.join(os.homedir(), '.agentforge');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -52,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')
@@ -184,7 +186,14 @@ program
   .command('start')
   .description('Start worker and connect to AgentForge')
   .option('-u, --url <url>', 'Custom AgentForge URL (overrides saved config)')
+  .option('--detach', 'Run worker in background (returns shell prompt immediately)')
+  .option('--no-daemon', 'Run worker directly without supervisor (internal use)')
   .action(async (options) => {
+    // Self-update: check for newer package version before doing anything else.
+    // Skipped when AGENTFORGE_SKIP_UPDATE=1 (set by supervisor on re-exec).
+    const pkg = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    await checkAndUpdate(pkg.name, pkg.version);
+
     const config = loadConfig();
 
     if (!config.token) {
@@ -207,6 +216,27 @@ program
       process.exit(1);
     }
 
+    // Supervisor routing:
+    //   --detach    → spawn background supervisor and return shell immediately
+    //   (default)   → run foreground supervisor that auto-restarts on crash
+    //   --no-daemon → skip supervisor entirely (used by supervisor internally)
+    if (options.detach) {
+      // Build the argv for the background supervisor process (no --detach flag so it
+      // enters runSupervisor and manages workers; AGENTFORGE_SKIP_UPDATE=1 is set by detachSupervisor)
+      const supervisorArgv = ['start', ...(options.url ? ['--url', options.url] : [])];
+      detachSupervisor(supervisorArgv);
+      process.exit(0);
+    }
+
+    if (options.daemon !== false) {
+      // Foreground supervisor mode — re-exec self with --no-daemon, restart on crash
+      const innerArgv = ['start', '--no-daemon', ...(options.url ? ['--url', options.url] : [])];
+      await runSupervisor(innerArgv);
+      return; // runSupervisor exits the process — this is just a safety return
+    }
+
+    // --no-daemon: run the actual worker directly (no supervision wrapper)
+
     // Use saved URL from login, or override with --url flag
     const baseUrl = options.url || config.url || process.env.AGENTFORGE_URL || 'https://agentforgeai-production.up.railway.app';
     const wsUrl = baseUrl.replace(/^http/, 'ws') + '/socket';
@@ -420,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('');
   });
 
@@ -864,4 +1104,11 @@ program
     }
   });
 
+program
+  .command('stop')
+  .description('Stop a running background supervisor (started with --detach)')
+  .action(() => {
+    stopSupervisor();
+  });
+
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hamp10/agentforge",
-  "version": "0.1.1",
+  "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;
       }

package/src/OpenClawCLI.js

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync, readFileSync, existsSync, readdirSync, unlink
 import { EventEmitter } from 'events';
 import { homedir } from 'os';
 import path from 'path';
+import { resolveOpenclawBin } from './resolveOpenclaw.js';
 import treeKill from 'tree-kill';
 
 // Canary configuration
@@ -14,14 +15,7 @@ const CANARY_PARENT_API_KEY = process.env.CANARY_PARENT_API_KEY; // Optional: in
  */
 export class OpenClawCLI extends EventEmitter {
   static _findBin() {
-    const home = process.env.HOME || homedir();
-    const candidates = [
-      path.join(home, '.npm-global/bin/openclaw'),
-      '/usr/local/bin/openclaw',
-      '/opt/homebrew/bin/openclaw',
-    ];
-    for (const c of candidates) if (existsSync(c)) return c;
-    return null;
+    return resolveOpenclawBin();
   }
 
   static isAvailable() {

package/src/resolveOpenclaw.js

@@ -0,0 +1,105 @@
+/**
+ * Resolves the openclaw binary and module index.js path on any machine,
+ * regardless of install method (npm -g, nvm, homebrew, system).
+ *
+ * Priority:
+ *   1. OPENCLAW_PATH env var (explicit override)
+ *   2. `which openclaw` — asks the shell's PATH, works for any install method
+ *   3. `readlink -f` on the bin to resolve symlinks, then walk up to dist/index.js
+ *   4. `npm root -g` — finds global node_modules regardless of prefix
+ *   5. Static candidates — final fallback for known install locations
+ */
+
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+function tryExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch {
+    return null;
+  }
+}
+
+// Walk up from a binary path to find dist/index.js in the containing package.
+function findModuleIndex(binPath) {
+  if (!binPath) return null;
+  // If it already ends in index.js, use it directly.
+  if (binPath.endsWith('index.js') && existsSync(binPath)) return binPath;
+  let dir = path.dirname(binPath);
+  for (let i = 0; i < 5; i++) {
+    const candidate = path.join(dir, 'dist', 'index.js');
+    if (existsSync(candidate)) return candidate;
+    const up = path.dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return null;
+}
+
+/**
+ * Returns the path to openclaw's dist/index.js suitable for spawning
+ * via `node dist/index.js gateway ...`.
+ * Returns null if openclaw is not found.
+ */
+export function resolveOpenclawModule() {
+  // 1. Explicit env override
+  if (process.env.OPENCLAW_PATH) {
+    const p = process.env.OPENCLAW_PATH;
+    return existsSync(p) ? p : null;
+  }
+
+  // 2. which openclaw → resolve symlink → find dist/index.js
+  const which = tryExec('which openclaw');
+  if (which && existsSync(which)) {
+    const real = tryExec(`readlink -f "${which}"`) || which;
+    const idx = findModuleIndex(real);
+    if (idx) return idx;
+    // which found the binary but we couldn't find index.js — try npm root
+  }
+
+  // 3. npm root -g
+  const npmRoot = tryExec('npm root -g');
+  if (npmRoot) {
+    const candidate = path.join(npmRoot, 'openclaw', 'dist', 'index.js');
+    if (existsSync(candidate)) return candidate;
+  }
+
+  // 4. Static fallbacks for known install locations
+  const home = process.env.HOME || homedir();
+  const statics = [
+    '/usr/local/lib/node_modules/openclaw/dist/index.js',
+    path.join(home, '.npm-global/lib/node_modules/openclaw/dist/index.js'),
+    '/opt/homebrew/lib/node_modules/openclaw/dist/index.js',
+    // nvm — try the active version via node path
+    path.join(path.dirname(process.execPath), '..', 'lib', 'node_modules', 'openclaw', 'dist', 'index.js'),
+  ].map(p => path.normalize(p));
+
+  for (const p of statics) {
+    if (existsSync(p)) return p;
+  }
+
+  return null;
+}
+
+/**
+ * Returns the openclaw binary path (for running as a CLI command).
+ * Returns null if not found.
+ */
+export function resolveOpenclawBin() {
+  if (process.env.OPENCLAW_BIN) return process.env.OPENCLAW_BIN;
+
+  const which = tryExec('which openclaw');
+  if (which && existsSync(which)) return which;
+
+  const home = process.env.HOME || homedir();
+  const statics = [
+    '/usr/local/bin/openclaw',
+    path.join(home, '.npm-global/bin/openclaw'),
+    '/opt/homebrew/bin/openclaw',
+    path.join(path.dirname(process.execPath), 'openclaw'),
+  ];
+  return statics.find(p => existsSync(p)) || null;
+}

package/src/selfUpdate.js

@@ -0,0 +1,66 @@
+/**
+ * Self-update: checks npm registry for a newer version of this package
+ * and auto-updates + re-execs if one is found.
+ *
+ * Set AGENTFORGE_SKIP_UPDATE=1 to bypass (used internally after update to
+ * prevent infinite re-exec loops).
+ */
+
+import { execSync, spawn } from 'child_process';
+
+function parseVersion(v) {
+  return (v || '0.0.0').split('.').map(Number);
+}
+
+function isNewer(latest, current) {
+  const l = parseVersion(latest);
+  const c = parseVersion(current);
+  for (let i = 0; i < 3; i++) {
+    if (l[i] > c[i]) return true;
+    if (l[i] < c[i]) return false;
+  }
+  return false;
+}
+
+export async function checkAndUpdate(packageName, currentVersion) {
+  if (process.env.AGENTFORGE_SKIP_UPDATE === '1') return;
+
+  let latestVersion;
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) return;
+    const data = await res.json();
+    latestVersion = data.version;
+  } catch {
+    // Registry unreachable — continue with current version
+    return;
+  }
+
+  if (!isNewer(latestVersion, currentVersion)) return;
+
+  console.log(`\n🔄 Update available: ${currentVersion} → ${latestVersion}`);
+  console.log(`   Updating ${packageName}...`);
+
+  try {
+    execSync(`npm install -g ${packageName}@${latestVersion}`, { stdio: 'inherit' });
+  } catch {
+    console.warn('⚠️  Auto-update failed — continuing with current version');
+    return;
+  }
+
+  console.log(`✅ Updated to ${latestVersion}. Restarting...\n`);
+
+  // Re-exec with the new binary, skipping update on the next run
+  const child = spawn(process.execPath, [process.argv[1], ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    detached: false,
+    env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
+  });
+
+  child.on('exit', (code) => process.exit(code ?? 0));
+
+  // Park the parent — child owns the terminal from here
+  await new Promise(() => {});
+}

package/src/supervisor.js

@@ -0,0 +1,128 @@
+/**
+ * Supervisor: spawns the worker process and restarts it on crash.
+ *
+ * Usage modes (controlled by bin/agentforge.js):
+ *   agentforge start              — foreground supervisor (Ctrl+C stops everything)
+ *   agentforge start --detach     — background supervisor (shell returns immediately)
+ *   agentforge start --no-daemon  — raw worker, no supervision (internal use only)
+ *
+ * The supervisor re-execs this same binary with --no-daemon so the actual
+ * worker code path is unchanged — only the lifecycle wrapper is new.
+ */
+
+import { spawn } from 'child_process';
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import path from 'path';
+
+const BACKOFF_MS    = [1000, 2000, 5000, 15000, 30000];
+const CRASH_WINDOW  = 10_000; // process lived < 10s → count as crash
+const CONFIG_DIR    = path.join(homedir(), '.agentforge');
+const PID_FILE      = path.join(CONFIG_DIR, 'supervisor.pid');
+const WORKER_PID_FILE = path.join(CONFIG_DIR, 'worker.pid');
+
+function writePid(file, pid) {
+  try {
+    mkdirSync(path.dirname(file), { recursive: true });
+    writeFileSync(file, String(pid));
+  } catch {}
+}
+
+function removePid(file) {
+  try { unlinkSync(file); } catch {}
+}
+
+/**
+ * Run the supervisor in the foreground. Blocks until a clean exit (code 0).
+ * @param {string[]} innerArgv  argv to pass to the worker process (must include --no-daemon)
+ */
+export async function runSupervisor(innerArgv) {
+  writePid(PID_FILE, process.pid);
+
+  process.on('SIGTERM', () => {
+    console.log('[supervisor] Received SIGTERM — shutting down');
+    removePid(PID_FILE);
+    process.exit(0);
+  });
+
+  let consecutiveCrashes = 0;
+
+  while (true) {
+    const startTime = Date.now();
+
+    const child = spawn(process.execPath, [process.argv[1], ...innerArgv], {
+      stdio: 'inherit',
+      detached: false,
+      env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
+    });
+
+    writePid(WORKER_PID_FILE, child.pid);
+
+    const exitCode = await new Promise(resolve => {
+      child.on('exit', resolve);
+      child.on('error', () => resolve(1));
+    });
+
+    removePid(WORKER_PID_FILE);
+
+    // Clean exit (0) = user Ctrl+C or graceful shutdown — stop supervising
+    if (exitCode === 0) {
+      removePid(PID_FILE);
+      process.exit(0);
+    }
+
+    const elapsed = Date.now() - startTime;
+    if (elapsed < CRASH_WINDOW) {
+      consecutiveCrashes++;
+    } else {
+      consecutiveCrashes = 0; // ran long enough — reset crash counter
+    }
+
+    const backoff = BACKOFF_MS[Math.min(consecutiveCrashes - 1, BACKOFF_MS.length - 1)] ?? BACKOFF_MS[0];
+    console.log(`\n[supervisor] Worker exited (code ${exitCode ?? 'null'}), crash #${consecutiveCrashes} — restarting in ${backoff}ms...`);
+    await new Promise(r => setTimeout(r, backoff));
+    console.log('[supervisor] Restarting worker...\n');
+  }
+}
+
+/**
+ * Detach: spawn this binary as a background supervisor, then return control
+ * to the shell immediately. The background process runs runSupervisor().
+ * @param {string[]} supervisorArgv  argv for the background supervisor (without --detach)
+ */
+export function detachSupervisor(supervisorArgv) {
+  const logFile = path.join(CONFIG_DIR, 'worker.log');
+  mkdirSync(CONFIG_DIR, { recursive: true });
+
+  const child = spawn(process.execPath, [process.argv[1], ...supervisorArgv], {
+    detached: true,
+    stdio: ['ignore', 'ignore', 'ignore'],
+    env: { ...process.env, AGENTFORGE_SKIP_UPDATE: '1' },
+  });
+
+  child.unref();
+
+  writePid(PID_FILE, child.pid);
+  console.log(`✅ AgentForge worker started in background (PID ${child.pid})`);
+  console.log(`   Logs: ${logFile}`);
+  console.log(`   Stop: agentforge stop`);
+}
+
+/**
+ * Stop a running background supervisor by sending SIGTERM to the PID in the pid file.
+ */
+export function stopSupervisor() {
+  if (!existsSync(PID_FILE)) {
+    console.log('No running supervisor found.');
+    return;
+  }
+  try {
+    const pid = parseInt(readFileSync(PID_FILE, 'utf8'));
+    process.kill(pid, 'SIGTERM');
+    removePid(PID_FILE);
+    console.log(`Stopped supervisor (PID ${pid})`);
+  } catch (e) {
+    console.log('Supervisor not running or already stopped.');
+    removePid(PID_FILE);
+  }
+}

package/src/worker.js

@@ -4,6 +4,7 @@ import WebSocket from 'ws';
 import { OpenClawCLI } from './OpenClawCLI.js';
 import { HampAgentCLI } from './HampAgentCLI.js';
 import { OllamaAgent } from './OllamaAgent.js';
+import { resolveOpenclawModule } from './resolveOpenclaw.js';
 import EventEmitter from 'events';
 import path from 'path';
 import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, copyFileSync, statSync, unlinkSync, openSync } from 'fs';
@@ -184,8 +185,11 @@ export class AgentForgeWorker extends EventEmitter {
     // Spawn openclaw-gateway as a child of this worker process.
     // When the worker exits (Ctrl+C in terminal), the gateway dies with it.
     // No LaunchAgent needed — the terminal session owns everything.
-    const openclaw = process.env.OPENCLAW_PATH ||
-      '/Users/hamp/.npm-global/lib/node_modules/openclaw/dist/index.js';
+    const openclaw = resolveOpenclawModule();
+    if (!openclaw) {
+      console.warn('⚠️  openclaw not found — browser tools unavailable. Install with: npm install -g openclaw');
+      return;
+    }
     const port = 18789;
     const logDir = path.join(homedir(), '.openclaw', 'logs');
     mkdirSync(logDir, { recursive: true });
@@ -1128,7 +1132,7 @@ export class AgentForgeWorker extends EventEmitter {
         `- VIEWING/TESTING A WEB APP: Always check for a deployed URL first — look in the project for railway.toml, vercel.json, netlify.toml, .env, README.md, or package.json for a live URL. Open the deployed app in the browser. Only spin up a local server if there is genuinely no deployed version. Never default to localhost when a live URL might exist.`,
         `- LOCAL SERVERS: If you must use localhost, try http://127.0.0.1:PORT if http://localhost:PORT fails. Do not stop and ask — just try both.`,
         `- CREATING AGENTS AND CHATTING WITH THEM: Open the browser to https://agentforgeai-production.up.railway.app/dashboard. Click + to create a new agent. Click into that new agent's chat panel. Type a message into the chat input and send it — IN THE BROWSER, not via sessions_send. NEVER use sessions_send or sessions_spawn for this — those do not open a visible chat. The entire interaction happens inside the browser UI, start to finish, exactly like a human clicking around the dashboard.`,
-        `- Your runner: ${useHampagent ? 'Hampagent' : 'OpenClaw'}.`,
+        `- Your runner: ${useHampagent ? 'Hampagent' : 'OpenClaw'}. Running on: ${homedir().split('/').pop()}@${hostname()}.`,
         (!conversationHistory || conversationHistory.length === 0)
           ? `- This is the first message. When greeting, say: "I'm [your name] — your ${useHampagent ? 'Hampagent' : 'OpenClaw'} agent running on AgentForge." Never say "autonomous AI agent". Never list capabilities in an intro.`
           : `- This is a continuing conversation. Do NOT re-introduce yourself.`,