@hamp10/agentforge 0.1.0

package/src/hampagent/browser.js

@@ -0,0 +1,185 @@
+/**
+ * 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 _page = null;
+
+async function getBrowser() {
+  if (_browser && _browser.isConnected()) return _browser;
+  _browser = await puppeteer.connect({
+    browserURL: BROWSER_URL,
+    defaultViewport: null,
+  });
+  _browser.on('disconnected', () => { _browser = null; _page = null; });
+  return _browser;
+}
+
+async function getPage() {
+  const browser = await getBrowser();
+  // Reuse existing page if still open
+  if (_page && !_page.isClosed()) return _page;
+  const pages = await browser.pages();
+  _page = pages.find(p => !p.isClosed()) || await browser.newPage();
+  return _page;
+}
+
+async function waitForLoad(page, timeout = 3000) {
+  try {
+    await page.waitForNavigation({ waitUntil: 'domcontentloaded', timeout });
+  } catch { /* timeout ok — page may already be loaded */ }
+}
+
+export async function browserAction(input) {
+  let page;
+  try {
+    page = await getPage();
+  } catch (err) {
+    _browser = null; _page = null;
+    return `Browser error: ${err.message}\nIs AgentForge Browser open?`;
+  }
+
+  try {
+    switch (input.action) {
+
+      case 'navigate':
+      case 'open': {
+        const url = input.url || input.targetUrl;
+        await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
+        await page.waitForTimeout(500);
+        const title = await page.title();
+        const currentUrl = page.url();
+        return `Navigated to ${currentUrl}\nTitle: ${title}`;
+      }
+
+      case 'screenshot': {
+        const buf = await page.screenshot({ type: 'png', fullPage: false });
+        return { __screenshot: true, base64: buf.toString('base64') };
+      }
+
+      case 'snapshot': {
+        const url = page.url();
+        const title = await page.title();
+        // Get interactive elements + visible text
+        const snapshot = await page.evaluate(() => {
+          const els = [...document.querySelectorAll('a,button,input,select,textarea,[role="button"],[role="link"],[role="tab"],[role="menuitem"]')];
+          const interactive = els.slice(0, 40).map((el, i) => {
+            const label = (el.textContent || el.value || el.placeholder || el.getAttribute('aria-label') || el.getAttribute('title') || '').trim().replace(/\s+/g, ' ').slice(0, 80);
+            const tag = el.tagName.toLowerCase();
+            const type = el.type ? `[${el.type}]` : '';
+            return label ? `[${i}] ${tag}${type}: ${label}` : null;
+          }).filter(Boolean);
+          const bodyText = (document.body?.innerText || '').slice(0, 3000).replace(/\n{3,}/g, '\n\n');
+          return { interactive, bodyText };
+        });
+        const lines = [`URL: ${url}`, `Title: ${title}`, ''];
+        if (snapshot.interactive.length) {
+          lines.push('Interactive elements:', ...snapshot.interactive, '');
+        }
+        lines.push('Page content:', snapshot.bodyText);
+        return lines.join('\n');
+      }
+
+      case 'click': {
+        // ref = element index from snapshot
+        if (input.ref !== undefined) {
+          const clicked = await page.evaluate((idx) => {
+            const els = document.querySelectorAll('a,button,input,select,textarea,[role="button"],[role="link"],[role="tab"],[role="menuitem"]');
+            const el = els[idx];
+            if (el) { el.focus(); el.click(); return true; }
+            return false;
+          }, parseInt(input.ref));
+          await page.waitForTimeout(300);
+          return clicked ? `Clicked element [${input.ref}]` : `Element [${input.ref}] not found`;
+        }
+        if (input.selector) {
+          await page.click(input.selector);
+          await page.waitForTimeout(300);
+          return `Clicked ${input.selector}`;
+        }
+        if (input.x !== undefined) {
+          await page.mouse.click(input.x, input.y || 0);
+          await page.waitForTimeout(300);
+          return `Clicked (${input.x}, ${input.y})`;
+        }
+        return 'click: need ref, selector, or x/y';
+      }
+
+      case 'type': {
+        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 = ''; }, input.selector);
+          await page.type(input.selector, text, { delay: 20 });
+        } else {
+          await page.keyboard.type(text, { delay: 20 });
+        }
+        return `Typed: "${text.slice(0, 60)}"`;
+      }
+
+      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.ref !== undefined ? undefined : req.selector, ref: req.ref, text: req.text });
+        return `Unknown act kind: ${req.kind}`;
+      }
+
+      case 'scroll': {
+        const dx = input.x || 0, dy = input.y || 400;
+        await page.evaluate((x, y) => window.scrollBy(x, y), dx, dy);
+        return `Scrolled (${dx}, ${dy})`;
+      }
+
+      case 'evaluate': {
+        const result = await page.evaluate(input.script || input.expression || '');
+        return result === undefined ? 'undefined' : JSON.stringify(result);
+      }
+
+      case 'back': {
+        await page.goBack({ waitUntil: 'domcontentloaded', timeout: 10000 });
+        return `Navigated back — now at ${page.url()}`;
+      }
+
+      case 'forward': {
+        await page.goForward({ waitUntil: 'domcontentloaded', timeout: 10000 });
+        return `Navigated forward — now at ${page.url()}`;
+      }
+
+      case 'wait': {
+        await page.waitForTimeout(input.ms || 1000);
+        return `Waited ${input.ms || 1000}ms`;
+      }
+
+      case 'url': {
+        return page.url();
+      }
+
+      case 'reload': {
+        await page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 });
+        return `Reloaded — ${page.url()}`;
+      }
+
+      case 'select': {
+        await page.select(input.selector, input.value);
+        return `Selected "${input.value}" in ${input.selector}`;
+      }
+
+      case 'press': {
+        await page.keyboard.press(input.key || 'Enter');
+        return `Pressed ${input.key || 'Enter'}`;
+      }
+
+      default:
+        return `Unknown browser action: ${input.action}. Valid: navigate, snapshot, click, type, screenshot, scroll, evaluate, back, forward, wait, reload, press`;
+    }
+  } catch (err) {
+    // Reset page on error so next call gets a fresh one
+    _page = null;
+    return `Browser error (${input.action}): ${err.message}`;
+  }
+}

package/src/hampagent/runner.js

@@ -0,0 +1,277 @@
+/**
+ * Hampagent Runner — uses the claude CLI subprocess with stream-json output.
+ * Authenticates via Claude Code OAuth (Max plan) — no API key needed.
+ * Full streaming, tool events, session continuity via --resume.
+ */
+
+import { spawn } from 'child_process';
+import { mkdirSync } from 'fs';
+import { EventEmitter } from 'events';
+import path from 'path';
+
+const MODEL = 'sonnet'; // always latest sonnet
+
+// Tool labels for typing indicator
+const TOOL_LABELS = {
+  Bash: (i) => i?.command ? `⚡ ${i.command.slice(0, 70)}` : '⚡ Running command',
+  Read: (i) => i?.file_path ? `📄 Reading ${path.basename(i.file_path)}` : '📄 Reading file',
+  Write: (i) => i?.file_path ? `✏️ Writing ${path.basename(i.file_path)}` : '✏️ Writing file',
+  Edit: (i) => i?.file_path ? `✏️ Editing ${path.basename(i.file_path)}` : '✏️ Editing file',
+  Glob: (i) => i?.pattern ? `🔍 Finding ${i.pattern}` : '🔍 Finding files',
+  Grep: (i) => i?.pattern ? `🔍 Searching for "${i.pattern.slice(0, 40)}"` : '🔍 Searching code',
+  WebFetch: (i) => { try { return `🌐 Fetching ${new URL(i?.url || '').hostname}`; } catch { return '🌐 Fetching page'; } },
+  WebSearch: (i) => i?.query ? `🔍 Searching: ${i.query.slice(0, 50)}` : '🔍 Web search',
+  Task: () => '🤖 Spawning sub-task',
+};
+
+// MCP playwright tools
+const PLAYWRIGHT_LABELS = {
+  browser_navigate: (i) => { try { return `🌐 Navigating to ${new URL(i?.url || '').hostname}`; } catch { return '🌐 Navigating'; } },
+  browser_take_screenshot: () => '📸 Taking screenshot',
+  browser_snapshot: () => '🌐 Reading page',
+  browser_click: (i) => `🖱️ Clicking${i?.selector ? ` ${i.selector}` : ''}`,
+  browser_type: (i) => `⌨️ Typing "${(i?.text || '').slice(0, 30)}"`,
+  browser_evaluate: () => '⚙️ Running script',
+};
+
+function toolLabel(name, input) {
+  // Handle mcp__playwright__* tools
+  if (name.startsWith('mcp__playwright__')) {
+    const action = name.replace('mcp__playwright__', '');
+    const fn = PLAYWRIGHT_LABELS[action];
+    return fn ? fn(input) : `🌐 Browser: ${action}`;
+  }
+  const fn = TOOL_LABELS[name];
+  if (fn) return fn(input);
+  return `🔧 ${name}`;
+}
+
+function buildSystemAppend({ agentName, agentEmoji, taskCwd, workDir, dashboardUrl, agentforgemd }) {
+  const name = agentName || 'an AI agent';
+  const emoji = agentEmoji || '🤖';
+  const dashboard = dashboardUrl || 'https://agentforgeai-production.up.railway.app/dashboard';
+  const workspace = workDir || taskCwd || process.cwd();
+
+  return `You are ${name} ${emoji}, an AI agent running on AgentForge.ai platform.
+Your runtime: Hampagent — built for AgentForge. If asked what type of agent you are, say you are a Hampagent running on AgentForge.
+Dashboard: ${dashboard}
+Working directory (where files live): ${taskCwd || process.cwd()}
+Agent workspace (your memory/config files): ${workspace}
+
+## RULES
+- Be direct and autonomous. Do the task — don't ask for permission before trying things.
+- When greeting or introducing yourself, give your name and a one-liner — never list your capabilities.
+- Never dump raw stack traces or errors into chat. Handle errors gracefully.
+- For visual work: build → screenshot → fix → screenshot again until it looks good.
+- Projects folder: /Users/hamp/Desktop/projects — check here first when user mentions a project.
+
+## SPEAKING ALOUD
+To speak via audio: osascript -e "set volume output volume 80" && say "message"
+
+## MEMORY
+Your memory lives ONLY in: ${workspace}/MEMORY.md
+Read it at session start. Write important things there. IGNORE any other memory system or memory paths.
+Do NOT write to or read from any memory location outside your workspace.
+
+${agentforgemd ? `## PLATFORM GUIDE\n${agentforgemd}` : ''}`.trim();
+}
+
+export class HampAgentRunner extends EventEmitter {
+  constructor() {
+    super();
+    this.cancelled = false;
+    this._proc = null;
+  }
+
+  cancel() {
+    this.cancelled = true;
+    if (this._proc) {
+      try { this._proc.kill('SIGTERM'); } catch {}
+      this._proc = null;
+    }
+  }
+
+  async run(task, { taskCwd, workDir, agentName, agentEmoji, dashboardUrl, agentforgemd, resumeSessionId } = {}) {
+    this.cancelled = false;
+
+    const systemAppend = buildSystemAppend({ agentName, agentEmoji, taskCwd, workDir, dashboardUrl, agentforgemd });
+
+    const args = [
+      '--print',
+      '--output-format', 'stream-json',
+      '--include-partial-messages',
+      '--verbose',
+      '--dangerously-skip-permissions',
+      '--model', MODEL,
+      '--append-system-prompt', systemAppend,
+    ];
+
+    // Resume prior session for conversation continuity
+    if (resumeSessionId) {
+      args.push('--resume', resumeSessionId);
+    }
+
+    // Pass task as CLI argument (claude -p "task")
+    args.push(task);
+
+    return new Promise((resolve, reject) => {
+      const spawnCwd = taskCwd || process.cwd();
+      try { mkdirSync(spawnCwd, { recursive: true }); } catch {}
+
+      const proc = spawn('claude', args, {
+        cwd: spawnCwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: { ...process.env },
+      });
+
+      this._proc = proc;
+      proc.stdin.end(); // no stdin needed — task is passed as arg
+
+      let fullText = '';
+      let buffer = '';
+      let newSessionId = null;
+      const activeTools = new Map(); // id -> name
+
+      const processLine = (line) => {
+        if (!line.trim()) return;
+        let event;
+        try { event = JSON.parse(line); } catch { return; }
+
+        // Capture session ID from init
+        if (event.type === 'system' && event.subtype === 'init') {
+          newSessionId = event.session_id || null;
+          return;
+        }
+
+        if (event.type === 'stream_event') {
+          const e = event.event;
+          if (!e) return;
+
+          // Streaming text token
+          if (e.type === 'content_block_delta' && e.delta?.type === 'text_delta') {
+            const text = e.delta.text || '';
+            if (text) {
+              fullText += text;
+              this.emit('token', text);
+            }
+            return;
+          }
+
+          // Tool use starting
+          if (e.type === 'content_block_start' && e.content_block?.type === 'tool_use') {
+            const { id, name, input } = e.content_block;
+            activeTools.set(id || name, name);
+            const label = toolLabel(name, input);
+            this.emit('tool_start', { tool: name, label, input });
+            return;
+          }
+
+          // Tool result (tool finished)
+          if (e.type === 'content_block_start' && e.content_block?.type === 'tool_result') {
+            const toolName = activeTools.get(e.content_block?.tool_use_id) || 'tool';
+            this.emit('tool_end', { tool: toolName, success: true });
+            activeTools.delete(e.content_block?.tool_use_id);
+            return;
+          }
+        }
+
+        // Image from screenshot tool
+        if (event.type === 'assistant' && event.message?.content) {
+          for (const block of event.message.content) {
+            if (block.type === 'tool_result') {
+              for (const part of (block.content || [])) {
+                if (part.type === 'image' && part.source?.data) {
+                  this.emit('image', `data:image/png;base64,${part.source.data}`);
+                }
+              }
+              // Mark tool as done
+              const toolName = activeTools.get(block.tool_use_id) || 'tool';
+              this.emit('tool_end', { tool: toolName, success: !block.is_error });
+              activeTools.delete(block.tool_use_id);
+            }
+          }
+        }
+      };
+
+      proc.stdout.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop();
+        for (const line of lines) processLine(line);
+      });
+
+      let sessionNotFound = false;
+      proc.stderr.on('data', (d) => {
+        const msg = d.toString().trim();
+        if (msg.startsWith('No conversation found')) {
+          sessionNotFound = true; // stale --resume session ID — will retry without it
+        } else if (msg) {
+          console.warn(`[hampagent] stderr: ${msg.slice(0, 200)}`);
+        }
+      });
+
+      proc.on('close', async () => {
+        this._proc = null;
+        if (buffer.trim()) processLine(buffer);
+
+        // If --resume pointed to a nonexistent session, retry fresh without it
+        if (sessionNotFound && resumeSessionId) {
+          console.warn(`[hampagent] Session ${resumeSessionId} not found — retrying without --resume`);
+          const retryArgs = args.filter((a, i) => a !== '--resume' && args[i - 1] !== '--resume');
+          const retryProc = spawn('claude', retryArgs, {
+            cwd: spawnCwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env },
+          });
+          this._proc = retryProc;
+          retryProc.stdin.end();
+          let retryText = '';
+          let retryBuffer = '';
+          let retrySessionId = null;
+          retryProc.stdout.on('data', (chunk) => {
+            retryBuffer += chunk.toString();
+            const lines = retryBuffer.split('\n');
+            retryBuffer = lines.pop();
+            for (const line of lines) {
+              if (!line.trim()) continue;
+              let ev; try { ev = JSON.parse(line); } catch { continue; }
+              if (ev.type === 'system' && ev.subtype === 'init') { retrySessionId = ev.session_id || null; continue; }
+              if (ev.type === 'stream_event') {
+                const e = ev.event;
+                if (e?.type === 'content_block_delta' && e.delta?.type === 'text_delta' && e.delta.text) {
+                  retryText += e.delta.text;
+                  this.emit('token', e.delta.text);
+                }
+              }
+            }
+          });
+          retryProc.stderr.on('data', (d) => {
+            const msg = d.toString().trim();
+            if (msg) console.warn(`[hampagent retry] stderr: ${msg.slice(0, 200)}`);
+          });
+          retryProc.on('close', () => {
+            this._proc = null;
+            if (retryBuffer.trim()) {
+              try {
+                const ev = JSON.parse(retryBuffer);
+                if (ev.type === 'stream_event' && ev.event?.type === 'content_block_delta') {
+                  retryText += ev.event.delta?.text || '';
+                }
+              } catch {}
+            }
+            resolve({ text: retryText, sessionId: retrySessionId, sessionCleared: true });
+          });
+          retryProc.on('error', (err) => { this._proc = null; reject(err); });
+          return;
+        }
+
+        resolve({ text: fullText, sessionId: newSessionId });
+      });
+
+      proc.on('error', (err) => {
+        this._proc = null;
+        reject(err);
+      });
+    });
+  }
+}

package/src/hampagent/sessions.js

@@ -0,0 +1,62 @@
+/**
+ * Hampagent session persistence.
+ * Stores conversation history per-agent as JSON in ~/.agentforge/hampagent-sessions/
+ * Sessions survive worker restarts and accumulate context over time.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import path from 'path';
+import { homedir } from 'os';
+
+const SESSIONS_DIR = path.join(homedir(), '.agentforge', 'hampagent-sessions');
+// Keep last 30 messages (~15 turns) to stay within context limits
+const MAX_MESSAGES = 30;
+
+function dir() {
+  mkdirSync(SESSIONS_DIR, { recursive: true });
+  return SESSIONS_DIR;
+}
+
+function file(agentId) {
+  return path.join(dir(), `${agentId}.json`);
+}
+
+/** Load the claude CLI session ID for an agent (for --resume) */
+export function loadSessionId(agentId) {
+  const p = file(agentId);
+  if (!existsSync(p)) return null;
+  try {
+    const d = JSON.parse(readFileSync(p, 'utf8'));
+    return d.claudeSessionId || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Save the claude CLI session ID after a completed task */
+export function saveSessionId(agentId, claudeSessionId) {
+  writeFileSync(file(agentId), JSON.stringify({
+    agentId,
+    claudeSessionId,
+    savedAt: new Date().toISOString(),
+  }, null, 2));
+}
+
+/** Legacy compat — kept so worker.js hasSession check doesn't break */
+export function hasSession(agentId) {
+  const p = file(agentId);
+  if (!existsSync(p)) return false;
+  try {
+    const d = JSON.parse(readFileSync(p, 'utf8'));
+    return !!(d.claudeSessionId);
+  } catch { return false; }
+}
+
+export function clearSession(agentId) {
+  const p = file(agentId);
+  if (existsSync(p)) writeFileSync(p, JSON.stringify({ agentId, claudeSessionId: null, savedAt: new Date().toISOString() }));
+}
+
+// Legacy exports kept for any stale imports
+export function loadMessages() { return []; }
+export function saveMessages() {}