@hamp10/agentforge 0.1.0 → 0.2.0

package/bin/agentforge.js

@@ -8,10 +8,23 @@ 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');
 
+process.on('unhandledRejection', (reason) => {
+  console.error('❌ Unhandled promise rejection:', reason instanceof Error ? reason.message : reason);
+  if (reason instanceof Error && reason.stack) {
+    console.error(reason.stack.split('\n').slice(0, 4).join('\n'));
+  }
+});
+process.on('uncaughtException', (err) => {
+  console.error('❌ Uncaught exception:', err.message);
+  console.error(err.stack?.split('\n').slice(0, 4).join('\n') || '');
+});
+
 const program = new Command();
 
 function ensureConfigDir() {
@@ -173,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) {
@@ -196,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';
@@ -241,11 +282,7 @@ program
       await worker.initialize();
       await worker.connect();
 
-      // Auto-launch AgentForge browser if not already running
-      if (!isBrowserRunning()) {
-        const dashboardUrl = baseUrl.replace(/^ws/, 'http') + '/dashboard';
-        launchBrowser(dashboardUrl);
-      }
+      // Agent browser starts on-demand when an agent needs browser tools — not at worker start.
 
       console.log('');
       console.log('✅ Worker running');
@@ -477,10 +514,31 @@ program
   });
 
 // ── Browser helpers ──────────────────────────────────────────────────────────
+// Agents use a dedicated browser profile on port 9223 — isolated from the
+// user's real browser, but seeded with Chrome cookies when Chrome is available
+// (both share the same "Chrome Safe Storage" Keychain key, so cookies decrypt).
+// Non-Chrome users get the same isolated profile but log in manually once.
+// A LaunchAgent keeps the agent browser running on every login.
+
+const CDP_PORT = 9223;
+const BROWSER_PROFILE_DIR = path.join(CONFIG_DIR, 'browser');
+const LAUNCH_AGENT_LABEL = 'ai.agentforge.browser';
+const LAUNCH_AGENT_PLIST = path.join(
+  os.homedir(), 'Library', 'LaunchAgents', `${LAUNCH_AGENT_LABEL}.plist`
+);
+const CHROME_BIN = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+
+// Returns Google Chrome path if installed — required for cookie seeding
+// (shared "Chrome Safe Storage" Keychain key makes copied cookies readable).
+function findGoogleChrome() {
+  return fs.existsSync(CHROME_BIN) ? CHROME_BIN : null;
+}
 
-function findChrome() {
+// Returns the best available browser for running the agent profile.
+// Prefers Chrome (for seeding compatibility) but falls back to others.
+function findBrowser() {
   const candidates = [
-    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    CHROME_BIN,
     '/Applications/Chromium.app/Contents/MacOS/Chromium',
     '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
     '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
@@ -493,66 +551,354 @@ function findChrome() {
 
 function isBrowserRunning() {
   try {
-    const out = execSync('pgrep -f "remote-debugging-port=9223" 2>/dev/null || true').toString().trim();
+    const out = execSync(`pgrep -f "remote-debugging-port=${CDP_PORT}" 2>/dev/null || true`).toString().trim();
     return out.length > 0;
   } catch {
     return false;
   }
 }
 
-function seedBrowserProfile() {
+// Check if the agent browser profile has an active Google session.
+function isGoogleLoggedIn() {
+  const cookiePath = path.join(BROWSER_PROFILE_DIR, 'Default', 'Cookies');
+  if (!fs.existsSync(cookiePath)) return false;
+  try {
+    const count = execSync(
+      `sqlite3 "${cookiePath}" "SELECT COUNT(*) FROM cookies WHERE host_key LIKE '%.google.com' AND name='SID';" 2>/dev/null`
+    ).toString().trim();
+    return parseInt(count) > 0;
+  } catch { return false; }
+}
+
+// Copies Chrome session data into the agent browser profile so agents start
+// already logged in. Only works with Google Chrome (shared Keychain key).
+// NEVER overwrites Google cookies — Google session-binds cookies to browser
+// fingerprint, so any manually-logged-in Google session must be preserved.
+// Pass force=true to re-copy everything except Google cookies.
+// Must be called while the agent browser is NOT running (Cookies file is locked).
+function seedBrowserProfile(force = false) {
+  const chrome = findGoogleChrome();
+  if (!chrome) return 'no-chrome';
   const srcDir = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome', 'Default');
-  const destDir = path.join(CONFIG_DIR, 'browser', 'Default');
-  if (!fs.existsSync(srcDir)) return;
-  if (fs.existsSync(destDir)) return; // already seeded
+  const destDir = path.join(BROWSER_PROFILE_DIR, 'Default');
+  if (!fs.existsSync(srcDir)) return 'no-chrome';
+  const destCookies = path.join(destDir, 'Cookies');
+  if (!force && fs.existsSync(destCookies)) return 'already-seeded';
   fs.mkdirSync(destDir, { recursive: true });
-  const files = ['Cookies', 'Login Data', 'Web Data'];
-  for (const f of files) {
+
+  // Non-cookie files: always copy
+  for (const f of ['Login Data', 'Web Data', 'Preferences', 'Bookmarks', 'Bookmarks.bak']) {
     const src = path.join(srcDir, f);
-    if (fs.existsSync(src)) {
-      try { fs.copyFileSync(src, path.join(destDir, f)); } catch {}
-    }
+    if (fs.existsSync(src)) try { fs.copyFileSync(src, path.join(destDir, f)); } catch {}
   }
-  const lsDir = path.join(srcDir, 'Local Storage');
-  const lsDest = path.join(destDir, 'Local Storage');
-  if (fs.existsSync(lsDir) && !fs.existsSync(lsDest)) {
-    try {
-      fs.cpSync(lsDir, lsDest, { recursive: true });
-    } catch {}
+  for (const dir of ['Local Storage', 'IndexedDB']) {
+    const src = path.join(srcDir, dir);
+    const dest = path.join(destDir, dir);
+    if (fs.existsSync(src)) try { fs.cpSync(src, dest, { recursive: true, force: true }); } catch {}
+  }
+
+  // Cookies: if agent browser already has a Google session, preserve it.
+  // Copy Chrome cookies but restore any existing Google cookies on top.
+  const srcCookies = path.join(srcDir, 'Cookies');
+  if (!fs.existsSync(srcCookies)) return 'seeded';
+
+  if (fs.existsSync(destCookies) && isGoogleLoggedIn()) {
+    // Preserve Google session: copy Chrome cookies via Python, skip google.com rows
+    const py = `
+import sqlite3, shutil, os, sys
+src = sqlite3.connect("${srcCookies.replace(/"/g, '\\"')}")
+dst_path = "${destCookies.replace(/"/g, '\\"')}"
+tmp = dst_path + ".new"
+shutil.copy2("${srcCookies.replace(/"/g, '\\"')}", tmp)
+# Load saved Google cookies from existing agent browser db
+old = sqlite3.connect(dst_path)
+old.row_factory = sqlite3.Row
+google_rows = old.execute("SELECT * FROM cookies WHERE host_key LIKE '%.google.com' OR host_key='accounts.google.com'").fetchall()
+old.close()
+# Write them into the new cookie db
+new_db = sqlite3.connect(tmp)
+for row in google_rows:
+    cols = row.keys()
+    new_db.execute(f"DELETE FROM cookies WHERE host_key=? AND name=?", (row['host_key'], row['name']))
+    ph = ','.join(['?' for _ in cols])
+    try: new_db.execute(f"INSERT INTO cookies ({','.join(cols)}) VALUES ({ph})", tuple(row[c] for c in cols))
+    except: pass
+new_db.commit(); new_db.close()
+os.replace(tmp, dst_path)
+print('ok')
+`;
+    const pyFile = path.join(os.tmpdir(), 'af_seed_cookies.py');
+    fs.writeFileSync(pyFile, py);
+    try { execSync(`python3 "${pyFile}" 2>/dev/null`); } catch {}
+  } else {
+    // No existing Google session — copy cookies wholesale (first-time setup)
+    try { fs.copyFileSync(srcCookies, destCookies); } catch {}
+  }
+
+  return 'seeded';
+}
+
+// Live-syncs session cookies from Chrome to the agent browser using Python/sqlite3.
+// Works while BOTH browsers are running — no restart needed.
+// Returns the number of cookies synced or -1 on error.
+function syncSessionCookies() {
+  const chrome = findGoogleChrome();
+  if (!chrome) return 0;
+  const srcDb = path.join(os.homedir(), 'Library', 'Application Support', 'Google', 'Chrome', 'Default', 'Cookies');
+  const destDb = path.join(BROWSER_PROFILE_DIR, 'Default', 'Cookies');
+  if (!fs.existsSync(srcDb) || !fs.existsSync(destDb)) return 0;
+
+  const py = `
+import sqlite3, sys
+src = sqlite3.connect("${srcDb.replace(/"/g, '\\"')}")
+dst = sqlite3.connect("${destDb.replace(/"/g, '\\"')}")
+src.row_factory = sqlite3.Row
+rows = src.execute("SELECT * FROM cookies WHERE host_key LIKE '%agentforgeai%' OR host_key='localhost'").fetchall()
+count = 0
+for row in rows:
+    cols = row.keys()
+    vals = tuple(row[c] for c in cols)
+    try:
+        dst.execute(f"DELETE FROM cookies WHERE host_key=? AND name=?", (row['host_key'], row['name']))
+        ph = ','.join(['?' for _ in cols])
+        dst.execute(f"INSERT INTO cookies ({','.join(cols)}) VALUES ({ph})", vals)
+        count += 1
+    except Exception as e:
+        pass
+dst.commit()
+src.close(); dst.close()
+print(count)
+`;
+  try {
+    const pyFile = path.join(os.tmpdir(), 'af_cookie_sync.py');
+    fs.writeFileSync(pyFile, py);
+    const result = execSync(`python3 "${pyFile}" 2>/dev/null`).toString().trim();
+    return parseInt(result) || 0;
+  } catch { return -1; }
+}
+
+// Creates /Applications/AgentForge Browser.app — a Chrome wrapper that:
+//  - Appears as a distinct app in the dock (own icon, own name)
+//  - Launches Chrome with the agent profile flags
+//  - Shares Chrome's "Chrome Safe Storage" Keychain key so seeded cookies work
+// Falls back to ~/Applications if /Applications isn't writable.
+function installAgentBrowserApp() {
+  const chrome = findGoogleChrome();
+  if (!chrome) return null; // Chrome required — Chromium can't share Keychain
+
+  const appName = 'AgentForge Browser.app';
+  let appDir = path.join('/Applications', appName);
+  try {
+    fs.mkdirSync(path.join(appDir, 'Contents', 'MacOS'), { recursive: true });
+    fs.mkdirSync(path.join(appDir, 'Contents', 'Resources'), { recursive: true });
+  } catch {
+    appDir = path.join(os.homedir(), 'Applications', appName);
+    fs.mkdirSync(path.join(appDir, 'Contents', 'MacOS'), { recursive: true });
+    fs.mkdirSync(path.join(appDir, 'Contents', 'Resources'), { recursive: true });
   }
+
+  // Info.plist — distinct bundle ID so macOS treats this as a separate app
+  fs.writeFileSync(path.join(appDir, 'Contents', 'Info.plist'), `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleName</key><string>AgentForge Browser</string>
+  <key>CFBundleDisplayName</key><string>AgentForge Browser</string>
+  <key>CFBundleIdentifier</key><string>ai.agentforge.browser-app</string>
+  <key>CFBundleExecutable</key><string>AgentForge Browser</string>
+  <key>CFBundleIconFile</key><string>AppIcon</string>
+  <key>CFBundlePackageType</key><string>APPL</string>
+  <key>CFBundleVersion</key><string>1.0</string>
+  <key>NSHighResolutionCapable</key><true/>
+  <key>LSMinimumSystemVersion</key><string>12.0</string>
+</dict>
+</plist>`);
+
+  // Executable — shell script that launches Chrome with agent flags.
+  // Uses spawn (not exec) so macOS associates the process with this app bundle.
+  const execPath = path.join(appDir, 'Contents', 'MacOS', 'AgentForge Browser');
+  fs.writeFileSync(execPath, `#!/bin/bash
+CHROME="${chrome}"
+PROFILE_DIR="$HOME/.agentforge/browser"
+
+if [ ! -f "$CHROME" ]; then
+  osascript -e 'display alert "AgentForge Browser" message "Google Chrome is required but was not found."'
+  exit 1
+fi
+
+"$CHROME" \\
+  --remote-debugging-port=${CDP_PORT} \\
+  --user-data-dir="$PROFILE_DIR" \\
+  --no-first-run \\
+  --no-default-browser-check \\
+  --disable-sync \\
+  --disable-component-update \\
+  --safebrowsing-disable-auto-update \\
+  "$@"
+`);
+  fs.chmodSync(execPath, 0o755);
+
+  // Generate icon with Python (graceful no-op if unavailable)
+  _generateAppIcon(path.join(appDir, 'Contents', 'Resources'));
+
+  // Ad-hoc sign + remove quarantine
+  try { execSync(`codesign --sign - --force "${appDir}" 2>/dev/null`); } catch {}
+  try { execSync(`xattr -rd com.apple.quarantine "${appDir}" 2>/dev/null`); } catch {}
+
+  // Register with Launch Services so it appears in Spotlight/dock
+  const lsreg = '/System/Library/Frameworks/CoreServices.framework/Frameworks/LaunchServices.framework/Support/lsregister';
+  try { execSync(`"${lsreg}" -f "${appDir}" 2>/dev/null`); } catch {}
+
+  return appDir;
 }
 
-function launchBrowser(dashboardUrl) {
-  const chrome = findChrome();
-  if (!chrome) return false;
-  const profileDir = path.join(CONFIG_DIR, 'browser');
-  seedBrowserProfile();
-  const proc = spawn(chrome, [
-    `--remote-debugging-port=9223`,
-    `--user-data-dir=${profileDir}`,
-    '--no-first-run',
-    '--no-default-browser-check',
-    dashboardUrl,
-  ], { detached: true, stdio: 'ignore' });
-  proc.unref();
+function _generateAppIcon(resourcesDir) {
+  const icnsPath = path.join(resourcesDir, 'AppIcon.icns');
+  if (fs.existsSync(icnsPath)) return; // already generated
+  const pyScript = path.join(os.tmpdir(), 'af_browser_icon.py');
+  fs.writeFileSync(pyScript, `
+try:
+    from PIL import Image, ImageDraw
+except ImportError:
+    import subprocess, sys
+    subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'Pillow', '-q'])
+    from PIL import Image, ImageDraw
+import os, subprocess, tempfile
+
+size = 1024
+img = Image.new('RGBA', (size, size), (0, 0, 0, 0))
+draw = ImageDraw.Draw(img)
+cx, cy = size // 2, size // 2
+
+draw.ellipse([cx-460, cy-460, cx+460, cy+460], fill=(10, 10, 12, 255))
+
+bar_top, bar_h = cy - 260, 90
+bar_l, bar_r = cx - 290, cx + 290
+draw.rounded_rectangle([bar_l, bar_top, bar_r, bar_top+bar_h], radius=18, fill=(255, 107, 53, 255))
+for i, col in enumerate([(232,70,60,255),(255,185,30,255),(39,199,109,255)]):
+    dx = bar_l + 38 + i*38
+    draw.ellipse([dx-11, cy-260+45-11, dx+11, cy-260+45+11], fill=col)
+draw.rounded_rectangle([bar_l+130, bar_top+18, bar_r-18, bar_top+bar_h-18], radius=10, fill=(30,30,35,220))
+
+vp_top, vp_bot = bar_top+bar_h+14, cy+280
+draw.rounded_rectangle([bar_l, vp_top, bar_r, vp_bot], radius=18, fill=(20,20,25,255))
+
+af = (255,107,53,255)
+mx, my, s = cx, (vp_top+vp_bot)//2-10, 22
+draw.polygon([(mx-90,my+90),(mx-90+s,my+90),(mx,my-90),(mx-s//2,my-90)], fill=af)
+draw.polygon([(mx+90,my+90),(mx+90-s,my+90),(mx,my-90),(mx+s//2,my-90)], fill=af)
+draw.rectangle([mx-52, my-8, mx+52, my+8+s], fill=af)
+
+png = os.path.join(tempfile.gettempdir(), 'af_icon_gen.png')
+iconset = os.path.join(tempfile.gettempdir(), 'af_icon.iconset')
+img.save(png)
+os.makedirs(iconset, exist_ok=True)
+for sz in [16,32,128,256,512]:
+    subprocess.run(['sips','-z',str(sz),str(sz),png,'--out',f'{iconset}/icon_{sz}x{sz}.png'], capture_output=True)
+    subprocess.run(['sips','-z',str(sz*2),str(sz*2),png,'--out',f'{iconset}/icon_{sz}x{sz}@2x.png'], capture_output=True)
+subprocess.run(['iconutil','-c','icns',iconset,'-o','${icnsPath}'], capture_output=True)
+print('ok')
+`);
+  try { execSync(`python3 "${pyScript}" 2>/dev/null`); } catch {}
+}
+
+function installLaunchAgent(browserPath, startupUrl = 'https://agentforgeai-production.up.railway.app/dashboard') {
+  const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LAUNCH_AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${browserPath}</string>
+    <string>--remote-debugging-address=0.0.0.0</string>
+    <string>--remote-debugging-port=${CDP_PORT}</string>
+    <string>--user-data-dir=${BROWSER_PROFILE_DIR}</string>
+    <string>--no-first-run</string>
+    <string>--no-default-browser-check</string>
+    <string>--disable-sync</string>
+    <string>--disable-component-update</string>
+    <string>--safebrowsing-disable-auto-update</string>
+    <string>${startupUrl}</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardErrorPath</key>
+  <string>${path.join(CONFIG_DIR, 'browser.log')}</string>
+</dict>
+</plist>`;
+  fs.mkdirSync(path.dirname(LAUNCH_AGENT_PLIST), { recursive: true });
+  fs.writeFileSync(LAUNCH_AGENT_PLIST, plist);
+  try { execSync(`launchctl load "${LAUNCH_AGENT_PLIST}" 2>/dev/null`); } catch {}
   return true;
 }
 
 program
   .command('browser')
-  .description('Launch the AgentForge browser')
-  .option('--url <url>', 'URL to open', 'https://agentforgeai-production.up.railway.app/dashboard')
+  .description('Manage the AgentForge agent browser')
+  .option('--url <url>', 'URL to open on launch', 'https://agentforgeai-production.up.railway.app/dashboard')
+  .option('--reseed', 'Re-copy Chrome sessions into agent browser to refresh expired logins (Chrome only)')
+  .option('--sync', 'Live-sync session cookies from Chrome to agent browser (no restart)')
   .action((options) => {
+    const browser = findBrowser();
+    if (!browser) {
+      console.error('❌ No browser found. Install Chrome: https://www.google.com/chrome');
+      process.exit(1);
+    }
+
+    if (options.sync) {
+      const n = syncSessionCookies();
+      if (n >= 0) console.log(`✅ Synced ${n} session cookie(s) from Chrome to agent browser.`);
+      else console.log('⚠️  Could not sync cookies — is Chrome installed?');
+      return;
+    }
+
+    if (options.reseed) {
+      const chrome = findGoogleChrome();
+      if (!chrome) {
+        console.error('❌ --reseed requires Google Chrome.');
+        console.error('   Without Chrome, log in manually in the agent browser window.');
+        process.exit(1);
+      }
+      if (isBrowserRunning()) {
+        console.log('Stopping agent browser to reseed...');
+        try { execSync(`launchctl unload "${LAUNCH_AGENT_PLIST}" 2>/dev/null`); } catch {}
+        execSync('sleep 2');
+      }
+      const result = seedBrowserProfile(true);
+      if (result === 'seeded') {
+        console.log('✅ Sessions refreshed. Log into Google in the browser window — everything else is ready.');
+      } else {
+        console.log('⚠️  Could not read Chrome profile.');
+      }
+      installLaunchAgent(browser);
+      console.log('✅ Agent browser restarted — log into Google in the browser window.');
+      return;
+    }
+
     if (isBrowserRunning()) {
-      console.log('✅ AgentForge browser already running');
+      console.log('✅ AgentForge Browser already running (port 9223)');
       return;
     }
-    const ok = launchBrowser(options.url);
-    if (!ok) {
-      console.error('❌ Could not find Chrome, Chromium, Brave, or Edge.');
-      console.error('   Install Chrome from https://www.google.com/chrome');
-      process.exit(1);
+
+    installAgentBrowserApp();
+    const result = seedBrowserProfile();
+    installLaunchAgent(browser);
+    if (result === 'seeded') {
+      console.log('✅ Agent browser launched — log into Google in the browser window (one time only).');
+    } else {
+      console.log('✅ Agent browser launched.');
     }
   });
 
+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.0",
+  "version": "0.2.0",
   "description": "AgentForge worker — connect your machine to agentforge.ai",
   "type": "module",
   "bin": {