nothing-browser 0.1.3 → 0.1.4

package/{piggy.ts → piggy.js}

@@ -1,63 +1,63 @@
-// piggy.ts — patched: adds single:true + piggy.extend()
-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, type SiteObject } from "./piggy/register";
-import { routeRegistry, keepAliveSites, startServer, stopServer } from "./piggy/server";
-import { TabPool } from "./piggy/pool";
-import { createRouter, type PiggyRouter } from "./piggy/router";
-import { createCaptureAPI } from "./piggy/capture";
-import { createCaptchaAPI } from "./piggy/captcha";
-import { createDialogAPI } from "./piggy/dialog";
-import { createExportAPI } from "./piggy/export";
-import { createFindAPI } from "./piggy/find";
-import { createHumanAPI } from "./piggy/human";
-import { createIframeAPI } from "./piggy/iframe";
-import { createInteractionsAPI } from "./piggy/interactions";
-import { createMediaAPI } from "./piggy/media";
-import { createNavigationAPI } from "./piggy/navigation";
-import { createProvideAPI } from "./piggy/provide";
-import { createProxyAPI } from "./piggy/proxy";
-import { createSessionAPI } from "./piggy/session";
-import { createTabsAPI } from "./piggy/tabs";
-import { createWaitAPI, createEvaluateAPI, createFetchAPI } from "./piggy/wait";
-import { createHttpClient, type HttpClientOptions } from "./piggy/http";
-import logger from "./piggy/logger";
-
-type TabMode = "tab" | "process";
-
-// A plugin installer is an async function that receives a site and enriches it.
-type PluginInstaller = (site: SiteObject) => Promise<any>;
-
-let _client: PiggyClient | null = null;
-let _router: PiggyRouter | null = null;
-let _tabMode: TabMode = "tab";
-const _extraProcs: { socket: string; client: PiggyClient }[] = [];
-const _sites: Record<string, SiteObject> = {};
-
-// ── Single-site tracking for extend() ────────────────────────────────────────
-// Only one site may be registered with { single: true } at a time.
-let _singleSiteName: string | null = null;
-
-// ── Internal guard ────────────────────────────────────────────────────────────
-
-function guardClient(): PiggyClient {
+'use strict';
+
+const { detectBinary }                          = require("./piggy/launch/detect");
+const { spawnBrowser, killBrowser,
+        spawnBrowserOnSocket }                  = require("./piggy/launch/spawn");
+const { PiggyClient }                           = require("./piggy/client");
+const { setClient, setHumanMode,
+        createSiteObject }                      = require("./piggy/register");
+const { routeRegistry, keepAliveSites,
+        startServer, stopServer }               = require("./piggy/server");
+const { TabPool }                               = require("./piggy/pool");
+const { createRouter }                          = require("./piggy/router");
+const { createCaptureAPI }                      = require("./piggy/capture");
+const { createCaptchaAPI }                      = require("./piggy/captcha");
+const { createDialogAPI }                       = require("./piggy/dialog");
+const { createExportAPI }                       = require("./piggy/export");
+const { createFindAPI }                         = require("./piggy/find");
+const { createHumanAPI }                        = require("./piggy/human");
+const { createIframeAPI }                       = require("./piggy/iframe");
+const { createInteractionsAPI }                 = require("./piggy/interactions");
+const { createMediaAPI }                        = require("./piggy/media");
+const { createNavigationAPI }                   = require("./piggy/navigation");
+const { createProvideAPI }                      = require("./piggy/provide");
+const { createProxyAPI }                        = require("./piggy/proxy");
+const { createSessionAPI }                      = require("./piggy/session");
+const { createTabsAPI }                         = require("./piggy/tabs");
+const { createWaitAPI, createEvaluateAPI,
+        createFetchAPI }                        = require("./piggy/wait");
+const { createHttpClient }                      = require("./piggy/http");
+const logger                                    = require("./piggy/logger");
+
+// ── State ─────────────────────────────────────────────────────────────────────
+
+let _client         = null;
+let _router         = null;
+let _tabMode        = "tab";
+let _singleSiteName = null;
+
+const _extraProcs = [];
+const _sites      = {};
+
+// ── Internal helpers ──────────────────────────────────────────────────────────
+
+function guardClient() {
   if (!_client) throw new Error("No client. Call piggy.launch() or piggy.connect() first.");
   return _client;
 }
 
-// ── Build sub-APIs from a client ──────────────────────────────────────────────
-
-function buildAPIs(client: PiggyClient) {
+function buildAPIs(client) {
   _router = createRouter(client);
 }
 
-const piggy: any = {
+// ── piggy object ──────────────────────────────────────────────────────────────
+
+const piggy = {
 
   // ── Local launch (unix socket) ────────────────────────────────────────────
-  launch: async (opts?: { mode?: TabMode; binary?: BinaryMode }) => {
-    _tabMode = opts?.mode ?? "tab";
-    const binaryMode: BinaryMode = opts?.binary ?? "headless";
+  launch: async (opts = {}) => {
+    _tabMode = opts.mode ?? "tab";
+    const binaryMode = opts.binary ?? "headless";
     await spawnBrowser(binaryMode);
     await new Promise(r => setTimeout(r, 500));
     _client = new PiggyClient();
@@ -69,9 +69,9 @@ const piggy: any = {
   },
 
   // ── Remote connect (HTTP) ─────────────────────────────────────────────────
-  connect: async (opts: { host: string; key: string }) => {
+  connect: async (opts) => {
     _tabMode = "tab";
-    _client = new PiggyClient({ host: opts.host, key: opts.key });
+    _client  = new PiggyClient({ host: opts.host, key: opts.key });
     await _client.connect();
     setClient(_client);
     buildAPIs(_client);
@@ -79,24 +79,17 @@ const piggy: any = {
     return piggy;
   },
 
-  // ── HTTP client (port 2005 direct) ────────────────────────────────────────
-  http: (opts: HttpClientOptions) => createHttpClient(opts),
+  // ── HTTP client ───────────────────────────────────────────────────────────
+  http: (opts) => createHttpClient(opts),
 
   // ── Register ──────────────────────────────────────────────────────────────
-  register: async (
-    name: string,
-    url: string,
-    opts?: { binary?: BinaryMode; pool?: number; single?: boolean }
-  ) => {
+  register: async (name, url, opts = {}) => {
     if (!url?.trim()) throw new Error(`No URL for site "${name}"`);
 
-    const binaryMode: BinaryMode = opts?.binary ?? "headless";
-    const poolSize   = opts?.pool ?? 0;
-    const isSingle   = opts?.single === true;
+    const binaryMode = opts.binary   ?? "headless";
+    const poolSize   = opts.pool     ?? 0;
+    const isSingle   = opts.single   === true;
 
-    // ── single: true enforcement ───────────────────────────────────────────
-    // A single-site registration uses the default tab and blocks tab.new so
-    // the binary stays strictly single-tab. Only one site may be single.
     if (isSingle && _singleSiteName && _singleSiteName !== name) {
       throw new Error(
         `piggy: site "${_singleSiteName}" is already registered as single. ` +
@@ -109,18 +102,17 @@ const piggy: any = {
 
       if (poolSize > 1) {
         if (isSingle) throw new Error('piggy: { single: true } is incompatible with pool > 1');
-        const pool = new TabPool(client, poolSize, url, name);
+        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;
+        _sites[name]  = siteObj;
+        piggy[name]   = siteObj;
         logger.success(`[${name}] registered with pool of ${poolSize} tabs`);
       } else {
-        // single: true  →  reuse the default tab, never call newTab()
-        const tabId = isSingle ? "default" : await client.newTab();
+        const tabId   = isSingle ? "default" : await client.newTab();
         const siteObj = createSiteObject(name, url, client, tabId);
-        _sites[name] = siteObj;
-        piggy[name]  = siteObj;
+        _sites[name]  = siteObj;
+        piggy[name]   = siteObj;
 
         if (isSingle) {
           _singleSiteName = name;
@@ -138,26 +130,16 @@ const piggy: any = {
       await c.connect();
       _extraProcs.push({ socket: socketName, client: c });
       const siteObj = createSiteObject(name, url, c, "default");
-      _sites[name] = siteObj;
-      piggy[name]  = siteObj;
+      _sites[name]  = siteObj;
+      piggy[name]   = siteObj;
       logger.success(`[${name}] registered as process on "${socketName}"`);
     }
 
     return piggy;
   },
 
-  // ── extend() — installs plugins onto the single-flagged site ─────────────
-  //
-  // Each installer is an async function returned by a plugin factory, e.g.:
-  //   innerstorage({ path: './wa-storage.json' })   → installer fn
-  //
-  // Usage:
-  //   await piggy.extend(
-  //     innerstorage({ path: './wa-storage.json' }),
-  //     cookiesinject({ cookieFile: './wa-cookies.json' }),
-  //     mediacapture({ downloadDir: './wa-media/' })
-  //   );
-  extend: async (...installers: PluginInstaller[]) => {
+  // ── extend() ─────────────────────────────────────────────────────────────
+  extend: async (...installers) => {
     if (!_singleSiteName) {
       throw new Error(
         'piggy.extend() requires a site registered with { single: true }.\n' +
@@ -174,6 +156,13 @@ const piggy: any = {
       throw new Error(`piggy.extend(): site "${_singleSiteName}" not found — register it first`);
     }
 
+    // Inject _send before any installer runs so plugins can reach C++ commands.
+    if (typeof site._send !== 'function') {
+      const client = guardClient();
+      const tabId  = site._tabId ?? 'default';
+      site._send   = (cmd, payload = {}) => client.send(cmd, { tabId, ...payload });
+    }
+
     for (const installer of installers) {
       if (typeof installer !== 'function') {
         throw new Error('piggy.extend(): each argument must be a plugin installer function');
@@ -185,8 +174,7 @@ const piggy: any = {
     return piggy;
   },
 
-  // ── Sub-APIs (1:1 with C++ files, available after launch/connect) ─────────
-
+  // ── Sub-APIs ──────────────────────────────────────────────────────────────
   get tabs()         { return _router?.tabs         ?? createTabsAPI(guardClient()); },
   get tab()          { return _router?.tabs         ?? createTabsAPI(guardClient()); },
   get navigation()   { return _router?.navigation   ?? createNavigationAPI(guardClient()); },
@@ -205,63 +193,54 @@ const piggy: any = {
   get session()      { return _router?.session      ?? createSessionAPI(guardClient()); },
   get export()       { return _router?.export       ?? createExportAPI(guardClient()); },
 
-  // ── Proxy (global, not per-tab) ───────────────────────────────────────────
+  // ── Proxy ─────────────────────────────────────────────────────────────────
   get proxy() {
     const api = _router?.proxy ?? createProxyAPI(guardClient());
     return {
-      load:     (path: string)                                              => api.load(path),
-      fetch:    (url: string)                                               => api.fetch(url),
-      ovpn:     (path: string)                                             => api.ovpn(path),
-      set:      (opts: Parameters<typeof api.set>[0])                       => api.set(opts),
-      test:     ()                                                          => api.test(),
-      testStop: ()                                                          => api.testStop(),
-      next:     ()                                                          => api.next(),
-      rotate:   ()                                                          => api.rotate(),
-      disable:  ()                                                          => api.disable(),
-      enable:   ()                                                          => api.enable(),
-      current:  ()                                                          => api.current(),
-      stats:    ()                                                          => api.stats(),
-      list:     (limit?: number)                                            => api.list(limit),
-      rotation: (mode: "none" | "timed" | "perrequest", interval?: number) => api.rotation(mode, interval),
-      config:   (opts: { skipDead?: boolean; autoCheck?: boolean })         => api.config(opts),
-      save:     (path: string, filter?: "alive" | "dead" | "all")          => api.save(path, filter),
-      on:       (event: string, handler: (data: any) => void)               => guardClient().onProxyEvent(event, handler),
+      load:     (path)                        => api.load(path),
+      fetch:    (url)                         => api.fetch(url),
+      ovpn:     (path)                        => api.ovpn(path),
+      set:      (opts)                        => api.set(opts),
+      test:     ()                            => api.test(),
+      testStop: ()                            => api.testStop(),
+      next:     ()                            => api.next(),
+      rotate:   ()                            => api.rotate(),
+      disable:  ()                            => api.disable(),
+      enable:   ()                            => api.enable(),
+      current:  ()                            => api.current(),
+      stats:    ()                            => api.stats(),
+      list:     (limit)                       => api.list(limit),
+      rotation: (mode, interval)              => api.rotation(mode, interval),
+      config:   (opts)                        => api.config(opts),
+      save:     (path, filter)                => api.save(path, filter),
+      on:       (event, handler)              => guardClient().onProxyEvent(event, handler),
     };
   },
 
   // ── Global controls ───────────────────────────────────────────────────────
-  actHuman: (enable: boolean) => {
+  actHuman: (enable) => {
     setHumanMode(enable);
     logger.info(`[piggy] actHuman: ${enable}`);
     return piggy;
   },
 
-  mode: (m: TabMode) => { _tabMode = m; return piggy; },
+  mode: (m) => { _tabMode = m; return piggy; },
 
   // ── Global expose ─────────────────────────────────────────────────────────
-  expose: async (name: string, handler: (data: any) => Promise<any> | any, tabId = "default") => {
+  expose: async (name, handler, tabId = "default") => {
     await guardClient().exposeFunction(name, handler, tabId);
     logger.success(`[piggy] exposed global function: ${name}`);
     return piggy;
   },
 
-  unexpose: async (name: string, tabId = "default") => {
+  unexpose: async (name, tabId = "default") => {
     await guardClient().unexposeFunction(name, tabId);
     logger.info(`[piggy] unexposed function: ${name}`);
     return piggy;
   },
 
   // ── Elysia server ─────────────────────────────────────────────────────────
-  serve: (
-    port: number,
-    opts?: {
-      hostname?: string;
-      title?: string;
-      version?: string;
-      description?: string;
-      path?: string;
-    }
-  ) => startServer(port, opts?.hostname, opts),
+  serve: (port, opts) => startServer(port, opts?.hostname, opts),
 
   stopServer,
 
@@ -271,34 +250,34 @@ const piggy: any = {
       const [site] = key.split(":");
       return {
         site,
-        method: cfg.method,
-        path: `/${site}${cfg.path}`,
-        ttl: cfg.ttl,
+        method:          cfg.method,
+        path:            `/${site}${cfg.path}`,
+        ttl:             cfg.ttl,
         middlewareCount: cfg.before.length,
       };
     }),
 
   // ── Multi-site helpers ────────────────────────────────────────────────────
-  all: (sites: SiteObject[]) =>
-    new Proxy({} as any, {
-      get: (_, method: string) =>
-        (...args: any[]) => Promise.all(sites.map((s: any) => s[method]?.(...args))),
+  all: (sites) =>
+    new Proxy({}, {
+      get: (_, method) =>
+        (...args) => Promise.all(sites.map(s => s[method]?.(...args))),
     }),
 
-  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]]));
+  diff: (sites) =>
+    new Proxy({}, {
+      get: (_, method) =>
+        async (...args) => {
+          const results = await Promise.all(sites.map(s => s[method]?.(...args)));
+          return Object.fromEntries(sites.map((s, i) => [s._name ?? i, results[i]]));
         },
     }),
 
   // ── Shutdown ──────────────────────────────────────────────────────────────
-  close: async (opts?: { force?: boolean }) => {
+  close: async (opts = {}) => {
     stopServer();
     _singleSiteName = null;
-    if (opts?.force) {
+    if (opts.force) {
       for (const { client: c } of _extraProcs) c.disconnect();
       _client?.disconnect();
       killBrowser();
@@ -306,7 +285,7 @@ const piggy: any = {
       keepAliveSites.clear();
     } else {
       for (const [name, site] of Object.entries(_sites)) {
-        if (!keepAliveSites.has(name)) await (site as any).close?.();
+        if (!keepAliveSites.has(name)) await site.close?.();
       }
       if (keepAliveSites.size === 0) {
         for (const { client: c } of _extraProcs) c.disconnect();
@@ -327,14 +306,11 @@ const piggy: any = {
 
 // ── usePiggy ──────────────────────────────────────────────────────────────────
 
-type TypedPiggy<Sites extends string> = typeof piggy & {
-  [K in Sites]: SiteObject;
-};
-
-export function usePiggy<Sites extends string>(): TypedPiggy<Sites> {
-  return piggy as TypedPiggy<Sites>;
+function usePiggy() {
+  return piggy;
 }
 
-export type { SiteObject };
-export default piggy;
-export { piggy };
+module.exports         = piggy;
+module.exports.default = piggy;
+module.exports.piggy   = piggy;
+module.exports.usePiggy = usePiggy;

package/dist/cache/memory.js

@@ -1,35 +0,0 @@
-// piggy/cache/memory.ts
-var store = new Map;
-function get(key) {
-  const entry = store.get(key);
-  if (!entry)
-    return null;
-  if (Date.now() > entry.expires) {
-    store.delete(key);
-    return null;
-  }
-  return entry.data;
-}
-function set(key, data, ttlMs) {
-  store.set(key, { data, expires: Date.now() + ttlMs });
-}
-function del(key) {
-  store.delete(key);
-}
-function clear() {
-  store.clear();
-}
-function size() {
-  return store.size;
-}
-function keys() {
-  return Array.from(store.keys());
-}
-export {
-  size,
-  set,
-  keys,
-  get,
-  del,
-  clear
-};