hypha-debugger 0.1.3 → 0.1.4

package/dist/hypha-debugger.mjs

@@ -742,6 +742,31 @@ getPageInfo.__schema__ = {
         },
     },
 };
+function getConsoleLogs(options) {
+    const logs = window.__HYPHA_DEBUGGER__?.consoleLogs ?? [];
+    const level = options?.level;
+    const limit = options?.limit ?? 100;
+    let filtered = level ? logs.filter((l) => l.level === level) : logs;
+    return filtered.slice(-limit);
+}
+getConsoleLogs.__schema__ = {
+    name: "getConsoleLogs",
+    description: "Retrieve captured console output (log, warn, error, info).",
+    parameters: {
+        type: "object",
+        properties: {
+            level: {
+                type: "string",
+                description: 'Filter by log level: "log", "warn", "error", "info". Omit for all levels.',
+                enum: ["log", "warn", "error", "info"],
+            },
+            limit: {
+                type: "number",
+                description: "Maximum number of log entries to return (most recent). Default: 100.",
+            },
+        },
+    },
+};
 /** Install console interceptor to capture logs. */
 function installConsoleCapture(maxEntries = 500) {
     var _a;
@@ -941,6 +966,88 @@ scrollTo.__schema__ = {
         required: ["target"],
     },
 };
+function getComputedStyles(selector, properties) {
+    const el = document.querySelector(selector);
+    if (!el) {
+        return { error: `No element found for selector: ${selector}` };
+    }
+    const computed = getComputedStyle(el);
+    const result = {};
+    const props = properties ??
+        [
+            "display",
+            "position",
+            "width",
+            "height",
+            "color",
+            "background-color",
+            "font-size",
+            "font-family",
+            "margin",
+            "padding",
+            "border",
+            "opacity",
+            "visibility",
+            "overflow",
+            "z-index",
+        ];
+    for (const prop of props) {
+        result[prop] = computed.getPropertyValue(prop);
+    }
+    return result;
+}
+getComputedStyles.__schema__ = {
+    name: "getComputedStyles",
+    description: "Get computed CSS styles for an element.",
+    parameters: {
+        type: "object",
+        properties: {
+            selector: {
+                type: "string",
+                description: "CSS selector of the element.",
+            },
+            properties: {
+                type: "array",
+                items: { type: "string" },
+                description: 'CSS property names to retrieve, e.g. ["color", "font-size"]. Omit for common defaults.',
+            },
+        },
+        required: ["selector"],
+    },
+};
+function getElementBounds(selector) {
+    const el = document.querySelector(selector);
+    if (!el) {
+        return { error: `No element found for selector: ${selector}` };
+    }
+    const rect = el.getBoundingClientRect();
+    return {
+        bounds: {
+            x: Math.round(rect.x),
+            y: Math.round(rect.y),
+            width: Math.round(rect.width),
+            height: Math.round(rect.height),
+        },
+        visible: rect.width > 0 &&
+            rect.height > 0 &&
+            getComputedStyle(el).visibility !== "hidden" &&
+            getComputedStyle(el).display !== "none",
+    };
+}
+getElementBounds.__schema__ = {
+    name: "getElementBounds",
+    description: "Get the bounding rectangle and visibility of a DOM element.",
+    parameters: {
+        type: "object",
+        properties: {
+            selector: {
+                type: "string",
+                description: "CSS selector of the element.",
+            },
+        },
+        required: ["selector"],
+    },
+};
 function getHtml(selector, outer, max_length) {
     const useOuter = outer ?? true;
     const maxLen = max_length ?? 50000;
@@ -2045,6 +2152,60 @@ navigate.__schema__ = {
         required: ["url"],
     },
 };
+function goBack() {
+    try {
+        window.history.back();
+        return { success: true, message: "Navigated back" };
+    }
+    catch (err) {
+        return { success: false, message: `Back navigation failed: ${err.message ?? err}` };
+    }
+}
+goBack.__schema__ = {
+    name: "goBack",
+    description: "Navigate back in browser history.",
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+};
+function goForward() {
+    try {
+        window.history.forward();
+        return { success: true, message: "Navigated forward" };
+    }
+    catch (err) {
+        return {
+            success: false,
+            message: `Forward navigation failed: ${err.message ?? err}`,
+        };
+    }
+}
+goForward.__schema__ = {
+    name: "goForward",
+    description: "Navigate forward in browser history.",
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+};
+function reload() {
+    try {
+        window.location.reload();
+        return { success: true, message: "Reloading page" };
+    }
+    catch (err) {
+        return { success: false, message: `Reload failed: ${err.message ?? err}` };
+    }
+}
+reload.__schema__ = {
+    name: "reload",
+    description: "Reload the current page.",
+    parameters: {
+        type: "object",
+        properties: {},
+    },
+};
 
 /**
  * React component tree inspection service.
@@ -2387,6 +2548,33 @@ function generateSkillMd(serviceFunctions, serviceUrl) {
     return [frontmatter, intro, functionDocs.join("\n"), tips].join("\n");
 }
 
+/**
+ * Wrap a function with correct, unminified parameter names for hypha-rpc.
+ *
+ * In production builds, Babel/Terser minifies parameter names (e.g. 'code' → 'e').
+ * hypha-rpc's getParamNames() parses Function.toString() to map kwargs to
+ * positional args. With minified names, kwargs like {code: '...'} can't be
+ * mapped and args are silently dropped.
+ *
+ * This helper uses new Function() to create a wrapper whose parameter names
+ * are taken from the function's __schema__ property, so hypha-rpc always sees
+ * the real parameter names regardless of minification.
+ */
+function wrapFn(fn) {
+    const schema = fn.__schema__;
+    const paramNames = schema?.parameters?.properties
+        ? Object.keys(schema.parameters.properties)
+        : [];
+    if (paramNames.length === 0) {
+        return fn;
+    }
+    const paramList = paramNames.join(", ");
+    const wrapper = new Function("fn", `return async function(${paramList}) { return fn(${paramList}); }`)(fn);
+    if (schema)
+        wrapper.__schema__ = schema;
+    return wrapper;
+}
+
 /**
  * @file port from browser-use
  * @see https://github.com/browser-use/browser-use/commits/main/browser_use/dom/dom_tree/index.js
@@ -5391,21 +5579,17 @@ class HyphaDebugger {
         return lines.join("\n");
     }
     /**
-     * Wrap a service function with logging and correct parameter names.
+     * Wrap a service function with overlay logging + correct parameter names.
      *
-     * Uses new Function() to create a wrapper whose parameter names match
-     * the __schema__ property names. This is critical for production builds
-     * where Babel/Terser minifies parameter names — hypha-rpc's
-     * getParamNames() parses Function.toString() to map kwargs to positional
-     * args, so the wrapper must have the real (unminified) parameter names.
+     * Adds logging around the function, then applies baseWrapFn() which uses
+     * new Function() to create a wrapper with unminified parameter names from
+     * __schema__. This is critical for production builds where Babel/Terser
+     * minifies parameter names — hypha-rpc's getParamNames() parses
+     * Function.toString() to map kwargs to positional args.
      */
     wrapFn(fn, name) {
-        const schema = fn.__schema__;
-        const paramNames = schema?.parameters?.properties
-            ? Object.keys(schema.parameters.properties)
-            : [];
         const self = this;
-        const callAndLog = async (args) => {
+        const logged = async (...args) => {
             self.overlay?.addLog(`${name}(${self.summarizeArgs(args)})`, "call");
             try {
                 const result = await fn(...args);
@@ -5423,19 +5607,10 @@ class HyphaDebugger {
                 throw err;
             }
         };
-        let wrapper;
-        if (paramNames.length === 0) {
-            wrapper = async (...args) => callAndLog(args);
-        }
-        else {
-            // Create a function with explicit, unminified parameter names so
-            // hypha-rpc can parse them from Function.toString().
-            const paramList = paramNames.join(", ");
-            wrapper = new Function("callAndLog", `return async function(${paramList}) { return callAndLog([${paramList}]); }`)(callAndLog);
-        }
-        if (schema)
-            wrapper.__schema__ = schema;
-        return wrapper;
+        // Preserve __schema__ so baseWrapFn can read parameter names
+        if (fn.__schema__)
+            logged.__schema__ = fn.__schema__;
+        return wrapFn(logged);
     }
     summarizeArgs(args) {
         if (args.length === 0)
@@ -5465,7 +5640,11 @@ class HyphaDebugger {
  * Programmatic usage:
  *   import { startDebugger } from 'hypha-debugger';
  *   const session = await startDebugger({ server_url: 'https://hypha.aicell.io' });
+ *
+ * Library usage (import individual functions):
+ *   import { getPageInfo, clickElement, wrapFn, PageController } from 'hypha-debugger';
  */
+// ── Core debugger ──
 /**
  * Start the Hypha debugger. Connects to a Hypha server and registers
  * a debug service that remote clients can use to inspect and interact
@@ -5534,5 +5713,5 @@ if (typeof window !== "undefined") {
     }
 }
 
-export { HyphaDebugger, startDebugger };
+export { AICursor, HyphaDebugger, PageController, clickElement$1 as clickElement, clickElementByIndex, disposeController, executeScript, fillInput, generateSkillMd, getBrowserState, getComputedStyles, getConsoleLogs, getElementBounds, getHtml, getPageInfo, getReactTree, goBack, goForward, inputText, installConsoleCapture, navigate, queryDom, reload, removeHighlights, scroll, scrollTo, selectOption, startDebugger, takeScreenshot, wrapFn };
 //# sourceMappingURL=hypha-debugger.mjs.map