nothing-browser 0.1.2 → 0.1.4

package/piggy/launch/{detect.ts → detect.js}

@@ -1,15 +1,14 @@
+
 import { existsSync } from 'fs';
 import { join } from 'path';
-import logger from '../logger';
-
-export type BinaryMode = 'headless' | 'headful' | (string & {});
+import logger from '../logger.js';
 
-const BINARY_NAMES: Record<string, string> = {
+const BINARY_NAMES = {
   headless: 'nothing-browser-headless',
   headful:  'nothing-browser-headful',
 };
 
-export function detectBinary(mode: BinaryMode = 'headless'): string | null {
+export function detectBinary(mode = 'headless') {
   const cwd = process.cwd();
 
   // Custom path passed directly
@@ -18,7 +17,6 @@ export function detectBinary(mode: BinaryMode = 'headless'): string | null {
       logger.success(`Binary found (custom path): ${mode}`);
       return mode;
     }
-    // try relative to cwd
     const abs = join(cwd, mode);
     if (existsSync(abs)) {
       logger.success(`Binary found (custom path): ${abs}`);

package/piggy/launch/{spawn.ts → spawn.js}

@@ -1,15 +1,15 @@
 import { spawn as nodeSpawn } from "child_process";
 import { execSync } from "child_process";
 import { platform } from "os";
-import { detectBinary, type BinaryMode } from "./detect";
-import logger from "../logger";
+import { detectBinary } from "./detect.js";
+import logger from "../logger.js";
 
-let activeProcess: any = null;
-const extraProcesses: any[] = [];
+let activeProcess = null;
+const extraProcesses = [];
 
-const isBun = typeof (globalThis as any).Bun !== 'undefined';
+const isBun = typeof globalThis.Bun !== 'undefined';
 
-export function killAllBrowsers(): void {
+export function killAllBrowsers() {
   try {
     logger.info('Cleaning up existing browser processes...');
     if (platform() === 'win32') {
@@ -27,7 +27,7 @@ export function killAllBrowsers(): void {
   }
 }
 
-export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<string> {
+export async function spawnBrowser(mode = 'headless') {
   killAllBrowsers();
   await new Promise(resolve => setTimeout(resolve, 500));
 
@@ -39,8 +39,7 @@ export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<strin
   logger.info(`Spawning Nothing Browser (${mode}) from: ${binaryPath}`);
 
   if (isBun) {
-    const Bun = (globalThis as any).Bun;
-    activeProcess = Bun.spawn([binaryPath], {
+    activeProcess = globalThis.Bun.spawn([binaryPath], {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: process.env,
     });
@@ -57,7 +56,7 @@ export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<strin
       read();
     }
 
-    activeProcess.exited.then((code: number | null) => {
+    activeProcess.exited.then((code) => {
       logger.warn(`Browser process exited with code: ${code}`);
       activeProcess = null;
     });
@@ -68,18 +67,18 @@ export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<strin
     });
 
     if (activeProcess.stdout) {
-      activeProcess.stdout.on('data', (data: Buffer) => {
+      activeProcess.stdout.on('data', (data) => {
         logger.debug(`[Browser] ${data.toString()}`);
       });
     }
 
     if (activeProcess.stderr) {
-      activeProcess.stderr.on('data', (data: Buffer) => {
+      activeProcess.stderr.on('data', (data) => {
         logger.debug(`[Browser Error] ${data.toString()}`);
       });
     }
 
-    activeProcess.on('exit', (code: number | null) => {
+    activeProcess.on('exit', (code) => {
       logger.warn(`Browser process exited with code: ${code}`);
       activeProcess = null;
     });
@@ -96,10 +95,7 @@ export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<strin
   return binaryPath;
 }
 
-export async function spawnBrowserOnSocket(
-  socketName: string,
-  mode: BinaryMode = 'headless'
-): Promise<void> {
+export async function spawnBrowserOnSocket(socketName, mode = 'headless') {
   const binaryPath = detectBinary(mode);
   if (!binaryPath) {
     throw new Error(`Binary not found (${mode}). Cannot launch.`);
@@ -108,15 +104,14 @@ export async function spawnBrowserOnSocket(
   logger.info(`Spawning browser (${mode}) on socket: ${socketName}`);
 
   if (isBun) {
-    const Bun = (globalThis as any).Bun;
-    const proc = Bun.spawn([binaryPath], {
+    const proc = globalThis.Bun.spawn([binaryPath], {
       stdio: ['ignore', 'pipe', 'pipe'],
       env: { ...process.env, PIGGY_SOCKET: socketName },
     });
 
     extraProcesses.push(proc);
 
-    proc.exited.then((code: number | null) => {
+    proc.exited.then((code) => {
       logger.warn(`Browser on socket ${socketName} exited with code: ${code}`);
     });
   } else {
@@ -127,7 +122,7 @@ export async function spawnBrowserOnSocket(
 
     extraProcesses.push(proc);
 
-    proc.on('exit', (code: number | null) => {
+    proc.on('exit', (code) => {
       logger.warn(`Browser on socket ${socketName} exited with code: ${code}`);
     });
   }
@@ -136,7 +131,7 @@ export async function spawnBrowserOnSocket(
   logger.success(`Browser spawned (${mode}) on socket: ${socketName}`);
 }
 
-export function killBrowser(): void {
+export function killBrowser() {
   if (activeProcess) {
     logger.info('Killing browser process...');
     if (isBun) {

package/piggy/media/{index.ts → index.js}

@@ -1,15 +1,17 @@
-// piggy/media/index.ts
-import { PiggyClient } from "../client";
+// piggy/media/index.js
+import { PiggyClient } from "../client.js";
 import { writeFileSync, mkdirSync } from "fs";
 import { dirname } from "path";
 
 export class MediaClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
   // ── Screenshot ────────────────────────────────────────────────────────────
 
-  async screenshot(filePath?: string, tabId = "default"): Promise<string> {
-    const b64 = await this.client.send<string>("screenshot", { tabId });
+  async screenshot(filePath, tabId = "default") {
+    const b64 = await this.client.send("screenshot", { tabId });
     if (filePath) {
       mkdirSync(dirname(filePath), { recursive: true });
       writeFileSync(filePath, Buffer.from(b64, "base64"));
@@ -20,8 +22,8 @@ export class MediaClient {
 
   // ── PDF ───────────────────────────────────────────────────────────────────
 
-  async pdf(filePath?: string, tabId = "default"): Promise<string> {
-    const b64 = await this.client.send<string>("pdf", { tabId });
+  async pdf(filePath, tabId = "default") {
+    const b64 = await this.client.send("pdf", { tabId });
     if (filePath) {
       mkdirSync(dirname(filePath), { recursive: true });
       writeFileSync(filePath, Buffer.from(b64, "base64"));
@@ -32,15 +34,15 @@ export class MediaClient {
 
   // ── Image blocking ────────────────────────────────────────────────────────
 
-  blockImages(tabId = "default"): Promise<void> {
+  blockImages(tabId = "default") {
     return this.client.send("intercept.block.images", { tabId });
   }
 
-  unblockImages(tabId = "default"): Promise<void> {
+  unblockImages(tabId = "default") {
     return this.client.send("intercept.unblock.images", { tabId });
   }
 }
 
-export function createMediaAPI(client: PiggyClient): MediaClient {
+export function createMediaAPI(client) {
   return new MediaClient(client);
-}
+}

package/piggy/navigation/{index.ts → index.js}

@@ -1,52 +1,54 @@
-// piggy/navigation/index.ts
-import { PiggyClient } from "../client";
+// piggy/navigation/index.js
+import { PiggyClient } from "../client.js";
 
 export class NavigationClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
   // ── Navigation ────────────────────────────────────────────────────────────
 
-  navigate(url: string, tabId = "default"): Promise<void> {
+  navigate(url, tabId = "default") {
     return this.client.send("navigate", { url, tabId });
   }
 
-  reload(tabId = "default"): Promise<void> {
+  reload(tabId = "default") {
     return this.client.send("reload", { tabId });
   }
 
-  goBack(tabId = "default"): Promise<void> {
+  goBack(tabId = "default") {
     return this.client.send("go.back", { tabId });
   }
 
-  goForward(tabId = "default"): Promise<void> {
+  goForward(tabId = "default") {
     return this.client.send("go.forward", { tabId });
   }
 
   // ── Page info ─────────────────────────────────────────────────────────────
 
-  url(tabId = "default"): Promise<string> {
+  url(tabId = "default") {
     return this.client.send("page.url", { tabId });
   }
 
-  title(tabId = "default"): Promise<string> {
+  title(tabId = "default") {
     return this.client.send("page.title", { tabId });
   }
 
-  content(tabId = "default"): Promise<string> {
+  content(tabId = "default") {
     return this.client.send("page.content", { tabId });
   }
 
   // ── Wait ──────────────────────────────────────────────────────────────────
 
-  waitForNavigation(tabId = "default"): Promise<void> {
+  waitForNavigation(tabId = "default") {
     return this.client.send("wait.navigation", { tabId });
   }
 
-  waitForSelector(selector: string, timeout = 10000, tabId = "default"): Promise<void> {
+  waitForSelector(selector, timeout = 10000, tabId = "default") {
     return this.client.send("wait.selector", { selector, timeout, tabId });
   }
 }
 
-export function createNavigationAPI(client: PiggyClient): NavigationClient {
+export function createNavigationAPI(client) {
   return new NavigationClient(client);
-}
+}

package/piggy/pool/index.js

@@ -0,0 +1,76 @@
+// piggy/pool/index.js
+import { PiggyClient } from "../client.js";
+import logger from "../logger.js";
+
+export class TabPool {
+  #idle = [];
+  #busy = new Set();
+  #queue = [];
+
+  constructor(client, size, seedUrl, name) {
+    this.client  = client;
+    this.size    = size;
+    this.seedUrl = seedUrl;
+    this.name    = name;
+  }
+
+  async init() {
+    for (let i = 0; i < this.size; i++) {
+      const tabId = await this.client.newTab();
+      await this.client.navigate(this.seedUrl, tabId);
+      this.#idle.push(tabId);
+      logger.success(`[${this.name}] pool tab ${i + 1}/${this.size} ready: ${tabId}`);
+    }
+  }
+
+  acquire() {
+    return new Promise(resolve => {
+      const tabId = this.#idle.pop();
+      if (tabId) {
+        this.#busy.add(tabId);
+        resolve(tabId);
+      } else {
+        this.#queue.push(resolve);
+      }
+    });
+  }
+
+  release(tabId) {
+    this.#busy.delete(tabId);
+    const next = this.#queue.shift();
+    if (next) {
+      this.#busy.add(tabId);
+      next(tabId);
+    } else {
+      this.#idle.push(tabId);
+    }
+  }
+
+  async withTab(fn) {
+    logger.warn("[TabPool] withTab() is deprecated and will be removed in a later version — use the new tab API instead.");
+    const tabId = await this.acquire();
+    try {
+      return await fn(tabId);
+    } finally {
+      this.release(tabId);
+    }
+  }
+
+  async close() {
+    for (const tabId of [...this.#idle, ...this.#busy]) {
+      try { await this.client.closeTab(tabId); } catch {}
+    }
+    this.#idle  = [];
+    this.#busy.clear();
+    this.#queue = [];
+  }
+
+  get stats() {
+    return {
+      idle:   this.#idle.length,
+      busy:   this.#busy.size,
+      queued: this.#queue.length,
+      total:  this.size,
+    };
+  }
+}

package/piggy/provide/index.js

@@ -0,0 +1,97 @@
+// piggy/provide/index.js
+import { PiggyClient } from "../client.js";
+
+// ─── ProvideClient ────────────────────────────────────────────────────────────
+// provide answers ONE question: "give me the actual value from this element."
+// All methods take an options object { selector, parent? } so scoping is consistent.
+// If you just want to know if something exists, use find instead.
+
+export class ProvideClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /** innerText of the first matched element. */
+  text(opts, tabId = "default") {
+    return this.client.send("provide.text", { ...opts, tabId });
+  }
+
+  /** innerText of all matched elements. */
+  textAll(opts, tabId = "default") {
+    return this.client.send("provide.textAll", { ...opts, tabId });
+  }
+
+  /** Single attribute value from the first matched element. */
+  attr(opts, tabId = "default") {
+    return this.client.send("provide.attr", { ...opts, tabId });
+  }
+
+  /** Attribute value from all matched elements. */
+  attrAll(opts, tabId = "default") {
+    return this.client.send("provide.attrAll", { ...opts, tabId });
+  }
+
+  /** innerHTML of the first matched element. */
+  html(opts, tabId = "default") {
+    return this.client.send("provide.html", { ...opts, tabId });
+  }
+
+  /** Extract a table into headers + rows. */
+  table(opts, tabId = "default") {
+    return this.client.send("provide.table", { ...opts, tabId });
+  }
+
+  /** Extract a list of text items, optionally scoped to child items. */
+  list(opts, tabId = "default") {
+    return this.client.send("provide.list", { ...opts, tabId });
+  }
+
+  /** All links inside the matched selector. */
+  links(opts, tabId = "default") {
+    return this.client.send("provide.links", { ...opts, tabId });
+  }
+
+  /** All images inside the matched selector. */
+  images(opts, tabId = "default") {
+    return this.client.send("provide.images", { ...opts, tabId });
+  }
+
+  /** Form field name→value map. */
+  form(opts, tabId = "default") {
+    return this.client.send("provide.form", { ...opts, tabId });
+  }
+
+  /** Full page info: title, url, html, text. No selector needed. */
+  page(tabId = "default") {
+    return this.client.send("provide.page", { tabId });
+  }
+
+  /** Structured div tree: tag, id, cls, text, html, children[]. */
+  div(opts, tabId = "default") {
+    return this.client.send("provide.div", { ...opts, tabId });
+  }
+
+  /** All <meta> name→content pairs. No selector needed. */
+  meta(tabId = "default") {
+    return this.client.send("provide.meta", { tabId });
+  }
+
+  /** <select> current value + all options. */
+  select(opts, tabId = "default") {
+    return this.client.send("provide.select", { ...opts, tabId });
+  }
+
+  /**
+   * Parse JSON from element innerText or script[type=application/json].
+   * selector is optional — defaults to the first matching JSON script tag.
+   */
+  json(opts, tabId = "default") {
+    return this.client.send("provide.json", { ...opts, tabId });
+  }
+}
+
+// ─── Factory helper ───────────────────────────────────────────────────────────
+
+export function createProvideAPI(client) {
+  return new ProvideClient(client);
+}

package/piggy/proxy/index.js

@@ -0,0 +1,95 @@
+// piggy/proxy/index.js
+import { PiggyClient } from "../client.js";
+
+export class ProxyClient {
+  constructor(client) {
+    this.client = client;
+  }
+
+  /** Load proxies from a local file path. */
+  load(path) {
+    return this.client.send("proxy.load", { path });
+  }
+
+  /** Fetch proxies from a URL. Result comes via proxy:loaded / proxy:fetch:failed events. */
+  fetch(url) {
+    return this.client.send("proxy.fetch", { url });
+  }
+
+  /** Load an .ovpn config file. */
+  ovpn(path) {
+    return this.client.send("proxy.ovpn", { path });
+  }
+
+  /** Set a single proxy inline. */
+  set(opts) {
+    return this.client.send("proxy.set", opts);
+  }
+
+  /** Health-check all loaded proxies. Results come via events. */
+  test() {
+    return this.client.send("proxy.test", {});
+  }
+
+  /** Abort an in-progress health check. */
+  testStop() {
+    return this.client.send("proxy.test.stop", {});
+  }
+
+  /** Rotate to the next proxy in the pool. */
+  next() {
+    return this.client.send("proxy.next", {});
+  }
+
+  /** Alias for next(). */
+  rotate() {
+    return this.client.send("proxy.rotate", {});
+  }
+
+  /** Disable the proxy — use the real IP. */
+  disable() {
+    return this.client.send("proxy.disable", {});
+  }
+
+  /** Re-enable the current proxy. */
+  enable() {
+    return this.client.send("proxy.enable", {});
+  }
+
+  /** Get the current active proxy details. */
+  current() {
+    return this.client.send("proxy.current", {});
+  }
+
+  /** Get pool stats: total, alive, dead, index, active, checking. */
+  stats() {
+    return this.client.send("proxy.stats", {});
+  }
+
+  /** List all proxies with health info. limit defaults to 500. */
+  list(limit) {
+    return this.client.send("proxy.list", { limit });
+  }
+
+  /** Set rotation mode and interval (seconds, only used for "timed"). */
+  rotation(mode, interval) {
+    return this.client.send("proxy.rotation", { mode, interval });
+  }
+
+  /** Set skipDead / autoCheck flags. */
+  config(opts) {
+    return this.client.send("proxy.config", opts);
+  }
+
+  /**
+   * Save the current proxy list to a file.
+   * filter: "all" | "alive" | "dead" — defaults to "all".
+   */
+  save(path, filter) {
+    return this.client.send("proxy.save", { path, filter });
+  }
+}
+
+export function createProxyAPI(client) {
+  return new ProxyClient(client);
+}