@hamp10/agentforge 0.1.0

package/src/hampagent/tools.js

@@ -0,0 +1,298 @@
+/**
+ * Hampagent tool definitions + implementations.
+ * Matches openclaw's tool surface area, optimized for AgentForge.
+ */
+
+import { spawn, execSync } from 'child_process';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, readdirSync, statSync } from 'fs';
+import path from 'path';
+import { browserAction } from './browser.js';
+
+// ── Tool schema definitions (Anthropic tool_use format) ────────────────────
+
+export const TOOLS = [
+  {
+    name: 'bash',
+    description: 'Execute shell commands on the user\'s Mac. Returns stdout + stderr. Use for: running scripts, installing packages, git operations, checking system state, serving files, running processes. Commands run in the task working directory.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'Shell command to execute' },
+        timeout_ms: { type: 'number', description: 'Timeout in ms (default 30000, max 300000 for long builds)' }
+      },
+      required: ['command']
+    }
+  },
+  {
+    name: 'read',
+    description: 'Read a file. Returns contents with line numbers. Use offset+limit for large files.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string', description: 'Path to file (absolute or relative to working dir)' },
+        offset: { type: 'number', description: 'Start line, 1-indexed (default: 1)' },
+        limit: { type: 'number', description: 'Max lines to return (default: all)' }
+      },
+      required: ['file_path']
+    }
+  },
+  {
+    name: 'write',
+    description: 'Write content to a file. Creates parent directories automatically.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string' },
+        content: { type: 'string' }
+      },
+      required: ['file_path', 'content']
+    }
+  },
+  {
+    name: 'edit',
+    description: 'Replace exact text in a file. old_string must match exactly (whitespace included). Fails if not found or not unique — use read first to verify.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        file_path: { type: 'string' },
+        old_string: { type: 'string', description: 'Exact text to find — must be unique in the file' },
+        new_string: { type: 'string', description: 'Replacement text' },
+        replace_all: { type: 'boolean', description: 'Replace all occurrences (default false)' }
+      },
+      required: ['file_path', 'old_string', 'new_string']
+    }
+  },
+  {
+    name: 'glob',
+    description: 'Find files matching a pattern. Returns file paths sorted by modification time.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Glob pattern e.g. "**/*.js", "src/**/*.ts", "*.json"' },
+        path: { type: 'string', description: 'Directory to search in (default: working dir)' }
+      },
+      required: ['pattern']
+    }
+  },
+  {
+    name: 'grep',
+    description: 'Search file contents with regex. Returns matching lines with file:line format.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Regex pattern to search for' },
+        path: { type: 'string', description: 'File or directory to search (default: working dir)' },
+        glob: { type: 'string', description: 'File filter pattern e.g. "*.js", "*.{ts,tsx}"' },
+        output_mode: { type: 'string', enum: ['content', 'files_with_matches', 'count'], description: 'Output format (default: content)' },
+        '-i': { type: 'boolean', description: 'Case insensitive' },
+        '-A': { type: 'number', description: 'Lines after match' },
+        '-B': { type: 'number', description: 'Lines before match' }
+      },
+      required: ['pattern']
+    }
+  },
+  {
+    name: 'browser',
+    description: 'Control AgentForge Browser (Chrome, already open on port 9223, logged into user\'s services). Use for ALL web tasks — browsing, searching, filling forms, clicking UI. Do NOT use curl/wget for web pages.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        action: {
+          type: 'string',
+          enum: ['navigate', 'open', 'click', 'type', 'act', 'scroll', 'screenshot', 'snapshot', 'evaluate', 'back', 'forward', 'wait', 'url'],
+          description: 'navigate/open: go to URL | snapshot: get page content + interactive elements | click: click element | type: enter text | screenshot: capture page | evaluate: run JS | act: ref-based click/type from snapshot'
+        },
+        url: { type: 'string', description: 'URL for navigate/open' },
+        targetUrl: { type: 'string', description: 'URL alias for open action' },
+        selector: { type: 'string', description: 'CSS selector for click/type' },
+        ref: { description: 'Element index from snapshot for click/act' },
+        text: { type: 'string', description: 'Text for type action' },
+        script: { type: 'string', description: 'JavaScript to evaluate' },
+        expression: { type: 'string', description: 'JS expression alias' },
+        x: { type: 'number', description: 'X coordinate for click' },
+        y: { type: 'number', description: 'Y coordinate for click' },
+        ms: { type: 'number', description: 'Milliseconds for wait' },
+        request: {
+          type: 'object',
+          description: 'For act action: {kind: "click"|"type", ref: elementIndex, text: "..."}',
+          properties: {
+            kind: { type: 'string' },
+            ref: {},
+            selector: { type: 'string' },
+            text: { type: 'string' }
+          }
+        }
+      },
+      required: ['action']
+    }
+  }
+];
+
+// ── Tool implementations ────────────────────────────────────────────────────
+
+export async function executeTool(name, input, ctx) {
+  const { taskCwd, workDir, agentId, onImage } = ctx;
+
+  switch (name) {
+
+    case 'bash': {
+      const timeout = Math.min(input.timeout_ms || 30000, 300000);
+      return new Promise((resolve) => {
+        let out = '';
+        const proc = spawn('bash', ['-c', input.command], {
+          cwd: taskCwd,
+          env: { ...process.env, TERM: 'dumb' },
+        });
+
+        const timer = setTimeout(() => {
+          proc.kill('SIGKILL');
+          resolve(out ? `[timeout after ${timeout}ms]\n${out}` : `[timeout after ${timeout}ms]`);
+        }, timeout);
+
+        proc.stdout.on('data', d => { out += d.toString(); });
+        proc.stderr.on('data', d => { out += d.toString(); });
+
+        proc.on('close', (code) => {
+          clearTimeout(timer);
+          // Check for AGENTFORGE_IMAGE protocol
+          const lines = out.split('\n');
+          const filtered = [];
+          for (const line of lines) {
+            if (line.trim().startsWith('AGENTFORGE_IMAGE:')) {
+              const imgPath = line.trim().slice('AGENTFORGE_IMAGE:'.length).trim();
+              if (onImage && existsSync(imgPath)) {
+                try {
+                  const data = readFileSync(imgPath);
+                  const ext = imgPath.split('.').pop().toLowerCase();
+                  const mime = ext === 'jpg' || ext === 'jpeg' ? 'image/jpeg' : ext === 'gif' ? 'image/gif' : 'image/png';
+                  onImage(`data:${mime};base64,${data.toString('base64')}`);
+                } catch (e) { /* ignore */ }
+              }
+            } else {
+              filtered.push(line);
+            }
+          }
+          const result = filtered.join('\n').trimEnd();
+          resolve(result || `Exit ${code}`);
+        });
+        proc.on('error', (err) => { clearTimeout(timer); resolve(`Error: ${err.message}`); });
+      });
+    }
+
+    case 'read': {
+      const fp = resolveFile(input.file_path, taskCwd);
+      if (!existsSync(fp)) return `File not found: ${fp}`;
+      try {
+        const lines = readFileSync(fp, 'utf8').split('\n');
+        const start = Math.max(0, (input.offset || 1) - 1);
+        const end = input.limit ? start + input.limit : lines.length;
+        const slice = lines.slice(start, end);
+        return slice.map((l, i) => `${String(start + i + 1).padStart(6)} ${l}`).join('\n');
+      } catch (e) {
+        return `Error reading ${fp}: ${e.message}`;
+      }
+    }
+
+    case 'write': {
+      const fp = resolveFile(input.file_path, taskCwd);
+      try {
+        mkdirSync(path.dirname(fp), { recursive: true });
+        writeFileSync(fp, input.content, 'utf8');
+        return `Written ${input.content.length} bytes to ${fp}`;
+      } catch (e) {
+        return `Error writing ${fp}: ${e.message}`;
+      }
+    }
+
+    case 'edit': {
+      const fp = resolveFile(input.file_path, taskCwd);
+      if (!existsSync(fp)) return `File not found: ${fp}`;
+      try {
+        const content = readFileSync(fp, 'utf8');
+        const count = content.split(input.old_string).length - 1;
+        if (count === 0) return `Error: old_string not found in ${fp}\nFirst 200 chars of file:\n${content.slice(0, 200)}`;
+        if (count > 1 && !input.replace_all) return `Error: old_string found ${count} times — must be unique, or set replace_all: true`;
+        const newContent = input.replace_all
+          ? content.split(input.old_string).join(input.new_string)
+          : content.replace(input.old_string, input.new_string);
+        writeFileSync(fp, newContent, 'utf8');
+        return `Edited ${fp} (${count} replacement${count > 1 ? 's' : ''})`;
+      } catch (e) {
+        return `Error editing ${fp}: ${e.message}`;
+      }
+    }
+
+    case 'glob': {
+      const searchDir = input.path ? resolveFile(input.path, taskCwd) : taskCwd;
+      try {
+        // Use bash find + glob expansion for maximum compatibility
+        const pattern = input.pattern;
+        const cmd = `cd ${JSON.stringify(searchDir)} && find . -type f | grep -E ${JSON.stringify(globToRegex(pattern))} | sort -t'/' -k2 | head -200`;
+        const result = execSync(cmd, { cwd: searchDir, timeout: 10000 }).toString().trim();
+        if (!result) return '(no matches)';
+        return result.split('\n').map(f => f.replace(/^\.\//, '')).join('\n');
+      } catch {
+        try {
+          // Fallback: simple find
+          const result = execSync(`find ${JSON.stringify(searchDir)} -name "${input.pattern.replace(/\*\*\//g, '').split('/').pop()}" 2>/dev/null | head -100`, { timeout: 8000 }).toString().trim();
+          return result || '(no matches)';
+        } catch { return '(no matches)'; }
+      }
+    }
+
+    case 'grep': {
+      const searchPath = input.path ? resolveFile(input.path, taskCwd) : taskCwd;
+      const flags = ['-n', '--color=never'];
+      if (input['-i']) flags.push('-i');
+      if (input['-A']) flags.push(`-A${input['-A']}`);
+      if (input['-B']) flags.push(`-B${input['-B']}`);
+      if (input.glob) flags.push(`--include=${input.glob}`);
+      if (input.output_mode === 'files_with_matches') flags.push('-l');
+      if (input.output_mode === 'count') flags.push('-c');
+      flags.push('-r');
+      try {
+        const result = execSync(`grep ${flags.join(' ')} ${JSON.stringify(input.pattern)} ${JSON.stringify(searchPath)} 2>/dev/null | head -200`, { timeout: 15000 }).toString().trim();
+        return result || '(no matches)';
+      } catch {
+        return '(no matches)';
+      }
+    }
+
+    case 'browser': {
+      const result = await browserAction(input);
+      // Handle screenshot result — save to workspace and emit image
+      if (result && result.__screenshot) {
+        const imgPath = path.join(workDir || taskCwd, `browser_screenshot_${Date.now()}.png`);
+        try {
+          mkdirSync(path.dirname(imgPath), { recursive: true });
+          writeFileSync(imgPath, Buffer.from(result.base64, 'base64'));
+          if (onImage) onImage(`data:image/png;base64,${result.base64}`);
+          return `Screenshot saved to ${imgPath}. Image sent to chat.`;
+        } catch (e) {
+          if (onImage) onImage(`data:image/png;base64,${result.base64}`);
+          return `Screenshot taken (${Math.round(result.base64.length * 0.75 / 1024)}KB)`;
+        }
+      }
+      return result;
+    }
+
+    default:
+      return `Unknown tool: ${name}`;
+  }
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function resolveFile(filePath, cwd) {
+  if (path.isAbsolute(filePath)) return filePath;
+  return path.join(cwd || process.cwd(), filePath);
+}
+
+function globToRegex(pattern) {
+  // Convert glob pattern to regex for grep filtering
+  return pattern
+    .replace(/\./g, '\\.')
+    .replace(/\*\*/g, '.*')
+    .replace(/\*/g, '[^/]*')
+    .replace(/\?/g, '[^/]');
+}

package/src/preview-server.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+// AgentForge Preview Server
+// Usage: node preview-server.js <directory> <port> <agentId>
+//
+// Serves a static site and injects a click-to-comment overlay.
+// Feedback is forwarded to the AgentForge server as a new agent task.
+
+import { createServer } from 'http';
+import { readFileSync, existsSync, statSync } from 'fs';
+import { join, extname, resolve } from 'path';
+import { homedir } from 'os';
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.css': 'text/css',
+  '.js': 'application/javascript',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.woff': 'font/woff',
+  '.woff2': 'font/woff2',
+  '.ttf': 'font/ttf',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+};
+
+const [,, dir = '.', port = '8080', agentId = ''] = process.argv;
+const serveDir = resolve(dir);
+const PORT = parseInt(port);
+
+// Read AgentForge config for Railway URL and worker token
+let railwayUrl = '';
+let workerToken = '';
+try {
+  const configPath = join(homedir(), '.agentforge', 'config.json');
+  const config = JSON.parse(readFileSync(configPath, 'utf8'));
+  railwayUrl = (config.url || '').replace(/\/+$/, '');
+  workerToken = config.token || '';
+} catch (e) {
+  console.warn('⚠️  Could not read ~/.agentforge/config.json — feedback forwarding disabled');
+}
+
+// Overlay script injected into every HTML page
+const overlayScript = `<script data-agentforge-overlay>
+(function() {
+  if (window.__agentforgeOverlay) return;
+  window.__agentforgeOverlay = true;
+
+  let popover = null;
+
+  function getSelector(el) {
+    if (!el || el === document.body) return 'body';
+    const parts = [];
+    let cur = el;
+    while (cur && cur !== document.body && parts.length < 4) {
+      let sel = cur.tagName.toLowerCase();
+      if (cur.id) { sel += '#' + cur.id; parts.unshift(sel); break; }
+      if (cur.className && typeof cur.className === 'string') {
+        const cls = [...cur.classList].filter(c => !c.match(/^(active|hover|focus|open|visible|hidden)$/)).slice(0, 2).join('.');
+        if (cls) sel += '.' + cls;
+      }
+      const siblings = cur.parentElement ? [...cur.parentElement.children].filter(s => s.tagName === cur.tagName) : [];
+      if (siblings.length > 1) sel += ':nth-of-type(' + (siblings.indexOf(cur) + 1) + ')';
+      parts.unshift(sel);
+      cur = cur.parentElement;
+    }
+    return parts.join(' > ');
+  }
+
+  function dismiss() { popover && (popover.remove(), popover = null); }
+
+  function showPopover(x, y, el) {
+    dismiss();
+    const selector = getSelector(el);
+    const snippet = el.textContent?.trim().replace(/\\s+/g, ' ').slice(0, 50) || '';
+
+    popover = document.createElement('div');
+    popover.dataset.agentforgePopover = '';
+    popover.style.cssText = [
+      'position:fixed', 'z-index:2147483647', 'width:300px',
+      'background:#111827', 'border:1px solid #374151', 'border-radius:12px',
+      'padding:14px', 'box-shadow:0 20px 60px rgba(0,0,0,.7)',
+      'font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif',
+      'font-size:13px', 'color:#e5e7eb', 'box-sizing:border-box'
+    ].join(';');
+
+    let left = x + 14, top = y + 14;
+    if (left + 300 > window.innerWidth - 8) left = x - 314;
+    if (top + 200 > window.innerHeight - 8) top = y - 214;
+    popover.style.left = Math.max(8, left) + 'px';
+    popover.style.top  = Math.max(8, top)  + 'px';
+
+    popover.innerHTML = \`
+      <div style="font-size:11px;color:#6b7280;font-family:monospace;margin-bottom:4px;word-break:break-all;white-space:nowrap;overflow:hidden;text-overflow:ellipsis" title="\${selector}">\${selector}</div>
+      \${snippet ? \`<div style="font-size:11px;color:#9ca3af;margin-bottom:10px;font-style:italic;white-space:nowrap;overflow:hidden;text-overflow:ellipsis">"\${snippet}"</div>\` : '<div style="margin-bottom:10px"></div>'}
+      <textarea id="_af_txt" placeholder="Feedback for the agent…" style="
+        width:100%;box-sizing:border-box;height:76px;resize:none;
+        background:#1f2937;border:1px solid #374151;border-radius:8px;
+        color:#e5e7eb;padding:8px 10px;font-size:13px;outline:none;
+        font-family:inherit;line-height:1.4;
+      "></textarea>
+      <div style="display:flex;gap:8px;margin-top:8px;align-items:center;">
+        <button id="_af_send" style="
+          flex:1;background:#6366f1;color:#fff;border:none;border-radius:8px;
+          padding:8px;font-size:13px;font-weight:600;cursor:pointer;
+        ">Send to Agent</button>
+        <button id="_af_close" style="
+          background:#1f2937;color:#9ca3af;border:1px solid #374151;border-radius:8px;
+          padding:8px 10px;font-size:13px;cursor:pointer;
+        ">✕</button>
+      </div>
+      <div id="_af_status" style="font-size:11px;text-align:center;margin-top:6px;min-height:14px;color:#6b7280;"></div>
+    \`;
+
+    document.body.appendChild(popover);
+    popover.querySelector('#_af_txt').focus();
+
+    popover.querySelector('#_af_close').onclick = dismiss;
+
+    popover.querySelector('#_af_send').onclick = async () => {
+      const comment = popover.querySelector('#_af_txt').value.trim();
+      if (!comment) return;
+      const btn = popover.querySelector('#_af_send');
+      const status = popover.querySelector('#_af_status');
+      btn.disabled = true; btn.textContent = 'Sending…';
+      try {
+        const r = await fetch('/agentforge-feedback', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ comment, selector, elementText: snippet })
+        });
+        if (r.ok) {
+          status.style.color = '#6366f1';
+          status.textContent = '✓ Sent';
+          setTimeout(dismiss, 1000);
+        } else throw new Error('Server error ' + r.status);
+      } catch(err) {
+        status.style.color = '#ef4444';
+        status.textContent = err.message;
+        btn.disabled = false; btn.textContent = 'Send to Agent';
+      }
+    };
+  }
+
+  // Click → show popover (capture phase so it works on everything)
+  document.addEventListener('click', e => {
+    if (e.target.closest('[data-agentforge-popover]') || e.target.closest('[data-agentforge-overlay]')) return;
+    if (popover) { dismiss(); return; }
+    e.preventDefault(); e.stopPropagation();
+    const prev = e.target.style.outline;
+    e.target.style.outline = '2px solid #6366f1';
+    setTimeout(() => { e.target.style.outline = prev; }, 800);
+    showPopover(e.clientX, e.clientY, e.target);
+  }, true);
+
+  document.addEventListener('keydown', e => { if (e.key === 'Escape') dismiss(); });
+
+  // Badge
+  const badge = document.createElement('div');
+  badge.dataset.agentforgeOverlay = '';
+  badge.style.cssText = 'position:fixed;bottom:14px;right:14px;z-index:2147483646;background:#111827;border:1px solid #374151;border-radius:20px;padding:5px 11px;font-family:-apple-system,sans-serif;font-size:11px;color:#6b7280;pointer-events:none;';
+  badge.textContent = '⬡ AgentForge Preview — click to comment';
+  document.addEventListener('DOMContentLoaded', () => document.body.appendChild(badge));
+  if (document.body) document.body.appendChild(badge);
+})();
+</script>`;
+
+const server = createServer(async (req, res) => {
+  // Feedback endpoint
+  if (req.method === 'POST' && req.url === '/agentforge-feedback') {
+    let body = '';
+    req.on('data', c => body += c);
+    req.on('end', async () => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      try {
+        const { comment, selector, elementText } = JSON.parse(body);
+        if (!comment) { res.writeHead(400); res.end('{"error":"no comment"}'); return; }
+
+        const message = [
+          '[Visual feedback on your site preview]',
+          `Element: ${selector}${elementText ? ` — "${elementText}"` : ''}`,
+          `Feedback: ${comment}`
+        ].join('\n');
+
+        console.log(`\n📝 Feedback received:\n  ${selector}\n  "${comment}"\n`);
+
+        if (railwayUrl && workerToken && agentId) {
+          const resp = await fetch(`${railwayUrl}/api/preview/feedback`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${workerToken}` },
+            body: JSON.stringify({ agentId, message })
+          });
+          if (!resp.ok) console.warn('⚠️  Failed to forward feedback to AgentForge:', resp.status);
+        } else {
+          console.log('  (No AgentForge config — feedback logged locally only)');
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end('{"success":true}');
+      } catch (e) {
+        res.writeHead(400); res.end(`{"error":${JSON.stringify(e.message)}}`);
+      }
+    });
+    return;
+  }
+
+  if (req.method === 'OPTIONS') {
+    res.writeHead(204, { 'Access-Control-Allow-Origin': '*', 'Access-Control-Allow-Methods': 'POST, GET', 'Access-Control-Allow-Headers': 'Content-Type' });
+    res.end(); return;
+  }
+
+  // Static file serving
+  let urlPath = decodeURIComponent(req.url.split('?')[0]);
+  if (urlPath === '/') urlPath = '/index.html';
+
+  let filePath = resolve(join(serveDir, urlPath));
+  if (!filePath.startsWith(serveDir)) { res.writeHead(403); res.end('Forbidden'); return; }
+
+  if (existsSync(filePath) && statSync(filePath).isDirectory()) {
+    filePath = join(filePath, 'index.html');
+  }
+
+  if (!existsSync(filePath)) {
+    // SPA fallback
+    const fallback = join(serveDir, 'index.html');
+    if (existsSync(fallback)) filePath = fallback;
+    else { res.writeHead(404); res.end('Not found'); return; }
+  }
+
+  try {
+    const ext = extname(filePath).toLowerCase();
+    const mime = MIME_TYPES[ext] || 'application/octet-stream';
+    let content = readFileSync(filePath);
+
+    if (ext === '.html') {
+      let html = content.toString();
+      const insertAt = html.lastIndexOf('</body>');
+      html = insertAt >= 0
+        ? html.slice(0, insertAt) + overlayScript + '\n' + html.slice(insertAt)
+        : html + overlayScript;
+      content = html;
+    }
+
+    res.writeHead(200, { 'Content-Type': mime, 'Cache-Control': 'no-cache' });
+    res.end(content);
+  } catch (e) {
+    res.writeHead(500); res.end('Server error');
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`\n🔍 AgentForge Preview  →  http://localhost:${PORT}`);
+  console.log(`   Directory : ${serveDir}`);
+  console.log(`   Agent     : ${agentId || '(not set)'}`);
+  console.log(`   Click any element on the page to leave feedback for the agent\n`);
+});