nothing-browser 0.0.21 → 0.1.1

package/piggy/export/index.ts

@@ -0,0 +1,147 @@
+// piggy/export/index.ts
+import { PiggyClient } from "../client";
+import type { CapturedRequest, WebSocketFrame, CapturedCookie } from "../capture";
+import type { SessionPaths } from "../session";
+
+// ─── Intercept ────────────────────────────────────────────────────────────────
+export interface InterceptRule {
+  pattern: string;
+  block?: boolean;
+  redirect?: string;
+  setHeaders?: Record<string, string>;
+  removeHeaders?: string[];
+}
+
+// ─── Cookie types (defined here, imported by session) ────────────────────────
+export interface CookieSetOptions {
+  name: string;
+  value: string;
+  domain: string;
+  path?: string;
+  httpOnly?: boolean;
+  secure?: boolean;
+  expiry?: number;
+}
+
+export interface CookieDeleteOptions {
+  name: string;
+  domain: string;
+}
+
+// ─── Session export types (re-exported from capture) ────────────────────────
+export type { CapturedRequest, WebSocketFrame, CapturedCookie, SessionPaths };
+
+export interface SessionExport {
+  url: string;
+  requests: CapturedRequest[];
+  ws: WebSocketFrame[];
+  cookies: CapturedCookie[];
+}
+
+export interface ExposedFunctionCall {
+  name: string;
+  callId: string;
+  data: string;
+  tabId: string;
+}
+
+// ─── ExportClient ─────────────────────────────────────────────────────────────
+export class ExportClient {
+  constructor(private client: PiggyClient) {}
+
+  // DOM fetch
+  searchCss(query: string, tabId = "default"): Promise<any> {
+    return this.client.send("search.css", { query, tabId });
+  }
+
+  searchId(query: string, tabId = "default"): Promise<any> {
+    return this.client.send("search.id", { query, tabId });
+  }
+
+  // Cookies
+  setCookie(opts: CookieSetOptions, tabId = "default"): Promise<void> {
+    return this.client.send("cookie.set", { ...opts, tabId });
+  }
+
+  deleteCookie(opts: CookieDeleteOptions, tabId = "default"): Promise<void> {
+    return this.client.send("cookie.delete", { ...opts, tabId });
+  }
+
+  // Session
+  sessionReload(tabId = "default"): Promise<void> {
+    return this.client.send("session.reload", { tabId });
+  }
+
+  cookiesPath(): Promise<string> {
+    return this.client.send("session.cookies.path", {});
+  }
+
+  profilePath(): Promise<string> {
+    return this.client.send("session.profile.path", {});
+  }
+
+  wsPath(): Promise<string> {
+    return this.client.send("session.ws.path", {});
+  }
+
+  pingsPath(): Promise<string> {
+    return this.client.send("session.pings.path", {});
+  }
+
+  sessionPaths(): Promise<SessionPaths> {
+    return this.client.send("session.paths", {});
+  }
+
+  setWsSave(enabled: boolean): Promise<void> {
+    return this.client.send("session.ws.save", { enabled });
+  }
+
+  setPingsSave(enabled: boolean): Promise<void> {
+    return this.client.send("session.pings.save", { enabled });
+  }
+
+  // Intercept rules
+  addInterceptRule(rule: InterceptRule, tabId = "default"): Promise<void> {
+    return this.client.send("intercept.rule.add", { ...rule, tabId });
+  }
+
+  clearInterceptRules(tabId = "default"): Promise<void> {
+    return this.client.send("intercept.rule.clear", { tabId });
+  }
+
+  // Session export / import
+  async exportSession(tabId = "default"): Promise<SessionExport> {
+    const raw = await this.client.send<string>("session.export", { tabId });
+    return typeof raw === "string" ? JSON.parse(raw) : raw;
+  }
+
+  importSession(data: SessionExport, tabId = "default"): Promise<void> {
+    return this.client.send("session.import", {
+      data: JSON.stringify(data),
+      tabId,
+    });
+  }
+
+  // Exposed functions
+  exposeFunction(name: string, tabId = "default"): Promise<void> {
+    return this.client.send("expose.function", { name, tabId });
+  }
+
+  resolveExposed(callId: string, result: string, isError = false, tabId = "default"): Promise<void> {
+    return this.client.send("exposed.result", { callId, result, isError, tabId });
+  }
+
+  // Init scripts
+  addInitScript(js: string, tabId = "default"): Promise<void> {
+    return this.client.send("addInitScript", { js, tabId });
+  }
+
+  // Events
+  onExposedFunctionCalled(tabId: string, handler: (call: ExposedFunctionCall) => void): () => void {
+    return this.client.onEvent("exposed_call", tabId, handler);
+  }
+}
+
+export function createExportAPI(client: PiggyClient): ExportClient {
+  return new ExportClient(client);
+}

package/piggy/find/index.ts

@@ -0,0 +1,118 @@
+// 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>;
+}
+
+// ─── FindClient ───────────────────────────────────────────────────────────────
+// find answers ONE question: "is this thing here, and where?"
+// All methods take plain selector strings — no option objects, no parent scoping.
+// If you need a value out of an element, use provide instead.
+
+export class FindClient {
+  constructor(private client: PiggyClient) {}
+
+  // ── Multi-result ─────────────────────────────────────────────────────────────
+
+  /** querySelectorAll — returns all matching elements. */
+  css(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    return this.client.send("find.css", { selector, tabId });
+  }
+
+  /** Alias for css(). */
+  all(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    return this.client.send("find.all", { selector, tabId });
+  }
+
+  /** querySelector — returns a single-element array or []. */
+  first(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    return this.client.send("find.first", { selector, tabId });
+  }
+
+  /** Find elements whose innerText contains the given text. */
+  byText(text: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    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[]> {
+    return this.client.send("find.byAttr", { attr, value, tabId });
+  }
+
+  /** getElementsByTagName. */
+  byTag(tag: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    return this.client.send("find.byTag", { tag, tabId });
+  }
+
+  /** Find inputs/textareas whose placeholder contains the given text. */
+  byPlaceholder(text: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    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[]> {
+    return this.client.send("find.byRole", { role, name, tabId });
+  }
+
+  /** Direct children of the matched element. */
+  children(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    return this.client.send("find.children", { selector, tabId });
+  }
+
+  /** parentElement of the matched element. */
+  parent(selector: string, tabId = "default"): Promise<ElementDescriptor[]> {
+    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[]> {
+    return this.client.send("find.closest", { selector, ancestor, tabId });
+  }
+
+  // ── Boolean / numeric ────────────────────────────────────────────────────────
+
+  /** Number of elements matching the selector. */
+  count(selector: string, tabId = "default"): Promise<number> {
+    return this.client.send("find.count", { selector, tabId });
+  }
+
+  /** True if at least one element matches. */
+  exists(selector: string, tabId = "default"): Promise<boolean> {
+    return this.client.send("find.exists", { selector, tabId });
+  }
+
+  /** True if the first matched element is visible. */
+  visible(selector: string, tabId = "default"): Promise<boolean> {
+    return this.client.send("find.visible", { selector, tabId });
+  }
+
+  /** True if the first matched element is not disabled. */
+  enabled(selector: string, tabId = "default"): Promise<boolean> {
+    return this.client.send("find.enabled", { selector, tabId });
+  }
+
+  /** True if the first matched checkbox/radio is checked. */
+  checked(selector: string, tabId = "default"): Promise<boolean> {
+    return this.client.send("find.checked", { selector, tabId });
+  }
+}
+
+// ─── Factory helper ───────────────────────────────────────────────────────────
+
+export function createFindAPI(client: PiggyClient): FindClient {
+  return new FindClient(client);
+}

package/piggy/http/index.ts

@@ -0,0 +1,65 @@
+// piggy/http/index.ts
+// 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) {
+    const host = opts.host ?? "localhost";
+    const port = opts.port ?? 2005;
+    this.baseUrl = `http://${host}:${port}`;
+    this.key = opts.key;
+  }
+
+  // ── Health check ──────────────────────────────────────────────────────────
+
+  async ping(): Promise<boolean> {
+    try {
+      const res = await fetch(this.baseUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Piggy-Key": this.key,
+        },
+        body: "hello",
+      });
+      const text = await res.text();
+      return text.includes("active");
+    } catch {
+      return false;
+    }
+  }
+
+  // ── Send command ──────────────────────────────────────────────────────────
+
+  async send<T = any>(cmd: string, payload: Record<string, any> = {}): Promise<T> {
+    const res = await fetch(this.baseUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Piggy-Key": this.key,
+      },
+      body: JSON.stringify({ id: String(Date.now()), cmd, payload }),
+    });
+
+    if (res.status === 401) throw new Error("Unauthorized — invalid X-Piggy-Key");
+    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 };
+    if (!data.ok) throw new Error(String(data.data) ?? "command failed");
+    return data.data;
+  }
+}
+
+export function createHttpClient(opts: HttpClientOptions): PiggyHttpClient {
+  return new PiggyHttpClient(opts);
+}

package/piggy/human/index.ts

@@ -1,53 +1,115 @@
-// piggy/human/index.ts
-
-export function randomDelay(min: number, max: number): Promise<void> {
-  return new Promise(r => setTimeout(r, Math.floor(Math.random() * (max - min + 1)) + min));
-}
-
-/**
- * Simulates human typing by introducing ~2 random typos and correcting them.
- * Returns an array of { char, isBackspace } actions to replay.
- */
-export function humanTypeSequence(text: string): string[] {
-  const adjacent: Record<string, string[]> = {
-    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"],
-    h: ["g","y","u","j","n","b"], i: ["u","o","k","j"],
-    j: ["h","u","i","k","m","n"], k: ["j","i","o","l","m"],
-    l: ["k","o","p"], m: ["n","j","k"], n: ["b","h","j","m"],
-    o: ["i","p","l","k"], p: ["o","l"], q: ["w","a"],
-    r: ["e","t","f","d"], s: ["a","w","e","d","x","z"],
-    t: ["r","y","g","f"], u: ["y","i","h","j"],
-    v: ["c","f","g","b"], w: ["q","e","a","s"],
-    x: ["z","s","d","c"], y: ["t","u","g","h"],
-    z: ["a","s","x"],
-  };
-
-  const actions: string[] = [];
-  const typoIndices = new Set<number>();
-
-  // Pick ~2 random positions to typo (skip short strings)
-  if (text.length > 4) {
-    let tries = 0;
-    while (typoIndices.size < 2 && tries < 20) {
-      typoIndices.add(Math.floor(Math.random() * text.length));
-      tries++;
-    }
-  }
-
-  for (let i = 0; i < text.length; i++) {
-    if (typoIndices.has(i)) {
-      const ch = text[i]!.toLowerCase();
-      const neighbors = adjacent[ch];
-        const typo = neighbors
-        ? neighbors[Math.floor(Math.random() * neighbors.length)] ?? ch
-        : ch;
-      actions.push(typo);        // wrong char
-      actions.push("BACKSPACE"); // correct it
-    }
-    actions.push(text[i]!);
-  }
-
-  return actions;
-}
+// piggy/human/index.ts
+import { PiggyClient } from "../client";
+
+// ─── Local utilities ──────────────────────────────────────────────────────────
+
+export function randomDelay(min: number, max: number): Promise<void> {
+  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[]> = {
+    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"],
+    h: ["g","y","u","j","n","b"], i: ["u","o","k","j"],
+    j: ["h","u","i","k","m","n"], k: ["j","i","o","l","m"],
+    l: ["k","o","p"], m: ["n","j","k"], n: ["b","h","j","m"],
+    o: ["i","p","l","k"], p: ["o","l"], q: ["w","a"],
+    r: ["e","t","f","d"], s: ["a","w","e","d","x","z"],
+    t: ["r","y","g","f"], u: ["y","i","h","j"],
+    v: ["c","f","g","b"], w: ["q","e","a","s"],
+    x: ["z","s","d","c"], y: ["t","u","g","h"],
+    z: ["a","s","x"],
+  };
+
+  const actions: string[] = [];
+  const typoIndices = new Set<number>();
+
+  if (text.length > 4) {
+    let tries = 0;
+    while (typoIndices.size < 2 && tries < 20) {
+      typoIndices.add(Math.floor(Math.random() * text.length));
+      tries++;
+    }
+  }
+
+  for (let i = 0; i < text.length; i++) {
+    if (typoIndices.has(i)) {
+      const ch = text[i]!.toLowerCase();
+      const neighbors = adjacent[ch];
+      const typo = neighbors
+        ? neighbors[Math.floor(Math.random() * neighbors.length)] ?? ch
+        : ch;
+      actions.push(typo);
+      actions.push("BACKSPACE");
+    }
+    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) {}
+
+  // human.set — update global profile
+  set(opts: HumanSetOptions, tabId = "default"): Promise<HumanProfile> {
+    return this.client.send("human.set", { ...opts, tabId });
+  }
+
+  // human.get — read current profile
+  get(tabId = "default"): Promise<HumanProfile> {
+    return this.client.send("human.get", { tabId });
+  }
+
+  // human.type — char-by-char typing with realistic delays
+  type(opts: HumanTypeOptions, tabId = "default"): Promise<void> {
+    return this.client.send("human.type", { ...opts, tabId });
+  }
+
+  // human.click — delayed click with optional force dispatch
+  click(opts: HumanClickOptions, tabId = "default"): Promise<void> {
+    return this.client.send("human.click", { ...opts, tabId });
+  }
+}
+
+export function createHumanAPI(client: PiggyClient): HumanClient {
+  return new HumanClient(client);
+}

package/piggy/iframe/index.ts

@@ -0,0 +1,79 @@
+// piggy/iframe/index.ts
+import { PiggyClient } from "../client";
+
+// ─── Descriptor types ─────────────────────────────────────────────────────────
+
+export interface IframeDescriptor {
+  index: number;
+  src:   string;
+  id:    string;
+  name:  string;
+}
+
+// ─── Option types ─────────────────────────────────────────────────────────────
+
+/** Target an iframe by its index or src. One must be provided. */
+export type IframeTarget =
+  | { index: number; src?: never }
+  | { src: string;  index?: never };
+
+export type IframeEvaluateOptions = IframeTarget & { js: string };
+export type IframeClickOptions    = IframeTarget & { sel: string };
+export type IframeTypeOptions     = IframeTarget & { sel: string; text: string };
+export type IframeTextOptions     = IframeTarget & { sel: string };
+export type IframeHtmlOptions     = IframeTarget;
+export type IframeWaitSelOptions  = IframeTarget & { sel: string; timeout?: number };
+
+// ─── IframeClient ─────────────────────────────────────────────────────────────
+
+export class IframeClient {
+  constructor(private client: PiggyClient) {}
+
+  /** List all iframes on the page: index, src, id, name. */
+  list(tabId = "default"): Promise<IframeDescriptor[]> {
+    return this.client.send("iframe.list", { tabId });
+  }
+
+  /** Run arbitrary JS inside the targeted iframe. Returns whatever the script returns. */
+  evaluate(opts: IframeEvaluateOptions, tabId = "default"): Promise<unknown> {
+    return this.client.send("iframe.evaluate", { ...opts, tabId });
+  }
+
+  /** Click a selector inside the targeted iframe. */
+  click(opts: IframeClickOptions, tabId = "default"): Promise<boolean> {
+    return this.client.send("iframe.click", { ...opts, tabId });
+  }
+
+  /** Type text into a selector inside the targeted iframe. */
+  type(opts: IframeTypeOptions, tabId = "default"): Promise<boolean> {
+    return this.client.send("iframe.type", { ...opts, tabId });
+  }
+
+  /** Get innerText of a selector inside the targeted iframe. */
+  text(opts: IframeTextOptions, tabId = "default"): Promise<string> {
+    return this.client.send("iframe.text", { ...opts, tabId });
+  }
+
+  /** Get the full HTML of the targeted iframe. */
+  html(opts: IframeHtmlOptions, tabId = "default"): Promise<string> {
+    return this.client.send("iframe.html", { ...opts, tabId });
+  }
+
+  /** Wait until a selector appears inside the targeted iframe. */
+  waitSel(opts: IframeWaitSelOptions, tabId = "default"): Promise<boolean> {
+    return this.client.send("iframe.waitSel", { ...opts, tabId });
+  }
+}
+
+// ─── Factory helper ───────────────────────────────────────────────────────────
+
+export function createIframeAPI(client: PiggyClient): IframeClient {
+  return new IframeClient(client);
+}
+// Done. One thing worth noting — `IframeTarget` is a discriminated union so TypeScript enforces you pass either `index` or `src`, never both. Usage looks like:
+
+// ```js
+// 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

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