@hamp10/agentforge 0.2.21 → 0.2.23

package/src/HampAgentCLI.js

@@ -1,125 +0,0 @@
-/**
- * HampAgentCLI — drop-in replacement for OpenClawCLI.
- * Uses claude CLI subprocess with stream-json — works with Claude Max plan, no API key needed.
- * Emits identical events (agent_output, tool_activity, agent_image, agent_alive, agent_completed)
- * so worker.js can route tasks to either runner transparently.
- */
-
-import { EventEmitter } from 'events';
-import { execSync } from 'child_process';
-import { HampAgentRunner } from './hampagent/runner.js';
-import { loadSessionId, saveSessionId, clearSession } from './hampagent/sessions.js';
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-
-/** Check that the claude CLI is available */
-function claudeAvailable() {
-  try { execSync('which claude', { stdio: 'pipe' }); return true; } catch { return false; }
-}
-
-export class HampAgentCLI extends EventEmitter {
-  constructor() {
-    super();
-    this.anthropicApiKey = null; // kept for API compat, not used
-    this._runners = new Map(); // agentId -> HampAgentRunner (active tasks only)
-  }
-
-  setAnthropicKey(key) { this.anthropicApiKey = key; }
-
-  async createAgent(agentId, workDir) {
-    return { agentId, workDir };
-  }
-
-  async getAgentIdentity(agentId) {
-    return null;
-  }
-
-  cancelAgent(agentId) {
-    const runner = this._runners.get(agentId);
-    if (runner) { runner.cancel(); this._runners.delete(agentId); return true; }
-    return false;
-  }
-
-  isAvailable() { return claudeAvailable(); }
-
-  async runAgentTask(agentId, task, workDir, sessionId = null, image = null, browserProfile = null, imageWorkDir = null) {
-    if (!claudeAvailable()) throw new Error('Hampagent: claude CLI not found — install Claude Code first');
-
-    // Load prior claude session ID for conversation continuity
-    const claudeSessionId = loadSessionId(agentId);
-
-    // Load AGENTFORGE.md if available in the agent workspace
-    let agentforgemd = null;
-    const afPath = path.join(workDir, 'AGENTFORGE.md');
-    if (existsSync(afPath)) {
-      try { agentforgemd = readFileSync(afPath, 'utf8'); } catch {}
-    }
-
-    const runner = new HampAgentRunner();
-    runner._agentId = agentId;
-    this._runners.set(agentId, runner);
-
-    // ── Forward runner events to worker.js as standard events ──────────────
-
-    runner.on('token', (text) => {
-      this.emit('agent_output', { agentId, output: text });
-      this.emit('agent_alive', { agentId });
-    });
-
-    runner.on('tool_start', ({ tool, label, input }) => {
-      this.emit('agent_alive', { agentId });
-      this.emit('tool_activity', {
-        agentId,
-        event: 'tool_start',
-        tool,
-        description: label,
-        toolInput: input,
-      });
-    });
-
-    runner.on('tool_end', ({ tool, success, error }) => {
-      this.emit('tool_activity', {
-        agentId,
-        event: 'tool_end',
-        tool,
-        description: success ? `✓ ${tool}` : `✗ ${tool}: ${error}`,
-      });
-    });
-
-    runner.on('image', (base64DataUrl) => {
-      this.emit('agent_image', { agentId, image: base64DataUrl });
-    });
-
-    const startTime = Date.now();
-
-    try {
-      const result = await runner.run(task, {
-        taskCwd: workDir,
-        workDir: imageWorkDir || workDir,
-        agentName: this._agentName,
-        agentEmoji: this._agentEmoji,
-        dashboardUrl: 'https://agentforgeai-production.up.railway.app/dashboard',
-        agentforgemd,
-        resumeSessionId: claudeSessionId,
-      });
-
-      // Save new claude session ID for next turn (or clear if session was stale)
-      if (result.sessionCleared) clearSession(agentId);
-      if (result.sessionId) saveSessionId(agentId, result.sessionId);
-
-      this._runners.delete(agentId);
-
-      const identity = {
-        identityName: this._agentName || agentId,
-        identityEmoji: this._agentEmoji || '🦅',
-      };
-      const duration = Date.now() - startTime;
-      this.emit('agent_completed', { agentId, duration, result: { output: result.text }, identity });
-      return { success: true, agentId, duration, result: { output: result.text }, identity };
-
-    } catch (err) {
-      this._runners.delete(agentId);
-      throw err;
-    }
-  }
-}

package/src/hampagent/browser.js

@@ -1,321 +0,0 @@
-/**
- * Hampagent Browser Tool — Puppeteer connected to AgentForge Browser (port 9223)
- * Uses puppeteer-core to attach to the already-running AgentForge Browser (Thorium).
- */
-
-import puppeteer from 'puppeteer-core';
-
-const BROWSER_URL = 'http://127.0.0.1:9223';
-
-let _browser = null;
-let _activePage = null; // explicitly tracked active page — updated by focus/navigate
-
-async function getBrowser() {
-  if (_browser && _browser.isConnected()) return _browser;
-  _browser = await puppeteer.connect({
-    browserURL: BROWSER_URL,
-    defaultViewport: null,
-  });
-  _browser.on('disconnected', () => { _browser = null; _activePage = null; });
-  return _browser;
-}
-
-// Return the active page. Priority:
-// 1. Explicitly focused page (_activePage)
-// 2. Page whose URL includes preferUrl
-// 3. Most recently opened real page (non-blank, non-chrome)
-// 4. Any non-closed page
-async function getPage(preferUrl) {
-  const browser = await getBrowser();
-
-  // Validate cached active page
-  if (_activePage && !_activePage.isClosed()) {
-    if (!preferUrl || _activePage.url().includes(preferUrl)) return _activePage;
-  }
-
-  const pages = await browser.pages();
-  const real = pages.filter(p => !p.isClosed() && !p.url().startsWith('chrome') && p.url() !== 'about:blank' && p.url() !== '');
-
-  if (preferUrl) {
-    const match = real.find(p => p.url().includes(preferUrl));
-    if (match) { _activePage = match; return match; }
-  }
-
-  if (real.length > 0) {
-    _activePage = real[real.length - 1];
-    return _activePage;
-  }
-
-  const any = pages.find(p => !p.isClosed());
-  if (any) { _activePage = any; return any; }
-  const fresh = await browser.newPage();
-  _activePage = fresh;
-  return fresh;
-}
-
-const _wait = (ms) => new Promise(r => setTimeout(r, ms));
-
-// Take a structured snapshot of a page — content + interactive elements + all inputs
-async function _snapshot(page) {
-  const url = page.url();
-  let title = '';
-  try { title = await page.title(); } catch {}
-
-  const browser = await getBrowser();
-  const allPages = await browser.pages();
-  const open = allPages.filter(p => !p.isClosed());
-  const tabLines = await Promise.all(open.map(async (p, i) => {
-    const u = p.url();
-    let t = '';
-    try { t = await p.title(); } catch {}
-    const active = (p === page) ? ' ← ACTIVE' : '';
-    return `  [tab ${i}] ${t || '(no title)'} — ${u}${active}`;
-  }));
-
-  const data = await page.evaluate(() => {
-    // All interactive clickable elements (buttons, links, tabs)
-    const clickEls = [...document.querySelectorAll('a,button,[role="button"],[role="link"],[role="tab"],[role="menuitem"]')];
-    const interactive = clickEls.slice(0, 80).map((el, i) => {
-      const label = (el.textContent || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim().replace(/\s+/g, ' ').slice(0, 80);
-      return label ? `[${i}] ${el.tagName.toLowerCase()}: ${label}` : null;
-    }).filter(Boolean);
-
-    // All form inputs — these are critical for filling in filters
-    const formEls = [...document.querySelectorAll('input,select,textarea')];
-    const inputs = formEls.slice(0, 40).map((el, i) => {
-      const name = el.name || el.id || el.getAttribute('placeholder') || '';
-      const type = el.type || el.tagName.toLowerCase();
-      const val = el.value || '';
-      const opts = el.tagName === 'SELECT'
-        ? Array.from(el.options).map(o => o.text.trim()).filter(Boolean).slice(0, 20).join(' | ')
-        : '';
-      return `[input-${i}] ${type} name="${name}" value="${val}"${opts ? ` options: ${opts}` : ''}`;
-    });
-
-    // Page text — scroll position 0 so we always capture the top of the page
-    window.scrollTo(0, 0);
-    const bodyText = (document.body?.innerText || '').replace(/\n{3,}/g, '\n\n').slice(0, 8000);
-
-    return { interactive, inputs, bodyText };
-  });
-
-  const lines = [
-    `Open tabs:`,
-    ...tabLines,
-    ``,
-    `Active tab — URL: ${url}`,
-    `Title: ${title}`,
-  ];
-
-  if (data.interactive.length) {
-    lines.push(``, `Clickable elements (use ref index with click action):`);
-    lines.push(...data.interactive);
-  }
-
-  if (data.inputs.length) {
-    lines.push(``, `Form inputs (use selector="#id" or selector="[name=x]" with type action):`);
-    lines.push(...data.inputs);
-  }
-
-  lines.push(``, `Page content:`, data.bodyText);
-  return lines.join('\n');
-}
-
-export async function browserAction(input) {
-  let browser;
-  try {
-    browser = await getBrowser();
-  } catch (err) {
-    _browser = null; _activePage = null;
-    return `Browser error: ${err.message}\nIs AgentForge Browser running? (port 9223)`;
-  }
-
-  try {
-    switch (input.action) {
-
-      case 'tabs': {
-        const pages = await browser.pages();
-        const open = pages.filter(p => !p.isClosed());
-        const lines = await Promise.all(open.map(async (p, i) => {
-          const url = p.url();
-          let title = '';
-          try { title = await p.title(); } catch {}
-          return `[${i}] ${title || '(no title)'} — ${url}`;
-        }));
-        return `Open tabs (${open.length}):\n${lines.join('\n')}\n\nTo switch to a tab: {"action":"focus","url":"fragment"} or {"action":"focus","index":N}`;
-      }
-
-      case 'navigate':
-      case 'open': {
-        const url = input.url || input.targetUrl;
-        const page = await getPage();
-        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
-        _activePage = page;
-        // Brief pause for initial render, then snapshot
-        await _wait(400);
-        return await _snapshot(page);
-      }
-
-      case 'focus': {
-        const pages = await browser.pages();
-        const open = pages.filter(p => !p.isClosed());
-        let target;
-        if (input.index !== undefined) {
-          target = open[parseInt(input.index)];
-        } else if (input.url) {
-          target = open.find(p => p.url().includes(input.url));
-        }
-        if (!target) return `Tab not found. Available tabs:\n${open.map((p,i) => `[${i}] ${p.url()}`).join('\n')}`;
-        await target.bringToFront();
-        _activePage = target;
-        return await _snapshot(target);
-      }
-
-      case 'snapshot': {
-        const page = await getPage(input.url);
-        return await _snapshot(page);
-      }
-
-      case 'screenshot': {
-        const page = await getPage(input.url);
-        const buf = await page.screenshot({ type: 'png', fullPage: false });
-        return { __screenshot: true, base64: buf.toString('base64') };
-      }
-
-      case 'click': {
-        const page = await getPage();
-
-        let clickResult = null;
-
-        if (input.ref !== undefined) {
-          clickResult = await page.evaluate((idx) => {
-            const els = document.querySelectorAll('a,button,[role="button"],[role="link"],[role="tab"],[role="menuitem"]');
-            const el = els[idx];
-            if (el) { el.focus(); el.click(); return `[${idx}] ${el.tagName}: ${(el.textContent||'').trim().slice(0,80)}`; }
-            return null;
-          }, parseInt(input.ref));
-        } else if (input.text) {
-          clickResult = await page.evaluate((text) => {
-            const all = Array.from(document.querySelectorAll('a,button,input,select,span,div,th,td,li,label,[role="button"]'));
-            const el = all.find(e => e.textContent.trim().includes(text) && e.offsetParent !== null);
-            if (el) { el.click(); return `${el.tagName}: ${el.textContent.trim().slice(0, 80)}`; }
-            return null;
-          }, input.text);
-        } else if (input.selector) {
-          await page.click(input.selector);
-          clickResult = `clicked ${input.selector}`;
-        } else if (input.x !== undefined) {
-          await page.mouse.click(input.x, input.y || 0);
-          clickResult = `clicked (${input.x}, ${input.y})`;
-        }
-
-        if (!clickResult) {
-          return input.ref !== undefined
-            ? `Element [${input.ref}] not found — take a snapshot to get current refs`
-            : `No visible element found matching "${input.text || input.selector}"`;
-        }
-
-        // Brief pause for dynamic content to render
-        await _wait(300);
-
-        // Always return a fresh snapshot after clicking so agent immediately sees what changed
-        const snap = await _snapshot(page);
-        return `Clicked: ${clickResult}\n\n--- Page state after click ---\n${snap}`;
-      }
-
-      case 'type': {
-        const page = await getPage();
-        const text = input.text || '';
-        if (input.selector) {
-          await page.focus(input.selector);
-          await page.evaluate((sel) => {
-            const el = document.querySelector(sel);
-            if (el) { el.value = ''; el.dispatchEvent(new Event('input', {bubbles:true})); }
-          }, input.selector);
-          await page.type(input.selector, text, { delay: 30 });
-          await page.evaluate((sel) => {
-            const el = document.querySelector(sel);
-            if (el) el.dispatchEvent(new Event('change', {bubbles:true}));
-          }, input.selector);
-        } else {
-          await page.keyboard.type(text, { delay: 30 });
-        }
-        await _wait(500);
-        return `Typed "${text.slice(0, 60)}" — take a snapshot to see the result`;
-      }
-
-      case 'act': {
-        const req = input.request || {};
-        if (req.kind === 'click') return browserAction({ action: 'click', ref: req.ref, selector: req.selector });
-        if (req.kind === 'type') return browserAction({ action: 'type', selector: req.selector, text: req.text });
-        return `Unknown act kind: ${req.kind}`;
-      }
-
-      case 'scroll': {
-        const page = await getPage();
-        const dx = input.x || 0, dy = input.y || 400;
-        await page.evaluate((x, y) => window.scrollBy(x, y), dx, dy);
-        await _wait(300);
-        return await _snapshot(page);
-      }
-
-      case 'evaluate': {
-        const page = await getPage();
-        const result = await page.evaluate(input.script || input.expression || '');
-        return result === undefined ? 'undefined' : JSON.stringify(result);
-      }
-
-      case 'back': {
-        const page = await getPage();
-        await page.goBack({ waitUntil: 'domcontentloaded', timeout: 10000 });
-        await _wait(500);
-        return await _snapshot(page);
-      }
-
-      case 'forward': {
-        const page = await getPage();
-        await page.goForward({ waitUntil: 'domcontentloaded', timeout: 10000 });
-        await _wait(500);
-        return await _snapshot(page);
-      }
-
-      case 'wait': {
-        await _wait(input.ms || 1000);
-        const page = await getPage();
-        return await _snapshot(page);
-      }
-
-      case 'url': {
-        const page = await getPage();
-        return page.url();
-      }
-
-      case 'reload': {
-        const page = await getPage();
-        await page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 });
-        await _wait(500);
-        return await _snapshot(page);
-      }
-
-      case 'select': {
-        const page = await getPage();
-        await page.select(input.selector, input.value);
-        await _wait(500);
-        return await _snapshot(page);
-      }
-
-      case 'press': {
-        const page = await getPage();
-        await page.keyboard.press(input.key || 'Enter');
-        await _wait(300);
-        return `Pressed ${input.key || 'Enter'}`;
-      }
-
-      default:
-        return `Unknown browser action: ${input.action}. Valid: tabs, navigate, open, focus, snapshot, click, type, screenshot, scroll, evaluate, select, press, wait, reload, back, forward, url`;
-    }
-  } catch (err) {
-    _activePage = null;
-    return `Browser error (${input.action}): ${err.message}`;
-  }
-}