@ceki/sdk 1.9.0

package/dist/index.js

@@ -0,0 +1,1993 @@
+// src/client.ts
+import WebSocket from "ws";
+
+// src/config.ts
+var defaults = {
+  apiUrl: "https://api.ceki.me",
+  relayUrl: "wss://browser.ceki.me/ws/agent",
+  chatUrl: "https://chat.ceki.me/api/chat"
+};
+function resolveConfig(opts) {
+  return {
+    apiUrl: opts?.apiUrl ?? process.env.CEKI_API_URL ?? defaults.apiUrl,
+    relayUrl: opts?.relayUrl ?? process.env.CEKI_RELAY_URL ?? defaults.relayUrl,
+    chatUrl: opts?.chatUrl ?? process.env.CEKI_CHAT_URL ?? defaults.chatUrl,
+    basicAuth: opts?.basicAuth ?? (process.env.CEKI_BASIC_AUTH_USER && process.env.CEKI_BASIC_AUTH_PASS ? [process.env.CEKI_BASIC_AUTH_USER, process.env.CEKI_BASIC_AUTH_PASS] : void 0),
+    reconnect: opts?.reconnect ?? true
+  };
+}
+
+// src/errors.ts
+var CekiBrowserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CekiBrowserError";
+  }
+};
+var AuthError = class extends CekiBrowserError {
+  constructor(message = "Authentication failed") {
+    super(message);
+    this.name = "AuthError";
+  }
+};
+var SessionNotFound = class extends CekiBrowserError {
+  constructor(message = "Session not found") {
+    super(message);
+    this.name = "SessionNotFound";
+  }
+};
+var SessionExpired = class extends SessionNotFound {
+  constructor(message = "Session expired") {
+    super(message);
+    this.name = "SessionExpired";
+  }
+};
+var NotOwner = class extends CekiBrowserError {
+  constructor(message = "Not session owner") {
+    super(message);
+    this.name = "NotOwner";
+  }
+};
+var TransportError = class extends CekiBrowserError {
+  constructor(message = "Transport error") {
+    super(message);
+    this.name = "TransportError";
+  }
+};
+var TimeoutError = class extends CekiBrowserError {
+  constructor(message = "Operation timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+var SessionEnded = class extends CekiBrowserError {
+  reason;
+  constructor(reason) {
+    super(`Session ended: ${reason}`);
+    this.name = "SessionEnded";
+    this.reason = reason;
+  }
+};
+var InsufficientFunds = class extends CekiBrowserError {
+  constructor(message = "Insufficient funds") {
+    super(message);
+    this.name = "InsufficientFunds";
+  }
+};
+var RateLimitExceeded = class extends CekiBrowserError {
+  retryAfter;
+  constructor(retryAfter = 0, message = "Rate limit exceeded") {
+    super(message);
+    this.name = "RateLimitExceeded";
+    this.retryAfter = retryAfter;
+  }
+};
+var ConnectionLost = class extends CekiBrowserError {
+  constructor(message = "Connection lost") {
+    super(message);
+    this.name = "ConnectionLost";
+  }
+};
+var ProviderOffline = class extends CekiBrowserError {
+  constructor(message = "Provider offline") {
+    super(message);
+    this.name = "ProviderOffline";
+  }
+};
+var ProviderDisconnected = class extends CekiBrowserError {
+  constructor(message = "Provider disconnected") {
+    super(message);
+    this.name = "ProviderDisconnected";
+  }
+};
+var CdpUnrecoverable = class extends CekiBrowserError {
+  lastError;
+  constructor(lastError) {
+    super(`CDP unrecoverable: ${lastError}`);
+    this.name = "CdpUnrecoverable";
+    this.lastError = lastError;
+  }
+};
+var CaptchaError = class extends CekiBrowserError {
+  constructor(message = "Captcha error") {
+    super(message);
+    this.name = "CaptchaError";
+  }
+};
+var CaptchaTimeoutError = class extends CaptchaError {
+  phase;
+  constructor(phase) {
+    super(`Captcha timeout: ${phase}`);
+    this.name = "CaptchaTimeoutError";
+    this.phase = phase;
+  }
+};
+var ChatSendFailed = class extends CekiBrowserError {
+  status;
+  messageText;
+  constructor(status, messageText) {
+    super(`Chat send failed (${status})`);
+    this.name = "ChatSendFailed";
+    this.status = status;
+    this.messageText = messageText;
+  }
+};
+
+// src/chat.ts
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var MAX_IMAGE_SIZE = 5 * 1024 * 1024;
+function detectMime(buf) {
+  if (buf.length >= 4 && buf[0] === 137 && buf[1] === 80 && buf[2] === 78 && buf[3] === 71) {
+    return { mime: "image/png", ext: "png" };
+  }
+  if (buf.length >= 3 && buf[0] === 255 && buf[1] === 216 && buf[2] === 255) {
+    return { mime: "image/jpeg", ext: "jpg" };
+  }
+  if (buf.length >= 12 && buf[0] === 82 && buf[1] === 73 && buf[2] === 70 && buf[3] === 70 && buf[8] === 87 && buf[9] === 69 && buf[10] === 66 && buf[11] === 80) {
+    return { mime: "image/webp", ext: "webp" };
+  }
+  return { mime: "application/octet-stream", ext: "bin" };
+}
+function randomHex(len) {
+  return crypto.randomBytes(len / 2).toString("hex");
+}
+var BrowserChat = class {
+  _browser;
+  _topicId;
+  _messageHandlers = [];
+  _readHandlers = [];
+  _pendingSends = /* @__PURE__ */ new Map();
+  /** @internal */
+  _actionCallbacks = /* @__PURE__ */ new Map();
+  constructor(browser) {
+    this._browser = browser;
+    this._topicId = browser.chatTopicId;
+  }
+  get topicId() {
+    return this._topicId;
+  }
+  async send(text) {
+    const clientMsgId = randomHex(32);
+    const msg = {
+      type: "chat.send",
+      session_id: this._browser.sessionId,
+      client_msg_id: clientMsgId,
+      text
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingSends.delete(clientMsgId);
+        reject(new TimeoutError("Chat send timed out"));
+      }, 15e3);
+      this._pendingSends.set(clientMsgId, { resolve, reject, timer });
+      this._browser._sendRaw(msg);
+    });
+  }
+  async sendImage(source, text) {
+    let buf;
+    let filename;
+    if (typeof source === "string") {
+      buf = fs.readFileSync(source);
+      filename = path.basename(source);
+    } else {
+      buf = Buffer.isBuffer(source) ? source : Buffer.from(source);
+      filename = "image";
+    }
+    if (buf.length > MAX_IMAGE_SIZE) {
+      throw new Error(`Image too large: ${buf.length} bytes (max ${MAX_IMAGE_SIZE})`);
+    }
+    const { mime, ext } = detectMime(buf);
+    if (!filename.includes(".")) {
+      filename = `${filename}.${ext}`;
+    }
+    const clientMsgId = randomHex(32);
+    const data_b64 = buf.toString("base64");
+    const msg = {
+      type: "chat.send_image",
+      session_id: this._browser.sessionId,
+      client_msg_id: clientMsgId,
+      filename,
+      mime,
+      data_b64
+    };
+    if (text) msg.text = text;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingSends.delete(clientMsgId);
+        reject(new TimeoutError("Chat sendImage timed out"));
+      }, 15e3);
+      this._pendingSends.set(clientMsgId, { resolve, reject, timer });
+      this._browser._sendRaw(msg);
+    });
+  }
+  onMessage(cb) {
+    this._messageHandlers.push(cb);
+  }
+  onRead(cb) {
+    this._readHandlers.push(cb);
+  }
+  async history(opts) {
+    if (!this._topicId) return [];
+    const params = new URLSearchParams();
+    params.set("topic_id", this._topicId);
+    if (opts?.limit != null) params.set("limit", String(opts.limit));
+    if (opts?.beforeId) params.set("before", opts.beforeId);
+    if (opts?.since) params.set("since", opts.since);
+    const url = `${this._browser._chatUrl}/messages?${params.toString()}`;
+    const headers = {
+      "Authorization": `Bearer ${this._browser._apiKey}`
+    };
+    const basicAuth = this._browser._basicAuth;
+    if (basicAuth) {
+      const encoded = Buffer.from(`${basicAuth[0]}:${basicAuth[1]}`).toString("base64");
+      headers["X-Basic-Auth"] = `Basic ${encoded}`;
+    }
+    const resp = await fetch(url, { headers });
+    if (!resp.ok) {
+      throw new Error(`Chat history request failed: ${resp.status} ${resp.statusText}`);
+    }
+    const body = await resp.json();
+    const messages = body.messages ?? body.data ?? body;
+    if (!Array.isArray(messages)) return [];
+    return messages.map(parseChatMessage);
+  }
+  /** @internal */
+  _onMessage(payload) {
+    const msgData = payload.message ?? payload;
+    if (msgData.type === "action" && msgData.action) {
+      const action = msgData.action;
+      const eventId = Number(action.event_id);
+      if (eventId && this._actionCallbacks.has(eventId)) {
+        this._actionCallbacks.get(eventId)(action);
+      }
+    }
+    const msg = parseChatMessage(msgData);
+    for (const h of this._messageHandlers) {
+      try {
+        const result = h(msg);
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onRead(payload) {
+    const receipt = {
+      topic_id: String(payload.topic_id ?? this._topicId ?? ""),
+      last_read_message_id: String(payload.last_read_message_id ?? ""),
+      read_at: Number(payload.read_at ?? 0)
+    };
+    for (const h of this._readHandlers) {
+      try {
+        const result = h(receipt);
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onSendAck(msg) {
+    const clientMsgId = String(msg.client_msg_id ?? "");
+    const pending = this._pendingSends.get(clientMsgId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this._pendingSends.delete(clientMsgId);
+    pending.resolve({
+      messageId: String(msg.message_id ?? ""),
+      sentAt: String(msg.sent_at ?? "")
+    });
+  }
+  /** @internal */
+  _onSendError(msg) {
+    const clientMsgId = String(msg.client_msg_id ?? "");
+    const pending = this._pendingSends.get(clientMsgId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this._pendingSends.delete(clientMsgId);
+    pending.reject(new ChatSendFailed(
+      Number(msg.status ?? 0),
+      String(msg.message ?? "")
+    ));
+  }
+};
+function parseChatMessage(data) {
+  const action = data.action;
+  return {
+    id: String(data.id ?? data._id ?? data.message_id ?? ""),
+    topic_id: String(data.topic_id ?? ""),
+    sender_id: data.sender_id != null ? Number(data.sender_id) : null,
+    text: data.text != null ? String(data.text) : null,
+    media: data.media ?? null,
+    type: String(data.type ?? "text"),
+    created_at: String(data.created_at ?? ""),
+    edited_at: data.edited_at != null ? String(data.edited_at) : null,
+    deleted_at: data.deleted_at != null ? String(data.deleted_at) : null,
+    action: action ? {
+      kind: String(action.kind ?? ""),
+      event_id: Number(action.event_id ?? 0),
+      data: action.data ?? void 0
+    } : null
+  };
+}
+
+// src/profile.ts
+var BrowserProfile = class {
+  _browser;
+  constructor(browser) {
+    this._browser = browser;
+  }
+  async export(opts) {
+    let fingerprint = null;
+    try {
+      const fpResult = await this._browser.send({ method: "Browser.getFingerprint" });
+      fingerprint = fpResult ?? null;
+    } catch {
+      fingerprint = null;
+    }
+    let cookies = [];
+    try {
+      const cookieResult = await this._browser.send({ method: "Network.getCookies" });
+      const allCookies = cookieResult?.cookies ?? [];
+      if (opts?.domains && opts.domains.length > 0) {
+        const domainSet = new Set(opts.domains.map((d) => d.toLowerCase()));
+        cookies = allCookies.filter((c) => {
+          const cookieDomain = String(c.domain ?? "").toLowerCase().replace(/^\./, "");
+          return domainSet.has(cookieDomain) || opts.domains.some(
+            (d) => cookieDomain.endsWith("." + d.toLowerCase()) || cookieDomain === d.toLowerCase()
+          );
+        });
+      } else {
+        cookies = allCookies;
+      }
+    } catch {
+      cookies = [];
+    }
+    let localStorage = {};
+    try {
+      const lsResult = await this._browser.send({
+        method: "Runtime.evaluate",
+        params: { expression: "JSON.stringify(localStorage)", returnByValue: true }
+      });
+      const resultObj = lsResult?.result;
+      if (resultObj?.value) {
+        localStorage = JSON.parse(String(resultObj.value));
+      }
+    } catch {
+      localStorage = {};
+    }
+    let sessionStorage = {};
+    if (opts?.includeSessionStorage !== false) {
+      try {
+        const ssResult = await this._browser.send({
+          method: "Runtime.evaluate",
+          params: { expression: "JSON.stringify(sessionStorage)", returnByValue: true }
+        });
+        const resultObj = ssResult?.result;
+        if (resultObj?.value) {
+          sessionStorage = JSON.parse(String(resultObj.value));
+        }
+      } catch {
+        sessionStorage = {};
+      }
+    }
+    let origin = "";
+    try {
+      const originResult = await this._browser.send({
+        method: "Runtime.evaluate",
+        params: { expression: "location.origin", returnByValue: true }
+      });
+      const resultObj = originResult?.result;
+      if (resultObj?.value) {
+        origin = String(resultObj.value);
+      }
+    } catch {
+      origin = "";
+    }
+    return {
+      schema_version: 2,
+      fingerprint,
+      origin,
+      cookies,
+      localStorage,
+      sessionStorage
+    };
+  }
+  async import(profile) {
+    if (profile.schema_version !== 1 && profile.schema_version !== 2) {
+      throw new Error(`Unsupported profile schema_version: ${profile.schema_version}`);
+    }
+    if (profile.cookies && profile.cookies.length > 0) {
+      await this._browser.send({
+        method: "Network.setCookies",
+        params: { cookies: profile.cookies }
+      });
+    }
+    if (profile.localStorage && Object.keys(profile.localStorage).length > 0) {
+      const entries = JSON.stringify(profile.localStorage);
+      await this._browser.send({
+        method: "Runtime.evaluate",
+        params: {
+          expression: `(function(){var d=${entries};for(var k in d)localStorage.setItem(k,d[k])})()`,
+          returnByValue: true
+        }
+      });
+    }
+    if (profile.sessionStorage && Object.keys(profile.sessionStorage).length > 0) {
+      const entries = JSON.stringify(profile.sessionStorage);
+      await this._browser.send({
+        method: "Runtime.evaluate",
+        params: {
+          expression: `(function(){var d=${entries};for(var k in d)sessionStorage.setItem(k,d[k])})()`,
+          returnByValue: true
+        }
+      });
+    }
+  }
+};
+
+// src/state.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as os from "os";
+var STATE_DIR = path2.join(os.homedir(), ".ceki", "sessions");
+function statePath(sid) {
+  return path2.join(STATE_DIR, `${sid}.json`);
+}
+function loadSession(sid) {
+  try {
+    const raw = fs2.readFileSync(statePath(sid), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveSession(sid, data) {
+  fs2.mkdirSync(STATE_DIR, { recursive: true });
+  const payload = { ...data, updated_at: (/* @__PURE__ */ new Date()).toISOString() };
+  fs2.writeFileSync(statePath(sid), JSON.stringify(payload, null, 2), "utf-8");
+}
+function getLastSeenTs(sid) {
+  const data = loadSession(sid);
+  if (!data) return null;
+  return data.last_seen_ts ?? null;
+}
+function updateLastSeenTs(sid, ts) {
+  const data = loadSession(sid) ?? {};
+  data.last_seen_ts = ts;
+  saveSession(sid, data);
+}
+
+// src/humanize/keymap.ts
+var STATIC_MAP = {
+  " ": { code: "Space", key: " ", vk: 32, needsShift: false },
+  "\n": { code: "Enter", key: "Enter", vk: 13, needsShift: false },
+  "	": { code: "Tab", key: "Tab", vk: 9, needsShift: false },
+  // Shifted digits
+  "!": { code: "Digit1", key: "!", vk: 49, needsShift: true },
+  "@": { code: "Digit2", key: "@", vk: 50, needsShift: true },
+  "#": { code: "Digit3", key: "#", vk: 51, needsShift: true },
+  "$": { code: "Digit4", key: "$", vk: 52, needsShift: true },
+  "%": { code: "Digit5", key: "%", vk: 53, needsShift: true },
+  "^": { code: "Digit6", key: "^", vk: 54, needsShift: true },
+  "&": { code: "Digit7", key: "&", vk: 55, needsShift: true },
+  "*": { code: "Digit8", key: "*", vk: 56, needsShift: true },
+  "(": { code: "Digit9", key: "(", vk: 57, needsShift: true },
+  ")": { code: "Digit0", key: ")", vk: 48, needsShift: true },
+  // Punctuation (unshifted)
+  "-": { code: "Minus", key: "-", vk: 189, needsShift: false },
+  "=": { code: "Equal", key: "=", vk: 187, needsShift: false },
+  "[": { code: "BracketLeft", key: "[", vk: 219, needsShift: false },
+  "]": { code: "BracketRight", key: "]", vk: 221, needsShift: false },
+  "\\": { code: "Backslash", key: "\\", vk: 220, needsShift: false },
+  ";": { code: "Semicolon", key: ";", vk: 186, needsShift: false },
+  "'": { code: "Quote", key: "'", vk: 222, needsShift: false },
+  ",": { code: "Comma", key: ",", vk: 188, needsShift: false },
+  ".": { code: "Period", key: ".", vk: 190, needsShift: false },
+  "/": { code: "Slash", key: "/", vk: 191, needsShift: false },
+  "`": { code: "Backquote", key: "`", vk: 192, needsShift: false },
+  // Punctuation (shifted)
+  "_": { code: "Minus", key: "_", vk: 189, needsShift: true },
+  "+": { code: "Equal", key: "+", vk: 187, needsShift: true },
+  "{": { code: "BracketLeft", key: "{", vk: 219, needsShift: true },
+  "}": { code: "BracketRight", key: "}", vk: 221, needsShift: true },
+  "|": { code: "Backslash", key: "|", vk: 220, needsShift: true },
+  ":": { code: "Semicolon", key: ":", vk: 186, needsShift: true },
+  '"': { code: "Quote", key: '"', vk: 222, needsShift: true },
+  "<": { code: "Comma", key: "<", vk: 188, needsShift: true },
+  ">": { code: "Period", key: ">", vk: 190, needsShift: true },
+  "?": { code: "Slash", key: "?", vk: 191, needsShift: true },
+  "~": { code: "Backquote", key: "~", vk: 192, needsShift: true }
+};
+function keymapForChar(char) {
+  if (char >= "a" && char <= "z") {
+    const upper = char.toUpperCase();
+    return {
+      code: `Key${upper}`,
+      key: char,
+      vk: upper.charCodeAt(0),
+      needsShift: false
+    };
+  }
+  if (char >= "A" && char <= "Z") {
+    return {
+      code: `Key${char}`,
+      key: char,
+      vk: char.charCodeAt(0),
+      needsShift: true
+    };
+  }
+  if (char >= "0" && char <= "9") {
+    return {
+      code: `Digit${char}`,
+      key: char,
+      vk: char.charCodeAt(0),
+      needsShift: false
+    };
+  }
+  const mapping = STATIC_MAP[char];
+  if (mapping) return mapping;
+  return null;
+}
+
+// src/browser.ts
+var Browser = class {
+  sessionId;
+  browserId;
+  scheduleId;
+  chatTopicId;
+  browserInfo;
+  providerUserId;
+  /** @internal */
+  _eventId;
+  chat;
+  profile;
+  /** @internal */
+  _client;
+  /** @internal */
+  _humanizer = null;
+  /** @internal */
+  _lastPointer = null;
+  /** @internal */
+  _lastSeenTs = null;
+  /** @internal */
+  _cdpCounter = 1;
+  /** @internal */
+  _pendingCdp = /* @__PURE__ */ new Map();
+  /** @internal */
+  _ended;
+  /** @internal */
+  _endedReason = null;
+  /** @internal */
+  _resolveEnded;
+  _eventHandlers = [];
+  _tabHandlers = [];
+  _disconnectHandlers = [];
+  _reconnectHandlers = [];
+  _userEventHandlers = [];
+  /** @internal */
+  get _apiKey() {
+    return this._client._apiKey;
+  }
+  /** @internal */
+  get _chatUrl() {
+    return this._client._chatUrl;
+  }
+  /** @internal */
+  get _basicAuth() {
+    return this._client._basicAuth;
+  }
+  constructor(client, match, humanizer) {
+    this._client = client;
+    this.sessionId = match.session_id;
+    this.browserId = match.schedule_id;
+    this.scheduleId = match.schedule_id;
+    this.chatTopicId = match.chat_topic_id ?? null;
+    this.browserInfo = match.browser_info ?? {};
+    this.providerUserId = match.provider_user_id ?? null;
+    this._eventId = match.event_id ?? null;
+    this._humanizer = humanizer ?? null;
+    this.chat = new BrowserChat(this);
+    this.profile = new BrowserProfile(this);
+    this._ended = new Promise((resolve) => {
+      this._resolveEnded = resolve;
+    });
+    this._lastSeenTs = getLastSeenTs(this.sessionId);
+    saveSession(this.sessionId, {
+      session_id: this.sessionId,
+      chat_topic_id: this.chatTopicId,
+      schedule_id: this.scheduleId,
+      last_seen_ts: this._lastSeenTs
+    });
+  }
+  /** @internal — send raw message via client WS */
+  _sendRaw(msg) {
+    this._client._wsSend(msg);
+  }
+  async send(cdp, timeout = 3e4) {
+    if (this._endedReason) {
+      throw new SessionEnded(this._endedReason);
+    }
+    const id = this._cdpCounter++;
+    const msg = {
+      type: "cdp",
+      session_id: this.sessionId,
+      id,
+      method: cdp.method,
+      params: cdp.params ?? {}
+    };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingCdp.delete(id);
+        reject(new TimeoutError(`CDP ${cdp.method} timed out after ${timeout}ms`));
+      }, timeout);
+      this._pendingCdp.set(id, { resolve, reject, timer });
+      this._sendRaw(msg);
+    });
+  }
+  async navigate(url, timeout = 3e4) {
+    if (this._humanizer) await this._humanizer.before("navigate");
+    const result = await this.send({ method: "Page.navigate", params: { url } }, timeout);
+    if (this._humanizer) await this._humanizer.after("navigate");
+    return {
+      url: String(result?.url ?? url),
+      frameId: result?.frameId ? String(result.frameId) : void 0
+    };
+  }
+  async click(x, y) {
+    if (this._humanizer) await this._humanizer.before("click");
+    await this.send({
+      method: "Input.dispatchMouseEvent",
+      params: { type: "mousePressed", x, y, button: "left", clickCount: 1 }
+    });
+    await this.send({
+      method: "Input.dispatchMouseEvent",
+      params: { type: "mouseReleased", x, y, button: "left", clickCount: 1 }
+    });
+    this._lastPointer = [x, y];
+    if (this._humanizer) await this._humanizer.after("click");
+  }
+  async _sendKeystroke(char) {
+    const mapping = keymapForChar(char);
+    if (!mapping) {
+      await this.send({ method: "Input.insertText", params: { text: char } });
+      return;
+    }
+    const { code, key, vk, needsShift } = mapping;
+    if (needsShift) {
+      await this.send({
+        method: "Input.dispatchKeyEvent",
+        params: { type: "keyDown", key: "Shift", code: "ShiftLeft", windowsVirtualKeyCode: 16, nativeVirtualKeyCode: 16 }
+      });
+    }
+    await this.send({
+      method: "Input.dispatchKeyEvent",
+      params: {
+        type: "keyDown",
+        key,
+        code,
+        text: char,
+        unmodifiedText: needsShift ? char.toLowerCase() : char,
+        windowsVirtualKeyCode: vk,
+        nativeVirtualKeyCode: vk,
+        ...needsShift ? { modifiers: 8 } : {}
+      }
+    });
+    await this.send({
+      method: "Input.dispatchKeyEvent",
+      params: {
+        type: "keyUp",
+        key,
+        code,
+        windowsVirtualKeyCode: vk,
+        nativeVirtualKeyCode: vk,
+        ...needsShift ? { modifiers: 8 } : {}
+      }
+    });
+    if (needsShift) {
+      await this.send({
+        method: "Input.dispatchKeyEvent",
+        params: { type: "keyUp", key: "Shift", code: "ShiftLeft", windowsVirtualKeyCode: 16, nativeVirtualKeyCode: 16 }
+      });
+    }
+  }
+  async type(text) {
+    if (this._humanizer) {
+      await this._humanizer.before("type");
+      if (this._lastPointer) {
+        const [px, py] = this._lastPointer;
+        await this.send({
+          method: "Input.dispatchMouseEvent",
+          params: { type: "mousePressed", x: px, y: py, button: "left", clickCount: 1 }
+        });
+        await this.send({
+          method: "Input.dispatchMouseEvent",
+          params: { type: "mouseReleased", x: px, y: py, button: "left", clickCount: 1 }
+        });
+      }
+      for (const char of text) {
+        await this._sendKeystroke(char);
+        const delay = this._humanizer.typeDelay();
+        if (delay > 0) {
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+      await this._humanizer.after("type");
+    } else {
+      for (const char of text) {
+        await this._sendKeystroke(char);
+      }
+    }
+  }
+  async scroll(opts) {
+    const x = opts?.x ?? 0;
+    const y = opts?.y ?? 0;
+    const deltaX = opts?.deltaX ?? 0;
+    const deltaY = opts?.deltaY ?? -300;
+    if (this._humanizer) await this._humanizer.before("scroll");
+    await this.send({
+      method: "Input.dispatchMouseEvent",
+      params: { type: "mouseWheel", x, y, deltaX, deltaY }
+    });
+    this._lastPointer = [x, y];
+    if (this._humanizer) await this._humanizer.after("scroll");
+  }
+  async screenshot(opts) {
+    const format = opts?.format ?? "base64";
+    const fullPage = opts?.fullPage ?? false;
+    let clip;
+    if (fullPage) {
+      const metrics = await this.send({ method: "Page.getLayoutMetrics" });
+      const contentSize = metrics?.contentSize;
+      if (contentSize) {
+        const width = Number(contentSize.width ?? 1920);
+        const height = Math.min(Number(contentSize.height ?? 1080), 16384);
+        clip = { x: 0, y: 0, width, height, scale: 1 };
+      }
+    }
+    const params = { format: "png" };
+    if (clip) params.clip = clip;
+    const result = await this.send({ method: "Page.captureScreenshot", params });
+    const data = String(result?.data ?? "");
+    if (format === "png") {
+      return Buffer.from(data, "base64");
+    }
+    return { data };
+  }
+  async snapshot() {
+    const [ssResult, chatMessages] = await Promise.all([
+      this.screenshot({ format: "base64" }),
+      this.chat.history({ since: this._lastSeenTs ?? void 0 })
+    ]);
+    const screenshotData = ssResult.data;
+    if (chatMessages.length > 0) {
+      const lastMsg = chatMessages[chatMessages.length - 1];
+      this._lastSeenTs = lastMsg.created_at;
+      updateLastSeenTs(this.sessionId, this._lastSeenTs);
+    }
+    return {
+      screenshot: screenshotData,
+      chat: chatMessages,
+      ts: /* @__PURE__ */ new Date()
+    };
+  }
+  async upload(selector, source, filename) {
+    let buf;
+    let resolvedFilename;
+    if (typeof source === "string") {
+      const fs4 = await import("fs");
+      const path3 = await import("path");
+      buf = fs4.readFileSync(source);
+      resolvedFilename = filename ?? path3.basename(source);
+    } else {
+      buf = Buffer.isBuffer(source) ? source : Buffer.from(source);
+      resolvedFilename = filename ?? "file";
+    }
+    const b64 = buf.toString("base64");
+    const size = buf.length;
+    const expression = `
+      (function() {
+        var input = document.querySelector(${JSON.stringify(selector)});
+        if (!input) return JSON.stringify({ok: false, error: 'Element not found'});
+        var b64 = ${JSON.stringify(b64)};
+        var binary = atob(b64);
+        var bytes = new Uint8Array(binary.length);
+        for (var i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+        var file = new File([bytes], ${JSON.stringify(resolvedFilename)}, {type: 'application/octet-stream'});
+        var dt = new DataTransfer();
+        dt.items.add(file);
+        input.files = dt.files;
+        input.dispatchEvent(new Event('change', {bubbles: true}));
+        return JSON.stringify({ok: true, filename: ${JSON.stringify(resolvedFilename)}, size: ${size}});
+      })()
+    `.trim();
+    const result = await this.send({
+      method: "Runtime.evaluate",
+      params: { expression, returnByValue: true }
+    });
+    const resultObj = result?.result;
+    if (resultObj?.value) {
+      return JSON.parse(String(resultObj.value));
+    }
+    return { ok: true, filename: resolvedFilename, size };
+  }
+  async switchTab() {
+    this._sendRaw({ type: "switch_tab", session_id: this.sessionId });
+  }
+  async configure(opts) {
+    const msg = {
+      type: "session.configure",
+      session_id: this.sessionId
+    };
+    if (opts.maskingMode !== void 0) msg.masking_mode = opts.maskingMode;
+    if (opts.fingerprint !== void 0) msg.fingerprint = opts.fingerprint;
+    this._sendRaw(msg);
+  }
+  async close(timeout = 1e4) {
+    if (this._endedReason) return;
+    this._sendRaw({
+      type: "session.end",
+      session_id: this.sessionId,
+      reason: "user_stop"
+    });
+    await Promise.race([
+      this._ended,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new TimeoutError("Close timed out")), timeout)
+      )
+    ]).catch(() => {
+    });
+    this._cleanup();
+  }
+  async release(timeout) {
+    return this.close(timeout);
+  }
+  async waitUntilEnded() {
+    return this._ended;
+  }
+  onEvent(cb) {
+    this._eventHandlers.push(cb);
+  }
+  onTabOpened(cb) {
+    this._tabHandlers.push(cb);
+  }
+  onProviderDisconnected(cb) {
+    this._disconnectHandlers.push(cb);
+  }
+  onProviderReconnected(cb) {
+    this._reconnectHandlers.push(cb);
+  }
+  onUserEvent(cb) {
+    this._userEventHandlers.push(cb);
+  }
+  // --- Captcha / human action ---
+  _apiHeaders() {
+    const headers = {
+      "Authorization": `Bearer ${this._apiKey}`,
+      "Content-Type": "application/json"
+    };
+    const basicAuth = this._basicAuth;
+    if (basicAuth) {
+      const encoded = Buffer.from(`${basicAuth[0]}:${basicAuth[1]}`).toString("base64");
+      headers["X-Basic-Auth"] = `Basic ${encoded}`;
+    }
+    return headers;
+  }
+  async requestCaptcha(opts) {
+    let acceptanceTimeout = opts?.acceptanceTimeout ?? 60;
+    let completionTimeout = opts?.completionTimeout ?? 120;
+    const autoAccept = opts?.autoAccept ?? true;
+    if (acceptanceTimeout < 30) throw new Error("acceptanceTimeout must be >= 30 seconds");
+    if (completionTimeout < 30) throw new Error("completionTimeout must be >= 30 seconds");
+    acceptanceTimeout = Math.min(acceptanceTimeout, 300);
+    completionTimeout = Math.min(completionTimeout, 600);
+    const { id: childEventId } = await this._createCaptchaEvent(acceptanceTimeout, completionTimeout);
+    const completionDeadline = Date.now() + completionTimeout * 1e3;
+    const buffer = [];
+    let waiter = null;
+    this.chat._actionCallbacks.set(childEventId, (action) => {
+      if (waiter) {
+        const w = waiter;
+        waiter = null;
+        w(action);
+      } else {
+        buffer.push(action);
+      }
+    });
+    const nextAction = (timeoutMs) => {
+      if (buffer.length > 0) return Promise.resolve(buffer.shift());
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          waiter = null;
+          reject(new Error("timeout"));
+        }, timeoutMs);
+        waiter = (action) => {
+          clearTimeout(timer);
+          resolve(action);
+        };
+      });
+    };
+    const cleanup = () => {
+      this.chat._actionCallbacks.delete(childEventId);
+      waiter = null;
+    };
+    const makeResult = async (data, solved) => {
+      const correctionId = data.correction_id != null ? Number(data.correction_id) : null;
+      const proofMessageId = data.proof_message_id != null ? String(data.proof_message_id) : null;
+      let voted = false;
+      const result = {
+        solved,
+        proofMessageId,
+        cancelReason: null,
+        childEventId,
+        correctionId,
+        acceptWork: async () => {
+          if (voted) return;
+          if (!correctionId) throw new CaptchaError("no correction_id \u2014 provider has not proposed completion");
+          voted = true;
+          await fetch(`${this._client._apiUrl}/api/agent/kal/event/${childEventId}/vote`, {
+            method: "POST",
+            headers: this._apiHeaders(),
+            body: JSON.stringify({ ids: [correctionId], vote: true })
+          });
+        },
+        rejectWork: async (reason) => {
+          if (voted) return;
+          if (!correctionId) throw new CaptchaError("no correction_id \u2014 provider has not proposed completion");
+          voted = true;
+          const body = { ids: [correctionId], vote: false };
+          if (reason) body.reason = reason;
+          await fetch(`${this._client._apiUrl}/api/agent/kal/event/${childEventId}/vote`, {
+            method: "POST",
+            headers: this._apiHeaders(),
+            body: JSON.stringify(body)
+          });
+        }
+      };
+      if (autoAccept && solved && correctionId) {
+        await new Promise((r) => setTimeout(r, 2e3));
+        await result.acceptWork();
+      }
+      return result;
+    };
+    let accepted = false;
+    try {
+      const acceptDeadline = Date.now() + acceptanceTimeout * 1e3;
+      while (true) {
+        const remaining = acceptDeadline - Date.now();
+        if (remaining <= 0) throw new Error("timeout");
+        const action = await nextAction(remaining);
+        const kind = String(action.kind ?? "");
+        const data = action.data ?? {};
+        if (kind === "human_action_accepted") {
+          accepted = true;
+          break;
+        }
+        if (kind === "human_action_completed") {
+          cleanup();
+          return await makeResult(data, true);
+        }
+        if (kind === "human_action_failed" || kind === "human_action_declined" || kind === "human_action_withdrew") {
+          cleanup();
+          return {
+            solved: false,
+            proofMessageId: null,
+            cancelReason: kind.replace("human_action_", ""),
+            childEventId,
+            correctionId: null,
+            acceptWork: async () => {
+            },
+            rejectWork: async () => {
+            }
+          };
+        }
+      }
+      while (true) {
+        const remaining = completionDeadline - Date.now();
+        if (remaining <= 0) throw new Error("timeout");
+        const action = await nextAction(remaining);
+        const kind = String(action.kind ?? "");
+        const data = action.data ?? {};
+        if (kind === "human_action_completed") {
+          cleanup();
+          return await makeResult(data, true);
+        }
+        if (kind === "human_action_failed" || kind === "human_action_withdrew") {
+          cleanup();
+          return {
+            solved: false,
+            proofMessageId: null,
+            cancelReason: kind.replace("human_action_", ""),
+            childEventId,
+            correctionId: null,
+            acceptWork: async () => {
+            },
+            rejectWork: async () => {
+            }
+          };
+        }
+      }
+    } catch {
+      cleanup();
+      const phase = accepted ? "completion" : "acceptance";
+      await this._expireCaptchaEvent(childEventId);
+      throw new CaptchaTimeoutError(phase);
+    }
+  }
+  async _createCaptchaEvent(acceptanceTimeout, completionTimeout) {
+    const body = {
+      acceptance_deadline_at: Math.floor(acceptanceTimeout),
+      completion_deadline_at: Math.floor(completionTimeout)
+    };
+    const resp = await fetch(`${this._client._apiUrl}/api/agent/sessions/${this._eventId}/captcha-request`, {
+      method: "POST",
+      headers: this._apiHeaders(),
+      body: JSON.stringify(body)
+    });
+    if (!resp.ok) {
+      throw new Error(`Captcha request failed: ${resp.status}`);
+    }
+    const result = await resp.json();
+    if (!result.id) throw new Error("Captcha request did not return an id");
+    return { id: result.id, amount: result.amount };
+  }
+  async _expireCaptchaEvent(childEventId) {
+    try {
+      await fetch(`${this._client._apiUrl}/api/agent/kal/event/${childEventId}`, {
+        method: "PATCH",
+        headers: this._apiHeaders(),
+        body: JSON.stringify({ status_id: 777 })
+      });
+    } catch {
+    }
+  }
+  // --- Internal handlers called by Client dispatch ---
+  /** @internal */
+  _onCdpResponse(msg) {
+    const id = Number(msg.id);
+    const pending = this._pendingCdp.get(id);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this._pendingCdp.delete(id);
+    if (msg.ok === false) {
+      const error = msg.error;
+      pending.reject(new Error(String(error?.message ?? error?.code ?? "CDP error")));
+    } else {
+      pending.resolve(msg.result ?? null);
+    }
+  }
+  /** @internal */
+  _onCdpEvent(msg) {
+    const method = String(msg.method ?? "");
+    const params = msg.params ?? {};
+    for (const h of this._eventHandlers) {
+      try {
+        h(method, params);
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onTabOpened(msg) {
+    const url = String(msg.url ?? "");
+    for (const h of this._tabHandlers) {
+      try {
+        h(url);
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onSessionEnded(msg) {
+    const reason = String(msg.reason ?? "unknown");
+    this._endedReason = reason;
+    this._resolveEnded(reason);
+    this._rejectAllPending(new SessionEnded(reason));
+    this._cleanup();
+  }
+  /** @internal */
+  _onProviderDisconnected() {
+    for (const h of this._disconnectHandlers) {
+      try {
+        h();
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onProviderReconnected() {
+    for (const h of this._reconnectHandlers) {
+      try {
+        h();
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onError(msg) {
+    const reason = String(msg.reason ?? msg.message ?? "unknown error");
+    this._endedReason = reason;
+    this._resolveEnded(reason);
+    this._rejectAllPending(new SessionEnded(reason));
+    this._cleanup();
+  }
+  /** @internal */
+  _onUserEvents(msg) {
+    const events = msg.events ?? [];
+    for (const h of this._userEventHandlers) {
+      try {
+        h(events);
+      } catch {
+      }
+    }
+  }
+  /** @internal */
+  _onChatMessage(payload) {
+    this.chat._onMessage(payload);
+  }
+  /** @internal */
+  _onChatRead(payload) {
+    this.chat._onRead(payload);
+  }
+  /** @internal */
+  _onChatSendAck(msg) {
+    this.chat._onSendAck(msg);
+  }
+  /** @internal */
+  _onChatSendError(msg) {
+    this.chat._onSendError(msg);
+  }
+  _rejectAllPending(err) {
+    for (const [id, pending] of this._pendingCdp) {
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this._pendingCdp.clear();
+  }
+  _cleanup() {
+    this._client._activeBrowsers.delete(this.sessionId);
+  }
+};
+
+// src/humanize/humanizer.ts
+function seededRandom(seed) {
+  if (seed === null || seed === void 0) {
+    return Math.random;
+  }
+  let s = seed;
+  return () => {
+    s = s * 1664525 + 1013904223 & 4294967295;
+    return (s >>> 0) / 4294967295;
+  };
+}
+function gaussianRandom(rng, mean, sigma) {
+  let u1, u2;
+  do {
+    u1 = rng();
+  } while (u1 === 0);
+  u2 = rng();
+  const z = Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+  return mean + z * sigma;
+}
+var Humanizer = class {
+  profile;
+  _rng;
+  constructor(profile) {
+    this.profile = profile;
+    this._rng = seededRandom(profile.raw.rng_seed ?? null);
+  }
+  async before(action) {
+    const [lo, hi] = this.profile.getRange(action, "pre");
+    if (lo === 0 && hi === 0) return;
+    const delay = lo + this._rng() * (hi - lo);
+    await sleep(delay);
+  }
+  async after(action) {
+    const [lo, hi] = this.profile.getRange(action, "post");
+    if (lo === 0 && hi === 0) return;
+    const delay = lo + this._rng() * (hi - lo);
+    await sleep(delay);
+  }
+  typeDelay() {
+    const typing = this.profile.raw.typing ?? {};
+    const wpm = typing.wpm ?? 110;
+    const jitter = typing.jitter ?? 0.35;
+    const thinkProb = typing.thinking_pause_prob ?? 0;
+    const thinkMs = typing.thinking_pause_ms ?? [300, 1200];
+    const meanInterval = 6e4 / (wpm * 5);
+    const sigma = meanInterval * jitter;
+    let delay = gaussianRandom(this._rng, meanInterval, sigma);
+    delay = Math.max(delay, 20);
+    if (thinkProb > 0 && this._rng() < thinkProb) {
+      delay += thinkMs[0] + this._rng() * (thinkMs[1] - thinkMs[0]);
+    }
+    return delay;
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/humanize/profile.ts
+import * as fs3 from "fs";
+var PRESETS = {
+  natural: {
+    version: 1,
+    name: "natural",
+    typing: { wpm: 110, jitter: 0.35, thinking_pause_prob: 0.012, thinking_pause_ms: [300, 1200], typo_prob: 0 },
+    pre_action_ms: { click: [80, 350], type: [120, 500], scroll: [50, 250], navigate: [0, 0], screenshot: [0, 0] },
+    post_action_ms: { click: [150, 800], type: [150, 800], scroll: [200, 900], navigate: [400, 1800], screenshot: [0, 0] },
+    mouse: { move_before_click: false, trajectory: "off" },
+    rng_seed: null
+  },
+  careful: {
+    version: 1,
+    name: "careful",
+    typing: { wpm: 80, jitter: 0.4, thinking_pause_prob: 0.025, thinking_pause_ms: [400, 1800], typo_prob: 0 },
+    pre_action_ms: { click: [200, 600], type: [250, 800], scroll: [100, 400], navigate: [0, 0], screenshot: [0, 0] },
+    post_action_ms: { click: [400, 1500], type: [300, 1200], scroll: [300, 1200], navigate: [800, 3e3], screenshot: [0, 0] },
+    mouse: { move_before_click: false, trajectory: "off" },
+    rng_seed: null
+  }
+};
+var DEFAULTS = {
+  version: 1,
+  name: "custom",
+  typing: {
+    wpm: 110,
+    jitter: 0.35,
+    thinking_pause_prob: 0.012,
+    thinking_pause_ms: [300, 1200],
+    typo_prob: 0
+  },
+  pre_action_ms: {
+    click: [80, 350],
+    type: [120, 500],
+    scroll: [50, 250],
+    navigate: [0, 0],
+    screenshot: [0, 0]
+  },
+  post_action_ms: {
+    click: [150, 800],
+    type: [150, 800],
+    scroll: [200, 900],
+    navigate: [400, 1800],
+    screenshot: [0, 0]
+  },
+  mouse: {
+    move_before_click: false,
+    trajectory: "off"
+  },
+  rng_seed: null
+};
+function deepMerge(base, override) {
+  const result = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (key in result && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key]) && typeof value === "object" && value !== null && !Array.isArray(value)) {
+      result[key] = deepMerge(
+        result[key],
+        value
+      );
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+var HumanProfile = class _HumanProfile {
+  name;
+  raw;
+  constructor(name, raw) {
+    this.name = name;
+    this.raw = raw;
+  }
+  static fromDict(d) {
+    const merged = deepMerge(
+      DEFAULTS,
+      d
+    );
+    const name = d.name ?? "custom";
+    merged.name = name;
+    return new _HumanProfile(name, merged);
+  }
+  static load(filePath) {
+    const raw = fs3.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(raw);
+    return _HumanProfile.fromDict(data);
+  }
+  static loadPreset(name) {
+    const preset = PRESETS[name];
+    if (!preset) {
+      throw new Error(`Preset '${name}' not found. Available: ${Object.keys(PRESETS).join(", ")}`);
+    }
+    return _HumanProfile.fromDict(preset);
+  }
+  getRange(action, phase) {
+    const key = `${phase}_action_ms`;
+    const mapping = this.raw[key];
+    const pair = mapping?.[action];
+    if (Array.isArray(pair) && pair.length === 2) {
+      return [pair[0], pair[1]];
+    }
+    return [0, 0];
+  }
+  typingInterval() {
+    const wpm = this.raw.typing?.wpm ?? 110;
+    return 6e4 / (wpm * 5);
+  }
+  toDict() {
+    return JSON.parse(JSON.stringify(this.raw));
+  }
+  toJSON(indent = 2) {
+    return JSON.stringify(this.raw, null, indent);
+  }
+};
+
+// src/client.ts
+var BACKOFF_SCHEDULE = [1, 2, 4, 8, 16, 32, 60];
+var MAX_RECONNECT_ATTEMPTS = 10;
+var PING_INTERVAL = 3e4;
+var PONG_TIMEOUT = 9e4;
+var Client = class _Client {
+  /** @internal */
+  _apiKey;
+  /** @internal */
+  _chatUrl;
+  /** @internal */
+  _basicAuth;
+  /** @internal */
+  _activeBrowsers = /* @__PURE__ */ new Map();
+  _ws = null;
+  /** @internal */
+  _apiUrl;
+  _relayUrl;
+  _reconnect;
+  _reconnectAttempt = 0;
+  _reconnecting = false;
+  _closed = false;
+  _pingTimer = null;
+  _pongTimer = null;
+  _lastPongAt = 0;
+  _pendingRents = /* @__PURE__ */ new Map();
+  // keyed by `rent:<scheduleId>` or eventId
+  _pendingResumes = /* @__PURE__ */ new Map();
+  // keyed by sessionId
+  _connectResolve = null;
+  _connectReject = null;
+  constructor(apiKey, opts) {
+    const cfg = resolveConfig(opts);
+    this._apiKey = apiKey;
+    this._apiUrl = cfg.apiUrl;
+    this._relayUrl = cfg.relayUrl;
+    this._chatUrl = cfg.chatUrl;
+    this._basicAuth = cfg.basicAuth;
+    this._reconnect = cfg.reconnect;
+  }
+  /** Factory: create client and connect */
+  static async create(apiKey, opts) {
+    const client = new _Client(apiKey, opts);
+    await client._connect();
+    return client;
+  }
+  /** @internal */
+  _wsSend(msg) {
+    if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+      throw new ConnectionLost("WebSocket not connected");
+    }
+    this._ws.send(JSON.stringify(msg));
+  }
+  async search(filters, limit) {
+    const params = new URLSearchParams();
+    if (limit != null) params.set("limit", String(limit));
+    if (filters) {
+      for (const [key, value] of Object.entries(filters)) {
+        if (value != null) params.set(key, String(value));
+      }
+    }
+    const url = `${this._apiUrl}/api/browsers/search?${params.toString()}`;
+    const headers = {
+      "Authorization": `Bearer ${this._apiKey}`
+    };
+    if (this._basicAuth) {
+      const encoded = Buffer.from(`${this._basicAuth[0]}:${this._basicAuth[1]}`).toString("base64");
+      headers["X-Basic-Auth"] = `Basic ${encoded}`;
+    }
+    const resp = await fetch(url, { headers });
+    if (!resp.ok) {
+      throw new TransportError(`Search request failed: ${resp.status} ${resp.statusText}`);
+    }
+    const body = await resp.json();
+    const data = body.data ?? body;
+    return Array.isArray(data) ? data : [];
+  }
+  async listSessions(opts) {
+    const active = opts?.active ?? true;
+    const limit = opts?.limit ?? 50;
+    const params = new URLSearchParams({
+      active: active ? "1" : "0",
+      limit: String(limit)
+    });
+    const url = `${this._apiUrl}/api/agent/sessions?${params.toString()}`;
+    const headers = {
+      "Authorization": `Bearer ${this._apiKey}`
+    };
+    if (this._basicAuth) {
+      const encoded = Buffer.from(`${this._basicAuth[0]}:${this._basicAuth[1]}`).toString("base64");
+      headers["X-Basic-Auth"] = `Basic ${encoded}`;
+    }
+    const resp = await fetch(url, { headers });
+    if (!resp.ok) {
+      throw new TransportError(`listSessions request failed: ${resp.status} ${resp.statusText}`);
+    }
+    const body = await resp.json();
+    const items = body.data ?? body;
+    return Array.isArray(items) ? items : [];
+  }
+  async myBrowsers() {
+    const url = `${this._apiUrl}/api/agent/browsers`;
+    const headers = {
+      "Authorization": `Bearer ${this._apiKey}`
+    };
+    if (this._basicAuth) {
+      const encoded = Buffer.from(`${this._basicAuth[0]}:${this._basicAuth[1]}`).toString("base64");
+      headers["X-Basic-Auth"] = `Basic ${encoded}`;
+    }
+    const resp = await fetch(url, { headers });
+    if (!resp.ok) {
+      throw new TransportError(`myBrowsers request failed: ${resp.status} ${resp.statusText}`);
+    }
+    const body = await resp.json();
+    const items = body.browsers ?? body.data ?? body;
+    return Array.isArray(items) ? items : [];
+  }
+  async rent(scheduleId, opts) {
+    const rentMsg = { type: "rent", browser_id: scheduleId };
+    if (opts?.mode) rentMsg.mode = opts.mode;
+    this._wsSend(rentMsg);
+    const key = `rent:${scheduleId}`;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingRents.delete(key);
+        reject(new TimeoutError("Rent timed out after 90s"));
+      }, 9e4);
+      this._pendingRents.set(key, {
+        scheduleId,
+        eventId: null,
+        opts,
+        resolve: (match) => {
+          const humanizer = this._resolveHumanizer(opts);
+          const browser = new Browser(this, match, humanizer);
+          this._activeBrowsers.set(browser.sessionId, browser);
+          if (opts?.maskingMode) {
+            browser.configure({ maskingMode: true }).catch(() => {
+            });
+          }
+          if (opts?.fingerprint) {
+            browser.configure({ fingerprint: opts.fingerprint }).catch(() => {
+            });
+          }
+          resolve(browser);
+        },
+        reject,
+        timer
+      });
+    });
+  }
+  async resume(sessionId, opts) {
+    this._wsSend({ type: "resume", session_id: sessionId });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingResumes.delete(sessionId);
+        reject(new TimeoutError("Resume timed out after 10s"));
+      }, 1e4);
+      this._pendingResumes.set(sessionId, {
+        sessionId,
+        opts,
+        resolve: (match) => {
+          const humanizer = this._resolveHumanizer(opts);
+          const browser = new Browser(this, match, humanizer);
+          this._activeBrowsers.set(browser.sessionId, browser);
+          resolve(browser);
+        },
+        reject,
+        timer
+      });
+    });
+  }
+  async close() {
+    this._closed = true;
+    const closePromises = [];
+    for (const browser of this._activeBrowsers.values()) {
+      closePromises.push(browser.close().catch(() => {
+      }));
+    }
+    await Promise.allSettled(closePromises);
+    for (const [key, pending] of this._pendingRents) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Client closed"));
+    }
+    this._pendingRents.clear();
+    for (const [key, pending] of this._pendingResumes) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Client closed"));
+    }
+    this._pendingResumes.clear();
+    this._stopHeartbeat();
+    this._closeWs();
+  }
+  async disconnect() {
+    this._closed = true;
+    this._activeBrowsers.clear();
+    this._pendingRents.clear();
+    this._pendingResumes.clear();
+    this._stopHeartbeat();
+    this._closeWs();
+  }
+  // --- Private methods ---
+  async _connect() {
+    return new Promise((resolve, reject) => {
+      this._connectResolve = resolve;
+      this._connectReject = reject;
+      this._openWs();
+    });
+  }
+  _openWs() {
+    const protocols = [`bearer.${this._apiKey}`];
+    this._ws = new WebSocket(this._relayUrl, protocols);
+    this._ws.on("open", () => {
+      this._reconnectAttempt = 0;
+      this._reconnecting = false;
+      this._lastPongAt = Date.now();
+      this._startHeartbeat();
+      if (this._connectResolve) {
+        this._connectResolve();
+        this._connectResolve = null;
+        this._connectReject = null;
+      }
+    });
+    this._ws.on("message", (data) => {
+      this._handleMessage(data);
+    });
+    this._ws.on("close", (code, reason) => {
+      this._stopHeartbeat();
+      const reasonStr = reason.toString();
+      if (code === 4401 || code === 4403) {
+        const err = new AuthError(reasonStr || `Auth failed (${code})`);
+        if (this._connectReject) {
+          this._connectReject(err);
+          this._connectResolve = null;
+          this._connectReject = null;
+        }
+        return;
+      }
+      if (!this._closed && this._reconnect) {
+        this._scheduleReconnect();
+      }
+    });
+    this._ws.on("error", (err) => {
+      if (this._connectReject) {
+        this._connectReject(new TransportError(err.message));
+        this._connectResolve = null;
+        this._connectReject = null;
+      }
+    });
+  }
+  _closeWs() {
+    if (this._ws) {
+      try {
+        this._ws.removeAllListeners();
+        this._ws.close();
+      } catch {
+      }
+      this._ws = null;
+    }
+  }
+  _scheduleReconnect() {
+    if (this._closed || this._reconnecting) return;
+    if (this._reconnectAttempt >= MAX_RECONNECT_ATTEMPTS) {
+      const err = new ConnectionLost("Max reconnection attempts exceeded");
+      this._rejectAllPending(err);
+      return;
+    }
+    this._reconnecting = true;
+    const backoffIdx = Math.min(this._reconnectAttempt, BACKOFF_SCHEDULE.length - 1);
+    const delay = BACKOFF_SCHEDULE[backoffIdx] * 1e3;
+    this._reconnectAttempt++;
+    setTimeout(() => {
+      if (this._closed) return;
+      this._closeWs();
+      this._connectResolve = () => {
+        for (const browser of this._activeBrowsers.values()) {
+          this._wsSend({ type: "resume", session_id: browser.sessionId });
+        }
+      };
+      this._connectReject = () => {
+        this._reconnecting = false;
+        this._scheduleReconnect();
+      };
+      this._openWs();
+    }, delay);
+  }
+  _startHeartbeat() {
+    this._stopHeartbeat();
+    this._pingTimer = setInterval(() => {
+      try {
+        this._wsSend({ type: "ping" });
+      } catch {
+      }
+    }, PING_INTERVAL);
+    this._pongTimer = setTimeout(() => {
+      this._checkPongTimeout();
+    }, PONG_TIMEOUT);
+  }
+  _stopHeartbeat() {
+    if (this._pingTimer) {
+      clearInterval(this._pingTimer);
+      this._pingTimer = null;
+    }
+    if (this._pongTimer) {
+      clearTimeout(this._pongTimer);
+      this._pongTimer = null;
+    }
+  }
+  _checkPongTimeout() {
+    if (this._closed) return;
+    const elapsed = Date.now() - this._lastPongAt;
+    if (elapsed >= PONG_TIMEOUT) {
+      this._closeWs();
+      if (this._reconnect) {
+        this._scheduleReconnect();
+      }
+    } else {
+      this._pongTimer = setTimeout(() => {
+        this._checkPongTimeout();
+      }, PONG_TIMEOUT - elapsed);
+    }
+  }
+  _handleMessage(data) {
+    let msg;
+    try {
+      msg = JSON.parse(data.toString());
+    } catch {
+      return;
+    }
+    const type = String(msg.type ?? "");
+    const sessionId = msg.session_id ? String(msg.session_id) : null;
+    switch (type) {
+      case "pong":
+        this._lastPongAt = Date.now();
+        break;
+      case "rent_pending":
+        this._onRentPending(msg);
+        break;
+      case "match":
+        this._onMatch(msg);
+        break;
+      case "rent.error":
+        this._onRentError(msg);
+        break;
+      case "resume_ok":
+        this._onResumeOk(msg);
+        break;
+      case "resume_failed":
+        this._onResumeFailed(msg);
+        break;
+      case "cdp_response":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onCdpResponse(msg);
+        }
+        break;
+      case "cdp_event":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onCdpEvent(msg);
+        }
+        break;
+      case "tab_opened":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onTabOpened(msg);
+        }
+        break;
+      case "session.ended":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onSessionEnded(msg);
+        }
+        break;
+      case "session.provider_disconnected":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onProviderDisconnected();
+        }
+        break;
+      case "session.provider_reconnected":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onProviderReconnected();
+        }
+        break;
+      case "user_events":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onUserEvents(msg);
+        }
+        break;
+      case "chat.message":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onChatMessage(msg.payload ?? msg);
+        }
+        break;
+      case "chat.read":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onChatRead(msg.payload ?? msg);
+        }
+        break;
+      case "chat.send_ack":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onChatSendAck(msg);
+        }
+        break;
+      case "chat.error":
+        if (sessionId) {
+          const browser = this._activeBrowsers.get(sessionId);
+          browser?._onChatSendError(msg);
+        }
+        break;
+      case "error":
+        this._onError(msg);
+        break;
+    }
+  }
+  _onRentPending(msg) {
+    const eventId = String(msg.event_id ?? "");
+    for (const [key, pending] of this._pendingRents) {
+      if (!pending.eventId) {
+        pending.eventId = eventId;
+        this._pendingRents.delete(key);
+        this._pendingRents.set(`event:${eventId}`, pending);
+        break;
+      }
+    }
+  }
+  _onMatch(msg) {
+    const eventId = String(msg.event_id ?? "");
+    const scheduleId = Number(msg.schedule_id ?? 0);
+    const sessionId = String(msg.session_id ?? "");
+    if (msg.requires_ack) {
+      try {
+        this._wsSend({ type: "match_ack", session_id: sessionId });
+      } catch {
+      }
+    }
+    let pending = this._pendingRents.get(`event:${eventId}`);
+    if (!pending) {
+      pending = this._pendingRents.get(`rent:${scheduleId}`);
+    }
+    if (pending) {
+      clearTimeout(pending.timer);
+      const key = pending.eventId ? `event:${pending.eventId}` : `rent:${pending.scheduleId}`;
+      this._pendingRents.delete(key);
+      const match = {
+        session_id: sessionId,
+        schedule_id: scheduleId,
+        event_id: eventId || null,
+        chat_topic_id: msg.chat_topic_id ? String(msg.chat_topic_id) : null,
+        provider_user_id: msg.provider_user_id != null ? Number(msg.provider_user_id) : null,
+        started_at: Date.now(),
+        browser_info: msg.browser_info ?? {}
+      };
+      pending.resolve(match);
+    }
+  }
+  _onRentError(msg) {
+    const eventId = String(msg.event_id ?? "");
+    const code = String(msg.code ?? "");
+    const message = String(msg.message ?? "");
+    let pending = this._pendingRents.get(`event:${eventId}`);
+    if (!pending) {
+      for (const [key, p] of this._pendingRents) {
+        pending = p;
+        this._pendingRents.delete(key);
+        break;
+      }
+    } else {
+      this._pendingRents.delete(`event:${eventId}`);
+    }
+    if (pending) {
+      clearTimeout(pending.timer);
+      if (code === "provider_offline") {
+        pending.reject(new ProviderOffline(message));
+      } else {
+        pending.reject(new TransportError(message || `Rent error: ${code}`));
+      }
+    }
+  }
+  _onResumeOk(msg) {
+    const sessionId = String(msg.session_id ?? "");
+    const pending = this._pendingResumes.get(sessionId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this._pendingResumes.delete(sessionId);
+    const match = {
+      session_id: sessionId,
+      event_id: msg.event_id != null ? String(msg.event_id) : null,
+      schedule_id: Number(msg.schedule_id ?? 0),
+      chat_topic_id: msg.chat_topic_id ? String(msg.chat_topic_id) : null,
+      provider_user_id: msg.provider_user_id != null ? Number(msg.provider_user_id) : null,
+      started_at: Date.now(),
+      browser_info: msg.browser_info ?? {}
+    };
+    pending.resolve(match);
+  }
+  _onResumeFailed(msg) {
+    const sessionId = String(msg.session_id ?? "");
+    const reason = String(msg.reason ?? "");
+    const pending = this._pendingResumes.get(sessionId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this._pendingResumes.delete(sessionId);
+    switch (reason) {
+      case "expired":
+        pending.reject(new SessionExpired());
+        break;
+      case "not_owner":
+        pending.reject(new NotOwner());
+        break;
+      case "not_found":
+        pending.reject(new SessionNotFound());
+        break;
+      default:
+        pending.reject(new SessionNotFound(reason));
+    }
+  }
+  _onError(msg) {
+    const code = Number(msg.code ?? 0);
+    const reason = String(msg.reason ?? msg.message ?? "");
+    const sessionId = msg.session_id ? String(msg.session_id) : null;
+    if (sessionId) {
+      const browser = this._activeBrowsers.get(sessionId);
+      if (browser) {
+        switch (code) {
+          case -1011:
+            browser._onSessionEnded({ reason: "heartbeat_timeout" });
+            return;
+          case -1012:
+            browser._onError({ reason: "insufficient_funds" });
+            return;
+          case -1013:
+            browser._onError({ reason: "rate_limit_exceeded" });
+            return;
+          case -1015:
+            browser._onSessionEnded({ reason: "provider_declined" });
+            return;
+          case -1018:
+            browser._onSessionEnded({ reason: "killed" });
+            return;
+          case -1050:
+            browser._onError({ reason: `cdp_unrecoverable: ${reason}` });
+            return;
+          default:
+            browser._onError(msg);
+            return;
+        }
+      }
+    }
+    let err;
+    switch (code) {
+      case -1012:
+        err = new InsufficientFunds(reason);
+        this._rejectAllPending(err);
+        break;
+      case -1013:
+        err = new RateLimitExceeded(0, reason);
+        this._rejectAllPending(err);
+        break;
+      case -1015:
+        err = new ProviderOffline(reason);
+        this._rejectFirstPendingRent(err);
+        break;
+      default:
+        err = new CekiBrowserError(reason || `relay error ${code}`);
+        this._rejectFirstPendingRent(err);
+        break;
+    }
+  }
+  _rejectFirstPendingRent(err) {
+    const eventId = this._pendingRents.keys().next().value;
+    if (eventId != null) {
+      const pending = this._pendingRents.get(eventId);
+      clearTimeout(pending.timer);
+      this._pendingRents.delete(eventId);
+      pending.reject(err);
+    }
+  }
+  _rejectAllPending(err) {
+    for (const [key, pending] of this._pendingRents) {
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this._pendingRents.clear();
+    for (const [key, pending] of this._pendingResumes) {
+      clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this._pendingResumes.clear();
+  }
+  _resolveHumanizer(opts) {
+    if (process.env.CEKI_HUMAN_DISABLE === "1") return null;
+    const human = opts?.human;
+    if (human === null || human === void 0) {
+      const envPreset = process.env.CEKI_HUMAN_PROFILE;
+      const envPath = process.env.CEKI_HUMAN_PROFILE_PATH;
+      if (envPath) return new Humanizer(HumanProfile.load(envPath));
+      if (envPreset) return new Humanizer(HumanProfile.loadPreset(envPreset));
+      return new Humanizer(HumanProfile.loadPreset("natural"));
+    }
+    if (human === "natural" || human === "careful") {
+      return new Humanizer(HumanProfile.loadPreset(human));
+    }
+    return null;
+  }
+};
+async function connect(apiKey, opts) {
+  return Client.create(apiKey, opts);
+}
+export {
+  AuthError,
+  Browser,
+  BrowserChat,
+  BrowserProfile,
+  CaptchaError,
+  CaptchaTimeoutError,
+  CdpUnrecoverable,
+  CekiBrowserError,
+  ChatSendFailed,
+  Client,
+  ConnectionLost,
+  HumanProfile,
+  Humanizer,
+  InsufficientFunds,
+  NotOwner,
+  ProviderDisconnected,
+  ProviderOffline,
+  RateLimitExceeded,
+  SessionEnded,
+  SessionExpired,
+  SessionNotFound,
+  TimeoutError,
+  TransportError,
+  connect
+};
+//# sourceMappingURL=index.js.map