@harperfast/agent 0.12.1 → 0.13.0

package/dist/agent.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import "./chunk-2ESYSVXG.js";
 
 // agent.ts
 import "dotenv/config";
@@ -282,9 +283,9 @@ var HarperProcess = class {
     this.stopTailingLogs();
   }
   getAndClearLogs() {
-    const logs = this.logs;
+    const logs2 = this.logs;
     this.logs = [];
-    return logs.join("");
+    return logs2.join("");
   }
 };
 var harperProcess = new HarperProcess();
@@ -702,10 +703,275 @@ function sayHi() {
   );
 }
 
-// tools/files/applyPatchTool.ts
+// tools/browser/browserClickTool.ts
+import { tool } from "@openai/agents";
+import { z } from "zod";
+
+// tools/browser/browserManager.ts
+var browser = null;
+var page = null;
+var logs = [];
+async function getBrowser() {
+  if (!browser) {
+    let puppeteer;
+    try {
+      puppeteer = await import("./puppeteer-KULXOV7T.js");
+    } catch {
+      throw new Error(
+        "Puppeteer is not installed. Browser tools require puppeteer. Please install it with `npm install puppeteer`."
+      );
+    }
+    browser = await puppeteer.default.launch({
+      headless: false,
+      defaultViewport: null
+    });
+  }
+  return browser;
+}
+async function getPage() {
+  if (!page) {
+    const b = await getBrowser();
+    const pages = await b.pages();
+    if (pages.length > 0) {
+      page = pages[0];
+    } else {
+      page = await b.newPage();
+    }
+    page.on("console", (msg) => {
+      logs.push(`[${msg.type()}] ${msg.text()}`);
+    });
+    page.on("pageerror", (err) => {
+      logs.push(`[error] ${err.message || err}`);
+    });
+  }
+  return page;
+}
+function getBrowserLogs() {
+  return logs;
+}
+function clearBrowserLogs() {
+  logs.length = 0;
+}
+async function closeBrowser() {
+  if (browser) {
+    await browser.close();
+    browser = null;
+    page = null;
+  }
+}
+
+// tools/browser/browserClickTool.ts
+var ToolParameters = z.object({
+  selector: z.string().describe("The CSS selector of the element to click."),
+  button: z.enum(["left", "right", "middle"]).default("left").describe("The button to use for the click."),
+  clickCount: z.number().default(1).describe("The number of times to click.")
+});
+async function execute({ selector, button, clickCount }) {
+  try {
+    const page2 = await getPage();
+    await page2.click(selector, { button, clickCount });
+    return `Successfully clicked on ${selector}`;
+  } catch (error) {
+    return `Error clicking on ${selector}: ${error}`;
+  }
+}
+var browserClickTool = tool({
+  name: "browser_click",
+  description: "Clicks on an element specified by a CSS selector.",
+  parameters: ToolParameters,
+  execute
+});
+
+// tools/browser/browserCloseTool.ts
 import { tool as tool2 } from "@openai/agents";
-import chalk7 from "chalk";
 import { z as z2 } from "zod";
+var ToolParameters2 = z2.object({});
+async function execute2() {
+  try {
+    await closeBrowser();
+    return "Browser closed successfully.";
+  } catch (error) {
+    return `Error closing browser: ${error}`;
+  }
+}
+var browserCloseTool = tool2({
+  name: "browser_close",
+  description: "Closes the browser instance.",
+  parameters: ToolParameters2,
+  execute: execute2
+});
+
+// tools/browser/browserEvaluateTool.ts
+import { tool as tool3 } from "@openai/agents";
+import { z as z3 } from "zod";
+var ToolParameters3 = z3.object({
+  script: z3.string().describe("The JavaScript to evaluate in the context of the page.")
+});
+async function execute3({ script }) {
+  try {
+    const page2 = await getPage();
+    const result = await page2.evaluate(script);
+    return JSON.stringify(result, null, 2);
+  } catch (error) {
+    return `Error evaluating script: ${error}`;
+  }
+}
+var browserEvaluateTool = tool3({
+  name: "browser_evaluate",
+  description: "Evaluates JavaScript in the context of the current page.",
+  parameters: ToolParameters3,
+  execute: execute3
+});
+
+// tools/browser/browserGetContentTool.ts
+import { tool as tool4 } from "@openai/agents";
+import { z as z4 } from "zod";
+var ToolParameters4 = z4.object({
+  type: z4.enum(["html", "text"]).default("html").describe("The type of content to retrieve (html or text).")
+});
+async function execute4({ type }) {
+  try {
+    const page2 = await getPage();
+    if (type === "text") {
+      return await page2.evaluate(() => document.body.innerText);
+    }
+    return await page2.content();
+  } catch (error) {
+    return `Error getting content: ${error}`;
+  }
+}
+var browserGetContentTool = tool4({
+  name: "browser_get_content",
+  description: "Gets the content (HTML or text) of the current page.",
+  parameters: ToolParameters4,
+  execute: execute4
+});
+
+// tools/browser/browserGetLogsTool.ts
+import { tool as tool5 } from "@openai/agents";
+import { z as z5 } from "zod";
+var ToolParameters5 = z5.object({
+  clear: z5.boolean().default(false).describe("Whether to clear the logs after reading them.")
+});
+async function execute5({ clear }) {
+  const logs2 = getBrowserLogs();
+  const result = logs2.length > 0 ? logs2.join("\n") : "No logs found.";
+  if (clear) {
+    clearBrowserLogs();
+  }
+  return result;
+}
+var browserGetLogsTool = tool5({
+  name: "browser_get_logs",
+  description: "Returns the console logs from the browser.",
+  parameters: ToolParameters5,
+  execute: execute5
+});
+
+// tools/browser/browserIsElementPresentTool.ts
+import { tool as tool6 } from "@openai/agents";
+import { z as z6 } from "zod";
+var ToolParameters6 = z6.object({
+  selector: z6.string().describe("The CSS selector of the element to check for presence.")
+});
+async function execute6({ selector }) {
+  try {
+    const page2 = await getPage();
+    const element = await page2.$(selector);
+    return element !== null ? `Element ${selector} is present.` : `Element ${selector} is not present.`;
+  } catch (error) {
+    return `Error checking for element ${selector}: ${error}`;
+  }
+}
+var browserIsElementPresentTool = tool6({
+  name: "browser_is_element_present",
+  description: "Checks if an element is present on the page.",
+  parameters: ToolParameters6,
+  execute: execute6
+});
+
+// tools/browser/browserNavigateTool.ts
+import { tool as tool7 } from "@openai/agents";
+import { z as z7 } from "zod";
+var ToolParameters7 = z7.object({
+  url: z7.string().describe("The URL to navigate to."),
+  waitUntil: z7.enum(["load", "domcontentloaded", "networkidle0", "networkidle2"]).default("load").describe("When to consider navigation succeeded.")
+});
+async function execute7({ url, waitUntil }) {
+  try {
+    const page2 = await getPage();
+    await page2.goto(url, { waitUntil });
+    return `Successfully navigated to ${url}`;
+  } catch (error) {
+    return `Error navigating to ${url}: ${error}`;
+  }
+}
+var browserNavigateTool = tool7({
+  name: "browser_navigate",
+  description: "Navigates the browser to a specified URL.",
+  parameters: ToolParameters7,
+  execute: execute7
+});
+
+// tools/browser/browserScreenshotTool.ts
+import { tool as tool8 } from "@openai/agents";
+import { z as z8 } from "zod";
+var ToolParameters8 = z8.object({
+  fullPage: z8.boolean().default(false).describe("Whether to take a screenshot of the full scrollable page.")
+});
+async function execute8({ fullPage }) {
+  try {
+    const page2 = await getPage();
+    const screenshot = await page2.screenshot({
+      encoding: "base64",
+      type: "jpeg",
+      quality: 80,
+      fullPage
+    });
+    return {
+      type: "image",
+      image: `data:image/jpeg;base64,${screenshot}`,
+      detail: "auto"
+    };
+  } catch (error) {
+    return `Error taking screenshot: ${error}`;
+  }
+}
+var browserScreenshotTool = tool8({
+  name: "browser_screenshot",
+  description: "Takes a screenshot of the current page.",
+  parameters: ToolParameters8,
+  execute: execute8
+});
+
+// tools/browser/browserTypeTool.ts
+import { tool as tool9 } from "@openai/agents";
+import { z as z9 } from "zod";
+var ToolParameters9 = z9.object({
+  selector: z9.string().describe("The CSS selector of the element to type into."),
+  text: z9.string().describe("The text to type into the element."),
+  delay: z9.number().default(0).describe("Delay between key presses in milliseconds.")
+});
+async function execute9({ selector, text, delay }) {
+  try {
+    const page2 = await getPage();
+    await page2.type(selector, text, { delay });
+    return `Successfully typed into ${selector}`;
+  } catch (error) {
+    return `Error typing into ${selector}: ${error}`;
+  }
+}
+var browserTypeTool = tool9({
+  name: "browser_type",
+  description: "Types text into an element specified by a CSS selector.",
+  parameters: ToolParameters9,
+  execute: execute9
+});
+
+// tools/files/applyPatchTool.ts
+import { tool as tool11 } from "@openai/agents";
+import chalk7 from "chalk";
+import { z as z11 } from "zod";
 
 // utils/files/printDiff.ts
 import chalk5 from "chalk";
@@ -746,11 +1012,11 @@ function getEnv(newKey, oldKey) {
 }
 
 // tools/harper/getHarperSkillTool.ts
-import { tool } from "@openai/agents";
+import { tool as tool10 } from "@openai/agents";
 import { readdirSync, readFileSync as readFileSync3 } from "fs";
 import { createRequire } from "module";
 import { dirname, join as join6 } from "path";
-import { z } from "zod";
+import { z as z10 } from "zod";
 var createHarper = dirname(createRequire(import.meta.url).resolve("create-harper"));
 var agentsMarkdown = join6(
   createHarper,
@@ -763,16 +1029,16 @@ var skillsDir = join6(
 );
 var skillLinkRegex = /\[[^\]]+]\(skills\/([^)]+)\.md\)/g;
 var skills = getSkills();
-var ToolParameters = z.object({
-  skill: z.enum(skills.length > 0 ? skills : ["none"]).describe(
+var ToolParameters10 = z10.object({
+  skill: z10.enum(skills.length > 0 ? skills : ["none"]).describe(
     "The name of the skill to retrieve."
   )
 });
-var getHarperSkillTool = tool({
+var getHarperSkillTool = tool10({
   name: "getHarperSkill",
   description: getSkillsDescription(),
-  parameters: ToolParameters,
-  execute
+  parameters: ToolParameters10,
+  execute: execute10
 });
 function getSkillsDescription() {
   try {
@@ -788,7 +1054,7 @@ function getSkills() {
     return [];
   }
 }
-async function execute({ skill }) {
+async function execute10({ skill }) {
   if (skill === "none") {
     return "No skills found.";
   }
@@ -933,10 +1199,10 @@ var WorkspaceEditor = class {
 };
 
 // tools/files/applyPatchTool.ts
-var ApplyPatchParameters = z2.object({
-  type: z2.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
-  path: z2.string().describe("The path to the file to operate on."),
-  diff: z2.string().optional().default("").describe(
+var ApplyPatchParameters = z11.object({
+  type: z11.enum(["create_file", "update_file", "delete_file"]).describe("The type of operation to perform."),
+  path: z11.string().describe("The path to the file to operate on."),
+  diff: z11.string().optional().default("").describe(
     'The diff to apply. For create_file, every line must start with "+". For update_file, use a headerless unified diff format (start sections with "@@", and use "+", "-", or " " for lines). Do not include markers like "*** Begin Patch" or "*** Add File:".'
   )
 });
@@ -1011,7 +1277,7 @@ ${chalk7.bold.bgYellow.black(" Apply patch approval required: ")}`);
   }
 }
 function createApplyPatchTool() {
-  return tool2({
+  return tool11({
     name: "apply_patch",
     description: "Applies a patch (create, update, or delete a file) to the workspace.",
     parameters: ApplyPatchParameters,
@@ -1020,7 +1286,7 @@ function createApplyPatchTool() {
       try {
         const needed = await requiredSkillForOperation(operation.path, operation.type);
         if (needed) {
-          const content = await execute({ skill: needed });
+          const content = await execute10({ skill: needed });
           return { status: "completed", output: content };
         }
         switch (operation.type) {
@@ -1048,13 +1314,13 @@ function createApplyPatchTool() {
 }
 
 // tools/files/changeCwdTool.ts
-import { tool as tool3 } from "@openai/agents";
+import { tool as tool12 } from "@openai/agents";
 import { statSync } from "fs";
-import { z as z3 } from "zod";
-var ToolParameters2 = z3.object({
-  path: z3.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
+import { z as z12 } from "zod";
+var ToolParameters11 = z12.object({
+  path: z12.string().describe("Directory to switch into. Can be absolute or relative to current workspace.")
 });
-async function execute2({ path: path8 }) {
+async function execute11({ path: path8 }) {
   try {
     const target = resolvePath(trackedState.cwd, path8);
     const stat = statSync(target);
@@ -1081,27 +1347,27 @@ I strongly suggest you use these newfound skills!`;
     return `Failed to change directory: ${err.message}`;
   }
 }
-var changeCwdTool = tool3({
+var changeCwdTool = tool12({
   name: "changeCwd",
   description: "Changes the current working directory for subsequent tools. Accepts absolute or relative paths.",
-  parameters: ToolParameters2,
-  execute: execute2
+  parameters: ToolParameters11,
+  execute: execute11
 });
 
 // tools/files/egrepTool.ts
-import { tool as tool4 } from "@openai/agents";
+import { tool as tool13 } from "@openai/agents";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { z as z4 } from "zod";
+import { z as z13 } from "zod";
 var execFileAsync = promisify(execFile);
-var ToolParameters3 = z4.object({
-  path: z4.string().describe("The path to start the search from."),
-  pattern: z4.string().describe("The pattern to search")
+var ToolParameters12 = z13.object({
+  path: z13.string().describe("The path to start the search from."),
+  pattern: z13.string().describe("The pattern to search")
 });
-var egrepTool = tool4({
+var egrepTool = tool13({
   name: "egrep",
   description: "File pattern searcher.",
-  parameters: ToolParameters3,
+  parameters: ToolParameters12,
   async execute({ path: searchPath, pattern }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1127,21 +1393,21 @@ var egrepTool = tool4({
 });
 
 // tools/files/findTool.ts
-import { tool as tool5 } from "@openai/agents";
+import { tool as tool14 } from "@openai/agents";
 import { execFile as execFile2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import { z as z5 } from "zod";
+import { z as z14 } from "zod";
 var execFileAsync2 = promisify2(execFile2);
-var ToolParameters4 = z5.object({
-  path: z5.string().describe("The path to start the search from."),
-  iname: z5.string().describe(
+var ToolParameters13 = z14.object({
+  path: z14.string().describe("The path to start the search from."),
+  iname: z14.string().describe(
     "Case insensitive, true if the last component of the pathname being examined matches pattern.  Special shell pattern matching characters (\u201C[\u201D, \u201C]\u201D, \u201C*\u201D, and \u201C?\u201D) may be used as part of pattern.  These characters may be matched explicitly by escaping them with a backslash (\u201C\\\u201D)."
   )
 });
-var findTool = tool5({
+var findTool = tool14({
   name: "find",
   description: "Walk a file hierarchy.",
-  parameters: ToolParameters4,
+  parameters: ToolParameters13,
   async execute({ path: searchPath, iname }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, searchPath);
@@ -1154,17 +1420,17 @@ var findTool = tool5({
 });
 
 // tools/files/readDirTool.ts
-import { tool as tool6 } from "@openai/agents";
+import { tool as tool15 } from "@openai/agents";
 import { readdir } from "fs/promises";
 import path5 from "path";
-import { z as z6 } from "zod";
-var ToolParameters5 = z6.object({
-  directoryName: z6.string().describe("The name of the directory to read.")
+import { z as z15 } from "zod";
+var ToolParameters14 = z15.object({
+  directoryName: z15.string().describe("The name of the directory to read.")
 });
-var readDirTool = tool6({
+var readDirTool = tool15({
   name: "readDir",
   description: "Lists the files in a directory.",
-  parameters: ToolParameters5,
+  parameters: ToolParameters14,
   async execute({ directoryName }) {
     try {
       const resolvedPath = resolvePath(trackedState.cwd, directoryName);
@@ -1177,51 +1443,70 @@ var readDirTool = tool6({
 });
 
 // tools/files/readFileTool.ts
-import { tool as tool7 } from "@openai/agents";
+import { tool as tool16 } from "@openai/agents";
 import { readFile } from "fs/promises";
-import { z as z7 } from "zod";
-var ToolParameters6 = z7.object({
-  fileName: z7.string().describe("The name of the file to read.")
+import { extname } from "path";
+import { z as z16 } from "zod";
+var ToolParameters15 = z16.object({
+  fileName: z16.string().describe("The name of the file to read.")
 });
-var readFileTool = tool7({
-  name: "readFile",
-  description: "Reads the contents of a specified file.",
-  parameters: ToolParameters6,
-  async execute({ fileName }) {
-    try {
-      const normalized = String(fileName).replace(/\\/g, "/");
-      const m = normalized.match(/(?:^|\/)skills\/([A-Za-z0-9_-]+)\.md(?:$|[?#])/);
-      if (m && m[1]) {
-        trackedState.session?.addSkillRead?.(m[1]);
-      }
-      const resolvedPath = resolvePath(trackedState.cwd, fileName);
-      return readFile(resolvedPath, "utf8");
-    } catch (error) {
-      return `Error reading file: ${error}`;
+var IMAGE_EXTENSIONS = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".bmp": "image/bmp"
+};
+async function execute12({ fileName }) {
+  try {
+    const normalized = String(fileName).replace(/\\/g, "/");
+    const m = normalized.match(/(?:^|\/)skills\/([A-Za-z0-9_-]+)\.md(?:$|[?#])/);
+    if (m && m[1]) {
+      trackedState.session?.addSkillRead?.(m[1]);
+    }
+    const resolvedPath = resolvePath(trackedState.cwd, fileName);
+    const ext = extname(resolvedPath).toLowerCase();
+    if (IMAGE_EXTENSIONS[ext]) {
+      const buffer = await readFile(resolvedPath);
+      return {
+        type: "image",
+        image: `data:${IMAGE_EXTENSIONS[ext]};base64,${buffer.toString("base64")}`,
+        detail: "auto"
+      };
     }
+    return await readFile(resolvedPath, "utf8");
+  } catch (error) {
+    return `Error reading file: ${error}`;
   }
+}
+var readFileTool = tool16({
+  name: "readFile",
+  description: "Reads the contents of a specified file. If the file is an image, it returns a structured image object.",
+  parameters: ToolParameters15,
+  execute: execute12
 });
 
 // tools/general/codeInterpreterTool.ts
-import { tool as tool8 } from "@openai/agents";
+import { tool as tool17 } from "@openai/agents";
 import chalk8 from "chalk";
 import { exec } from "child_process";
 import { unlink, writeFile as writeFile2 } from "fs/promises";
 import path6 from "path";
 import { promisify as promisify3 } from "util";
-import { z as z8 } from "zod";
+import { z as z17 } from "zod";
 var execAsync = promisify3(exec);
-var CodeInterpreterParameters = z8.object({
-  code: z8.string().describe("The code to execute."),
-  language: z8.enum(["python", "javascript"]).optional().default("python").describe(
+var CodeInterpreterParameters = z17.object({
+  code: z17.string().describe("The code to execute."),
+  language: z17.enum(["python", "javascript"]).optional().default("python").describe(
     "The programming language of the code."
   )
 });
-var codeInterpreterTool = tool8({
+var codeInterpreterTool = tool17({
   name: "code_interpreter",
   description: "Executes Python or JavaScript code in a local environment. This is useful for data analysis, complex calculations, and more. All code will be executed in the current workspace.",
   parameters: CodeInterpreterParameters,
-  execute: execute3,
+  execute: execute13,
   needsApproval: needsApproval2
 });
 async function needsApproval2(runContext, { code, language }, callId) {
@@ -1243,7 +1528,7 @@ ${chalk8.bold.bgYellow.black(` Code interpreter (${language}) approval required:
   }
   return !autoApproved;
 }
-async function execute3({ code, language }) {
+async function execute13({ code, language }) {
   const extension = language === "javascript" ? "js" : "py";
   const interpreter = language === "javascript" ? "node" : "python3";
   const tempFile = path6.join(trackedState.cwd, `.temp_code_${Date.now()}.${extension}`);
@@ -1265,8 +1550,8 @@ STDERR: ${error.stderr || ""}`;
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-import { tool as tool9 } from "@openai/agents";
-import { z as z9 } from "zod";
+import { tool as tool18 } from "@openai/agents";
+import { z as z18 } from "zod";
 
 // utils/files/updateEnv.ts
 import { existsSync as existsSync6 } from "fs";
@@ -1293,10 +1578,10 @@ async function updateEnv(key, value) {
 }
 
 // tools/general/setInterpreterAutoApproveTool.ts
-var SetInterpreterAutoApproveParameters = z9.object({
-  autoApprove: z9.boolean()
+var SetInterpreterAutoApproveParameters = z18.object({
+  autoApprove: z18.boolean()
 });
-var setInterpreterAutoApproveTool = tool9({
+var setInterpreterAutoApproveTool = tool18({
   name: "setInterpreterAutoApproveTool",
   description: "Enable or disable automatic approval for code interpreter by setting HARPER_AGENT_AUTO_APPROVE_CODE_INTERPRETER=1 or 0 in .env and current process.",
   parameters: SetInterpreterAutoApproveParameters,
@@ -1319,12 +1604,12 @@ var setInterpreterAutoApproveTool = tool9({
 });
 
 // tools/general/setPatchAutoApproveTool.ts
-import { tool as tool10 } from "@openai/agents";
-import { z as z10 } from "zod";
-var SetPatchAutoApproveParameters = z10.object({
-  autoApprove: z10.boolean()
+import { tool as tool19 } from "@openai/agents";
+import { z as z19 } from "zod";
+var SetPatchAutoApproveParameters = z19.object({
+  autoApprove: z19.boolean()
 });
-var setPatchAutoApproveTool = tool10({
+var setPatchAutoApproveTool = tool19({
   name: "setPatchAutoApproveTool",
   description: "Enable or disable automatic approval for patch commands by setting HARPER_AGENT_AUTO_APPROVE_PATCHES=1 or 0 in .env and current process.",
   parameters: SetPatchAutoApproveParameters,
@@ -1347,12 +1632,12 @@ var setPatchAutoApproveTool = tool10({
 });
 
 // tools/general/setShellAutoApproveTool.ts
-import { tool as tool11 } from "@openai/agents";
-import { z as z11 } from "zod";
-var SetShellAutoApproveParameters = z11.object({
-  autoApprove: z11.boolean()
+import { tool as tool20 } from "@openai/agents";
+import { z as z20 } from "zod";
+var SetShellAutoApproveParameters = z20.object({
+  autoApprove: z20.boolean()
 });
-var setShellAutoApproveTool = tool11({
+var setShellAutoApproveTool = tool20({
   name: "setShellAutoApproveTool",
   description: "Enable or disable automatic approval for shell commands by setting HARPER_AGENT_AUTO_APPROVE_SHELL=1 or 0 in .env and current process.",
   parameters: SetShellAutoApproveParameters,
@@ -1375,9 +1660,9 @@ var setShellAutoApproveTool = tool11({
 });
 
 // tools/general/shellTool.ts
-import { tool as tool12 } from "@openai/agents";
+import { tool as tool21 } from "@openai/agents";
 import chalk9 from "chalk";
-import { z as z12 } from "zod";
+import { z as z21 } from "zod";
 
 // utils/files/mentionsIgnoredPath.ts
 function mentionsIgnoredPath(command) {
@@ -1489,11 +1774,11 @@ var LocalShell = class {
 };
 
 // tools/general/shellTool.ts
-var ShellParameters = z12.object({
-  commands: z12.array(z12.string()).describe("The commands to execute.")
+var ShellParameters = z21.object({
+  commands: z21.array(z21.string()).describe("The commands to execute.")
 });
 var shell = new LocalShell();
-var shellTool = tool12({
+var shellTool = tool21({
   name: "shellToolForCommandsWithoutABetterTool",
   description: "Executes shell commands.",
   parameters: ShellParameters,
@@ -1550,15 +1835,15 @@ TIMEOUT`;
 });
 
 // tools/git/gitAddTool.ts
-import { tool as tool13 } from "@openai/agents";
+import { tool as tool22 } from "@openai/agents";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify5 } from "util";
-import { z as z13 } from "zod";
+import { z as z22 } from "zod";
 var execFileAsync3 = promisify5(execFile3);
-var GitAddParameters = z13.object({
-  files: z13.array(z13.string()).describe("The files to add. If not provided, all changes will be added.")
+var GitAddParameters = z22.object({
+  files: z22.array(z22.string()).describe("The files to add. If not provided, all changes will be added.")
 });
-var gitAddTool = tool13({
+var gitAddTool = tool22({
   name: "gitAddTool",
   description: "Add file contents to the index.",
   parameters: GitAddParameters,
@@ -1579,16 +1864,16 @@ var gitAddTool = tool13({
 });
 
 // tools/git/gitBranchTool.ts
-import { tool as tool14 } from "@openai/agents";
+import { tool as tool23 } from "@openai/agents";
 import { execFile as execFile4 } from "child_process";
 import { promisify as promisify6 } from "util";
-import { z as z14 } from "zod";
+import { z as z23 } from "zod";
 var execFileAsync4 = promisify6(execFile4);
-var GitBranchParameters = z14.object({
-  branchName: z14.string().describe("The name of the branch to create or switch to."),
-  create: z14.boolean().optional().default(false).describe("Whether to create a new branch.")
+var GitBranchParameters = z23.object({
+  branchName: z23.string().describe("The name of the branch to create or switch to."),
+  create: z23.boolean().optional().default(false).describe("Whether to create a new branch.")
 });
-var gitBranchTool = tool14({
+var gitBranchTool = tool23({
   name: "gitBranchTool",
   description: "Create or switch to a git branch.",
   parameters: GitBranchParameters,
@@ -1605,18 +1890,18 @@ var gitBranchTool = tool14({
 });
 
 // tools/git/gitCommitTool.ts
-import { tool as tool15 } from "@openai/agents";
+import { tool as tool24 } from "@openai/agents";
 import { execFile as execFile5 } from "child_process";
 import { promisify as promisify7 } from "util";
-import { z as z15 } from "zod";
+import { z as z24 } from "zod";
 var execFileAsync5 = promisify7(execFile5);
-var GitCommitParameters = z15.object({
-  message: z15.string().describe("The commit message."),
-  addAll: z15.boolean().optional().default(false).describe(
+var GitCommitParameters = z24.object({
+  message: z24.string().describe("The commit message."),
+  addAll: z24.boolean().optional().default(false).describe(
     "Whether to add all changes before committing (git commit -am)."
   )
 });
-var gitCommitTool = tool15({
+var gitCommitTool = tool24({
   name: "gitCommitTool",
   description: "Commit changes to the repository.",
   parameters: GitCommitParameters,
@@ -1632,16 +1917,16 @@ var gitCommitTool = tool15({
 });
 
 // tools/git/gitLogTool.ts
-import { tool as tool16 } from "@openai/agents";
+import { tool as tool25 } from "@openai/agents";
 import { execFile as execFile6 } from "child_process";
 import { promisify as promisify8 } from "util";
-import { z as z16 } from "zod";
+import { z as z25 } from "zod";
 var execFileAsync6 = promisify8(execFile6);
-var GitLogParameters = z16.object({
-  count: z16.number().optional().default(10).describe("Number of commits to show."),
-  oneline: z16.boolean().optional().default(true).describe("Whether to show log in oneline format.")
+var GitLogParameters = z25.object({
+  count: z25.number().optional().default(10).describe("Number of commits to show."),
+  oneline: z25.boolean().optional().default(true).describe("Whether to show log in oneline format.")
 });
-var gitLogTool = tool16({
+var gitLogTool = tool25({
   name: "gitLogTool",
   description: "Show commit logs.",
   parameters: GitLogParameters,
@@ -1660,17 +1945,17 @@ var gitLogTool = tool16({
 });
 
 // tools/git/gitStashTool.ts
-import { tool as tool17 } from "@openai/agents";
+import { tool as tool26 } from "@openai/agents";
 import { execFile as execFile7 } from "child_process";
 import { promisify as promisify9 } from "util";
-import { z as z17 } from "zod";
+import { z as z26 } from "zod";
 var execFileAsync7 = promisify9(execFile7);
 var allowedActions = ["push", "pop", "apply", "list"];
-var GitStashParameters = z17.object({
-  action: z17.string().describe("The stash action to perform: " + allowedActions.join(", ")),
-  message: z17.string().describe("A message for the stash change.")
+var GitStashParameters = z26.object({
+  action: z26.string().describe("The stash action to perform: " + allowedActions.join(", ")),
+  message: z26.string().describe("A message for the stash change.")
 });
-var gitStashTool = tool17({
+var gitStashTool = tool26({
   name: "gitStashTool",
   description: "Stash changes or apply a stash.",
   parameters: GitStashParameters,
@@ -1692,15 +1977,15 @@ var gitStashTool = tool17({
 });
 
 // tools/git/gitStatusTool.ts
-import { tool as tool18 } from "@openai/agents";
+import { tool as tool27 } from "@openai/agents";
 import { execFile as execFile8 } from "child_process";
 import { promisify as promisify10 } from "util";
-import { z as z18 } from "zod";
+import { z as z27 } from "zod";
 var execFileAsync8 = promisify10(execFile8);
-var GitStatusParameters = z18.object({
-  short: z18.boolean().optional().default(false).describe("Whether to show the status in short format.")
+var GitStatusParameters = z27.object({
+  short: z27.boolean().optional().default(false).describe("Whether to show the status in short format.")
 });
-var gitStatusTool = tool18({
+var gitStatusTool = tool27({
   name: "gitStatusTool",
   description: "Show the working tree status.",
   parameters: GitStatusParameters,
@@ -1719,17 +2004,17 @@ var gitStatusTool = tool18({
 });
 
 // tools/git/gitWorkspaceTool.ts
-import { tool as tool19 } from "@openai/agents";
+import { tool as tool28 } from "@openai/agents";
 import { execFile as execFile9 } from "child_process";
 import { promisify as promisify11 } from "util";
-import { z as z19 } from "zod";
+import { z as z28 } from "zod";
 var execFileAsync9 = promisify11(execFile9);
-var GitWorkspaceParameters = z19.object({
-  path: z19.string().describe("The path where the new workspace (worktree) should be created."),
-  branchName: z19.string().describe("The name of the branch to use in the new workspace."),
-  createBranch: z19.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
+var GitWorkspaceParameters = z28.object({
+  path: z28.string().describe("The path where the new workspace (worktree) should be created."),
+  branchName: z28.string().describe("The name of the branch to use in the new workspace."),
+  createBranch: z28.boolean().optional().default(false).describe("Whether to create a new branch for this workspace.")
 });
-var gitWorkspaceTool = tool19({
+var gitWorkspaceTool = tool28({
   name: "gitWorkspaceTool",
   description: "Create a new workspace (git worktree) for parallel work.",
   parameters: GitWorkspaceParameters,
@@ -1746,13 +2031,13 @@ var gitWorkspaceTool = tool19({
 });
 
 // tools/harper/checkHarperStatusTool.ts
-import { tool as tool20 } from "@openai/agents";
-import { z as z20 } from "zod";
-var ToolParameters7 = z20.object({});
-var checkHarperStatusTool = tool20({
+import { tool as tool29 } from "@openai/agents";
+import { z as z29 } from "zod";
+var ToolParameters16 = z29.object({});
+var checkHarperStatusTool = tool29({
   name: "checkHarperStatusTool",
   description: "Checks if a Harper application is currently running.",
-  parameters: ToolParameters7,
+  parameters: ToolParameters16,
   async execute() {
     if (harperProcess.running) {
       return "A Harper application is currently running.";
@@ -1763,10 +2048,10 @@ var checkHarperStatusTool = tool20({
 });
 
 // tools/harper/createNewHarperApplicationTool.ts
-import { tool as tool21 } from "@openai/agents";
+import { tool as tool30 } from "@openai/agents";
 import { execSync as execSync3 } from "child_process";
 import path7 from "path";
-import { z as z21 } from "zod";
+import { z as z30 } from "zod";
 
 // utils/package/buildHarperCreateCommand.ts
 function buildCreateCommand(pm, appName, template) {
@@ -1816,11 +2101,11 @@ var PM_DISPLAY = {
 };
 
 // tools/harper/createNewHarperApplicationTool.ts
-var ToolParameters8 = z21.object({
-  directoryName: z21.string().describe("The name of the directory to create the application in."),
-  template: z21.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
+var ToolParameters17 = z30.object({
+  directoryName: z30.string().describe("The name of the directory to create the application in."),
+  template: z30.enum(["vanilla-ts", "vanilla", "react-ts", "react"]).optional().describe("The template to use for the new application. Defaults to vanilla-ts.").default("vanilla-ts")
 });
-async function execute4({ directoryName, template }) {
+async function execute14({ directoryName, template }) {
   const currentCwd = trackedState.cwd;
   const resolvedPath = resolvePath(currentCwd, directoryName);
   const isCurrentDir = resolvedPath === currentCwd;
@@ -1837,7 +2122,7 @@ async function execute4({ directoryName, template }) {
     });
     console.log(`Initializing new Git repository in ${resolvedPath}...`);
     execSync3("git init", { cwd: resolvedPath, stdio: "ignore" });
-    const switchedDir = await execute2({ path: resolvedPath });
+    const switchedDir = await execute11({ path: resolvedPath });
     return `Successfully created a new Harper application in '${resolvedPath}' using template '${template}' with a matching Git repository initialized.  Use the readDir and readFile tools to inspect the contents of the application. ${switchedDir}.`;
   } catch (error) {
     let errorMsg = `Error creating new Harper application: ${error.message}`;
@@ -1850,28 +2135,28 @@ ${error.stdout}`;
     return errorMsg;
   }
 }
-var createNewHarperApplicationTool = tool21({
+var createNewHarperApplicationTool = tool30({
   name: "createNewHarperApplicationTool",
   description: "Creates a new Harper application using the best available package manager (yarn/pnpm/bun/deno, falling back to npm).",
-  parameters: ToolParameters8,
-  execute: execute4
+  parameters: ToolParameters17,
+  execute: execute14
 });
 
 // tools/harper/getHarperConfigSchemaTool.ts
-import { tool as tool22 } from "@openai/agents";
+import { tool as tool31 } from "@openai/agents";
 import { readFile as readFile3 } from "fs/promises";
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname2, join as join8 } from "path";
-import { z as z22 } from "zod";
-var ToolParameters9 = z22.object({
-  schemaType: z22.enum(["app", "root"]).describe(
+import { z as z31 } from "zod";
+var ToolParameters18 = z31.object({
+  schemaType: z31.enum(["app", "root"]).describe(
     'The type of configuration schema to retrieve: "app" for application configuration or "root" for root Harper configuration.'
   )
 });
-var getHarperConfigSchemaTool = tool22({
+var getHarperConfigSchemaTool = tool31({
   name: "getHarperConfigSchemaTool",
   description: "Returns the JSON schema for HarperDB configuration files (either app or root), which describes the config.yaml or harperdb-config.yaml files.",
-  parameters: ToolParameters9,
+  parameters: ToolParameters18,
   async execute({ schemaType }) {
     try {
       return await readFile3(
@@ -1888,13 +2173,13 @@ var getHarperConfigSchemaTool = tool22({
 });
 
 // tools/harper/getHarperResourceInterfaceTool.ts
-import { tool as tool23 } from "@openai/agents";
+import { tool as tool32 } from "@openai/agents";
 import { readFile as readFile4 } from "fs/promises";
 import { createRequire as createRequire3 } from "module";
 import { dirname as dirname3, join as join9 } from "path";
-import { z as z23 } from "zod";
-var ToolParameters10 = z23.object({
-  resourceFile: z23.enum([
+import { z as z32 } from "zod";
+var ToolParameters19 = z32.object({
+  resourceFile: z32.enum([
     "ResourceInterfaceV2",
     "ResourceInterface",
     "Table",
@@ -1904,10 +2189,10 @@ var ToolParameters10 = z23.object({
     "The resource-related definition file to read. Defaults to ResourceInterfaceV2."
   ).default("ResourceInterfaceV2")
 });
-var getHarperResourceInterfaceTool = tool23({
+var getHarperResourceInterfaceTool = tool32({
   name: "getHarperResourceInterfaceTool",
   description: "Reads HarperDB resource interface and class definitions (like ResourceInterfaceV2.d.ts) to understand how resources and tables are structured.",
-  parameters: ToolParameters10,
+  parameters: ToolParameters19,
   async execute({ resourceFile }) {
     try {
       return await readFile4(
@@ -1925,16 +2210,16 @@ var getHarperResourceInterfaceTool = tool23({
 });
 
 // tools/harper/getHarperSchemaGraphQLTool.ts
-import { tool as tool24 } from "@openai/agents";
+import { tool as tool33 } from "@openai/agents";
 import { readFile as readFile5 } from "fs/promises";
 import { createRequire as createRequire4 } from "module";
 import { dirname as dirname4, join as join10 } from "path";
-import { z as z24 } from "zod";
-var ToolParameters11 = z24.object({});
-var getHarperSchemaGraphQLTool = tool24({
+import { z as z33 } from "zod";
+var ToolParameters20 = z33.object({});
+var getHarperSchemaGraphQLTool = tool33({
   name: "getHarperSchemaGraphQLTool",
   description: "Returns the GraphQL schema for HarperDB schema files, which define the structure of HarperDB database tables.",
-  parameters: ToolParameters11,
+  parameters: ToolParameters20,
   async execute() {
     try {
       return await readFile5(
@@ -1951,22 +2236,22 @@ var getHarperSchemaGraphQLTool = tool24({
 });
 
 // tools/harper/hitHarperAPITool.ts
-import { tool as tool25 } from "@openai/agents";
-import { z as z25 } from "zod";
-var ToolParameters12 = z25.object({
-  method: z25.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
+import { tool as tool34 } from "@openai/agents";
+import { z as z34 } from "zod";
+var ToolParameters21 = z34.object({
+  method: z34.enum(["POST", "GET", "PUT", "DELETE"]).optional().default("GET").describe(
     'The HTTP method to use, defaults to "get". Notably, POST and PUT require the full body be sent.'
   ),
-  path: z25.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
-  port: z25.number().optional().default(harperProcess.httpPort).describe(
+  path: z34.string().optional().default("/openapi").describe("The path to fetch from localhost (defaults to /openapi)."),
+  port: z34.number().optional().default(harperProcess.httpPort).describe(
     "The port to fetch from localhost (defaults to the running Harper port)."
   ),
-  body: z25.string().optional().default("").describe("An optional JSON string body to send along with the request.")
+  body: z34.string().optional().default("").describe("An optional JSON string body to send along with the request.")
 });
-var hitHarperAPITool = tool25({
+var hitHarperAPITool = tool34({
   name: "hitHarperAPITool",
   description: "Performs a request against the running Harper API. Use /openapi to look up Harper APIs.",
-  parameters: ToolParameters12,
+  parameters: ToolParameters21,
   needsApproval: async (runContext, input, callId) => {
     if (callId && runContext.isToolApproved({ toolName: "hitHarperAPITool", callId })) {
       return false;
@@ -2003,57 +2288,21 @@ var hitHarperAPITool = tool25({
   }
 });
 
-// tools/harper/openHarperInBrowserTool.ts
-import { tool as tool26 } from "@openai/agents";
-import spawn2 from "cross-spawn";
-import { platform } from "os";
-import { z as z26 } from "zod";
-var alreadyOpened = false;
-var ToolParameters13 = z26.object({});
-var openHarperInBrowserTool = tool26({
-  name: "openHarperInBrowserTool",
-  description: "Opens the running Harper app in the user's browser.",
-  parameters: ToolParameters13,
-  async execute() {
-    try {
-      if (alreadyOpened) {
-        return `Browser is already open.`;
-      }
-      if (!harperProcess.running) {
-        return `Error: No Harper application is currently running.`;
-      }
-      const url = `http://localhost:${harperProcess.httpPort}/`;
-      const p = platform();
-      if (p === "darwin") {
-        spawn2("open", [url]);
-      } else if (p === "win32") {
-        spawn2("start", ["", url]);
-      } else {
-        spawn2("xdg-open", [url]);
-      }
-      alreadyOpened = true;
-      return `Successfully opened '${url}' in the browser.`;
-    } catch (error) {
-      return `Error opening browser: ${error}`;
-    }
-  }
-});
-
 // tools/harper/readHarperLogsTool.ts
-import { tool as tool27 } from "@openai/agents";
-import { z as z27 } from "zod";
-var ToolParameters14 = z27.object({});
-var readHarperLogsTool = tool27({
+import { tool as tool35 } from "@openai/agents";
+import { z as z35 } from "zod";
+var ToolParameters22 = z35.object({});
+var readHarperLogsTool = tool35({
   name: "readHarperLogsTool",
   description: "Reads the most recent console logs of a started Harper app and clears them so that subsequent reads will only show new logs.",
-  parameters: ToolParameters14,
+  parameters: ToolParameters22,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
     }
     try {
-      const logs = harperProcess.getAndClearLogs();
-      return logs || "No logs available yet.";
+      const logs2 = harperProcess.getAndClearLogs();
+      return logs2 || "No logs available yet.";
     } catch (error) {
       return `Error reading Harper application logs: ${error}`;
     }
@@ -2061,10 +2310,10 @@ var readHarperLogsTool = tool27({
 });
 
 // tools/harper/startHarperTool.ts
-import { tool as tool28 } from "@openai/agents";
+import { tool as tool36 } from "@openai/agents";
 import { existsSync as existsSync7 } from "fs";
 import { basename, resolve } from "path";
-import { z as z28 } from "zod";
+import { z as z36 } from "zod";
 
 // utils/promises/sleep.ts
 function sleep(ms) {
@@ -2072,13 +2321,13 @@ function sleep(ms) {
 }
 
 // tools/harper/startHarperTool.ts
-var ToolParameters15 = z28.object({
-  directoryName: z28.string().describe("The name of the directory that the Harper app is in.")
+var ToolParameters23 = z36.object({
+  directoryName: z36.string().describe("The name of the directory that the Harper app is in.")
 });
-var startHarperTool = tool28({
+var startHarperTool = tool36({
   name: "startHarperTool",
-  description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, openHarperInBrowserTool, etc).",
-  parameters: ToolParameters15,
+  description: "Starts a Harper app background process, allowing you to observe the app in action (by readHarperLogsTool, hitHarperAPITool, etc).",
+  parameters: ToolParameters23,
   async execute({ directoryName }) {
     if (isIgnored(directoryName)) {
       return `Error: Target directory ${directoryName} is restricted by .aiignore`;
@@ -2097,9 +2346,9 @@ var startHarperTool = tool28({
       }
       harperProcess.start(effectiveDirectory);
       await sleep(5e3);
-      const logs = harperProcess.getAndClearLogs();
+      const logs2 = harperProcess.getAndClearLogs();
       return `Successfully started Harper application with auto-reload in '${effectiveDirectory}' with initial logs:
-${logs}`;
+${logs2}`;
     } catch (error) {
       return `Error: failed to start Harper application: ${error}`;
     }
@@ -2107,13 +2356,13 @@ ${logs}`;
 });
 
 // tools/harper/stopHarperTool.ts
-import { tool as tool29 } from "@openai/agents";
-import { z as z29 } from "zod";
-var ToolParameters16 = z29.object({});
-var stopHarperTool = tool29({
+import { tool as tool37 } from "@openai/agents";
+import { z as z37 } from "zod";
+var ToolParameters24 = z37.object({});
+var stopHarperTool = tool37({
   name: "stopHarperTool",
   description: "Stops all previously started Harper app background process.",
-  parameters: ToolParameters16,
+  parameters: ToolParameters24,
   async execute() {
     if (!harperProcess.running) {
       return `Error: No Harper application is currently running.`;
@@ -2130,6 +2379,15 @@ var stopHarperTool = tool29({
 // tools/factory.ts
 function createTools() {
   return [
+    browserClickTool,
+    browserCloseTool,
+    browserEvaluateTool,
+    browserGetContentTool,
+    browserGetLogsTool,
+    browserIsElementPresentTool,
+    browserNavigateTool,
+    browserScreenshotTool,
+    browserTypeTool,
     changeCwdTool,
     checkHarperStatusTool,
     codeInterpreterTool,
@@ -2149,7 +2407,6 @@ function createTools() {
     gitStatusTool,
     gitWorkspaceTool,
     hitHarperAPITool,
-    openHarperInBrowserTool,
     readDirTool,
     readFileTool,
     readHarperLogsTool,
@@ -2164,7 +2421,7 @@ function createTools() {
 
 // utils/package/checkForUpdate.ts
 import chalk10 from "chalk";
-import spawn3 from "cross-spawn";
+import spawn2 from "cross-spawn";
 
 // utils/package/getLatestVersion.ts
 async function getLatestVersion(packageName) {
@@ -2224,7 +2481,7 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
 `);
       let isGlobal = false;
       try {
-        const globalRootResult = spawn3.sync("npm", ["root", "-g"], {
+        const globalRootResult = spawn2.sync("npm", ["root", "-g"], {
           encoding: "utf8"
         });
         const globalRoot = globalRootResult.stdout?.trim();
@@ -2234,15 +2491,15 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
       } catch {
       }
       if (isGlobal) {
-        spawn3.sync("npm", ["install", "-g", `${packageName}@latest`], {
+        spawn2.sync("npm", ["install", "-g", `${packageName}@latest`], {
           stdio: "inherit"
         });
-        const result2 = spawn3.sync("harper-agent", process.argv.slice(2), {
+        const result2 = spawn2.sync("harper-agent", process.argv.slice(2), {
           stdio: "inherit"
         });
         process.exit(result2.status ?? 0);
       }
-      const lsResult = spawn3.sync("npm", ["cache", "npx", "ls", packageName], {
+      const lsResult = spawn2.sync("npm", ["cache", "npx", "ls", packageName], {
         encoding: "utf8"
       });
       if (lsResult.stdout) {
@@ -2251,12 +2508,12 @@ A new version of ${chalk10.bold(packageName)} is available! (${chalk10.dim(packa
           return pkgPart && pkgPart.trim().startsWith(`${packageName}@`);
         }).map((line) => line.split(":")[0].trim());
         if (keys.length > 0) {
-          spawn3.sync("npm", ["cache", "npx", "rm", ...keys], {
+          spawn2.sync("npm", ["cache", "npx", "rm", ...keys], {
             stdio: "inherit"
           });
         }
       }
-      const result = spawn3.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], {
+      const result = spawn2.sync("npx", ["-y", `${packageName}@latest`, ...process.argv.slice(2)], {
         stdio: "inherit"
       });
       process.exit(result.status ?? 0);