nothing-browser 0.0.20 → 0.1.0

package/piggy/register/index.ts

@@ -1,8 +1,8 @@
 // piggy/register/index.ts
 import { PiggyClient } from "../client";
+import { HumanClient } from "../human";
 import logger from "../logger";
 import { routeRegistry, keepAliveSites, type RouteHandler, type BeforeMiddleware, type RouteDetail } from "../server";
-import { randomDelay, humanTypeSequence } from "../human";
 import { buildRespondScript, buildModifyResponseScript } from "../intercept/scripts";
 import { storeRecord } from "../store";
 import { TabPool } from "../pool";
@@ -37,8 +37,6 @@ export function createSiteObject(
   let _currentUrl: string = registeredUrl;
   let _modifyRuleCounter = 0;
 
-  // ── helpers ────────────────────────────────────────────────────────────────
-  // If pool exists, run fn with a pool tab. Otherwise use the fixed tabId.
   function withTab<T>(fn: (t: string) => Promise<T>): Promise<T> {
     return pool ? pool.withTab(fn) : fn(tabId);
   }
@@ -69,10 +67,8 @@ export function createSiteObject(
     _tabId: tabId,
     _pool: pool ?? null,
 
-    // ── Pool stats ────────────────────────────────────────────────────────────
     poolStats: () => pool?.stats ?? null,
 
-    // ── Navigation ────────────────────────────────────────────────────────────
     navigate: (url?: string, opts?: { retries?: number }) => {
       const target = url ?? registeredUrl;
       return withTab(t =>
@@ -115,7 +111,6 @@ export function createSiteObject(
     waitForResponse: (pattern: string, timeout = 30000) =>
       withTab(t => client.waitForResponse(pattern, timeout, t)),
 
-    // ── Init Script ───────────────────────────────────────────────────────────
     addInitScript: async (js: string | (() => void)) => {
       const code = typeof js === "function" ? `(${js.toString()})();` : js;
       await withTab(t => client.addInitScript(code, t));
@@ -123,7 +118,6 @@ export function createSiteObject(
       return site;
     },
 
-    // ── Events ────────────────────────────────────────────────────────────────
     on: (event: string, handler: (data: any) => void): (() => void) => {
       if (!_eventListeners.has(event)) _eventListeners.set(event, new Set());
       _eventListeners.get(event)!.add(handler);
@@ -138,12 +132,11 @@ export function createSiteObject(
       _eventListeners.get(event)?.delete(handler);
     },
 
-    // ── Interactions ──────────────────────────────────────────────────────────
     click: (selector: string, opts?: { retries?: number; timeout?: number }) =>
       withErrScreen(() =>
         withTab(t =>
           retry(name, async () => {
-            if (humanMode) await randomDelay(80, 220);
+            if (humanMode) await new Promise(r => setTimeout(r, 80 + Math.random() * 140));
             await client.waitForSelector(selector, opts?.timeout ?? 15000, t);
             const ok = await client.click(selector, t);
             if (!ok) throw new Error(`click failed: ${selector}`);
@@ -157,7 +150,7 @@ export function createSiteObject(
     doubleClick: (selector: string) =>
       withErrScreen(() =>
         withTab(async t => {
-          if (humanMode) await randomDelay(80, 200);
+          if (humanMode) await new Promise(r => setTimeout(r, 80 + Math.random() * 120));
           return client.doubleClick(selector, t);
         }),
         `dblclick(${selector})`
@@ -166,52 +159,50 @@ export function createSiteObject(
     hover: (selector: string) =>
       withErrScreen(() =>
         withTab(async t => {
-          if (humanMode) await randomDelay(50, 150);
+          if (humanMode) await new Promise(r => setTimeout(r, 50 + Math.random() * 100));
           return client.hover(selector, t);
         }),
         `hover(${selector})`
       ),
 
-      type: (selector: string, text: string, opts?: { delay?: number; retries?: number; fact?: boolean; wpm?: number }) =>
-  withErrScreen(() =>
-    withTab(async t => {
-      await client.waitForSelector(selector, 30000, t);
-      if (humanMode && !opts?.fact) {
-        const seq = humanTypeSequence(text);
-        let current = "";
-        for (const action of seq) {
-          if (action === "BACKSPACE") current = current.slice(0, -1);
-          else current += action;
+    // ──────────────────────────────────────────────────────────────────────────
+    // type – uses HumanClient when humanMode is true, otherwise basic client.type
+    // ──────────────────────────────────────────────────────────────────────────
+    type: (selector: string, text: string, opts?: { delay?: number; retries?: number; clear?: boolean; speed?: number }) =>
+      withErrScreen(() =>
+        withTab(async t => {
+          await client.waitForSelector(selector, 30000, t);
+
+          if (humanMode) {
+            const human = new HumanClient(client);
+            await human.type({
+              selector,
+              text,
+              clear: opts?.clear ?? false,
+              speed: opts?.speed
+            }, t);
+          } else {
+            // Fallback to basic type (with optional clear)
+            if (opts?.clear) {
+              await client.evaluate(`
+                const el = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                if (el) { el.value = ''; el.dispatchEvent(new Event('input', { bubbles: true })); }
+              `, t);
+            }
+            await client.type(selector, text, t);
+          }
+
+          // Fire blur to trigger reactive frameworks
           await client.evaluate(`
-            (function() {
-              const el = document.querySelector('${selector}');
-              const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value').set;
-              nativeSetter.call(el, '${current.replace(/'/g, "\\'")}');
-              el.dispatchEvent(new Event('input', { bubbles: true }));
-              el.dispatchEvent(new Event('change', { bubbles: true }));
-            })()
+            document.querySelector('${selector.replace(/'/g, "\\'")}')?.dispatchEvent(new Event('blur', { bubbles: true }));
           `, t);
-          const wpm = opts?.wpm ?? 120;
-          const msPerChar = Math.round(60000 / (wpm * 5));
-          await randomDelay(msPerChar * 0.5, msPerChar * 1.8);
-        }
-      } else if (opts?.delay) {
-        for (const ch of text) {
-          await client.type(selector, ch, t);
-          await new Promise(r => setTimeout(r, opts.delay));
-        }
-      } else {
-        await client.type(selector, text, t);
-      }
-      // fire blur so Phoenix/Angular/React pick up the final value
-      await client.evaluate(`
-        document.querySelector('${selector}').dispatchEvent(new Event('blur', { bubbles: true }))
-      `, t);
-      logger.success(`[${name}] typed into: ${selector}`);
-      return true;
-    }),
-    `type(${selector})`
-  ),
+
+          logger.success(`[${name}] typed into: ${selector}`);
+          return true;
+        }),
+        `type(${selector})`
+      ),
+
     select:   (selector: string, value: string) => withTab(t => client.select(selector, value, t)),
 
     evaluate: (js: string | (() => any), ...args: any[]) => {
@@ -240,7 +231,7 @@ export function createSiteObject(
             const chunk = px / steps;
             for (let i = 0; i < steps; i++) {
               await client.scrollBy(chunk, t);
-              await randomDelay(30, 80);
+              await new Promise(r => setTimeout(r, 30 + Math.random() * 50));
             }
           } else {
             await client.scrollBy(px, t);
@@ -248,7 +239,6 @@ export function createSiteObject(
         }) as Promise<void>,
     },
 
-    // ── Fetch ─────────────────────────────────────────────────────────────────
     fetchText:   (selector: string) => withTab(t => client.fetchText(selector, t)),
 
     fetchLinks: async (selector: string) => {
@@ -268,7 +258,6 @@ export function createSiteObject(
       id:  (query: string) => withTab(t => client.searchId(query, t)),
     },
 
-    // ── Screenshot / PDF ──────────────────────────────────────────────────────
     screenshot: async (filePath?: string) => {
       const r = await withTab(t => client.screenshot(filePath, t));
       logger.success(`[${name}] screenshot → ${filePath ?? "base64"}`);
@@ -284,7 +273,6 @@ export function createSiteObject(
     blockImages:   () => withTab(async t => { await client.blockImages(t);   logger.info(`[${name}] images blocked`); }),
     unblockImages: () => withTab(async t => { await client.unblockImages(t); logger.info(`[${name}] images unblocked`); }),
 
-    // ── Cookies ───────────────────────────────────────────────────────────────
     cookies: {
       set: async (cookieName: string, value: string, domain: string, path = "/") => {
         await withTab(t => client.setCookie(cookieName, value, domain, path, t));
@@ -298,7 +286,6 @@ export function createSiteObject(
       list: () => withTab(t => client.listCookies(t)),
     },
 
-    // ── Interception ──────────────────────────────────────────────────────────
     intercept: {
       block: async (pattern: string) => {
         await withTab(t => client.addInterceptRule("block", pattern, {}, t));
@@ -399,7 +386,6 @@ export function createSiteObject(
       },
     },
 
-    // ── Network capture ───────────────────────────────────────────────────────
     capture: {
       start:    () => withTab(async t => { await client.captureStart(t);  logger.info(`[${name}] capture started`); }),
       stop:     () => withTab(async t => { await client.captureStop(t);   logger.info(`[${name}] capture stopped`); }),
@@ -410,7 +396,6 @@ export function createSiteObject(
       clear:    () => withTab(async t => { await client.captureClear(t);  logger.info(`[${name}] capture cleared`); }),
     },
 
-    // ── Session ───────────────────────────────────────────────────────────────
     session: {
       export: async () => {
         const data = await withTab(t => client.sessionExport(t));
@@ -423,7 +408,6 @@ export function createSiteObject(
       },
     },
 
-    // ── Expose Function ───────────────────────────────────────────────────────
     exposeFunction: async (fnName: string, handler: (data: any) => Promise<any> | any) => {
       await client.exposeFunction(fnName, handler, tabId);
       logger.success(`[${name}] exposed function: ${fnName}`);
@@ -447,7 +431,6 @@ export function createSiteObject(
       return site;
     },
 
-    // ── Store ─────────────────────────────────────────────────────────────────
     store: async (
       data: Record<string, any> | Record<string, any>[],
       schemaName?: string
@@ -458,7 +441,6 @@ export function createSiteObject(
       return result;
     },
 
-    // ── Elysia API ────────────────────────────────────────────────────────────
     api: (
       path: string,
       handler: RouteHandler,

package/piggy/router/index.ts

@@ -0,0 +1,69 @@
+// piggy/router/index.ts
+// Mirrors PiggyCommandRouter.cpp.
+// This is the single entry point that composes all sub-clients
+// into one object — the same way the C++ router dispatches to sub-handlers.
+
+import { PiggyClient } from "../client";
+import { CaptureClient, createCaptureAPI } from "../capture";
+import { CaptchaClient, createCaptchaAPI } from "../captcha";
+import { DialogClient, createDialogAPI } from "../dialog";
+import { ExportClient, createExportAPI } from "../export";
+import { FindClient, createFindAPI } from "../find";
+import { HumanClient, createHumanAPI } from "../human";
+import { IframeClient, createIframeAPI } from "../iframe";
+import { InteractionsClient, createInteractionsAPI } from "../interactions";
+import { MediaClient, createMediaAPI } from "../media";
+import { NavigationClient, createNavigationAPI } from "../navigation";
+import { ProvideClient, createProvideAPI } from "../provide";
+import { ProxyClient, createProxyAPI } from "../proxy";
+import { SessionClient, createSessionAPI } from "../session";
+import { TabsClient, createTabsAPI } from "../tabs";
+import { WaitClient, EvaluateClient, FetchClient, createWaitAPI, createEvaluateAPI, createFetchAPI } from "../wait";
+
+export interface PiggyRouter {
+  // Core transport
+  client: PiggyClient;
+
+  // Sub-routers — 1:1 with C++ files
+  tabs: TabsClient;
+  navigation: NavigationClient;
+  interactions: InteractionsClient;
+  media: MediaClient;
+  capture: CaptureClient;
+  find: FindClient;
+  provide: ProvideClient;
+  wait: WaitClient;
+  evaluate: EvaluateClient;
+  fetch: FetchClient;
+  proxy: ProxyClient;
+  captcha: CaptchaClient;
+  dialog: DialogClient;
+  human: HumanClient;
+  iframe: IframeClient;
+  session: SessionClient;
+  export: ExportClient;
+}
+
+export function createRouter(client: PiggyClient): PiggyRouter {
+  return {
+    client,
+    tabs:         createTabsAPI(client),
+    navigation:   createNavigationAPI(client),
+    interactions: createInteractionsAPI(client),
+    media:        createMediaAPI(client),
+    capture:      createCaptureAPI(client),
+    find:         createFindAPI(client),
+    provide:      createProvideAPI(client),
+    wait:         createWaitAPI(client),
+    evaluate:     createEvaluateAPI(client),
+    fetch:        createFetchAPI(client),
+    proxy:        createProxyAPI(client),
+    captcha:      createCaptchaAPI(client),
+    dialog:       createDialogAPI(client),
+    human:        createHumanAPI(client),
+    iframe:       createIframeAPI(client),
+    session:      createSessionAPI(client),
+    export:       createExportAPI(client),
+  };
+}
+

package/piggy/session/index.ts

@@ -0,0 +1,76 @@
+// piggy/session/index.ts
+import { PiggyClient } from "../client";
+import type { CookieSetOptions, CookieDeleteOptions } from "../export";
+
+export interface SessionPaths {
+  workDir: string;
+  cookies: string;
+  profile: string;
+  ws: string;
+  pings: string;
+}
+
+export class SessionClient {
+  constructor(private client: PiggyClient) {}
+
+  // Session lifecycle
+  reload(tabId = "default"): Promise<void> {
+    return this.client.send("session.reload", { tabId });
+  }
+
+  // Paths
+  paths(): Promise<SessionPaths> {
+    return this.client.send("session.paths", {});
+  }
+
+  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", {});
+  }
+
+  // Opt-in persistence
+  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 });
+  }
+
+  // Export / import
+  async export(tabId = "default"): Promise<any> {
+    const raw = await this.client.send<string>("session.export", { tabId });
+    return typeof raw === "string" ? JSON.parse(raw) : raw;
+  }
+
+  import(data: any, tabId = "default"): Promise<void> {
+    return this.client.send("session.import", {
+      data: JSON.stringify(data),
+      tabId,
+    });
+  }
+
+  // Cookies (using imported types from export)
+  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 });
+  }
+}
+
+export function createSessionAPI(client: PiggyClient): SessionClient {
+  return new SessionClient(client);
+}

package/piggy/tabs/index.ts

@@ -0,0 +1,22 @@
+// piggy/tabs/index.ts
+import { PiggyClient } from "../client";
+
+export class TabsClient {
+  constructor(private client: PiggyClient) {}
+
+  new(): Promise<string> {
+    return this.client.send("tab.new", {});
+  }
+
+  close(tabId: string): Promise<void> {
+    return this.client.send("tab.close", { tabId });
+  }
+
+  list(): Promise<string[]> {
+    return this.client.send("tab.list", {});
+  }
+}
+
+export function createTabsAPI(client: PiggyClient): TabsClient {
+  return new TabsClient(client);
+}

package/piggy/wait/index.ts

@@ -0,0 +1,90 @@
+// piggy/wait/index.ts
+import { PiggyClient } from "../client";
+
+export type WaitSelectorState = "attached" | "detached" | "visible" | "hidden";
+
+// ─── WaitClient ───────────────────────────────────────────────────────────────
+// Maps to PiggyWait.cpp
+
+export class WaitClient {
+  constructor(private client: PiggyClient) {}
+
+  // wait.function — poll every 100ms until JS expr is truthy
+  function(js: string, timeout = 10000, tabId = "default"): Promise<void> {
+    return this.client.send("wait.function", { js, timeout, tabId });
+  }
+
+  // wait.selector — with full state support (attached|detached|visible|hidden)
+  selector(
+    selector: string,
+    state: WaitSelectorState = "attached",
+    timeout = 10000,
+    tabId = "default"
+  ): Promise<void> {
+    return this.client.send("wait.selector", { selector, state, timeout, tabId });
+  }
+}
+
+// ─── EvaluateClient ───────────────────────────────────────────────────────────
+// Maps to the evaluate command in PiggyWait.cpp (with timeout support)
+// and PiggyInteractions.cpp (without timeout)
+
+export class EvaluateClient {
+  constructor(private client: PiggyClient) {}
+
+  // evaluate with optional wall-clock timeout
+  run(js: string, timeout?: number, tabId = "default"): Promise<unknown> {
+    return this.client.send("evaluate", {
+      js,
+      tabId,
+      ...(timeout !== undefined ? { timeout } : {}),
+    });
+  }
+}
+
+// ─── FetchClient ──────────────────────────────────────────────────────────────
+// Maps to fetch.textAll / fetch.attr / fetch.attrAll in PiggyWait.cpp
+// and fetch.text / fetch.links / fetch.image in PiggyExport.cpp
+
+export class FetchClient {
+  constructor(private client: PiggyClient) {}
+
+  // fetch.text — single element innerText
+  text(selector: string, tabId = "default"): Promise<string | null> {
+    return this.client.send("fetch.text", { query: selector, tabId });
+  }
+
+  // fetch.textAll — all matching elements innerText
+  textAll(selector: string, tabId = "default"): Promise<string[]> {
+    return this.client.send("fetch.textAll", { selector, tabId });
+  }
+
+  // fetch.attr — single attribute from first match
+  attr(selector: string, attr: string, tabId = "default"): Promise<string | null> {
+    return this.client.send("fetch.attr", { selector, attr, tabId });
+  }
+
+  // fetch.attrAll — attribute from all matches
+  attrAll(selector: string, attr: string, tabId = "default"): Promise<string[]> {
+    return this.client.send("fetch.attrAll", { selector, attr, tabId });
+  }
+
+  // fetch.links — links inside a selector
+  links(selector: string, tabId = "default"): Promise<string[]> {
+    return this.client.send("fetch.links", { query: selector, tabId });
+  }
+
+  // fetch.links.all — all links on page
+  linksAll(tabId = "default"): Promise<string[]> {
+    return this.client.send("fetch.links.all", { tabId });
+  }
+
+  // fetch.image — images inside a selector
+  images(selector: string, tabId = "default"): Promise<string[]> {
+    return this.client.send("fetch.image", { query: selector, tabId });
+  }
+}
+
+export function createWaitAPI(client: PiggyClient):     WaitClient     { return new WaitClient(client); }
+export function createEvaluateAPI(client: PiggyClient): EvaluateClient { return new EvaluateClient(client); }
+export function createFetchAPI(client: PiggyClient):    FetchClient    { return new FetchClient(client); }