browser-pilot-cli 0.1.5 → 0.2.1

package/dist/managed-target-janitor.js

@@ -0,0 +1,490 @@
+// src/cdp.ts
+import WebSocket from "ws";
+
+// src/protocol/errors.ts
+var BrowserPilotError = class extends Error {
+  code;
+  retryable;
+  context;
+  remediation;
+  rpcCode;
+  constructor(code, message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "BrowserPilotError";
+    this.code = code;
+    this.retryable = options.retryable ?? false;
+    this.context = options.context;
+    this.remediation = options.remediation;
+    this.rpcCode = options.rpcCode ?? -32e3;
+  }
+  toData() {
+    return {
+      code: this.code,
+      retryable: this.retryable,
+      ...this.context ? { context: this.context } : {},
+      ...this.remediation ? { remediation: this.remediation } : {}
+    };
+  }
+  toJsonRpcError() {
+    return {
+      code: this.rpcCode,
+      message: this.message,
+      data: this.toData()
+    };
+  }
+};
+
+// src/cdp.ts
+var CDPClient = class {
+  ws;
+  nextId = 1;
+  callbacks = /* @__PURE__ */ new Map();
+  eventHandlers = /* @__PURE__ */ new Map();
+  anyEventHandlers = /* @__PURE__ */ new Set();
+  connectionHandlers = /* @__PURE__ */ new Set();
+  state = "disconnected";
+  closeRequested = false;
+  get connectionState() {
+    return this.state;
+  }
+  connect(wsUrl2) {
+    if (this.state === "connecting" || this.state === "connected") {
+      return Promise.reject(new Error("CDP transport is already connected or connecting"));
+    }
+    this.closeRequested = false;
+    this.transition("connecting");
+    return new Promise((resolve, reject) => {
+      const socket = new WebSocket(wsUrl2);
+      this.ws = socket;
+      let settled = false;
+      const rejectConnect = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+      const resolveConnect = () => {
+        if (settled) return;
+        settled = true;
+        resolve();
+      };
+      socket.on("error", (error) => {
+        if (socket !== this.ws) return;
+        const stable = this.disconnectedError(error);
+        this.failPending(stable);
+        rejectConnect(stable);
+        this.transition(this.closeRequested ? "closed" : "disconnected", stable);
+        if (!this.closeRequested && socket.readyState !== WebSocket.CLOSED) socket.terminate();
+      });
+      const onOpen = () => {
+        if (socket !== this.ws) return;
+        this.transition("connected");
+        resolveConnect();
+      };
+      socket.once("open", onOpen);
+      socket.on("message", (data) => {
+        if (socket !== this.ws) return;
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          return;
+        }
+        if ("id" in msg) {
+          const cb = this.callbacks.get(msg.id);
+          if (cb) {
+            this.callbacks.delete(msg.id);
+            msg.error ? cb.reject(new Error(msg.error.message)) : cb.resolve(msg.result ?? {});
+          }
+        } else if (msg.method) {
+          if (msg.sessionId) {
+            for (const h of this.eventHandlers.get(`${msg.sessionId}:${msg.method}`) ?? []) {
+              h(msg.params, msg.sessionId);
+            }
+          }
+          for (const h of this.eventHandlers.get(msg.method) ?? []) {
+            h(msg.params, msg.sessionId);
+          }
+          for (const h of this.anyEventHandlers) {
+            h(msg.method, msg.params, msg.sessionId);
+          }
+        }
+      });
+      socket.on("close", () => {
+        if (socket !== this.ws) return;
+        this.ws = void 0;
+        const error = this.disconnectedError();
+        this.failPending(error);
+        rejectConnect(error);
+        this.transition(this.closeRequested ? "closed" : "disconnected", error);
+      });
+    });
+  }
+  send(method, params, sessionId) {
+    const socket = this.ws;
+    if (this.state !== "connected" || !socket || socket.readyState !== WebSocket.OPEN) {
+      return Promise.reject(this.disconnectedError());
+    }
+    return new Promise((resolve, reject) => {
+      const id = this.nextId++;
+      const msg = { id, method };
+      if (params && Object.keys(params).length > 0) msg.params = params;
+      if (sessionId) msg.sessionId = sessionId;
+      const timeout = setTimeout(() => {
+        this.callbacks.delete(id);
+        reject(new Error(`CDP timeout: ${method}`));
+      }, 3e4);
+      this.callbacks.set(id, {
+        resolve: (v) => {
+          clearTimeout(timeout);
+          resolve(v);
+        },
+        reject: (e) => {
+          clearTimeout(timeout);
+          reject(e);
+        }
+      });
+      socket.send(JSON.stringify(msg), (error) => {
+        if (!error) return;
+        const callback = this.callbacks.get(id);
+        if (!callback) return;
+        this.callbacks.delete(id);
+        callback.reject(this.disconnectedError(error));
+      });
+    });
+  }
+  on(method, handler) {
+    const handlers = this.eventHandlers.get(method) ?? [];
+    handlers.push(handler);
+    this.eventHandlers.set(method, handlers);
+  }
+  onAny(handler) {
+    this.anyEventHandlers.add(handler);
+    return () => this.anyEventHandlers.delete(handler);
+  }
+  onConnectionState(handler) {
+    this.connectionHandlers.add(handler);
+    return () => this.connectionHandlers.delete(handler);
+  }
+  close() {
+    this.closeRequested = true;
+    const socket = this.ws;
+    if (!socket) {
+      this.transition("closed");
+      return Promise.resolve();
+    }
+    if (socket.readyState !== WebSocket.CONNECTING && socket.readyState !== WebSocket.OPEN) {
+      this.ws = void 0;
+      this.failPending(this.disconnectedError());
+      this.transition("closed");
+      return Promise.resolve();
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      const finish2 = () => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        socket.terminate();
+        if (this.ws === socket) {
+          this.ws = void 0;
+          this.failPending(this.disconnectedError());
+          this.transition("closed");
+        }
+        finish2();
+      }, 1e3);
+      timer.unref();
+      socket.once("close", finish2);
+      socket.close();
+    });
+  }
+  disconnectedError(cause) {
+    return new BrowserPilotError("browser_disconnected", "Chrome DevTools connection is unavailable", {
+      retryable: true,
+      ...cause ? { cause } : {}
+    });
+  }
+  failPending(error) {
+    for (const callback of this.callbacks.values()) callback.reject(error);
+    this.callbacks.clear();
+  }
+  transition(state, error) {
+    const previousState = this.state;
+    if (state === previousState) return;
+    this.state = state;
+    const event = {
+      state,
+      previousState,
+      ...error ? { error } : {}
+    };
+    for (const handler of this.connectionHandlers) {
+      try {
+        handler(event);
+      } catch {
+      }
+    }
+  }
+};
+
+// src/managed-target-janitor.ts
+var MAX_LINE_BYTES = 64 * 1024;
+var MAX_TRACKED_TARGETS = 4096;
+var CLEANUP_TIMEOUT_MS = 5e3;
+var wsUrl = process.argv[2];
+if (!wsUrl || !/^wss?:\/\//.test(wsUrl)) {
+  process.stderr.write("Managed target janitor requires a CDP WebSocket URL\n");
+  process.exit(2);
+}
+var cdp = new CDPClient();
+var ownedTargets = /* @__PURE__ */ new Map();
+var pending = Buffer.alloc(0);
+var commandTail = Promise.resolve();
+var finishing = false;
+var outputAvailable = true;
+function emit(value) {
+  if (typeof process.send === "function" && process.connected) {
+    process.send(value);
+    return;
+  }
+  if (!outputAvailable || process.stdout.destroyed || !process.stdout.writable) return;
+  process.stdout.write(`${JSON.stringify(value)}
+`);
+}
+function boundedMessage(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return message.slice(0, 1024);
+}
+function validateRequest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Invalid janitor request");
+  const request = value;
+  if (!Number.isSafeInteger(request.id) || Number(request.id) < 1) throw new Error("Invalid janitor request ID");
+  if (request.method !== "create" && request.method !== "adopt" && request.method !== "cdp.send") {
+    throw new Error("Invalid janitor method");
+  }
+  if (!request.params || typeof request.params !== "object" || Array.isArray(request.params)) {
+    throw new Error("Invalid janitor params");
+  }
+  return request;
+}
+function parseRequest(line) {
+  if (line.length === 0 || line.length > MAX_LINE_BYTES) throw new Error("Invalid janitor request size");
+  return validateRequest(JSON.parse(line.toString("utf8")));
+}
+function notifyOwned(targetId, openerTargetId) {
+  emit({ event: "owned", targetId, ...openerTargetId ? { openerTargetId } : {} });
+}
+async function trackTarget(targetId, openerTargetId) {
+  if (ownedTargets.has(targetId)) return true;
+  if (ownedTargets.size >= MAX_TRACKED_TARGETS) {
+    await cdp.send("Target.closeTarget", { targetId }).catch(() => {
+    });
+    return false;
+  }
+  ownedTargets.set(targetId, openerTargetId);
+  notifyOwned(targetId, openerTargetId);
+  return true;
+}
+async function createTarget(params) {
+  if (params.url !== "about:blank") throw new Error("Managed targets must start at about:blank");
+  const newWindow = params.newWindow === true;
+  const windowId = params.windowId;
+  if (newWindow === (windowId !== void 0)) throw new Error("Exactly one managed target window selector is required");
+  if (windowId !== void 0 && (!Number.isSafeInteger(windowId) || Number(windowId) < 0)) {
+    throw new Error("Invalid managed target window ID");
+  }
+  const created = await cdp.send("Target.createTarget", {
+    url: "about:blank",
+    ...newWindow ? { newWindow: true } : { windowId }
+  });
+  if (typeof created?.targetId !== "string" || created.targetId.length === 0) {
+    throw new Error("Chrome returned an invalid managed target ID");
+  }
+  if (!await trackTarget(created.targetId)) throw new Error("Managed target capacity reached");
+  return { targetId: created.targetId };
+}
+async function adoptTargets(params) {
+  if (!Array.isArray(params.targetIds) || params.targetIds.length > MAX_TRACKED_TARGETS) {
+    throw new Error("Invalid managed target adoption list");
+  }
+  const requested = params.targetIds;
+  if (requested.some((value) => typeof value !== "string" || value.length === 0 || value.length > 1024)) {
+    throw new Error("Invalid managed target ID");
+  }
+  const result = await cdp.send("Target.getTargets");
+  const infos = Array.isArray(result?.targetInfos) ? result.targetInfos : [];
+  const live = /* @__PURE__ */ new Map();
+  for (const info of infos) {
+    if (!info || typeof info.targetId !== "string") continue;
+    live.set(info.targetId, typeof info.openerId === "string" ? info.openerId : void 0);
+  }
+  const before = ownedTargets.size;
+  for (const targetId of requested) {
+    if (live.has(targetId)) await trackTarget(targetId, live.get(targetId));
+  }
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [targetId, openerTargetId] of live) {
+      if (!openerTargetId || !ownedTargets.has(openerTargetId) || ownedTargets.has(targetId)) continue;
+      if (await trackTarget(targetId, openerTargetId)) changed = true;
+    }
+  }
+  return { adopted: ownedTargets.size - before };
+}
+async function forwardCdp(params) {
+  if (typeof params.method !== "string" || params.method.length === 0 || params.method.length > 256) {
+    throw new Error("Invalid CDP method");
+  }
+  if (params.params !== void 0 && (!params.params || typeof params.params !== "object" || Array.isArray(params.params))) {
+    throw new Error("Invalid CDP params");
+  }
+  if (params.sessionId !== void 0 && (typeof params.sessionId !== "string" || params.sessionId.length === 0 || params.sessionId.length > 1024)) {
+    throw new Error("Invalid CDP session ID");
+  }
+  return cdp.send(
+    params.method,
+    params.params,
+    params.sessionId
+  );
+}
+async function handle(request) {
+  try {
+    const result = request.method === "create" ? await createTarget(request.params) : request.method === "adopt" ? await adoptTargets(request.params) : await forwardCdp(request.params);
+    emit({ id: request.id, result });
+  } catch (error) {
+    emit({
+      id: request.id,
+      error: {
+        code: request.method === "cdp.send" ? "cdp_error" : "janitor_error",
+        message: boundedMessage(error)
+      }
+    });
+  }
+}
+function cleanupOrder() {
+  const depth = (targetId) => {
+    const seen = /* @__PURE__ */ new Set();
+    let current = targetId;
+    let value = 0;
+    while (current && !seen.has(current)) {
+      seen.add(current);
+      const opener = ownedTargets.get(current);
+      if (!opener || !ownedTargets.has(opener)) break;
+      value += 1;
+      current = opener;
+    }
+    return value;
+  };
+  return [...ownedTargets.keys()].sort((left, right) => depth(right) - depth(left));
+}
+async function closeOwnedTargets() {
+  const targetIds = cleanupOrder();
+  for (let offset = 0; offset < targetIds.length; offset += 32) {
+    await Promise.all(targetIds.slice(offset, offset + 32).map((targetId) => cdp.send("Target.closeTarget", { targetId }).catch(() => {
+    })));
+  }
+}
+async function finish(cleanup, exitCode = 0) {
+  if (finishing) return;
+  finishing = true;
+  process.stdin.pause();
+  if (cleanup && cdp.connectionState === "connected") {
+    await Promise.race([
+      closeOwnedTargets(),
+      new Promise((resolve) => setTimeout(resolve, CLEANUP_TIMEOUT_MS))
+    ]).catch(() => {
+    });
+  }
+  await cdp.close();
+  process.exitCode = exitCode;
+  setImmediate(() => process.exit(exitCode));
+}
+async function main() {
+  process.stdout.on("error", () => {
+    outputAvailable = false;
+  });
+  process.stderr.on("error", () => {
+  });
+  process.stdin.on("end", () => {
+    void commandTail.finally(() => finish(true));
+  });
+  process.stdin.on("error", () => {
+    void finish(true, 1);
+  });
+  process.on("disconnect", () => {
+    void commandTail.finally(() => finish(true));
+  });
+  process.on("SIGTERM", () => {
+    void finish(true);
+  });
+  process.on("SIGINT", () => {
+    void finish(true);
+  });
+  process.stdin.resume();
+  cdp.on("Target.targetCreated", (params) => {
+    const info = params?.targetInfo;
+    if (typeof info?.targetId !== "string" || typeof info?.openerId !== "string" || !ownedTargets.has(info.openerId)) return;
+    void trackTarget(info.targetId, info.openerId);
+  });
+  cdp.on("Target.targetDestroyed", (params) => {
+    if (typeof params?.targetId !== "string" || !ownedTargets.delete(params.targetId)) return;
+    emit({ event: "destroyed", targetId: params.targetId });
+  });
+  cdp.onAny((method, params, sessionId) => {
+    emit({ event: "cdp", method, params, ...sessionId ? { sessionId } : {} });
+  });
+  cdp.onConnectionState((event) => {
+    if (event.state === "disconnected" && !finishing) void finish(false, 1);
+  });
+  await cdp.connect(wsUrl);
+  await cdp.send("Target.setDiscoverTargets", { discover: true });
+  emit({ event: "ready" });
+  const enqueue = (request) => {
+    if (request.method === "cdp.send") {
+      void handle(request);
+      return;
+    }
+    commandTail = commandTail.then(() => handle(request));
+  };
+  if (typeof process.send === "function") {
+    process.on("message", (value) => {
+      try {
+        enqueue(validateRequest(value));
+      } catch (error) {
+        process.stderr.write(`${boundedMessage(error)}
+`);
+        void finish(true, 2);
+      }
+    });
+  } else {
+    process.stdin.on("data", (value) => {
+      const chunk = Buffer.isBuffer(value) ? value : Buffer.from(value);
+      if (pending.length + chunk.length > MAX_LINE_BYTES * 2) {
+        void finish(true, 2);
+        return;
+      }
+      pending = pending.length === 0 ? chunk : Buffer.concat([pending, chunk]);
+      let newline = pending.indexOf(10);
+      while (newline >= 0) {
+        const line = pending.subarray(0, newline);
+        pending = pending.subarray(newline + 1);
+        try {
+          enqueue(parseRequest(line));
+        } catch (error) {
+          process.stderr.write(`${boundedMessage(error)}
+`);
+          void finish(true, 2);
+          return;
+        }
+        newline = pending.indexOf(10);
+      }
+    });
+  }
+}
+main().catch((error) => {
+  if (!finishing) process.stderr.write(`${boundedMessage(error)}
+`);
+  void finish(false, 1);
+});