nothing-browser 0.0.19 → 0.0.20

package/piggy/launch/spawn.ts

@@ -1,165 +1,165 @@
-// piggy/launch/spawn.ts
-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";
-
-let activeProcess: any = null;
-const extraProcesses: any[] = [];
-
-// Runtime detection without importing "bun" at build time
-const isBun = typeof (globalThis as any).Bun !== 'undefined';
-
-export function killAllBrowsers(): void {
-  try {
-    logger.info('Cleaning up existing browser processes...');
-    
-    if (platform() === 'win32') {
-      execSync('taskkill /F /IM nothing-browser-headless.exe 2>nul || true', { stdio: 'ignore' });
-      execSync('taskkill /F /IM nothing-browser-headful.exe 2>nul || true', { stdio: 'ignore' });
-      execSync('taskkill /F /IM QtWebEngineProcess.exe 2>nul || true', { stdio: 'ignore' });
-    } else {
-      execSync('pkill -f nothing-browser-headless 2>/dev/null || true', { stdio: 'ignore' });
-      execSync('pkill -f nothing-browser-headful 2>/dev/null || true', { stdio: 'ignore' });
-      execSync('pkill -f QtWebEngineProcess 2>/dev/null || true', { stdio: 'ignore' });
-      execSync('rm -f /tmp/piggy', { stdio: 'ignore' });
-    }
-  } catch {
-    // no processes to kill
-  }
-}
-
-export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<string> {
-  killAllBrowsers();
-  await new Promise(resolve => setTimeout(resolve, 500));
-
-  const binaryPath = detectBinary(mode);
-  if (!binaryPath) {
-    throw new Error(`Binary not found (${mode}). Cannot launch.`);
-  }
-
-  logger.info(`Spawning Nothing Browser (${mode}) from: ${binaryPath}`);
-
-  if (isBun) {
-    // Bun runtime - use Bun.spawn
-    const Bun = (globalThis as any).Bun;
-    activeProcess = Bun.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) {
-          logger.debug(`[Browser] ${new TextDecoder().decode(value)}`);
-          read();
-        }
-      };
-      read();
-    }
-
-    activeProcess.exited.then((code: number | null) => {
-      logger.warn(`Browser process exited with code: ${code}`);
-      activeProcess = null;
-    });
-  } else {
-    // Node.js runtime
-    activeProcess = nodeSpawn(binaryPath, [], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: process.env,
-    });
-
-    if (activeProcess.stdout) {
-      activeProcess.stdout.on('data', (data: Buffer) => {
-        logger.debug(`[Browser] ${data.toString()}`);
-      });
-    }
-
-    if (activeProcess.stderr) {
-      activeProcess.stderr.on('data', (data: Buffer) => {
-        logger.debug(`[Browser Error] ${data.toString()}`);
-      });
-    }
-
-    activeProcess.on('exit', (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 (${mode})`);
-  } else {
-    logger.error('Browser started but exited immediately');
-  }
-
-  return binaryPath;
-}
-
-export async function spawnBrowserOnSocket(
-  socketName: string,
-  mode: BinaryMode = 'headless'
-): Promise<void> {
-  const binaryPath = detectBinary(mode);
-  if (!binaryPath) {
-    throw new Error(`Binary not found (${mode}). Cannot launch.`);
-  }
-
-  logger.info(`Spawning browser (${mode}) on socket: ${socketName}`);
-
-  if (isBun) {
-    // Bun runtime
-    const Bun = (globalThis as any).Bun;
-    const proc = Bun.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}`);
-    });
-  } else {
-    // Node.js runtime
-    const proc = nodeSpawn(binaryPath, [], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: { ...process.env, PIGGY_SOCKET: socketName },
-    });
-
-    extraProcesses.push(proc);
-
-    proc.on('exit', (code: number | null) => {
-      logger.warn(`Browser on socket ${socketName} exited with code: ${code}`);
-    });
-  }
-
-  await new Promise(resolve => setTimeout(resolve, 1000));
-  logger.success(`Browser spawned (${mode}) on socket: ${socketName}`);
-}
-
-export function killBrowser(): void {
-  if (activeProcess) {
-    logger.info('Killing browser process...');
-    if (isBun) {
-      activeProcess.kill();
-    } else {
-      activeProcess.kill('SIGTERM');
-    }
-    activeProcess = null;
-  }
-  
-  for (const proc of extraProcesses) {
-    if (isBun) {
-      proc.kill();
-    } else {
-      proc.kill('SIGTERM');
-    }
-  }
-  extraProcesses.length = 0;
+// piggy/launch/spawn.ts
+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";
+
+let activeProcess: any = null;
+const extraProcesses: any[] = [];
+
+// Runtime detection without importing "bun" at build time
+const isBun = typeof (globalThis as any).Bun !== 'undefined';
+
+export function killAllBrowsers(): void {
+  try {
+    logger.info('Cleaning up existing browser processes...');
+    
+    if (platform() === 'win32') {
+      execSync('taskkill /F /IM nothing-browser-headless.exe 2>nul || true', { stdio: 'ignore' });
+      execSync('taskkill /F /IM nothing-browser-headful.exe 2>nul || true', { stdio: 'ignore' });
+      execSync('taskkill /F /IM QtWebEngineProcess.exe 2>nul || true', { stdio: 'ignore' });
+    } else {
+      execSync('pkill -f nothing-browser-headless 2>/dev/null || true', { stdio: 'ignore' });
+      execSync('pkill -f nothing-browser-headful 2>/dev/null || true', { stdio: 'ignore' });
+      execSync('pkill -f QtWebEngineProcess 2>/dev/null || true', { stdio: 'ignore' });
+      execSync('rm -f /tmp/piggy', { stdio: 'ignore' });
+    }
+  } catch {
+    // no processes to kill
+  }
+}
+
+export async function spawnBrowser(mode: BinaryMode = 'headless'): Promise<string> {
+  killAllBrowsers();
+  await new Promise(resolve => setTimeout(resolve, 500));
+
+  const binaryPath = detectBinary(mode);
+  if (!binaryPath) {
+    throw new Error(`Binary not found (${mode}). Cannot launch.`);
+  }
+
+  logger.info(`Spawning Nothing Browser (${mode}) from: ${binaryPath}`);
+
+  if (isBun) {
+    // Bun runtime - use Bun.spawn
+    const Bun = (globalThis as any).Bun;
+    activeProcess = Bun.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) {
+          logger.debug(`[Browser] ${new TextDecoder().decode(value)}`);
+          read();
+        }
+      };
+      read();
+    }
+
+    activeProcess.exited.then((code: number | null) => {
+      logger.warn(`Browser process exited with code: ${code}`);
+      activeProcess = null;
+    });
+  } else {
+    // Node.js runtime
+    activeProcess = nodeSpawn(binaryPath, [], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    if (activeProcess.stdout) {
+      activeProcess.stdout.on('data', (data: Buffer) => {
+        logger.debug(`[Browser] ${data.toString()}`);
+      });
+    }
+
+    if (activeProcess.stderr) {
+      activeProcess.stderr.on('data', (data: Buffer) => {
+        logger.debug(`[Browser Error] ${data.toString()}`);
+      });
+    }
+
+    activeProcess.on('exit', (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 (${mode})`);
+  } else {
+    logger.error('Browser started but exited immediately');
+  }
+
+  return binaryPath;
+}
+
+export async function spawnBrowserOnSocket(
+  socketName: string,
+  mode: BinaryMode = 'headless'
+): Promise<void> {
+  const binaryPath = detectBinary(mode);
+  if (!binaryPath) {
+    throw new Error(`Binary not found (${mode}). Cannot launch.`);
+  }
+
+  logger.info(`Spawning browser (${mode}) on socket: ${socketName}`);
+
+  if (isBun) {
+    // Bun runtime
+    const Bun = (globalThis as any).Bun;
+    const proc = Bun.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}`);
+    });
+  } else {
+    // Node.js runtime
+    const proc = nodeSpawn(binaryPath, [], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, PIGGY_SOCKET: socketName },
+    });
+
+    extraProcesses.push(proc);
+
+    proc.on('exit', (code: number | null) => {
+      logger.warn(`Browser on socket ${socketName} exited with code: ${code}`);
+    });
+  }
+
+  await new Promise(resolve => setTimeout(resolve, 1000));
+  logger.success(`Browser spawned (${mode}) on socket: ${socketName}`);
+}
+
+export function killBrowser(): void {
+  if (activeProcess) {
+    logger.info('Killing browser process...');
+    if (isBun) {
+      activeProcess.kill();
+    } else {
+      activeProcess.kill('SIGTERM');
+    }
+    activeProcess = null;
+  }
+  
+  for (const proc of extraProcesses) {
+    if (isBun) {
+      proc.kill();
+    } else {
+      proc.kill('SIGTERM');
+    }
+  }
+  extraProcesses.length = 0;
 }

package/piggy/logger/index.d.ts

@@ -1,3 +1,3 @@
-declare const logger: import("ernest-logger").Logger;
-export default logger;
+declare const logger: import("ernest-logger").Logger;
+export default logger;
 //# sourceMappingURL=index.d.ts.map

package/piggy/logger/index.ts

@@ -1,59 +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 ℹ️
-
+
+//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.d.ts

@@ -1,4 +1,4 @@
-export default function open(): {
-    name: string;
-};
+export default function open(): {
+    name: string;
+};
 //# sourceMappingURL=index.d.ts.map

package/piggy/open/index.ts

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

package/piggy/pool/index.d.ts

@@ -1,12 +1,12 @@
-// piggy/pool/index.d.ts
-import { PiggyClient } from "../client";
-
-export declare class TabPool {
-  constructor(client: PiggyClient, size: number, seedUrl: string, name: string);
-  init(): Promise<void>;
-  acquire(): Promise<string>;
-  release(tabId: string): void;
-  withTab<T>(fn: (tabId: string) => Promise<T>): Promise<T>;
-  close(): Promise<void>;
-  get stats(): { idle: number; busy: number; queued: number; total: number };
+// piggy/pool/index.d.ts
+import { PiggyClient } from "../client";
+
+export declare class TabPool {
+  constructor(client: PiggyClient, size: number, seedUrl: string, name: string);
+  init(): Promise<void>;
+  acquire(): Promise<string>;
+  release(tabId: string): void;
+  withTab<T>(fn: (tabId: string) => Promise<T>): Promise<T>;
+  close(): Promise<void>;
+  get stats(): { idle: number; busy: number; queued: number; total: number };
 }

package/piggy/pool/index.ts

@@ -1,75 +1,75 @@
-// piggy/pool/index.ts
-import { PiggyClient } from "../client";
-import logger from "../logger";
-
-export class TabPool {
-  private idle: string[] = [];
-  private busy = new Set<string>();
-  private queue: ((tabId: string) => void)[] = [];
-
-  constructor(
-    private client: PiggyClient,
-    private size: number,
-    private seedUrl: string,
-    private name: string
-  ) {}
-
-  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(): Promise<string> {
-    return new Promise(resolve => {
-      const tabId = this.idle.pop();
-      if (tabId) {
-        this.busy.add(tabId);
-        resolve(tabId);
-      } else {
-        this.queue.push(resolve);
-      }
-    });
-  }
-
-  release(tabId: string) {
-    this.busy.delete(tabId);
-    const next = this.queue.shift();
-    if (next) {
-      this.busy.add(tabId);
-      next(tabId);
-    } else {
-      this.idle.push(tabId);
-    }
-  }
-
-  async withTab<T>(fn: (tabId: string) => Promise<T>): Promise<T> {
-    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,
-    };
-  }
+// piggy/pool/index.ts
+import { PiggyClient } from "../client";
+import logger from "../logger";
+
+export class TabPool {
+  private idle: string[] = [];
+  private busy = new Set<string>();
+  private queue: ((tabId: string) => void)[] = [];
+
+  constructor(
+    private client: PiggyClient,
+    private size: number,
+    private seedUrl: string,
+    private name: string
+  ) {}
+
+  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(): Promise<string> {
+    return new Promise(resolve => {
+      const tabId = this.idle.pop();
+      if (tabId) {
+        this.busy.add(tabId);
+        resolve(tabId);
+      } else {
+        this.queue.push(resolve);
+      }
+    });
+  }
+
+  release(tabId: string) {
+    this.busy.delete(tabId);
+    const next = this.queue.shift();
+    if (next) {
+      this.busy.add(tabId);
+      next(tabId);
+    } else {
+      this.idle.push(tabId);
+    }
+  }
+
+  async withTab<T>(fn: (tabId: string) => Promise<T>): Promise<T> {
+    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/register/index.d.ts

@@ -1,7 +1,7 @@
-import { PiggyClient } from "../client";
-export declare let humanMode: boolean;
-export declare function setClient(c: PiggyClient | null): void;
-export declare function setHumanMode(v: boolean): void;
-export declare function createSiteObject(name: string, registeredUrl: string, client: PiggyClient, tabId: string): any;
-export declare function createExposedAPI<T extends Record<string, (data: any) => any>>(site: any, apiName: string, handlers: T): Promise<void>;
+import { PiggyClient } from "../client";
+export declare let humanMode: boolean;
+export declare function setClient(c: PiggyClient | null): void;
+export declare function setHumanMode(v: boolean): void;
+export declare function createSiteObject(name: string, registeredUrl: string, client: PiggyClient, tabId: string): any;
+export declare function createExposedAPI<T extends Record<string, (data: any) => any>>(site: any, apiName: string, handlers: T): Promise<void>;
 //# sourceMappingURL=index.d.ts.map