nothing-browser 0.1.2 → 0.1.4

package/piggy/export/index.js

@@ -0,0 +1,105 @@
+// piggy/export/index.js
+import { PiggyClient } from "../client.js";
+
+// ─── ExportClient ─────────────────────────────────────────────────────────────
+export class ExportClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  // DOM fetch
+  searchCss(query, tabId = "default") {
+    return this.client.send("search.css", { query, tabId });
+  }
+
+  searchId(query, tabId = "default") {
+    return this.client.send("search.id", { query, tabId });
+  }
+
+  // Cookies
+  setCookie(opts, tabId = "default") {
+    return this.client.send("cookie.set", { ...opts, tabId });
+  }
+
+  deleteCookie(opts, tabId = "default") {
+    return this.client.send("cookie.delete", { ...opts, tabId });
+  }
+
+  // Session
+  sessionReload(tabId = "default") {
+    return this.client.send("session.reload", { tabId });
+  }
+
+  cookiesPath() {
+    return this.client.send("session.cookies.path", {});
+  }
+
+  profilePath() {
+    return this.client.send("session.profile.path", {});
+  }
+
+  wsPath() {
+    return this.client.send("session.ws.path", {});
+  }
+
+  pingsPath() {
+    return this.client.send("session.pings.path", {});
+  }
+
+  sessionPaths() {
+    return this.client.send("session.paths", {});
+  }
+
+  setWsSave(enabled) {
+    return this.client.send("session.ws.save", { enabled });
+  }
+
+  setPingsSave(enabled) {
+    return this.client.send("session.pings.save", { enabled });
+  }
+
+  // Intercept rules
+  addInterceptRule(rule, tabId = "default") {
+    return this.client.send("intercept.rule.add", { ...rule, tabId });
+  }
+
+  clearInterceptRules(tabId = "default") {
+    return this.client.send("intercept.rule.clear", { tabId });
+  }
+
+  // Session export / import
+  async exportSession(tabId = "default") {
+    const raw = await this.client.send("session.export", { tabId });
+    return typeof raw === "string" ? JSON.parse(raw) : raw;
+  }
+
+  importSession(data, tabId = "default") {
+    return this.client.send("session.import", {
+      data: JSON.stringify(data),
+      tabId,
+    });
+  }
+
+  // Exposed functions
+  exposeFunction(name, tabId = "default") {
+    return this.client.send("expose.function", { name, tabId });
+  }
+
+  resolveExposed(callId, result, isError = false, tabId = "default") {
+    return this.client.send("exposed.result", { callId, result, isError, tabId });
+  }
+
+  // Init scripts
+  addInitScript(js, tabId = "default") {
+    return this.client.send("addInitScript", { js, tabId });
+  }
+
+  // Events
+  onExposedFunctionCalled(tabId, handler) {
+    return this.client.onEvent("exposed_call", tabId, handler);
+  }
+}
+
+export function createExportAPI(client) {
+  return new ExportClient(client);
+}

package/piggy/expose/index.js

@@ -0,0 +1,24 @@
+import { PiggyClient } from "../client.js";
+import logger from "../logger.js";
+
+export async function exposeFunction(client, fnName, handler, tabId) {
+  await client.exposeFunction(fnName, handler, tabId);
+  logger.success(`[${tabId}] exposed function: ${fnName}`);
+}
+
+export async function unexposeFunction(client, fnName, tabId) {
+  await client.unexposeFunction(fnName, tabId);
+  logger.info(`[${tabId}] unexposed function: ${fnName}`);
+}
+
+export async function clearExposedFunctions(client, tabId) {
+  await client.clearExposedFunctions(tabId);
+  logger.info(`[${tabId}] cleared all exposed functions`);
+}
+
+export async function exposeAndInject(client, fnName, handler, injectionJs, tabId) {
+  await client.exposeFunction(fnName, handler, tabId);
+  const js = typeof injectionJs === "function" ? injectionJs(fnName) : injectionJs;
+  await client.evaluate(js, tabId);
+  logger.success(`[${tabId}] exposed and injected: ${fnName}`);
+}

package/piggy/find/{index.ts → index.js}

@@ -1,22 +1,5 @@
-// piggy/find/index.ts
-import { PiggyClient } from "../client";
-
-// ─── Element descriptor ───────────────────────────────────────────────────────
-// Mirrors __nb_serialize() in PiggyFind.cpp
-
-export interface ElementDescriptor {
-  tag:   string;
-  id:    string;
-  cls:   string;
-  /** First 400 chars of innerText */
-  text:  string;
-  /** First 800 chars of innerHTML */
-  html:  string;
-  href:  string;
-  src:   string;
-  value: string;
-  attrs: Record<string, string>;
-}
+// piggy/find/index.js
+import { PiggyClient } from "../client.js";
 
 // ─── FindClient ───────────────────────────────────────────────────────────────
 // find answers ONE question: "is this thing here, and where?"
@@ -24,95 +7,97 @@ export interface ElementDescriptor {
 // If you need a value out of an element, use provide instead.
 
 export class FindClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
-  // ── Multi-result ─────────────────────────────────────────────────────────────
+  // ── Multi-result ──────────────────────────────────────────────────────────
 
   /** querySelectorAll — returns all matching elements. */
-  css(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  css(selector, tabId = "default") {
     return this.client.send("find.css", { selector, tabId });
   }
 
   /** Alias for css(). */
-  all(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  all(selector, tabId = "default") {
     return this.client.send("find.all", { selector, tabId });
   }
 
   /** querySelector — returns a single-element array or []. */
-  first(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  first(selector, tabId = "default") {
     return this.client.send("find.first", { selector, tabId });
   }
 
   /** Find elements whose innerText contains the given text. */
-  byText(text: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  byText(text, tabId = "default") {
     return this.client.send("find.byText", { text, tabId });
   }
 
   /** Find elements by attribute name (and optional value). */
-  byAttr(attr: string, value?: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  byAttr(attr, value, tabId = "default") {
     return this.client.send("find.byAttr", { attr, value, tabId });
   }
 
   /** getElementsByTagName. */
-  byTag(tag: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  byTag(tag, tabId = "default") {
     return this.client.send("find.byTag", { tag, tabId });
   }
 
   /** Find inputs/textareas whose placeholder contains the given text. */
-  byPlaceholder(text: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  byPlaceholder(text, tabId = "default") {
     return this.client.send("find.byPlaceholder", { text, tabId });
   }
 
   /** Find elements by ARIA role, optionally filtered by accessible name. */
-  byRole(role: string, name?: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  byRole(role, name, tabId = "default") {
     return this.client.send("find.byRole", { role, name, tabId });
   }
 
   /** Direct children of the matched element. */
-  children(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  children(selector, tabId = "default") {
     return this.client.send("find.children", { selector, tabId });
   }
 
   /** parentElement of the matched element. */
-  parent(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  parent(selector, tabId = "default") {
     return this.client.send("find.parent", { selector, tabId });
   }
 
   /** Walk up the DOM from selector until ancestor matches. */
-  closest(selector: string, ancestor: string, tabId = "default"): Promise<ElementDescriptor[]> {
+  closest(selector, ancestor, tabId = "default") {
     return this.client.send("find.closest", { selector, ancestor, tabId });
   }
 
-  // ── Boolean / numeric ────────────────────────────────────────────────────────
+  // ── Boolean / numeric ─────────────────────────────────────────────────────
 
   /** Number of elements matching the selector. */
-  count(selector: string, tabId = "default"): Promise<number> {
+  count(selector, tabId = "default") {
     return this.client.send("find.count", { selector, tabId });
   }
 
   /** True if at least one element matches. */
-  exists(selector: string, tabId = "default"): Promise<boolean> {
+  exists(selector, tabId = "default") {
     return this.client.send("find.exists", { selector, tabId });
   }
 
   /** True if the first matched element is visible. */
-  visible(selector: string, tabId = "default"): Promise<boolean> {
+  visible(selector, tabId = "default") {
     return this.client.send("find.visible", { selector, tabId });
   }
 
   /** True if the first matched element is not disabled. */
-  enabled(selector: string, tabId = "default"): Promise<boolean> {
+  enabled(selector, tabId = "default") {
     return this.client.send("find.enabled", { selector, tabId });
   }
 
   /** True if the first matched checkbox/radio is checked. */
-  checked(selector: string, tabId = "default"): Promise<boolean> {
+  checked(selector, tabId = "default") {
     return this.client.send("find.checked", { selector, tabId });
   }
 }
 
 // ─── Factory helper ───────────────────────────────────────────────────────────
 
-export function createFindAPI(client: PiggyClient): FindClient {
+export function createFindAPI(client) {
   return new FindClient(client);
 }

package/piggy/http/{index.ts → index.js}

@@ -1,18 +1,9 @@
-// piggy/http/index.ts
+// piggy/http/index.js
 // Mirrors PiggyHttp.cpp — connects to the HTTP server on port 2005.
 // Use this when you want to talk to the browser over HTTP instead of the unix socket.
 
-export interface HttpClientOptions {
-  host?: string;
-  port?: number;
-  key: string;
-}
-
 export class PiggyHttpClient {
-  private baseUrl: string;
-  private key: string;
-
-  constructor(opts: HttpClientOptions) {
+  constructor(opts) {
     const host = opts.host ?? "localhost";
     const port = opts.port ?? 2005;
     this.baseUrl = `http://${host}:${port}`;
@@ -21,7 +12,7 @@ export class PiggyHttpClient {
 
   // ── Health check ──────────────────────────────────────────────────────────
 
-  async ping(): Promise<boolean> {
+  async ping() {
     try {
       const res = await fetch(this.baseUrl, {
         method: "POST",
@@ -40,7 +31,7 @@ export class PiggyHttpClient {
 
   // ── Send command ──────────────────────────────────────────────────────────
 
-  async send<T = any>(cmd: string, payload: Record<string, any> = {}): Promise<T> {
+  async send(cmd, payload = {}) {
     const res = await fetch(this.baseUrl, {
       method: "POST",
       headers: {
@@ -54,12 +45,12 @@ export class PiggyHttpClient {
     if (res.status === 400) throw new Error("Bad request — invalid JSON");
     if (!res.ok) throw new Error(`HTTP ${res.status}`);
 
-    const data = await res.json() as { ok: boolean; data: T };
+    const data = await res.json();
     if (!data.ok) throw new Error(String(data.data) ?? "command failed");
     return data.data;
   }
 }
 
-export function createHttpClient(opts: HttpClientOptions): PiggyHttpClient {
+export function createHttpClient(opts) {
   return new PiggyHttpClient(opts);
-}
+}

package/piggy/human/{index.ts → index.js}

@@ -1,14 +1,14 @@
-// piggy/human/index.ts
-import { PiggyClient } from "../client";
+// piggy/human/index.js
+import { PiggyClient } from "../client.js";
 
 // ─── Local utilities ──────────────────────────────────────────────────────────
 
-export function randomDelay(min: number, max: number): Promise<void> {
+export function randomDelay(min, max) {
   return new Promise(r => setTimeout(r, Math.floor(Math.random() * (max - min + 1)) + min));
 }
 
-export function humanTypeSequence(text: string): string[] {
-  const adjacent: Record<string, string[]> = {
+export function humanTypeSequence(text) {
+  const adjacent = {
     a: ["q","w","s","z"], b: ["v","g","h","n"], c: ["x","d","f","v"],
     d: ["s","e","r","f","c","x"], e: ["w","r","d","s"],
     f: ["d","r","t","g","v","c"], g: ["f","t","y","h","b","v"],
@@ -23,8 +23,8 @@ export function humanTypeSequence(text: string): string[] {
     z: ["a","s","x"],
   };
 
-  const actions: string[] = [];
-  const typoIndices = new Set<number>();
+  const actions = [];
+  const typoIndices = new Set();
 
   if (text.length > 4) {
     let tries = 0;
@@ -36,7 +36,7 @@ export function humanTypeSequence(text: string): string[] {
 
   for (let i = 0; i < text.length; i++) {
     if (typoIndices.has(i)) {
-      const ch = text[i]!.toLowerCase();
+      const ch = text[i].toLowerCase();
       const neighbors = adjacent[ch];
       const typo = neighbors
         ? neighbors[Math.floor(Math.random() * neighbors.length)] ?? ch
@@ -44,72 +44,41 @@ export function humanTypeSequence(text: string): string[] {
       actions.push(typo);
       actions.push("BACKSPACE");
     }
-    actions.push(text[i]!);
+    actions.push(text[i]);
   }
 
   return actions;
 }
 
-// ─── Profile types ────────────────────────────────────────────────────────────
-
-export type TypingSpeed = "slow" | "normal" | "fast";
-export type ClickDelay  = "cautious" | "normal" | "fast";
-export type ScrollSpeed = "slow" | "normal" | "fast";
-
-export interface HumanProfile {
-  typingSpeed: TypingSpeed;
-  clickDelay:  ClickDelay;
-  scrollSpeed: ScrollSpeed;
-  mouseWiggle: boolean;
-}
-
-export interface HumanSetOptions {
-  typingSpeed?: TypingSpeed;
-  clickDelay?:  ClickDelay;
-  scrollSpeed?: ScrollSpeed;
-  mouseWiggle?: boolean;
-}
-
-export interface HumanTypeOptions {
-  selector: string;
-  text:     string;
-  clear?:   boolean;
-  speed?:   number;
-}
-
-export interface HumanClickOptions {
-  selector: string;
-  force?:   boolean;
-  delay?:   number;
-}
-
 // ─── HumanClient ─────────────────────────────────────────────────────────────
 // Maps 1:1 to PiggyHuman.cpp commands
 
 export class HumanClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
   // human.set — update global profile
-  set(opts: HumanSetOptions, tabId = "default"): Promise<HumanProfile> {
+  set(opts, tabId = "default") {
     return this.client.send("human.set", { ...opts, tabId });
   }
 
   // human.get — read current profile
-  get(tabId = "default"): Promise<HumanProfile> {
+  get(tabId = "default") {
     return this.client.send("human.get", { tabId });
   }
 
   // human.type — char-by-char typing with realistic delays
-  type(opts: HumanTypeOptions, tabId = "default"): Promise<void> {
+  type(opts, tabId = "default") {
     return this.client.send("human.type", { ...opts, tabId });
   }
 
   // human.click — delayed click with optional force dispatch
-  click(opts: HumanClickOptions, tabId = "default"): Promise<void> {
+  click(opts, tabId = "default") {
     return this.client.send("human.click", { ...opts, tabId });
   }
 }
 
-export function createHumanAPI(client: PiggyClient): HumanClient {
+export function createHumanAPI(client) {
   return new HumanClient(client);
-}
+}

package/piggy/iframe/index.js

@@ -0,0 +1,56 @@
+// piggy/iframe/index.js
+import { PiggyClient } from "../client.js";
+
+// ─── IframeClient ─────────────────────────────────────────────────────────────
+
+export class IframeClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /** List all iframes on the page: index, src, id, name. */
+  list(tabId = "default") {
+    return this.client.send("iframe.list", { tabId });
+  }
+
+  /** Run arbitrary JS inside the targeted iframe. Returns whatever the script returns. */
+  evaluate(opts, tabId = "default") {
+    return this.client.send("iframe.evaluate", { ...opts, tabId });
+  }
+
+  /** Click a selector inside the targeted iframe. */
+  click(opts, tabId = "default") {
+    return this.client.send("iframe.click", { ...opts, tabId });
+  }
+
+  /** Type text into a selector inside the targeted iframe. */
+  type(opts, tabId = "default") {
+    return this.client.send("iframe.type", { ...opts, tabId });
+  }
+
+  /** Get innerText of a selector inside the targeted iframe. */
+  text(opts, tabId = "default") {
+    return this.client.send("iframe.text", { ...opts, tabId });
+  }
+
+  /** Get the full HTML of the targeted iframe. */
+  html(opts, tabId = "default") {
+    return this.client.send("iframe.html", { ...opts, tabId });
+  }
+
+  /** Wait until a selector appears inside the targeted iframe. */
+  waitSel(opts, tabId = "default") {
+    return this.client.send("iframe.waitSel", { ...opts, tabId });
+  }
+}
+
+// ─── Factory helper ───────────────────────────────────────────────────────────
+
+export function createIframeAPI(client) {
+  return new IframeClient(client);
+}
+
+// Usage:
+// piggy.google.iframe.list()
+// piggy.google.iframe.click({ index: 0, sel: "#btn" })
+// piggy.google.iframe.evaluate({ src: "https://...", js: "document.title" })

package/piggy/interactions/{index.ts → index.js}

@@ -1,79 +1,76 @@
-// piggy/interactions/index.ts
-import { PiggyClient } from "../client";
-
-export interface MousePosition {
-  x: number;
-  y: number;
-}
+// piggy/interactions/index.js
+import { PiggyClient } from "../client.js";
 
 export class InteractionsClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
   // ── Click ─────────────────────────────────────────────────────────────────
 
-  click(selector: string, tabId = "default"): Promise<boolean> {
+  click(selector, tabId = "default") {
     return this.client.send("click", { selector, tabId });
   }
 
-  dblclick(selector: string, tabId = "default"): Promise<boolean> {
+  dblclick(selector, tabId = "default") {
     return this.client.send("dblclick", { selector, tabId });
   }
 
-  hover(selector: string, tabId = "default"): Promise<boolean> {
+  hover(selector, tabId = "default") {
     return this.client.send("hover", { selector, tabId });
   }
 
   // ── Input ─────────────────────────────────────────────────────────────────
 
-  type(selector: string, text: string, tabId = "default"): Promise<boolean> {
+  type(selector, text, tabId = "default") {
     return this.client.send("type", { selector, text, tabId });
   }
 
-  typeClear(selector: string, text: string, tabId = "default"): Promise<boolean> {
+  typeClear(selector, text, tabId = "default") {
     return this.client.send("type", { selector, text, clear: true, tabId });
   }
 
-  select(selector: string, value: string, tabId = "default"): Promise<boolean> {
+  select(selector, value, tabId = "default") {
     return this.client.send("select", { selector, value, tabId });
   }
 
   // ── Scroll ────────────────────────────────────────────────────────────────
 
-  scrollTo(selector: string, tabId = "default"): Promise<boolean> {
+  scrollTo(selector, tabId = "default") {
     return this.client.send("scroll.to", { selector, tabId });
   }
 
-  scrollBy(px: number, tabId = "default"): Promise<boolean> {
+  scrollBy(px, tabId = "default") {
     return this.client.send("scroll.by", { px, tabId });
   }
 
   // ── Keyboard ──────────────────────────────────────────────────────────────
 
-  keyPress(key: string, tabId = "default"): Promise<boolean> {
+  keyPress(key, tabId = "default") {
     return this.client.send("keyboard.press", { key, tabId });
   }
 
-  keyCombo(combo: string, tabId = "default"): Promise<boolean> {
+  keyCombo(combo, tabId = "default") {
     return this.client.send("keyboard.combo", { combo, tabId });
   }
 
   // ── Mouse ─────────────────────────────────────────────────────────────────
 
-  mouseMove(x: number, y: number, tabId = "default"): Promise<boolean> {
+  mouseMove(x, y, tabId = "default") {
     return this.client.send("mouse.move", { x, y, tabId });
   }
 
-  mouseDrag(from: MousePosition, to: MousePosition, tabId = "default"): Promise<boolean> {
+  mouseDrag(from, to, tabId = "default") {
     return this.client.send("mouse.drag", { from, to, tabId });
   }
 
   // ── Evaluate ──────────────────────────────────────────────────────────────
 
-  evaluate(js: string, tabId = "default"): Promise<unknown> {
+  evaluate(js, tabId = "default") {
     return this.client.send("evaluate", { js, tabId });
   }
 }
 
-export function createInteractionsAPI(client: PiggyClient): InteractionsClient {
+export function createInteractionsAPI(client) {
   return new InteractionsClient(client);
-}
+}

package/piggy/intercept/{scripts.ts → scripts.js}

@@ -1,4 +1,4 @@
-// piggy/intercept/scripts.ts
+// piggy/intercept/scripts.js
 // JS injection helpers for intercept.respond and intercept.modifyResponse.
 // Both work purely in the browser's JS layer — no C++ changes needed.
 
@@ -6,12 +6,7 @@
  * Generates a script that short-circuits matching fetch/XHR requests
  * and returns a static fake response — the request never hits the network.
  */
-export function buildRespondScript(
-  pattern: string,
-  status: number,
-  contentType: string,
-  body: string
-): string {
+export function buildRespondScript(pattern, status, contentType, body) {
   const safePattern     = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const safeBody        = body.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   const safeContentType = contentType.replace(/'/g, "\\'");
@@ -32,7 +27,6 @@ export function buildRespondScript(
     catch { return url.includes(pattern); }
   }
 
-  // Only install wrappers once per page
   if (window.__PIGGY_RESPOND_INSTALLED__) return;
   window.__PIGGY_RESPOND_INSTALLED__ = true;
 
@@ -92,7 +86,7 @@ export function buildRespondScript(
  * The exposed function returns { body?, status?, headers? } modifications
  * or an empty object {} to pass through unchanged.
  */
-export function buildModifyResponseScript(pattern: string, exposedFnName: string): string {
+export function buildModifyResponseScript(pattern, exposedFnName) {
   const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
   const safeFnName  = exposedFnName.replace(/'/g, "\\'");
 
@@ -107,7 +101,6 @@ export function buildModifyResponseScript(pattern: string, exposedFnName: string
     catch { return url.includes(pattern); }
   }
 
-  // Only install wrappers once per page
   if (window.__PIGGY_MODIFY_INSTALLED__) return;
   window.__PIGGY_MODIFY_INSTALLED__ = true;
 
@@ -121,7 +114,6 @@ export function buildModifyResponseScript(pattern: string, exposedFnName: string
       if (_piggyMatchUrl(url, rule.pattern)) { matchedFn = rule.fn; break; }
     }
 
-    // No match — pass through untouched
     const resp = await _origFetch.apply(this, arguments);
     if (!matchedFn) return resp;
 
@@ -133,7 +125,6 @@ export function buildModifyResponseScript(pattern: string, exposedFnName: string
       const handlerFn = window[matchedFn];
       if (typeof handlerFn !== 'function') return resp;
 
-      // Call Node.js handler via exposeFunction bridge
       const mod = await handlerFn({ body: bodyText, status: resp.status, headers });
       if (!mod || typeof mod !== 'object' || Object.keys(mod).length === 0) return resp;
 
@@ -145,7 +136,7 @@ export function buildModifyResponseScript(pattern: string, exposedFnName: string
         }
       );
     } catch {
-      return resp; // On any error, pass through original response
+      return resp;
     }
   };
 })();