hypha-debugger 0.1.2 → 0.1.3

package/dist/hypha-debugger.mjs

@@ -5390,50 +5390,52 @@ class HyphaDebugger {
         lines.push(``, `# 1. Get interactive elements (smart DOM analysis with indexed elements):`, `curl "$SERVICE_URL/get_browser_state"${auth}`, ``, `# 2. Click element by index (e.g. click [3]):`, `curl -X POST "$SERVICE_URL/click_element_by_index"${auth} -H "Content-Type: application/json" -d '{"index": 3}'`, ``, `# 3. Type into an input by index:`, `curl -X POST "$SERVICE_URL/input_text"${auth} -H "Content-Type: application/json" -d '{"index": 5, "text": "hello"}'`, ``, `# Take a screenshot:`, `curl "$SERVICE_URL/take_screenshot"${auth}`, ``, `# Execute JavaScript remotely:`, `curl -X POST "$SERVICE_URL/execute_script"${auth} -H "Content-Type: application/json" -d '{"code": "document.title"}'`, ``, `# Full API docs:`, `curl "$SERVICE_URL/get_skill_md"${auth}`);
         return lines.join("\n");
     }
-    /** Wrap a service function with logging and kwargs-to-positional-args support. */
+    /**
+     * Wrap a service function with logging and 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.
+     */
     wrapFn(fn, name) {
-        const wrapped = async (...args) => {
-            // Hypha's HTTP API calls with keyword arguments (**kwargs),
-            // which arrive on the JS side as a single object argument.
-            // Destructure into positional args based on schema properties.
-            if (args.length === 1 &&
-                args[0] &&
-                typeof args[0] === "object" &&
-                !Array.isArray(args[0]) &&
-                fn.__schema__?.parameters?.properties) {
-                const kwargs = args[0];
-                const props = fn.__schema__.parameters.properties;
-                const paramNames = Object.keys(props);
-                // Check if any kwargs key matches a schema property name
-                const hasMatchingKey = paramNames.some((p) => p in kwargs);
-                if (hasMatchingKey) {
-                    args = paramNames.map((p) => kwargs[p]);
-                    while (args.length > 0 && args[args.length - 1] === undefined) {
-                        args.pop();
-                    }
-                }
-            }
-            this.overlay?.addLog(`${name}(${this.summarizeArgs(args)})`, "call");
+        const schema = fn.__schema__;
+        const paramNames = schema?.parameters?.properties
+            ? Object.keys(schema.parameters.properties)
+            : [];
+        const self = this;
+        const callAndLog = async (args) => {
+            self.overlay?.addLog(`${name}(${self.summarizeArgs(args)})`, "call");
             try {
                 const result = await fn(...args);
                 const hasError = result && typeof result === "object" && "error" in result;
                 if (hasError) {
-                    this.overlay?.addLog(`${name}: ${result.error}`, "error");
+                    self.overlay?.addLog(`${name}: ${result.error}`, "error");
                 }
                 else {
-                    this.overlay?.addLog(`${name} -> OK`, "result");
+                    self.overlay?.addLog(`${name} -> OK`, "result");
                 }
                 return result;
             }
             catch (err) {
-                this.overlay?.addLog(`${name}: ${err.message}`, "error");
+                self.overlay?.addLog(`${name}: ${err.message}`, "error");
                 throw err;
             }
         };
-        if (fn.__schema__) {
-            wrapped.__schema__ = fn.__schema__;
+        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);
         }
-        return wrapped;
+        if (schema)
+            wrapper.__schema__ = schema;
+        return wrapper;
     }
     summarizeArgs(args) {
         if (args.length === 0)