Agentcore Browser

"use strict";
const fs = require("fs");

const BROWSER_SESSION_FILE = "/tmp/agentcore-browser-session.json";
const CONTENT_TRUNCATE_CHARS = 8000;
const NAV_TIMEOUT_MS = 30000;
const INTERACT_TIMEOUT_MS = 10000;
const WAIT_TIMEOUT_MS = 15000;

function getBrowserSession() {
  if (!fs.existsSync(BROWSER_SESSION_FILE)) {
    throw new Error(
      "Browser session not available. Ensure enable_browser=true in CDK config and that the session has been initialized."
    );
  }
  const data = JSON.parse(fs.readFileSync(BROWSER_SESSION_FILE, "utf8"));
  if (!data.endpoint) throw new Error("Browser session file missing endpoint");
  return data;
}

async function connectBrowser() {
  const session = getBrowserSession();
  const { chromium } = require("playwright-core");
  const browser = await chromium.connectOverCDP(session.endpoint, {
    timeout: 15000,
    headers: session.headers || {},
  });
  const contexts = browser.contexts();
  const context = contexts.length > 0 ? contexts[0] : await browser.newContext();
  const pages = context.pages();
  const page = pages.length > 0 ? pages[0] : await context.newPage();
  return {
    browser,
    page,
    disconnect: async () => {
      try { await browser.close(); } catch {}
    },
  };
}

async function uploadScreenshotToS3(imageBuffer) {
  const bucket = process.env.S3_USER_FILES_BUCKET;
  if (!bucket) {
    throw new Error("S3_USER_FILES_BUCKET environment variable is not set — cannot upload screenshot");
  }
  const userId = process.env.USER_ID || "default-user";
  const namespace = userId.replace(/:/g, "_");
  const timestamp = Date.now();
  const key = `${namespace}/_screenshots/screenshot_${timestamp}.png`;

  const { S3Client, PutObjectCommand } = require("@aws-sdk/client-s3");
  const client = new S3Client({ region: process.env.AWS_REGION || "us-east-1" });
  await client.send(new PutObjectCommand({
    Bucket: bucket,
    Key: key,
    Body: imageBuffer,
    ContentType: "image/png",
  }));
  return key;
}

function truncateContent(text, maxChars) {
  if (text.length <= maxChars) return text;
  return text.slice(0, maxChars) + `\n\n[Content truncated at ${maxChars} characters]`;
}

const STEALTH_USER_AGENT =
  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36";

async function applyStealthHeaders(page) {
  await page.addInitScript(() => {
    Object.defineProperty(navigator, "webdriver", { get: () => undefined });
    Object.defineProperty(navigator, "plugins", { get: () => [1, 2, 3, 4, 5] });
    Object.defineProperty(navigator, "languages", { get: () => ["en-US", "en"] });
    window.chrome = { runtime: {} };
  });
  await page.setExtraHTTPHeaders({
    "User-Agent": STEALTH_USER_AGENT,
    "Accept-Language": "en-US,en;q=0.9",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
  });
}

module.exports = {
  getBrowserSession,
  connectBrowser,
  applyStealthHeaders,
  uploadScreenshotToS3,
  truncateContent,
  CONTENT_TRUNCATE_CHARS,
  NAV_TIMEOUT_MS,
  INTERACT_TIMEOUT_MS,
  WAIT_TIMEOUT_MS,
};

"use strict";
const { connectBrowser, applyStealthHeaders, INTERACT_TIMEOUT_MS, WAIT_TIMEOUT_MS } = require("./common");

const VALID_ACTIONS = new Set(["click", "type", "wait", "scroll"]);

async function browserInteract(args) {
  const { action, selector, text } = args || {};

  if (!action) return JSON.stringify({ error: "action is required" });
  if (!VALID_ACTIONS.has(action)) {
    return JSON.stringify({ error: `Invalid action. Must be one of: ${[...VALID_ACTIONS].join(", ")}` });
  }

  // Validate required args before connecting to browser
  if ((action === "click" || action === "wait") && !selector) {
    return JSON.stringify({ error: `selector is required for ${action}` });
  }
  if (action === "type") {
    if (!selector) return JSON.stringify({ error: "selector is required for type" });
    if (!text) return JSON.stringify({ error: "text is required for type" });
  }

  const { page, disconnect } = await connectBrowser();
  try {
    await applyStealthHeaders(page);

    switch (action) {
      case "click":
        await page.click(selector, { timeout: INTERACT_TIMEOUT_MS });
        return JSON.stringify({ success: true, message: `Clicked: ${selector}` });

      case "type":
        await page.fill(selector, text);
        return JSON.stringify({ success: true, message: `Typed into: ${selector}` });

      case "wait":
        await page.waitForSelector(selector, { timeout: WAIT_TIMEOUT_MS });
        return JSON.stringify({ success: true, message: `Element appeared: ${selector}` });

      case "scroll":
        await page.evaluate(() => window.scrollBy(0, 500));
        return JSON.stringify({ success: true, message: "Scrolled down 500px" });

      default:
        return JSON.stringify({ error: `Unknown action: ${action}` });
    }
  } catch (err) {
    if (err.message.includes("Browser session not available")) {
      return JSON.stringify({ error: "Browser is not available. The enable_browser feature must be enabled in CDK configuration." });
    }
    return JSON.stringify({ error: `Interaction failed: ${err.message}` });
  } finally {
    await disconnect();
  }
}

const args = JSON.parse(process.argv[2] || "{}");
browserInteract(args).then(console.log).catch(err => console.log(JSON.stringify({ error: err.message })));

"use strict";
const { connectBrowser, applyStealthHeaders, truncateContent, CONTENT_TRUNCATE_CHARS, NAV_TIMEOUT_MS } = require("./common");

async function browserNavigate(args) {
  const { url } = args;
  if (!url) return JSON.stringify({ error: "url is required" });

  const { page, disconnect } = await connectBrowser();
  try {
    await applyStealthHeaders(page);
    await page.goto(url, { waitUntil: "domcontentloaded", timeout: NAV_TIMEOUT_MS });
    const title = await page.title();

    // Extract readable text — remove script/style noise
    let content = "";
    try {
      content = await page.evaluate(() => {
        const clone = document.cloneNode(true);
        clone.querySelectorAll("script, style, noscript, iframe").forEach(el => el.remove());
        return clone.body?.innerText || clone.body?.textContent || "";
      });
    } catch (_) {
      // Execution context may be destroyed during navigation — title is enough as fallback
    }

    return JSON.stringify({
      url: page.url(),
      title,
      content: truncateContent(content.replace(/\s+/g, " ").trim(), CONTENT_TRUNCATE_CHARS),
    });
  } catch (err) {
    if (err.message.includes("Browser session not available")) {
      return JSON.stringify({ error: "Browser is not available. The enable_browser feature must be enabled in CDK configuration." });
    }
    return JSON.stringify({ error: `Navigation failed: ${err.message}` });
  } finally {
    await disconnect();
  }
}

// CLI entrypoint (called by OpenClaw)
const args = JSON.parse(process.argv[2] || "{}");
browserNavigate(args).then(console.log).catch(err => console.log(JSON.stringify({ error: err.message })));

"use strict";
const { connectBrowser, uploadScreenshotToS3 } = require("./common");

async function browserScreenshot(args) {
  const { description } = args || {};

  const { page, disconnect } = await connectBrowser();
  try {
    const imageBuffer = await page.screenshot({ type: "png", fullPage: false });
    const s3Key = await uploadScreenshotToS3(imageBuffer);

    const caption = description ? ` — ${description}` : "";
    return `Screenshot taken${caption}: [SCREENSHOT:${s3Key}]`;
  } catch (err) {
    if (err.message.includes("Browser session not available")) {
      return JSON.stringify({ error: "Browser is not available. The enable_browser feature must be enabled in CDK configuration." });
    }
    return JSON.stringify({ error: `Screenshot failed: ${err.message}` });
  } finally {
    await disconnect();
  }
}

const args = JSON.parse(process.argv[2] || "{}");
browserScreenshot(args).then(console.log).catch(err => console.log(JSON.stringify({ error: err.message })));