@hamp10/agentforge 0.1.0

package/bin/agentforge.js

@@ -0,0 +1,558 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import open from 'open';
+import { execSync, spawn } from 'child_process';
+import { AgentForgeWorker } from '../src/worker.js';
+import { OpenClawCLI } from '../src/OpenClawCLI.js';
+
+const CONFIG_DIR = path.join(os.homedir(), '.agentforge');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+const program = new Command();
+
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+}
+
+function loadConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+  } catch (error) {
+    console.error('❌ Failed to load config:', error.message);
+    return {};
+  }
+}
+
+function saveConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+program
+  .name('agentforge')
+  .description('AgentForge worker - connect your machine to agentforge.ai')
+  .version('0.1.0');
+
+program
+  .command('login')
+  .description('Authenticate with AgentForge')
+  .option('--url <url>', 'Custom AgentForge URL')
+  .option('--token <token>', 'Pre-issued auth token (skips OAuth browser flow)')
+  .action(async (options) => {
+    const baseUrl = options.url || process.env.AGENTFORGE_URL || 'https://agentforgeai-production.up.railway.app';
+    const preToken = options.token || process.env.AGENTFORGE_TOKEN;
+
+    console.log('');
+    console.log('🔐 Authenticating with AgentForge');
+    console.log('================================');
+    console.log('');
+
+    try {
+      let token;
+
+      if (preToken) {
+        // ── Pre-issued token path — no browser, no polling ──────────────────
+        console.log('🔑 Using pre-issued token...');
+
+        // Validate the token with the server
+        const validateResponse = await fetch(`${baseUrl}/api/cli/auth/validate`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ token: preToken })
+        });
+
+        if (!validateResponse.ok) {
+          throw new Error(`Token validation failed: ${validateResponse.statusText}`);
+        }
+
+        const validateData = await validateResponse.json();
+        if (!validateData.success) {
+          throw new Error(validateData.error || 'Invalid or expired token');
+        }
+
+        token = preToken;
+      } else {
+        // ── Standard device-code OAuth flow ─────────────────────────────────
+
+        // Step 1: Request device code
+        console.log('📡 Requesting authentication...');
+        const deviceResponse = await fetch(`${baseUrl}/api/cli/auth/device`, {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' }
+        });
+
+        if (!deviceResponse.ok) {
+          throw new Error(`Failed to get device code: ${deviceResponse.statusText}`);
+        }
+
+        const deviceData = await deviceResponse.json();
+        const { device_code, user_code, verification_uri, interval } = deviceData;
+
+        // Step 2: Show user code and open browser
+        console.log('');
+        console.log('✨ Your authentication code:');
+        console.log('');
+        console.log(`   ${user_code}`);
+        console.log('');
+        console.log('🌐 Opening browser for authentication...');
+        console.log(`   ${verification_uri}?code=${user_code}`);
+        console.log('');
+
+        await open(`${verification_uri}?code=${user_code}`);
+
+        console.log('⏳ Waiting for approval...');
+        console.log('');
+
+        // Step 3: Poll for approval
+        const pollInterval = (interval || 5) * 1000;
+        let attempts = 0;
+        const maxAttempts = 120; // 10 minutes
+
+        token = await new Promise((resolve, reject) => {
+          const pollTimer = setInterval(async () => {
+            attempts++;
+
+            if (attempts > maxAttempts) {
+              clearInterval(pollTimer);
+              reject(new Error('Authentication timeout'));
+              return;
+            }
+
+            try {
+              const pollResponse = await fetch(`${baseUrl}/api/cli/auth/poll`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ device_code })
+              });
+
+              const pollData = await pollResponse.json();
+
+              if (pollData.success && pollData.token) {
+                clearInterval(pollTimer);
+                resolve(pollData.token);
+              } else if (pollData.error) {
+                clearInterval(pollTimer);
+                reject(new Error(pollData.error));
+              }
+              // Otherwise keep polling
+            } catch (error) {
+              clearInterval(pollTimer);
+              reject(error);
+            }
+          }, pollInterval);
+        });
+      }
+
+      // Save token and URL
+      const config = loadConfig();
+      config.token = token;
+      config.url = baseUrl;
+      saveConfig(config);
+
+      console.log('✅ Authentication successful!');
+      console.log('');
+      console.log('Next step:  agentforge start');
+      console.log('');
+    } catch (error) {
+      console.error('❌ Authentication failed:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('start')
+  .description('Start worker and connect to AgentForge')
+  .option('-u, --url <url>', 'Custom AgentForge URL (overrides saved config)')
+  .action(async (options) => {
+    const config = loadConfig();
+
+    if (!config.token) {
+      console.error('❌ Not authenticated. Run: agentforge login');
+      process.exit(1);
+    }
+
+    // Check that a working AI backend is configured
+    if (config.provider !== 'local' && !OpenClawCLI.isAvailable()) {
+      console.error('');
+      console.error('❌ No AI backend configured.');
+      console.error('');
+      console.error('   AgentForge needs an AI model to run agents.');
+      console.error('   Configure a local model server (Ollama, LM Studio, Jan, etc.):');
+      console.error('');
+      console.error('     agentforge local --url http://localhost:11434 --model llama3.1:8b');
+      console.error('');
+      console.error('   Then run:  agentforge start');
+      console.error('');
+      process.exit(1);
+    }
+
+    // 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';
+
+    console.log('');
+    console.log('🚀 Starting AgentForge Worker');
+    console.log('================================');
+    console.log(`📡 Connecting to: ${wsUrl}`);
+    console.log('');
+
+    // Tee all console output to ~/.agentforge/worker.log (rolling at 5MB)
+    const logFile = path.join(CONFIG_DIR, 'worker.log');
+    const MAX_LOG_BYTES = 5 * 1024 * 1024;
+    let logStream = fs.createWriteStream(logFile, { flags: 'a' });
+    logStream.write(`\n\n===== Worker started ${new Date().toISOString()} =====\n\n`);
+    const writeLog = (level, args) => {
+      const line = `[${new Date().toISOString()}] [${level}] ${args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ')}\n`;
+      try {
+        logStream.write(line);
+        if (fs.statSync(logFile).size > MAX_LOG_BYTES) {
+          logStream.end();
+          try { fs.renameSync(logFile, logFile + '.old'); } catch {}
+          logStream = fs.createWriteStream(logFile, { flags: 'a' });
+          logStream.write(`===== Log rolled ${new Date().toISOString()} =====\n`);
+        }
+      } catch {} // never crash due to log failure
+    };
+    const _origLog = console.log.bind(console);
+    const _origErr = console.error.bind(console);
+    const _origWarn = console.warn.bind(console);
+    console.log   = (...a) => { _origLog(...a);   writeLog('LOG', a); };
+    console.error = (...a) => { _origErr(...a);   writeLog('ERR', a); };
+    console.warn  = (...a) => { _origWarn(...a);  writeLog('WRN', a); };
+
+    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(); });
+
+    try {
+      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);
+      }
+
+      console.log('');
+      console.log('✅ Worker running');
+      console.log('   Press Ctrl+C to stop');
+      console.log('');
+    } catch (error) {
+      console.error('❌ Failed to start worker:', error.message);
+      process.exit(1);
+    }
+  });
+
+program
+  .command('status')
+  .description('Check worker configuration')
+  .action(() => {
+    const config = loadConfig();
+
+    console.log('');
+    console.log('📊 AgentForge Worker Status');
+    console.log('================================');
+    console.log(`Authenticated: ${config.token ? '✅ Yes' : '❌ No'}`);
+
+    // Backend status
+    if (config.provider === 'local') {
+      console.log(`AI Backend:    ✅ Local model (${config.localModel || 'llama3.1:8b'} @ ${config.localUrl || 'http://localhost:11434'})`);
+    } else if (OpenClawCLI.isAvailable()) {
+      console.log(`AI Backend:    ✅ openclaw`);
+    } else {
+      console.log(`AI Backend:    ❌ Not configured`);
+    }
+
+    console.log(`Config file: ${CONFIG_FILE}`);
+    console.log('');
+
+    if (!config.token) {
+      console.log('Run: agentforge login');
+    } else if (config.provider !== 'local' && !OpenClawCLI.isAvailable()) {
+      console.log('Configure a backend first:  agentforge local --url http://localhost:11434 --model llama3.1:8b');
+    } else {
+      console.log('Ready to connect! Run: agentforge start');
+    }
+    console.log('');
+  });
+
+program
+  .command('logout')
+  .description('Remove authentication token')
+  .action(() => {
+    if (fs.existsSync(CONFIG_FILE)) {
+      fs.unlinkSync(CONFIG_FILE);
+      console.log('✅ Logged out successfully');
+    } else {
+      console.log('Not currently logged in');
+    }
+  });
+
+program
+  .command('local')
+  .description('Configure a local model backend (Ollama, LM Studio, Jan, llama.cpp, etc.)')
+  .option('--url <url>', 'Base URL of the local server', 'http://localhost:11434')
+  .option('--model <model>', 'Model name to use', 'llama3.1:8b')
+  .option('--reset', 'Switch back to openclaw (default) backend')
+  .action(async (options) => {
+    const config = loadConfig();
+
+    if (options.reset) {
+      delete config.provider;
+      delete config.localUrl;
+      delete config.localModel;
+      saveConfig(config);
+      console.log('✅ Reset to openclaw backend');
+      return;
+    }
+
+    // Validate the server is reachable
+    console.log(`\n🦙 Testing connection to ${options.url}...`);
+    try {
+      const res = await fetch(`${options.url}/v1/models`, { signal: AbortSignal.timeout(5000) });
+      if (res.ok) {
+        const data = await res.json();
+        const models = data.data?.map(m => m.id) ?? [];
+        console.log(`✅ Connected! Available models: ${models.slice(0, 5).join(', ') || '(none listed)'}`);
+      } else {
+        console.log(`⚠️  Server responded with ${res.status} — saving anyway`);
+      }
+    } catch (err) {
+      console.log(`⚠️  Could not reach ${options.url} (${err.message})`);
+      console.log(`   Make sure your local server is running before starting the worker.`);
+    }
+
+    config.provider = 'local';
+    config.localUrl = options.url;
+    config.localModel = options.model;
+    saveConfig(config);
+
+    console.log('');
+    console.log('✅ Local model backend configured:');
+    console.log(`   URL:   ${options.url}`);
+    console.log(`   Model: ${options.model}`);
+    console.log('');
+    console.log('Run: agentforge start');
+    console.log('');
+    console.log('To switch back to openclaw: agentforge local --reset');
+    console.log('');
+  });
+
+program
+  .command('refresh-token')
+  .description('Refresh expired Anthropic token across all openclaw agents')
+  .action(async () => {
+    const { execSync, spawnSync } = await import('child_process');
+    const { glob } = await import('fs');
+    const { promisify } = await import('util');
+    const globAsync = promisify(glob);
+
+    console.log('');
+    console.log('🔑 Refreshing Anthropic token');
+    console.log('================================');
+    console.log('');
+    console.log('Step 1: Run  claude setup-token  in a NEW terminal, then paste the token here.');
+    console.log('');
+
+    const readline = await import('readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const newToken = await new Promise(resolve => rl.question('Paste token: ', ans => { rl.close(); resolve(ans.trim()); }));
+
+    if (!newToken.startsWith('sk-ant-')) {
+      console.error('❌ Invalid token format');
+      process.exit(1);
+    }
+
+    console.log('');
+    console.log('Step 2: Updating all agent auth-profiles...');
+
+    const agentsDir = path.join(os.homedir(), '.openclaw', 'agents');
+    if (!fs.existsSync(agentsDir)) {
+      console.error('❌ No openclaw agents directory found');
+      process.exit(1);
+    }
+
+    let updated = 0;
+    const dirs = fs.readdirSync(agentsDir);
+    for (const dir of dirs) {
+      const authPath = path.join(agentsDir, dir, 'agent', 'auth-profiles.json');
+      if (!fs.existsSync(authPath)) continue;
+      try {
+        const data = JSON.parse(fs.readFileSync(authPath, 'utf-8'));
+        let changed = false;
+        for (const profile of Object.values(data?.profiles || {})) {
+          if (profile?.provider === 'anthropic' && profile?.token) {
+            profile.token = newToken;
+            changed = true;
+          }
+        }
+        if (changed) {
+          fs.writeFileSync(authPath, JSON.stringify(data, null, 2));
+          updated++;
+        }
+      } catch {}
+    }
+
+    console.log(`✅ Updated ${updated} agent auth files`);
+    console.log('');
+    console.log('Now run: agentforge start');
+    console.log('');
+  });
+
+program
+  .command('setup')
+  .description('Full device setup: AgentForge login + Anthropic auth + Tailscale')
+  .option('--tailscale-key <key>', 'Tailscale auth key (from tailscale.com/admin/settings/keys)')
+  .action(async (options) => {
+    const { execSync, spawnSync } = await import('child_process');
+
+    console.log('');
+    console.log('🚀 AgentForge Device Setup');
+    console.log('================================');
+    console.log('');
+
+    // 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 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('');
+
+    // Step 3: Tailscale
+    console.log('Step 3/3: Tailscale (remote access from any network)');
+    console.log('');
+
+    const tailscaleInstalled = spawnSync('which', ['tailscale'], { encoding: 'utf-8' }).status === 0;
+
+    if (tailscaleInstalled) {
+      console.log('✅ Tailscale already installed');
+    } else {
+      console.log('Installing Tailscale...');
+      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');
+      }
+    }
+
+    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');
+      }
+    } 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');
+    }
+
+    console.log('');
+    console.log('✅ Setup complete! Run: agentforge start');
+    console.log('');
+  });
+
+// ── Browser helpers ──────────────────────────────────────────────────────────
+
+function findChrome() {
+  const candidates = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) return c;
+  }
+  return null;
+}
+
+function isBrowserRunning() {
+  try {
+    const out = execSync('pgrep -f "remote-debugging-port=9223" 2>/dev/null || true').toString().trim();
+    return out.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function seedBrowserProfile() {
+  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
+  fs.mkdirSync(destDir, { recursive: true });
+  const files = ['Cookies', 'Login Data', 'Web Data'];
+  for (const f of files) {
+    const src = path.join(srcDir, f);
+    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 {}
+  }
+}
+
+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();
+  return true;
+}
+
+program
+  .command('browser')
+  .description('Launch the AgentForge browser')
+  .option('--url <url>', 'URL to open', 'https://agentforgeai-production.up.railway.app/dashboard')
+  .action((options) => {
+    if (isBrowserRunning()) {
+      console.log('✅ AgentForge browser already running');
+      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);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@hamp10/agentforge",
+  "version": "0.1.0",
+  "description": "AgentForge worker — connect your machine to agentforge.ai",
+  "type": "module",
+  "bin": {
+    "agentforge": "./bin/agentforge.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "templates"
+  ],
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.80.0",
+    "commander": "^12.0.0",
+    "open": "^10.0.0",
+    "puppeteer-core": "^24.40.0",
+    "tree-kill": "^1.2.2",
+    "ws": "^8.16.0"
+  }
+}