nothing-browser 0.0.1

package/piggy/client/index.ts

@@ -0,0 +1,330 @@
+// piggy/client/index.ts
+import { connect, type Socket } from "net";
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import logger from "../logger";
+
+export class PiggyClient {
+  private socketPath: string;
+  private socket: Socket | null = null;
+  private reqId = 0;
+  private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
+  private buf = "";
+
+  constructor(socketPath = "/tmp/piggy") {
+    this.socketPath = socketPath;
+  }
+
+  connect(): 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");
+        resolve();
+      });
+
+      sock.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);
+            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();
+      });
+    });
+  }
+
+  disconnect() {
+    this.socket?.destroy();
+    this.socket = null;
+  }
+
+  private 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"));
+      const id = String(++this.reqId);
+      this.pending.set(id, { resolve, reject });
+      this.socket.write(JSON.stringify({ id, cmd, payload }) + "\n");
+    });
+  }
+
+  // ── Tabs ─────────────────────────────────────────────────────────────────────
+
+  async newTab(): Promise<string> {
+    return this.send<string>("tab.new", {});
+  }
+
+  async closeTab(tabId: string): Promise<void> {
+    await this.send("tab.close", { tabId });
+  }
+
+  async listTabs(): Promise<string[]> {
+    return this.send<string[]>("tab.list", {});
+  }
+
+  // ── Navigation ───────────────────────────────────────────────────────────────
+
+  async navigate(url: string, tabId = "default"): Promise<void> {
+    await this.send("navigate", { url, tabId });
+  }
+
+  async reload(tabId = "default"): Promise<void> {
+    await this.send("reload", { tabId });
+  }
+
+  async goBack(tabId = "default"): Promise<void> {
+    await this.send("go.back", { tabId });
+  }
+
+  async goForward(tabId = "default"): Promise<void> {
+    await this.send("go.forward", { tabId });
+  }
+
+  // ── Page info ─────────────────────────────────────────────────────────────────
+
+  async getTitle(tabId = "default"): Promise<string> {
+    return this.send<string>("page.title", { tabId });
+  }
+
+  async getUrl(tabId = "default"): Promise<string> {
+    return this.send<string>("page.url", { tabId });
+  }
+
+  async content(tabId = "default"): Promise<string> {
+    return this.send<string>("page.content", { tabId });
+  }
+
+  // ── Eval / JS ─────────────────────────────────────────────────────────────────
+
+  async evaluate(js: string, tabId = "default"): Promise<any> {
+    return this.send("evaluate", { js, tabId });
+  }
+
+  // ── Interactions ──────────────────────────────────────────────────────────────
+
+  async click(selector: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("click", { selector, tabId });
+  }
+
+  async doubleClick(selector: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("dblclick", { selector, tabId });
+  }
+
+  async hover(selector: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("hover", { selector, tabId });
+  }
+
+  async type(selector: string, text: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("type", { selector, text, tabId });
+  }
+
+  async select(selector: string, value: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("select", { selector, value, tabId });
+  }
+
+  async keyPress(key: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("keyboard.press", { key, tabId });
+  }
+
+  async keyCombo(combo: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("keyboard.combo", { combo, tabId });
+  }
+
+  async mouseMove(x: number, y: number, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("mouse.move", { x, y, tabId });
+  }
+
+  async mouseDrag(from: { x: number; y: number }, to: { x: number; y: number }, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("mouse.drag", { from, to, tabId });
+  }
+
+  // ── Scroll ────────────────────────────────────────────────────────────────────
+
+  async scrollTo(selector: string, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("scroll.to", { selector, tabId });
+  }
+
+  async scrollBy(px: number, tabId = "default"): Promise<boolean> {
+    return this.send<boolean>("scroll.by", { px, tabId });
+  }
+
+  // ── Fetch ─────────────────────────────────────────────────────────────────────
+
+  async fetchText(query: string, tabId = "default"): Promise<string | null> {
+    return this.send<string | null>("fetch.text", { query, tabId });
+  }
+
+  async fetchLinks(query: string, tabId = "default"): Promise<string[]> {
+    if (query === "a" || query === "body") {
+      const result = await this.send<string[]>("fetch.links.all", { tabId });
+      return Array.isArray(result) ? result : [];
+    }
+    const result = await this.send<string[]>("fetch.links", { query, tabId });
+    return Array.isArray(result) ? result : [];
+  }
+
+  async fetchImages(query: string, tabId = "default"): Promise<string[]> {
+    const result = await this.send<string[]>("fetch.image", { query, tabId });
+    return Array.isArray(result) ? result : [];
+  }
+
+  // ── Search ────────────────────────────────────────────────────────────────────
+
+  async searchCss(query: string, tabId = "default"): Promise<any> {
+    return this.send("search.css", { query, tabId });
+  }
+
+  async searchId(query: string, tabId = "default"): Promise<any> {
+    return this.send("search.id", { query, tabId });
+  }
+
+  // ── Wait ──────────────────────────────────────────────────────────────────────
+
+  async waitForSelector(selector: string, timeout = 30000, tabId = "default"): Promise<void> {
+    await this.send("wait.selector", { selector, timeout, tabId });
+  }
+
+  async waitForNavigation(tabId = "default"): Promise<void> {
+    await this.send("wait.navigation", { tabId });
+  }
+
+  async waitForResponse(urlPattern: string, timeout = 30000, tabId = "default"): Promise<void> {
+    await this.send("wait.response", { url: urlPattern, timeout, tabId });
+  }
+
+  // ── Screenshot ────────────────────────────────────────────────────────────────
+
+  async screenshot(filePath?: string, tabId = "default"): Promise<string> {
+    const b64 = await this.send<string>("screenshot", { tabId });
+    if (filePath) {
+      mkdirSync(dirname(filePath), { recursive: true });
+      writeFileSync(filePath, Buffer.from(b64, "base64"));
+    }
+    return filePath ?? b64;
+  }
+
+  // ── PDF ───────────────────────────────────────────────────────────────────────
+
+  async pdf(filePath?: string, tabId = "default"): Promise<string> {
+    const b64 = await this.send<string>("pdf", { tabId });
+    if (filePath) {
+      mkdirSync(dirname(filePath), { recursive: true });
+      writeFileSync(filePath, Buffer.from(b64, "base64"));
+    }
+    return filePath ?? b64;
+  }
+
+  // ── Image blocking ────────────────────────────────────────────────────────────
+
+  async blockImages(tabId = "default"): Promise<void> {
+    await this.send("intercept.block.images", { tabId });
+  }
+
+  async unblockImages(tabId = "default"): Promise<void> {
+    await this.send("intercept.unblock.images", { tabId });
+  }
+
+  // ── Cookies ───────────────────────────────────────────────────────────────────
+
+  async setCookie(
+    name: string,
+    value: string,
+    domain: string,
+    path = "/",
+    tabId = "default"
+  ): Promise<void> {
+    await this.send("cookie.set", { name, value, domain, path, tabId });
+  }
+
+  async getCookie(name: string, tabId = "default"): Promise<any> {
+    return this.send("cookie.get", { name, tabId });
+  }
+
+  async deleteCookie(name: string, tabId = "default"): Promise<void> {
+    await this.send("cookie.delete", { name, tabId });
+  }
+
+  async listCookies(tabId = "default"): Promise<any[]> {
+    return this.send<any[]>("cookie.list", { tabId });
+  }
+
+  // ── Interception ──────────────────────────────────────────────────────────────
+
+  async addInterceptRule(
+    action: "block" | "redirect" | "modifyHeaders",
+    pattern: string,
+    options: { redirectUrl?: string; headers?: Record<string, string> } = {},
+    tabId = "default"
+  ): Promise<void> {
+    await this.send("intercept.rule.add", { action, pattern, ...options, tabId });
+  }
+
+  async clearInterceptRules(tabId = "default"): Promise<void> {
+    await this.send("intercept.rule.clear", { tabId });
+  }
+
+  // ── Network capture ───────────────────────────────────────────────────────────
+
+  async captureStart(tabId = "default"): Promise<void> {
+    await this.send("capture.start", { tabId });
+  }
+
+  async captureStop(tabId = "default"): Promise<void> {
+    await this.send("capture.stop", { tabId });
+  }
+
+  async captureRequests(tabId = "default"): Promise<any[]> {
+    return this.send<any[]>("capture.requests", { tabId });
+  }
+
+  async captureWs(tabId = "default"): Promise<any[]> {
+    return this.send<any[]>("capture.ws", { tabId });
+  }
+
+  async captureCookies(tabId = "default"): Promise<any[]> {
+    return this.send<any[]>("capture.cookies", { tabId });
+  }
+
+  async captureStorage(tabId = "default"): Promise<any> {
+    return this.send("capture.storage", { tabId });
+  }
+
+  async captureClear(tabId = "default"): Promise<void> {
+    await this.send("capture.clear", { tabId });
+  }
+
+  // ── Session ───────────────────────────────────────────────────────────────────
+
+  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 });
+  }
+}

package/piggy/human/index.ts

@@ -0,0 +1,53 @@
+// piggy/human/index.ts
+
+export function randomDelay(min: number, max: number): Promise<void> {
+  return new Promise(r => setTimeout(r, Math.floor(Math.random() * (max - min + 1)) + min));
+}
+
+/**
+ * Simulates human typing by introducing ~2 random typos and correcting them.
+ * Returns an array of { char, isBackspace } actions to replay.
+ */
+export function humanTypeSequence(text: string): string[] {
+  const adjacent: Record<string, string[]> = {
+    a: ["q","w","s","z"], b: ["v","g","h","n"], c: ["x","d","f","v"],
+    d: ["s","e","r","f","c","x"], e: ["w","r","d","s"],
+    f: ["d","r","t","g","v","c"], g: ["f","t","y","h","b","v"],
+    h: ["g","y","u","j","n","b"], i: ["u","o","k","j"],
+    j: ["h","u","i","k","m","n"], k: ["j","i","o","l","m"],
+    l: ["k","o","p"], m: ["n","j","k"], n: ["b","h","j","m"],
+    o: ["i","p","l","k"], p: ["o","l"], q: ["w","a"],
+    r: ["e","t","f","d"], s: ["a","w","e","d","x","z"],
+    t: ["r","y","g","f"], u: ["y","i","h","j"],
+    v: ["c","f","g","b"], w: ["q","e","a","s"],
+    x: ["z","s","d","c"], y: ["t","u","g","h"],
+    z: ["a","s","x"],
+  };
+
+  const actions: string[] = [];
+  const typoIndices = new Set<number>();
+
+  // Pick ~2 random positions to typo (skip short strings)
+  if (text.length > 4) {
+    let tries = 0;
+    while (typoIndices.size < 2 && tries < 20) {
+      typoIndices.add(Math.floor(Math.random() * text.length));
+      tries++;
+    }
+  }
+
+  for (let i = 0; i < text.length; i++) {
+    if (typoIndices.has(i)) {
+      const ch = text[i]!.toLowerCase();
+      const neighbors = adjacent[ch];
+        const typo = neighbors
+        ? neighbors[Math.floor(Math.random() * neighbors.length)] ?? ch
+        : ch;
+      actions.push(typo);        // wrong char
+      actions.push("BACKSPACE"); // correct it
+    }
+    actions.push(text[i]!);
+  }
+
+  return actions;
+}

package/piggy/launch/detect.ts

@@ -0,0 +1,33 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import logger from '../logger';
+
+export function detectBinary(): string | null {
+    const cwd = process.cwd();
+    
+    // Windows
+    const windowsPath = join(cwd, 'nothing-browser-headless.exe');
+    if (process.platform === 'win32' && existsSync(windowsPath)) {
+        logger.success(`Binary found! Platform: Windows`);
+        return windowsPath;
+    }
+    
+    // Linux / macOS
+    const unixPath = join(cwd, 'nothing-browser-headless');
+    if (existsSync(unixPath)) {
+        logger.success(`Binary found at: ${unixPath}`);
+        return unixPath;
+    }
+    
+    logger.error("❌ Binary not found in project root");
+    logger.error("");
+    logger.error("Download from:");
+    logger.error("  https://github.com/BunElysiaReact/nothing-browser/releases/");
+    logger.error("");
+    logger.error(`Place in: ${cwd}/nothing-browser-headless${process.platform === 'win32' ? '.exe' : ''}`);
+    if (process.platform !== 'win32') {
+        logger.error("Then run: chmod +x nothing-browser-headless");
+    }
+    
+    return null;
+}

package/piggy/launch/spawn.ts

@@ -0,0 +1,101 @@
+import { spawn } from 'bun';
+import { execSync } from 'child_process';
+import { detectBinary } from './detect';
+import logger from '../logger';
+
+let activeProcess: any = null;
+const extraProcesses: any[] = [];
+
+export function killAllBrowsers(): void {
+    try {
+        logger.info("Cleaning up existing browser processes...");
+        execSync('pkill -f nothing-browser-headless 2>/dev/null || true', { stdio: 'ignore' });
+        execSync('pkill -f QtWebEngineProcess 2>/dev/null || true', { stdio: 'ignore' });
+        execSync('rm -f /tmp/piggy', { stdio: 'ignore' });
+    } catch {
+        // Ignore errors - no processes to kill
+    }
+}
+
+export async function spawnBrowser(): Promise<string> {
+    killAllBrowsers();
+
+    // Give OS time to release the socket
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    const binaryPath = detectBinary();
+    if (!binaryPath) {
+        throw new Error("Binary not found. Cannot launch.");
+    }
+
+    logger.info(`Spawning Nothing Browser from: ${binaryPath}`);
+
+    activeProcess = spawn([binaryPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: process.env
+    });
+
+    if (activeProcess.stdout) {
+        const reader = activeProcess.stdout.getReader();
+        const read = async () => {
+            const { done, value } = await reader.read();
+            if (!done) {
+                const output = new TextDecoder().decode(value);
+                logger.debug(`[Browser] ${output}`);
+                read();
+            }
+        };
+        read();
+    }
+
+    activeProcess.exited.then((code: number | null) => {
+        logger.warn(`Browser process exited with code: ${code}`);
+        activeProcess = null;
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 2000));
+
+    if (activeProcess) {
+        logger.success("Browser spawned and running");
+    } else {
+        logger.error("Browser started but exited immediately");
+    }
+
+    return binaryPath;
+}
+
+export async function spawnBrowserOnSocket(socketName: string): Promise<void> {
+    const binaryPath = detectBinary();
+    if (!binaryPath) {
+        throw new Error("Binary not found. Cannot launch.");
+    }
+
+    logger.info(`Spawning browser on socket: ${socketName}`);
+
+    const proc = spawn([binaryPath], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, PIGGY_SOCKET: socketName }
+    });
+
+    extraProcesses.push(proc);
+
+    proc.exited.then((code: number | null) => {
+        logger.warn(`Browser on socket ${socketName} exited with code: ${code}`);
+    });
+
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    logger.success(`Browser spawned on socket: ${socketName}`);
+}
+
+export function killBrowser(): void {
+    if (activeProcess) {
+        logger.info("Killing browser process...");
+        activeProcess.kill();
+        activeProcess = null;
+    }
+
+    for (const proc of extraProcesses) {
+        proc.kill();
+    }
+    extraProcesses.length = 0;
+}

package/piggy/logger/index.ts

@@ -0,0 +1,59 @@
+
+//piggy/logger/index.ts
+import { createLogger } from "ernest-logger";
+
+const logger = createLogger({
+    time: true,
+    file: true,
+    filePath: './piggy.log',
+    prefix: '[PIGGY]',
+    emoji: true,
+    level: 'trace',
+    customLevels: {
+        info: {
+            color: 'blue',
+            emoji: 'ℹ️',
+            priority: 2
+        },
+        success: {
+            color: 'green',
+            emoji: '✅',
+            priority: 2
+        },
+        error: {
+            color: 'red',
+            emoji: '❌',
+            priority: 5
+        },
+        warn: {
+            color: 'yellow',
+            emoji: '⚠️',
+            priority: 4
+        },
+        debug: {
+            color: 'magenta',
+            emoji: '🐞',
+            priority: 1
+        },
+        network: {
+            color: 'brightCyan',
+            emoji: '🌐',
+            priority: 2
+        },
+        db: {
+            color: 'brightMagenta',
+            emoji: '🗄️',
+            priority: 2
+        },
+        security: {
+            color: 'brightRed',
+            emoji: '🔒',
+            priority: 3
+        }
+    }
+});
+
+// Now these methods exist with your custom colors
+logger.info("logger initialized");      // Blue with ℹ️
+
+export default logger;

package/piggy/open/index.ts

@@ -0,0 +1,5 @@
+export default function open() {
+  return {
+    name: 'piggy-open',
+  };
+}