nothing-browser 0.0.16 → 0.0.18

package/piggy.ts

@@ -2,287 +2,25 @@
 import { detectBinary, type BinaryMode } from "./piggy/launch/detect";
 import { spawnBrowser, killBrowser, spawnBrowserOnSocket } from "./piggy/launch/spawn";
 import { PiggyClient } from "./piggy/client";
-import { setClient, setHumanMode, createSiteObject } from "./piggy/register";
+import { setClient, setHumanMode, createSiteObject, type SiteObject } from "./piggy/register";
 import { routeRegistry, keepAliveSites, startServer, stopServer } from "./piggy/server";
+import { TabPool } from "./piggy/pool";
 import logger from "./piggy/logger";
-import type { Logger } from "ernest-logger";
-import type { Elysia } from "elysia";
-import type { RouteHandler, BeforeMiddleware, RouteConfig } from "./piggy/server";
 
-// ── Core types ───────────────────────────────────────────────────────────────
-
-export type TabMode = "tab" | "process";
-
-/** Full API surface of a registered site. */
-export interface SiteObject {
-  readonly _name: string;
-  readonly _tabId: string;
-
-  // ── Navigation ─────────────────────────────────────────────────────────────
-  navigate(url?: string, opts?: { retries?: number }): Promise<void>;
-  reload(): Promise<void>;
-  goBack(): Promise<void>;
-  goForward(): Promise<void>;
-  waitForNavigation(): Promise<void>;
-  title(): Promise<string>;
-  /** Returns the last known URL (synchronous — does NOT hit the browser). */
-  url(): string;
-  content(): Promise<string>;
-
-  // ── Timing ────────────────────────────────────────────────────────────────
-  wait(ms: number): Promise<void>;
-  waitForSelector(selector: string, timeout?: number): Promise<void>;
-  waitForVisible(selector: string, timeout?: number): Promise<void>;
-  waitForResponse(pattern: string, timeout?: number): Promise<void>;
-
-  // ── Init script ───────────────────────────────────────────────────────────
-  addInitScript(js: string | (() => void)): Promise<SiteObject>;
-
-  // ── Event emitter ─────────────────────────────────────────────────────────
-  on(event: "navigate", handler: (url: string) => void): () => void;
-  on(event: string, handler: (data: unknown) => void): () => void;
-  off(event: string, handler: (data: unknown) => void): void;
-
-  // ── Interactions ──────────────────────────────────────────────────────────
-  click(selector: string, opts?: { retries?: number; timeout?: number }): Promise<boolean>;
-  doubleClick(selector: string): Promise<boolean>;
-  hover(selector: string): Promise<boolean>;
-  type(
-    selector: string,
-    text: string,
-    opts?: { delay?: number; retries?: number; fact?: boolean; wpm?: number }
-  ): Promise<boolean>;
-  select(selector: string, value: string): Promise<boolean>;
-  evaluate<T = unknown>(js: string | ((...args: unknown[]) => T), ...args: unknown[]): Promise<T>;
-
-  keyboard: {
-    press(key: string): Promise<boolean>;
-    combo(combo: string): Promise<boolean>;
-  };
-  mouse: {
-    move(x: number, y: number): Promise<boolean>;
-    drag(from: { x: number; y: number }, to: { x: number; y: number }): Promise<boolean>;
-  };
-  scroll: {
-    to(selector: string): Promise<boolean>;
-    by(px: number): Promise<boolean>;
-  };
-
-  // ── Fetch ─────────────────────────────────────────────────────────────────
-  fetchText(selector: string): Promise<string | null>;
-  fetchLinks(selector: string): Promise<string[]>;
-  fetchImages(selector: string): Promise<string[]>;
-  search: {
-    css(query: string): Promise<unknown>;
-    id(query: string): Promise<unknown>;
-  };
-
-  // ── Screenshot / PDF ──────────────────────────────────────────────────────
-  screenshot(filePath?: string): Promise<string>;
-  pdf(filePath?: string): Promise<string>;
-  blockImages(): Promise<void>;
-  unblockImages(): Promise<void>;
-
-  // ── Cookies ───────────────────────────────────────────────────────────────
-  cookies: {
-    set(name: string, value: string, domain: string, path?: string): Promise<void>;
-    get(name: string): Promise<unknown>;
-    delete(name: string): Promise<void>;
-    list(): Promise<unknown[]>;
-  };
-
-  // ── Interception ──────────────────────────────────────────────────────────
-  intercept: {
-    block(pattern: string): Promise<void>;
-    redirect(pattern: string, redirectUrl: string): Promise<void>;
-    headers(pattern: string, headers: Record<string, string>): Promise<void>;
-    respond(
-      pattern: string,
-      handlerOrResponse:
-        | { status?: number; contentType?: string; body: string }
-        | ((req: { url: string; method: string }) => {
-            status?: number;
-            contentType?: string;
-            body: string;
-          })
-    ): Promise<SiteObject>;
-    modifyResponse(
-      pattern: string,
-      handler: (response: {
-        body: string;
-        status: number;
-        headers: Record<string, string>;
-      }) => Promise<{ body?: string; status?: number; headers?: Record<string, string> } | void> | void
-    ): Promise<SiteObject>;
-    clear(): Promise<void>;
-  };
-
-  // ── Network capture ───────────────────────────────────────────────────────
-  capture: {
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    requests(): Promise<unknown[]>;
-    ws(): Promise<unknown[]>;
-    cookies(): Promise<unknown[]>;
-    storage(): Promise<unknown>;
-    clear(): Promise<void>;
-  };
-
-  // ── Session ───────────────────────────────────────────────────────────────
-  session: {
-    export(): Promise<unknown>;
-    import(data: unknown): Promise<void>;
-  };
-
-  // ── Expose / unexpose ─────────────────────────────────────────────────────
-  exposeFunction(
-    fnName: string,
-    handler: (data: unknown) => Promise<unknown> | unknown
-  ): Promise<SiteObject>;
-  unexposeFunction(fnName: string): Promise<SiteObject>;
-  clearExposedFunctions(): Promise<SiteObject>;
-  exposeAndInject(
-    fnName: string,
-    handler: (data: unknown) => Promise<unknown> | unknown,
-    injectionJs: string | ((fnName: string) => string)
-  ): Promise<SiteObject>;
-
-  // ── Elysia route registration ─────────────────────────────────────────────
-  api(
-    path: string,
-    handler: RouteHandler,
-    opts?: {
-      ttl?: number;
-      before?: BeforeMiddleware[];
-      method?: "GET" | "POST" | "PUT" | "DELETE";
-    }
-  ): SiteObject;
-
-  noclose(): SiteObject;
-  close(): Promise<void>;
-}
-
-// ── Route summary ─────────────────────────────────────────────────────────────
-
-export interface RouteSummary {
-  site: string;
-  method: RouteConfig["method"];
-  path: string;
-  ttl: number;
-  middlewareCount: number;
-}
-
-// ── Multi-site proxy helpers ──────────────────────────────────────────────────
-
-export type AllProxy = {
-  [K in keyof SiteObject]: SiteObject[K] extends (...args: infer A) => Promise<infer R>
-    ? (...args: A) => Promise<R[]>
-    : SiteObject[K] extends (...args: infer A) => infer R
-      ? (...args: A) => Promise<R[]>
-      : never;
-};
-
-export type DiffProxy = {
-  [K in keyof SiteObject]: SiteObject[K] extends (...args: infer A) => Promise<infer R>
-    ? (...args: A) => Promise<Record<string, R>>
-    : SiteObject[K] extends (...args: infer A) => infer R
-      ? (...args: A) => Promise<Record<string, R>>
-      : never;
-};
-
-// ── Option bags ───────────────────────────────────────────────────────────────
-
-export interface LaunchOptions {
-  mode?: TabMode;
-  binary?: BinaryMode;
-}
-
-export interface RegisterOptions {
-  binary?: BinaryMode;
-}
-
-export interface ServeOptions {
-  hostname?: string;
-}
-
-// ── PiggyBase — named methods, no index signature ─────────────────────────────
-
-export interface PiggyBase {
-  launch(opts?: LaunchOptions): Promise<PiggyBase>;
-  register(name: string, url: string, opts?: RegisterOptions): Promise<PiggyBase>;
-  actHuman(enable: boolean): PiggyBase;
-  mode(m: TabMode): PiggyBase;
-  expose(
-    name: string,
-    handler: (data: unknown) => Promise<unknown> | unknown,
-    tabId?: string
-  ): Promise<PiggyBase>;
-  unexpose(name: string, tabId?: string): Promise<PiggyBase>;
-  serve(port: number, opts?: ServeOptions): Promise<Elysia>;
-  stopServer(): void;
-  routes(): RouteSummary[];
-  all(sites: SiteObject[]): AllProxy;
-  diff(sites: SiteObject[]): DiffProxy;
-  close(opts?: { force?: boolean }): Promise<void>;
-  detect(mode?: BinaryMode): string | null;
-  logger: Logger;
-}
-
-// ── PiggyWithSites<S> — PiggyBase + typed site keys ──────────────────────────
-
-export type PiggyWithSites<S extends string> = PiggyBase & {
-  [K in S]: SiteObject;
-};
-
-// ── usePiggy — takes the piggy import, returns it typed ──────────────────────
-//
-// The variable is ALWAYS called `piggy`. No rename. No new variable.
-// Just pass the import in, get it back fully typed.
-//
-//   import piggy, { usePiggy } from 'nothing-browser';
-//   usePiggy<"amazon" | "walmart" | "ebay">(piggy);
-//
-//   await piggy.launch({ mode: "tab" });
-//   await piggy.register("amazon",  "https://www.amazon.com/");
-//   await piggy.register("walmart", "https://www.walmart.com/");
-//   await piggy.register("ebay",    "https://www.ebay.com/");
-//
-//   await piggy.amazon.navigate();    // ✅ full autocomplete
-//   await piggy.walmart.click("..."); // ✅
-//   await piggy.ebay.screenshot();    // ✅
-//
-// How it works: TypeScript narrows the type of `piggy` at the call site
-// via the returned typed reference. Assign back to `piggy` with `let`:
-//
-//   import piggyRaw, { usePiggy } from 'nothing-browser';
-//   const piggy = usePiggy<"amazon" | "walmart" | "ebay">(piggyRaw);
-//
-// OR use the reassignment pattern with `let` for maximum cleanliness:
-//
-//   import { piggy as _piggy, usePiggy } from 'nothing-browser';
-//   const piggy = usePiggy<"amazon" | "walmart" | "ebay">(_piggy);
-//
-// Either way: `piggy` is the word in your code, always.
-
-export function usePiggy<S extends string>(): PiggyWithSites<S> {
-  return piggy as unknown as PiggyWithSites<S>;
-}
-
-// ── Module-private state ──────────────────────────────────────────────────────
+type TabMode = "tab" | "process";
 
 let _client: PiggyClient | null = null;
 let _tabMode: TabMode = "tab";
 const _extraProcs: { socket: string; client: PiggyClient }[] = [];
-const _sites: Record<string, SiteObject> = {};
+const _sites: Record<string, SiteObject> = [];
 
-// ── The piggy singleton ───────────────────────────────────────────────────────
-
-const piggy: PiggyBase = {
-  launch: async (opts?: LaunchOptions): Promise<PiggyBase> => {
+const piggy: any = {
+  // ── Local launch (socket) ─────────────────────────────────────────────────
+  launch: async (opts?: { mode?: TabMode; binary?: BinaryMode }) => {
     _tabMode = opts?.mode ?? "tab";
     const binaryMode: BinaryMode = opts?.binary ?? "headless";
     await spawnBrowser(binaryMode);
-    await new Promise<void>((r) => setTimeout(r, 500));
+    await new Promise(r => setTimeout(r, 500));
     _client = new PiggyClient();
     await _client.connect();
     setClient(_client);
@@ -290,72 +28,126 @@ const piggy: PiggyBase = {
     return piggy;
   },
 
-  register: async (name: string, url: string, opts?: RegisterOptions): Promise<PiggyBase> => {
+  // ── Remote connect (HTTP) ─────────────────────────────────────────────────
+  connect: async (opts: { host: string; key: string }) => {
+    _tabMode = "tab";
+    _client = new PiggyClient({ host: opts.host, key: opts.key });
+    await _client.connect();
+    setClient(_client);
+    logger.info(`[piggy] connected (HTTP) → ${opts.host}`);
+    return piggy;
+  },
+
+  // ── Register ──────────────────────────────────────────────────────────────
+  register: async (
+    name: string,
+    url: string,
+    opts?: {
+      binary?: BinaryMode;
+      pool?: number;
+    }
+  ) => {
     if (!url?.trim()) throw new Error(`No URL for site "${name}"`);
     const binaryMode: BinaryMode = opts?.binary ?? "headless";
-
-    let siteObj: SiteObject;
+    const poolSize = opts?.pool ?? 0;
 
     if (_tabMode === "tab") {
-      if (!_client) throw new Error("No client. Call piggy.launch() first.");
-      const tabId = await _client.newTab();
-      siteObj = createSiteObject(name, url, _client, tabId) as SiteObject;
-      logger.success(`[${name}] registered as tab ${tabId}`);
+      if (!_client) throw new Error("No client. Call piggy.launch() or piggy.connect() first.");
+
+      if (poolSize > 1) {
+        const pool = new TabPool(_client, poolSize, url, name);
+        await pool.init();
+        const siteObj = createSiteObject(name, url, _client, "default", pool);
+        _sites[name] = siteObj;
+        piggy[name] = siteObj;
+        logger.success(`[${name}] registered with pool of ${poolSize} tabs`);
+      } else {
+        const tabId = await _client.newTab();
+        const siteObj = createSiteObject(name, url, _client, tabId);
+        _sites[name] = siteObj;
+        piggy[name] = siteObj;
+        logger.success(`[${name}] registered as tab ${tabId}`);
+      }
     } else {
       const socketName = `piggy_${name}`;
       await spawnBrowserOnSocket(socketName, binaryMode);
-      await new Promise<void>((r) => setTimeout(r, 500));
+      await new Promise(r => setTimeout(r, 500));
       const c = new PiggyClient(socketName);
       await c.connect();
       _extraProcs.push({ socket: socketName, client: c });
-      siteObj = createSiteObject(name, url, c, "default") as SiteObject;
+      const siteObj = createSiteObject(name, url, c, "default");
+      _sites[name] = siteObj;
+      piggy[name] = siteObj;
       logger.success(`[${name}] registered as process on "${socketName}"`);
     }
 
-    _sites[name] = siteObj;
-    (piggy as unknown as Record<string, unknown>)[name] = siteObj;
     return piggy;
   },
 
-  actHuman: (enable: boolean): PiggyBase => {
+  // ── Global controls ───────────────────────────────────────────────────────
+  actHuman: (enable: boolean) => {
     setHumanMode(enable);
     logger.info(`[piggy] actHuman: ${enable}`);
     return piggy;
   },
 
-  mode: (m: TabMode): PiggyBase => {
-    _tabMode = m;
-    return piggy;
-  },
+  mode: (m: TabMode) => { _tabMode = m; return piggy; },
 
-  expose: async (
-    name: string,
-    handler: (data: unknown) => Promise<unknown> | unknown,
-    tabId = "default"
-  ): Promise<PiggyBase> => {
-    if (!_client) throw new Error("No client. Call piggy.launch() first.");
+  // ── Expose Function ───────────────────────────────────────────────────────
+  expose: async (name: string, handler: (data: any) => Promise<any> | any, tabId = "default") => {
+    if (!_client) throw new Error("No client. Call piggy.launch() or piggy.connect() first.");
     await _client.exposeFunction(name, handler, tabId);
     logger.success(`[piggy] exposed global function: ${name}`);
     return piggy;
   },
 
-  unexpose: async (name: string, tabId = "default"): Promise<PiggyBase> => {
-    if (!_client) throw new Error("No client. Call piggy.launch() first.");
+  unexpose: async (name: string, tabId = "default") => {
+    if (!_client) throw new Error("No client. Call piggy.launch() or piggy.connect() first.");
     await _client.unexposeFunction(name, tabId);
     logger.info(`[piggy] unexposed function: ${name}`);
     return piggy;
   },
 
-  serve: (port: number, opts?: ServeOptions): Promise<Elysia> =>
-    startServer(port, opts?.hostname),
+  // ── Proxy ─────────────────────────────────────────────────────────────────
+  proxy: {
+    load:     (path: string)                                               => { if (!_client) throw new Error("No client"); return _client.proxyLoad(path); },
+    fetch:    (url: string)                                                => { if (!_client) throw new Error("No client"); return _client.proxyFetch(url); },
+    ovpn:     (path: string)                                               => { if (!_client) throw new Error("No client"); return _client.proxyOvpn(path); },
+    set:      (opts: Parameters<PiggyClient["proxySet"]>[0])               => { if (!_client) throw new Error("No client"); return _client.proxySet(opts); },
+    test:     ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyTest(); },
+    testStop: ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyTestStop(); },
+    next:     ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyNext(); },
+    disable:  ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyDisable(); },
+    enable:   ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyEnable(); },
+    current:  ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyCurrent(); },
+    stats:    ()                                                           => { if (!_client) throw new Error("No client"); return _client.proxyStats(); },
+    list:     (limit?: number)                                             => { if (!_client) throw new Error("No client"); return _client.proxyList(limit); },
+    rotation: (mode: "none" | "timed" | "perrequest", interval?: number)  => { if (!_client) throw new Error("No client"); return _client.proxyRotation(mode, interval); },
+    config:   (opts: { skipDead?: boolean; autoCheck?: boolean })          => { if (!_client) throw new Error("No client"); return _client.proxyConfig(opts); },
+    save:     (path: string, filter?: "alive" | "dead" | "all")           => { if (!_client) throw new Error("No client"); return _client.proxySave(path, filter); },
+    on:       (event: string, handler: (data: any) => void)               => { if (!_client) throw new Error("No client"); return _client.onProxyEvent(event, handler); },
+  },
+
+  // ── Elysia server ─────────────────────────────────────────────────────────
+  serve: (
+    port: number,
+    opts?: {
+      hostname?: string;
+      title?: string;
+      version?: string;
+      description?: string;
+      path?: string;
+    }
+  ) => startServer(port, opts?.hostname, opts),
 
   stopServer,
 
-  routes: (): RouteSummary[] =>
-    Array.from(routeRegistry.entries()).map(([key, cfg]): RouteSummary => {
+  // ── Route listing ─────────────────────────────────────────────────────────
+  routes: () =>
+    Array.from(routeRegistry.entries()).map(([key, cfg]) => {
       const [site] = key.split(":");
       return {
-        site: site ?? key,
+        site,
         method: cfg.method,
         path: `/${site}${cfg.path}`,
         ttl: cfg.ttl,
@@ -363,31 +155,24 @@ const piggy: PiggyBase = {
       };
     }),
 
-  all: (sites: SiteObject[]): AllProxy =>
-    new Proxy({} as AllProxy, {
-      get: (_target, method: string) =>
-        (...args: unknown[]) =>
-          Promise.all(
-            sites.map((s) =>
-              (s as unknown as Record<string, (...a: unknown[]) => unknown>)[method]?.(...args)
-            )
-          ),
+  // ── Multi-site ────────────────────────────────────────────────────────────
+  all: (sites: SiteObject[]) =>
+    new Proxy({} as any, {
+      get: (_, method: string) =>
+        (...args: any[]) => Promise.all(sites.map((s: any) => s[method]?.(...args))),
     }),
 
-  diff: (sites: SiteObject[]): DiffProxy =>
-    new Proxy({} as DiffProxy, {
-      get: (_target, method: string) =>
-        async (...args: unknown[]) => {
-          const results = await Promise.all(
-            sites.map((s) =>
-              (s as unknown as Record<string, (...a: unknown[]) => unknown>)[method]?.(...args)
-            )
-          );
-          return Object.fromEntries(sites.map((s, i) => [s._name ?? i, results[i]]));
+  diff: (sites: SiteObject[]) =>
+    new Proxy({} as any, {
+      get: (_, method: string) =>
+        async (...args: any[]) => {
+          const results = await Promise.all(sites.map((s: any) => s[method]?.(...args)));
+          return Object.fromEntries(sites.map((s: any, i) => [s._name ?? i, results[i]]));
         },
     }),
 
-  close: async (opts?: { force?: boolean }): Promise<void> => {
+  // ── Shutdown ──────────────────────────────────────────────────────────────
+  close: async (opts?: { force?: boolean }) => {
     stopServer();
     if (opts?.force) {
       for (const { client: c } of _extraProcs) c.disconnect();
@@ -397,7 +182,7 @@ const piggy: PiggyBase = {
       keepAliveSites.clear();
     } else {
       for (const [name, site] of Object.entries(_sites)) {
-        if (!keepAliveSites.has(name)) await site.close?.();
+        if (!keepAliveSites.has(name)) await (site as any).close?.();
       }
       if (keepAliveSites.size === 0) {
         for (const { client: c } of _extraProcs) c.disconnect();
@@ -415,5 +200,18 @@ const piggy: PiggyBase = {
   logger,
 };
 
+// ── usePiggy ──────────────────────────────────────────────────────────────────
+// Typed accessor — call AFTER register() so sites exist on piggy.
+// const { amazon, ebay } = usePiggy<"amazon" | "ebay">()
+
+type TypedPiggy<Sites extends string> = typeof piggy & {
+  [K in Sites]: SiteObject;
+};
+
+export function usePiggy<Sites extends string>(): TypedPiggy<Sites> {
+  return piggy as TypedPiggy<Sites>;
+}
+
+export type { SiteObject };
 export default piggy;
 export { piggy };