nothing-browser 0.0.20 → 0.1.0

package/dist/register/index.js

@@ -6805,6 +6805,26 @@ var require_lib = __commonJS((exports, module) => {
   module.exports.SqliteError = require_sqlite_error();
 });
 
+// piggy/human/index.ts
+class HumanClient {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  set(opts, tabId = "default") {
+    return this.client.send("human.set", { ...opts, tabId });
+  }
+  get(tabId = "default") {
+    return this.client.send("human.get", { tabId });
+  }
+  type(opts, tabId = "default") {
+    return this.client.send("human.type", { ...opts, tabId });
+  }
+  click(opts, tabId = "default") {
+    return this.client.send("human.click", { ...opts, tabId });
+  }
+}
+
 // piggy/logger/index.ts
 var import_ernest_logger = __toESM(require_ernest_logger(), 1);
 var logger = import_ernest_logger.createLogger({
@@ -22570,61 +22590,6 @@ var store = new Map;
 var routeRegistry = new Map;
 var keepAliveSites = new Set;
 
-// piggy/human/index.ts
-function randomDelay(min, max) {
-  return new Promise((r) => setTimeout(r, Math.floor(Math.random() * (max - min + 1)) + min));
-}
-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"],
-    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 = [];
-  const typoIndices = new Set;
-  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;
-}
-
 // piggy/intercept/scripts.ts
 function buildRespondScript(pattern, status2, contentType, body) {
   const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
@@ -23035,7 +23000,7 @@ function createSiteObject(name, registeredUrl, client, tabId, pool) {
     },
     click: (selector, opts) => withErrScreen(() => withTab((t2) => retry(name, async () => {
       if (humanMode)
-        await randomDelay(80, 220);
+        await new Promise((r) => setTimeout(r, 80 + Math.random() * 140));
       await client.waitForSelector(selector, opts?.timeout ?? 15000, t2);
       const ok = await client.click(selector, t2);
       if (!ok)
@@ -23045,48 +23010,36 @@ function createSiteObject(name, registeredUrl, client, tabId, pool) {
     }, opts?.retries ?? 2)), `click(${selector})`),
     doubleClick: (selector) => withErrScreen(() => withTab(async (t2) => {
       if (humanMode)
-        await randomDelay(80, 200);
+        await new Promise((r) => setTimeout(r, 80 + Math.random() * 120));
       return client.doubleClick(selector, t2);
     }), `dblclick(${selector})`),
     hover: (selector) => withErrScreen(() => withTab(async (t2) => {
       if (humanMode)
-        await randomDelay(50, 150);
+        await new Promise((r) => setTimeout(r, 50 + Math.random() * 100));
       return client.hover(selector, t2);
     }), `hover(${selector})`),
     type: (selector, text, opts) => withErrScreen(() => withTab(async (t2) => {
       await client.waitForSelector(selector, 30000, t2);
-      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;
+      if (humanMode) {
+        const human = new HumanClient(client);
+        await human.type({
+          selector,
+          text,
+          clear: opts?.clear ?? false,
+          speed: opts?.speed
+        }, t2);
+      } else {
+        if (opts?.clear) {
           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 }));
-            })()
-          `, t2);
-          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, t2);
-          await new Promise((r) => setTimeout(r, opts.delay));
+                const el = document.querySelector('${selector.replace(/'/g, "\\'")}');
+                if (el) { el.value = ''; el.dispatchEvent(new Event('input', { bubbles: true })); }
+              `, t2);
         }
-      } else {
         await client.type(selector, text, t2);
       }
       await client.evaluate(`
-        document.querySelector('${selector}').dispatchEvent(new Event('blur', { bubbles: true }))
-      `, t2);
+            document.querySelector('${selector.replace(/'/g, "\\'")}')?.dispatchEvent(new Event('blur', { bubbles: true }));
+          `, t2);
       logger_default.success(`[${name}] typed into: ${selector}`);
       return true;
     }), `type(${selector})`),
@@ -23111,7 +23064,7 @@ function createSiteObject(name, registeredUrl, client, tabId, pool) {
           const chunk = px / steps;
           for (let i = 0;i < steps; i++) {
             await client.scrollBy(chunk, t2);
-            await randomDelay(30, 80);
+            await new Promise((r) => setTimeout(r, 30 + Math.random() * 50));
           }
         } else {
           await client.scrollBy(px, t2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nothing-browser",
-  "version": "0.0.20",
+  "version": "0.1.0",
   "description": "Browser automation library powered by Nothing Browser",
   "homepage": "https://github.com/ernest-tech-house-co-operation/nothing-browser#readme",
   "repository": {

package/piggy/captcha/index.d.ts

@@ -0,0 +1,35 @@
+// piggy/captcha/index.d.ts
+import { PiggyClient } from "../client";
+
+export interface CaptchaState {
+  detected: boolean;
+  paused: boolean;
+  type: string;
+}
+
+export interface BlockState {
+  detected: boolean;
+  type: string;
+}
+
+export declare class CaptchaClient {
+  constructor(client: PiggyClient);
+
+  status(tabId?: string): Promise<CaptchaState>;
+  resolve(tabId?: string): Promise<void>;
+  pause(tabId?: string): Promise<void>;
+  check(tabId?: string): Promise<void>;
+  setAutoRetry(enabled: boolean): Promise<void>;
+
+  blockStatus(tabId?: string): Promise<BlockState>;
+  blockRetry(tabId?: string): Promise<void>;
+
+  onCaptcha(tabId: string, handler: (data: { captchaType: string; tabId: string }) => void): () => void;
+  onCaptchaResolved(tabId: string, handler: (data: { tabId: string }) => void): () => void;
+  onBlocked(tabId: string, handler: (data: { blockType: string; tabId: string }) => void): () => void;
+  onBlockRetry(tabId: string, handler: (data: { tabId: string; proxy: string }) => void): () => void;
+
+  waitForResolution(tabId?: string, timeoutMs?: number): Promise<void>;
+}
+
+export declare function createCaptchaAPI(client: PiggyClient): CaptchaClient;

package/piggy/captcha/index.ts

@@ -0,0 +1,93 @@
+// piggy/captcha/index.ts
+import { PiggyClient } from "../client";
+import logger from "../logger";
+
+export interface CaptchaState {
+  detected: boolean;
+  paused: boolean;
+  type: string; // "cloudflare" | "recaptcha" | "hcaptcha" | "generic"
+}
+
+export interface BlockState {
+  detected: boolean;
+  type: string; // "403" | "access-denied" | "firewall" | "rate-limit"
+}
+
+export class CaptchaClient {
+  constructor(private client: PiggyClient) {}
+
+  // ── Captcha ───────────────────────────────────────────────────────────────
+
+  status(tabId = "default"): Promise<CaptchaState> {
+    return this.client.send("captcha.status", { tabId });
+  }
+
+  resolve(tabId = "default"): Promise<void> {
+    return this.client.send("captcha.resolve", { tabId });
+  }
+
+  pause(tabId = "default"): Promise<void> {
+    return this.client.send("captcha.pause", { tabId });
+  }
+
+  check(tabId = "default"): Promise<void> {
+    return this.client.send("captcha.check", { tabId });
+  }
+
+  setAutoRetry(enabled: boolean): Promise<void> {
+    return this.client.send("captcha.autoRetry", { enabled });
+  }
+
+  // ── Block ─────────────────────────────────────────────────────────────────
+
+  blockStatus(tabId = "default"): Promise<BlockState> {
+    return this.client.send("block.status", { tabId });
+  }
+
+  blockRetry(tabId = "default"): Promise<void> {
+    return this.client.send("block.retry", { tabId });
+  }
+
+  // ── Event subscriptions ───────────────────────────────────────────────────
+
+  onCaptcha(tabId: string, handler: (data: { captchaType: string; tabId: string }) => void): () => void {
+    return this.client.onEvent("captcha", tabId, handler);
+  }
+
+  onCaptchaResolved(tabId: string, handler: (data: { tabId: string }) => void): () => void {
+    return this.client.onEvent("captcha:resolved", tabId, handler);
+  }
+
+  onBlocked(tabId: string, handler: (data: { blockType: string; tabId: string }) => void): () => void {
+    return this.client.onEvent("blocked", tabId, handler);
+  }
+
+  onBlockRetry(tabId: string, handler: (data: { tabId: string; proxy: string }) => void): () => void {
+    return this.client.onEvent("block:retry", tabId, handler);
+  }
+
+  // ── Convenience: wait until captcha is resolved ───────────────────────────
+
+  waitForResolution(tabId = "default", timeoutMs = 300_000): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        unsub();
+        reject(new Error(`captcha.waitForResolution: timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      const unsub = this.onCaptchaResolved(tabId, () => {
+        clearTimeout(timer);
+        unsub();
+        resolve();
+      });
+
+      logger.warn(`[captcha] waiting for manual resolution on tab ${tabId}…`);
+    });
+  }
+}
+
+// ── Factory helper so site objects can expose a .captcha sub-namespace ────────
+
+export function createCaptchaAPI(client: PiggyClient): CaptchaClient {
+  return new CaptchaClient(client);
+}

package/piggy/capture/index.ts

@@ -0,0 +1,76 @@
+// piggy/capture/index.ts
+import { PiggyClient } from "../client";
+
+export interface CapturedRequest {
+  method: string;
+  url: string;
+  status: string;
+  type: string;
+  mime: string;
+  reqHeaders: string;
+  reqBody: string;
+  resHeaders: string;
+  resBody: string;
+  size: number;
+  timestamp: string;
+}
+
+export interface WebSocketFrame {
+  connectionId: string;
+  url: string;
+  direction: string;
+  data: string;
+  binary: boolean;
+  timestamp: string;
+}
+
+export interface CapturedCookie {
+  name: string;
+  value: string;
+  domain: string;
+  path: string;
+  httpOnly: boolean;
+  secure: boolean;
+  expires: string;
+}
+
+export interface StorageEntry {
+  key: string;
+  value: string;
+}
+
+export class CaptureClient {
+  constructor(private client: PiggyClient) {}
+
+  start(tabId = "default"): Promise<void> {
+    return this.client.send("capture.start", { tabId });
+  }
+
+  stop(tabId = "default"): Promise<void> {
+    return this.client.send("capture.stop", { tabId });
+  }
+
+  requests(tabId = "default"): Promise<CapturedRequest[]> {
+    return this.client.send("capture.requests", { tabId });
+  }
+
+  ws(tabId = "default"): Promise<WebSocketFrame[]> {
+    return this.client.send("capture.ws", { tabId });
+  }
+
+  cookies(tabId = "default"): Promise<CapturedCookie[]> {
+    return this.client.send("capture.cookies", { tabId });
+  }
+
+  storage(tabId = "default"): Promise<StorageEntry[]> {
+    return this.client.send("capture.storage", { tabId });
+  }
+
+  clear(tabId = "default"): Promise<void> {
+    return this.client.send("capture.clear", { tabId });
+  }
+}
+
+export function createCaptureAPI(client: PiggyClient): CaptureClient {
+  return new CaptureClient(client);
+}

package/piggy/dialog/index.d.ts

@@ -0,0 +1,29 @@
+// piggy/dialog/index.d.ts
+import { PiggyClient } from "../client";
+
+export interface DialogState {
+  pending: boolean;
+  type: string;
+  message: string;
+  defaultValue: string;
+}
+
+export declare class DialogClient {
+  constructor(client: PiggyClient);
+
+  accept(tabId?: string, text?: string): Promise<void>;
+  dismiss(tabId?: string): Promise<void>;
+  status(tabId?: string): Promise<DialogState>;
+  setAutoAction(tabId?: string, action: "accept" | "dismiss" | ""): Promise<void>;
+  upload(selector: string, filePath: string, tabId?: string): Promise<void>;
+
+  onDialog(
+    tabId: string,
+    handler: (data: { dialogType: string; message: string; defaultValue: string; tabId: string }) => void
+  ): () => void;
+
+  waitAndAccept(tabId?: string, text?: string, timeoutMs?: number): Promise<DialogState>;
+  waitAndDismiss(tabId?: string, timeoutMs?: number): Promise<DialogState>;
+}
+
+export declare function createDialogAPI(client: PiggyClient): DialogClient;

package/piggy/dialog/index.ts

@@ -0,0 +1,85 @@
+// piggy/dialog/index.ts
+import { PiggyClient } from "../client";
+import logger from "../logger";
+
+export interface DialogState {
+  pending: boolean;
+  type: string;         // "alert" | "confirm" | "prompt" | "beforeunload"
+  message: string;
+  defaultValue: string;
+}
+
+// Event data from C++ (doesn't include pending)
+interface DialogEventData {
+  dialogType: string;
+  message: string;
+  defaultValue: string;
+  tabId: string;
+}
+
+export class DialogClient {
+  constructor(private client: PiggyClient) {}
+
+  accept(tabId = "default", text?: string): Promise<void> {
+    return this.client.send("dialog.accept", { tabId, ...(text !== undefined ? { text } : {}) });
+  }
+
+  dismiss(tabId = "default"): Promise<void> {
+    return this.client.send("dialog.dismiss", { tabId });
+  }
+
+  status(tabId = "default"): Promise<DialogState> {
+    return this.client.send("dialog.status", { tabId });
+  }
+
+  setAutoAction(tabId = "default", action: "accept" | "dismiss" | ""): Promise<void> {
+    return this.client.send("dialog.onDialog", { tabId, action });
+  }
+
+  upload(selector: string, filePath: string, tabId = "default"): Promise<void> {
+    return this.client.send("upload", { selector, path: filePath, tabId });
+  }
+
+  onDialog(
+    tabId: string,
+    handler: (data: DialogEventData) => void
+  ): () => void {
+    return this.client.onEvent("dialog", tabId, handler);
+  }
+
+  waitAndAccept(tabId = "default", text?: string, timeoutMs = 30_000): Promise<DialogEventData> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        unsub();
+        reject(new Error(`dialog.waitAndAccept: timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      const unsub = this.onDialog(tabId, async (data) => {
+        clearTimeout(timer);
+        unsub();
+        await this.accept(tabId, text);
+        resolve(data);
+      });
+    });
+  }
+
+  waitAndDismiss(tabId = "default", timeoutMs = 30_000): Promise<DialogEventData> {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        unsub();
+        reject(new Error(`dialog.waitAndDismiss: timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      const unsub = this.onDialog(tabId, async (data) => {
+        clearTimeout(timer);
+        unsub();
+        await this.dismiss(tabId);
+        resolve(data);
+      });
+    });
+  }
+}
+
+export function createDialogAPI(client: PiggyClient): DialogClient {
+  return new DialogClient(client);
+}

package/piggy/export/index.d.ts

@@ -0,0 +1,117 @@
+// piggy/export/index.d.ts
+import { PiggyClient } from "../client";
+
+export interface CookieSetOptions {
+  name: string;
+  value: string;
+  domain: string;
+  /** @default "/" */
+  path?: string;
+  /** @default false */
+  httpOnly?: boolean;
+  /** @default false */
+  secure?: boolean;
+  /** Unix epoch seconds. Omit for a session cookie. */
+  expiry?: number;
+}
+
+export interface CookieDeleteOptions {
+  name: string;
+  domain: string;
+}
+
+export interface CapturedRequest {
+  method: string;
+  url: string;
+  status: string;
+  type: string;
+  mime: string;
+  reqHeaders: string;
+  reqBody: string;
+  resHeaders: string;
+  resBody: string;
+}
+
+export interface WebSocketFrame {
+  url: string;
+  direction: string;
+  data: string;
+  binary: boolean;
+}
+
+export interface CapturedCookie {
+  name: string;
+  value: string;
+  domain: string;
+}
+
+export interface SessionExport {
+  url: string;
+  requests: CapturedRequest[];
+  ws: WebSocketFrame[];
+  cookies: CapturedCookie[];
+}
+
+export interface SessionPaths {
+  workDir: string;
+  cookies: string;
+  profile: string;
+  ws: string;
+  pings: string;
+}
+
+export interface InterceptRule {
+  pattern: string;
+  block?: boolean;
+  redirect?: string;
+  setHeaders?: Record<string, string>;
+  removeHeaders?: string[];
+}
+
+export interface ExposedFunctionCall {
+  name: string;
+  callId: string;
+  data: string;
+  tabId: string;
+}
+
+export declare class ExportClient {
+  constructor(client: PiggyClient);
+
+  // Cookies
+  setCookie(opts: CookieSetOptions, tabId?: string): Promise<void>;
+  deleteCookie(opts: CookieDeleteOptions, tabId?: string): Promise<void>;
+
+  // Session
+  sessionReload(tabId?: string): Promise<void>;
+  cookiesPath(tabId?: string): Promise<string>;
+  profilePath(tabId?: string): Promise<string>;
+  wsPath(tabId?: string): Promise<string>;
+  pingsPath(tabId?: string): Promise<string>;
+  sessionPaths(tabId?: string): Promise<SessionPaths>;
+  setWsSave(enabled: boolean, tabId?: string): Promise<void>;
+  setPingsSave(enabled: boolean, tabId?: string): Promise<void>;
+
+  // Intercept rules
+  addInterceptRule(rule: InterceptRule, tabId?: string): Promise<void>;
+  clearInterceptRules(tabId?: string): Promise<void>;
+
+  // Session export / import
+  exportSession(tabId?: string): Promise<SessionExport>;
+  importSession(data: SessionExport, tabId?: string): Promise<void>;
+
+  // Exposed functions
+  exposeFunction(name: string, tabId?: string): Promise<void>;
+  resolveExposed(callId: string, result: string, isError?: boolean, tabId?: string): Promise<void>;
+
+  // Init scripts
+  addInitScript(js: string, tabId?: string): Promise<void>;
+
+  // Events
+  onExposedFunctionCalled(
+    tabId: string,
+    handler: (call: ExposedFunctionCall) => void
+  ): () => void;
+}
+
+export declare function createExportAPI(client: PiggyClient): ExportClient;