cdp-toolkit 1.1.0 → 1.4.0

package/dist/index.js

@@ -1,3 +1,258 @@
+// src/leases.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var DEFAULT_LEASE_TTL_MS = 900000;
+function leaseDir() {
+  return process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
+}
+function leaseTtlMs() {
+  const raw = Number(process.env.CDP_LEASE_TTL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_LEASE_TTL_MS;
+}
+function defaultLabel() {
+  return `pid-${process.pid}`;
+}
+function safeId(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function leaseFile(backend, targetId) {
+  return join(leaseDir(), `lease-${backend}-${safeId(targetId)}.json`);
+}
+function mintToken(backend, targetId, nonce) {
+  return `${backend}:${targetId}:${nonce}`;
+}
+function tokenParts(token) {
+  if (typeof token !== "string")
+    return;
+  const first = token.indexOf(":");
+  const last = token.lastIndexOf(":");
+  if (first <= 0 || last <= first)
+    return;
+  const backend = token.slice(0, first);
+  if (backend !== "chrome" && backend !== "firefox")
+    return;
+  const targetId = token.slice(first + 1, last);
+  const nonce = token.slice(last + 1);
+  if (!targetId.length || !/^[0-9a-f]{24}$/.test(nonce))
+    return;
+  return { backend, targetId, nonce };
+}
+
+class LeaseConflictError extends Error {
+  targetId;
+  holder;
+  constructor(message, targetId, holder) {
+    super(message);
+    this.targetId = targetId;
+    this.holder = holder;
+    this.name = "LeaseConflictError";
+  }
+}
+async function readLease(backend, targetId) {
+  let raw;
+  try {
+    raw = await readFile(leaseFile(backend, targetId), "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  try {
+    const rec = JSON.parse(raw);
+    if (typeof rec?.nonce === "string" && typeof rec?.pid === "number")
+      return rec;
+  } catch {}
+  return;
+}
+function isPidAlive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function staleReason(rec, opts) {
+  if (!isPidAlive(rec.pid))
+    return "dead-pid";
+  if (opts.now - rec.lastUsedAt > rec.ttlMs)
+    return "expired";
+  if (opts.liveIds && !opts.liveIds.includes(rec.targetId))
+    return "target-gone";
+  return false;
+}
+async function claimLease(backend, targetId, opts) {
+  const now = opts.now ?? Date.now();
+  await mkdir(leaseDir(), { recursive: true });
+  for (let attempt = 0;attempt < 3; attempt++) {
+    const record = {
+      backend,
+      targetId,
+      nonce: randomBytes(12).toString("hex"),
+      pid: process.pid,
+      label: opts.label,
+      createdAt: now,
+      lastUsedAt: now,
+      ttlMs: opts.ttlMs ?? leaseTtlMs()
+    };
+    try {
+      await writeFile(leaseFile(backend, targetId), JSON.stringify(record), { flag: "wx" });
+      return { token: mintToken(backend, targetId, record.nonce), record };
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const existing = await readLease(backend, targetId);
+    if (!existing)
+      continue;
+    const stale = staleReason(existing, { now, liveIds: opts.liveIds });
+    if (!stale) {
+      throw new LeaseConflictError(`target '${targetId}' is already leased by '${existing.label}' (pid ${existing.pid}); call release_page with that lease's token, or list_leases to inspect it`, targetId, existing.label);
+    }
+    await unlink(leaseFile(backend, targetId)).catch(() => {
+      return;
+    });
+  }
+  throw new LeaseConflictError(`target '${targetId}' could not be claimed after 3 attempts: another process is claiming and releasing it concurrently`, targetId);
+}
+async function releaseLease(token) {
+  const parts = tokenParts(token);
+  if (!parts)
+    return { released: false };
+  const rec = await readLease(parts.backend, parts.targetId);
+  if (!rec || rec.nonce !== parts.nonce)
+    return { released: false };
+  await unlink(leaseFile(parts.backend, parts.targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+async function releaseLeaseFor(backend, targetId) {
+  if (!await readLease(backend, targetId))
+    return { released: false };
+  await unlink(leaseFile(backend, targetId)).catch(() => {
+    return;
+  });
+  return { released: true };
+}
+var leaseScope = new AsyncLocalStorage;
+function withLeaseScope(lease, fn) {
+  return leaseScope.run(lease, fn);
+}
+function currentLease() {
+  return leaseScope.getStore();
+}
+function leaseFromArgs(args) {
+  if (!args || typeof args !== "object")
+    return;
+  const lease = args.lease;
+  return typeof lease === "string" && lease.length > 0 ? lease : undefined;
+}
+async function touchLease(rec, now = Date.now()) {
+  const current = await readLease(rec.backend, rec.targetId).catch(() => {
+    return;
+  });
+  if (!current || current.nonce !== rec.nonce)
+    return;
+  await writeFile(leaseFile(current.backend, current.targetId), JSON.stringify({ ...current, lastUsedAt: now }), "utf8").catch(() => {
+    return;
+  });
+}
+function describeTarget(targetId, ctx) {
+  const url = ctx.url ? ` (url ${ctx.url})` : ctx.title ? ` (title ${JSON.stringify(ctx.title)})` : "";
+  return `target '${targetId}'${url}`;
+}
+async function assertLeaseOk(backend, targetId, ctx = {}) {
+  const token = ctx.lease ?? currentLease();
+  const now = ctx.now ?? Date.now();
+  const rec = await readLease(backend, targetId);
+  const held = rec && !staleReason(rec, { now, liveIds: ctx.liveIds }) ? rec : undefined;
+  const where = describeTarget(targetId, ctx);
+  if (token === undefined) {
+    if (!held)
+      return;
+    throw new LeaseConflictError(`${where} is leased by '${held.label}' (pid ${held.pid}). Pass that lease's token as the 'lease' argument, or call release_page to free it. list_leases shows every active lease.`, targetId, held.label);
+  }
+  const parts = tokenParts(token);
+  if (!parts) {
+    throw new LeaseConflictError(`malformed lease token for ${where}. Pass back the token claim_page returned, never a constructed one.`, targetId);
+  }
+  if (parts.backend !== backend || parts.targetId !== targetId) {
+    if (!held)
+      return;
+    throw new LeaseConflictError(`the lease token you passed is for ${parts.backend} target '${parts.targetId}', not ${where}, which is leased by '${held.label}'. Resolve the tab you actually hold, or claim this one.`, targetId, held.label);
+  }
+  if (!held) {
+    throw new LeaseConflictError(`${where} is not leased any more: the token you passed belongs to a lease that was released or reclaimed. Call claim_page again to take the tab.`, targetId);
+  }
+  if (parts.nonce !== held.nonce) {
+    throw new LeaseConflictError(`${where} was reclaimed and is now leased by '${held.label}' (pid ${held.pid}). Your token was invalidated by that reclamation. Call claim_page again if you still need this tab.`, targetId, held.label);
+  }
+  await touchLease(held, now);
+}
+var LEASE_FILE_RE = /^lease-(chrome|firefox)-(.+)\.json$/;
+async function listLeases(opts = {}) {
+  const now = opts.now ?? Date.now();
+  let names = [];
+  try {
+    names = await readdir(leaseDir());
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return [];
+    throw err;
+  }
+  const out = [];
+  for (const name of names) {
+    const parts = LEASE_FILE_RE.exec(name);
+    if (!parts)
+      continue;
+    const fromName = {
+      backend: parts[1],
+      targetId: parts[2],
+      label: "",
+      pid: 0,
+      createdAt: 0,
+      lastUsedAt: 0,
+      ttlMs: 0,
+      pidAlive: false,
+      stale: false
+    };
+    let rec;
+    try {
+      rec = JSON.parse(await readFile(join(leaseDir(), name), "utf8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        continue;
+      out.push({ ...fromName, unreadable: code ?? "unparseable" });
+      continue;
+    }
+    if (typeof rec?.nonce !== "string" || typeof rec?.pid !== "number") {
+      out.push({ ...fromName, unreadable: "unparseable" });
+      continue;
+    }
+    out.push({
+      backend: rec.backend,
+      targetId: rec.targetId,
+      label: rec.label,
+      pid: rec.pid,
+      createdAt: rec.createdAt,
+      lastUsedAt: rec.lastUsedAt,
+      ttlMs: rec.ttlMs,
+      pidAlive: isPidAlive(rec.pid),
+      stale: staleReason(rec, {
+        now,
+        liveIds: opts.liveBackend === undefined || opts.liveBackend === rec.backend ? opts.liveIds : undefined
+      })
+    });
+  }
+  return out;
+}
+
 // src/client.ts
 var BASE = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
 var DEFAULT_TIMEOUT_MS = Number(process.env.CDP_TIMEOUT_MS ?? 15000);
@@ -151,8 +406,13 @@ async function browserWsUrl() {
   const v = await httpJson("/json/version");
   return v.webSocketDebuggerUrl;
 }
-async function resolveTarget(selector) {
+async function resolveTarget(selector, opts = {}) {
   const targets = await listTargets();
+  const hit = pickTarget(targets, selector);
+  await assertLeaseOk("chrome", hit.id, { lease: opts.lease, url: hit.url, title: hit.title });
+  return hit;
+}
+function pickTarget(targets, selector) {
   const pages = targets.filter((t) => t.type === "page");
   if (!selector || selector === "active") {
     if (!pages.length)
@@ -188,7 +448,7 @@ async function openBrowser(opts = {}) {
   return new CdpConnection(await browserWsUrl(), opts).connect();
 }
 async function openPage(selector, opts = {}) {
-  const target = await resolveTarget(selector);
+  const target = await resolveTarget(selector, { lease: opts.lease });
   const conn = await new CdpConnection(target.webSocketDebuggerUrl, opts).connect();
   return { conn, target };
 }
@@ -445,6 +705,31 @@ function decodeUid(uid) {
     throw driverError("foreign-uid", `malformed cdp uid payload: ${uid}`);
   return n;
 }
+function normalizeCdpCookie(c) {
+  const same = (c.sameSite ?? "").toLowerCase();
+  const sameSite = same === "strict" || same === "lax" || same === "none" ? same : "default";
+  return {
+    name: c.name,
+    value: c.value,
+    domain: c.domain,
+    path: c.path,
+    expires: typeof c.expires === "number" ? c.expires : -1,
+    size: typeof c.size === "number" ? c.size : Buffer.byteLength(`${c.name}${c.value}`, "utf8"),
+    httpOnly: c.httpOnly === true,
+    secure: c.secure === true,
+    sameSite,
+    session: c.session === true
+  };
+}
+function cdpSameSite(sameSite) {
+  if (sameSite === "strict")
+    return "Strict";
+  if (sameSite === "lax")
+    return "Lax";
+  if (sameSite === "none")
+    return "None";
+  return;
+}
 async function centerOf(conn, objectId) {
   const fn = "function(){this.scrollIntoView({block:'center',inline:'center'});const r=this.getBoundingClientRect();if(r.width===0&&r.height===0)return null;return {x:r.left+r.width/2,y:r.top+r.height/2};}";
   const { result, exceptionDetails } = await conn.send("Runtime.callFunctionOn", { objectId, functionDeclaration: fn, returnByValue: true });
@@ -967,6 +1252,38 @@ class CdpPageDriver {
       });
     });
   }
+  async getCookies() {
+    await this.ensureDomain("Network");
+    const { cookies } = await this.conn.send("Network.getCookies");
+    return (cookies ?? []).map(normalizeCdpCookie);
+  }
+  async setCookie(params) {
+    await this.ensureDomain("Network");
+    const sameSite = cdpSameSite(params.sameSite);
+    const { success } = await this.conn.send("Network.setCookie", {
+      name: params.name,
+      value: params.value,
+      ...params.url !== undefined ? { url: params.url } : {},
+      ...params.domain !== undefined ? { domain: params.domain } : {},
+      ...params.path !== undefined ? { path: params.path } : {},
+      ...params.expires !== undefined ? { expires: params.expires } : {},
+      ...params.httpOnly !== undefined ? { httpOnly: params.httpOnly } : {},
+      ...params.secure !== undefined ? { secure: params.secure } : {},
+      ...sameSite !== undefined ? { sameSite } : {}
+    });
+    if (success !== true) {
+      throw driverError("page-error", `Network.setCookie declined the cookie '${params.name}'. Chrome rejects a cookie whose domain does not match the url, a secure cookie on an insecure origin, and an oversized name or value.`);
+    }
+  }
+  async deleteCookies(filter) {
+    await this.ensureDomain("Network");
+    await this.conn.send("Network.deleteCookies", {
+      name: filter.name,
+      ...filter.url !== undefined ? { url: filter.url } : {},
+      ...filter.domain !== undefined ? { domain: filter.domain } : {},
+      ...filter.path !== undefined ? { path: filter.path } : {}
+    });
+  }
   async startBodyCapture() {
     await this.ensureDomain("Network");
     return async () => {
@@ -1026,6 +1343,10 @@ async function withBrowserConn(fn) {
   }
 }
 function noSuchTarget(e) {
+  if (e instanceof LeaseConflictError)
+    throw e;
+  if (typeof e?.code === "string")
+    throw e;
   throw driverError("no-such-target", e instanceof CdpError ? e.message : String(e));
 }
 
@@ -1069,9 +1390,154 @@ function createCdpDriver() {
   return new CdpBrowserDriver;
 }
 
+// src/origins.ts
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+function safeId2(id) {
+  return id.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function originFile(backend, targetId) {
+  return join2(leaseDir(), `origin-${backend}-${safeId2(targetId)}.json`);
+}
+var ORIGIN_FILE_RE = /^origin-(chrome|firefox)-(.+)\.json$/;
+async function recordOrigin(backend, targetId, opts = {}) {
+  const record = {
+    backend,
+    targetId,
+    label: typeof opts.label === "string" && opts.label.length ? opts.label : defaultLabel(),
+    pid: process.pid,
+    createdAt: opts.now ?? Date.now()
+  };
+  const file = originFile(backend, targetId);
+  try {
+    await mkdir2(leaseDir(), { recursive: true });
+    try {
+      await writeFile2(file, JSON.stringify(record), { flag: "wx" });
+      return;
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    await unlink2(file).catch(() => {
+      return;
+    });
+    await writeFile2(file, JSON.stringify(record), { flag: "wx" });
+  } catch {}
+}
+async function listOrigins(opts = {}) {
+  let names = [];
+  try {
+    names = await readdir2(leaseDir());
+  } catch {
+    return [];
+  }
+  const live = opts.liveIds === undefined ? undefined : new Set(opts.liveIds.map((id) => safeId2(id)));
+  const out = [];
+  for (const name of names) {
+    const parts = ORIGIN_FILE_RE.exec(name);
+    if (!parts)
+      continue;
+    const backend = parts[1];
+    const nameId = parts[2];
+    const scoped = live !== undefined && (opts.liveBackend === undefined || opts.liveBackend === backend);
+    if (scoped && !live.has(nameId)) {
+      await unlink2(join2(leaseDir(), name)).catch(() => {
+        return;
+      });
+      continue;
+    }
+    const fromName = { backend, targetId: nameId, label: "", pid: 0, createdAt: 0 };
+    let rec;
+    try {
+      rec = JSON.parse(await readFile2(join2(leaseDir(), name), "utf8"));
+    } catch (err) {
+      const code = err.code;
+      if (code === "ENOENT")
+        continue;
+      out.push({ ...fromName, unreadable: code ?? "unparseable" });
+      continue;
+    }
+    if (typeof rec?.targetId !== "string" || typeof rec?.label !== "string" || typeof rec?.createdAt !== "number") {
+      out.push({ ...fromName, unreadable: "unparseable" });
+      continue;
+    }
+    out.push({ backend: rec.backend, targetId: rec.targetId, label: rec.label, pid: rec.pid, createdAt: rec.createdAt });
+  }
+  return out;
+}
+async function originIndex(backend, liveIds) {
+  const rows = await listOrigins({ liveIds, liveBackend: backend }).catch(() => []);
+  const index = new Map;
+  for (const row of rows) {
+    if (row.backend !== backend)
+      continue;
+    index.set(row.targetId, row);
+  }
+  return index;
+}
+async function newTrackedPage(driver, backend, opts = {}) {
+  const page = await driver.newPage(opts.url);
+  await recordOrigin(backend, page.id, { label: opts.label });
+  return page;
+}
+
+// src/leases-tools.ts
+class LeaseToolError extends Error {
+}
+function backendOf(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
+async function claimPage(driver, args = {}) {
+  const backend = backendOf(driver);
+  const label = typeof args.label === "string" && args.label.length ? args.label : defaultLabel();
+  const pages = await driver.listPages();
+  let targetId = args.targetId;
+  let url = args.url ?? "about:blank";
+  if (targetId === undefined || targetId === "") {
+    const page = await newTrackedPage(driver, backend, { url: args.url, label });
+    targetId = page.id;
+    url = page.url;
+  } else {
+    const existing = pages.find((p) => p.id === targetId);
+    if (!existing)
+      throw new LeaseToolError(`claim_page: no page target with id '${targetId}'`);
+    url = existing.url;
+  }
+  const liveIds = [...pages.map((p) => p.id), targetId];
+  const { record, token } = await claimLease(backend, targetId, {
+    label,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs(),
+    liveIds
+  });
+  return {
+    lease: token,
+    targetId,
+    url,
+    label: record.label,
+    ttlMs: record.ttlMs,
+    expiresAt: record.lastUsedAt + record.ttlMs
+  };
+}
+async function releasePage(_driver, args) {
+  if (typeof args.lease !== "string" || !args.lease.length) {
+    throw new LeaseToolError("release_page requires the 'lease' token returned by claim_page");
+  }
+  return releaseLease(args.lease);
+}
+async function listLeasesTool(driver, _args = {}) {
+  const liveIds = (await driver.listPages()).map((p) => p.id);
+  const leases = await listLeases({ liveIds, liveBackend: backendOf(driver) });
+  return { leases, count: leases.length };
+}
+var LEASE_TOOLS = {
+  claim_page: claimPage,
+  release_page: releasePage,
+  list_leases: listLeasesTool
+};
+
 // src/shared-tools.ts
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { mkdir as mkdir3, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname, join as join3 } from "node:path";
 var ARTIFACT_DIR = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 var STATE_DIR = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
 
@@ -1080,6 +1546,9 @@ class SharedToolError extends Error {
 function target3(p) {
   return { id: p.id, url: p.url, title: p.title };
 }
+function backendOf2(driver) {
+  return driver.scheme === "bidi" ? "firefox" : "chrome";
+}
 async function withPage2(driver, target, fn) {
   const page = await driver.page(target);
   try {
@@ -1090,6 +1559,11 @@ async function withPage2(driver, target, fn) {
 }
 async function resolvePage(driver, selector) {
   const pages = await driver.listPages();
+  const hit = await pickPage(driver, pages, selector);
+  await assertLeaseOk(backendOf2(driver), hit.id, { url: hit.url, title: hit.title });
+  return hit;
+}
+async function pickPage(driver, pages, selector) {
   if (selector === undefined || selector === "active") {
     if (!pages.length)
       throw new SharedToolError("no page targets open");
@@ -1131,24 +1605,52 @@ function locatorOf(args) {
     throw new SharedToolError("provide exactly one of { uid } or { selector }");
   return hasUid ? { uid: args.uid } : { css: args.selector };
 }
+async function reapSet(driver, pages, all) {
+  if (all === true)
+    return pages.map((p) => p.id);
+  try {
+    return (await driver.listPages({ all: true })).map((p) => p.id);
+  } catch {
+    return;
+  }
+}
 async function listPages(driver, args = {}) {
   const pages = await driver.listPages({ all: args.all });
-  return { pages, count: pages.length };
+  const ledger = await originIndex(backendOf2(driver), await reapSet(driver, pages, args.all));
+  const annotated = pages.map((p) => {
+    const rec = ledger.get(p.id);
+    if (!rec)
+      return { ...p, origin: "unknown" };
+    if (rec.unreadable !== undefined)
+      return { ...p, origin: "unknown", originUnreadable: rec.unreadable };
+    return { ...p, origin: "agent", label: rec.label, createdAt: rec.createdAt };
+  });
+  return { pages: annotated, count: annotated.length };
 }
 async function newPage(driver, args = {}) {
-  const p = await driver.newPage(args.url);
-  return { targetId: p.id, url: p.url };
+  const label = typeof args.label === "string" && args.label.length ? args.label : defaultLabel();
+  const p = await newTrackedPage(driver, backendOf2(driver), { url: args.url, label });
+  if (args.claim !== true)
+    return { targetId: p.id, url: p.url };
+  const { record, token } = await claimLease(backendOf2(driver), p.id, {
+    label,
+    ttlMs: typeof args.ttlMs === "number" && args.ttlMs > 0 ? args.ttlMs : leaseTtlMs()
+  });
+  return { targetId: p.id, url: p.url, lease: token, label: record.label, expiresAt: record.lastUsedAt + record.ttlMs };
 }
 async function closePage(driver, args) {
   if (args.target === undefined || args.target === "")
     throw new SharedToolError("close_page requires an explicit target; refusing to guess which page to close");
   const p = await resolvePage(driver, args.target);
   const res = await driver.closePage(p.id);
-  return { closed: p.id, success: res.success };
+  if (!res.success)
+    return { closed: p.id, success: false, leaseReleased: false };
+  const released = await releaseLeaseFor(backendOf2(driver), p.id);
+  return { closed: p.id, success: true, ...released.released ? { leaseReleased: true } : {} };
 }
 async function writeSelectedFile(id) {
-  await mkdir(STATE_DIR, { recursive: true });
-  await writeFile(join(STATE_DIR, "selected"), id, "utf8");
+  await mkdir3(STATE_DIR, { recursive: true });
+  await writeFile3(join3(STATE_DIR, "selected"), id, "utf8");
 }
 async function selectPage(driver, args) {
   if (args.target === undefined || args.target === "")
@@ -1188,11 +1690,108 @@ async function waitForText(driver, args) {
     return { found: true, waitedMs: r.elapsedMs };
   });
 }
+function serializeForSink(value) {
+  const json = JSON.stringify(value === undefined ? null : value, null, 2);
+  return json ?? "null";
+}
+async function writeJsonSink(savePath, value) {
+  const path = savePath.startsWith("/") ? savePath : join3(ARTIFACT_DIR, savePath);
+  await mkdir3(dirname(path), { recursive: true });
+  const json = serializeForSink(value);
+  await writeFile3(path, json, "utf8");
+  return { path, bytes: Buffer.byteLength(json, "utf8") };
+}
+function sinkRequested(savePath) {
+  return savePath !== undefined && savePath !== "";
+}
 async function evaluateScript(driver, args) {
   if (typeof args.expression !== "string" || args.expression.length === 0) {
     throw new SharedToolError("evaluateScript: 'expression' must be a non-empty string");
   }
-  return withPage2(driver, args.target, (page) => page.evaluate(args.expression, { args: args.args, awaitPromise: args.awaitPromise ?? true }));
+  return withPage2(driver, args.target, async (page) => {
+    const value = await page.evaluate(args.expression, { args: args.args, awaitPromise: args.awaitPromise ?? true });
+    if (!sinkRequested(args.savePath))
+      return value;
+    const { path, bytes } = await writeJsonSink(args.savePath, value);
+    const result = {
+      path,
+      bytes,
+      type: value === null ? "null" : typeof value,
+      target: target3(page.info)
+    };
+    return result;
+  });
+}
+function cookieDomainMatches(cookieDomain, filter) {
+  const bare = (d) => (d.startsWith(".") ? d.slice(1) : d).toLowerCase();
+  const c = bare(cookieDomain);
+  const f = bare(filter);
+  return c === f || c.endsWith(`.${f}`);
+}
+function filterCookies(cookies, filter) {
+  return cookies.filter((c) => {
+    if (filter.name !== undefined && filter.name !== "" && c.name !== filter.name)
+      return false;
+    if (filter.domain !== undefined && filter.domain !== "" && !cookieDomainMatches(c.domain, filter.domain))
+      return false;
+    return true;
+  });
+}
+async function listCookies(driver, args = {}) {
+  return withPage2(driver, args.target, async (page) => {
+    const all = await page.getCookies();
+    const cookies = filterCookies(all, { domain: args.domain, name: args.name });
+    if (!sinkRequested(args.savePath)) {
+      return { cookies, count: cookies.length, target: target3(page.info) };
+    }
+    const { path, bytes } = await writeJsonSink(args.savePath, cookies);
+    return { path, bytes, count: cookies.length, target: target3(page.info) };
+  });
+}
+function assertCookieSite(args, toolName) {
+  const hasUrl = args.url !== undefined && args.url !== "";
+  const hasDomain = args.domain !== undefined && args.domain !== "";
+  if (!hasUrl && !hasDomain) {
+    throw new Error(`${toolName} requires either 'url' or 'domain': a cookie has to be attributed to a site, and neither was given.`);
+  }
+}
+function assertCookieName(name, toolName) {
+  if (name === undefined || name === "") {
+    throw new Error(`${toolName} requires a non-empty 'name'.`);
+  }
+}
+async function setCookie(driver, args) {
+  assertCookieName(args.name, "set_cookie");
+  if (typeof args.value !== "string")
+    throw new Error("set_cookie requires a string 'value'.");
+  assertCookieSite(args, "set_cookie");
+  return withPage2(driver, args.target, async (page) => {
+    await page.setCookie({
+      name: args.name,
+      value: args.value,
+      ...args.url !== undefined ? { url: args.url } : {},
+      ...args.domain !== undefined ? { domain: args.domain } : {},
+      ...args.path !== undefined ? { path: args.path } : {},
+      ...args.expires !== undefined ? { expires: args.expires } : {},
+      ...args.httpOnly !== undefined ? { httpOnly: args.httpOnly } : {},
+      ...args.secure !== undefined ? { secure: args.secure } : {},
+      ...args.sameSite !== undefined ? { sameSite: args.sameSite } : {}
+    });
+    return { set: true, target: target3(page.info) };
+  });
+}
+async function deleteCookies(driver, args) {
+  assertCookieName(args.name, "delete_cookies");
+  assertCookieSite(args, "delete_cookies");
+  return withPage2(driver, args.target, async (page) => {
+    await page.deleteCookies({
+      name: args.name,
+      ...args.url !== undefined ? { url: args.url } : {},
+      ...args.domain !== undefined ? { domain: args.domain } : {},
+      ...args.path !== undefined ? { path: args.path } : {}
+    });
+    return { deleted: true, target: target3(page.info) };
+  });
 }
 var BARE_TOKEN_EXTRAS = new Set(["disabled", "focused"]);
 var UNQUOTED_EXTRAS = new Set(["checked", "expanded", "url"]);
@@ -1303,10 +1902,10 @@ async function takeScreenshot(driver, args = {}) {
     const { data, format: outFormat } = await page.screenshot({ format, quality: args.quality, fullPage: args.fullPage, ...clip ? { clip } : {} });
     if (data.byteLength === 0)
       throw new SharedToolError("captureScreenshot returned empty data");
-    await mkdir(ARTIFACT_DIR, { recursive: true });
+    await mkdir3(ARTIFACT_DIR, { recursive: true });
     const ext = outFormat === "jpeg" ? "jpg" : "png";
-    const path = args.savePath ?? join(ARTIFACT_DIR, `screenshot-${page.info.id.slice(0, 8)}-${stamp()}.${ext}`);
-    await writeFile(path, Buffer.from(data));
+    const path = args.savePath ?? join3(ARTIFACT_DIR, `screenshot-${page.info.id.slice(0, 8)}-${stamp()}.${ext}`);
+    await writeFile3(path, Buffer.from(data));
     const result = {
       path,
       bytes: data.byteLength,
@@ -1353,6 +1952,9 @@ var SHARED_TOOLS = {
   navigate_page: navigatePage,
   wait_for: waitForText,
   evaluate_script: evaluateScript,
+  list_cookies: listCookies,
+  set_cookie: setCookie,
+  delete_cookies: deleteCookies,
   take_snapshot: takeSnapshot,
   click,
   hover,
@@ -1369,10 +1971,10 @@ var SHARED_TOOLS = {
 };
 
 // src/tools/console.ts
-import { readFile } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
 
 // src/tools/recorder.ts
-import { mkdir as mkdir2, appendFile, writeFile as writeFile2, copyFile } from "node:fs/promises";
+import { mkdir as mkdir4, appendFile, writeFile as writeFile4, copyFile } from "node:fs/promises";
 var ARTIFACT_DIR2 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function recFile(targetId) {
   return `${ARTIFACT_DIR2}/rec-${targetId}.jsonl`;
@@ -1393,11 +1995,11 @@ var CONSOLE_EVENTS = ["Runtime.consoleAPICalled", "Runtime.exceptionThrown", "Lo
 async function startRecorder(target, opts = {}) {
   const network = opts.network ?? true;
   const consoleCap = opts.console ?? true;
-  await mkdir2(ARTIFACT_DIR2, { recursive: true });
+  await mkdir4(ARTIFACT_DIR2, { recursive: true });
   const { conn, target: resolved } = await openPage(target, { timeoutMs: opts.timeoutMs });
   const file = opts.file ?? recFile(resolved.id);
   if (opts.truncate) {
-    await writeFile2(file, "");
+    await writeFile4(file, "");
   }
   let chain = Promise.resolve();
   let dropped = 0;
@@ -1539,7 +2141,7 @@ function lineToEntry(line, index) {
 async function readConsoleEntries(file) {
   let raw;
   try {
-    raw = await readFile(file, "utf8");
+    raw = await readFile3(file, "utf8");
   } catch {
     return [];
   }
@@ -1595,7 +2197,7 @@ async function getConsoleMessage(args = {}) {
 }
 
 // src/tools/network.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile4 } from "node:fs/promises";
 var DEFAULT_CAPTURE_MS2 = 2500;
 function asHeaders(v) {
   if (!v || typeof v !== "object")
@@ -1662,7 +2264,7 @@ function correlate(lines) {
 async function readNetworkRequests(file) {
   let raw;
   try {
-    raw = await readFile2(file, "utf8");
+    raw = await readFile4(file, "utf8");
   } catch {
     return [];
   }
@@ -1744,8 +2346,8 @@ async function getNetworkRequest(args = {}) {
 }
 
 // src/tools/performance.ts
-import { mkdir as mkdir3, readFile as readFile3, writeFile as writeFile3, stat, unlink } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile5, stat, unlink as unlink3 } from "node:fs/promises";
+import { join as join4 } from "node:path";
 var ARTIFACT_DIR3 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 var STATE_DIR2 = process.env.CDP_STATE_DIR ?? "/tmp/cdp-toolkit";
 var DEFAULT_CATEGORIES = [
@@ -1763,7 +2365,7 @@ function shortId(id) {
   return id.slice(0, 8);
 }
 function stateFilePath() {
-  return join2(STATE_DIR2, "trace-state.json");
+  return join4(STATE_DIR2, "trace-state.json");
 }
 function bufferTraceData(conn, sink) {
   return conn.on("Tracing.dataCollected", (params) => {
@@ -1785,10 +2387,10 @@ async function endTrace(conn, sink, timeoutMs = 30000) {
   return sink;
 }
 async function writeTrace(events, targetId) {
-  await mkdir3(ARTIFACT_DIR3, { recursive: true });
-  const path = join2(ARTIFACT_DIR3, `trace-${shortId(targetId)}-${stamp2()}.json`);
+  await mkdir5(ARTIFACT_DIR3, { recursive: true });
+  const path = join4(ARTIFACT_DIR3, `trace-${shortId(targetId)}-${stamp2()}.json`);
   const body = JSON.stringify({ traceEvents: events, metadata: { source: "cdp-toolkit" } });
-  await writeFile3(path, body, "utf8");
+  await writeFile5(path, body, "utf8");
   const { size } = await stat(path);
   return { path, bytes: size };
 }
@@ -1808,7 +2410,7 @@ async function performanceStartTrace(args = {}) {
     throw err;
   }
   liveTraces.set(target.id, { conn, target, events, startedAt: Date.now() });
-  await mkdir3(STATE_DIR2, { recursive: true });
+  await mkdir5(STATE_DIR2, { recursive: true });
   const state = {
     targetId: target.id,
     url: target.url,
@@ -1816,7 +2418,7 @@ async function performanceStartTrace(args = {}) {
     pid: process.pid,
     categories
   };
-  await writeFile3(stateFilePath(), JSON.stringify(state), "utf8");
+  await writeFile5(stateFilePath(), JSON.stringify(state), "utf8");
   return {
     target: { id: target.id, url: target.url, title: target.title },
     categories,
@@ -1829,7 +2431,7 @@ async function performanceStopTrace(args = {}) {
   if (!entry) {
     let hint = "";
     try {
-      const raw = await readFile3(stateFilePath(), "utf8");
+      const raw = await readFile5(stateFilePath(), "utf8");
       const state = JSON.parse(raw);
       hint = state.pid === process.pid ? ` (state file lists target ${shortId(state.targetId)} but its live connection is gone)` : ` (trace was started by a DIFFERENT process pid=${state.pid}; live recordings cannot cross process boundaries)`;
     } catch {}
@@ -1841,7 +2443,7 @@ async function performanceStopTrace(args = {}) {
   } finally {
     conn.close();
     liveTraces.delete(target.id);
-    await unlink(stateFilePath()).catch(() => {});
+    await unlink3(stateFilePath()).catch(() => {});
   }
   const written = await writeTrace(events, target.id);
   const metrics = analyzeEvents(events);
@@ -1959,7 +2561,7 @@ async function performanceAnalyzeInsight(args = {}) {
   }
   let raw;
   try {
-    raw = await readFile3(args.tracePath, "utf8");
+    raw = await readFile5(args.tracePath, "utf8");
   } catch (err) {
     throw new CdpError(`cannot read trace file '${args.tracePath}': ${err.message}`);
   }
@@ -1976,8 +2578,8 @@ async function performanceAnalyzeInsight(args = {}) {
 }
 
 // src/tools/heap.ts
-import { mkdir as mkdir4, writeFile as writeFile4 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join5 } from "node:path";
 var ARTIFACT_DIR4 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function stamp3(targetId) {
   const short = targetId.slice(0, 8);
@@ -2002,9 +2604,9 @@ async function takeHeapsnapshot(args = {}) {
     if (snapshot.length === 0) {
       throw new Error("HeapProfiler.takeHeapSnapshot produced no chunks");
     }
-    await mkdir4(ARTIFACT_DIR4, { recursive: true });
-    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join3(ARTIFACT_DIR4, args.savePath) : join3(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
-    await writeFile4(path, snapshot, "utf8");
+    await mkdir6(ARTIFACT_DIR4, { recursive: true });
+    const path = args.savePath ? args.savePath.startsWith("/") ? args.savePath : join5(ARTIFACT_DIR4, args.savePath) : join5(ARTIFACT_DIR4, `take_heapsnapshot-${stamp3(target.id)}.heapsnapshot`);
+    await writeFile6(path, snapshot, "utf8");
     const bytes = Buffer.byteLength(snapshot, "utf8");
     return {
       path,
@@ -2017,7 +2619,7 @@ async function takeHeapsnapshot(args = {}) {
 
 // src/tools/lighthouse.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir5, readFile as readFile4, stat as stat2 } from "node:fs/promises";
+import { mkdir as mkdir7, readFile as readFile6, stat as stat2 } from "node:fs/promises";
 var ARTIFACT_DIR5 = process.env.CDP_ARTIFACT_DIR ?? "/tmp/cdp-toolkit";
 function cdpPort() {
   const base = process.env.CDP_BASE ?? "http://127.0.0.1:9222";
@@ -2078,7 +2680,7 @@ async function lighthouseAudit(args) {
   const url = args.url.trim();
   const timeoutMs = args.timeoutMs ?? 120000;
   const port = cdpPort();
-  await mkdir5(ARTIFACT_DIR5, { recursive: true });
+  await mkdir7(ARTIFACT_DIR5, { recursive: true });
   const outPath = args.savePath ?? `${ARTIFACT_DIR5}/lighthouse-${shortHost(url)}-${stamp4()}.json`;
   const formFactor = args.formFactor ?? "desktop";
   const lhArgs = [
@@ -2107,7 +2709,7 @@ async function lighthouseAudit(args) {
   }
   let raw;
   try {
-    raw = await readFile4(outPath, "utf8");
+    raw = await readFile6(outPath, "utf8");
   } catch {
     raw = undefined;
   }
@@ -2115,7 +2717,7 @@ async function lighthouseAudit(args) {
     if (res.signal === "SIGKILL") {
       throw new CdpError(`lighthouse_audit timed out after ${timeoutMs}ms (no report written). stderr: ${truncate(res.stderr)}`);
     }
-    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx — ensure network access and that 'lighthouse' is installable." : "";
+    const hint = /not found|could not determine executable|npm ERR|E404|ERR_MODULE/i.test(res.stderr) ? " The Lighthouse CLI could not be fetched/installed via npx; ensure network access and that 'lighthouse' is installable." : "";
     throw new CdpError(`lighthouse_audit produced no report (exit code ${res.code}).${hint} stderr: ${truncate(res.stderr)}`);
   }
   let report;
@@ -2164,6 +2766,9 @@ var TOOLS = {
   navigate_page: onCdp(SHARED_TOOLS.navigate_page),
   wait_for: onCdp(SHARED_TOOLS.wait_for),
   evaluate_script: onCdp(SHARED_TOOLS.evaluate_script),
+  list_cookies: onCdp(SHARED_TOOLS.list_cookies),
+  set_cookie: onCdp(SHARED_TOOLS.set_cookie),
+  delete_cookies: onCdp(SHARED_TOOLS.delete_cookies),
   take_snapshot: onCdp(SHARED_TOOLS.take_snapshot),
   click: onCdp(SHARED_TOOLS.click),
   hover: onCdp(SHARED_TOOLS.hover),
@@ -2189,7 +2794,10 @@ var TOOLS = {
   lighthouse_audit: lighthouseAudit,
   mock_request: mockRequest,
   list_mocks: listMocks,
-  clear_mocks: clearMocks
+  clear_mocks: clearMocks,
+  claim_page: onCdp(LEASE_TOOLS.claim_page),
+  release_page: onCdp(LEASE_TOOLS.release_page),
+  list_leases: onCdp(LEASE_TOOLS.list_leases)
 };
 var TOOL_NAMES = Object.keys(TOOLS);
 export {