nothing-browser 0.0.19 → 0.0.20

package/piggy/human/index.d.ts

@@ -1,7 +1,7 @@
-export declare function randomDelay(min: number, max: number): Promise<void>;
-/**
- * Simulates human typing by introducing ~2 random typos and correcting them.
- * Returns an array of { char, isBackspace } actions to replay.
- */
-export declare function humanTypeSequence(text: string): string[];
+export declare function randomDelay(min: number, max: number): Promise<void>;
+/**
+ * Simulates human typing by introducing ~2 random typos and correcting them.
+ * Returns an array of { char, isBackspace } actions to replay.
+ */
+export declare function humanTypeSequence(text: string): string[];
 //# sourceMappingURL=index.d.ts.map

package/piggy/human/index.ts

@@ -1,53 +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;
+// 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/intercept/scripts.d.ts

@@ -1,13 +1,13 @@
-/**
- * Generates a script that short-circuits matching fetch/XHR requests
- * and returns a static fake response — the request never hits the network.
- */
-export declare function buildRespondScript(pattern: string, status: number, contentType: string, body: string): string;
-/**
- * Generates a script that lets the request hit the network, then calls
- * an exposed function with { body, status, headers }.
- * The exposed function returns { body?, status?, headers? } modifications
- * or an empty object {} to pass through unchanged.
- */
-export declare function buildModifyResponseScript(pattern: string, exposedFnName: string): string;
+/**
+ * Generates a script that short-circuits matching fetch/XHR requests
+ * and returns a static fake response — the request never hits the network.
+ */
+export declare function buildRespondScript(pattern: string, status: number, contentType: string, body: string): string;
+/**
+ * Generates a script that lets the request hit the network, then calls
+ * an exposed function with { body, status, headers }.
+ * The exposed function returns { body?, status?, headers? } modifications
+ * or an empty object {} to pass through unchanged.
+ */
+export declare function buildModifyResponseScript(pattern: string, exposedFnName: string): string;
 //# sourceMappingURL=scripts.d.ts.map

package/piggy/intercept/scripts.ts

@@ -1,153 +1,153 @@
-// piggy/intercept/scripts.ts
-// JS injection helpers for intercept.respond and intercept.modifyResponse.
-// Both work purely in the browser's JS layer — no C++ changes needed.
-
-/**
- * Generates a script that short-circuits matching fetch/XHR requests
- * and returns a static fake response — the request never hits the network.
- */
-export function buildRespondScript(
-  pattern: string,
-  status: number,
-  contentType: string,
-  body: string
-): string {
-  const safePattern     = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const safeBody        = body.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
-  const safeContentType = contentType.replace(/'/g, "\\'");
-
-  return `
-(function() {
-  'use strict';
-  if (!window.__PIGGY_RESPOND_RULES__) window.__PIGGY_RESPOND_RULES__ = [];
-  window.__PIGGY_RESPOND_RULES__.push({
-    pattern: '${safePattern}',
-    status: ${status},
-    contentType: '${safeContentType}',
-    body: \`${safeBody}\`
-  });
-
-  function _piggyMatchUrl(url, pattern) {
-    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
-    catch { return url.includes(pattern); }
-  }
-
-  // Only install wrappers once per page
-  if (window.__PIGGY_RESPOND_INSTALLED__) return;
-  window.__PIGGY_RESPOND_INSTALLED__ = true;
-
-  // ── fetch wrapper ──────────────────────────────────────────────────────────
-  const _origFetch = window.fetch;
-  window.fetch = function(input, init) {
-    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
-    const rules = window.__PIGGY_RESPOND_RULES__ || [];
-    for (const rule of rules) {
-      if (_piggyMatchUrl(url, rule.pattern)) {
-        return Promise.resolve(new Response(rule.body, {
-          status: rule.status,
-          headers: { 'Content-Type': rule.contentType }
-        }));
-      }
-    }
-    return _origFetch.apply(this, arguments);
-  };
-
-  // ── XHR wrapper ────────────────────────────────────────────────────────────
-  const _origOpen = XMLHttpRequest.prototype.open;
-  const _origSend = XMLHttpRequest.prototype.send;
-
-  XMLHttpRequest.prototype.open = function(method, url) {
-    this.__piggy_url__ = String(url);
-    return _origOpen.apply(this, arguments);
-  };
-
-  XMLHttpRequest.prototype.send = function() {
-    const url = this.__piggy_url__ || '';
-    const rules = window.__PIGGY_RESPOND_RULES__ || [];
-    for (const rule of rules) {
-      if (_piggyMatchUrl(url, rule.pattern)) {
-        const self = this;
-        Object.defineProperty(self, 'readyState',   { get: () => 4,            configurable: true });
-        Object.defineProperty(self, 'status',       { get: () => rule.status,  configurable: true });
-        Object.defineProperty(self, 'responseText', { get: () => rule.body,    configurable: true });
-        Object.defineProperty(self, 'response',     { get: () => rule.body,    configurable: true });
-        setTimeout(() => {
-          if (typeof self.onreadystatechange === 'function') self.onreadystatechange();
-          self.dispatchEvent(new Event('readystatechange'));
-          self.dispatchEvent(new Event('load'));
-          self.dispatchEvent(new Event('loadend'));
-        }, 0);
-        return;
-      }
-    }
-    return _origSend.apply(this, arguments);
-  };
-})();
-`;
-}
-
-/**
- * Generates a script that lets the request hit the network, then calls
- * an exposed function with { body, status, headers }.
- * The exposed function returns { body?, status?, headers? } modifications
- * or an empty object {} to pass through unchanged.
- */
-export function buildModifyResponseScript(pattern: string, exposedFnName: string): string {
-  const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-  const safeFnName  = exposedFnName.replace(/'/g, "\\'");
-
-  return `
-(function() {
-  'use strict';
-  if (!window.__PIGGY_MODIFY_RULES__) window.__PIGGY_MODIFY_RULES__ = [];
-  window.__PIGGY_MODIFY_RULES__.push({ pattern: '${safePattern}', fn: '${safeFnName}' });
-
-  function _piggyMatchUrl(url, pattern) {
-    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
-    catch { return url.includes(pattern); }
-  }
-
-  // Only install wrappers once per page
-  if (window.__PIGGY_MODIFY_INSTALLED__) return;
-  window.__PIGGY_MODIFY_INSTALLED__ = true;
-
-  const _origFetch = window.fetch;
-  window.fetch = async function(input, init) {
-    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
-    const rules = window.__PIGGY_MODIFY_RULES__ || [];
-
-    let matchedFn = null;
-    for (const rule of rules) {
-      if (_piggyMatchUrl(url, rule.pattern)) { matchedFn = rule.fn; break; }
-    }
-
-    // No match — pass through untouched
-    const resp = await _origFetch.apply(this, arguments);
-    if (!matchedFn) return resp;
-
-    try {
-      const bodyText = await resp.clone().text();
-      const headers  = {};
-      resp.headers.forEach((v, k) => { headers[k] = v; });
-
-      const handlerFn = window[matchedFn];
-      if (typeof handlerFn !== 'function') return resp;
-
-      // Call Node.js handler via exposeFunction bridge
-      const mod = await handlerFn({ body: bodyText, status: resp.status, headers });
-      if (!mod || typeof mod !== 'object' || Object.keys(mod).length === 0) return resp;
-
-      return new Response(
-        mod.body    !== undefined ? mod.body    : bodyText,
-        {
-          status:  mod.status  !== undefined ? mod.status  : resp.status,
-          headers: mod.headers !== undefined ? mod.headers : headers,
-        }
-      );
-    } catch {
-      return resp; // On any error, pass through original response
-    }
-  };
-})();
-`;
+// piggy/intercept/scripts.ts
+// JS injection helpers for intercept.respond and intercept.modifyResponse.
+// Both work purely in the browser's JS layer — no C++ changes needed.
+
+/**
+ * Generates a script that short-circuits matching fetch/XHR requests
+ * and returns a static fake response — the request never hits the network.
+ */
+export function buildRespondScript(
+  pattern: string,
+  status: number,
+  contentType: string,
+  body: string
+): string {
+  const safePattern     = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const safeBody        = body.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  const safeContentType = contentType.replace(/'/g, "\\'");
+
+  return `
+(function() {
+  'use strict';
+  if (!window.__PIGGY_RESPOND_RULES__) window.__PIGGY_RESPOND_RULES__ = [];
+  window.__PIGGY_RESPOND_RULES__.push({
+    pattern: '${safePattern}',
+    status: ${status},
+    contentType: '${safeContentType}',
+    body: \`${safeBody}\`
+  });
+
+  function _piggyMatchUrl(url, pattern) {
+    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
+    catch { return url.includes(pattern); }
+  }
+
+  // Only install wrappers once per page
+  if (window.__PIGGY_RESPOND_INSTALLED__) return;
+  window.__PIGGY_RESPOND_INSTALLED__ = true;
+
+  // ── fetch wrapper ──────────────────────────────────────────────────────────
+  const _origFetch = window.fetch;
+  window.fetch = function(input, init) {
+    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const rules = window.__PIGGY_RESPOND_RULES__ || [];
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) {
+        return Promise.resolve(new Response(rule.body, {
+          status: rule.status,
+          headers: { 'Content-Type': rule.contentType }
+        }));
+      }
+    }
+    return _origFetch.apply(this, arguments);
+  };
+
+  // ── XHR wrapper ────────────────────────────────────────────────────────────
+  const _origOpen = XMLHttpRequest.prototype.open;
+  const _origSend = XMLHttpRequest.prototype.send;
+
+  XMLHttpRequest.prototype.open = function(method, url) {
+    this.__piggy_url__ = String(url);
+    return _origOpen.apply(this, arguments);
+  };
+
+  XMLHttpRequest.prototype.send = function() {
+    const url = this.__piggy_url__ || '';
+    const rules = window.__PIGGY_RESPOND_RULES__ || [];
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) {
+        const self = this;
+        Object.defineProperty(self, 'readyState',   { get: () => 4,            configurable: true });
+        Object.defineProperty(self, 'status',       { get: () => rule.status,  configurable: true });
+        Object.defineProperty(self, 'responseText', { get: () => rule.body,    configurable: true });
+        Object.defineProperty(self, 'response',     { get: () => rule.body,    configurable: true });
+        setTimeout(() => {
+          if (typeof self.onreadystatechange === 'function') self.onreadystatechange();
+          self.dispatchEvent(new Event('readystatechange'));
+          self.dispatchEvent(new Event('load'));
+          self.dispatchEvent(new Event('loadend'));
+        }, 0);
+        return;
+      }
+    }
+    return _origSend.apply(this, arguments);
+  };
+})();
+`;
+}
+
+/**
+ * Generates a script that lets the request hit the network, then calls
+ * an exposed function with { body, status, headers }.
+ * The exposed function returns { body?, status?, headers? } modifications
+ * or an empty object {} to pass through unchanged.
+ */
+export function buildModifyResponseScript(pattern: string, exposedFnName: string): string {
+  const safePattern = pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+  const safeFnName  = exposedFnName.replace(/'/g, "\\'");
+
+  return `
+(function() {
+  'use strict';
+  if (!window.__PIGGY_MODIFY_RULES__) window.__PIGGY_MODIFY_RULES__ = [];
+  window.__PIGGY_MODIFY_RULES__.push({ pattern: '${safePattern}', fn: '${safeFnName}' });
+
+  function _piggyMatchUrl(url, pattern) {
+    try { return url.includes(pattern) || new RegExp(pattern).test(url); }
+    catch { return url.includes(pattern); }
+  }
+
+  // Only install wrappers once per page
+  if (window.__PIGGY_MODIFY_INSTALLED__) return;
+  window.__PIGGY_MODIFY_INSTALLED__ = true;
+
+  const _origFetch = window.fetch;
+  window.fetch = async function(input, init) {
+    const url = typeof input === 'string' ? input : (input?.url ?? String(input));
+    const rules = window.__PIGGY_MODIFY_RULES__ || [];
+
+    let matchedFn = null;
+    for (const rule of rules) {
+      if (_piggyMatchUrl(url, rule.pattern)) { matchedFn = rule.fn; break; }
+    }
+
+    // No match — pass through untouched
+    const resp = await _origFetch.apply(this, arguments);
+    if (!matchedFn) return resp;
+
+    try {
+      const bodyText = await resp.clone().text();
+      const headers  = {};
+      resp.headers.forEach((v, k) => { headers[k] = v; });
+
+      const handlerFn = window[matchedFn];
+      if (typeof handlerFn !== 'function') return resp;
+
+      // Call Node.js handler via exposeFunction bridge
+      const mod = await handlerFn({ body: bodyText, status: resp.status, headers });
+      if (!mod || typeof mod !== 'object' || Object.keys(mod).length === 0) return resp;
+
+      return new Response(
+        mod.body    !== undefined ? mod.body    : bodyText,
+        {
+          status:  mod.status  !== undefined ? mod.status  : resp.status,
+          headers: mod.headers !== undefined ? mod.headers : headers,
+        }
+      );
+    } catch {
+      return resp; // On any error, pass through original response
+    }
+  };
+})();
+`;
 }

package/piggy/launch/detect.d.ts

@@ -1,3 +1,3 @@
-export type BinaryMode = 'headless' | 'headful';
-export declare function detectBinary(mode?: BinaryMode): string | null;
+export type BinaryMode = 'headless' | 'headful';
+export declare function detectBinary(mode?: BinaryMode): string | null;
 //# sourceMappingURL=detect.d.ts.map

package/piggy/launch/detect.ts

@@ -1,52 +1,43 @@
-import { existsSync } from 'fs';
-import { join } from 'path';
-import logger from '../logger';
-
-export type BinaryMode = 'headless' | 'headful' | (string & {});
-
-const BINARY_NAMES: Record<'headless' | 'headful', string> = {
-  headless: 'nothing-browser-headless',
-  headful:  'nothing-browser-headful',
-};
-
-export function detectBinary(mode: BinaryMode = 'headless'): string | null {
-  // If it's an arbitrary path, just verify it exists and return it as-is
-  if (mode !== 'headless' && mode !== 'headful') {
-    if (existsSync(mode)) {
-      logger.success(`Binary found (custom path): ${mode}`);
-      return mode;
-    }
-    logger.error(`❌ Binary not found at custom path: ${mode}`);
-    return null;
-  }
-
-  const cwd = process.cwd();
-const name = BINARY_NAMES[mode as 'headless' | 'headful'];
-
-  // Windows
-  if (process.platform === 'win32') {
-    const p = join(cwd, `${name}.exe`);
-    if (existsSync(p)) {
-      logger.success(`Binary found (${mode}): ${p}`);
-      return p;
-    }
-  }
-
-  // Linux / macOS
-  const p = join(cwd, name);
-  if (existsSync(p)) {
-    logger.success(`Binary found (${mode}): ${p}`);
-    return p;
-  }
-
-  logger.error(`❌ Binary not found in project root: ${name}`);
-  logger.error('');
-  logger.error('Download from:');
-  logger.error('  https://github.com/BunElysiaReact/nothing-browser/releases/');
-  logger.error('');
-  logger.error(`Place in: ${cwd}/${name}${process.platform === 'win32' ? '.exe' : ''}`);
-  if (process.platform !== 'win32') {
-    logger.error(`Then run: chmod +x ${name}`);
-  }
-  return null;
+import { existsSync } from 'fs';
+import { join } from 'path';
+import logger from '../logger';
+
+export type BinaryMode = 'headless' | 'headful';
+
+const BINARY_NAMES: Record<BinaryMode, string> = {
+  headless: 'nothing-browser-headless',
+  headful:  'nothing-browser-headful',
+};
+
+export function detectBinary(mode: BinaryMode = 'headless'): string | null {
+  const cwd = process.cwd();
+  const name = BINARY_NAMES[mode];
+
+  // Windows
+  if (process.platform === 'win32') {
+    const p = join(cwd, `${name}.exe`);
+    if (existsSync(p)) {
+      logger.success(`Binary found (${mode}): ${p}`);
+      return p;
+    }
+  }
+
+  // Linux / macOS
+  const p = join(cwd, name);
+  if (existsSync(p)) {
+    logger.success(`Binary found (${mode}): ${p}`);
+    return p;
+  }
+
+  logger.error(`❌ Binary not found in project root: ${name}`);
+  logger.error('');
+  logger.error('Download from:');
+  logger.error('  https://github.com/BunElysiaReact/nothing-browser/releases/');
+  logger.error('');
+  logger.error(`Place in: ${cwd}/${name}${process.platform === 'win32' ? '.exe' : ''}`);
+  if (process.platform !== 'win32') {
+    logger.error(`Then run: chmod +x ${name}`);
+  }
+
+  return null;
 }

package/piggy/launch/spawn.d.ts

@@ -1,6 +1,6 @@
-import { type BinaryMode } from "./detect";
-export declare function killAllBrowsers(): void;
-export declare function spawnBrowser(mode?: BinaryMode): Promise<string>;
-export declare function spawnBrowserOnSocket(socketName: string, mode?: BinaryMode): Promise<void>;
-export declare function killBrowser(): void;
+import { type BinaryMode } from "./detect";
+export declare function killAllBrowsers(): void;
+export declare function spawnBrowser(mode?: BinaryMode): Promise<string>;
+export declare function spawnBrowserOnSocket(socketName: string, mode?: BinaryMode): Promise<void>;
+export declare function killBrowser(): void;
 //# sourceMappingURL=spawn.d.ts.map