@ceki/sdk 1.9.0

package/dist/cli.js

@@ -0,0 +1,2658 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import * as fs4 from "fs";
+import * as path3 from "path";
+
+// 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 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((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingSends.delete(clientMsgId);
+        reject(new TimeoutError("Chat send timed out"));
+      }, 15e3);
+      this._pendingSends.set(clientMsgId, { resolve: resolve2, 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((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this._pendingSends.delete(clientMsgId);
+        reject(new TimeoutError("Chat sendImage timed out"));
+      }, 15e3);
+      this._pendingSends.set(clientMsgId, { resolve: resolve2, 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 deleteSession(sid) {
+  try {
+    fs2.unlinkSync(statePath(sid));
+  } catch (err2) {
+    if (err2.code !== "ENOENT") throw err2;
+  }
+}
+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((resolve2) => {
+      this._resolveEnded = resolve2;
+    });
+    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((resolve2, 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: resolve2, 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 fs5 = await import("fs");
+      const path4 = await import("path");
+      buf = fs5.readFileSync(source);
+      resolvedFilename = filename ?? path4.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((resolve2, reject) => {
+        const timer = setTimeout(() => {
+          waiter = null;
+          reject(new Error("timeout"));
+        }, timeoutMs);
+        waiter = (action) => {
+          clearTimeout(timer);
+          resolve2(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(err2) {
+    for (const [id, pending] of this._pendingCdp) {
+      clearTimeout(pending.timer);
+      pending.reject(err2);
+    }
+    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((resolve2) => setTimeout(resolve2, 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((resolve2, 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(() => {
+            });
+          }
+          resolve2(browser);
+        },
+        reject,
+        timer
+      });
+    });
+  }
+  async resume(sessionId, opts) {
+    this._wsSend({ type: "resume", session_id: sessionId });
+    return new Promise((resolve2, 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);
+          resolve2(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((resolve2, reject) => {
+      this._connectResolve = resolve2;
+      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 err2 = new AuthError(reasonStr || `Auth failed (${code})`);
+        if (this._connectReject) {
+          this._connectReject(err2);
+          this._connectResolve = null;
+          this._connectReject = null;
+        }
+        return;
+      }
+      if (!this._closed && this._reconnect) {
+        this._scheduleReconnect();
+      }
+    });
+    this._ws.on("error", (err2) => {
+      if (this._connectReject) {
+        this._connectReject(new TransportError(err2.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 err2 = new ConnectionLost("Max reconnection attempts exceeded");
+      this._rejectAllPending(err2);
+      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 err2;
+    switch (code) {
+      case -1012:
+        err2 = new InsufficientFunds(reason);
+        this._rejectAllPending(err2);
+        break;
+      case -1013:
+        err2 = new RateLimitExceeded(0, reason);
+        this._rejectAllPending(err2);
+        break;
+      case -1015:
+        err2 = new ProviderOffline(reason);
+        this._rejectFirstPendingRent(err2);
+        break;
+      default:
+        err2 = new CekiBrowserError(reason || `relay error ${code}`);
+        this._rejectFirstPendingRent(err2);
+        break;
+    }
+  }
+  _rejectFirstPendingRent(err2) {
+    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(err2);
+    }
+  }
+  _rejectAllPending(err2) {
+    for (const [key, pending] of this._pendingRents) {
+      clearTimeout(pending.timer);
+      pending.reject(err2);
+    }
+    this._pendingRents.clear();
+    for (const [key, pending] of this._pendingResumes) {
+      clearTimeout(pending.timer);
+      pending.reject(err2);
+    }
+    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);
+}
+
+// src/cli.ts
+function out(data) {
+  process.stdout.write(JSON.stringify(data) + "\n");
+}
+function err(error, code = "error") {
+  process.stderr.write(JSON.stringify({ error, code }) + "\n");
+}
+function getApiKey() {
+  const key = process.env.CEKI_API_KEY;
+  if (!key) {
+    err("CEKI_API_KEY not set", "auth");
+    process.exit(2);
+  }
+  return key;
+}
+function connectOptions() {
+  return { reconnect: false };
+}
+async function resumeBrowser(apiKey, sessionId) {
+  const client = await connect(apiKey, connectOptions());
+  const browser = await client.resume(sessionId, { human: null });
+  return [client, browser];
+}
+async function closeClient(client) {
+  try {
+    await client.disconnect();
+  } catch {
+  }
+}
+function parseBool(val) {
+  return val === "true" || val === "1" || val === "yes";
+}
+async function cmdRent(args) {
+  let scheduleId = null;
+  let fingerprintFrom = null;
+  let mode = "incognito";
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--schedule" && args[i + 1]) scheduleId = parseInt(args[++i], 10);
+    if (args[i] === "--fingerprint-from" && args[i + 1]) fingerprintFrom = args[++i];
+    if (args[i] === "--mode" && args[i + 1]) {
+      const v = args[++i];
+      if (v !== "incognito" && v !== "main") {
+        err("invalid mode, must be incognito or main", "args");
+        process.exit(1);
+      }
+      mode = v;
+    }
+  }
+  if (scheduleId == null) {
+    err("--schedule is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  let fpData = true;
+  if (fingerprintFrom) {
+    const profile = JSON.parse(fs4.readFileSync(fingerprintFrom, "utf-8"));
+    fpData = profile.fingerprint || true;
+  }
+  const client = await connect(apiKey, connectOptions());
+  try {
+    const browser = await client.rent(scheduleId, { human: null, fingerprint: fpData, mode });
+    saveSession(browser.sessionId, {
+      session_id: browser.sessionId,
+      chat_topic_id: browser.chatTopicId,
+      schedule_id: browser.scheduleId,
+      last_seen_ts: null
+    });
+    out({
+      session_id: browser.sessionId,
+      chat_topic_id: browser.chatTopicId,
+      schedule_id: browser.scheduleId
+    });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdSearch(args) {
+  let limit = 20;
+  const filters = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--limit" && args[i + 1]) limit = parseInt(args[++i], 10);
+    if (args[i] === "--filter" && args[i + 1]) {
+      const [k, ...v] = args[++i].split("=");
+      filters[k] = v.join("=");
+    }
+  }
+  const apiKey = getApiKey();
+  const client = await connect(apiKey, connectOptions());
+  try {
+    const results = await client.search(filters, limit);
+    out(results);
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdSessions(args) {
+  let showAll = false;
+  let limit = 50;
+  let jsonOutput = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--all") showAll = true;
+    else if (args[i] === "--json") jsonOutput = true;
+    else if (args[i] === "--limit" && args[i + 1]) limit = Number(args[++i]);
+  }
+  const apiKey = getApiKey();
+  const client = await connect(apiKey, connectOptions());
+  try {
+    const results = await client.listSessions({ active: !showAll, limit });
+    if (jsonOutput) {
+      out(results);
+    } else {
+      if (!results.length) {
+        process.stdout.write("No sessions found.\n");
+        return;
+      }
+      const header = "SID".padEnd(8) + "SCHEDULE".padEnd(10) + "STARTED".padEnd(22) + "DURATION".padEnd(10) + "EARNED".padEnd(9) + "STATUS".padEnd(10) + "RENTER".padEnd(16) + "PROVIDER";
+      process.stdout.write(header + "\n");
+      for (const s of results) {
+        const started = s.started_at ?? "\u2014";
+        const mins = Math.floor(s.duration / 60);
+        const secs = s.duration % 60;
+        const dur = `${mins}:${String(secs).padStart(2, "0")}`;
+        const earned = `$${s.earned.toFixed(2)}`;
+        const renter = s.renter?.name ?? "\u2014";
+        const provider = s.provider?.name ?? "\u2014";
+        const line = String(s.id).padEnd(8) + String(s.schedule_id).padEnd(10) + started.padEnd(22) + dur.padEnd(10) + earned.padEnd(9) + s.status.padEnd(10) + renter.padEnd(16) + provider;
+        process.stdout.write(line + "\n");
+      }
+    }
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdMyBrowsers() {
+  const apiKey = getApiKey();
+  const client = await connect(apiKey, connectOptions());
+  try {
+    const results = await client.myBrowsers();
+    out(results);
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdSnapshot(sid, args) {
+  let outputPath = null;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "-o" || args[i] === "--output") && args[i + 1]) outputPath = args[++i];
+  }
+  if (!outputPath) {
+    err("-o/--output is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const lastSeen = getLastSeenTs(sid);
+    browser._lastSeenTs = lastSeen;
+    const snap = await browser.snapshot();
+    const pngBuf = Buffer.from(snap.screenshot, "base64");
+    fs4.writeFileSync(outputPath, pngBuf);
+    if (browser._lastSeenTs) {
+      updateLastSeenTs(sid, browser._lastSeenTs);
+    }
+    const chatList = snap.chat.map((m) => ({
+      from: m.sender_id,
+      text: m.text,
+      ts: m.created_at
+    }));
+    out({ screenshot: outputPath, chat: chatList, ts: snap.ts.toISOString() });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdNavigate(sid, args) {
+  const url = args[0];
+  if (!url) {
+    err("URL is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.navigate(url);
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdClick(sid, args) {
+  const x = parseInt(args[0], 10);
+  const y = parseInt(args[1], 10);
+  if (isNaN(x) || isNaN(y)) {
+    err("x and y coordinates are required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.click(x, y);
+    out({ ok: true, pointer: [x, y] });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdType(sid, args) {
+  let text = "";
+  let natural = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--natural") natural = true;
+    else if (!text) text = args[i];
+  }
+  if (!text) {
+    err("text is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const human = natural ? "natural" : null;
+  const client = await connect(apiKey, connectOptions());
+  try {
+    const browser = await client.resume(sid, { human });
+    if (!natural) {
+      browser._humanizer = null;
+    }
+    await browser.type(text);
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdScroll(sid, args) {
+  const x = parseInt(args[0], 10);
+  const y = parseInt(args[1], 10);
+  const dy = parseInt(args[2], 10);
+  if (isNaN(x) || isNaN(y) || isNaN(dy)) {
+    err("x, y, dy are required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.scroll({ x, y, deltaY: dy });
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdChat(sid, action, args) {
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    switch (action) {
+      case "send": {
+        const text = args[0];
+        if (!text) {
+          err("text is required", "args");
+          process.exit(1);
+        }
+        const result = await browser.chat.send(text);
+        out({ ok: true, message_id: result.messageId });
+        break;
+      }
+      case "send-image": {
+        let imagePath = null;
+        let text;
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === "--image" && args[i + 1]) imagePath = args[++i];
+          if (args[i] === "--text" && args[i + 1]) text = args[++i];
+        }
+        if (!imagePath) {
+          err("--image is required", "args");
+          process.exit(1);
+        }
+        if (text) {
+          await browser.chat.send(text);
+        }
+        const result = await browser.chat.sendImage(imagePath);
+        out({ ok: true, message_id: result.messageId });
+        break;
+      }
+      case "next": {
+        let timeout = 60;
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === "--timeout" && args[i + 1]) timeout = parseFloat(args[++i]);
+        }
+        const lastSeen = getLastSeenTs(sid);
+        const msgs = await browser.chat.history({ since: lastSeen ?? void 0 });
+        if (msgs.length > 0) {
+          const m = msgs[0];
+          updateLastSeenTs(sid, m.created_at);
+          out({ from: m.sender_id, text: m.text, ts: m.created_at });
+        } else {
+          let resolved = false;
+          const waitPromise = new Promise((resolve2) => {
+            const timer = setTimeout(() => {
+              if (!resolved) {
+                resolved = true;
+                resolve2(null);
+              }
+            }, timeout * 1e3);
+            browser.chat.onMessage((msg2) => {
+              if (!resolved) {
+                resolved = true;
+                clearTimeout(timer);
+                resolve2(msg2);
+              }
+            });
+          });
+          const msg = await waitPromise;
+          if (msg) {
+            updateLastSeenTs(sid, msg.created_at);
+            out({ from: msg.sender_id, text: msg.text, ts: msg.created_at });
+          } else {
+            out(null);
+          }
+        }
+        break;
+      }
+      case "history": {
+        let since;
+        let limit = 50;
+        for (let i = 0; i < args.length; i++) {
+          if (args[i] === "--since" && args[i + 1]) {
+            const val = args[++i];
+            const asNum = Number(val);
+            if (!isNaN(asNum) && val.match(/^\d+(\.\d+)?$/)) {
+              since = new Date(asNum * 1e3).toISOString();
+            } else {
+              since = val;
+            }
+          }
+          if (args[i] === "--limit" && args[i + 1]) limit = parseInt(args[++i], 10);
+        }
+        const msgs = await browser.chat.history({ since, limit });
+        out(msgs.map((m) => ({ from: m.sender_id, text: m.text, ts: m.created_at })));
+        break;
+      }
+      default:
+        err(`Unknown chat action: ${action}`, "args");
+        process.exit(1);
+    }
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdStop(sid) {
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.close();
+    deleteSession(sid);
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdProfile(sid, action, args) {
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    switch (action) {
+      case "export": {
+        let outputPath = null;
+        let domains;
+        let noSessionStorage = false;
+        for (let i = 0; i < args.length; i++) {
+          if ((args[i] === "-o" || args[i] === "--output") && args[i + 1]) outputPath = args[++i];
+          if (args[i] === "--domains" && args[i + 1]) domains = args[++i].split(",").map((d) => d.trim());
+          if (args[i] === "--no-session-storage") noSessionStorage = true;
+        }
+        if (!outputPath) {
+          err("-o/--output is required", "args");
+          process.exit(1);
+        }
+        const profile = await browser.profile.export({
+          domains,
+          includeSessionStorage: !noSessionStorage
+        });
+        fs4.writeFileSync(outputPath, JSON.stringify(profile, null, 2), "utf-8");
+        out({ ok: true, path: outputPath });
+        break;
+      }
+      case "import": {
+        let inputPath = null;
+        for (let i = 0; i < args.length; i++) {
+          if ((args[i] === "-i" || args[i] === "--input") && args[i + 1]) inputPath = args[++i];
+        }
+        if (!inputPath) {
+          err("-i/--input is required", "args");
+          process.exit(1);
+        }
+        const profileData = JSON.parse(fs4.readFileSync(inputPath, "utf-8"));
+        await browser.profile.import(profileData);
+        out({ ok: true });
+        break;
+      }
+      default:
+        err(`Unknown profile action: ${action}`, "args");
+        process.exit(1);
+    }
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdWait(sid) {
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const reason = await browser.waitUntilEnded();
+    out({ ended: true, reason });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdScreenshot(sid, args) {
+  let outputPath = null;
+  let fullPage = false;
+  for (let i = 0; i < args.length; i++) {
+    if ((args[i] === "-o" || args[i] === "--output") && args[i + 1]) outputPath = args[++i];
+    if (args[i] === "--full") fullPage = true;
+  }
+  if (!outputPath) {
+    err("-o/--output is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const data = await browser.screenshot({ format: "png", fullPage });
+    fs4.writeFileSync(outputPath, data);
+    out({ ok: true, path: outputPath });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdSwitchTab(sid) {
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.switchTab();
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdConfigure(sid, args) {
+  const opts = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--masking-mode" && args[i + 1]) opts.maskingMode = parseBool(args[++i]);
+    if (args[i] === "--fingerprint" && args[i + 1]) opts.fingerprint = parseBool(args[++i]);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    await browser.configure(opts);
+    out({ ok: true });
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdCdp(sid, args) {
+  let method = null;
+  let params = {};
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--method" && args[i + 1]) method = args[++i];
+    if (args[i] === "--params" && args[i + 1]) params = JSON.parse(args[++i]);
+  }
+  if (!method) {
+    err("--method is required", "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const result = await browser.send({ method, params });
+    out(result);
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdRequestCaptcha(sid, args) {
+  let acceptance = 60;
+  let completion = 120;
+  let manual = false;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--acceptance" && args[i + 1]) acceptance = parseFloat(args[++i]);
+    if (args[i] === "--completion" && args[i + 1]) completion = parseFloat(args[++i]);
+    if (args[i] === "--manual") manual = true;
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const result = await browser.requestCaptcha({
+      acceptanceTimeout: acceptance,
+      completionTimeout: completion,
+      autoAccept: !manual
+    });
+    out({
+      solved: result.solved,
+      proof_message_id: result.proofMessageId,
+      cancel_reason: result.cancelReason,
+      child_event_id: result.childEventId,
+      correction_id: result.correctionId
+    });
+    if (!result.solved) process.exit(1);
+  } catch (e) {
+    if (e instanceof CaptchaTimeoutError) {
+      out({ solved: false, cancel_reason: `timeout:${e.phase}`, child_event_id: null, correction_id: null });
+      process.exit(1);
+    }
+    throw e;
+  } finally {
+    await closeClient(client);
+  }
+}
+async function cmdUpload(sid, args) {
+  let selector = null;
+  let filePath = null;
+  let filename;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--selector" && args[i + 1]) selector = args[++i];
+    if (args[i] === "--file" && args[i + 1]) filePath = args[++i];
+    if (args[i] === "--filename" && args[i + 1]) filename = args[++i];
+  }
+  if (!selector || !filePath) {
+    err("--selector and --file are required", "args");
+    process.exit(1);
+  }
+  if (!fs4.existsSync(filePath)) {
+    err(`File not found: ${filePath}`, "args");
+    process.exit(1);
+  }
+  const apiKey = getApiKey();
+  const [client, browser] = await resumeBrowser(apiKey, sid);
+  try {
+    const result = await browser.upload(selector, filePath, filename);
+    out(result);
+  } finally {
+    await closeClient(client);
+  }
+}
+function printHelp() {
+  console.log(`ceki-browser \u2014 CLI for browser.ceki.me rental
+
+Usage: ceki-browser <command> [options]
+
+Commands:
+  rent --schedule N [--fingerprint-from PATH]
+  my-browsers
+  search [--limit N] [--filter k=v]...
+  snapshot <sid> -o PATH
+  screenshot <sid> -o PATH [--full]
+  navigate <sid> <url>
+  click <sid> <x> <y>
+  type <sid> "<text>" [--natural]
+  scroll <sid> <x> <y> <dy>
+  switch-tab <sid>
+  configure <sid> [--masking-mode true|false] [--fingerprint true|false]
+  cdp <sid> --method <M> [--params JSON]
+  upload <sid> --selector CSS --file PATH [--filename NAME]
+  request-captcha <sid> [--acceptance N] [--completion M] [--manual]
+  wait <sid>
+  chat <sid> send "<text>"
+  chat <sid> send-image --image PATH [--text "..."]
+  chat <sid> next [--timeout N]
+  chat <sid> history [--since TS] [--limit N]
+  profile export <sid> -o file [--domains a,b,c] [--no-session-storage]
+  profile import <sid> -i file
+  stop <sid>
+
+Environment:
+  CEKI_API_KEY (required)
+  CEKI_RELAY_URL (default: wss://browser.ceki.me/ws/agent)
+  CEKI_API_URL (default: https://api.ceki.me)
+  CEKI_CHAT_URL (default: https://chat.ceki.me/api/chat)
+  CEKI_BASIC_AUTH_USER / CEKI_BASIC_AUTH_PASS (optional)
+
+Exit codes: 0=success, 1=error, 2=auth, 3=session_not_found, 4=timeout, 5=network`);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.length === 0 || argv[0] === "--help" || argv[0] === "-h") {
+    printHelp();
+    process.exit(0);
+  }
+  if (argv[0] === "--version" || argv[0] === "-v") {
+    const pkgPath = path3.resolve(path3.dirname(new URL(import.meta.url).pathname), "..", "package.json");
+    try {
+      const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
+      console.log(pkg.version);
+    } catch {
+      console.log("unknown");
+    }
+    process.exit(0);
+  }
+  const command = argv[0];
+  const rest = argv.slice(1);
+  switch (command) {
+    case "rent":
+      await cmdRent(rest);
+      break;
+    case "search":
+      await cmdSearch(rest);
+      break;
+    case "sessions":
+      await cmdSessions(rest);
+      break;
+    case "my-browsers":
+      await cmdMyBrowsers();
+      break;
+    case "snapshot":
+      await cmdSnapshot(rest[0], rest.slice(1));
+      break;
+    case "navigate":
+      await cmdNavigate(rest[0], rest.slice(1));
+      break;
+    case "click":
+      await cmdClick(rest[0], rest.slice(1));
+      break;
+    case "type":
+      await cmdType(rest[0], rest.slice(1));
+      break;
+    case "scroll":
+      await cmdScroll(rest[0], rest.slice(1));
+      break;
+    case "switch-tab":
+      await cmdSwitchTab(rest[0]);
+      break;
+    case "configure":
+      await cmdConfigure(rest[0], rest.slice(1));
+      break;
+    case "cdp":
+      await cmdCdp(rest[0], rest.slice(1));
+      break;
+    case "upload":
+      await cmdUpload(rest[0], rest.slice(1));
+      break;
+    case "request-captcha":
+      await cmdRequestCaptcha(rest[0], rest.slice(1));
+      break;
+    case "wait":
+      await cmdWait(rest[0]);
+      break;
+    case "stop":
+      await cmdStop(rest[0]);
+      break;
+    case "screenshot":
+      await cmdScreenshot(rest[0], rest.slice(1));
+      break;
+    case "chat":
+      if (rest.length < 2) {
+        err("Usage: ceki-browser chat <sid> <action> [args]", "args");
+        process.exit(1);
+      }
+      await cmdChat(rest[0], rest[1], rest.slice(2));
+      break;
+    case "profile":
+      if (rest.length < 2) {
+        err("Usage: ceki-browser profile export|import <sid> [args]", "args");
+        process.exit(1);
+      }
+      await cmdProfile(rest[1], rest[0], rest.slice(2));
+      break;
+    default:
+      err(`Unknown command: ${command}`, "args");
+      process.exit(1);
+  }
+}
+main().catch((e) => {
+  if (e instanceof SessionExpired || e instanceof SessionNotFound) {
+    err(String(e), "session_not_found");
+    process.exit(3);
+  }
+  if (e instanceof NotOwner) {
+    err(String(e), "not_owner");
+    process.exit(3);
+  }
+  if (e instanceof TimeoutError) {
+    err(String(e), "timeout");
+    process.exit(4);
+  }
+  if (e instanceof ConnectionLost || e instanceof AuthError || e instanceof TransportError) {
+    err(String(e), "network");
+    process.exit(5);
+  }
+  if (e instanceof CekiBrowserError) {
+    err(String(e), "ceki_error");
+    process.exit(1);
+  }
+  err(e instanceof Error ? e.message : String(e), "error");
+  process.exit(1);
+});
+//# sourceMappingURL=cli.js.map