@flemist/mcp-project-tools 1.0.3 → 3.0.0

package/build/startMcpServer-BOhpWAg9.js

@@ -0,0 +1,3475 @@
+import A from "express";
+import * as rt from "cors";
+import { McpServer as st } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomBytes as ot } from "crypto";
+import { StreamableHTTPServerTransport as nt } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import * as B from "fs";
+import * as T from "path";
+import it from "path";
+import { spawn as at } from "child_process";
+import { z as p } from "zod";
+import J from "tree-kill";
+import { Pool as lt, poolRunWait as U } from "@flemist/time-limits";
+import { priorityCreate as z } from "@flemist/priority-queue";
+import { useAbortController as ct, combineAbortSignals as ut } from "@flemist/async-utils";
+import dt from "node:os";
+import ft from "picomatch";
+import { webkit as mt, firefox as ht, chromium as pt } from "playwright";
+function gt(t) {
+  const { authToken: r } = t;
+  return function(o, e, n) {
+    if ((o.query.token || o.headers.authorization?.replace("Bearer ", "")) !== r) {
+      e.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    n();
+  };
+}
+async function G(t) {
+  const { logFilePath: r, message: s, data: o } = t;
+  try {
+    const e = (/* @__PURE__ */ new Date()).toISOString().replace(/[TZ]/g, " ").trim(), n = typeof o == "string" ? o : JSON.stringify(o, null, 2), i = `[${e}] ${s}
+${n}
+
+`;
+    await B.promises.mkdir(T.dirname(r), { recursive: !0 }), await B.promises.appendFile(r, i);
+  } catch (e) {
+    console.error(`Failed to log "${s}":`, e);
+  }
+}
+const R = /* @__PURE__ */ new Map();
+function wt(t, r) {
+  return async function(o, e) {
+    const n = o.headers["mcp-session-id"] || o.headers["x-session-id"] || o.query.token;
+    let i;
+    o.method === "POST" ? (await G({
+      logFilePath: r.logFilePath,
+      message: "REQUEST",
+      data: o.body
+    }), n && R.has(n) ? i = R.get(n) : (i = new nt({
+      sessionIdGenerator: () => n || ot(16).toString("hex"),
+      onsessioninitialized: (a) => {
+        R.set(a, i), console.log(`Session initialized: ${a}`);
+      },
+      enableJsonResponse: r.enableJsonResponse || !1
+    }), i.onclose = () => {
+      i.sessionId && (R.delete(i.sessionId), console.log(`Session closed: ${i.sessionId}`));
+    }, await t.connect(i), n && R.set(n, i)), await i.handleRequest(o, e, o.body)) : o.method === "GET" ? n && R.has(n) ? (i = R.get(n), await i.handleRequest(o, e)) : e.status(400).json({ error: "No valid session" }) : e.status(405).json({ error: "Method not allowed" });
+  };
+}
+const F = /* @__PURE__ */ new Map();
+let yt = 0;
+const ne = 10, bt = 1800 * 1e3, k = 2e3, $t = 500, xt = 5e3;
+function St(t) {
+  const { commandLine: r, commandLineRules: s } = t;
+  let o = !1;
+  for (const e of s)
+    if (new RegExp(e.regexp).test(r))
+      switch (e.rule) {
+        case "allow":
+          o = !0;
+          break;
+        case "deny":
+          o = !1;
+          break;
+        default:
+          throw new Error(`Unknown command line rule: ${e.rule}`);
+      }
+  return o;
+}
+function It() {
+  return ++yt;
+}
+let ie = !1;
+function Mt() {
+  if (ie)
+    return;
+  ie = !0;
+  const t = () => {
+    console.log("Auto-killing all child processes...");
+    for (const [r, s] of Array.from(F.entries()))
+      if (s.isRunning && s.pid)
+        try {
+          J(s.pid, "SIGKILL");
+        } catch (o) {
+          console.error(`Error killing process ${r}:`, o);
+        }
+    process.exit(0);
+  };
+  process.on("SIGINT", t), process.on("SIGTERM", t);
+}
+function W() {
+  const t = Date.now(), r = [];
+  for (const [s, o] of Array.from(F.entries()))
+    !o.isRunning && o.endTime && t - o.endTime.getTime() > bt && r.push(s);
+  for (const s of r)
+    F.delete(s);
+}
+function Q(t) {
+  const { process: r } = t, s = Date.now();
+  if (s - r.lastOutputTime.getTime() >= $t && (r.output += r.localOutput, r.localOutput = "", r.lastOutputTime = new Date(s), r.output.length > k)) {
+    const n = `
+... [${r.output.length - k} characters trimmed] ...
+`, i = k - n.length;
+    if (i > 0) {
+      const a = Math.floor(i / 2);
+      r.output = r.output.substring(0, a) + n + r.output.substring(
+        r.output.length - (i - a)
+      );
+    } else
+      r.output = r.output.substring(0, k);
+  }
+}
+function Tt(t, r) {
+  const s = r.limit - 35;
+  if (t.length <= s) return t;
+  const e = `
+... [${t.length - s} characters trimmed] ...
+`, n = s - e.length;
+  if (n <= 0)
+    return t.substring(0, s);
+  const i = Math.floor(n / 2);
+  return t.substring(0, i) + e + t.substring(t.length - (n - i));
+}
+const Se = p.object({
+  id: p.number().describe(
+    "Process ID to get detailed status information for. Get process IDs using process-list. Works for both running and completed processes. Examples: 1, 42, 123"
+  ),
+  outputLimit: p.number().max(k).default(k).describe(
+    `Maximum number of output characters to capture and return from the process. Output exceeding this limit will be truncated with beginning/end preserved and middle removed. Maximum: ${k} characters. Default: ${k}.`
+  )
+});
+async function H(t, r) {
+  W();
+  let s;
+  try {
+    s = Se.parse(t);
+  } catch (u) {
+    return {
+      error: `Invalid arguments: ${u instanceof Error ? u.message : "Unknown error"}`
+    };
+  }
+  const { id: o, outputLimit: e } = s, n = F.get(o);
+  if (!n)
+    return {
+      error: `Process ${o} not found. The process may have already completed and been cleaned up after 30 minutes, or the ID may be incorrect. Use process-list to see available processes and their current status.`
+    };
+  Q({ process: n });
+  const i = n.output + n.localOutput, a = Tt(i, { limit: e });
+  return n.output = "", n.localOutput = "", {
+    id: n.id,
+    cwd: T.relative(r.workingDir || "", n.cwd),
+    commandLine: n.commandLine,
+    pid: n.pid,
+    startTime: n.startTime.toISOString().replace(/[TZ]/g, " ").trim(),
+    endTime: n.endTime?.toISOString().replace(/[TZ]/g, " ").trim(),
+    exitCode: n.exitCode,
+    isRunning: n.isRunning,
+    output: a,
+    error: n.error
+  };
+}
+function vt(t, r) {
+  t(
+    "process-status",
+    {
+      title: "Get Host Machine Process Status",
+      description: "Get detailed status information about a process on the host machine. Use this to check if commands completed successfully, get their output, or monitor running processes. The output is cleared after retrieval to prevent duplication in subsequent calls",
+      inputSchema: Se.shape
+    },
+    async (s) => {
+      const o = await H(s, r);
+      if (!("output" in o))
+        return `Method: process-status(${JSON.stringify(s)})
+❌ Error: ${o.error}`;
+      const e = o.output || "";
+      return delete o.output, `Method: process-status(${JSON.stringify(s)})
+${JSON.stringify(o, null, 2)}
+
+Output:
+${e.trim()}`;
+    }
+  );
+}
+function Ie(t) {
+  J(t, "SIGTERM", (r) => {
+    r && !r.message.includes("not found") && console.error(`Error sending SIGTERM to process ${t}:`, r);
+  }), setTimeout(() => {
+    J(t, "SIGKILL", (r) => {
+      r && !r.message.includes("not found") && console.error(`Error sending SIGKILL to process ${t}:`, r);
+    });
+  }, xt);
+}
+const Me = p.object({
+  id: p.number().describe(
+    "Process ID to wait for completion. Get process IDs using process-list. The process can be running or already completed. Examples: 1, 42, 123"
+  ),
+  waitTime: p.number().optional().describe(
+    "Maximum time to wait in seconds for process completion. If omitted, waits indefinitely until process completes. If process is already completed, returns immediately. Examples: 30 (wait up to 30 seconds), 300 (wait up to 5 minutes)"
+  ),
+  autoKill: p.boolean().default(!1).describe(
+    "Automatically terminate the process if waitTime expires and it is still running. Only applies when waitTime is specified. Default: false (let process continue running after timeout). Set to true for processes that should not run indefinitely"
+  ),
+  outputLimit: p.number().max(k).default(k).describe(
+    `Maximum number of output characters to capture and return from the process. Output exceeding this limit will be truncated with beginning/end preserved and middle removed. Maximum: ${k} characters. Default: ${k}.`
+  )
+});
+async function Te(t, r) {
+  let s;
+  try {
+    s = Me.parse(t);
+  } catch (m) {
+    return {
+      error: `Invalid arguments: ${m instanceof Error ? m.message : "Unknown error"}`
+    };
+  }
+  const { id: o, waitTime: e, autoKill: n, outputLimit: i } = s, a = F.get(o);
+  if (!a)
+    return {
+      error: `Process ${o} not found. The process may have already completed and been cleaned up after 30 minutes, or the ID may be incorrect. Use process-list to see available processes and their current status.`
+    };
+  const u = Date.now();
+  let l = !1, c = !1;
+  e != null && await new Promise((h) => {
+    const g = setInterval(() => {
+      a.isRunning ? Date.now() - u >= e * 1e3 && (clearInterval(g), l = !0, n && a.pid && (Ie(a.pid), c = !0), h()) : (clearInterval(g), h());
+    }, 100);
+  });
+  const f = (Date.now() - u) / 1e3;
+  return {
+    ...await H({ id: o, outputLimit: i }, r),
+    waitDuration: f,
+    waitTimeExceeded: l,
+    autoKillExecuted: c
+  };
+}
+function kt(t, r) {
+  t(
+    "process-wait",
+    {
+      title: "Wait for Host Machine Process",
+      description: "Wait for a host machine process to complete execution, with optional timeout and auto-kill functionality. Use this for long-running commands like builds, installs, or tests when you need final results",
+      inputSchema: Me.shape
+    },
+    async (s) => {
+      const o = await Te(s, r);
+      if (!("output" in o))
+        return `Method: process-wait(${JSON.stringify(s)})
+❌ Error: ${o.error}`;
+      const e = o.output || "";
+      return delete o.output, `Method: process-wait(${JSON.stringify(s)})
+${JSON.stringify(o, null, 2)}
+
+Output:
+${e.trim()}`;
+    }
+  );
+}
+const ve = p.object({
+  cwd: p.string().optional().describe(
+    'Working directory for command execution, resolved relative to the current working directory. Leave empty to use current directory. Examples: "src" (run in src/ subdirectory), "../parent" (run in parent directory), "build/output" (run in nested subdirectory). Directory must exist'
+  ),
+  commandLine: p.string().describe(
+    'Complete command line to execute on the host machine. Include all arguments and options. Examples: "npm install", "pnpm build", "node script.js --verbose", "git status". Command must be in the allowed commands list for security'
+  ),
+  waitTime: p.number().optional().describe(
+    "Time to wait in seconds for process completion before returning results. If specified, will wait this long then return final status. If omitted, returns immediately with initial status. Use process-wait or process-status to check progress later. Examples: 30 (wait 30 seconds), 120 (wait 2 minutes)"
+  ),
+  autoKill: p.boolean().default(!1).describe(
+    "Automatically kill the process if waitTime expires and it is still running. Only applies when waitTime is specified. Default: false (let process continue running). Set to true for commands that should not run indefinitely"
+  ),
+  outputLimit: p.number().max(k).default(k).describe(
+    `Maximum number of output characters to capture and return from the process. Output exceeding this limit will be truncated with beginning/end preserved and middle removed. Maximum: ${k} characters. Default: ${k}.`
+  )
+});
+async function Ct(t, r) {
+  W();
+  let s;
+  try {
+    s = ve.parse(t);
+  } catch (d) {
+    return {
+      error: `Invalid arguments: ${d instanceof Error ? d.message : "Unknown error"}`
+    };
+  }
+  const { commandLine: o, waitTime: e, autoKill: n, outputLimit: i } = s, { commandLineRules: a } = r, u = T.resolve(r.workingDir || "", s.cwd || "");
+  if (!St({ commandLine: o, commandLineRules: a })) {
+    const d = a.map(
+      (m) => `${m.rule.toUpperCase()}: /${m.regexp}/ (${m.note})`
+    ).join(`
+`);
+    return {
+      error: `Command line not allowed: "${o}". For security, command lines are validated against configured rules in order. Command line was denied by the rule evaluation. Current command line rules:
+${d}
+
+To use this command line, ask the user to modify the command line rules in the configuration.`
+    };
+  }
+  if (Array.from(F.values()).filter(
+    (d) => d.isRunning
+  ).length >= ne)
+    return {
+      error: `Maximum concurrent process limit reached (${ne} processes). Cannot start new process until existing processes complete. Use process-list to see active processes, or process-kill to terminate unnecessary processes.`
+    };
+  const c = It(), f = {
+    id: c,
+    cwd: u,
+    commandLine: o,
+    startTime: /* @__PURE__ */ new Date(),
+    isRunning: !0,
+    output: "",
+    localOutput: "",
+    lastOutputTime: /* @__PURE__ */ new Date()
+  };
+  F.set(c, f);
+  try {
+    const d = at(o, [], {
+      shell: !0,
+      cwd: u,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    f.pid = d.pid;
+    const m = (h) => {
+      const g = h.toString();
+      f.localOutput += g, Q({ process: f }), console.log(g);
+    };
+    return d.stdout?.on("data", m), d.stderr?.on("data", m), d.on("close", (h) => {
+      if (f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.exitCode = h !== null ? h : void 0, f.output += f.localOutput, f.localOutput = "", f.output.length > k) {
+        const b = `
+... [${f.output.length - k} characters trimmed] ...
+`, y = k - b.length;
+        if (y > 0) {
+          const $ = Math.floor(y / 2);
+          f.output = f.output.substring(0, $) + b + f.output.substring(
+            f.output.length - (y - $)
+          );
+        } else
+          f.output = f.output.substring(0, k);
+      }
+      console.log(`Process ${c} (${o}) exited with code ${h}`);
+    }), d.on("error", (h) => {
+      f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.error = h.message, console.error(`Process ${c} error:`, h.message);
+    }), e != null ? Te({ id: c, waitTime: e, autoKill: n, outputLimit: i }, r) : H({ id: c, outputLimit: i }, r);
+  } catch (d) {
+    return f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.error = d instanceof Error ? d.message : "Unknown error", { error: f.error };
+  }
+}
+function Et(t, r) {
+  const s = r.commandLineRules.map((o) => `${o.rule.toUpperCase()}: ${o.regexp} (${o.note})`).join(`
+`);
+  t(
+    "process-run",
+    {
+      title: "Execute Command Line on Host Machine",
+      description: `Execute command lines on the host machine. Use this to build, test, lint, install packages, or run system commands. Security: Command lines are validated against configured rules processed in order (later rules override earlier ones). Current command line rules:
+${s}`,
+      inputSchema: ve.shape
+    },
+    async (o) => {
+      const e = await Ct(o, r);
+      if (!("output" in e))
+        return `Method: process-run(${JSON.stringify(o)})
+❌ Error: ${e.error}`;
+      const n = e.output || "";
+      return delete e.output, `Method: process-run(${JSON.stringify(o)})
+${JSON.stringify(e, null, 2)}
+
+Output:
+${n.trim()}`;
+    }
+  );
+}
+const ke = p.object({
+  minOpenDateTime: p.string().optional().describe(
+    'Filter to processes started after this datetime. Accepts ISO format or space-separated format. Examples: "2024-01-15T10:30:00Z", "2024-01-15 10:30:00". Underscores and spaces are converted to standard ISO format internally'
+  ),
+  minCloseDateTime: p.string().optional().describe(
+    'Filter to processes that finished after this datetime. Only applies to completed processes. Accepts ISO format or space-separated format. Examples: "2024-01-15T14:30:00Z", "2024-01-15 14:30:00". Useful for finding recently completed processes'
+  ),
+  activeOnly: p.boolean().default(!1).describe(
+    "Show only currently running processes. Set to true to exclude completed processes, false to show all processes (running and completed). Default: false (show all)"
+  ),
+  fields: p.array(p.string()).optional().describe(
+    'Specific process data fields to include in the response. If omitted, returns all available fields. Available fields: id, cwd, commandLine, pid, startTime, endTime, exitCode, isRunning, output, error. Examples: ["id", "commandLine", "isRunning"] for minimal info, ["id", "output", "exitCode"] for execution results'
+  )
+});
+async function Nt(t, r) {
+  W();
+  let s;
+  try {
+    s = ke.parse(t);
+  } catch (l) {
+    return {
+      error: `Invalid arguments: ${l instanceof Error ? l.message : "Unknown error"}`
+    };
+  }
+  const { minOpenDateTime: o, minCloseDateTime: e, activeOnly: n, fields: i } = s;
+  let a = Array.from(F.values());
+  if (o) {
+    const l = new Date(o.replace(/[_\s]/g, "T"));
+    a = a.filter((c) => c.startTime >= l);
+  }
+  if (e) {
+    const l = new Date(e.replace(/[_\s]/g, "T"));
+    a = a.filter((c) => c.endTime && c.endTime >= l);
+  }
+  return n && (a = a.filter((l) => l.isRunning)), { processes: a.map((l) => {
+    Q({ process: l });
+    let c = {
+      id: l.id,
+      cwd: it.relative(r.workingDir || "", l.cwd),
+      commandLine: l.commandLine,
+      pid: l.pid,
+      startTime: l.startTime.toISOString().replace(/[TZ]/g, " ").trim(),
+      endTime: l.endTime?.toISOString().replace(/[TZ]/g, " ").trim(),
+      exitCode: l.exitCode,
+      isRunning: l.isRunning,
+      output: l.output + l.localOutput,
+      error: l.error
+    };
+    if (i) {
+      const f = {};
+      for (const d of i)
+        d in c && (f[d] = c[d]);
+      c = f;
+    }
+    return c;
+  }) };
+}
+function Dt(t, r) {
+  t(
+    "process-list",
+    {
+      title: "List Host Machine Processes",
+      description: "List all processes that have been executed on the host machine. Use this to see running processes, check command history, or find process IDs for status/wait operations",
+      inputSchema: ke.shape
+    },
+    async (s) => {
+      const o = await Nt(s, r);
+      if (o.error != null)
+        return `Method: process-list(${JSON.stringify(s)})
+❌ Error: ${o.error}`;
+      const e = o.processes.map(
+        (n) => `[${n.isRunning ? "RUNNING" : "COMPLETED"}] ${n.id}: ${n.commandLine}`
+      ).join(`
+`);
+      return `Method: process-list(${JSON.stringify(s)})
+Active processes:
+${e}`;
+    }
+  );
+}
+const Ce = p.object({
+  id: p.number().describe(
+    "Process ID of the process to terminate. Get process IDs using process-list. The process must be currently running. Examples: 1, 42, 123"
+  )
+});
+function Bt(t) {
+  let r;
+  try {
+    r = Ce.parse(t);
+  } catch (e) {
+    return {
+      error: `Invalid arguments: ${e instanceof Error ? e.message : "Unknown error"}`
+    };
+  }
+  const { id: s } = r, o = F.get(s);
+  if (!o)
+    return {
+      error: `Process ${s} not found. The process may have already completed, been cleaned up after 30 minutes, or the ID may be incorrect. Use process-list to see available processes and their current status.`
+    };
+  if (!o.isRunning)
+    return {
+      error: `Process ${s} is not currently running. The process has already completed or was previously terminated. Use process-list to see the process status and process-status to get final execution details.`
+    };
+  if (!o.pid)
+    return {
+      error: `Process ${s} has no system process ID (PID). This indicates the process failed to start properly or the system was unable to assign a PID. Check process-status for error details.`
+    };
+  try {
+    return Ie(o.pid), { success: !0, message: `Kill signal sent to process ${s}` };
+  } catch (e) {
+    return {
+      error: `Failed to terminate process ${s}: ${e instanceof Error ? e.message : "Unknown error"}. The process may have already exited, be protected by the system, or there may be insufficient permissions. Use process-status to check current process state.`
+    };
+  }
+}
+function Ft(t, r) {
+  t(
+    "process-kill",
+    {
+      title: "Kill Host Machine Process",
+      description: "Forcibly terminate a running process on the host machine. Use this to stop runaway processes, hung commands, or long-running tasks that need to be cancelled",
+      inputSchema: Ce.shape
+    },
+    async (s) => {
+      const o = Bt(s);
+      return o.error != null ? `Method: process-kill(${JSON.stringify(s)})
+❌ Error: ${o.error}` : `Method: process-kill(${JSON.stringify(s)})
+${JSON.stringify(o, null, 2)}`;
+    }
+  );
+}
+function Ot(t, r) {
+  Mt(), r.run && Et(t, r), r.status && vt(t, r), r.wait && kt(t, r), r.list && Dt(t, r), r.kill && Ft(t);
+  const s = r.commandLineRules?.map(
+    (o) => `${o.rule.toUpperCase()}: ${o.regexp} (${o.note})`
+  ) || [];
+  console.log(
+    `Process manager:
+- Working directory: ${T.resolve(r.workingDir || "")}
+- Command line rules: ${r.commandLineRules?.length || 0} rules configured:
+${s.map((o) => `- ${o}`).join(`
+`)}
+`
+  );
+}
+function Rt(t, r) {
+  return function(o, e, n) {
+    const i = async (...a) => {
+      await G({
+        logFilePath: r.logFilePath,
+        message: "REQUEST",
+        data: { name: o, args: a }
+      });
+      const u = await n(...a);
+      return await G({
+        logFilePath: r.logFilePath,
+        message: "RESPONSE",
+        data: u
+      }), {
+        content: [
+          {
+            type: "text",
+            text: u
+          }
+        ]
+      };
+    };
+    return t.registerTool(
+      o,
+      e,
+      i
+    );
+  };
+}
+function zt(t) {
+  return t.match(/^[/\\]?[^/\\]+/)[0];
+}
+function Ut(t, r) {
+  return zt(t) + "|" + r.ino;
+}
+function Pt(t) {
+  return t.endsWith(":") && (t += "/"), T.resolve(t);
+}
+const Ee = new lt(dt.cpus().length);
+function ae(t, r) {
+  t.totalSize += r.totalSize, t.maxFileDateModified = Math.max(
+    t.maxFileDateModified,
+    r.maxFileDateModified
+  ), t.countFiles += r.countFiles, t.countDirs += r.countDirs, t.countLinks += r.countLinks;
+}
+const Lt = function(r) {
+  return r.code === "ENOENT";
+};
+function Ne(t) {
+  const r = t.paths;
+  if (!r || r.length === 0)
+    return Promise.resolve({
+      totalSize: 0,
+      maxFileDateModified: 0,
+      countFiles: 0,
+      countDirs: 0,
+      countLinks: 0
+    });
+  const s = t.level ?? 0, o = t.walkedIds ?? /* @__PURE__ */ new Set(), e = t.abortSignal, n = t.pool ?? Ee, i = t.handleError, a = t.priority ?? z(0), u = t.walkLinks ?? !1, l = t.log, c = t.handlePath, f = t.matchPath;
+  async function d(h) {
+    if (!(i && await i(h)) && !Lt(h))
+      throw h;
+  }
+  function m(h) {
+    return !(!l || l.minTotalContentSize != null && h < l.minTotalContentSize || l.maxNestedLevel != null && s > l.maxNestedLevel);
+  }
+  return ct(async (h) => {
+    const g = ut(e, h), b = {
+      totalSize: 0,
+      maxFileDateModified: 0,
+      countFiles: 0,
+      countDirs: 0,
+      countLinks: 0
+    };
+    function y(w, M) {
+      if (m(M.totalSize)) {
+        const v = `${M.totalSize.toLocaleString("en-US").replace(/,/g, " ").padStart(19)}: ${w}`;
+        l?.handleLog ? l.handleLog(v) : console.log(v);
+      }
+    }
+    async function $(w, M, S, v) {
+      return c ? await U({
+        pool: n,
+        func: async () => {
+          try {
+            return await c({
+              level: s,
+              path: w,
+              stat: M,
+              itemStat: S,
+              totalStat: b,
+              abortSignal: g
+            });
+          } catch (E) {
+            return await d(E), !1;
+          }
+        },
+        count: 1,
+        priority: v,
+        abortSignal: g
+      }) : !0;
+    }
+    async function I(w, M, S, v) {
+      v || (v = w);
+      const E = await U({
+        pool: n,
+        func: () => B.promises.lstat(w).catch(d),
+        count: 1,
+        priority: z(M, z(1, a)),
+        abortSignal: g
+      });
+      if (!E || !S && E.isFile())
+        return null;
+      const oe = Ut(w, E);
+      if (o.has(oe))
+        return null;
+      o.add(oe);
+      let C = {
+        totalSize: E.size,
+        maxFileDateModified: E.isDirectory() ? 0 : E.mtimeMs,
+        countFiles: 0,
+        countDirs: 0,
+        countLinks: 0
+      };
+      const P = z(
+        M,
+        z(E.isDirectory() ? 2 : 3, a)
+      );
+      if (E.isSymbolicLink()) {
+        if (u) {
+          const D = await U({
+            pool: n,
+            func: () => B.promises.readlink(w).catch(d).then((O) => O ?? null),
+            count: 1,
+            priority: P,
+            abortSignal: g
+          });
+          if (D) {
+            const O = T.isAbsolute(D) ? D : T.resolve(T.dirname(v), D), L = await I(
+              O,
+              M,
+              S,
+              v
+            );
+            L && (C = L);
+          }
+        }
+        return (S || C.countFiles + C.countDirs + C.countLinks > 1) && (C.countLinks += 1, await $(
+          v,
+          E,
+          C,
+          P
+        ) && (ae(b, C), y(v, C))), C;
+      } else if (E.isDirectory()) {
+        const D = await U({
+          pool: n,
+          func: () => B.promises.readdir(w).catch(d),
+          count: 1,
+          priority: a,
+          abortSignal: g
+        });
+        if (D) {
+          for (let O = 0, L = D.length; O < L; O++)
+            D[O] = T.join(v, D[O]);
+          C = await Ne({
+            ...t,
+            paths: D,
+            abortSignal: g,
+            priority: P,
+            level: s + 1,
+            walkedIds: o
+          });
+        }
+      }
+      return (S || C.countFiles + C.countDirs + C.countLinks > 1) && (E.isDirectory() ? C.countDirs += 1 : E.isFile() && (C.countFiles += 1), await $(
+        v,
+        E,
+        C,
+        P
+      ) && (ae(b, C), y(v, C))), C;
+    }
+    const x = [];
+    for (let w = 0, M = r.length; w < M; w++) {
+      const S = Pt(r[w]), v = f ? f(S) : !0;
+      v !== !1 && x.push(I(S, w, v));
+    }
+    return await Promise.all(x), b;
+  });
+}
+function De(t) {
+  return Ne(t);
+}
+function At(t, r) {
+  if (!r || r === ".")
+    return t;
+  const s = t.startsWith("^");
+  s && (t = t.substring(1));
+  const o = t.startsWith("!");
+  return o && (t = t.substring(1)), t.startsWith("/") ? (r.endsWith("/") && (r = r.substring(0, r.length - 1)), t = r + t) : (r.endsWith("/") || (r += "/"), t.startsWith("./") ? t = r + t.substring(2) : t.startsWith("../") ? t = r + t : (r.startsWith("..") && (r = ""), t.startsWith("**") ? t = r + t : t = r + "**/" + t)), t = T.normalize(t).replace(/\\/g, "/"), o && (t = "!" + t), s && (t = "^" + t), t;
+}
+function Gt(t) {
+  const r = t.startsWith("!");
+  return r && (t = t.substring(1)), t.startsWith("/") ? t = t.substring(1) : !t.startsWith("**") && !t.startsWith("../") && (t = `**/${t}`), r && (t = "!" + t), t;
+}
+function le(t) {
+  return "^" + t;
+}
+async function qt(t) {
+  const s = (await B.promises.readFile(t, "utf-8")).split(`
+`), o = [];
+  return s.forEach((e) => {
+    e = e.trim(), !(!e || e.startsWith("#")) && o.push(e);
+  }), o;
+}
+async function Be(t) {
+  const r = t.rootDir ?? ".", s = [];
+  if (!t.globs?.length)
+    return s;
+  const o = [];
+  return t.globs.forEach((e) => {
+    e.value && (e.valueType === "file-contains-patterns" ? o.push(e) : e.valueType === "pattern" && s.push(e.exclude ? le(e.value) : e.value));
+  }), o.length && await Promise.all(
+    o.map(async (e) => {
+      await U({
+        pool: Ee,
+        count: 1,
+        func: async () => {
+          const n = T.resolve(r, e.value), i = await qt(n), a = T.relative(r, T.dirname(n));
+          i.forEach((u) => {
+            u = Gt(u), u = At(u, a), s.push(e.exclude ? le(u) : u);
+          });
+        }
+      });
+    })
+  ), s;
+}
+function Fe({
+  globs: t,
+  rootDir: r,
+  noCase: s
+}) {
+  const o = [];
+  return t.forEach((e) => {
+    e = e.replace(/\\/g, "/").trim();
+    const n = e.startsWith("^");
+    n && (e = e.substring(1).trim());
+    const i = e.startsWith("!");
+    if (i && (e = e.substring(1).trim()), e.startsWith("!") || e.startsWith("^"))
+      throw new Error(
+        `Invalid glob pattern: "${e}". The syntax '${e.substring(0, 2)}' is not supported. Valid glob patterns use: * (match any characters), ** (match any directories), ? (match single character), [abc] (character class), ! (negate pattern), ^ (exclude if included). Examples of valid patterns: "*.js", "src/**/*.ts", "!node_modules", "^dist". Avoid starting with '!' after '^' or multiple special prefixes.`
+      );
+    e.startsWith("/") && (e = "." + e);
+    const a = r ? T.resolve(r, e).replace(/\\/g, "/") : e;
+    if (!a)
+      return;
+    let u;
+    try {
+      u = ft(a, {
+        nocase: s ?? !1,
+        dot: !0,
+        strictBrackets: !0
+        // Validate bracket balance for patterns like "["
+      });
+    } catch (l) {
+      throw new Error(
+        `Invalid glob pattern: "${e}". ${l instanceof Error ? l.message : "Unknown error"}. Valid glob patterns use: * (match any characters), ** (match any directories), ? (match single character), [abc] (character class with balanced brackets), ! (negate pattern), ^ (exclude if included). Examples: "*.js", "src/**/*.ts", "!node_modules", "[abc]def.txt". Ensure all brackets [ ] are properly closed and balanced.`
+      );
+    }
+    o.push({
+      exclude: n,
+      negative: i,
+      debugInfo: a,
+      match: u
+    });
+  }), function(n) {
+    n = n.replace(/\\/g, "/");
+    let i = null, a = !1;
+    for (let u = 0, l = o.length; u < l; u++) {
+      const c = o[u];
+      c.match(n) && (c.exclude ? a = !c.negative : (i = !c.negative, a = !1));
+    }
+    return a ? !1 : i;
+  };
+}
+async function _t(t) {
+  const r = t.rootDir ?? ".", s = [], o = {};
+  t.result.countFiles && (o.countFiles = 0), t.result.size && (o.size = 0);
+  const e = await Be({
+    rootDir: r,
+    globs: t.globs
+  });
+  return await De({
+    paths: [r],
+    walkLinks: !0,
+    matchPath: Fe({
+      globs: e,
+      rootDir: r,
+      noCase: !0
+    }),
+    handlePath: async ({ path: n, stat: i, itemStat: a }) => {
+      const u = T.relative(r, n), l = i.isDirectory(), c = i.isFile();
+      if (!l && !c)
+        return !0;
+      const f = (u || ".").replace(/\\/g, "/"), d = l ? "dir" : "file", m = l ? a.maxFileDateModified || null : i.mtimeMs, h = l ? a.totalSize : i.size, g = l ? a.countFiles : null, b = {
+        path: f,
+        type: d
+      };
+      if (t.result.dateModified && (b.dateModified = m), t.result.size && (b.size = h), t.result.countFiles && (b.countFiles = g), t.dateModified && m != null) {
+        const [y, $] = t.dateModified;
+        if (y != null && m < y || $ != null && m > $)
+          return !1;
+      }
+      if (t.totalSize && h != null) {
+        const [y, $] = t.totalSize;
+        if (y != null && h < y || $ != null && h > $)
+          return !1;
+      }
+      return d === "file" && (o.countFiles = (o.countFiles ?? 0) + 1), d === "file" && h != null && (o.size = (o.size ?? 0) + h), m != null && (o.dateModified == null || m > o.dateModified) && (o.dateModified = m), l && !t.result.dirs || c && !t.result.files || s.push(b), !0;
+    }
+  }), { items: s, totals: o };
+}
+const ce = ["B", "KB", "MB", "GB", "TB"], ue = 1024;
+function de(t) {
+  if (t == null) return "-";
+  let r = t ?? 0, s = 0;
+  for (; r >= ue && s < ce.length - 1; )
+    r /= ue, s++;
+  return `${s === 0 ? r.toString() : r.toFixed(2)}${ce[s]}`;
+}
+function fe(t) {
+  const s = Date.now() - t;
+  if (s < 0) return "0s";
+  const o = Math.floor(s / 1e3), e = Math.floor(o / 60), n = Math.floor(e / 60), i = Math.floor(n / 24), a = Math.floor(i / 7), u = Math.floor(i / 30), l = Math.floor(i / 365);
+  return l > 0 ? `${l}Y` : u > 0 ? `${u}M` : a > 0 ? `${a}w` : i > 0 ? `${i}d` : n > 0 ? `${n}h` : e > 0 ? `${e}m` : `${o}s`;
+}
+function jt(t, r) {
+  return r?.length ? [...t].sort((s, o) => {
+    for (let e = 0, n = r.length; e < n; e++) {
+      const i = r[e];
+      let a, u;
+      switch (i.field) {
+        case "type":
+          a = s.type, u = o.type;
+          break;
+        case "path":
+          a = s.path, u = o.path;
+          break;
+        case "dateModified":
+          a = s.dateModified, u = o.dateModified;
+          break;
+        case "size":
+          a = s.size, u = o.size;
+          break;
+        case "countFiles":
+          a = s.countFiles, u = o.countFiles;
+          break;
+      }
+      if (a == null) {
+        if (u == null)
+          continue;
+        return 1;
+      }
+      if (u == null)
+        return -1;
+      const l = a > u ? 1 : a < u ? -1 : 0;
+      if (l !== 0)
+        return i.desc ? -l : l;
+    }
+    return 0;
+  }) : t;
+}
+function Jt(t, r) {
+  const s = jt(t.items, r.sort ?? []), o = r.fields && r.fields.length > 0 ? r.fields : [];
+  let e = "";
+  if (s.length > 0 && o.length > 0) {
+    for (let n = 0, i = o.length; n < i; n++) {
+      const a = o[n];
+      switch (n > 0 && (e += " | "), a) {
+        case "dateModified":
+          e += "Time ago (s/m/h/d/w/M/Y)";
+          break;
+        case "size":
+          e += "Size (B/KB/MB/TB)";
+          break;
+        case "type":
+          e += "Type";
+          break;
+        case "path":
+          e += "Path";
+          break;
+        case "countFiles":
+          e += "Files Count";
+          break;
+      }
+    }
+    for (let n = 0, i = s.length; n < i; n++) {
+      const a = s[n];
+      e += `
+`;
+      for (let u = 0, l = o.length; u < l; u++) {
+        const c = o[u];
+        switch (u > 0 && (e += " | "), c) {
+          case "dateModified":
+            e += a.dateModified ? fe(a.dateModified) : "-";
+            break;
+          case "size":
+            e += de(a.size);
+            break;
+          case "type":
+            e += a.type;
+            break;
+          case "path":
+            e += a.type === "dir" ? `${a.path}/` : a.path;
+            break;
+          case "countFiles":
+            a.type === "dir" ? e += a.countFiles != null ? a.countFiles.toString() : "-" : e += "-";
+            break;
+        }
+      }
+    }
+  }
+  {
+    e.length > 0 && (e += `
+---
+`);
+    const n = de(t.totals.size ?? 0), i = t.totals.dateModified ? `, last modified ${fe(t.totals.dateModified)} ago` : "";
+    e += `Totals: ${t.totals.countFiles ?? 0} files in dirs, ${n}${i}`;
+  }
+  return e;
+}
+const ns = "project-tools", is = "1.0.0", as = "d00f70240703039df14c76176a055bce6b5484d2b552ba2c89820f03b8e5e60d", me = 25e3;
+function he(t) {
+  const r = t.match(
+    /^\s*(\d+(?:\.\d+)?)\s*([smhdwMY]|sec(onds?)?|min(utes?)?|hours?|days?|weeks?|months?|years?)\s*$/i
+  );
+  if (!r)
+    throw new Error(
+      `Invalid time ago format: "${t}". Must be a number followed by a time unit. Valid units: s/sec/seconds (seconds), m/min/minutes (minutes), h/hours (hours), d/days (days), w/weeks (weeks), M/months (months), Y/years (years). Examples: "30s", "0.5h", "1.5d", "7d", "3w", "6M", "1Y". Format is case-insensitive except M (months) must be uppercase to distinguish from m (minutes).`
+    );
+  const s = parseFloat(r[1]);
+  let o = r[2];
+  switch (o !== "M" && (o = o.toLowerCase(), o.startsWith("month") ? o = "M" : o.length > 1 && (o = o[0])), o) {
+    case "s":
+      return s * 1e3;
+    case "m":
+      return s * 60 * 1e3;
+    case "h":
+      return s * 60 * 60 * 1e3;
+    case "d":
+      return s * 24 * 60 * 60 * 1e3;
+    case "w":
+      return s * 7 * 24 * 60 * 60 * 1e3;
+    case "M":
+      return s * 30 * 24 * 60 * 60 * 1e3;
+    case "y":
+      return s * 365 * 24 * 60 * 60 * 1e3;
+    default:
+      throw new Error(
+        `Unknown time unit: "${o}". Valid time units are: s (seconds), m (minutes), h (hours), d (days), w (weeks), M (months), Y (years). Use uppercase M for months to distinguish from lowercase m for minutes. Examples: "30s", "5m", "2h", "7d", "3w", "6M", "1Y".`
+      );
+  }
+}
+function pe(t) {
+  const r = t.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)\s*$/i);
+  if (!r)
+    throw new Error(
+      `Invalid size format: "${t}". Must be a number (integer or decimal) followed by a size unit. Valid units: B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes). Uses binary units (1024-based). Examples: "1B", "2.5KB", "100MB", "1.2GB", "0.5TB". Units are case-insensitive.`
+    );
+  const s = parseFloat(r[1]), o = r[2].toUpperCase();
+  switch (o) {
+    case "B":
+      return s;
+    case "KB":
+      return s * 1024;
+    case "MB":
+      return s * 1024 * 1024;
+    case "GB":
+      return s * 1024 * 1024 * 1024;
+    case "TB":
+      return s * 1024 * 1024 * 1024 * 1024;
+    default:
+      throw new Error(
+        `Unknown size unit: "${o}". Valid size units are: B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes). Uses binary calculation (1KB = 1024 bytes). Examples: "500B", "2KB", "100MB", "1.5GB", "2TB". Units are case-insensitive.`
+      );
+  }
+}
+const Oe = p.object({
+  rootDir: p.string().optional().describe(
+    'Root directory to list files from, resolved relative to the current working directory. Leave empty to use current directory. Examples: "src" (list src/ subdirectory), "../parent" (list parent directory), "docs/api" (list nested subdirectory). Path must exist and be accessible'
+  ),
+  globs: p.array(p.string()).optional().describe(
+    'Glob patterns to filter which files/directories to include. Add leading ** to match files and dirs in subdirectories. Examples: ["**/*.js"] (JavaScript files), ["src/**/*.ts"] (TypeScript files in src), ["**/dir/"] (all directories named "dir"), ["!node_modules"] (exclude {rootDir}/node_modules). If omitted, includes all files matching other criteria. Supports standard glob syntax: * (any chars), ** (any dirs), ? (single char), [abc] (char class)'
+  ),
+  showFiles: p.boolean().optional().describe(
+    "Whether to show regular files in the report table. Set to true to show files, false to hide them from the table. When both showFiles and showDirs are false, nothing will be shown in the table. It Does not affect totals. Default is false (do not show files in the table)"
+  ),
+  showDirs: p.boolean().optional().describe(
+    "Whether to show directories in the report table. Set to true to show directories, false to hide them from the table. When both showFiles and showDirs are false, nothing will be shown in the table. It Does not affect totals. Default is true (show directories in the table)"
+  ),
+  sortBy: p.array(
+    p.object({
+      field: p.enum(["type", "path", "lastModified", "size", "totalCountFiles"]).describe(
+        'Field to sort results by. "type" sorts files before directories. "path" sorts alphabetically by file/directory name. "lastModified" sorts by modification time (newest first when desc=true). "size" sorts by file/directory size (largest first when desc=true). "totalCountFiles" sorts by total files count (highest first when desc=true, directories only)'
+      ),
+      desc: p.boolean().optional().describe("Sort in descending order (largest/newest first)")
+    })
+  ).optional().describe(
+    'Multi-level sorting configuration. Sorts are applied in array order - first sort is primary, second is secondary, etc. Example: [{field: "type", desc: false}, {field: "size", desc: true}] sorts by type ascending, then by size descending within each type'
+  ),
+  fields: p.array(p.enum(["type", "path", "lastModified", "size", "totalCountFiles"])).optional().describe(
+    'Which data fields to include in the formatted table output. "type" shows file/directory indicator. "path" shows relative file/directory path. "lastModified" shows last modification time as time-ago format (5m, 2h, 3d, etc). "size" shows file/directory size in human-readable format (KB, MB, GB). "totalCountFiles" shows total files count for directories (displays "-" for files). Adding lastModified, size, or totalCountFiles fields increases processing time. Do not set fields if you want to show only totals summary'
+  ),
+  minTimeAgo: p.string().optional().describe(
+    'Filter files/directories modified at least this long ago. Only items older than this duration will be included. Format: number + unit (s/m/h/d/w/M/Y). Examples: "1h" (modified more than 1 hour ago), "7d" (modified more than 7 days ago), "6M" (modified more than 6 months ago)'
+  ),
+  maxTimeAgo: p.string().optional().describe(
+    'Filter files/directories modified at most this long ago. Only items newer than this duration will be included. Format: number + unit (s/m/h/d/w/M/Y). Examples: "1h" (modified within last hour), "7d" (modified within last 7 days), "1M" (modified within last month). Combine with minTimeAgo for date ranges'
+  ),
+  minTotalSize: p.string().optional().describe(
+    'Filter files/directories with total size at least this large. Only items with size >= this value will be included. For directories, uses total size of all contents. Format: number + unit (B/KB/MB/GB/TB). Examples: "1KB" (at least 1 kilobyte), "100MB" (at least 100 megabytes), "1.5GB" (at least 1.5 gigabytes)'
+  ),
+  maxTotalSize: p.string().optional().describe(
+    'Filter files/directories with total size at most this large. Only items with size <= this value will be included. For directories, uses total size of all contents. Format: number + unit (B/KB/MB/GB/TB). Examples: "1MB" (up to 1 megabyte), "500KB" (up to 500 kilobytes), "10GB" (up to 10 gigabytes). Combine with minTotalSize for size ranges'
+  )
+});
+async function Kt(t, r) {
+  let s;
+  try {
+    s = Oe.parse(t);
+  } catch (g) {
+    return {
+      error: `Invalid arguments: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+  const {
+    globs: o,
+    showFiles: e,
+    showDirs: n,
+    sortBy: i,
+    minTimeAgo: a,
+    maxTimeAgo: u,
+    minTotalSize: l,
+    maxTotalSize: c
+  } = s;
+  if (s.fields && s.fields.length > 0 && !s.fields.includes("path"))
+    return {
+      error: 'Fields array must include "path" field when fields are specified. The "path" field is required to identify files and directories in the output'
+    };
+  const f = s.fields ? s.fields.map((g) => g === "totalCountFiles" ? "countFiles" : g === "lastModified" ? "dateModified" : g) : [];
+  let d = i?.map((g) => {
+    let b = g.field;
+    return b === "totalCountFiles" && (b = "countFiles"), b === "lastModified" && (b = "dateModified"), {
+      field: b,
+      desc: g.desc ?? !1
+      // Default to ascending if not specified
+    };
+  }) ?? null;
+  (!d || d.length === 0) && (d = [{ field: "path", desc: !1 }]);
+  const m = d?.map((g) => g.field) || [], h = T.resolve(
+    r.workingDir || "",
+    s.rootDir || ""
+  );
+  try {
+    try {
+      await B.promises.access(h, B.constants.F_OK);
+    } catch (S) {
+      if (S.code === "ENOENT")
+        return {
+          error: `Directory does not exist: "${h}". Verify the path is correct and accessible. If using rootDir parameter, ensure it exists relative to the current working directory. Use fs-list without rootDir to list the current directory, or check parent directories first.`
+        };
+      throw S;
+    }
+    const g = o && o.length > 0 ? o.map((S) => ({
+      value: S,
+      valueType: "pattern",
+      exclude: !1
+    })) : [{ value: "**", valueType: "pattern", exclude: !1 }], b = r.globsExclude || [], y = [...g, ...b], $ = {
+      files: e ?? !1,
+      dirs: n ?? !1,
+      dateModified: f.includes("dateModified") || m.includes("dateModified"),
+      size: f.includes("size") || m.includes("size"),
+      countFiles: f.includes("countFiles") || m.includes("countFiles")
+    };
+    let I = null, x = null;
+    if (a || u)
+      try {
+        const S = Date.now(), v = u ? S - he(u) : null, E = a ? S - he(a) : null;
+        I = [v, E];
+      } catch (S) {
+        return {
+          error: S instanceof Error ? S.message : "Unknown error parsing time ago filter"
+        };
+      }
+    if (l || c)
+      try {
+        const S = l ? pe(l) : null, v = c ? pe(c) : null;
+        x = [S, v];
+      } catch (S) {
+        return {
+          error: S instanceof Error ? S.message : "Unknown error parsing size filter"
+        };
+      }
+    const w = await _t({
+      rootDir: h || null,
+      globs: y,
+      result: $,
+      dateModified: I,
+      totalSize: x
+    });
+    return w.items.length > me ? {
+      error: `Number of paths (${w.items.length}) exceeds maximum allowed (${me}). Consider using more specific glob patterns or filters to reduce the result set.`
+    } : {
+      output: Jt(w, {
+        sort: d,
+        fields: f,
+        totals: !0
+      })
+    };
+  } catch (g) {
+    return { error: g instanceof Error ? g.message : "Unknown error" };
+  }
+}
+function Wt(t, r) {
+  t(
+    "fs-list",
+    {
+      title: "List Files and Directories",
+      description: "List files and directories with advanced filtering, sorting and formatting options. Use this to analyze filesystem structure",
+      inputSchema: Oe.shape
+    },
+    async (s) => {
+      const o = await Kt(s, r);
+      return o.error ? `Method: fs-list(${JSON.stringify(s)})
+❌ Error: ${o.error}` : `Method: fs-list(${JSON.stringify(s)})
+${o.output || JSON.stringify(o, null, 2)}`;
+    }
+  );
+}
+const _ = /* @__PURE__ */ new Map();
+function Y(t) {
+  return _.has(t) || _.set(t, {
+    fsSnapshotQueries: /* @__PURE__ */ new Map(),
+    fsSnapshots: /* @__PURE__ */ new Map()
+  }), _.get(t);
+}
+function ge(t) {
+  const r = t.match(
+    /^\s*(\d+(?:\.\d+)?)\s*([smhdwMY]|sec(onds?)?|min(utes?)?|hours?|days?|weeks?|months?|years?)\s*$/i
+  );
+  if (!r)
+    throw new Error(
+      `Invalid time ago format: "${t}". Must be a number followed by a time unit. Valid units: s/sec/seconds (seconds), m/min/minutes (minutes), h/hours (hours), d/days (days), w/weeks (weeks), M/months (months), Y/years (years). Examples: "30s", "0.5h", "1.5d", "7d", "3w", "6M", "1Y". Format is case-insensitive except M (months) must be uppercase to distinguish from m (minutes).`
+    );
+  const s = parseFloat(r[1]);
+  let o = r[2];
+  switch (o !== "M" && (o = o.toLowerCase(), o.startsWith("month") ? o = "M" : o.length > 1 && (o = o[0])), o) {
+    case "s":
+      return s * 1e3;
+    case "m":
+      return s * 60 * 1e3;
+    case "h":
+      return s * 60 * 60 * 1e3;
+    case "d":
+      return s * 24 * 60 * 60 * 1e3;
+    case "w":
+      return s * 7 * 24 * 60 * 60 * 1e3;
+    case "M":
+      return s * 30 * 24 * 60 * 60 * 1e3;
+    case "y":
+      return s * 365 * 24 * 60 * 60 * 1e3;
+    default:
+      throw new Error(
+        `Unknown time unit: "${o}". Valid time units are: s (seconds), m (minutes), h (hours), d (days), w (weeks), M (months), Y (years). Use uppercase M for months to distinguish from lowercase m for minutes. Examples: "30s", "5m", "2h", "7d", "3w", "6M", "1Y".`
+      );
+  }
+}
+function we(t) {
+  const r = t.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)\s*$/i);
+  if (!r)
+    throw new Error(
+      `Invalid size format: "${t}". Must be a number (integer or decimal) followed by a size unit. Valid units: B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes). Uses binary units (1024-based). Examples: "1B", "2.5KB", "100MB", "1.2GB", "0.5TB". Units are case-insensitive.`
+    );
+  const s = parseFloat(r[1]), o = r[2].toUpperCase();
+  switch (o) {
+    case "B":
+      return s;
+    case "KB":
+      return s * 1024;
+    case "MB":
+      return s * 1024 * 1024;
+    case "GB":
+      return s * 1024 * 1024 * 1024;
+    case "TB":
+      return s * 1024 * 1024 * 1024 * 1024;
+    default:
+      throw new Error(
+        `Unknown size unit: "${o}". Valid size units are: B (bytes), KB (kilobytes), MB (megabytes), GB (gigabytes), TB (terabytes). Uses binary calculation (1KB = 1024 bytes). Examples: "500B", "2KB", "100MB", "1.5GB", "2TB". Units are case-insensitive.`
+      );
+  }
+}
+const V = p.object({
+  name: p.string().describe(
+    "Unique name for the filesystem snapshot query. Recommended format: kebab-case-1, kebab-case-2, ..."
+  ),
+  rootDir: p.string().optional().describe(
+    'Root directory to snapshot, resolved relative to the current working directory. Leave empty to use current directory. Examples: "src" (snapshot src/ subdirectory), "../parent" (snapshot parent directory), "docs/api" (snapshot nested subdirectory). Path must exist and be accessible'
+  ),
+  globs: p.array(p.string()).optional().describe(
+    'Glob patterns to filter which files/directories to include in snapshot. Add leading ** to match files and dirs in subdirectories. Examples: ["**/*.js"] (JavaScript files), ["src/**/*.ts"] (TypeScript files in src), ["**/dir/"] (all directories named "dir"), ["!node_modules"] (exclude {rootDir}/node_modules). If omitted, includes all files matching other criteria. Supports standard glob syntax: * (any chars), ** (any dirs), ? (single char), [abc] (char class)'
+  ),
+  matchFiles: p.boolean().optional().describe(
+    "Include matched files in the snapshot with all parent directories"
+  ),
+  matchDirs: p.boolean().optional().describe(
+    "Include matched directories in the snapshot with all parent directories"
+  ),
+  extraFields: p.array(p.enum(["lastModified", "size", "countMatched"])).optional().describe(
+    'Which extra data fields to include in the snapshot tree output. "lastModified" shows last modification time as time-ago format (5m, 2h, 3d, etc). "size" shows file/directory size in human-readable format (KB, MB, GB). "countMatched" shows total matched items count'
+  ),
+  minTimeAgo: p.string().optional().describe(
+    'Filter files/directories modified at least this long ago. Only items older than this duration will be included. Format: number + unit (s/m/h/d/w/M/Y). Examples: "1h" (modified more than 1 hour ago), "7d" (modified more than 7 days ago), "6M" (modified more than 6 months ago)'
+  ),
+  maxTimeAgo: p.string().optional().describe(
+    'Filter files/directories modified at most this long ago. Only items newer than this duration will be included. Format: number + unit (s/m/h/d/w/M/Y). Examples: "1h" (modified within last hour), "7d" (modified within last 7 days), "1M" (modified within last month). Combine with minTimeAgo for date ranges'
+  ),
+  minTotalSize: p.string().optional().describe(
+    'Filter files/directories with total size at least this large. Only items with size >= this value will be included. For directories, uses total size of all contents. Format: number + unit (B/KB/MB/GB/TB). Examples: "1KB" (at least 1 kilobyte), "100MB" (at least 100 megabytes), "1.5GB" (at least 1.5 gigabytes)'
+  ),
+  maxTotalSize: p.string().optional().describe(
+    'Filter files/directories with total size at most this large. Only items with size <= this value will be included. For directories, uses total size of all contents. Format: number + unit (B/KB/MB/GB/TB). Examples: "1MB" (up to 1 megabyte), "500KB" (up to 500 kilobytes), "10GB" (up to 10 gigabytes). Combine with minTotalSize for size ranges'
+  )
+}), ye = new Map(
+  [
+    "name",
+    "type",
+    "countMatched",
+    "size",
+    "dateModified"
+  ].map((t, r) => [t, r])
+);
+function Qt(t, r) {
+  const s = ye.get(t) ?? 1 / 0, o = ye.get(r) ?? 1 / 0;
+  return s > o ? 1 : s < o ? -1 : 0;
+}
+async function Re(t, r, s) {
+  let o;
+  try {
+    o = V.parse(t);
+  } catch (h) {
+    return {
+      error: `Invalid arguments: ${h instanceof Error ? h.message : "Unknown error"}`
+    };
+  }
+  const {
+    name: e,
+    globs: n,
+    matchFiles: i,
+    matchDirs: a,
+    minTimeAgo: u,
+    maxTimeAgo: l,
+    minTotalSize: c,
+    maxTotalSize: f
+  } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const d = Y(s.sessionId);
+  if (d.fsSnapshotQueries.has(e))
+    return {
+      error: `Filesystem snapshot query "${e}" already exists`
+    };
+  const m = T.resolve(r.workingDir || "", o.rootDir || "").replace(/\\/g, "/");
+  try {
+    try {
+      await B.promises.access(m, B.constants.F_OK);
+    } catch (w) {
+      if (w.code === "ENOENT")
+        return {
+          error: `Directory does not exist: "${m}". Verify the path is correct and accessible. If using rootDir parameter, ensure it exists relative to the current working directory. Use fs-snapshot-query-create without rootDir to snapshot the current directory, or check parent directories first.`
+        };
+      throw w;
+    }
+    const h = o.extraFields ? o.extraFields.map((w) => w === "lastModified" ? "dateModified" : w) : [];
+    h.includes("name") || h.push("name"), h.sort(Qt);
+    const g = n && n.length > 0 ? n.map((w) => ({
+      value: w,
+      valueType: "pattern",
+      exclude: !1
+    })) : [{ value: "**", valueType: "pattern", exclude: !1 }], b = r.globsExclude || [], y = [...g, ...b];
+    let $ = null, I = null;
+    if (u || l)
+      try {
+        const w = Date.now(), M = l ? w - ge(l) : null, S = u ? w - ge(u) : null;
+        $ = [M, S];
+      } catch (w) {
+        return {
+          error: w instanceof Error ? w.message : "Unknown error parsing time ago filter"
+        };
+      }
+    if (c || f)
+      try {
+        const w = c ? we(c) : null, M = f ? we(f) : null;
+        I = [w, M];
+      } catch (w) {
+        return {
+          error: w instanceof Error ? w.message : "Unknown error parsing size filter"
+        };
+      }
+    const x = {
+      name: e,
+      rootDir: m,
+      globs: y,
+      matchFiles: i ?? null,
+      matchDirs: a ?? null,
+      dateModified: $,
+      totalSize: I,
+      fields: h
+    };
+    return d.fsSnapshotQueries.set(e, x), {
+      snapshotQuery: x
+    };
+  } catch (h) {
+    return {
+      error: h instanceof Error ? h.message : "Unknown error"
+    };
+  }
+}
+function Ht(t, r) {
+  t(
+    "fs-snapshot-query-create",
+    {
+      title: "Create Filesystem Snapshot Query",
+      description: "Create a filesystem snapshot query. Prefer fs-snapshot-browse if you need to immediately create a query, snapshot and browse it",
+      inputSchema: V.shape
+    },
+    async (s, o) => {
+      const e = await Re(s, r, o);
+      return e.error != null ? `Method: fs-snapshot-query-create(${JSON.stringify(s)})
+❌ Error: ${e.error}` : `Method: fs-snapshot-query-create(${JSON.stringify(s)})
+✅ Filesystem snapshot query "${e.snapshotQuery.name}" created successfully`;
+    }
+  );
+}
+function q(t) {
+  const { idToNode: r, idToChildIds: s } = t, o = r.get(null);
+  if (o == null)
+    throw new Error(
+      "Impossible behavior: root node (id: null) not found in idToNode"
+    );
+  const e = /* @__PURE__ */ new Map();
+  return r.forEach((n, i) => {
+    if (n != null) {
+      if (e.has(n)) {
+        const a = e.get(n);
+        throw new Error(
+          `Impossible behavior: node appears with multiple IDs (existing: ${a}, new: ${i})`
+        );
+      }
+      e.set(n, i);
+    }
+  }), {
+    root: o,
+    getNode: (n) => r.get(n) ?? null,
+    getId: (n) => e.get(n) ?? null,
+    getChilds: (n) => {
+      let i = e.get(n);
+      if (i == null)
+        if (n === r.get(null))
+          i = null;
+        else
+          throw new Error("Impossible behavior: node not found in idToNode");
+      const a = s.get(i);
+      return a == null ? null : a.map((u) => {
+        const l = r.get(u);
+        if (l == null)
+          throw new Error(
+            `Child node with id '${u}' not found in idToNode`
+          );
+        return l;
+      });
+    }
+  };
+}
+function ze(t, r, s) {
+  let o = null;
+  for (let e = 0, n = r.length; e < n; e++) {
+    const i = r[e], a = t(i), u = a == null ? null : ze(t, a, s), l = s(i, u);
+    l != null && (o == null && (o = []), o.push(l));
+  }
+  return o;
+}
+function Ue(t) {
+  const { getId: r, getChilds: s, rootNodes: o, createSnapshotNode: e } = t, n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), u = ze(
+    s,
+    o,
+    (c, f) => {
+      const d = e(c, f);
+      if (c != null && d != null) {
+        const m = r(c);
+        n.set(m, d), i.set(d, m);
+      }
+      return d != null && f != null && a.set(
+        i.get(d),
+        f.map((m) => i.get(m))
+      ), d;
+    }
+  ), l = e(null, u);
+  if (l == null)
+    throw new Error("Impossible behavior: rootNode == null");
+  return n.set(null, l), u != null && a.set(
+    null,
+    u.map((c) => i.get(c))
+  ), {
+    idToNode: n,
+    idToChildIds: a
+  };
+}
+function K(t) {
+  return t = t?.replace(/\\/g, "/").replace(/\/$/, ""), !t || t === "." ? null : t;
+}
+async function Yt(t) {
+  const r = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), o = T.resolve(t.rootDir || "."), n = {
+    path: ".",
+    name: T.basename(o),
+    type: "dir",
+    isMatched: !1,
+    dateModified: null,
+    size: 0
+  };
+  r.set(null, n);
+  const i = await Be({
+    rootDir: o,
+    globs: t.globs
+  });
+  return await De({
+    paths: [o],
+    walkLinks: !0,
+    matchPath: Fe({
+      globs: i,
+      rootDir: o,
+      noCase: !0
+    }),
+    handlePath: async ({ path: a, stat: u, itemStat: l }) => {
+      const c = T.relative(o, a), f = u.isDirectory(), d = u.isFile();
+      if (!f && !d)
+        return !0;
+      const m = K(c || "."), h = f ? "dir" : "file", g = f ? null : u.mtimeMs, b = u.size;
+      let y = !0;
+      if (d && !t.matchFiles && (y = !1), f && !t.matchDirs && (y = !1), y && d && t.dateModified && g != null) {
+        const [w, M] = t.dateModified;
+        (w != null && g < w || M != null && g > M) && (y = !1);
+      }
+      if (y && d && t.totalSize && b != null) {
+        const [w, M] = t.totalSize;
+        (w != null && b < w || M != null && b > M) && (y = !1);
+      }
+      if (f && !y) {
+        if (!(l.countFiles && l.countFiles > 0)) return !1;
+      } else if (!y)
+        return !1;
+      const $ = {
+        path: m ?? ".",
+        name: T.basename(a),
+        type: h,
+        dateModified: g,
+        size: b,
+        isMatched: y
+      };
+      if (m == null)
+        return n.dateModified = g, n.size = b, n.isMatched = y, !0;
+      r.set(m, $);
+      const I = K(T.dirname(m).replace(/\\/g, "/"));
+      let x = s.get(I);
+      return x || (x = [], s.set(I, x)), x.push(m), !0;
+    }
+  }), {
+    idToNode: r,
+    idToChildIds: s
+  };
+}
+const Vt = [
+  { name: "[ ]", match: (t) => t === 32, min: 2, max: 81 },
+  { name: "[\\t]", match: (t) => t === 9, min: 2, max: 20 },
+  { name: "[\\n]", match: (t) => t === 10, min: 2, max: 14 },
+  { name: "[-]", match: (t) => t === 45, min: 2, max: 16 },
+  { name: "[=]", match: (t) => t === 61, min: 2, max: 16 },
+  { name: "[_]", match: (t) => t === 95, min: 2, max: 16 },
+  { name: "[*]", match: (t) => t === 42, min: 2, max: 16 },
+  { name: "[.]", match: (t) => t === 46, min: 2, max: 16 },
+  { name: "[0-9]", match: (t) => t >= 48 && t <= 57, min: 2, max: 3 }
+  // { name: '[a-z]', match: c => c >= 97 && c <= 122, min: 2, max: 2 },
+  // { name: '[A-Z]', match: c => c >= 65 && c <= 90, min: 2, max: 2 },
+  // Other ASCII symbols
+  // {
+  //   name: 'Other ASCII',
+  //   match: c =>
+  //     (c > 32 && c < 48) ||
+  //     (c > 57 && c < 65) ||
+  //     (c > 90 && c < 97),
+  //   min: 2,
+  //   max: 2,
+  // },
+];
+function be(t, r = Vt) {
+  const s = t.length;
+  if (s === 0) return 0;
+  const o = r.length;
+  if (o === 0)
+    return s;
+  let e = 0, n = 0;
+  for (; n < s; ) {
+    const i = t.charCodeAt(n);
+    let a = !1;
+    for (let u = 0; u < o; u++) {
+      const l = r[u];
+      if (l.match(i)) {
+        let c = 1;
+        for (; ++n < s && l.match(t.charCodeAt(n)) && c < l.max; )
+          c++;
+        if (c >= l.min) {
+          e++, a = !0;
+          break;
+        }
+      }
+    }
+    a || (n++, e++);
+  }
+  return e;
+}
+function Pe(t) {
+  let r = 0;
+  return r += be(t.textOpen) + 1, t.textClose != null && (r += be(t.textClose) + 1), t.indent && (r += 1), r;
+}
+const $e = ["B", "KB", "MB", "GB", "TB"], xe = 1024;
+function Zt(t) {
+  if (t == null) return "-";
+  let r = t ?? 0, s = 0;
+  for (; r >= xe && s < $e.length - 1; )
+    r /= xe, s++;
+  return `${s === 0 ? r.toString() : r.toFixed(2)}${$e[s]}`;
+}
+function Xt(t) {
+  const s = Date.now() - t;
+  if (s < 0) return "0s";
+  const o = Math.floor(s / 1e3), e = Math.floor(o / 60), n = Math.floor(e / 60), i = Math.floor(n / 24), a = Math.floor(i / 7), u = Math.floor(i / 30), l = Math.floor(i / 365);
+  return l > 0 ? `${l}Y` : u > 0 ? `${u}M` : a > 0 ? `${a}w` : i > 0 ? `${i}d` : n > 0 ? `${n}h` : e > 0 ? `${e}m` : `${o}s`;
+}
+function er(t) {
+  return function(s, o) {
+    const e = t.get(s), n = t.get(o);
+    if (e.type !== n.type)
+      return e.type === "file" ? -1 : 1;
+    if (e.type === "file")
+      return e.name < n.name ? -1 : e.name > n.name ? 1 : 0;
+    {
+      const i = e.countFiles || 0, a = n.countFiles || 0;
+      return i < a ? -1 : i > a ? 1 : e.name < n.name ? -1 : e.name > n.name ? 1 : 0;
+    }
+  };
+}
+function tr(t) {
+  const r = t.fields ?? [];
+  return function(o, e) {
+    let n = "", i, a = 0;
+    const u = e ? e.length : 0;
+    let l = 1, c, f = 0, d = 0, m = 0, h = 0, g = null, b, y, $;
+    if (e)
+      for (let x = 0; x < e.length; x++) {
+        const w = e[x];
+        a += w.countMatched, l += w.countTotal, f += w.tokens, d += w.tokensTotal, m += w.size, h += w.countFiles, w.dateModified != null && (g == null || w.dateModified > g) && (g = w.dateModified);
+      }
+    o ? (b = o.type, y = o.name, $ = o.path, i = o.isMatched, i && (a += 1), o.type === "file" ? (m = o.size || 0, h = 1, g = o.dateModified || null) : o.dateModified != null && (g == null || o.dateModified > g) && (g = o.dateModified)) : (b = "dir", y = "<root>", $ = ".", i = !0);
+    for (let x = 0, w = r.length; x < w; x++) {
+      const M = r[x];
+      switch (x > 0 && (n += " "), M) {
+        case "dateModified":
+          n += g ? Xt(g) : "-";
+          break;
+        case "size":
+          n += Zt(m);
+          break;
+        case "type":
+          n += b;
+          break;
+        case "name":
+          n += b === "dir" ? `${y}/` : y;
+          break;
+        case "countMatched":
+          n += a.toString();
+          break;
+      }
+    }
+    const I = {
+      indent: !0,
+      textOpen: n,
+      textClose: null
+    };
+    return c = Pe(I), d += c, {
+      type: b,
+      name: y,
+      path: $,
+      isMatched: i,
+      countMatched: a,
+      countChilds: u,
+      countTotal: l,
+      tokens: c,
+      tokensChilds: f,
+      tokensTotal: d,
+      text: I,
+      size: m,
+      countFiles: h,
+      dateModified: g
+    };
+  };
+}
+async function rr(t) {
+  const r = await Yt(t), s = q(r), o = s.getChilds(s.root), e = Ue({
+    getId: (i) => {
+      const a = s.getId(i);
+      if (a == null)
+        throw new Error(
+          `Invalid tree structure: node ID is null for node ${JSON.stringify(i)}`
+        );
+      return a;
+    },
+    getChilds: (i) => s.getChilds(i),
+    createSnapshotNode: tr(t),
+    rootNodes: o ?? []
+  }), n = er(e.idToNode);
+  return e.idToChildIds.forEach((i) => {
+    i.sort(n);
+  }), q(e);
+}
+const Z = p.object({
+  queryName: p.string().optional().describe("Name of previously created filesystem snapshot query, to use"),
+  query: V.optional().describe(
+    "Filesystem snapshot query creation options to automatically create query"
+  ),
+  name: p.string().describe(
+    "Unique name for the filesystem snapshot. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function Le(t, r, s) {
+  let o;
+  try {
+    o = Z.parse(t);
+  } catch (c) {
+    return {
+      error: `Invalid arguments: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+  const { name: e, queryName: n, query: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = Y(s.sessionId);
+  if (a.fsSnapshots.has(e))
+    return {
+      error: `Filesystem snapshot "${e}" already exists`
+    };
+  if (n && i)
+    return {
+      error: "Either queryName or query must be provided, not both"
+    };
+  let u, l = !1;
+  if (n) {
+    const c = a.fsSnapshotQueries.get(n);
+    if (!c)
+      return {
+        error: `Filesystem snapshot query "${n}" not found`
+      };
+    u = c;
+  } else if (i) {
+    const c = await Re(
+      i,
+      r,
+      s
+    );
+    if (c.error != null)
+      return {
+        error: c.error
+      };
+    u = c.snapshotQuery, l = !0;
+  } else
+    return {
+      error: "Either queryName or query must be provided"
+    };
+  try {
+    const c = await rr(u), f = {
+      name: e,
+      query: u,
+      tree: c
+    };
+    return a.fsSnapshots.set(e, f), {
+      fsSnapshot: f,
+      queryCreated: l
+    };
+  } catch (c) {
+    return {
+      error: `Failed to create filesystem snapshot: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+}
+function sr(t, r) {
+  t(
+    "fs-snapshot-create",
+    {
+      title: "Create Filesystem Snapshot",
+      description: "Create a filesystem snapshot. Use this to capture filesystem state for later browsing. Prefer fs-snapshot-browse if you need to immediately create and browse a snapshot",
+      inputSchema: Z.shape
+    },
+    async (s, o) => {
+      const e = await Le(s, r, o);
+      if (e.error != null)
+        return `Method: fs-snapshot-create(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: fs-snapshot-create(${JSON.stringify(s)})
+`;
+      return e.queryCreated && (n += `✅ Filesystem snapshot query "${e.fsSnapshot.query.name}" created successfully
+`), n += `✅ Filesystem snapshot "${e.fsSnapshot.name}" created successfully`, n;
+    }
+  );
+}
+class or {
+  _first = null;
+  _last = null;
+  _size = 0;
+  enqueue(r) {
+    const s = { item: r, next: null };
+    this._last ? this._last.next = s : this._first = s, this._last = s, this._size += 1;
+  }
+  dequeue() {
+    if (!this._first) return null;
+    const r = this._first.item;
+    return this._first = this._first.next, this._first || (this._last = null), this._size -= 1, r;
+  }
+  peek() {
+    return this._first ? this._first.item : null;
+  }
+  isEmpty() {
+    return this._first == null;
+  }
+  size() {
+    return this._size;
+  }
+}
+function nr(t) {
+  const r = new or(), {
+    tree: s,
+    limits: { maxCountTotal: o, maxTokensTotal: e, maxCountGroup: n, maxTokensGroup: i },
+    indexRangeGroupStrategy: a
+  } = t, u = s.getChilds(s.root);
+  u != null && u.length > 0 && r.enqueue({
+    reportNode: null,
+    node: s.root
+  });
+  let l = null, c = 0, f = 0;
+  for (; !r.isEmpty(); ) {
+    const { reportNode: d, node: m } = r.dequeue(), h = s.getChilds(m);
+    if (h == null || m.countChilds === 0 || h.length !== m.countChilds)
+      throw new Error(
+        "Impossible behavior: nodeChilds is null or length mismatch"
+      );
+    let g = r.size();
+    for (let y = 0; y < h.length; y++)
+      h[y].countChilds > 0 && (g += 1);
+    const b = g * a.tokens;
+    if (o != null && c + m.countChilds + g > o || e != null && f + m.tokensChilds + b > e) {
+      const y = [];
+      let $ = null, I = 0;
+      for (let w = 0, M = h.length; w < M; w++) {
+        const S = h[w], v = I * a.tokens;
+        $ != null && // Если общий лимит превышен, то не создаем новую группу, а продолжаем текущую. В случае достижения лимитов, последняя группа может содержать больше элементов, чем указано в лимитах группы, и это допустимо. Главное - дать в отчете полную картину.
+        !(o != null && c + 1 > o || e != null && f + a.tokens > e) && (n != null && $.countGrouped + 1 + I > n || i != null && $.tokensGrouped + S.tokens + v > i) && (y.push($), c += 1, f += a.tokens, $ = null, I = 0), $ = a.add($, S, w), S.countChilds > 0 && (I += 1);
+      }
+      $ != null && (y.push($), c += 1, f += a.tokens);
+      const x = y.map((w) => ({
+        text: a.getReportText(w)
+      }));
+      if (d != null) {
+        if (d.childs != null)
+          throw new Error("Impossible behavior: reportNode.childs != null");
+        d.childs = x;
+      } else {
+        if (l != null)
+          throw new Error("Impossible behavior: reportRootNodes != null");
+        l = x;
+      }
+    } else {
+      c += m.countChilds, f += m.tokensChilds;
+      const y = [];
+      for (let $ = 0; $ < h.length; $++) {
+        const I = h[$], x = {
+          text: I.text
+        };
+        y.push(x);
+        const w = s.getChilds(I);
+        w != null && w.length > 0 && r.enqueue({
+          reportNode: x,
+          node: I
+        });
+      }
+      if (d != null) {
+        if (d.childs != null)
+          throw new Error("Impossible behavior: reportNode.childs != null");
+        d.childs = y;
+      } else {
+        if (l != null)
+          throw new Error("Impossible behavior: reportRootNodes != null");
+        l = y;
+      }
+    }
+  }
+  return l ?? [];
+}
+function Ae(t) {
+  const {
+    tree: r,
+    request: { parentNodeId: s, childsIndexRange: o, limits: e },
+    indexRangeGroupStrategy: n,
+    ...i
+  } = t;
+  let a;
+  if (s != null) {
+    const d = r.getNode(s);
+    if (d == null)
+      throw new Error(`Parent node "${s}" not found`);
+    a = d;
+  } else
+    a = r.root;
+  let u, l = r.getChilds(a) ?? [];
+  if (o != null) {
+    const [d, m] = o;
+    if (d < 0 || m <= d || m >= l.length)
+      throw new Error(
+        `Invalid index range: ${d}-${m} for root nodes length ${l.length}`
+      );
+    const h = [];
+    let g = null;
+    for (let b = d; b <= m; b++) {
+      const y = l[b];
+      h.push(y), g = n.add(g, y, b);
+    }
+    l = h, u = {
+      ...a,
+      text: n.getReportText(g),
+      countChilds: g.countGrouped,
+      tokensChilds: g.tokensGrouped
+    };
+  } else
+    u = a;
+  const c = {
+    countChilds: 1,
+    tokensChilds: u.tokens
+  }, f = {
+    ...r,
+    root: c,
+    getChilds: (d) => d === c ? [u] : d === u ? l : r.getChilds(d)
+  };
+  return nr({
+    tree: f,
+    limits: e,
+    indexRangeGroupStrategy: n,
+    ...i
+  });
+}
+function Ge(t, r) {
+  if (t == null || t.length === 0)
+    return "No results found";
+  let s = "";
+  function o(e, n) {
+    for (let i = 0, a = e.length; i < a; i++) {
+      const u = e[i];
+      s += n, s += u.text.textOpen + `
+`, u.childs != null && u.childs.length > 0 && o(
+        u.childs,
+        u.text.indent ? n + "  " : n
+      ), u.text.textClose != null && (s += n, s += u.text.textClose + `
+`);
+    }
+  }
+  return o(t, ""), s;
+}
+class ir {
+  tokens = 16;
+  // +1 indent, +1 for line break
+  getReportText = (r) => ({
+    indent: !0,
+    textOpen: `[${r.indexRange[0]}-${r.indexRange[1]}] ${r.countMatched} matched ${r.tokensGrouped} tokens`,
+    textClose: null
+  });
+  add = (r, s, o) => r == null ? {
+    indexRange: [o, o],
+    countGrouped: 1,
+    countMatched: s.countMatched,
+    tokensGrouped: s.tokens
+  } : (r.indexRange[1] = o, r.countGrouped += 1, r.countMatched += s.countMatched, r.tokensGrouped += s.tokens, r);
+}
+const qe = p.object({
+  snapshotName: p.string().optional().describe("Name of previously created filesystem snapshot, to use"),
+  snapshot: Z.optional().describe(
+    "Filesystem snapshot creation options to automatically create snapshot"
+  ),
+  parentPath: p.string().optional().describe(
+    "Path relative to snapshot rootDir to browse. Omit to browse the rootDir itself"
+  ),
+  childsIndexRange: p.tuple([p.number(), p.number()]).optional().describe(
+    "Child index range to show [start, end]. Only use the exact ranges that appeared in previous snapshot results - do not modify, combine, or split them"
+  )
+  // maxCountTotal: z
+  //   .number()
+  //   .default(100)
+  //   .describe('Maximum total number of items to show'),
+  // maxTokensTotal: z
+  //   .number()
+  //   .default(10000)
+  //   .describe('Maximum total tokens to show'),
+  // maxCountGroup: z.number().default(10).describe('Maximum items per group'),
+  // maxTokensGroup: z.number().default(1000).describe('Maximum tokens per group'),
+});
+async function ar(t, r, s) {
+  let o;
+  try {
+    o = qe.parse(t);
+  } catch (g) {
+    return {
+      error: `Invalid arguments: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+  const {
+    snapshotName: e,
+    snapshot: n,
+    childsIndexRange: i
+    // maxCountTotal,
+    // maxTokensTotal,
+    // maxCountGroup,
+    // maxTokensGroup,
+  } = o, a = 60, u = 1e3, l = 25, c = 900;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const f = Y(s.sessionId);
+  let d, m = !1, h = !1;
+  if (e && n)
+    return {
+      error: "Either snapshotName or snapshot must be provided, not both"
+    };
+  if (e) {
+    if (d = f.fsSnapshots.get(e), d == null)
+      return {
+        error: `Filesystem snapshot "${e}" not found`
+      };
+  } else if (n) {
+    const g = await Le(
+      n,
+      r,
+      s
+    );
+    if (g.error != null)
+      return {
+        error: g.error
+      };
+    d = g.fsSnapshot, m = g.queryCreated, h = !0;
+  } else
+    return {
+      error: "Either snapshotName or snapshot must be provided"
+    };
+  try {
+    const g = K(o.parentPath), b = Ae({
+      tree: d.tree,
+      request: {
+        parentNodeId: g,
+        childsIndexRange: i,
+        limits: {
+          maxCountTotal: a,
+          maxTokensTotal: u,
+          maxCountGroup: l,
+          maxTokensGroup: c
+        }
+      },
+      indexRangeGroupStrategy: new ir()
+    }), y = Ge(b);
+    return {
+      fsSnapshot: d,
+      queryCreated: m,
+      snapshotCreated: h,
+      parentPath: g,
+      childsIndexRange: i,
+      report: y
+    };
+  } catch (g) {
+    return {
+      error: `Failed to browse filesystem snapshot: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+}
+function lr(t, r) {
+  t(
+    "fs-snapshot-browse",
+    {
+      title: "Browse Filesystem Snapshot",
+      description: "Browse and explore filesystem. Use this to efficiently browse, analyze, explore, inspect, etc directory and file structures",
+      inputSchema: qe.shape
+    },
+    async (s, o) => {
+      const e = await ar(s, r, o);
+      if (e.error != null)
+        return `Method: fs-snapshot-browse(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: fs-snapshot-browse(${JSON.stringify(s)})
+`;
+      if (e.queryCreated && (n += `✅ Filesystem snapshot query "${e.fsSnapshot.query.name}" created successfully
+`), e.snapshotCreated && (n += `✅ Filesystem snapshot "${e.fsSnapshot.name}" created successfully
+`), n += `✅ Browsing filesystem snapshot "${e.fsSnapshot.name}":
+`, n += `Root directory: ${e.fsSnapshot.query.rootDir || "./"}
+`, n += `Parent path: ${"./" + (e.parentPath ?? "")}
+`, n += `Fields: ${e.fsSnapshot.query.fields.map((i) => i === "dateModified" ? "lastModified" : i).join(" ")}
+`, e.childsIndexRange) {
+        const [i, a] = e.childsIndexRange, l = (e.parentPath ? e.fsSnapshot.tree.getNode(e.parentPath) : e.fsSnapshot.tree.root).countChilds;
+        n += `   Showing indexes: ${i}-${a} of ${l}
+`;
+      }
+      return n += `
+${e.report}`, n;
+    }
+  );
+}
+function cr(t, r) {
+  r.list && Wt(t, r), r.snapshotQueryCreate && Ht(t, r), r.snapshotCreate && sr(t, r), r.snapshotBrowse && lr(t, r), console.log(
+    `File manager:
+- Working directory: ${T.resolve(r.workingDir || "")}
+`
+  );
+}
+const j = /* @__PURE__ */ new Map();
+function N(t) {
+  return j.has(t) || j.set(t, {
+    browsers: /* @__PURE__ */ new Map(),
+    domSnapshotQueries: /* @__PURE__ */ new Map()
+  }), j.get(t);
+}
+const X = p.object({
+  name: p.string().describe(
+    "Unique name for the browser. Recommended format: kebab-case-1, kebab-case-2, ..."
+  ),
+  browserType: p.enum(["chromium", "firefox", "webkit"]).describe("Browser type to launch"),
+  muteAudio: p.boolean().optional().describe("Mute audio in the browser"),
+  devTools: p.boolean().optional().describe("Open browser with dev tools")
+});
+async function _e(t, r, s) {
+  let o;
+  try {
+    o = X.parse(t);
+  } catch (c) {
+    return {
+      error: `Invalid arguments: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+  const { name: e, browserType: n, muteAudio: i, devTools: a } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const u = N(s.sessionId), l = u.browsers.get(e);
+  if (l)
+    return {
+      error: `Browser "${l.name}" (${l.browserType}) already exists`
+    };
+  try {
+    const f = await {
+      chromium: pt,
+      firefox: ht,
+      webkit: mt
+    }[n].launch({
+      headless: !1,
+      devtools: a,
+      args: i ? ["--mute-audio"] : void 0
+    }), d = {
+      name: e,
+      browserType: n,
+      browser: f,
+      contexts: /* @__PURE__ */ new Map()
+    };
+    return u.browsers.set(e, d), { browserInfo: d };
+  } catch (c) {
+    return {
+      error: `Failed to create browser: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+}
+function ur(t, r) {
+  t(
+    "playwright-browser-create",
+    {
+      title: "Create Browser",
+      description: "Create a new browser. Prefer page-goto if you need to immediately create a browser, context, page and navigate",
+      inputSchema: X.shape
+    },
+    async (s, o) => {
+      const e = await _e(s, r, o);
+      return `Method: playwright-browser-create(${JSON.stringify(s)})
+${e.error != null ? `❌ Error: ${e.error}` : `✅ Browser "${e.browserInfo.name}" (${e.browserInfo.browserType}) created successfully`}`;
+    }
+  );
+}
+const je = p.object({});
+async function dr(t, r, s) {
+  let o;
+  try {
+    o = je.parse(t);
+  } catch (i) {
+    return {
+      error: `Invalid arguments: ${i instanceof Error ? i.message : "Unknown error"}`
+    };
+  }
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const e = N(s.sessionId);
+  return {
+    browserInfos: Array.from(e.browsers.values())
+  };
+}
+function fr(t, r) {
+  t(
+    "playwright-browser-list",
+    {
+      title: "List Browsers",
+      description: "List active browser instances",
+      inputSchema: je.shape
+    },
+    async (s, o) => {
+      const e = await dr(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-browser-list(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      const n = e.browserInfos.map(
+        (i) => `${i.name} (${i.browserType})`
+      );
+      return `Method: playwright-browser-list(${JSON.stringify(s)})
+${n.length === 0 ? "No browsers found" : `Browsers: ${n.join(", ")}`}`;
+    }
+  );
+}
+const Je = p.object({
+  names: p.array(p.string()).optional().describe(
+    "Names of browsers to close. If not specified, closes all browsers"
+  )
+});
+async function mr(t, r, s) {
+  let o;
+  try {
+    o = Je.parse(t);
+  } catch (l) {
+    return {
+      error: `Invalid arguments: ${l instanceof Error ? l.message : "Unknown error"}`
+    };
+  }
+  const { names: e } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const n = N(s.sessionId), i = [], a = [];
+  let u = [];
+  return e ? e.forEach((l) => {
+    const c = n.browsers.get(l);
+    c ? u.push(c) : a.push(`Browser "${l}" not found`);
+  }) : u = Array.from(n.browsers.values()), await Promise.all(
+    u.map(async (l) => {
+      try {
+        await l.browser.close(), n.browsers.delete(l.name), i.push(l);
+      } catch (c) {
+        a.push(
+          `Failed to close browser "${l.name}" (${l.browserType}): ${c instanceof Error ? c.message : "Unknown error"}`
+        );
+      }
+    })
+  ), {
+    closedBrowserInfos: i,
+    ...a.length > 0 && { errors: a }
+  };
+}
+function hr(t, r) {
+  t(
+    "playwright-browser-close",
+    {
+      title: "Close Browsers",
+      description: "Close browsers. Automatically closes all contexts and pages within the browsers",
+      inputSchema: Je.shape
+    },
+    async (s, o) => {
+      const e = await mr(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-browser-close(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      const n = [];
+      if (e.closedBrowserInfos.length > 0) {
+        const i = e.closedBrowserInfos.map(
+          (a) => `${a.name} (${a.browserType})`
+        );
+        n.push(`✅ Closed browsers: ${i.join(", ")}`);
+      }
+      return e.errors && e.errors.length > 0 && (n.length > 0 && n.push(""), n.push("❌ Errors:"), e.errors.forEach((i) => n.push(i))), n.length === 0 && n.push("No browsers to close"), `Method: playwright-browser-close(${JSON.stringify(s)})
+${n.join(`
+`)}`;
+    }
+  );
+}
+const ee = p.object({
+  browserName: p.string().optional().describe("Name of previously created browser, to use"),
+  browser: X.optional().describe(
+    "Browser creation options to automatically create browser"
+  ),
+  name: p.string().describe(
+    "Unique name for the context. Recommended format: kebab-case-1, kebab-case-2, ..."
+  ),
+  isMobile: p.boolean().optional().describe("Configure for mobile device simulation"),
+  hasTouch: p.boolean().optional().describe("Enable touch events"),
+  viewport: p.object({
+    width: p.number(),
+    height: p.number()
+  }).optional().describe("Viewport size configuration")
+});
+async function Ke(t, r, s) {
+  let o;
+  try {
+    o = ee.parse(t);
+  } catch (m) {
+    return {
+      error: `Invalid arguments: ${m instanceof Error ? m.message : "Unknown error"}`
+    };
+  }
+  const { name: e, browserName: n, browser: i, isMobile: a, hasTouch: u, viewport: l } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const c = N(s.sessionId);
+  if (n && i)
+    return {
+      error: "Either browserName or browser must be provided, not both"
+    };
+  let f = !1, d;
+  if (n) {
+    if (d = c.browsers.get(n), !d)
+      return {
+        error: `Browser "${n}" not found`
+      };
+  } else if (i) {
+    const m = await _e(i, r, s);
+    if (m.error != null)
+      return {
+        error: m.error
+      };
+    d = m.browserInfo, f = !0;
+  } else
+    return {
+      error: "Either browserName or browser must be provided"
+    };
+  if (d.contexts.has(e))
+    return {
+      error: `Context "${e}" already exists in browser "${d.name}" (${d.browserType})`
+    };
+  try {
+    const m = await d.browser.newContext({
+      isMobile: a,
+      hasTouch: u,
+      viewport: l
+    }), h = {
+      browserInfo: d,
+      name: e,
+      context: m,
+      pages: /* @__PURE__ */ new Map()
+    };
+    return d.contexts.set(e, h), {
+      browserInfoCreated: f,
+      browserInfo: d,
+      contextInfo: h
+    };
+  } catch (m) {
+    return {
+      error: `Failed to create context: ${m instanceof Error ? m.message : "Unknown error"} in browser "${d.name}" (${d.browserType})`
+    };
+  }
+}
+function pr(t, r) {
+  t(
+    "playwright-context-create",
+    {
+      title: "Create Browser Context",
+      description: "Create a new browser context. Prefer page-goto if you need to immediately create a context, page and navigate",
+      inputSchema: ee.shape
+    },
+    async (s, o) => {
+      const e = await Ke(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-context-create(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-context-create(${JSON.stringify(s)})
+`;
+      return e.browserInfoCreated && (n += `✅ Browser "${e.browserInfo.name}" (${e.browserInfo.browserType}) created successfully
+`), n += `✅ Context "${e.contextInfo.name}" created successfully in browser "${e.contextInfo.browserInfo.name}" (${e.contextInfo.browserInfo.browserType})`, n;
+    }
+  );
+}
+const We = p.object({
+  browserName: p.string().optional().describe(
+    "Name of browser to list contexts from. If not specified, lists contexts from all browsers"
+  )
+});
+async function gr(t, r, s) {
+  let o;
+  try {
+    o = We.parse(t);
+  } catch (a) {
+    return {
+      error: `Invalid arguments: ${a instanceof Error ? a.message : "Unknown error"}`
+    };
+  }
+  const { browserName: e } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const n = N(s.sessionId), i = [];
+  if (e) {
+    const a = n.browsers.get(e);
+    if (!a)
+      return {
+        error: `Browser "${e}" not found`
+      };
+    Array.from(a.contexts.values()).length > 0 && i.push({
+      browserInfo: a,
+      contexts: Array.from(a.contexts.values())
+    });
+  } else
+    for (const a of n.browsers.values()) {
+      const u = Array.from(a.contexts.values());
+      u.length > 0 && i.push({
+        browserInfo: a,
+        contexts: u
+      });
+    }
+  return {
+    contextsByBrowser: i
+  };
+}
+function wr(t, r) {
+  t(
+    "playwright-context-list",
+    {
+      title: "List Browser Contexts",
+      description: "List active browser contexts",
+      inputSchema: We.shape
+    },
+    async (s, o) => {
+      const e = await gr(s, r, o);
+      if ("error" in e)
+        return `Method: playwright-context-list(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-context-list(${JSON.stringify(s)})
+`;
+      return e.contextsByBrowser.length === 0 ? n += "No contexts found" : n += e.contextsByBrowser.map(
+        ({ browserInfo: i, contexts: a }) => `${i.name} (${i.browserType}): ${a.map((u) => u.name).join(", ")}`
+      ).join(`
+`), n;
+    }
+  );
+}
+const Qe = p.object({
+  names: p.array(p.string()).optional().describe(
+    "Names of contexts to close. If not specified, closes all contexts"
+  ),
+  browserName: p.string().optional().describe(
+    "Name of browser to close contexts from. If not specified, searches all browsers"
+  )
+});
+async function yr(t, r, s) {
+  let o;
+  try {
+    o = Qe.parse(t);
+  } catch (c) {
+    return {
+      error: `Invalid arguments: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+  const { names: e, browserName: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = N(s.sessionId), a = [], u = [];
+  let l = [];
+  if (n) {
+    const c = i.browsers.get(n);
+    if (!c)
+      return {
+        error: `Browser "${n}" not found`
+      };
+    e ? e.forEach((f) => {
+      const d = c.contexts.get(f);
+      d ? l.push(d) : u.push(
+        `Context "${f}" not found in browser "${c.name}" (${c.browserType})`
+      );
+    }) : l = Array.from(c.contexts.values());
+  } else if (e)
+    for (const c of i.browsers.values())
+      e.forEach((f) => {
+        const d = c.contexts.get(f);
+        d ? l.push(d) : u.push(
+          `Context "${f}" not found in browser "${c.name}" (${c.browserType})`
+        );
+      });
+  else
+    for (const c of i.browsers.values())
+      l.push(...Array.from(c.contexts.values()));
+  return await Promise.all(
+    l.map(async (c) => {
+      try {
+        await c.context.close(), c.browserInfo.contexts.delete(c.name), a.push(c);
+      } catch (f) {
+        u.push(
+          `Failed to close context "${c.name}" (${c.browserInfo.name}) (${c.browserInfo.browserType}): ${f instanceof Error ? f.message : "Unknown error"}`
+        );
+      }
+    })
+  ), {
+    closedContextInfos: a,
+    ...u.length > 0 && { errors: u }
+  };
+}
+function br(t, r) {
+  t(
+    "playwright-context-close",
+    {
+      title: "Close Browser Contexts",
+      description: "Close browser contexts. Automatically closes all pages within the contexts",
+      inputSchema: Qe.shape
+    },
+    async (s, o) => {
+      const e = await yr(s, r, o);
+      if ("error" in e)
+        return `Method: playwright-context-close(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      const n = [];
+      if (e.closedContextInfos.length > 0) {
+        const i = e.closedContextInfos.map(
+          (a) => `${a.name} (${a.browserInfo.name}) (${a.browserInfo.browserType})`
+        );
+        n.push(`✅ Closed contexts: ${i.join(", ")}`);
+      }
+      return e.errors && e.errors.length > 0 && (n.length > 0 && n.push(""), n.push("❌ Errors:"), e.errors.forEach((i) => n.push(i))), n.length === 0 && n.push("No contexts to close"), `Method: playwright-context-close(${JSON.stringify(s)})
+${n.join(`
+`)}`;
+    }
+  );
+}
+function $r() {
+  class t {
+    prevId = 0;
+    objectToId = /* @__PURE__ */ new WeakMap();
+    idToObject = /* @__PURE__ */ new Map();
+    cleanupRegistry;
+    constructor() {
+      this.cleanupRegistry = new FinalizationRegistry((u) => {
+        this.idToObject.delete(u);
+      });
+    }
+    getOrCreateId(u) {
+      let l = this.objectToId.get(u);
+      return l == null && (l = ++this.prevId, this.objectToId.set(u, l), this.idToObject.set(l, new WeakRef(u)), this.cleanupRegistry.register(u, l)), l;
+    }
+    getObject(u) {
+      const l = this.idToObject.get(u);
+      if (!l)
+        return null;
+      const c = l.deref();
+      return c ?? (this.idToObject.delete(u), null);
+    }
+  }
+  function r(a, u, l) {
+    let c = null;
+    for (let f = 0, d = u.length; f < d; f++) {
+      const m = u[f], h = a(m), g = h == null ? null : r(a, h, l), b = l(m, g);
+      b != null && (c == null && (c = []), c.push(b));
+    }
+    return c;
+  }
+  function s(a) {
+    const { getId: u, getChilds: l, rootNodes: c, createSnapshotNode: f } = a, d = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), g = r(
+      l,
+      c,
+      (y, $) => {
+        const I = f(y, $);
+        if (y != null && I != null) {
+          const x = u(y);
+          d.set(x, I), m.set(I, x);
+        }
+        return I != null && $ != null && h.set(
+          m.get(I),
+          $.map((x) => m.get(x))
+        ), I;
+      }
+    ), b = f(null, g);
+    if (b == null)
+      throw new Error("Impossible behavior: rootNode == null");
+    return d.set(null, b), g != null && h.set(
+      null,
+      g.map((y) => m.get(y))
+    ), {
+      idToNode: d,
+      idToChildIds: h
+    };
+  }
+  const o = (a) => a instanceof HTMLElement ? a.childNodes : null;
+  function e(a) {
+    return function(l, c) {
+      const f = c != null && c.length > 0;
+      let d = !1, m = null, h = null;
+      if (l instanceof HTMLElement) {
+        if (m = n.getOrCreateId(l), h = l.tagName.toLowerCase(), d = l.matches(a.cssSelector), !d && !f)
+          return null;
+      } else if (l == null)
+        m = null, h = null, d = !1;
+      else
+        return null;
+      return {
+        uid: m,
+        tagName: h,
+        isMatched: d
+      };
+    };
+  }
+  const n = new t();
+  function i(a) {
+    const u = e(a);
+    return s({
+      getId: (l) => n.getOrCreateId(l),
+      getChilds: o,
+      createSnapshotNode: u,
+      rootNodes: [window.document.documentElement]
+    });
+  }
+  window.__mcp_playwright_tool_tx4byhar35_createDomSnapshotTreeRawDom = i;
+}
+const xr = `(function (){function __name(fn){return fn};${$r.toString()}; setupPageGlobals();})()`, te = p.object({
+  contextName: p.string().optional().describe("Name of previously created context, to use"),
+  context: ee.optional().describe(
+    "Context creation options to automatically create context"
+  ),
+  name: p.string().describe(
+    "Unique name for the page. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function He(t, r, s) {
+  let o;
+  try {
+    o = te.parse(t);
+  } catch (f) {
+    return {
+      error: `Invalid arguments: ${f instanceof Error ? f.message : "Unknown error"}`
+    };
+  }
+  const { name: e, contextName: n, context: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = N(s.sessionId);
+  if (n && i)
+    return {
+      error: "Either contextName or context must be provided, not both"
+    };
+  let u = !1, l = !1, c;
+  if (n) {
+    for (const f of a.browsers.values())
+      if (f.contexts.has(n)) {
+        c = f.contexts.get(n);
+        break;
+      }
+    if (!c)
+      return {
+        error: `Context "${n}" not found`
+      };
+  } else if (i) {
+    const f = await Ke(i, r, s);
+    if (f.error != null)
+      return {
+        error: f.error
+      };
+    c = f.contextInfo, u = f.browserInfoCreated, l = !0;
+  } else
+    return {
+      error: "Either contextName or context must be provided"
+    };
+  if (c.pages.has(e))
+    return {
+      error: `Page "${e}" already exists in context "${c.name}" in browser "${c.browserInfo.name}" (${c.browserInfo.browserType})`
+    };
+  try {
+    const f = await c.context.newPage();
+    await f.addInitScript(xr), await f.goto("about:blank");
+    const d = {
+      contextInfo: c,
+      name: e,
+      page: f,
+      domSnapshots: /* @__PURE__ */ new Map()
+    };
+    return c.pages.set(e, d), {
+      browserInfoCreated: u,
+      contextInfoCreated: l,
+      pageInfo: d
+    };
+  } catch (f) {
+    return {
+      error: `Failed to create page: ${f instanceof Error ? f.message : "Unknown error"} in context "${c.name}" in browser "${c.browserInfo.name}" (${c.browserInfo.browserType})`
+    };
+  }
+}
+function Sr(t, r) {
+  t(
+    "playwright-page-create",
+    {
+      title: "Create Page",
+      description: "Create a new page. Prefer page-goto if you need to immediately create a page and navigate",
+      inputSchema: te.shape
+    },
+    async (s, o) => {
+      const e = await He(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-page-create(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-page-create(${JSON.stringify(s)})
+`;
+      return e.browserInfoCreated && (n += `✅ Browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType}) created successfully
+`), e.contextInfoCreated && (n += `✅ Context "${e.pageInfo.contextInfo.name}" created successfully in browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType})
+`), n += `✅ Page "${e.pageInfo.name}" created successfully in context "${e.pageInfo.contextInfo.name}" in browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType})`, n;
+    }
+  );
+}
+const Ye = p.object({
+  contextName: p.string().optional().describe(
+    "Name of context to list pages from. If not specified, lists pages from all contexts"
+  ),
+  browserName: p.string().optional().describe(
+    "Name of browser to search in. If not specified, searches all browsers"
+  )
+});
+async function Ir(t, r, s) {
+  let o;
+  try {
+    o = Ye.parse(t);
+  } catch (u) {
+    return {
+      error: `Invalid arguments: ${u instanceof Error ? u.message : "Unknown error"}`
+    };
+  }
+  const { contextName: e, browserName: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = N(s.sessionId), a = [];
+  if (n) {
+    const u = i.browsers.get(n);
+    if (!u)
+      return {
+        error: `Browser "${n}" not found`
+      };
+    if (e) {
+      const l = u.contexts.get(e);
+      if (!l)
+        return {
+          error: `Context "${e}" not found in browser "${u.name}" (${u.browserType})`
+        };
+      const c = Array.from(l.pages.values());
+      c.length > 0 && a.push({
+        contextInfo: l,
+        pages: c
+      });
+    } else
+      for (const l of u.contexts.values()) {
+        const c = Array.from(l.pages.values());
+        c.length > 0 && a.push({
+          contextInfo: l,
+          pages: c
+        });
+      }
+  } else if (e)
+    for (const u of i.browsers.values()) {
+      const l = u.contexts.get(e);
+      if (l) {
+        const c = Array.from(l.pages.values());
+        c.length > 0 && a.push({
+          contextInfo: l,
+          pages: c
+        });
+      }
+    }
+  else
+    for (const u of i.browsers.values())
+      for (const l of u.contexts.values()) {
+        const c = Array.from(l.pages.values());
+        c.length > 0 && a.push({
+          contextInfo: l,
+          pages: c
+        });
+      }
+  return {
+    pagesByContext: a
+  };
+}
+function Mr(t, r) {
+  t(
+    "playwright-page-list",
+    {
+      title: "List Pages",
+      description: "List active pages",
+      inputSchema: Ye.shape
+    },
+    async (s, o) => {
+      const e = await Ir(s, r, o);
+      if ("error" in e)
+        return `Method: playwright-page-list(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-page-list(${JSON.stringify(s)})
+`;
+      return e.pagesByContext.length === 0 ? n += "No pages found" : n += e.pagesByContext.map(
+        ({ contextInfo: i, pages: a }) => `${i.name} (${i.browserInfo.name}) (${i.browserInfo.browserType}): ${a.map((u) => u.name).join(", ")}`
+      ).join(`
+`), n;
+    }
+  );
+}
+const Ve = p.object({
+  names: p.array(p.string()).optional().describe("Names of pages to close. If not specified, closes all pages"),
+  contextName: p.string().optional().describe(
+    "Name of context to close pages from. If not specified, searches all contexts"
+  ),
+  browserName: p.string().optional().describe(
+    "Name of browser to search in. If not specified, searches all browsers"
+  )
+});
+async function Tr(t, r, s) {
+  let o;
+  try {
+    o = Ve.parse(t);
+  } catch (f) {
+    return {
+      error: `Invalid arguments: ${f instanceof Error ? f.message : "Unknown error"}`
+    };
+  }
+  const { names: e, contextName: n, browserName: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = N(s.sessionId), u = [], l = [];
+  let c = [];
+  if (i) {
+    const f = a.browsers.get(i);
+    if (!f)
+      return {
+        error: `Browser "${i}" not found`
+      };
+    if (n) {
+      const d = f.contexts.get(n);
+      if (!d)
+        return {
+          error: `Context "${n}" not found in browser "${f.name}" (${f.browserType})`
+        };
+      e ? e.forEach((m) => {
+        const h = d.pages.get(m);
+        h ? c.push(h) : l.push(
+          `Page "${m}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+        );
+      }) : c = Array.from(d.pages.values());
+    } else
+      for (const d of f.contexts.values())
+        e ? e.forEach((m) => {
+          const h = d.pages.get(m);
+          h ? c.push(h) : l.push(
+            `Page "${m}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+          );
+        }) : c.push(...Array.from(d.pages.values()));
+  } else if (n)
+    for (const f of a.browsers.values()) {
+      const d = f.contexts.get(n);
+      d && (e ? e.forEach((m) => {
+        const h = d.pages.get(m);
+        h ? c.push(h) : l.push(
+          `Page "${m}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+        );
+      }) : c.push(...Array.from(d.pages.values())));
+    }
+  else
+    for (const f of a.browsers.values())
+      for (const d of f.contexts.values())
+        e ? e.forEach((m) => {
+          const h = d.pages.get(m);
+          h ? c.push(h) : l.push(
+            `Page "${m}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+          );
+        }) : c.push(...Array.from(d.pages.values()));
+  return await Promise.all(
+    c.map(async (f) => {
+      try {
+        await f.page.close(), f.contextInfo.pages.delete(f.name), u.push(
+          `${f.name} (${f.contextInfo.name}) (${f.contextInfo.browserInfo.name}) (${f.contextInfo.browserInfo.browserType})`
+        );
+      } catch (d) {
+        l.push(
+          `Failed to close page "${f.name}" (${f.contextInfo.name}) (${f.contextInfo.browserInfo.name}) (${f.contextInfo.browserInfo.browserType}): ${d instanceof Error ? d.message : "Unknown error"}`
+        );
+      }
+    })
+  ), {
+    closedPages: u,
+    ...l.length > 0 && { errors: l }
+  };
+}
+function vr(t, r) {
+  t(
+    "playwright-page-close",
+    {
+      title: "Close Pages",
+      description: "Close pages",
+      inputSchema: Ve.shape
+    },
+    async (s, o) => {
+      const e = await Tr(s, r, o);
+      if ("error" in e)
+        return `Method: playwright-page-close(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      const n = [];
+      return e.closedPages.length > 0 && n.push(`✅ Closed pages: ${e.closedPages.join(", ")}`), e.errors && e.errors.length > 0 && (n.length > 0 && n.push(""), n.push("❌ Errors:"), e.errors.forEach((i) => n.push(i))), n.length === 0 && n.push("No pages to close"), `Method: playwright-page-close(${JSON.stringify(s)})
+${n.join(`
+`)}`;
+    }
+  );
+}
+const Ze = p.object({
+  pageName: p.string().optional().describe("Name of previously created page to navigate"),
+  page: te.optional().describe(
+    "Page creation options to automatically create page"
+  ),
+  url: p.string().describe("URL to navigate to"),
+  timeout: p.number().describe("Timeout in seconds"),
+  waitUntil: p.enum(["load", "domcontentloaded", "networkidle", "commit"]).describe(
+    `Wait until event:
+- 'domcontentloaded': DOMContentLoaded event is fired
+- 'load': load event is fired  
+- 'networkidle': DISCOURAGED - no network activity for 500ms
+- 'commit': network response received and document started loading`
+  )
+});
+async function kr(t, r, s) {
+  let o;
+  try {
+    o = Ze.parse(t);
+  } catch (h) {
+    return {
+      error: `Invalid arguments: ${h instanceof Error ? h.message : "Unknown error"}`
+    };
+  }
+  const { pageName: e, page: n, url: i, timeout: a, waitUntil: u } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const l = N(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either pageName or page must be provided, not both"
+    };
+  let c = !1, f = !1, d = !1, m;
+  if (e) {
+    for (const h of l.browsers.values()) {
+      for (const g of h.contexts.values())
+        if (g.pages.has(e)) {
+          m = g.pages.get(e);
+          break;
+        }
+      if (m) break;
+    }
+    if (!m)
+      return {
+        error: `Page "${e}" not found`
+      };
+  } else if (n) {
+    const h = await He(n, r, s);
+    if (h.error != null)
+      return {
+        error: h.error
+      };
+    m = h.pageInfo, c = h.browserInfoCreated, f = h.contextInfoCreated, d = !0;
+  } else
+    return {
+      error: "Either pageName or page must be provided"
+    };
+  try {
+    const h = await m.page.goto(i, {
+      timeout: a * 1e3,
+      waitUntil: u
+    });
+    return h ? {
+      browserInfoCreated: c,
+      contextInfoCreated: f,
+      pageInfoCreated: d,
+      pageInfo: m,
+      status: h.status()
+    } : {
+      browserInfoCreated: c,
+      contextInfoCreated: f,
+      pageInfoCreated: d,
+      pageInfo: m,
+      status: 200
+    };
+  } catch (h) {
+    return {
+      error: `Failed to navigate to "${i}": ${h instanceof Error ? h.message : "Unknown error"}`
+    };
+  }
+}
+function Cr(t, r) {
+  t(
+    "playwright-page-goto",
+    {
+      title: "Navigate Page",
+      description: "Navigate page to URL. Use for manual browser interaction",
+      inputSchema: Ze.shape
+    },
+    async (s, o) => {
+      const e = await kr(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-page-goto(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-page-goto(${JSON.stringify(s)})
+`;
+      return e.browserInfoCreated && (n += `✅ Browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType}) created successfully
+`), e.contextInfoCreated && (n += `✅ Context "${e.pageInfo.contextInfo.name}" created successfully in browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType})
+`), e.pageInfoCreated && (n += `✅ Page "${e.pageInfo.name}" created successfully in context "${e.pageInfo.contextInfo.name}" in browser "${e.pageInfo.contextInfo.browserInfo.name}" (${e.pageInfo.contextInfo.browserInfo.browserType})
+`), n += `✅ Navigation completed with HTTP status: ${e.status}`, n;
+    }
+  );
+}
+const re = p.object({
+  name: p.string().describe(
+    "Unique name for the DOM snapshot query. Recommended format: kebab-case-1, kebab-case-2, ..."
+  ),
+  cssSelector: p.string().describe("CSS selector to capture page content")
+});
+async function Xe(t, r, s) {
+  let o;
+  try {
+    o = re.parse(t);
+  } catch (u) {
+    return {
+      error: `Invalid arguments: ${u instanceof Error ? u.message : "Unknown error"}`
+    };
+  }
+  const { name: e, cssSelector: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = N(s.sessionId);
+  if (i.domSnapshotQueries.has(e))
+    return {
+      error: `DOM snapshot query "${e}" already exists`
+    };
+  const a = {
+    name: e,
+    cssSelector: n
+  };
+  return i.domSnapshotQueries.set(e, a), {
+    snapshotQuery: a
+  };
+}
+function Er(t, r) {
+  t(
+    "playwright-dom-snapshot-query-create",
+    {
+      title: "Create DOM Snapshot Query",
+      description: "Create a DOM snapshot query. Prefer dom-snapshot-browse if you need to immediately create a query and snapshot and browse it",
+      inputSchema: re.shape
+    },
+    async (s, o) => {
+      const e = await Xe(s, r, o);
+      return e.error != null ? `Method: playwright-dom-snapshot-query-create(${JSON.stringify(s)})
+❌ Error: ${e.error}` : `Method: playwright-dom-snapshot-query-create(${JSON.stringify(s)})
+✅ DOM snapshot query "${e.snapshotQuery.name}" created successfully`;
+    }
+  );
+}
+function Nr(t) {
+  return function(s, o) {
+    let e, n = 0;
+    const i = o ? o.length : 0;
+    let a = 1, u = 0, l = 0, c, f;
+    if (o)
+      for (let h = 0; h < o.length; h++) {
+        const g = o[h];
+        n += g.countMatched, a += g.countTotal, u += g.tokens, l += g.tokensTotal;
+      }
+    s ? (c = s.uid, f = s.tagName, e = s.isMatched, e && (n += 1)) : (c = null, f = null, e = !1);
+    let d;
+    f ? d = {
+      indent: !0,
+      textOpen: `<${f} uid:${c}>`,
+      textClose: `</${f}>`
+    } : d = {
+      indent: !0,
+      textOpen: `<root uid:${c}>`,
+      textClose: "</root>"
+    };
+    const m = Pe(d);
+    return l += m, {
+      uid: c,
+      tagName: f,
+      isMatched: e,
+      countMatched: n,
+      countChilds: i,
+      countTotal: a,
+      tokens: m,
+      tokensChilds: u,
+      tokensTotal: l,
+      text: d
+    };
+  };
+}
+function Dr(t, r) {
+  const s = q(r), o = s.getChilds(s.root), e = Ue({
+    getId: (n) => {
+      const i = s.getId(n);
+      if (i == null)
+        throw new Error(
+          `Invalid tree structure: node ID is null for node ${JSON.stringify(n)}`
+        );
+      return i;
+    },
+    getChilds: (n) => s.getChilds(n),
+    createSnapshotNode: Nr(),
+    rootNodes: o ?? []
+  });
+  return q(e);
+}
+const se = p.object({
+  pageName: p.string().describe("Name of previously created page, to create snapshot from"),
+  queryName: p.string().optional().describe("Name of previously created DOM snapshot query, to use"),
+  query: re.optional().describe(
+    "DOM snapshot query creation options to automatically create query"
+  ),
+  name: p.string().describe(
+    "Unique name for the DOM snapshot. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function et(t, r, s) {
+  let o;
+  try {
+    o = se.parse(t);
+  } catch (d) {
+    return {
+      error: `Invalid arguments: ${d instanceof Error ? d.message : "Unknown error"}`
+    };
+  }
+  const { pageName: e, queryName: n, query: i, name: a } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const u = N(s.sessionId);
+  let l;
+  for (const d of u.browsers.values()) {
+    for (const m of d.contexts.values())
+      if (m.pages.has(e)) {
+        l = m.pages.get(e);
+        break;
+      }
+    if (l) break;
+  }
+  if (!l)
+    return {
+      error: `Page "${e}" not found`
+    };
+  if (l.domSnapshots.has(a))
+    return {
+      error: `DOM snapshot "${a}" already exists in page "${e}"`
+    };
+  if (n && i)
+    return {
+      error: "Either queryName or query must be provided, not both"
+    };
+  let c, f = !1;
+  if (n) {
+    const d = u.domSnapshotQueries.get(n);
+    if (!d)
+      return {
+        error: `DOM snapshot query "${n}" not found`
+      };
+    c = d;
+  } else if (i) {
+    const d = await Xe(
+      i,
+      r,
+      s
+    );
+    if (d.error != null)
+      return {
+        error: d.error
+      };
+    c = d.snapshotQuery, f = !0;
+  } else
+    return {
+      error: "Either queryName or query must be provided"
+    };
+  try {
+    const d = await l.page.evaluate(
+      (b) => {
+        const y = window.__mcp_playwright_tool_tx4byhar35_createDomSnapshotTreeRawDom;
+        if (!y)
+          throw new Error("DOM snapshot global function not initialized");
+        const $ = y(b);
+        return {
+          idToNode: Array.from($.idToNode.entries()),
+          idToChildIds: Array.from($.idToChildIds.entries())
+        };
+      },
+      c
+    ), m = {
+      idToNode: new Map(d.idToNode),
+      idToChildIds: new Map(d.idToChildIds)
+    }, h = Dr(c, m), g = {
+      name: a,
+      query: c,
+      tree: h
+    };
+    return l.domSnapshots.set(a, g), {
+      domSnapshot: g,
+      queryCreated: f
+    };
+  } catch (d) {
+    return {
+      error: `Failed to create DOM snapshot: ${d instanceof Error ? d.message : "Unknown error"}`
+    };
+  }
+}
+function Br(t, r) {
+  t(
+    "playwright-dom-snapshot-create",
+    {
+      title: "Create DOM Snapshot",
+      description: "Create a DOM snapshot of page. Use this to capture webpage state for later browsing. Prefer dom-snapshot-browse if you need to immediately create and browse a snapshot",
+      inputSchema: se.shape
+    },
+    async (s, o) => {
+      const e = await et(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-dom-snapshot-create(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-dom-snapshot-create(${JSON.stringify(s)})
+`;
+      return e.queryCreated && (n += `✅ DOM snapshot query "${e.domSnapshot.query.name}" created successfully
+`), n += `✅ DOM snapshot "${e.domSnapshot.name}" created successfully`, n;
+    }
+  );
+}
+class Fr {
+  tokens = 16;
+  getReportText = (r) => ({
+    indent: !0,
+    textOpen: `[${r.indexRange[0]}-${r.indexRange[1]}] ${r.countMatched} matched ${r.tokensGrouped} tokens`,
+    textClose: null
+  });
+  add = (r, s, o) => r == null ? {
+    indexRange: [o, o],
+    countGrouped: 1,
+    countMatched: s.countMatched,
+    tokensGrouped: s.tokens
+  } : (r.indexRange[1] = o, r.countGrouped += 1, r.countMatched += s.countMatched, r.tokensGrouped += s.tokens, r);
+}
+const tt = p.object({
+  snapshotName: p.string().optional().describe("Name of previously created DOM snapshot, to use"),
+  snapshot: se.optional().describe(
+    "DOM snapshot creation options to automatically create snapshot"
+  ),
+  parentUid: p.number().optional().describe("UID of parent node to browse. Omit to browse the root node"),
+  childsIndexRange: p.tuple([p.number(), p.number()]).optional().describe(
+    "Child index range to show [start, end]. Only use the exact ranges that appeared in previous snapshot results - do not modify, combine, or split them"
+  )
+  // maxCountTotal: z
+  //   .number()
+  //   .default(100)
+  //   .describe('Maximum total number of items to show'),
+  // maxTokensTotal: z
+  //   .number()
+  //   .default(10000)
+  //   .describe('Maximum total tokens to show'),
+  // maxCountGroup: z.number().default(10).describe('Maximum items per group'),
+  // maxTokensGroup: z.number().default(1000).describe('Maximum tokens per group'),
+});
+async function Or(t, r, s) {
+  let o;
+  try {
+    o = tt.parse(t);
+  } catch (g) {
+    return {
+      error: `Invalid arguments: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+  const {
+    snapshotName: e,
+    snapshot: n,
+    childsIndexRange: i
+    // maxCountTotal,
+    // maxTokensTotal,
+    // maxCountGroup,
+    // maxTokensGroup,
+  } = o, a = 60, u = 1e3, l = 25, c = 900;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const f = N(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either snapshotName or snapshot must be provided, not both"
+    };
+  let d, m = !1, h = !1;
+  if (e) {
+    for (const g of f.browsers.values()) {
+      for (const b of g.contexts.values()) {
+        for (const y of b.pages.values())
+          if (y.domSnapshots.has(e)) {
+            d = y.domSnapshots.get(e);
+            break;
+          }
+        if (d != null) break;
+      }
+      if (d != null) break;
+    }
+    if (d == null)
+      return {
+        error: `DOM snapshot "${e}" not found`
+      };
+  } else if (n) {
+    const g = await et(
+      n,
+      r,
+      s
+    );
+    if (g.error != null)
+      return {
+        error: g.error
+      };
+    d = g.domSnapshot, m = g.queryCreated, h = !0;
+  } else
+    return {
+      error: "Either snapshotName or snapshot must be provided"
+    };
+  try {
+    const g = o.parentUid, b = Ae({
+      tree: d.tree,
+      request: {
+        parentNodeId: g,
+        childsIndexRange: i,
+        limits: {
+          maxCountTotal: a,
+          maxTokensTotal: u,
+          maxCountGroup: l,
+          maxTokensGroup: c
+        }
+      },
+      indexRangeGroupStrategy: new Fr()
+    }), y = Ge(b);
+    return {
+      domSnapshot: d,
+      queryCreated: m,
+      snapshotCreated: h,
+      parentUid: g,
+      childsIndexRange: i,
+      report: y
+    };
+  } catch (g) {
+    return {
+      error: `Failed to browse DOM snapshot: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+}
+function Rr(t, r) {
+  t(
+    "playwright-dom-snapshot-browse",
+    {
+      title: "Browse DOM Snapshot",
+      description: "Browse and explore DOM. Use this to browse, analyze, explore, inspect, etc webpage structure and styles, find elements, or inspect page content",
+      inputSchema: tt.shape
+    },
+    async (s, o) => {
+      const e = await Or(s, r, o);
+      if (e.error != null)
+        return `Method: playwright-dom-snapshot-browse(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: playwright-dom-snapshot-browse(${JSON.stringify(s)})
+`;
+      if (e.queryCreated && (n += `✅ DOM snapshot query "${e.domSnapshot.query.name}" created successfully
+`), e.snapshotCreated && (n += `✅ DOM snapshot "${e.domSnapshot.name}" created successfully
+`), n += `✅ Browsing DOM snapshot "${e.domSnapshot.name}":
+`, n += `CSS Selector: ${e.domSnapshot.query.cssSelector}
+`, n += `Parent UID: ${e.parentUid ?? "null (root node)"}
+`, e.childsIndexRange) {
+        const [i, a] = e.childsIndexRange, l = (e.parentUid ? e.domSnapshot.tree.getNode(e.parentUid) : e.domSnapshot.tree.root).countChilds;
+        n += `   Showing indexes: ${i}-${a} of ${l}
+`;
+      }
+      return n += `
+${e.report}`, n;
+    }
+  );
+}
+function zr(t, r) {
+  r.browserCreate && ur(t, r), r.browserList && fr(t, r), r.browserClose && hr(t, r), r.contextCreate && pr(t, r), r.contextList && wr(t, r), r.contextClose && br(t, r), r.pageCreate && Sr(t, r), r.pageList && Mr(t, r), r.pageClose && vr(t, r), r.pageGoto && Cr(t, r), r.domSnapshotQueryCreate && Er(t, r), r.domSnapshotCreate && Br(t, r), r.domSnapshotBrowse && Rr(t, r), console.log("Playwright manager");
+}
+function Ur(t) {
+  const { logFilePath: r } = t;
+  return async function(o, e, n, i) {
+    await G({
+      logFilePath: r,
+      message: "ERROR",
+      data: {
+        request: {
+          url: e.url,
+          method: e.method,
+          headers: e.headers,
+          body: e.body
+        },
+        error: o.message,
+        stack: o.stack
+      }
+    }), n.status(500).send({
+      error: "Internal Server Error",
+      message: o.stack || o.message || o.toString()
+    });
+  };
+}
+function Pr() {
+  return `mcp_${(/* @__PURE__ */ new Date()).toISOString().substring(0, 19).replace(/T/, "_").replace(/:/g, "-")}.log`;
+}
+function Lr(t) {
+  const r = A(), s = Gr();
+  return r.use(s), r;
+}
+function Ar(t) {
+  const r = new st({
+    name: t.name,
+    version: t.version,
+    title: "Project Tools"
+  }), s = qr(r, t);
+  return {
+    mcpServer: r,
+    mcpRouter: s
+  };
+}
+function Gr(t) {
+  const r = A.Router();
+  return r.use(
+    rt.default({
+      origin: "*",
+      credentials: !0,
+      allowedHeaders: [
+        "Content-Type",
+        "Authorization",
+        "X-Session-Id",
+        "mcp-session-id"
+      ],
+      exposedHeaders: ["mcp-session-id"]
+    })
+  ), r.use(A.json()), r;
+}
+function qr(t, r) {
+  const s = A.Router();
+  return s.use(gt({ authToken: r.authToken })), s.all("/mcp", wt(t, r)), s;
+}
+function _r(t, r) {
+  return t.use(Ur({ logFilePath: r.logFilePath })), new Promise((s, o) => {
+    let e;
+    const n = () => {
+      s(e);
+    };
+    try {
+      e = r.host ? t.listen(r.port ?? 0, r.host, n) : t.listen(r.port ?? 0, n), e.addListener("error", (i) => {
+        o(i);
+      });
+    } catch (i) {
+      o(i);
+    }
+  });
+}
+function jr(t, r) {
+  const s = t.address().family, o = t.address().port;
+  let e = t.address().address;
+  e === "::" ? e = "localhost" : s === "IPv6" && (e = `[${e}]`);
+  const n = `http://${s === "IPv6" ? `[${e}]` : e}:${o}`;
+  return `Project Tools - MCP Server Started
+
+Server Name: ${r.name}
+Server Version: ${r.version}
+Server URL: ${n}/mcp
+SSE Endpoint: ${n}/sse
+
+Log File: ${T.resolve(r.logFilePath)}`;
+}
+async function ls(t) {
+  const r = T.join(t.logDir, Pr()), s = Lr(), { mcpServer: o, mcpRouter: e } = Ar({
+    ...t,
+    logFilePath: r
+  });
+  s.use(e);
+  const n = Rt(o, {
+    logFilePath: r
+  });
+  t.tools.processManager && Ot(n, t.tools?.processManager), t.tools.fsManager && cr(n, t.tools.fsManager), t.tools.playwrightManager && zr(n, {
+    ...t.tools.playwrightManager
+  });
+  const i = await _r(s, {
+    host: t.host,
+    port: t.port,
+    logFilePath: r
+  });
+  return console.log(
+    jr(i, {
+      name: t.name,
+      version: t.version,
+      authToken: t.authToken,
+      logFilePath: r,
+      enableJsonResponse: t.enableJsonResponse
+    })
+  ), i;
+}
+export {
+  as as A,
+  is as S,
+  ns as a,
+  ls as s
+};