nothing-browser 0.0.1

package/piggy/register/index.ts

@@ -0,0 +1,316 @@
+// piggy/register/index.ts
+import { PiggyClient } from "../client";
+import logger from "../logger";
+import { routeRegistry, keepAliveSites, type RouteHandler, type BeforeMiddleware } from "../server";
+import { randomDelay, humanTypeSequence } from "../human";
+
+let globalClient: PiggyClient | null = null;
+export let humanMode = false;
+
+export function setClient(c: PiggyClient | null) { globalClient = c; }
+export function setHumanMode(v: boolean) { humanMode = v; }
+
+async function retry<T>(
+  label: string,
+  fn: () => Promise<T>,
+  retries = 2,
+  backoff = 150
+): Promise<T> {
+  let last!: Error;
+  for (let i = 0; i <= retries; i++) {
+    try { return await fn(); } catch (e: any) {
+      last = e;
+      if (i < retries) {
+        logger.warn(`[${label}] retry ${i + 1}/${retries}: ${e.message}`);
+        await new Promise(r => setTimeout(r, backoff * (i + 1)));
+      }
+    }
+  }
+  throw last;
+}
+
+export function createSiteObject(
+  name: string,
+  registeredUrl: string,
+  client: PiggyClient,
+  tabId: string
+) {
+  let _currentUrl: string = registeredUrl;
+
+  const withErrScreen = async <T>(fn: () => Promise<T>, label: string): Promise<T> => {
+    try { return await fn(); } catch (err: any) {
+      const p = `./error-${name}-${Date.now()}.png`;
+      try { await client.screenshot(p, tabId); logger.error(`[${name}] ${label} failed → ${p}`); }
+      catch { logger.error(`[${name}] ${label} failed (no screenshot)`); }
+      throw err;
+    }
+  };
+
+  const site: any = {
+    _name: name,
+    _tabId: tabId,
+
+    // ── Navigation ─────────────────────────────────────────────────────────────
+
+    navigate: (url?: string, opts?: { retries?: number }) => {
+      const target = url ?? registeredUrl;
+      return retry(name, async () => {
+        logger.network(`[${name}] navigating → ${target}`);
+        await client.navigate(target, tabId);
+        _currentUrl = target;
+      }, opts?.retries ?? 2);
+    },
+
+    reload:             () => client.reload(tabId),
+    goBack:             () => client.goBack(tabId),
+    goForward:          () => client.goForward(tabId),
+    waitForNavigation:  () => client.waitForNavigation(tabId),
+
+    title: async () => {
+      const t = await client.getTitle(tabId);
+      logger.info(`[${name}] title: ${t}`);
+      return t;
+    },
+    url:     () => _currentUrl,
+    content: () => client.content(tabId),
+
+    wait: (ms: number) => {
+      const actual = humanMode ? ms + Math.floor(Math.random() * 600) - 300 : ms;
+      return new Promise<void>(r => setTimeout(r, Math.max(0, actual)));
+    },
+
+    waitForSelector: (selector: string, timeout = 30000) => {
+      logger.debug(`[${name}] waitForSelector: ${selector}`);
+      return client.waitForSelector(selector, timeout, tabId);
+    },
+    waitForVisible:  (selector: string, timeout = 30000) => client.waitForSelector(selector, timeout, tabId),
+    waitForResponse: (pattern: string, timeout = 30000)  => client.waitForResponse(pattern, timeout, tabId),
+
+    // ── Interactions ───────────────────────────────────────────────────────────
+
+    click: (selector: string, opts?: { retries?: number; timeout?: number }) =>
+      withErrScreen(() =>
+        retry(name, async () => {
+          if (humanMode) await randomDelay(80, 220);
+          await client.waitForSelector(selector, opts?.timeout ?? 15000, tabId);
+          const ok = await client.click(selector, tabId);
+          if (!ok) throw new Error(`click failed: ${selector}`);
+          logger.success(`[${name}] clicked: ${selector}`);
+          return ok;
+        }, opts?.retries ?? 2),
+        `click(${selector})`
+      ),
+
+    doubleClick: (selector: string) =>
+      withErrScreen(async () => {
+        if (humanMode) await randomDelay(80, 200);
+        return client.doubleClick(selector, tabId);
+      }, `dblclick(${selector})`),
+
+    hover: (selector: string) =>
+      withErrScreen(async () => {
+        if (humanMode) await randomDelay(50, 150);
+        return client.hover(selector, tabId);
+      }, `hover(${selector})`),
+
+    type: async (selector: string, text: string, opts?: { delay?: number; retries?: number; fact?: boolean; wpm?: number }) =>
+      withErrScreen(async () => {
+        await client.waitForSelector(selector, 15000, tabId);
+        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;
+            await client.type(selector, current, tabId);
+            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, tabId);
+            await new Promise(r => setTimeout(r, opts.delay));
+          }
+        } else {
+          await client.type(selector, text, tabId);
+        }
+        logger.success(`[${name}] typed into: ${selector}`);
+        return true;
+      }, `type(${selector})`),
+
+    select:   (selector: string, value: string) => client.select(selector, value, tabId),
+    evaluate: (js: string | (() => any), ...args: any[]) => {
+      const code = typeof js === "function" ? `(${js.toString()})(${args.map(a => JSON.stringify(a)).join(",")})` : js;
+      return client.evaluate(code, tabId);
+    },
+
+    keyboard: {
+      press: (key: string)   => client.keyPress(key, tabId),
+      combo: (combo: string) => client.keyCombo(combo, tabId),
+    },
+
+    mouse: {
+      move: (x: number, y: number) => client.mouseMove(x, y, tabId),
+      drag: (from: { x: number; y: number }, to: { x: number; y: number }) => client.mouseDrag(from, to, tabId),
+    },
+
+    scroll: {
+      to: (selector: string) => client.scrollTo(selector, tabId),
+      by: (px: number) => {
+        if (humanMode) {
+          const steps = Math.ceil(Math.abs(px) / 120);
+          const chunk = px / steps;
+          return (async () => {
+            for (let i = 0; i < steps; i++) {
+              await client.scrollBy(chunk, tabId);
+              await randomDelay(30, 80);
+            }
+          })();
+        }
+        return client.scrollBy(px, tabId);
+      },
+    },
+
+    // ── Fetch ──────────────────────────────────────────────────────────────────
+
+    fetchText:   (selector: string) => client.fetchText(selector, tabId),
+    fetchLinks:  async (selector: string) => {
+      const links = await client.fetchLinks(selector, tabId);
+      logger.info(`[${name}] fetchLinks(${selector}): ${links.length}`);
+      return links;
+    },
+    fetchImages: async (selector: string) => {
+      const imgs = await client.fetchImages(selector, tabId);
+      logger.info(`[${name}] fetchImages(${selector}): ${imgs.length}`);
+      return imgs;
+    },
+
+    search: {
+      css: (query: string) => client.searchCss(query, tabId),
+      id:  (query: string) => client.searchId(query, tabId),
+    },
+
+    // ── Screenshot / PDF ───────────────────────────────────────────────────────
+
+    screenshot: async (filePath?: string) => {
+      const r = await client.screenshot(filePath, tabId);
+      logger.success(`[${name}] screenshot → ${filePath ?? "base64"}`);
+      return r;
+    },
+    pdf: async (filePath?: string) => {
+      const r = await client.pdf(filePath, tabId);
+      logger.success(`[${name}] pdf → ${filePath ?? "base64"}`);
+      return r;
+    },
+
+    blockImages:   async () => { await client.blockImages(tabId);   logger.info(`[${name}] images blocked`); },
+    unblockImages: async () => { await client.unblockImages(tabId); logger.info(`[${name}] images unblocked`); },
+
+    // ── Cookies ────────────────────────────────────────────────────────────────
+
+    cookies: {
+      set: async (name: string, value: string, domain: string, path = "/") => {
+        await client.setCookie(name, value, domain, path, tabId);
+        logger.info(`[${name}] cookie set: ${name} @ ${domain}`);
+      },
+      get: (cookieName: string) => client.getCookie(cookieName, tabId),
+      delete: async (cookieName: string) => {
+        await client.deleteCookie(cookieName, tabId);
+        logger.info(`[${name}] cookie deleted: ${cookieName}`);
+      },
+      list: () => client.listCookies(tabId),
+    },
+
+    // ── Interception ───────────────────────────────────────────────────────────
+
+    intercept: {
+      block: async (pattern: string) => {
+        await client.addInterceptRule("block", pattern, {}, tabId);
+        logger.info(`[${name}] intercept block: ${pattern}`);
+      },
+      redirect: async (pattern: string, redirectUrl: string) => {
+        await client.addInterceptRule("redirect", pattern, { redirectUrl }, tabId);
+        logger.info(`[${name}] intercept redirect: ${pattern} → ${redirectUrl}`);
+      },
+      headers: async (pattern: string, headers: Record<string, string>) => {
+        await client.addInterceptRule("modifyHeaders", pattern, { headers }, tabId);
+        logger.info(`[${name}] intercept modifyHeaders: ${pattern}`);
+      },
+      clear: async () => {
+        await client.clearInterceptRules(tabId);
+        logger.info(`[${name}] intercept rules cleared`);
+      },
+    },
+
+    // ── Network capture ────────────────────────────────────────────────────────
+
+    capture: {
+      start: async () => {
+        await client.captureStart(tabId);
+        logger.info(`[${name}] capture started`);
+      },
+      stop: async () => {
+        await client.captureStop(tabId);
+        logger.info(`[${name}] capture stopped`);
+      },
+      requests: () => client.captureRequests(tabId),
+      ws:       () => client.captureWs(tabId),
+      cookies:  () => client.captureCookies(tabId),
+      storage:  () => client.captureStorage(tabId),
+      clear: async () => {
+        await client.captureClear(tabId);
+        logger.info(`[${name}] capture cleared`);
+      },
+    },
+
+    // ── Session ────────────────────────────────────────────────────────────────
+
+    session: {
+      export: async () => {
+        const data = await client.sessionExport(tabId);
+        logger.success(`[${name}] session exported`);
+        return data;
+      },
+      import: async (data: any) => {
+        await client.sessionImport(data, tabId);
+        logger.success(`[${name}] session imported`);
+      },
+    },
+
+    // ── Elysia API ─────────────────────────────────────────────────────────────
+
+    api: (
+      path: string,
+      handler: RouteHandler,
+      opts?: { ttl?: number; before?: BeforeMiddleware[]; method?: "GET" | "POST" | "PUT" | "DELETE" }
+    ) => {
+      const key = `${name}:${path}`;
+      if (routeRegistry.has(key)) {
+        logger.warn(`[${name}] route ${path} already registered`);
+        return site;
+      }
+      routeRegistry.set(key, {
+        path,
+        method: opts?.method ?? "GET",
+        handler,
+        ttl: opts?.ttl ?? 360_000,
+        before: opts?.before ?? [],
+      });
+      logger.info(`[${name}] api route: ${opts?.method ?? "GET"} /${name}${path}`);
+      return site;
+    },
+
+    noclose: () => { keepAliveSites.add(name); logger.info(`[${name}] keep-alive`); return site; },
+
+    close: async () => {
+      keepAliveSites.delete(name);
+      if (tabId !== "default") {
+        await client.closeTab(tabId);
+        logger.info(`[${name}] tab closed`);
+      }
+    },
+  };
+
+  return site;
+}

package/piggy/server/index.ts

@@ -0,0 +1,137 @@
+// piggy/server/index.ts
+import { Elysia } from "elysia";
+import * as cache from "../cache/memory";
+import logger from "../logger";
+
+export type BeforeMiddleware = (ctx: {
+  params: Record<string, string>;
+  query: Record<string, string>;
+  body: any;
+  headers: Record<string, string>;
+  set: any;
+}) => void | Promise<void>;
+
+export type RouteHandler = (
+  params: Record<string, string>,
+  query: Record<string, string>,
+  body: any
+) => Promise<any>;
+
+export interface RouteConfig {
+  path: string;
+  method: "GET" | "POST" | "PUT" | "DELETE";
+  handler: RouteHandler;
+  ttl: number;
+  before: BeforeMiddleware[];
+}
+
+export const routeRegistry = new Map<string, RouteConfig>();
+export const keepAliveSites = new Set<string>();
+
+// ── Error mapper ──────────────────────────────────────────────────────────────
+
+function mapError(err: Error, site: string) {
+  const msg = err.message.toLowerCase();
+  if (msg.includes("selector") || msg.includes("not found") || msg.includes("null"))
+    return { status: 404, error: "Not found", site, details: err.message };
+  if (msg.includes("timeout") || msg.includes("timed out"))
+    return { status: 504, error: "Timeout", site, details: err.message };
+  if (msg.includes("socket") || msg.includes("closed") || msg.includes("browser"))
+    return { status: 503, error: "Browser unavailable", site, details: err.message };
+  return { status: 500, error: "Internal server error", site, details: err.message };
+}
+
+// ── Server factory ────────────────────────────────────────────────────────────
+
+let _app: Elysia | null = null;
+
+export async function startServer(port: number, hostname = "0.0.0.0"): Promise<Elysia> {
+  _app = new Elysia();
+
+  // ── Health route ────────────────────────────────────────────────────────────
+  _app.get("/health", () => ({
+    status: "ok",
+    routes: routeRegistry.size,
+    cacheEntries: cache.size(),
+    uptime: process.uptime(),
+  }));
+
+  // ── Cache management routes ─────────────────────────────────────────────────
+  _app.delete("/cache", () => {
+    cache.clear();
+    return { cleared: true };
+  });
+
+  _app.get("/cache/keys", () => ({ keys: cache.keys() }));
+
+  // ── Registered site routes ──────────────────────────────────────────────────
+  for (const [registryKey, config] of routeRegistry.entries()) {
+    // registryKey format is "siteName:path" e.g. "movie:/title"
+    const colonIdx = registryKey.indexOf(":");
+    const siteName = registryKey.substring(0, colonIdx);
+    const fullPath = `/${siteName}${config.path}`;
+    const method = config.method.toLowerCase() as "get" | "post" | "put" | "delete";
+
+    logger.info(`[server] mounting ${config.method} ${fullPath} (ttl=${config.ttl}ms)`);
+
+    const routeHandler = async ({ params, query, body, headers, set }: any) => {
+      // 1. Run before middleware
+      for (const mw of config.before) {
+        try {
+          await mw({ params, query, body, headers, set });
+        } catch (e: any) {
+          set.status = set.status ?? 400;
+          return { error: e.message };
+        }
+      }
+
+      // 2. Cache check
+      const cacheKey = `${siteName}:${fullPath}:${JSON.stringify({ params, query })}`;
+      const hit = cache.get(cacheKey);
+      if (hit !== null) {
+        set.headers["x-cache"] = "HIT";
+        set.headers["x-cache-key"] = cacheKey;
+        return hit;
+      }
+
+      // 3. Execute handler
+      let result: any;
+      try {
+        result = await config.handler(params, query, body);
+      } catch (e: any) {
+        const mapped = mapError(e, siteName);
+        set.status = mapped.status;
+        return mapped;
+      }
+
+      // 4. Store in cache
+      if (config.ttl > 0) {
+        cache.set(cacheKey, result, config.ttl);
+        set.headers["x-cache"] = "MISS";
+      }
+
+      return result;
+    };
+
+    if (method === "get")         _app.get(fullPath, routeHandler);
+    else if (method === "post")   _app.post(fullPath, routeHandler);
+    else if (method === "put")    _app.put(fullPath, routeHandler);
+    else if (method === "delete") _app.delete(fullPath, routeHandler);
+  }
+
+  _app.listen({ port, hostname });
+
+  logger.success(`🚀 Piggy API server → http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`);
+  logger.info(`   Routes mounted: ${routeRegistry.size}`);
+  routeRegistry.forEach((cfg, key) => {
+    const siteName = key.substring(0, key.indexOf(":"));
+    logger.info(`   ${cfg.method} /${siteName}${cfg.path}  (ttl=${cfg.ttl}ms)`);
+  });
+
+  return _app;
+}
+
+export function stopServer() {
+  _app?.stop();
+  _app = null;
+}

package/piggy.ts

@@ -0,0 +1,135 @@
+// piggy.ts
+import { detectBinary } 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 { routeRegistry, keepAliveSites, startServer, stopServer } from "./piggy/server";
+import logger from "./piggy/logger";
+
+type BrowserMode = "tab" | "process";
+type SiteObject = ReturnType<typeof createSiteObject>;
+
+let _client: PiggyClient | null = null;
+let _mode: BrowserMode = "tab";
+const _extraProcs: { socket: string; client: PiggyClient }[] = [];
+const _sites: Record<string, SiteObject> = {};
+
+const piggy: any = {
+  // ── Lifecycle ───────────────────────────────────────────────────────────────
+
+  launch: async (opts?: { mode?: BrowserMode }) => {
+    _mode = opts?.mode ?? "tab";
+    await spawnBrowser();
+    await new Promise(r => setTimeout(r, 500));
+    _client = new PiggyClient();
+    await _client.connect();
+    setClient(_client);
+    logger.info(`[piggy] launched in "${_mode}" mode`);
+    return piggy;
+  },
+
+  register: async (name: string, url: string, opts?: any) => {
+    if (!url?.trim()) throw new Error(`No URL for site "${name}"`);
+
+    let tabId = "default";
+    if (_mode === "tab") {
+      tabId = await _client!.newTab();
+      _sites[name] = createSiteObject(name, url, _client!, tabId);
+      piggy[name] = _sites[name];
+      logger.success(`[${name}] registered as tab ${tabId}`);
+    } else {
+      const socketName = `piggy_${name}`;
+      await spawnBrowserOnSocket(socketName);
+      await new Promise(r => setTimeout(r, 500));
+      const c = new PiggyClient(socketName);
+      await c.connect();
+      _extraProcs.push({ socket: socketName, client: c });
+      _sites[name] = createSiteObject(name, url, c, "default");
+      piggy[name] = _sites[name];
+      logger.success(`[${name}] registered as process on "${socketName}"`);
+    }
+
+    if (opts?.mode) logger.info(`[${name}] mode: ${opts.mode}`);
+    return piggy;
+  },
+
+  // ── Global controls ─────────────────────────────────────────────────────────
+
+  actHuman: (enable: boolean) => {
+    setHumanMode(enable);
+    logger.info(`[piggy] actHuman: ${enable}`);
+    return piggy;
+  },
+
+  mode: (m: BrowserMode) => { _mode = m; return piggy; },
+
+  // ── Elysia server ────────────────────────────────────────────────────────────
+
+  serve: (port: number, opts?: { hostname?: string }) =>
+    startServer(port, opts?.hostname),
+
+  stopServer,
+
+  // ── Route listing ────────────────────────────────────────────────────────────
+
+  routes: () =>
+    Array.from(routeRegistry.entries()).map(([key, cfg]) => {
+      const [site] = key.split(":");
+      return {
+        site,
+        method: cfg.method,
+        path: `/${site}${cfg.path}`,
+        ttl: cfg.ttl,
+        middlewareCount: cfg.before.length,
+      };
+    }),
+
+  // ── 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[]) =>
+    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]]));
+        },
+    }),
+
+  // ── Shutdown ─────────────────────────────────────────────────────────────────
+
+  close: async (opts?: { force?: boolean }) => {
+    stopServer();
+    if (opts?.force) {
+      for (const { client: c } of _extraProcs) c.disconnect();
+      _client?.disconnect();
+      killBrowser();
+      routeRegistry.clear();
+      keepAliveSites.clear();
+    } else {
+      for (const [name, site] of Object.entries(_sites)) {
+        if (!keepAliveSites.has(name)) await site.close?.();
+      }
+      if (keepAliveSites.size === 0) {
+        for (const { client: c } of _extraProcs) c.disconnect();
+        _extraProcs.length = 0;
+        _client?.disconnect();
+        _client = null;
+        setClient(null);
+        killBrowser();
+      }
+    }
+    logger.info("[piggy] closed");
+  },
+
+  detect: detectBinary,
+  logger,
+};
+
+export default piggy;
+export { piggy };