nothing-browser 0.1.2 → 0.1.4

package/piggy/client/{index.ts → index.js}

@@ -1,5 +1,5 @@
-//piggy/client/index.ts 
-import { connect, type Socket } from "net";
+// piggy/client/index.js
+import { connect } from "net";
 import { writeFileSync, mkdirSync } from "fs";
 import { dirname } from "path";
 import { platform } from "os";
@@ -9,30 +9,18 @@ const DEFAULT_SOCKET_PATH = platform() === "win32"
   ? "\\\\.\\pipe\\piggy"
   : "/tmp/piggy";
 
-// ── Transport interface ────────────────────────────────────────────────────────
-
-interface Transport {
-  send(data: string): void;
-  on(event: "data", handler: (chunk: string) => void): void;
-  on(event: "error", handler: (e: Error) => void): void;
-  on(event: "close", handler: () => void): void;
-  destroy(): void;
-}
-
 // ── Socket transport ───────────────────────────────────────────────────────────
 
-class SocketTransport implements Transport {
-  private sock: Socket;
-
-  constructor(sock: Socket) {
+class SocketTransport {
+  constructor(sock) {
     this.sock = sock;
   }
 
-  send(data: string) {
+  send(data) {
     this.sock.write(data);
   }
 
-  on(event: string, handler: any) {
+  on(event, handler) {
     this.sock.on(event, handler);
   }
 
@@ -43,26 +31,23 @@ class SocketTransport implements Transport {
 
 // ── HTTP transport ─────────────────────────────────────────────────────────────
 
-class HttpTransport implements Transport {
-  private host: string;
-  private key: string;
-  private dataHandlers: ((chunk: string) => void)[] = [];
-  private errorHandlers: ((e: Error) => void)[] = [];
-  private closeHandlers: (() => void)[] = [];
-  private _destroyed = false;
-
-  constructor(host: string, key: string) {
+class HttpTransport {
+  constructor(host, key) {
     this.host = host.replace(/\/$/, "");
     this.key = key;
+    this.dataHandlers = [];
+    this.errorHandlers = [];
+    this.closeHandlers = [];
+    this._destroyed = false;
   }
 
-  on(event: string, handler: any) {
+  on(event, handler) {
     if (event === "data")  this.dataHandlers.push(handler);
     if (event === "error") this.errorHandlers.push(handler);
     if (event === "close") this.closeHandlers.push(handler);
   }
 
-  send(data: string) {
+  send(data) {
     if (this._destroyed) return;
 
     fetch(this.host, {
@@ -87,7 +72,7 @@ class HttpTransport implements Transport {
           this.dataHandlers.forEach(h => h(line + "\n"));
         }
       })
-      .catch((e: Error) => {
+      .catch((e) => {
         if (!this._destroyed) {
           this.errorHandlers.forEach(h => h(e));
         }
@@ -103,38 +88,30 @@ class HttpTransport implements Transport {
 // ── PiggyClient ────────────────────────────────────────────────────────────────
 
 export class PiggyClient {
-  private socketPath: string;
-  private httpHost: string | null = null;
-  private httpKey: string | null = null;
-  private transport: Transport | null = null;
-  private reqId = 0;
-  private pending = new Map<string, { resolve: (v: any) => void; reject: (e: Error) => void }>();
-  private buf = "";
-  private eventHandlers = new Map<string, Map<string, (data: any) => Promise<any>>>();
-  private globalEventHandlers = new Map<string, Set<(data: any) => void>>();
-
-  constructor(socketPath?: string);
-  constructor(opts: { host: string; key: string });
-
-  constructor(arg?: string | { host: string; key: string }) {
+  constructor(arg) {
     if (arg && typeof arg === "object") {
       this.socketPath = "";
       this.httpHost = arg.host.replace(/\/$/, "");
       this.httpKey = arg.key;
     } else {
-      this.socketPath = (arg as string | undefined) ?? DEFAULT_SOCKET_PATH;
+      this.socketPath = arg ?? DEFAULT_SOCKET_PATH;
     }
+    this.reqId = 0;
+    this.pending = new Map();
+    this.buf = "";
+    this.eventHandlers = new Map();
+    this.globalEventHandlers = new Map();
     this.eventHandlers.set("default", new Map());
   }
 
   // ── Connect ───────────────────────────────────────────────────────────────
 
-  connect(): Promise<void> {
+  connect() {
     if (this.httpHost) return this._connectHttp();
     return this._connectSocket();
   }
 
-  private _connectSocket(): Promise<void> {
+  _connectSocket() {
     return new Promise((resolve, reject) => {
       logger.info(`Connecting to socket: ${this.socketPath}`);
       const sock = connect(this.socketPath);
@@ -155,35 +132,35 @@ export class PiggyClient {
     });
   }
 
-  private async _connectHttp(): Promise<void> {
+  async _connectHttp() {
     logger.info(`Connecting to Piggy server (HTTP): ${this.httpHost}`);
     try {
-      const res = await fetch(this.httpHost!, {
+      const res = await fetch(this.httpHost, {
         method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "X-Piggy-Key": this.httpKey!,
+          "X-Piggy-Key": this.httpKey,
         },
         body: "hello",
       });
       if (res.status === 401) {
         throw new Error("Unauthorized — invalid X-Piggy-Key");
       }
-      this.transport = new HttpTransport(this.httpHost!, this.httpKey!);
+      this.transport = new HttpTransport(this.httpHost, this.httpKey);
       this._wireTransport();
       logger.success(`Connected to Piggy server (HTTP): ${this.httpHost}`);
-    } catch (e: any) {
+    } catch (e) {
       throw new Error(`Failed to connect to Piggy HTTP server: ${e.message}`);
     }
   }
 
-  private _wireTransport() {
+  _wireTransport() {
     if (!this.transport) return;
 
-    this.transport.on("data", (chunk: string) => {
+    this.transport.on("data", (chunk) => {
       this.buf += chunk;
       const lines = this.buf.split("\n");
-      this.buf = lines.pop()!;
+      this.buf = lines.pop();
 
       for (const line of lines) {
         if (!line.trim()) continue;
@@ -206,7 +183,7 @@ export class PiggyClient {
       }
     });
 
-    this.transport.on("error", (e: Error) => {
+    this.transport.on("error", (e) => {
       for (const p of this.pending.values()) p.reject(e);
       this.pending.clear();
     });
@@ -219,7 +196,7 @@ export class PiggyClient {
 
   // ── Event handling ────────────────────────────────────────────────────────
 
-  private handleEvent(event: any) {
+  handleEvent(event) {
     if (event.event === "exposed_call") {
       const { tabId, name, callId, data } = event;
       const effectiveTabId = tabId || "default";
@@ -227,7 +204,7 @@ export class PiggyClient {
       const handler = handlers?.get(name);
 
       if (handler) {
-        let parsedData: any;
+        let parsedData;
         try {
           parsedData = JSON.parse(data || "null");
         } catch {
@@ -299,12 +276,12 @@ export class PiggyClient {
     }
   }
 
-  onEvent(eventName: string, tabId: string, handler: (data: any) => void): () => void {
+  onEvent(eventName, tabId, handler) {
     const key = `${eventName}:${tabId}`;
     if (!this.globalEventHandlers.has(key)) {
       this.globalEventHandlers.set(key, new Set());
     }
-    this.globalEventHandlers.get(key)!.add(handler);
+    this.globalEventHandlers.get(key).add(handler);
     return () => this.globalEventHandlers.get(key)?.delete(handler);
   }
 
@@ -315,7 +292,7 @@ export class PiggyClient {
 
   // ── Core send ─────────────────────────────────────────────────────────────
 
-  send<T = any>(cmd: string, payload: Record<string, any> = {}): Promise<T> {
+  send(cmd, payload = {}) {
     return new Promise((resolve, reject) => {
       if (!this.transport) return reject(new Error("Not connected"));
       const id = String(++this.reqId);
@@ -325,123 +302,123 @@ export class PiggyClient {
   }
 
   // ── 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", {}); }
+  async newTab() { return this.send("tab.new", {}); }
+  async closeTab(tabId) { await this.send("tab.close", { tabId }); }
+  async listTabs() { return this.send("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 }); }
+  async navigate(url, tabId = "default") { await this.send("navigate", { url, tabId }); }
+  async reload(tabId = "default") { await this.send("reload", { tabId }); }
+  async goBack(tabId = "default") { await this.send("go.back", { tabId }); }
+  async goForward(tabId = "default") { 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 }); }
+  async getTitle(tabId = "default") { return this.send("page.title", { tabId }); }
+  async getUrl(tabId = "default") { return this.send("page.url", { tabId }); }
+  async content(tabId = "default") { return this.send("page.content", { tabId }); }
 
   // ── Eval / JS ─────────────────────────────────────────────────────────────
-  async evaluate(js: string, tabId = "default"): Promise<any> { return this.send("evaluate", { js, tabId }); }
-  async addInitScript(js: string, tabId = "default"): Promise<void> { await this.send("addInitScript", { js, tabId }); }
+  async evaluate(js, tabId = "default") { return this.send("evaluate", { js, tabId }); }
+  async addInitScript(js, tabId = "default") { await this.send("addInitScript", { 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 }); }
+  async click(selector, tabId = "default") { return this.send("click", { selector, tabId }); }
+  async doubleClick(selector, tabId = "default") { return this.send("dblclick", { selector, tabId }); }
+  async hover(selector, tabId = "default") { return this.send("hover", { selector, tabId }); }
+  async type(selector, text, tabId = "default") { return this.send("type", { selector, text, tabId }); }
+  async select(selector, value, tabId = "default") { return this.send("select", { selector, value, tabId }); }
+  async keyPress(key, tabId = "default") { return this.send("keyboard.press", { key, tabId }); }
+  async keyCombo(combo, tabId = "default") { return this.send("keyboard.combo", { combo, tabId }); }
+  async mouseMove(x, y, tabId = "default") { return this.send("mouse.move", { x, y, tabId }); }
+  async mouseDrag(from, to, tabId = "default") { return this.send("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 }); }
+  async scrollTo(selector, tabId = "default") { return this.send("scroll.to", { selector, tabId }); }
+  async scrollBy(px, tabId = "default") { return this.send("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[]> {
+  async fetchText(query, tabId = "default") { return this.send("fetch.text", { query, tabId }); }
+  async fetchLinks(query, tabId = "default") {
     if (query === "a" || query === "body") {
-      const result = await this.send<string[]>("fetch.links.all", { tabId });
+      const result = await this.send("fetch.links.all", { tabId });
       return Array.isArray(result) ? result : [];
     }
-    const result = await this.send<string[]>("fetch.links", { query, tabId });
+    const result = await this.send("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 });
+  async fetchImages(query, tabId = "default") {
+    const result = await this.send("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 }); }
+  async searchCss(query, tabId = "default") { return this.send("search.css", { query, tabId }); }
+  async searchId(query, tabId = "default") { 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 }); }
+  async waitForSelector(selector, timeout = 30000, tabId = "default") { await this.send("wait.selector", { selector, timeout, tabId }); }
+  async waitForNavigation(tabId = "default") { await this.send("wait.navigation", { tabId }); }
+  async waitForResponse(urlPattern, timeout = 30000, tabId = "default") { await this.send("wait.response", { url: urlPattern, timeout, tabId }); }
 
   // ── Screenshot / PDF ──────────────────────────────────────────────────────
-  async screenshot(filePath?: string, tabId = "default"): Promise<string> {
-    const b64 = await this.send<string>("screenshot", { tabId });
+  async screenshot(filePath, tabId = "default") {
+    const b64 = await this.send("screenshot", { tabId });
     if (filePath) { mkdirSync(dirname(filePath), { recursive: true }); writeFileSync(filePath, Buffer.from(b64, "base64")); }
     return filePath ?? b64;
   }
-  async pdf(filePath?: string, tabId = "default"): Promise<string> {
-    const b64 = await this.send<string>("pdf", { tabId });
+  async pdf(filePath, tabId = "default") {
+    const b64 = await this.send("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 }); }
+  async blockImages(tabId = "default") { await this.send("intercept.block.images", { tabId }); }
+  async unblockImages(tabId = "default") { 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, domain = "", tabId = "default"): Promise<any> { return this.send("cookie.get", { name, domain, tabId }); }
-  async deleteCookie(name: string, domain: string, tabId = "default"): Promise<void> { await this.send("cookie.delete", { name, domain, tabId }); }
-  async listCookies(domain = "", tabId = "default"): Promise<any[]> { return this.send<any[]>("cookie.list", { domain, tabId }); }
+  async setCookie(name, value, domain, path = "/", tabId = "default") { await this.send("cookie.set", { name, value, domain, path, tabId }); }
+  async getCookie(name, domain = "", tabId = "default") { return this.send("cookie.get", { name, domain, tabId }); }
+  async deleteCookie(name, domain, tabId = "default") { await this.send("cookie.delete", { name, domain, tabId }); }
+  async listCookies(domain = "", tabId = "default") { return this.send("cookie.list", { domain, tabId }); }
 
   // ── Interception ──────────────────────────────────────────────────────────
-  async addInterceptRule(action: "block" | "redirect" | "modifyHeaders", pattern: string, options: { redirectUrl?: string; headers?: Record<string, string> } = {}, tabId = "default"): Promise<void> {
+  async addInterceptRule(action, pattern, options = {}, tabId = "default") {
     await this.send("intercept.rule.add", { action, pattern, ...options, tabId });
   }
-  async clearInterceptRules(tabId = "default"): Promise<void> { await this.send("intercept.rule.clear", { tabId }); }
+  async clearInterceptRules(tabId = "default") { 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 }); }
+  async captureStart(tabId = "default") { await this.send("capture.start", { tabId }); }
+  async captureStop(tabId = "default") { await this.send("capture.stop", { tabId }); }
+  async captureRequests(tabId = "default") { return this.send("capture.requests", { tabId }); }
+  async captureWs(tabId = "default") { return this.send("capture.ws", { tabId }); }
+  async captureCookies(tabId = "default") { return this.send("capture.cookies", { tabId }); }
+  async captureStorage(tabId = "default") { return this.send("capture.storage", { tabId }); }
+  async captureClear(tabId = "default") { 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 }); }
-
-  async sessionWsSave(enabled = true): Promise<void> { await this.send("session.ws.save", { enabled }); }
-  async sessionPingsSave(enabled = true): Promise<void> { await this.send("session.pings.save", { enabled }); }
-  async sessionPaths(): Promise<{ workDir: string; cookies: string; profile: string; ws: string; pings: string; }> { return this.send("session.paths", {}); }
-  async sessionCookiesPath(): Promise<string> { return this.send("session.cookies.path", {}); }
-  async sessionProfilePath(): Promise<string> { return this.send("session.profile.path", {}); }
-  async sessionWsPath(): Promise<string> { return this.send("session.ws.path", {}); }
-  async sessionPingsPath(): Promise<string> { return this.send("session.pings.path", {}); }
-  async sessionReload(): Promise<void> { await this.send("session.reload", {}); }
+  async sessionExport(tabId = "default") { return this.send("session.export", { tabId }); }
+  async sessionImport(data, tabId = "default") { await this.send("session.import", { data, tabId }); }
+
+  async sessionWsSave(enabled = true) { await this.send("session.ws.save", { enabled }); }
+  async sessionPingsSave(enabled = true) { await this.send("session.pings.save", { enabled }); }
+  async sessionPaths() { return this.send("session.paths", {}); }
+  async sessionCookiesPath() { return this.send("session.cookies.path", {}); }
+  async sessionProfilePath() { return this.send("session.profile.path", {}); }
+  async sessionWsPath() { return this.send("session.ws.path", {}); }
+  async sessionPingsPath() { return this.send("session.pings.path", {}); }
+  async sessionReload() { await this.send("session.reload", {}); }
 
   // ── Expose Function ───────────────────────────────────────────────────────
-  async exposeFunction(name: string, handler: (data: any) => Promise<any> | any, tabId = "default"): Promise<void> {
+  async exposeFunction(name, handler, tabId = "default") {
     if (!this.eventHandlers.has(tabId)) this.eventHandlers.set(tabId, new Map());
-    this.eventHandlers.get(tabId)!.set(name, async (data: any) => {
+    this.eventHandlers.get(tabId).set(name, async (data) => {
       try {
         const result = await handler(data);
         if (result && typeof result === "object" && ("success" in result || "error" in result)) return result;
         return { success: true, result };
-      } catch (err: any) {
+      } catch (err) {
         return { success: false, error: err.message || String(err) };
       }
     });
@@ -449,42 +426,44 @@ export class PiggyClient {
     logger.success(`[${tabId}] exposed function: ${name}`);
   }
 
-  async unexposeFunction(name: string, tabId = "default"): Promise<void> {
+  async unexposeFunction(name, tabId = "default") {
     const handlers = this.eventHandlers.get(tabId);
     if (handlers) handlers.delete(name);
     logger.info(`[${tabId}] unexposed function: ${name}`);
   }
 
-  async clearExposedFunctions(tabId = "default"): Promise<void> {
+  async clearExposedFunctions(tabId = "default") {
     this.eventHandlers.set(tabId, new Map());
     logger.info(`[${tabId}] cleared all exposed functions`);
   }
 
   // ── Proxy ─────────────────────────────────────────────────────────────────
-  async proxyLoad(path: string): Promise<void> { await this.send("proxy.load", { path }); }
-  async proxyFetch(url: string): Promise<void> { await this.send("proxy.fetch", { url }); }
-  async proxyOvpn(path: string): Promise<void> { await this.send("proxy.ovpn", { path }); }
-
-  async proxySet(opts: {
-    host?: string; port?: number;
-    type?: "http" | "https" | "socks5" | "socks4";
-    user?: string; pass?: string; proxy?: string;
-  }): Promise<void> { await this.send("proxy.set", opts as Record<string, any>); }
-
-  async proxyTest(): Promise<void> { await this.send("proxy.test", {}); }
-  async proxyTestStop(): Promise<void> { await this.send("proxy.test.stop", {}); }
-  async proxyNext(): Promise<void> { await this.send("proxy.next", {}); }
-  async proxyDisable(): Promise<void> { await this.send("proxy.disable", {}); }
-  async proxyEnable(): Promise<void> { await this.send("proxy.enable", {}); }
-
-  async proxyCurrent(): Promise<{ host: string; port: number; type: string; user?: string; alive: boolean; latencyMs?: number; }> { return this.send("proxy.current", {}); }
-  async proxyStats(): Promise<{ total: number; alive: number; dead: number; index: number; checking: boolean; }> { return this.send("proxy.stats", {}); }
-  async proxyList(limit?: number): Promise<{ host: string; port: number; type: string; alive: boolean; latencyMs?: number; }[]> { return this.send("proxy.list", limit !== undefined ? { limit } : {}); }
-  async proxyRotation(mode: "none" | "timed" | "perrequest", interval?: number): Promise<void> { await this.send("proxy.rotation", { mode, ...(interval !== undefined ? { interval } : {}) }); }
-  async proxyConfig(opts: { skipDead?: boolean; autoCheck?: boolean }): Promise<void> { await this.send("proxy.config", opts as Record<string, any>); }
-  async proxySave(path: string, filter: "alive" | "dead" | "all" = "all"): Promise<void> { await this.send("proxy.save", { path, filter }); }
-
-  onProxyEvent(event: string, handler: (data: any) => void): () => void {
+  async proxyLoad(path) { await this.send("proxy.load", { path }); }
+  async proxyFetch(url) { await this.send("proxy.fetch", { url }); }
+  async proxyOvpn(path) { await this.send("proxy.ovpn", { path }); }
+
+  async proxySet(opts) {
+    await this.send("proxy.set", opts);
+  }
+
+  async proxyTest() { await this.send("proxy.test", {}); }
+  async proxyTestStop() { await this.send("proxy.test.stop", {}); }
+  async proxyNext() { await this.send("proxy.next", {}); }
+  async proxyDisable() { await this.send("proxy.disable", {}); }
+  async proxyEnable() { await this.send("proxy.enable", {}); }
+
+  async proxyCurrent() { return this.send("proxy.current", {}); }
+  async proxyStats() { return this.send("proxy.stats", {}); }
+  async proxyList(limit) { return this.send("proxy.list", limit !== undefined ? { limit } : {}); }
+  async proxyRotation(mode, interval) {
+    await this.send("proxy.rotation", { mode, ...(interval !== undefined ? { interval } : {}) });
+  }
+  async proxyConfig(opts) {
+    await this.send("proxy.config", opts);
+  }
+  async proxySave(path, filter = "all") { await this.send("proxy.save", { path, filter }); }
+
+  onProxyEvent(event, handler) {
     return this.onEvent(event, "*", handler);
   }
 }

package/piggy/dialog/{index.ts → index.js}

@@ -1,53 +1,37 @@
-// piggy/dialog/index.ts
-import { PiggyClient } from "../client";
-import logger from "../logger";
-
-export interface DialogState {
-  pending: boolean;
-  type: string;         // "alert" | "confirm" | "prompt" | "beforeunload"
-  message: string;
-  defaultValue: string;
-}
-
-// Event data from C++ (doesn't include pending)
-interface DialogEventData {
-  dialogType: string;
-  message: string;
-  defaultValue: string;
-  tabId: string;
-}
+// piggy/dialog/index.js
+import { PiggyClient } from "../client.js";
+import logger from "../logger.js";
 
 export class DialogClient {
-  constructor(private client: PiggyClient) {}
+  constructor(client) {
+    this.client = client;
+  }
 
-  accept(tabId = "default", text?: string): Promise<void> {
+  accept(tabId = "default", text) {
     return this.client.send("dialog.accept", { tabId, ...(text !== undefined ? { text } : {}) });
   }
 
-  dismiss(tabId = "default"): Promise<void> {
+  dismiss(tabId = "default") {
     return this.client.send("dialog.dismiss", { tabId });
   }
 
-  status(tabId = "default"): Promise<DialogState> {
+  status(tabId = "default") {
     return this.client.send("dialog.status", { tabId });
   }
 
-  setAutoAction(tabId = "default", action: "accept" | "dismiss" | ""): Promise<void> {
+  setAutoAction(tabId = "default", action) {
     return this.client.send("dialog.onDialog", { tabId, action });
   }
 
-  upload(selector: string, filePath: string, tabId = "default"): Promise<void> {
+  upload(selector, filePath, tabId = "default") {
     return this.client.send("upload", { selector, path: filePath, tabId });
   }
 
-  onDialog(
-    tabId: string,
-    handler: (data: DialogEventData) => void
-  ): () => void {
+  onDialog(tabId, handler) {
     return this.client.onEvent("dialog", tabId, handler);
   }
 
-  waitAndAccept(tabId = "default", text?: string, timeoutMs = 30_000): Promise<DialogEventData> {
+  waitAndAccept(tabId = "default", text, timeoutMs = 30_000) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         unsub();
@@ -63,7 +47,7 @@ export class DialogClient {
     });
   }
 
-  waitAndDismiss(tabId = "default", timeoutMs = 30_000): Promise<DialogEventData> {
+  waitAndDismiss(tabId = "default", timeoutMs = 30_000) {
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         unsub();
@@ -80,6 +64,6 @@ export class DialogClient {
   }
 }
 
-export function createDialogAPI(client: PiggyClient): DialogClient {
+export function createDialogAPI(client) {
   return new DialogClient(client);
 }