nothing-browser 0.0.17 → 0.0.18

package/piggy/client/index.ts

@@ -5,78 +5,221 @@ import { dirname } from "path";
 import { platform } from "os";
 import logger from "../logger";
 
-const SOCKET_PATH = platform() === 'win32'
-  ? '\\\\.\\pipe\\piggy'
-  : '/tmp/piggy';
+const DEFAULT_SOCKET_PATH = platform() === "win32"
+  ? "\\\\.\\pipe\\piggy"
+  : "/tmp/piggy";
+
+// ── Transport interface ────────────────────────────────────────────────────────
+
+interface Transport {
+  send(data: string): void;
+  on(event: "data", handler: (chunk: string) => void): void;
+  on(event: "error", handler: (e: Error) => void): void;
+  on(event: "close", handler: () => void): void;
+  destroy(): void;
+}
+
+// ── Socket transport ───────────────────────────────────────────────────────────
+
+class SocketTransport implements Transport {
+  private sock: Socket;
+
+  constructor(sock: Socket) {
+    this.sock = sock;
+  }
+
+  send(data: string) {
+    this.sock.write(data);
+  }
+
+  on(event: string, handler: any) {
+    this.sock.on(event, handler);
+  }
+
+  destroy() {
+    this.sock.destroy();
+  }
+}
+
+// ── HTTP transport ─────────────────────────────────────────────────────────────
+
+class HttpTransport implements Transport {
+  private host: string;
+  private key: string;
+  private dataHandlers: ((chunk: string) => void)[] = [];
+  private errorHandlers: ((e: Error) => void)[] = [];
+  private closeHandlers: (() => void)[] = [];
+  private _destroyed = false;
+
+  constructor(host: string, key: string) {
+    this.host = host.replace(/\/$/, "");
+    this.key = key;
+  }
+
+  on(event: string, handler: any) {
+    if (event === "data")  this.dataHandlers.push(handler);
+    if (event === "error") this.errorHandlers.push(handler);
+    if (event === "close") this.closeHandlers.push(handler);
+  }
+
+  send(data: string) {
+    if (this._destroyed) return;
+
+    fetch(this.host, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Piggy-Key": this.key,
+      },
+      body: data,
+    })
+      .then(async (res) => {
+        if (!res.ok) {
+          const text = await res.text().catch(() => `HTTP ${res.status}`);
+          this.errorHandlers.forEach(h =>
+            h(new Error(`HTTP ${res.status}: ${text}`))
+          );
+          return;
+        }
+        const text = await res.text();
+        const lines = text.split("\n").filter(l => l.trim());
+        for (const line of lines) {
+          this.dataHandlers.forEach(h => h(line + "\n"));
+        }
+      })
+      .catch((e: Error) => {
+        if (!this._destroyed) {
+          this.errorHandlers.forEach(h => h(e));
+        }
+      });
+  }
+
+  destroy() {
+    this._destroyed = true;
+    this.closeHandlers.forEach(h => h());
+  }
+}
+
+// ── PiggyClient ────────────────────────────────────────────────────────────────
 
 export class PiggyClient {
   private socketPath: string;
-  private socket: Socket | null = null;
+  private httpHost: string | null = null;
+  private httpKey: string | null = null;
+  private transport: Transport | null = null;
   private reqId = 0;
   private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
   private buf = "";
-  private eventBuffer = "";
   private eventHandlers = new Map<string, Map<string, (data: any) => Promise<any>>>();
   private globalEventHandlers = new Map<string, Set<(data: any) => void>>();
 
-  constructor(socketPath = SOCKET_PATH) {
-    this.socketPath = socketPath;
+  constructor(socketPath?: string);
+  constructor(opts: { host: string; key: string });
+
+  constructor(arg?: string | { host: string; key: string }) {
+    if (arg && typeof arg === "object") {
+      this.socketPath = "";
+      this.httpHost = arg.host.replace(/\/$/, "");
+      this.httpKey = arg.key;
+    } else {
+      this.socketPath = (arg as string | undefined) ?? DEFAULT_SOCKET_PATH;
+    }
     this.eventHandlers.set("default", new Map());
   }
 
+  // ── Connect ───────────────────────────────────────────────────────────────
+
   connect(): Promise<void> {
+    if (this.httpHost) return this._connectHttp();
+    return this._connectSocket();
+  }
+
+  private _connectSocket(): Promise<void> {
     return new Promise((resolve, reject) => {
       logger.info(`Connecting to socket: ${this.socketPath}`);
       const sock = connect(this.socketPath);
       sock.setEncoding("utf8");
 
       sock.on("connect", () => {
-        this.socket = sock;
-        logger.success("Connected to Piggy server");
+        this.transport = new SocketTransport(sock);
+        this._wireTransport();
+        logger.success("Connected to Piggy server (socket)");
         resolve();
       });
 
-      sock.on("data", (chunk: string) => {
-        this.eventBuffer += chunk;
-        const lines = this.eventBuffer.split("\n");
-        this.eventBuffer = lines.pop()!;
-
-        for (const line of lines) {
-          if (!line.trim()) continue;
-          try {
-            const msg = JSON.parse(line);
-
-            if (msg.type === "event") {
-              this.handleEvent(msg);
-              continue;
-            }
-
-            const p = this.pending.get(msg.id);
-            if (p) {
-              this.pending.delete(msg.id);
-              msg.ok ? p.resolve(msg.data) : p.reject(new Error(msg.data ?? "command failed"));
-            }
-          } catch {
-            logger.error(`Bad JSON from server: ${line}`);
-          }
-        }
-      });
-
       sock.on("error", (e) => {
         for (const p of this.pending.values()) p.reject(e);
         this.pending.clear();
         reject(e);
       });
+    });
+  }
 
-      sock.on("close", () => {
-        for (const p of this.pending.values()) p.reject(new Error("Socket closed"));
-        this.pending.clear();
+  private async _connectHttp(): Promise<void> {
+    logger.info(`Connecting to Piggy server (HTTP): ${this.httpHost}`);
+    try {
+      const res = await fetch(this.httpHost!, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-Piggy-Key": this.httpKey!,
+        },
+        body: "hello",
       });
+      if (res.status === 401) {
+        throw new Error("Unauthorized — invalid X-Piggy-Key");
+      }
+      this.transport = new HttpTransport(this.httpHost!, this.httpKey!);
+      this._wireTransport();
+      logger.success(`Connected to Piggy server (HTTP): ${this.httpHost}`);
+    } catch (e: any) {
+      throw new Error(`Failed to connect to Piggy HTTP server: ${e.message}`);
+    }
+  }
+
+  private _wireTransport() {
+    if (!this.transport) return;
+
+    this.transport.on("data", (chunk: string) => {
+      this.buf += chunk;
+      const lines = this.buf.split("\n");
+      this.buf = lines.pop()!;
+
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const msg = JSON.parse(line);
+
+          if (msg.type === "event") {
+            this.handleEvent(msg);
+            continue;
+          }
+
+          const p = this.pending.get(msg.id);
+          if (p) {
+            this.pending.delete(msg.id);
+            msg.ok ? p.resolve(msg.data) : p.reject(new Error(msg.data ?? "command failed"));
+          }
+        } catch {
+          logger.error(`Bad JSON from server: ${line}`);
+        }
+      }
+    });
+
+    this.transport.on("error", (e: Error) => {
+      for (const p of this.pending.values()) p.reject(e);
+      this.pending.clear();
+    });
+
+    this.transport.on("close", () => {
+      for (const p of this.pending.values()) p.reject(new Error("Connection closed"));
+      this.pending.clear();
     });
   }
 
+  // ── Event handling ────────────────────────────────────────────────────────
+
   private handleEvent(event: any) {
-    // ── exposed_call ──────────────────────────────────────────────────────────
     if (event.event === "exposed_call") {
       const { tabId, name, callId, data } = event;
       const effectiveTabId = tabId || "default";
@@ -84,12 +227,11 @@ export class PiggyClient {
       const handler = handlers?.get(name);
 
       if (handler) {
-        // ✅ FIX: data can be a plain string (e.g., "OPENING") or JSON
-        let parsedData;
+        let parsedData: any;
         try {
           parsedData = JSON.parse(data || "null");
         } catch {
-          parsedData = data; // fallback to raw string
+          parsedData = data;
         }
 
         Promise.resolve(handler(parsedData))
@@ -99,14 +241,14 @@ export class PiggyClient {
                 tabId: effectiveTabId,
                 callId,
                 result: response.success ? JSON.stringify(response.result) : (response.error || "Unknown error"),
-                isError: !response.success
+                isError: !response.success,
               }).catch(e => logger.error(`Failed to send exposed result: ${e}`));
             } else {
               this.send("exposed.result", {
                 tabId: effectiveTabId,
                 callId,
                 result: JSON.stringify(response),
-                isError: false
+                isError: false,
               }).catch(e => logger.error(`Failed to send exposed result: ${e}`));
             }
           })
@@ -115,7 +257,7 @@ export class PiggyClient {
               tabId: effectiveTabId,
               callId,
               result: err.message || "Handler error",
-              isError: true
+              isError: true,
             }).catch(e => logger.error(`Failed to send exposed error: ${e}`));
           });
       } else {
@@ -124,7 +266,6 @@ export class PiggyClient {
       return;
     }
 
-    // ── navigate ──────────────────────────────────────────────────────────────
     if (event.event === "navigate") {
       const handlers = this.globalEventHandlers.get(`navigate:${event.tabId}`);
       if (handlers) {
@@ -132,39 +273,37 @@ export class PiggyClient {
           try { h(event.url); } catch (e) { logger.error(`navigate handler error: ${e}`); }
         }
       }
-      // Also fire wildcard listeners (no tabId filter)
       const wildcard = this.globalEventHandlers.get("navigate:*");
       if (wildcard) {
         for (const h of wildcard) {
           try { h({ url: event.url, tabId: event.tabId }); } catch {}
         }
       }
-      return;
     }
   }
 
-  // ── Global event subscription ─────────────────────────────────────────────
   onEvent(eventName: string, tabId: string, handler: (data: any) => void): () => void {
     const key = `${eventName}:${tabId}`;
     if (!this.globalEventHandlers.has(key)) {
       this.globalEventHandlers.set(key, new Set());
     }
     this.globalEventHandlers.get(key)!.add(handler);
-    // Return unsubscribe fn
     return () => this.globalEventHandlers.get(key)?.delete(handler);
   }
 
   disconnect() {
-    this.socket?.destroy();
-    this.socket = null;
+    this.transport?.destroy();
+    this.transport = null;
   }
 
+  // ── Core send ─────────────────────────────────────────────────────────────
+
   send<T = any>(cmd: string, payload: Record<string, any> = {}): Promise<T> {
     return new Promise((resolve, reject) => {
-      if (!this.socket) return reject(new Error("Not connected"));
+      if (!this.transport) return reject(new Error("Not connected"));
       const id = String(++this.reqId);
       this.pending.set(id, { resolve, reject });
-      this.socket.write(JSON.stringify({ id, cmd, payload }) + "\n");
+      this.transport.send(JSON.stringify({ id, cmd, payload }) + "\n");
     });
   }
 
@@ -268,6 +407,56 @@ export class PiggyClient {
   async sessionExport(tabId = "default"): Promise<any> { return this.send("session.export", { tabId }); }
   async sessionImport(data: any, tabId = "default"): Promise<void> { await this.send("session.import", { data, tabId }); }
 
+  // ── Session persistence (opt-in) ──────────────────────────────────────────
+  // WS frames and pings are NOT saved by default — you must opt in.
+  // Files are written to cwd (same folder as cookies.json / profile.json).
+
+  /** Enable or disable saving WebSocket frames to ws.json in cwd */
+  async sessionWsSave(enabled = true): Promise<void> {
+    await this.send("session.ws.save", { enabled });
+  }
+
+  /** Enable or disable saving ping log to pings.json in cwd */
+  async sessionPingsSave(enabled = true): Promise<void> {
+    await this.send("session.pings.save", { enabled });
+  }
+
+  /** Get all data file paths for the current session */
+  async sessionPaths(): Promise<{
+    workDir: string;
+    cookies: string;
+    profile: string;
+    ws: string;
+    pings: string;
+  }> {
+    return this.send("session.paths", {});
+  }
+
+  /** Get path to cookies.json */
+  async sessionCookiesPath(): Promise<string> {
+    return this.send("session.cookies.path", {});
+  }
+
+  /** Get path to profile.json */
+  async sessionProfilePath(): Promise<string> {
+    return this.send("session.profile.path", {});
+  }
+
+  /** Get path to ws.json */
+  async sessionWsPath(): Promise<string> {
+    return this.send("session.ws.path", {});
+  }
+
+  /** Get path to pings.json */
+  async sessionPingsPath(): Promise<string> {
+    return this.send("session.pings.path", {});
+  }
+
+  /** Reload cookies.json and profile.json from disk without restarting */
+  async sessionReload(): Promise<void> {
+    await this.send("session.reload", {});
+  }
+
   // ── Expose Function ───────────────────────────────────────────────────────
   async exposeFunction(name: string, handler: (data: any) => Promise<any> | any, tabId = "default"): Promise<void> {
     if (!this.eventHandlers.has(tabId)) this.eventHandlers.set(tabId, new Map());
@@ -294,4 +483,86 @@ export class PiggyClient {
     this.eventHandlers.set(tabId, new Map());
     logger.info(`[${tabId}] cleared all exposed functions`);
   }
+
+  // ── Proxy ─────────────────────────────────────────────────────────────────
+
+  async proxyLoad(path: string): Promise<void> {
+    await this.send("proxy.load", { path });
+  }
+
+  async proxyFetch(url: string): Promise<void> {
+    await this.send("proxy.fetch", { url });
+  }
+
+  async proxyOvpn(path: string): Promise<void> {
+    await this.send("proxy.ovpn", { path });
+  }
+
+  async proxySet(opts: {
+    host?: string;
+    port?: number;
+    type?: "http" | "https" | "socks5" | "socks4";
+    user?: string;
+    pass?: string;
+    proxy?: string;
+  }): Promise<void> {
+    await this.send("proxy.set", opts as Record<string, any>);
+  }
+
+  async proxyTest(): Promise<void> {
+    await this.send("proxy.test", {});
+  }
+
+  async proxyTestStop(): Promise<void> {
+    await this.send("proxy.test.stop", {});
+  }
+
+  async proxyNext(): Promise<void> {
+    await this.send("proxy.next", {});
+  }
+
+  async proxyDisable(): Promise<void> {
+    await this.send("proxy.disable", {});
+  }
+
+  async proxyEnable(): Promise<void> {
+    await this.send("proxy.enable", {});
+  }
+
+  async proxyCurrent(): Promise<{
+    host: string; port: number; type: string;
+    user?: string; alive: boolean; latencyMs?: number;
+  }> {
+    return this.send("proxy.current", {});
+  }
+
+  async proxyStats(): Promise<{
+    total: number; alive: number; dead: number;
+    index: number; checking: boolean;
+  }> {
+    return this.send("proxy.stats", {});
+  }
+
+  async proxyList(limit?: number): Promise<{
+    host: string; port: number; type: string;
+    alive: boolean; latencyMs?: number;
+  }[]> {
+    return this.send("proxy.list", limit !== undefined ? { limit } : {});
+  }
+
+  async proxyRotation(mode: "none" | "timed" | "perrequest", interval?: number): Promise<void> {
+    await this.send("proxy.rotation", { mode, ...(interval !== undefined ? { interval } : {}) });
+  }
+
+  async proxyConfig(opts: { skipDead?: boolean; autoCheck?: boolean }): Promise<void> {
+    await this.send("proxy.config", opts as Record<string, any>);
+  }
+
+  async proxySave(path: string, filter: "alive" | "dead" | "all" = "all"): Promise<void> {
+    await this.send("proxy.save", { path, filter });
+  }
+
+  onProxyEvent(event: string, handler: (data: any) => void): () => void {
+    return this.onEvent(event, "*", handler);
+  }
 }

package/piggy.ts

@@ -15,8 +15,7 @@ const _extraProcs: { socket: string; client: PiggyClient }[] = [];
 const _sites: Record<string, SiteObject> = [];
 
 const piggy: any = {
-  // ── Lifecycle ─────────────────────────────────────────────────────────────
-
+  // ── Local launch (socket) ─────────────────────────────────────────────────
   launch: async (opts?: { mode?: TabMode; binary?: BinaryMode }) => {
     _tabMode = opts?.mode ?? "tab";
     const binaryMode: BinaryMode = opts?.binary ?? "headless";
@@ -29,12 +28,23 @@ const piggy: any = {
     return piggy;
   },
 
+  // ── 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;          // number of tabs to pool — enables concurrent requests
+      pool?: number;
     }
   ) => {
     if (!url?.trim()) throw new Error(`No URL for site "${name}"`);
@@ -42,21 +52,16 @@ const piggy: any = {
     const poolSize = opts?.pool ?? 0;
 
     if (_tabMode === "tab") {
-      if (!_client) throw new Error("No client. Call piggy.launch() first.");
+      if (!_client) throw new Error("No client. Call piggy.launch() or piggy.connect() first.");
 
       if (poolSize > 1) {
-        // Pool mode — create N tabs, wrap in TabPool
         const pool = new TabPool(_client, poolSize, url, name);
         await pool.init();
-
-        // Use first tab as the "default" tabId for event subscriptions
-        const firstTabId = "default";
-        const siteObj = createSiteObject(name, url, _client, firstTabId, pool);
+        const siteObj = createSiteObject(name, url, _client, "default", pool);
         _sites[name] = siteObj;
         piggy[name] = siteObj;
         logger.success(`[${name}] registered with pool of ${poolSize} tabs`);
       } else {
-        // Single tab mode
         const tabId = await _client.newTab();
         const siteObj = createSiteObject(name, url, _client, tabId);
         _sites[name] = siteObj;
@@ -80,7 +85,6 @@ const piggy: any = {
   },
 
   // ── Global controls ───────────────────────────────────────────────────────
-
   actHuman: (enable: boolean) => {
     setHumanMode(enable);
     logger.info(`[piggy] actHuman: ${enable}`);
@@ -90,23 +94,41 @@ const piggy: any = {
   mode: (m: TabMode) => { _tabMode = m; return piggy; },
 
   // ── Expose Function ───────────────────────────────────────────────────────
-
   expose: async (name: string, handler: (data: any) => Promise<any> | any, tabId = "default") => {
-    if (!_client) throw new Error("No client. Call piggy.launch() first.");
+    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") => {
-    if (!_client) throw new Error("No client. Call piggy.launch() first.");
+    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;
   },
 
-  // ── Elysia server ─────────────────────────────────────────────────────────
+  // ── 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?: {
@@ -121,7 +143,6 @@ const piggy: any = {
   stopServer,
 
   // ── Route listing ─────────────────────────────────────────────────────────
-
   routes: () =>
     Array.from(routeRegistry.entries()).map(([key, cfg]) => {
       const [site] = key.split(":");
@@ -135,7 +156,6 @@ const piggy: any = {
     }),
 
   // ── Multi-site ────────────────────────────────────────────────────────────
-
   all: (sites: SiteObject[]) =>
     new Proxy({} as any, {
       get: (_, method: string) =>
@@ -152,7 +172,6 @@ const piggy: any = {
     }),
 
   // ── Shutdown ──────────────────────────────────────────────────────────────
-
   close: async (opts?: { force?: boolean }) => {
     stopServer();
     if (opts?.force) {