@ceki/n8n-nodes-ceki 0.2.5 → 0.2.7

package/dist/index.js

@@ -0,0 +1,1384 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.ts
+var index_exports = {};
+__export(index_exports, {
+  credentials: () => credentials,
+  nodes: () => nodes
+});
+module.exports = __toCommonJS(index_exports);
+
+// lib/ceki-client.ts
+function jsonParse(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var CekiClient = class {
+  constructor(_token, _relayUrl = "wss://browser.ceki.me/ws/agent", _apiUrl = "https://api.ceki.me") {
+    this._token = _token;
+    this._relayUrl = _relayUrl;
+    this._apiUrl = _apiUrl;
+    this._ws = null;
+    this._connected = false;
+    this._pendingRents = /* @__PURE__ */ new Map();
+    this._pendingResumes = /* @__PURE__ */ new Map();
+    this._pendingCdp = /* @__PURE__ */ new Map();
+    this._cdpCounter = 1;
+    this._activeSessions = /* @__PURE__ */ new Map();
+    this._connectReject = null;
+    this._closed = false;
+  }
+  /** Connect to the relay WebSocket. */
+  async connect() {
+    if (this._connected) return;
+    const protocols = [`bearer.${this._token}`];
+    this._ws = new WebSocket(this._relayUrl, protocols);
+    this._ws.onopen = () => {
+      this._connected = true;
+    };
+    this._ws.onmessage = (ev) => {
+      this._handleMessage(ev.data);
+    };
+    this._ws.onclose = (ev) => {
+      this._connected = false;
+      if ((ev.code === 4401 || ev.code === 4403) && this._connectReject) {
+        this._connectReject(new Error(`Auth failed: ${ev.reason || String(ev.code)}`));
+        this._connectReject = null;
+      }
+    };
+    this._ws.onerror = () => {
+      if (!this._connected && this._connectReject) {
+        this._connectReject(new Error("WebSocket connection failed"));
+        this._connectReject = null;
+      }
+    };
+    if (this._ws.readyState === WebSocket.CONNECTING) {
+      await new Promise((resolve, reject) => {
+        if (!this._ws) {
+          reject(new Error("No WebSocket"));
+          return;
+        }
+        this._connectReject = reject;
+        this._ws.onopen = () => {
+          this._connected = true;
+          resolve();
+        };
+      });
+    }
+  }
+  _sendRaw(msg) {
+    if (!this._ws || this._ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket not connected");
+    }
+    this._ws.send(JSON.stringify(msg));
+  }
+  /** Search for available browser providers (HTTP GET). */
+  async search(filters, limit) {
+    const params = new URLSearchParams();
+    if (limit != null) params.set("limit", String(limit));
+    if (filters) {
+      for (const [k, v] of Object.entries(filters)) {
+        if (v != null) params.set(k, String(v));
+      }
+    }
+    const resp = await fetch(`${this._apiUrl}/api/browsers/search?${params}`, {
+      headers: { Authorization: `Bearer ${this._token}` }
+    });
+    if (!resp.ok) throw new Error(`Search failed: ${resp.status}`);
+    const body = await resp.json();
+    const data = body.data ?? body;
+    return Array.isArray(data) ? data : [];
+  }
+  /** Rent a browser by schedule_id. */
+  async rent(scheduleId, opts) {
+    const msg = { type: "rent", browser_id: scheduleId };
+    if (opts?.mode) msg.mode = opts.mode;
+    this._sendRaw(msg);
+    return this._awaitRent(`rent:${scheduleId}`, scheduleId, 9e4);
+  }
+  /** Resume an existing session. */
+  async resume(sessionId) {
+    this._sendRaw({ type: "resume", session_id: sessionId });
+    return this._awaitResume(sessionId);
+  }
+  /** Close the WS connection — session stays alive in grace. */
+  disconnect() {
+    this._closed = true;
+    this._activeSessions.clear();
+    this._pendingRents.clear();
+    this._pendingResumes.clear();
+    this._closeWs();
+  }
+  /** Close everything. */
+  close() {
+    this.disconnect();
+  }
+  // ── private ────────────────────────────────────────────────
+  _awaitRent(key, scheduleId, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timeoutSignal = AbortSignal.timeout(timeoutMs);
+      timeoutSignal.addEventListener("abort", () => {
+        this._pendingRents.delete(key);
+        reject(new Error("Rent timed out"));
+      }, { once: true });
+      this._pendingRents.set(key, {
+        resolve: (match) => {
+          const browser = new CekiBrowser(this, match);
+          this._activeSessions.set(browser.sessionId, browser);
+          resolve(browser);
+        },
+        reject: (err) => {
+          reject(err);
+        }
+      });
+    });
+  }
+  _awaitResume(sessionId) {
+    return new Promise((resolve, reject) => {
+      const timeoutSignal = AbortSignal.timeout(1e4);
+      timeoutSignal.addEventListener("abort", () => {
+        this._pendingResumes.delete(sessionId);
+        reject(new Error("Resume timed out"));
+      }, { once: true });
+      this._pendingResumes.set(sessionId, {
+        resolve: (match) => {
+          const browser = new CekiBrowser(this, match);
+          this._activeSessions.set(browser.sessionId, browser);
+          resolve(browser);
+        },
+        reject: (err) => {
+          reject(err);
+        }
+      });
+    });
+  }
+  _closeWs() {
+    if (this._ws) {
+      try {
+        this._ws.onopen = null;
+        this._ws.onmessage = null;
+        this._ws.onclose = null;
+        this._ws.onerror = null;
+        this._ws.close();
+      } catch {
+      }
+      this._ws = null;
+    }
+  }
+  _handleMessage(data) {
+    const msg = jsonParse(String(data));
+    if (!msg || typeof msg !== "object") return;
+    const type = String(msg.type ?? "");
+    const sid = msg.session_id ? String(msg.session_id) : null;
+    switch (type) {
+      case "pong":
+      case "rent_pending":
+        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 (sid) this._onCdpResponse(sid, msg);
+        break;
+      case "session.ended":
+        if (sid) {
+          this._activeSessions.delete(sid);
+          const b = this._activeSessions.get(sid);
+          if (b) b._ended = String(msg.reason ?? "ended");
+        }
+        break;
+    }
+  }
+  _onMatch(msg) {
+    const scheduleId = Number(msg.schedule_id ?? 0);
+    const eventId = msg.event_id ? String(msg.event_id) : null;
+    let pending = this._pendingRents.get(`event:${eventId}`);
+    if (!pending) pending = this._pendingRents.get(`rent:${scheduleId}`);
+    if (pending) {
+      this._pendingRents.delete(`event:${eventId}`);
+      this._pendingRents.delete(`rent:${scheduleId}`);
+      pending.resolve({
+        session_id: String(msg.session_id ?? ""),
+        schedule_id: scheduleId,
+        event_id: eventId,
+        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,
+        browser_info: msg.browser_info ?? {}
+      });
+    }
+  }
+  _onRentError(msg) {
+    const code = String(msg.code ?? "");
+    const message = String(msg.message ?? "");
+    for (const [key, pending] of this._pendingRents) {
+      this._pendingRents.delete(key);
+      pending.reject(new Error(message || `Rent error: ${code}`));
+      return;
+    }
+  }
+  _onResumeOk(msg) {
+    const sessionId = String(msg.session_id ?? "");
+    const pending = this._pendingResumes.get(sessionId);
+    if (!pending) return;
+    this._pendingResumes.delete(sessionId);
+    pending.resolve({
+      session_id: sessionId,
+      schedule_id: Number(msg.schedule_id ?? 0),
+      event_id: msg.event_id ? String(msg.event_id) : 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,
+      browser_info: msg.browser_info ?? {}
+    });
+  }
+  _onResumeFailed(msg) {
+    const sessionId = String(msg.session_id ?? "");
+    const pending = this._pendingResumes.get(sessionId);
+    if (!pending) return;
+    this._pendingResumes.delete(sessionId);
+    pending.reject(new Error(String(msg.reason ?? "Resume failed")));
+  }
+  _onCdpResponse(sessionId, msg) {
+    const browser = this._activeSessions.get(sessionId);
+    if (!browser) return;
+    const id = Number(msg.id ?? 0);
+    const pending = this._pendingCdp.get(id);
+    if (!pending) return;
+    this._pendingCdp.delete(id);
+    if (msg.error) {
+      pending.reject(new Error(String(msg.error.message ?? "CDP error")));
+    } else {
+      pending.resolve(msg.result);
+    }
+  }
+};
+var CekiBrowser = class {
+  constructor(client, match) {
+    this._cdpId = 1;
+    this._pendingCdp = /* @__PURE__ */ new Map();
+    this._client = client;
+    this.sessionId = match.session_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;
+  }
+  /** Send a CDP command. Uses AbortSignal.timeout() (no restricted setTimeout global). */
+  async send(method, params, timeoutMs = 3e4) {
+    const id = this._cdpId++;
+    const msg = { type: "cdp", session_id: this.sessionId, id, method, params: params ?? {} };
+    this._client._sendRaw(msg);
+    return new Promise((resolve, reject) => {
+      const timeoutSignal = AbortSignal.timeout(timeoutMs);
+      timeoutSignal.addEventListener("abort", () => {
+        this._pendingCdp.delete(id);
+        reject(new Error(`CDP ${method} timed out after ${timeoutMs}ms`));
+      }, { once: true });
+      this._pendingCdp.set(id, {
+        resolve: (v) => {
+          resolve(v);
+        },
+        reject: (e) => {
+          reject(e);
+        }
+      });
+    });
+  }
+  async navigate(url, timeoutMs) {
+    await this.send("Page.navigate", { url }, timeoutMs);
+  }
+  async click(x, y) {
+    await this.send("Input.dispatchMouseEvent", { type: "mousePressed", x, y, button: "left", clickCount: 1 });
+    await this.send("Input.dispatchMouseEvent", { type: "mouseReleased", x, y, button: "left", clickCount: 1 });
+  }
+  async type(text) {
+    await this.send("Ceki.typeText", { text });
+  }
+  async scroll(deltaY) {
+    await this.send("Input.dispatchMouseEvent", { type: "mouseWheel", x: 0, y: 0, deltaX: 0, deltaY });
+  }
+  async screenshot(opts) {
+    const format = opts?.format ?? "base64";
+    const fullPage = opts?.fullPage ?? false;
+    let clip;
+    if (fullPage) {
+      const metrics = await this.send("Page.getLayoutMetrics");
+      const contentSize = metrics?.contentSize;
+      if (contentSize) {
+        clip = { x: 0, y: 0, width: Number(contentSize.width ?? 1920), height: Math.min(Number(contentSize.height ?? 1080), 16384), scale: 1 };
+      }
+    }
+    const result = await this.send("Page.captureScreenshot", { format: "png", ...clip ? { clip } : {} });
+    const data = String(result?.data ?? "");
+    if (format === "png") {
+      return Buffer.from(data, "base64");
+    }
+    return { data };
+  }
+  async snapshot() {
+    const ssResult = await this.screenshot({ format: "base64" });
+    return { screenshot: ssResult.data, ts: /* @__PURE__ */ new Date() };
+  }
+  async upload(selector, buf, filename = "file") {
+    const b64 = buf.toString("base64");
+    const size = buf.length;
+    const mime = "application/octet-stream";
+    const expression = `(function(){
+			var input = document.querySelector(${JSON.stringify(selector)});
+			if (!input) return JSON.stringify({ok:false,error:'Element not found'});
+			var b = atob(${JSON.stringify(b64)});
+			var u = new Uint8Array(b.length);
+			for (var i = 0; i < b.length; i++) u[i] = b.charCodeAt(i);
+			var f = new File([u], ${JSON.stringify(filename)}, {type: ${JSON.stringify(mime)}});
+			var dt = new DataTransfer(); dt.items.add(f);
+			input.files = dt.files;
+			input.dispatchEvent(new Event('change',{bubbles:true}));
+			return JSON.stringify({ok:true,filename:${JSON.stringify(filename)},size:${size}});
+		})()`;
+    const result = await this.send("Runtime.evaluate", { expression, returnByValue: true });
+    try {
+      await this.send("Input.dispatchKeyEvent", { type: "keyDown", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27 });
+      await this.send("Input.dispatchKeyEvent", { type: "keyUp", key: "Escape", code: "Escape", windowsVirtualKeyCode: 27, nativeVirtualKeyCode: 27 });
+    } catch {
+    }
+    const resultObj = result?.result;
+    if (resultObj?.value) return JSON.parse(String(resultObj.value));
+    return { ok: true, filename, size };
+  }
+  async close() {
+    await this.send("Ceki.close", {}).catch(() => {
+    });
+    this._client._activeSessions.delete(this.sessionId);
+  }
+};
+
+// nodes/BrowserCeki/BrowserCeki.node.ts
+var sleep = (ms) => new Promise((resolve) => {
+  AbortSignal.timeout(ms).addEventListener("abort", () => resolve(), { once: true });
+});
+var BrowserCeki = class {
+  constructor() {
+    this.description = {
+      displayName: "Browser Ceki",
+      name: "browserCeki",
+      icon: "file:ceki.png",
+      group: ["transform"],
+      version: 1,
+      subtitle: '={{ "Ceki: " + $operation }}',
+      description: "Rent a real human browser and control it: rent, navigate, click, type, screenshot, solve captchas, and more",
+      defaults: { name: "Browser Ceki" },
+      inputs: ["main"],
+      outputs: ["main"],
+      credentials: [{ name: "cekiApi", required: true }],
+      properties: [
+        {
+          displayName: "Operation",
+          name: "operation",
+          type: "options",
+          default: "rent",
+          options: [
+            { name: "Rent", value: "rent" },
+            { name: "Navigate", value: "navigate" },
+            { name: "Click", value: "click" },
+            { name: "Type", value: "type" },
+            { name: "Scroll", value: "scroll" },
+            { name: "Screenshot", value: "screenshot" },
+            { name: "Snapshot", value: "snapshot" },
+            { name: "Wait", value: "wait" },
+            { name: "Wait for Selector", value: "waitForSelector" },
+            { name: "Upload", value: "upload" },
+            { name: "Close", value: "close" }
+          ]
+        },
+        // === Rent: rental parameters ===
+        {
+          displayName: "Schedule ID",
+          name: "scheduleId",
+          type: "number",
+          default: 0,
+          description: "0 \u2014 search by the filters below",
+          displayOptions: { show: { operation: ["rent"] } }
+        },
+        {
+          displayName: "Geo",
+          name: "geo",
+          type: "string",
+          default: "",
+          placeholder: "RU, EE, US\u2026",
+          displayOptions: { show: { operation: ["rent"] } }
+        },
+        {
+          displayName: "Max $/min",
+          name: "maxPrice",
+          type: "number",
+          typeOptions: { numberPrecision: 4 },
+          default: 0.02,
+          displayOptions: { show: { operation: ["rent"] } }
+        },
+        {
+          displayName: "Min rating",
+          name: "minRating",
+          type: "number",
+          default: 0,
+          displayOptions: { show: { operation: ["rent"] } }
+        },
+        {
+          displayName: "Profile mode",
+          name: "mode",
+          type: "options",
+          default: "main",
+          options: [
+            { name: "main", value: "main" },
+            { name: "incognito", value: "incognito" }
+          ],
+          displayOptions: { show: { operation: ["rent"] } }
+        },
+        // === Operations: session_id ===
+        {
+          displayName: "Session ID",
+          name: "sessionId",
+          type: "string",
+          default: "={{ $json.session_id }}",
+          description: "From the Rent operation",
+          required: true,
+          displayOptions: {
+            show: {
+              operation: ["navigate", "click", "type", "scroll", "screenshot", "snapshot", "wait", "waitForSelector", "upload", "close"]
+            }
+          }
+        },
+        {
+          displayName: "URL",
+          name: "url",
+          type: "string",
+          default: "",
+          required: true,
+          displayOptions: { show: { operation: ["navigate"] } }
+        },
+        {
+          displayName: "X",
+          name: "x",
+          type: "number",
+          default: 0,
+          displayOptions: { show: { operation: ["click"] } }
+        },
+        {
+          displayName: "Y",
+          name: "y",
+          type: "number",
+          default: 0,
+          displayOptions: { show: { operation: ["click"] } }
+        },
+        {
+          displayName: "Text",
+          name: "text",
+          type: "string",
+          default: "",
+          displayOptions: { show: { operation: ["type"] } }
+        },
+        {
+          displayName: "Delta Y",
+          name: "deltaY",
+          type: "number",
+          default: -300,
+          displayOptions: { show: { operation: ["scroll"] } }
+        },
+        {
+          displayName: "Format",
+          name: "format",
+          type: "options",
+          default: "png",
+          options: [
+            { name: "PNG (binary)", value: "png" },
+            { name: "Base64", value: "base64" }
+          ],
+          displayOptions: { show: { operation: ["screenshot"] } }
+        },
+        {
+          displayName: "Full page",
+          name: "fullPage",
+          type: "boolean",
+          default: false,
+          displayOptions: { show: { operation: ["screenshot"] } }
+        },
+        {
+          displayName: "Milliseconds",
+          name: "ms",
+          type: "number",
+          default: 1e3,
+          typeOptions: { minValue: 0 },
+          description: "Fixed delay on the active session",
+          displayOptions: { show: { operation: ["wait"] } }
+        },
+        {
+          displayName: "CSS Selector",
+          name: "waitSelector",
+          type: "string",
+          default: "",
+          required: true,
+          placeholder: "e.g. .results, #content, table tr",
+          displayOptions: { show: { operation: ["waitForSelector"] } }
+        },
+        {
+          displayName: "Timeout (ms)",
+          name: "waitTimeout",
+          type: "number",
+          default: 3e4,
+          description: "Waits until the selector appears in the DOM",
+          displayOptions: { show: { operation: ["waitForSelector"] } }
+        },
+        {
+          displayName: "CSS Selector",
+          name: "selector",
+          type: "string",
+          default: "",
+          required: true,
+          displayOptions: { show: { operation: ["upload"] } }
+        },
+        {
+          displayName: "Binary Property",
+          name: "binaryPropertyName",
+          type: "string",
+          default: "data",
+          displayOptions: { show: { operation: ["upload"] } }
+        }
+      ]
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const out = [];
+    const creds = await this.getCredentials("cekiApi");
+    const token = creds.token;
+    const resolveSid = async (i, client) => {
+      const scheduleId = this.getNodeParameter("scheduleId", i);
+      if (scheduleId) return scheduleId;
+      const geo = this.getNodeParameter("geo", i);
+      const maxPrice = this.getNodeParameter("maxPrice", i);
+      const list = await client.search({
+        geo: geo || void 0,
+        max_price_per_min: maxPrice
+      });
+      if (!list.length) throw new Error("No browsers found by filters");
+      return list[0].schedule_id;
+    };
+    for (let i = 0; i < items.length; i++) {
+      const op = this.getNodeParameter("operation", i);
+      const client = new CekiClient(token);
+      await client.connect();
+      let browser;
+      try {
+        if (op === "rent") {
+          const sid2 = await resolveSid(i, client);
+          const mode = this.getNodeParameter("mode", i);
+          browser = await client.rent(sid2, { mode });
+          out.push({
+            json: { session_id: browser.sessionId, schedule_id: sid2, mode }
+          });
+          await client.disconnect();
+          continue;
+        }
+        const sessionId = this.getNodeParameter("sessionId", i);
+        browser = await client.resume(sessionId);
+        const sid = browser.sessionId;
+        switch (op) {
+          case "navigate": {
+            const url = this.getNodeParameter("url", i);
+            await browser.navigate(url);
+            out.push({ json: { session_id: sid, url } });
+            break;
+          }
+          case "click": {
+            const x = this.getNodeParameter("x", i);
+            const y = this.getNodeParameter("y", i);
+            await browser.click(x, y);
+            out.push({ json: { session_id: sid, clicked: [x, y] } });
+            break;
+          }
+          case "type": {
+            const text = this.getNodeParameter("text", i);
+            await browser.type(text);
+            out.push({ json: { session_id: sid, typed: text } });
+            break;
+          }
+          case "scroll": {
+            const deltaY = this.getNodeParameter("deltaY", i);
+            await browser.scroll(deltaY);
+            out.push({ json: { session_id: sid, scrolled: deltaY } });
+            break;
+          }
+          case "screenshot": {
+            const format = this.getNodeParameter("format", i);
+            const fullPage = this.getNodeParameter("fullPage", i);
+            const shot = await browser.screenshot({ format, fullPage });
+            const data = format === "base64" ? shot.data : shot.toString("base64");
+            const binary = await this.helpers.prepareBinaryData(
+              Buffer.from(data, "base64"),
+              "screenshot.png",
+              "image/png"
+            );
+            out.push({ json: { session_id: sid }, binary: { data: binary } });
+            break;
+          }
+          case "snapshot": {
+            const snap = await browser.snapshot();
+            out.push({
+              json: { session_id: sid, screenshot: snap.screenshot }
+            });
+            break;
+          }
+          case "wait": {
+            const ms = this.getNodeParameter("ms", i);
+            await sleep(ms);
+            out.push({ json: { session_id: sid, waited: ms } });
+            break;
+          }
+          case "waitForSelector": {
+            const selector = this.getNodeParameter("waitSelector", i);
+            const timeout = this.getNodeParameter("waitTimeout", i);
+            const expr = `!!document.querySelector(${JSON.stringify(selector)})`;
+            const deadline = Date.now() + timeout;
+            let ok = false;
+            let lastErr = null;
+            while (Date.now() < deadline) {
+              try {
+                const res = await browser.send("Runtime.evaluate", { expression: expr, returnByValue: true });
+                if (res?.result?.value === true) {
+                  ok = true;
+                  break;
+                }
+              } catch (e) {
+                lastErr = e;
+              }
+              await sleep(500);
+            }
+            if (!ok) {
+              throw new Error(
+                `waitForSelector("${selector}") timed out after ${timeout}ms${lastErr ? `: ${lastErr.message}` : ""}`
+              );
+            }
+            out.push({ json: { session_id: sid, selector, found: true } });
+            break;
+          }
+          case "upload": {
+            const selector = this.getNodeParameter("selector", i);
+            const bpn = this.getNodeParameter("binaryPropertyName", i);
+            const bin = items[i].binary?.[bpn];
+            if (!bin) throw new Error(`Binary property "${bpn}" not found on input`);
+            const stream = await this.helpers.getBinaryStream(bin.id);
+            const chunks = [];
+            for await (const c of stream) chunks.push(c);
+            const buf = Buffer.concat(chunks);
+            const res = await browser.upload(selector, buf);
+            out.push({ json: { session_id: sid, uploaded: res } });
+            break;
+          }
+          case "close": {
+            await browser.close();
+            out.push({ json: { closed: true, session_id: sessionId } });
+            break;
+          }
+        }
+        if (op === "close") {
+          await client.close();
+        } else {
+          await client.disconnect();
+        }
+      } finally {
+      }
+    }
+    return [out];
+  }
+};
+
+// lib/contract-client.ts
+function cleanArgs(o) {
+  const out = { ...o };
+  for (const k of Object.keys(out)) {
+    if (out[k] === void 0 || out[k] === null) delete out[k];
+  }
+  return out;
+}
+function parseBenefitable(value) {
+  if (!value) return null;
+  const m = /^(agent|user):(\d+)$/.exec(value);
+  if (!m) return null;
+  return { type: m[1], value: Number(m[2]) };
+}
+function parseParticipant(value, roleId) {
+  const b = parseBenefitable(value);
+  if (!b) return null;
+  return { participable_id: b.value, type: b.type, role_id: roleId };
+}
+function deriveLabel(desc) {
+  if (!desc) return "";
+  const line = desc.split("\n")[0].trim();
+  return line.length > 60 ? line.slice(0, 57) + "..." : line;
+}
+var ROLE_REVIEWER = 5;
+var ROLE_QA = 6;
+var ContractClient = class {
+  constructor(token, endpoint, apiBase) {
+    this._endpoint = (endpoint ?? "https://api.ceki.me/mcp").replace(/\/+$/, "");
+    this._apiBase = (apiBase ?? "https://api.ceki.me").replace(/\/+$/, "");
+    this._token = token;
+  }
+  _headers() {
+    return {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${this._token}`
+    };
+  }
+  async _rpc(method, params) {
+    const body = JSON.stringify({ jsonrpc: "2.0", id: Date.now(), method, params });
+    const resp = await fetch(this._endpoint, {
+      method: "POST",
+      headers: this._headers(),
+      body
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`HTTP ${resp.status}: ${text.slice(0, 400)}`);
+    }
+    return resp.json();
+  }
+  async _call(tool, args) {
+    const body = await this._rpc("tools/call", { name: tool, arguments: args ?? {} });
+    if (body.error) throw new Error(`${tool} \u2192 ${JSON.stringify(body.error).slice(0, 400)}`);
+    const result = body.result ?? {};
+    const content = result.content;
+    if (Array.isArray(content)) {
+      const texts = content.filter((c) => c.type === "text").map((c) => String(c.text ?? ""));
+      const joined = texts.join("\n");
+      try {
+        return JSON.parse(joined);
+      } catch {
+        return joined;
+      }
+    }
+    if (result.structuredContent !== void 0) return result.structuredContent;
+    return result;
+  }
+  // ── domain methods ─────────────────────────────────────────
+  async listContracts() {
+    return this._call("list-contracts");
+  }
+  async members(contractId) {
+    return this._call("contract-members", { contract_id: contractId });
+  }
+  async tasks(contractId) {
+    return this._call("contract-tasks", { contract_id: contractId });
+  }
+  async myEvents() {
+    return this._call("get-my-events");
+  }
+  async task(eventId) {
+    return this._call("get-event", { event_id: eventId });
+  }
+  async create(contractId, opts) {
+    const args = cleanArgs({
+      contract_id: contractId,
+      label: opts.label,
+      type_id: opts.type,
+      status_id: opts.status,
+      description: opts.description,
+      benefitable: opts.benefitable ? parseBenefitable(opts.benefitable) : void 0
+    });
+    const users = [];
+    const rev = parseParticipant(opts.reviewer, ROLE_REVIEWER);
+    if (rev) users.push(rev);
+    const qa = parseParticipant(opts.qa, ROLE_QA);
+    if (qa) users.push(qa);
+    if (users.length) args.users = users;
+    return this._call("create-contract-event", args);
+  }
+  async propose(eventId, opts) {
+    return this._call("propose-correction", cleanArgs({
+      event_id: eventId,
+      status_id: opts.status,
+      label: opts.label,
+      description: opts.description,
+      benefitable: opts.benefitable ? parseBenefitable(opts.benefitable) : void 0
+    }));
+  }
+  async comment(eventId, opts) {
+    return this._call("comment", cleanArgs({
+      event_id: eventId,
+      label: opts?.label,
+      description: opts?.description
+    }));
+  }
+  async progress(eventId, opts) {
+    let statusResult = null;
+    if (opts.status != null) {
+      statusResult = await this.propose(eventId, { status: opts.status });
+    }
+    const commentResult = await this.comment(eventId, { label: deriveLabel(opts.desc), description: opts.desc });
+    return { status_correction: statusResult, comment: commentResult };
+  }
+  async callHuman(eventId, kind, desc) {
+    if (!["input", "review", "stuck"].includes(kind)) throw new Error(`kind must be input|review|stuck, got ${kind}`);
+    return this._call("call-human", { event_id: eventId, kind, desc });
+  }
+  /** GET /agent/polling. Returns [] on 429. */
+  async poll() {
+    const resp = await fetch(`${this._apiBase}/agent/polling`, {
+      headers: { Accept: "application/json", Authorization: `Bearer ${this._token}` }
+    });
+    if (resp.status === 429) return [];
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`poll HTTP ${resp.status}: ${text.slice(0, 300)}`);
+    }
+    const body = await resp.json();
+    if (Array.isArray(body)) return body;
+    if (body && typeof body === "object") {
+      for (const k of ["notifications", "data", "items"]) {
+        if (Array.isArray(body[k])) return body[k];
+      }
+    }
+    return [];
+  }
+};
+
+// nodes/CekiContract/CekiContract.node.ts
+var STATUS_OPTIONS = [
+  { name: "100 \xB7 Backlog", value: 100 },
+  { name: "200 \xB7 Hand (assigned)", value: 200 },
+  { name: "222 \xB7 Hand done", value: 222 },
+  { name: "300 \xB7 QA", value: 300 },
+  { name: "350 \xB7 QA done", value: 350 },
+  { name: "499 \xB7 Reviewer", value: 499 }
+];
+var CekiContract = class {
+  constructor() {
+    this.description = {
+      displayName: "Ceki Contract",
+      name: "cekiContract",
+      icon: "file:ceki.png",
+      group: ["transform"],
+      version: 1,
+      subtitle: '={{ "Contract: " + $operation }}',
+      description: "Work with Ceki contract tasks: list, create, assign, update status, comment, report progress, escalate to a human, and poll",
+      defaults: { name: "Ceki Contract" },
+      inputs: ["main"],
+      outputs: ["main"],
+      credentials: [{ name: "cekiApi", required: true }],
+      properties: [
+        {
+          displayName: "Operation",
+          name: "operation",
+          type: "options",
+          default: "myEvents",
+          options: [
+            { name: "List My Contracts", value: "listContracts" },
+            { name: "List Tasks in Contract", value: "listTasks" },
+            { name: "Get Task", value: "getTask" },
+            { name: "My Assigned Events", value: "myEvents" },
+            { name: "Create Task", value: "createTask" },
+            { name: "Assign Executor", value: "assign" },
+            { name: "Update Status", value: "setStatus" },
+            { name: "Comment", value: "comment" },
+            { name: "Progress Report", value: "progress" },
+            { name: "Call Human", value: "callHuman" },
+            { name: "Poll Notifications", value: "poll" }
+          ]
+        },
+        // --- contractId / eventId ---
+        {
+          displayName: "Contract ID",
+          name: "contractId",
+          type: "number",
+          default: 0,
+          description: "ceki contract id",
+          displayOptions: { show: { operation: ["listTasks", "createTask"] } }
+        },
+        {
+          displayName: "Event ID",
+          name: "eventId",
+          type: "number",
+          default: 0,
+          description: "Task / event id (KalEvent)",
+          displayOptions: {
+            show: { operation: ["getTask", "assign", "setStatus", "comment", "progress", "callHuman"] }
+          }
+        },
+        // --- createTask fields ---
+        {
+          displayName: "Label",
+          name: "label",
+          type: "string",
+          default: "",
+          required: true,
+          displayOptions: { show: { operation: ["createTask"] } }
+        },
+        {
+          displayName: "Description",
+          name: "description",
+          type: "string",
+          typeOptions: { rows: 4 },
+          default: "",
+          displayOptions: { show: { operation: ["createTask", "comment"] } }
+        },
+        {
+          displayName: "Executor (benefitable)",
+          name: "benefitableType",
+          type: "options",
+          default: "agent",
+          options: [
+            { name: "Agent", value: "agent" },
+            { name: "User (human)", value: "user" }
+          ],
+          displayOptions: { show: { operation: ["createTask", "assign"] } }
+        },
+        {
+          displayName: "Executor ID",
+          name: "benefitableValue",
+          type: "number",
+          default: 0,
+          description: "Agent ID or user ID of the executor",
+          displayOptions: { show: { operation: ["createTask", "assign"] } }
+        },
+        // --- status ---
+        {
+          displayName: "Status",
+          name: "status",
+          type: "options",
+          options: STATUS_OPTIONS,
+          default: 200,
+          displayOptions: { show: { operation: ["createTask", "setStatus", "progress"] } }
+        },
+        // --- progress desc ---
+        {
+          displayName: "Progress Description",
+          name: "progressDesc",
+          type: "string",
+          typeOptions: { rows: 4 },
+          default: "",
+          required: true,
+          description: "Body of the progress comment (does not overwrite the task spec)",
+          displayOptions: { show: { operation: ["progress"] } }
+        },
+        // --- call human (escalate) ---
+        {
+          displayName: "Call Kind",
+          name: "callKind",
+          type: "options",
+          default: "review",
+          options: [
+            { name: "Input (need clarification)", value: "input" },
+            { name: "Review (done, take a look)", value: "review" },
+            { name: "Stuck (blocked)", value: "stuck" }
+          ],
+          description: "Type of escalation to a human (the call-human action)",
+          displayOptions: { show: { operation: ["callHuman"] } }
+        },
+        {
+          displayName: "Message",
+          name: "callDesc",
+          type: "string",
+          typeOptions: { rows: 4 },
+          default: "",
+          required: true,
+          description: "What to tell the human \u2014 context, question, or what was done",
+          displayOptions: { show: { operation: ["callHuman"] } }
+        }
+      ]
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const out = [];
+    const creds = await this.getCredentials("cekiApi");
+    const token = creds.token;
+    const client = new ContractClient(token);
+    for (let i = 0; i < items.length; i++) {
+      const op = this.getNodeParameter("operation", i);
+      let result;
+      switch (op) {
+        case "listContracts":
+          result = await client.listContracts();
+          break;
+        case "listTasks": {
+          const contractId = this.getNodeParameter("contractId", i);
+          result = await client.tasks(contractId);
+          break;
+        }
+        case "getTask": {
+          const eventId = this.getNodeParameter("eventId", i);
+          result = await client.task(eventId);
+          break;
+        }
+        case "myEvents":
+          result = await client.myEvents();
+          break;
+        case "createTask": {
+          const contractId = this.getNodeParameter("contractId", i);
+          const label = this.getNodeParameter("label", i);
+          const description = this.getNodeParameter("description", i) || "";
+          const status = this.getNodeParameter("status", i);
+          const bType = this.getNodeParameter("benefitableType", i);
+          const bValue = this.getNodeParameter("benefitableValue", i);
+          result = await client.create(contractId, {
+            label,
+            description: description || void 0,
+            status,
+            benefitable: bValue ? `${bType}:${bValue}` : void 0
+          });
+          break;
+        }
+        case "assign": {
+          const eventId = this.getNodeParameter("eventId", i);
+          const bType = this.getNodeParameter("benefitableType", i);
+          const bValue = this.getNodeParameter("benefitableValue", i);
+          if (!bValue) throw new Error("Executor ID is required for Assign");
+          result = await client.propose(eventId, { benefitable: `${bType}:${bValue}` });
+          break;
+        }
+        case "setStatus": {
+          const eventId = this.getNodeParameter("eventId", i);
+          const status = this.getNodeParameter("status", i);
+          result = await client.propose(eventId, { status });
+          break;
+        }
+        case "comment": {
+          const eventId = this.getNodeParameter("eventId", i);
+          const description = this.getNodeParameter("description", i) || "";
+          if (!description) throw new Error("Comment text is required");
+          result = await client.comment(eventId, { description });
+          break;
+        }
+        case "progress": {
+          const eventId = this.getNodeParameter("eventId", i);
+          const status = this.getNodeParameter("status", i);
+          const desc = this.getNodeParameter("progressDesc", i);
+          result = await client.progress(eventId, { status, desc });
+          break;
+        }
+        case "callHuman": {
+          const eventId = this.getNodeParameter("eventId", i);
+          const kind = this.getNodeParameter("callKind", i);
+          const desc = this.getNodeParameter("callDesc", i);
+          if (!desc) throw new Error("Message is required for Call Human");
+          result = await client.callHuman(eventId, kind, desc);
+          break;
+        }
+        case "poll":
+          result = await client.poll();
+          break;
+        default:
+          throw new Error(`Unknown operation: ${op}`);
+      }
+      out.push({ json: { op, result } });
+    }
+    return [out];
+  }
+};
+
+// nodes/recipes/CekiCaptchaScrape/CekiCaptchaScrape.node.ts
+var sleep2 = (ms) => new Promise((resolve) => {
+  AbortSignal.timeout(ms).addEventListener("abort", () => resolve(), { once: true });
+});
+async function waitForSelector(browser, selector, timeoutMs, intervalMs = 500) {
+  const expr = `!!document.querySelector(${JSON.stringify(selector)})`;
+  const deadline = Date.now() + timeoutMs;
+  let lastErr = null;
+  while (Date.now() < deadline) {
+    try {
+      const res = await browser.send("Runtime.evaluate", { expression: expr, returnByValue: true });
+      if (res?.result?.value === true) return true;
+    } catch (e) {
+      lastErr = e;
+    }
+    await sleep2(intervalMs);
+  }
+  throw new Error(
+    `waitForSelector("${selector}") timed out after ${timeoutMs}ms${lastErr ? `: ${lastErr.message}` : ""}`
+  );
+}
+async function extractHtml(browser, selector) {
+  const expr = selector.trim() === "" || selector === "body" ? `document.body ? document.body.outerHTML : ''` : `(function(){ var el = document.querySelector(${JSON.stringify(selector)}); return el ? el.outerHTML : ''; })()`;
+  const res = await browser.send("Runtime.evaluate", { expression: expr, returnByValue: true });
+  return res?.result?.value ?? "";
+}
+var CekiCaptchaScrape = class {
+  constructor() {
+    this.description = {
+      displayName: "Browser Ceki: Captcha-protected Scrape",
+      name: "cekiCaptchaScrape",
+      description: "Rent a human browser, wait, screenshot/HTML, release",
+      icon: "file:ceki.png",
+      group: ["transform"],
+      version: 1,
+      subtitle: "=rent in {{ $geo }} \u2192 snapshot",
+      defaults: { name: "Browser Ceki: Captcha-protected Scrape" },
+      inputs: ["main"],
+      outputs: ["main"],
+      credentials: [{ name: "cekiApi", required: true }],
+      properties: [
+        {
+          displayName: "URL",
+          name: "url",
+          type: "string",
+          default: "https://example.com",
+          required: true,
+          description: "Page protected by anti-bot / captcha"
+        },
+        {
+          displayName: "Geo",
+          name: "geo",
+          type: "string",
+          default: "RU",
+          placeholder: "RU, EE, US\u2026"
+        },
+        { displayName: "Max $/min", name: "maxPrice", type: "number", typeOptions: { numberPrecision: 4 }, default: 0.02 },
+        {
+          displayName: "Wait for Selector",
+          name: "waitSelector",
+          type: "string",
+          default: "",
+          placeholder: "CSS selector (optional)",
+          description: "Wait until this selector appears in the DOM"
+        },
+        {
+          displayName: "Wait Timeout (ms)",
+          name: "waitTimeout",
+          type: "number",
+          default: 3e4
+        },
+        {
+          displayName: "Extract HTML",
+          name: "extractHtml",
+          type: "boolean",
+          default: true
+        },
+        {
+          displayName: "HTML Selector",
+          name: "htmlSelector",
+          type: "string",
+          default: "body",
+          placeholder: 'CSS selector or "body"',
+          description: "outerHTML of this selector is returned as `html`",
+          displayOptions: { show: { extractHtml: [true] } }
+        },
+        {
+          displayName: "Full Page Screenshot",
+          name: "fullPage",
+          type: "boolean",
+          default: false
+        }
+      ]
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const out = [];
+    const creds = await this.getCredentials("cekiApi");
+    for (let i = 0; i < items.length; i++) {
+      const url = this.getNodeParameter("url", i);
+      const geo = this.getNodeParameter("geo", i);
+      const maxPrice = this.getNodeParameter("maxPrice", i);
+      const waitSelector = this.getNodeParameter("waitSelector", i) || "";
+      const waitTimeout = this.getNodeParameter("waitTimeout", i);
+      const extractHtmlFlag = this.getNodeParameter("extractHtml", i);
+      const htmlSelector = this.getNodeParameter("htmlSelector", i) || "body";
+      const fullPage = this.getNodeParameter("fullPage", i);
+      const client = new CekiClient(creds.token);
+      await client.connect();
+      let browser;
+      let scheduleId = 0;
+      try {
+        const list = await client.search({ geo: geo || void 0, max_price_per_min: maxPrice });
+        if (!list.length) throw new Error(`No browsers in geo ${geo || "*"}`);
+        scheduleId = list[0].schedule_id;
+        browser = await client.rent(scheduleId);
+        await browser.navigate(url);
+        if (waitSelector) {
+          await waitForSelector(browser, waitSelector, waitTimeout);
+        }
+        const shot = await browser.screenshot({ format: "base64", fullPage });
+        const data = shot.data ?? (shot instanceof Buffer ? shot.toString("base64") : "");
+        const binary = await this.helpers.prepareBinaryData(
+          Buffer.from(data, "base64"),
+          "captcha-scrape.png",
+          "image/png"
+        );
+        const json = {
+          url,
+          geo,
+          schedule_id: scheduleId
+        };
+        if (extractHtmlFlag) {
+          json.html = await extractHtml(browser, htmlSelector);
+        }
+        out.push({ json, binary: { data: binary } });
+      } finally {
+        if (browser) {
+          try {
+            await browser.close();
+          } catch {
+          }
+        }
+        try {
+          await client.close();
+        } catch {
+        }
+      }
+    }
+    return [out];
+  }
+};
+
+// nodes/recipes/CekiScreenshotGeo/CekiScreenshotGeo.node.ts
+var CekiScreenshotGeo = class {
+  constructor() {
+    this.description = {
+      displayName: "Browser Ceki: Screenshot in Geo",
+      name: "cekiScreenshotGeo",
+      description: "Rent a browser in a given geo, screenshot a page, release",
+      icon: "file:ceki.png",
+      group: ["transform"],
+      version: 1,
+      subtitle: "=rent in {{ $geo }} \u2192 screenshot \u2192 release",
+      defaults: { name: "Browser Ceki: Screenshot in Geo" },
+      inputs: ["main"],
+      outputs: ["main"],
+      credentials: [{ name: "cekiApi", required: true }],
+      properties: [
+        {
+          displayName: "URL",
+          name: "url",
+          type: "string",
+          default: "https://ifconfig.me",
+          required: true
+        },
+        { displayName: "Geo", name: "geo", type: "string", default: "RU", placeholder: "RU, EE, US\u2026" },
+        { displayName: "Full page", name: "fullPage", type: "boolean", default: false },
+        { displayName: "Max $/min", name: "maxPrice", type: "number", default: 0.02 }
+      ]
+    };
+  }
+  async execute() {
+    const items = this.getInputData();
+    const out = [];
+    const creds = await this.getCredentials("cekiApi");
+    for (let i = 0; i < items.length; i++) {
+      const url = this.getNodeParameter("url", i);
+      const geo = this.getNodeParameter("geo", i);
+      const fullPage = this.getNodeParameter("fullPage", i);
+      const maxPrice = this.getNodeParameter("maxPrice", i);
+      const client = new CekiClient(creds.token);
+      await client.connect();
+      let browser;
+      try {
+        const list = await client.search({ geo, max_price_per_min: maxPrice });
+        if (!list.length) throw new Error(`No browsers in geo ${geo}`);
+        browser = await client.rent(list[0].schedule_id);
+        await browser.navigate(url);
+        const shot = await browser.screenshot({ format: "base64", fullPage });
+        const binary = await this.helpers.prepareBinaryData(
+          Buffer.from(shot.data, "base64"),
+          "screenshot.png",
+          "image/png"
+        );
+        out.push({
+          json: { url, geo, schedule_id: list[0].schedule_id },
+          binary: { data: binary }
+        });
+      } finally {
+        if (browser) {
+          try {
+            await browser.close();
+          } catch {
+          }
+        }
+        try {
+          await client.close();
+        } catch {
+        }
+      }
+    }
+    return [out];
+  }
+};
+
+// credentials/CekiApi.credentials.ts
+var CekiApi = class {
+  constructor() {
+    this.name = "cekiApi";
+    this.displayName = "Ceki API";
+    this.documentationUrl = "https://browser.ceki.me/docs#api-key";
+    this.properties = [
+      {
+        displayName: "API Key",
+        name: "token",
+        type: "string",
+        typeOptions: { password: true },
+        default: "",
+        description: "Agent token (ag_...). [Get your API key \u2192](https://browser.ceki.me/docs#api-key)",
+        required: true
+      }
+    ];
+    this.authenticate = {
+      type: "generic",
+      properties: {
+        headers: {
+          Authorization: "=Bearer {{$credentials?.token}}"
+        }
+      }
+    };
+    this.test = {
+      request: {
+        baseURL: "https://api.ceki.me",
+        url: "/api/browsers/search",
+        method: "GET"
+      }
+    };
+  }
+};
+
+// index.ts
+var nodes = [
+  BrowserCeki,
+  CekiContract,
+  CekiCaptchaScrape,
+  CekiScreenshotGeo
+];
+var credentials = [
+  CekiApi
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  credentials,
+  nodes
+});
+//# sourceMappingURL=index.js.map