@flemist/mcp-project-tools 3.0.8 → 3.0.10

package/build/startMcpServer-Yp1zN-1S.js

@@ -0,0 +1,4026 @@
+import re from "express";
+import { McpServer as Dt } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { randomUUID as Rt } from "crypto";
+import * as W from "fs";
+import * as R from "path";
+import Ft from "path";
+import { StreamableHTTPServerTransport as Bt } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { spawn as Lt } from "child_process";
+import { z as p } from "zod";
+import fe from "tree-kill";
+import { Pool as Pt, poolRunWait as Y } from "@flemist/time-limits";
+import { priorityCreate as V } from "@flemist/priority-queue";
+import { useAbortController as At, combineAbortSignals as zt, Locker as Ut } from "@flemist/async-utils";
+import _t from "node:os";
+import qt from "picomatch";
+import { webkit as Gt, firefox as jt, chromium as Jt } from "playwright";
+function Kt(r) {
+  const { authToken: t } = r;
+  return function(o, e, n) {
+    if ((o.query.token || o.headers.authorization?.replace("Bearer ", "")) !== t) {
+      e.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    n();
+  };
+}
+async function se(r) {
+  const { logFilePath: t, message: s, data: o } = r;
+  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 W.promises.mkdir(R.dirname(t), { recursive: !0 }), await W.promises.appendFile(t, i);
+  } catch (e) {
+    console.error(`Failed to log "${s}":`, e);
+  }
+}
+const oe = /* @__PURE__ */ new Map();
+function Wt(r) {
+  return r.headers["mcp-session-id"] || r.headers["x-session-id"] || r.query.token;
+}
+async function Ht(r, t) {
+  const s = r.createMcpServer(), o = new Bt({
+    sessionIdGenerator: () => t || Rt(),
+    onsessioninitialized: (n) => {
+      oe.set(n, o);
+    },
+    enableJsonResponse: !0
+  });
+  async function e() {
+    const n = o.sessionId;
+    n && oe.delete(n);
+    try {
+      await s.close();
+    } catch (i) {
+      console.error("Failed to close session", i);
+    }
+  }
+  o.onclose = e;
+  try {
+    return await s.connect(o), o;
+  } catch (n) {
+    throw await e(), n;
+  }
+}
+async function Qt(r, t, s, o) {
+  await se({
+    logFilePath: s.logFilePath,
+    message: "REQUEST",
+    data: r.body
+  });
+  let e = o ? oe.get(o) : null;
+  e || (e = await Ht(s, o)), await e.handleRequest(r, t, r.body);
+}
+async function Yt(r, t, s) {
+  const o = s ? oe.get(s) : null;
+  if (!o) {
+    t.status(400).json({ error: "No valid session found" });
+    return;
+  }
+  await o.handleRequest(r, t);
+}
+function Vt(r) {
+  return async function(s, o) {
+    try {
+      const e = Wt(s);
+      s.method === "POST" ? await Qt(s, o, r, e) : s.method === "GET" ? await Yt(s, o, e) : o.status(405).json({ error: "Method not allowed" });
+    } catch (e) {
+      console.error("Unhandled error in streamableHttpHandler", e), o.status(500).json({
+        error: "Internal server error: " + (e instanceof Error ? e.message : "Unknown error")
+      });
+    }
+  };
+}
+const Q = /* @__PURE__ */ new Map();
+let Zt = 0;
+const Te = 10, Xt = 1800 * 1e3, F = 1e4, er = 500, tr = 5e3;
+function rr(r) {
+  const { commandLine: t, commandLineRules: s } = r;
+  let o = !1;
+  for (const e of s)
+    if (new RegExp(e.regexp).test(t))
+      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 sr() {
+  return ++Zt;
+}
+let Ce = !1;
+function or() {
+  if (Ce)
+    return;
+  Ce = !0;
+  const r = () => {
+    console.log("Auto-killing all child processes...");
+    for (const [t, s] of Array.from(Q.entries()))
+      if (s.isRunning && s.pid)
+        try {
+          fe(s.pid, "SIGKILL");
+        } catch (o) {
+          console.error(`Error killing process ${t}:`, o);
+        }
+    process.exit(0);
+  };
+  process.on("SIGINT", r), process.on("SIGTERM", r);
+}
+function pe() {
+  const r = Date.now(), t = [];
+  for (const [s, o] of Array.from(Q.entries()))
+    !o.isRunning && o.endTime && r - o.endTime.getTime() > Xt && t.push(s);
+  for (const s of t)
+    Q.delete(s);
+}
+function me(r) {
+  const { process: t } = r, s = Date.now();
+  if (s - t.lastOutputTime.getTime() >= er && (t.output += t.localOutput, t.localOutput = "", t.lastOutputTime = new Date(s), t.output.length > F)) {
+    const n = `
+... [${t.output.length - F} characters trimmed] ...
+`, i = F - n.length;
+    if (i > 0) {
+      const a = Math.floor(i / 2);
+      t.output = t.output.substring(0, a) + n + t.output.substring(
+        t.output.length - (i - a)
+      );
+    } else
+      t.output = t.output.substring(0, F);
+  }
+}
+function nr(r, t) {
+  const s = t.limit;
+  if (r.length <= s) return r;
+  const e = `
+... [${r.length - s} characters trimmed] ...
+`, n = s - e.length;
+  if (n <= 0)
+    return r.substring(0, s);
+  const i = Math.floor(n / 2);
+  return r.substring(0, i) + e + r.substring(r.length - (n - i));
+}
+function B(r) {
+  return `Invalid arguments: ${r instanceof Error ? r.message : "Unknown error"}.
+
+Provide valid parameters according to schema.`;
+}
+const Ze = 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(F).default(F).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: ${F} characters. Default: ${F}.`
+  )
+});
+async function ge(r, t) {
+  pe();
+  let s;
+  try {
+    s = Ze.parse(r);
+  } catch (l) {
+    return {
+      error: B(l)
+    };
+  }
+  const { id: o, outputLimit: e } = s, n = Q.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.`
+    };
+  me({ process: n });
+  const i = n.output + n.localOutput, a = nr(i, { limit: e });
+  return n.output = "", n.localOutput = "", {
+    id: n.id,
+    cwd: R.relative(t.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 ir(r, t) {
+  r(
+    "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: Ze.shape
+    },
+    async (s) => {
+      const o = await ge(s, t);
+      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 Xe(r) {
+  fe(r, "SIGTERM", (t) => {
+    t && !t.message.includes("not found") && console.error(`Error sending SIGTERM to process ${r}:`, t);
+  }), setTimeout(() => {
+    fe(r, "SIGKILL", (t) => {
+      t && !t.message.includes("not found") && console.error(`Error sending SIGKILL to process ${r}:`, t);
+    });
+  }, tr);
+}
+const et = 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(F).default(F).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: ${F} characters. Default: ${F}.`
+  )
+});
+async function tt(r, t) {
+  let s;
+  try {
+    s = et.parse(r);
+  } catch (h) {
+    return {
+      error: B(h)
+    };
+  }
+  const { id: o, waitTime: e, autoKill: n, outputLimit: i } = s, a = Q.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 l = Date.now();
+  let c = !1, u = !1;
+  e != null && await new Promise((m) => {
+    const g = setInterval(() => {
+      a.isRunning ? Date.now() - l >= e * 1e3 && (clearInterval(g), c = !0, n && a.pid && (Xe(a.pid), u = !0), m()) : (clearInterval(g), m());
+    }, 100);
+  });
+  const f = (Date.now() - l) / 1e3;
+  return {
+    ...await ge({ id: o, outputLimit: i }, t),
+    waitDuration: f,
+    waitTimeExceeded: c,
+    autoKillExecuted: u
+  };
+}
+function ar(r, t) {
+  r(
+    "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: et.shape
+    },
+    async (s) => {
+      const o = await tt(s, t);
+      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 rt = 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(F).default(F).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: ${F} characters. Default: ${F}.`
+  )
+});
+async function lr(r, t) {
+  pe();
+  let s;
+  try {
+    s = rt.parse(r);
+  } catch (d) {
+    return {
+      error: B(d)
+    };
+  }
+  const { commandLine: o, waitTime: e, autoKill: n, outputLimit: i } = s, { commandLineRules: a } = t, l = R.resolve(t.workingDir || "", s.cwd || "");
+  if (!rr({ commandLine: o, commandLineRules: a })) {
+    const d = a.map(
+      (h) => `${h.rule.toUpperCase()}: /${h.regexp}/ (${h.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(Q.values()).filter(
+    (d) => d.isRunning
+  ).length >= Te)
+    return {
+      error: `Maximum concurrent process limit reached (${Te} processes). Cannot start new process until existing processes complete. Use process-list to see active processes, or process-kill to terminate unnecessary processes.`
+    };
+  const u = sr(), f = {
+    id: u,
+    cwd: l,
+    commandLine: o,
+    startTime: /* @__PURE__ */ new Date(),
+    isRunning: !0,
+    output: "",
+    localOutput: "",
+    lastOutputTime: /* @__PURE__ */ new Date()
+  };
+  Q.set(u, f);
+  try {
+    const d = Lt(o, [], {
+      shell: !0,
+      cwd: l,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    f.pid = d.pid;
+    const h = (m) => {
+      const g = m.toString();
+      f.localOutput += g, me({ process: f }), console.log(g);
+    };
+    return d.stdout?.on("data", h), d.stderr?.on("data", h), d.on("close", (m) => {
+      if (f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.exitCode = m !== null ? m : void 0, f.output += f.localOutput, f.localOutput = "", f.output.length > F) {
+        const y = `
+... [${f.output.length - F} characters trimmed] ...
+`, w = F - y.length;
+        if (w > 0) {
+          const M = Math.floor(w / 2);
+          f.output = f.output.substring(0, M) + y + f.output.substring(
+            f.output.length - (w - M)
+          );
+        } else
+          f.output = f.output.substring(0, F);
+      }
+      console.log(`Process ${u} (${o}) exited with code ${m}`);
+    }), d.on("error", (m) => {
+      f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.error = m.message, console.error(`Process ${u} error:`, m.message);
+    }), e != null ? tt({ id: u, waitTime: e, autoKill: n, outputLimit: i }, t) : ge({ id: u, outputLimit: i }, t);
+  } catch (d) {
+    return f.isRunning = !1, f.endTime = /* @__PURE__ */ new Date(), f.error = d instanceof Error ? d.message : "Unknown error", { error: f.error };
+  }
+}
+function cr(r, t) {
+  const s = t.commandLineRules.map((o) => `${o.rule.toUpperCase()}: ${o.regexp} (${o.note})`).join(`
+`);
+  r(
+    "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. Prefer process-run with waitTime parameter if you need to immediately execute and wait for completion, instead of separate process-run and process-wait calls. Security: Command lines are validated against configured rules processed in order (later rules override earlier ones). Current command line rules:
+${s}`,
+      inputSchema: rt.shape
+    },
+    async (o) => {
+      const e = await lr(o, t);
+      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 st = 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 ur(r, t) {
+  pe();
+  let s;
+  try {
+    s = st.parse(r);
+  } catch (c) {
+    return {
+      error: B(c)
+    };
+  }
+  const { minOpenDateTime: o, minCloseDateTime: e, activeOnly: n, fields: i } = s;
+  let a = Array.from(Q.values());
+  if (o) {
+    const c = new Date(o.replace(/[_\s]/g, "T"));
+    a = a.filter((u) => u.startTime >= c);
+  }
+  if (e) {
+    const c = new Date(e.replace(/[_\s]/g, "T"));
+    a = a.filter((u) => u.endTime && u.endTime >= c);
+  }
+  return n && (a = a.filter((c) => c.isRunning)), { processes: a.map((c) => {
+    me({ process: c });
+    let u = {
+      id: c.id,
+      cwd: Ft.relative(t.workingDir || "", c.cwd),
+      commandLine: c.commandLine,
+      pid: c.pid,
+      startTime: c.startTime.toISOString().replace(/[TZ]/g, " ").trim(),
+      endTime: c.endTime?.toISOString().replace(/[TZ]/g, " ").trim(),
+      exitCode: c.exitCode,
+      isRunning: c.isRunning,
+      output: c.output + c.localOutput,
+      error: c.error
+    };
+    if (i) {
+      const f = {};
+      for (const d of i)
+        d in u && (f[d] = u[d]);
+      u = f;
+    }
+    return u;
+  }) };
+}
+function dr(r, t) {
+  r(
+    "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: st.shape
+    },
+    async (s) => {
+      const o = await ur(s, t);
+      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(`
+`) || "No processes found";
+      return `Method: process-list(${JSON.stringify(s)})
+Processes:
+${e}`;
+    }
+  );
+}
+const ot = 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 fr(r) {
+  let t;
+  try {
+    t = ot.parse(r);
+  } catch (e) {
+    return {
+      error: B(e)
+    };
+  }
+  const { id: s } = t, o = Q.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 Xe(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 hr(r, t) {
+  r(
+    "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: ot.shape
+    },
+    async (s) => {
+      const o = fr(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 pr(r, t) {
+  or(), t.run && cr(r, t), t.status && ir(r, t), t.wait && ar(r, t), t.list && dr(r, t), t.kill && hr(r);
+  const s = t.commandLineRules?.map(
+    (o) => `${o.rule.toUpperCase()}: ${o.regexp} (${o.note})`
+  ) || [];
+  console.log(
+    `Process manager:
+- Working directory: ${R.resolve(t.workingDir || "")}
+- Command line rules: ${t.commandLineRules?.length || 0} rules configured:
+${s.map((o) => `- ${o}`).join(`
+`)}
+`
+  );
+}
+function mr(r, t) {
+  return function(o, e, n) {
+    const i = async (...a) => {
+      await se({
+        logFilePath: t.logFilePath,
+        message: "REQUEST",
+        data: { name: o, args: a }
+      });
+      const l = await n(...a);
+      return await se({
+        logFilePath: t.logFilePath,
+        message: "RESPONSE",
+        data: l
+      }), {
+        content: [
+          {
+            type: "text",
+            text: l
+          }
+        ]
+      };
+    };
+    return r.registerTool(
+      o,
+      e,
+      i
+    );
+  };
+}
+function gr(r) {
+  return r.match(/^[/\\]?[^/\\]+/)[0];
+}
+function wr(r, t) {
+  return gr(r) + "|" + t.ino;
+}
+function yr(r) {
+  return r.endsWith(":") && (r += "/"), R.resolve(r);
+}
+const we = new Pt(_t.cpus().length);
+function ve(r, t) {
+  r.totalSize += t.totalSize, r.maxFileDateModified = Math.max(
+    r.maxFileDateModified,
+    t.maxFileDateModified
+  ), r.countFiles += t.countFiles, r.countDirs += t.countDirs, r.countLinks += t.countLinks;
+}
+const br = function(t) {
+  return t.code === "ENOENT";
+};
+function nt(r) {
+  const t = r.paths;
+  if (!t || t.length === 0)
+    return Promise.resolve({
+      totalSize: 0,
+      maxFileDateModified: 0,
+      countFiles: 0,
+      countDirs: 0,
+      countLinks: 0
+    });
+  const s = r.level ?? 0, o = r.walkedIds ?? /* @__PURE__ */ new Set(), e = r.abortSignal, n = r.pool ?? we, i = r.handleError, a = r.priority ?? V(0), l = r.walkLinks ?? !1, c = r.log, u = r.handlePath, f = r.matchPath;
+  async function d(m) {
+    if (!(i && await i(m)) && !br(m))
+      throw m;
+  }
+  function h(m) {
+    return !(!c || c.minTotalContentSize != null && m < c.minTotalContentSize || c.maxNestedLevel != null && s > c.maxNestedLevel);
+  }
+  return At(async (m) => {
+    const g = zt(e, m), y = {
+      totalSize: 0,
+      maxFileDateModified: 0,
+      countFiles: 0,
+      countDirs: 0,
+      countLinks: 0
+    };
+    function w($, S) {
+      if (h(S.totalSize)) {
+        const T = `${S.totalSize.toLocaleString("en-US").replace(/,/g, " ").padStart(19)}: ${$}`;
+        c?.handleLog ? c.handleLog(T) : console.log(T);
+      }
+    }
+    async function M($, S, x, T) {
+      return u ? await Y({
+        pool: n,
+        func: async () => {
+          try {
+            return await u({
+              level: s,
+              path: $,
+              stat: S,
+              itemStat: x,
+              totalStat: y,
+              abortSignal: g
+            });
+          } catch (v) {
+            return await d(v), !1;
+          }
+        },
+        count: 1,
+        priority: T,
+        abortSignal: g
+      }) : !0;
+    }
+    async function E($, S, x, T) {
+      T || (T = $);
+      const v = await Y({
+        pool: n,
+        func: () => W.promises.lstat($).catch(d),
+        count: 1,
+        priority: V(S, V(1, a)),
+        abortSignal: g
+      });
+      if (!v || !x && v.isFile())
+        return null;
+      const L = wr($, v);
+      if (o.has(L))
+        return null;
+      o.add(L);
+      let k = {
+        totalSize: v.size,
+        maxFileDateModified: v.isDirectory() ? 0 : v.mtimeMs,
+        countFiles: 0,
+        countDirs: 0,
+        countLinks: 0
+      };
+      const I = V(
+        S,
+        V(v.isDirectory() ? 2 : 3, a)
+      );
+      if (v.isSymbolicLink()) {
+        if (l) {
+          const C = await Y({
+            pool: n,
+            func: () => W.promises.readlink($).catch(d).then((N) => N ?? null),
+            count: 1,
+            priority: I,
+            abortSignal: g
+          });
+          if (C) {
+            const N = R.isAbsolute(C) ? C : R.resolve(R.dirname(T), C), O = await E(
+              N,
+              S,
+              x,
+              T
+            );
+            O && (k = O);
+          }
+        }
+        return (x || k.countFiles + k.countDirs + k.countLinks >= 1) && (k.countLinks += 1, await M(
+          T,
+          v,
+          k,
+          I
+        ) && (ve(y, k), w(T, k))), k;
+      } else if (v.isDirectory()) {
+        const C = await Y({
+          pool: n,
+          func: () => W.promises.readdir($).catch(d),
+          count: 1,
+          priority: a,
+          abortSignal: g
+        });
+        if (C) {
+          for (let N = 0, O = C.length; N < O; N++)
+            C[N] = R.join(T, C[N]);
+          k = await nt({
+            ...r,
+            paths: C,
+            abortSignal: g,
+            priority: I,
+            level: s + 1,
+            walkedIds: o
+          });
+        }
+      }
+      return (x || k.countFiles + k.countDirs + k.countLinks >= 1) && (v.isDirectory() ? k.countDirs += 1 : v.isFile() && (k.countFiles += 1), await M(
+        T,
+        v,
+        k,
+        I
+      ) && (ve(y, k), w(T, k))), k;
+    }
+    const b = [];
+    for (let $ = 0, S = t.length; $ < S; $++) {
+      const x = yr(t[$]), T = f ? f(x) : !0;
+      T !== !1 && b.push(E(x, $, T));
+    }
+    return await Promise.all(b), y;
+  });
+}
+function it(r) {
+  return nt(r);
+}
+function H(r) {
+  return r.replace(/\\/g, "/");
+}
+function Sr(r, t) {
+  if (!t || t === ".")
+    return r;
+  const s = r.startsWith("^");
+  s && (r = r.substring(1));
+  const o = r.startsWith("!");
+  return o && (r = r.substring(1)), r.startsWith("/") ? (t.endsWith("/") && (t = t.substring(0, t.length - 1)), r = t + r) : (t.endsWith("/") || (t += "/"), r.startsWith("./") ? r = t + r.substring(2) : r.startsWith("../") ? r = t + r : (t.startsWith("..") && (t = ""), r.startsWith("**") ? r = t + r : r = t + "**/" + r)), r = H(R.normalize(r)), o && (r = "!" + r), s && (r = "^" + r), r;
+}
+function xr(r) {
+  const t = r.startsWith("!");
+  return t && (r = r.substring(1)), r.startsWith("/") ? r = r.substring(1) : !r.startsWith("**") && !r.startsWith("../") && (r = `**/${r}`), t && (r = "!" + r), r;
+}
+function Ee(r) {
+  return "^" + r;
+}
+async function $r(r) {
+  const s = (await W.promises.readFile(r, "utf-8")).split(`
+`), o = [];
+  return s.forEach((e) => {
+    e = e.trim(), !(!e || e.startsWith("#")) && o.push(e);
+  }), o;
+}
+async function at(r) {
+  const t = r.rootDir ?? ".", s = [];
+  if (!r.globs?.length)
+    return s;
+  const o = [];
+  return r.globs.forEach((e) => {
+    e.value && (e.valueType === "file-contains-patterns" ? o.push(e) : e.valueType === "pattern" && s.push(e.exclude ? Ee(e.value) : e.value));
+  }), o.length && await Promise.all(
+    o.map(async (e) => {
+      await Y({
+        pool: we,
+        count: 1,
+        func: async () => {
+          const n = R.resolve(t, e.value), i = await $r(n), a = R.relative(t, R.dirname(n));
+          i.forEach((l) => {
+            l = xr(l), l = Sr(l, a), s.push(e.exclude ? Ee(l) : l);
+          });
+        }
+      });
+    })
+  ), s;
+}
+function lt({
+  globs: r,
+  rootDir: t,
+  noCase: s
+}) {
+  const o = [];
+  return r.forEach((e) => {
+    e = H(e).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 = H(t ? R.resolve(t, e) : e);
+    if (!a)
+      return;
+    let l;
+    try {
+      l = qt(a, {
+        nocase: s ?? !1,
+        dot: !0,
+        strictBrackets: !0
+        // Validate bracket balance for patterns like "["
+      });
+    } catch (c) {
+      throw new Error(
+        `Invalid glob pattern: "${e}". ${c instanceof Error ? c.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: l
+    });
+  }), function(n) {
+    n = H(n);
+    let i = null, a = !1;
+    for (let l = 0, c = o.length; l < c; l++) {
+      const u = o[l];
+      u.match(n) && (u.exclude ? a = !u.negative : (i = !u.negative, a = !1));
+    }
+    return a ? !1 : i;
+  };
+}
+async function Ir(r) {
+  const t = r.rootDir ?? ".", s = [], o = {};
+  r.result.countFiles && (o.countFiles = 0), r.result.size && (o.size = 0);
+  const e = await at({
+    rootDir: t,
+    globs: r.globs
+  });
+  return await it({
+    paths: [t],
+    walkLinks: !0,
+    matchPath: lt({
+      globs: e,
+      rootDir: t,
+      noCase: !0
+    }),
+    handlePath: async ({ path: n, stat: i, itemStat: a }) => {
+      const l = R.relative(t, n), c = i.isDirectory(), u = i.isFile();
+      if (!c && !u)
+        return !0;
+      const f = H(l || "."), d = c ? "dir" : "file", h = c ? a.maxFileDateModified || null : i.mtimeMs, m = c ? a.totalSize : i.size, g = c ? a.countFiles : null, y = {
+        path: f,
+        type: d
+      };
+      if (r.result.dateModified && (y.dateModified = h), r.result.size && (y.size = m), r.result.countFiles && (y.countFiles = g), r.dateModified && h != null) {
+        const [w, M] = r.dateModified;
+        if (w != null && h < w || M != null && h > M)
+          return !1;
+      }
+      if (r.totalSize && m != null) {
+        const [w, M] = r.totalSize;
+        if (w != null && m < w || M != null && m > M)
+          return !1;
+      }
+      return d === "file" && (o.countFiles = (o.countFiles ?? 0) + 1), d === "file" && m != null && (o.size = (o.size ?? 0) + m), h != null && (o.dateModified == null || h > o.dateModified) && (o.dateModified = h), c && !r.result.dirs || u && !r.result.files || s.push(y), !0;
+    }
+  }), { items: s, totals: o };
+}
+const Ne = ["B", "KB", "MB", "GB", "TB"], ke = 1024;
+function Oe(r) {
+  if (r == null) return "-";
+  let t = r ?? 0, s = 0;
+  for (; t >= ke && s < Ne.length - 1; )
+    t /= ke, s++;
+  return `${s === 0 ? t.toString() : t.toFixed(2)}${Ne[s]}`;
+}
+function De(r) {
+  const s = Date.now() - r;
+  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), l = Math.floor(i / 30), c = Math.floor(i / 365);
+  return c > 0 ? `${c}Y` : l > 0 ? `${l}M` : a > 0 ? `${a}w` : i > 0 ? `${i}d` : n > 0 ? `${n}h` : e > 0 ? `${e}m` : `${o}s`;
+}
+function Mr(r, t) {
+  return t?.length ? [...r].sort((s, o) => {
+    for (let e = 0, n = t.length; e < n; e++) {
+      const i = t[e];
+      let a, l;
+      switch (i.field) {
+        case "type":
+          a = s.type, l = o.type;
+          break;
+        case "path":
+          a = s.path, l = o.path;
+          break;
+        case "dateModified":
+          a = s.dateModified, l = o.dateModified;
+          break;
+        case "size":
+          a = s.size, l = o.size;
+          break;
+        case "countFiles":
+          a = s.countFiles, l = o.countFiles;
+          break;
+      }
+      if (a == null) {
+        if (l == null)
+          continue;
+        return 1;
+      }
+      if (l == null)
+        return -1;
+      const c = a > l ? 1 : a < l ? -1 : 0;
+      if (c !== 0)
+        return i.desc ? -c : c;
+    }
+    return 0;
+  }) : r;
+}
+function Tr(r, t) {
+  const s = Mr(r.items, t.sort ?? []), o = t.fields && t.fields.length > 0 ? t.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 l = 0, c = o.length; l < c; l++) {
+        const u = o[l];
+        switch (l > 0 && (e += " | "), u) {
+          case "dateModified":
+            e += a.dateModified ? De(a.dateModified) : "-";
+            break;
+          case "size":
+            e += Oe(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 = Oe(r.totals.size ?? 0), i = r.totals.dateModified ? `, last modified ${De(r.totals.dateModified)} ago` : "";
+    e += `Totals: ${r.totals.countFiles ?? 0} files in dirs, ${n}${i}`;
+  }
+  return e;
+}
+const Cr = "3.0.10", vr = {
+  version: Cr
+}, ao = "Project Tools", lo = "project-tools", co = vr.version, uo = "d00f70240703039df14c76176a055bce6b5484d2b552ba2c89820f03b8e5e60d", Re = 25e3;
+function Fe(r) {
+  const t = r.match(
+    /^\s*(\d+(?:\.\d+)?)\s*([smhdwMY]|sec(onds?)?|min(utes?)?|hours?|days?|weeks?|months?|years?)\s*$/i
+  );
+  if (!t)
+    throw new Error(
+      `Invalid time ago format: "${r}". 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(t[1]);
+  let o = t[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 Be(r) {
+  const t = r.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)\s*$/i);
+  if (!t)
+    throw new Error(
+      `Invalid size format: "${r}". 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(t[1]), o = t[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 ct = 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 Er(r, t) {
+  let s;
+  try {
+    s = ct.parse(r);
+  } catch (g) {
+    return {
+      error: B(g)
+    };
+  }
+  const {
+    globs: o,
+    showFiles: e,
+    showDirs: n,
+    sortBy: i,
+    minTimeAgo: a,
+    maxTimeAgo: l,
+    minTotalSize: c,
+    maxTotalSize: u
+  } = 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 y = g.field;
+    return y === "totalCountFiles" && (y = "countFiles"), y === "lastModified" && (y = "dateModified"), {
+      field: y,
+      desc: g.desc ?? !1
+      // Default to ascending if not specified
+    };
+  }) ?? null;
+  (!d || d.length === 0) && (d = [{ field: "path", desc: !1 }]);
+  const h = d?.map((g) => g.field) || [], m = R.resolve(
+    t.workingDir || "",
+    s.rootDir || ""
+  );
+  try {
+    try {
+      await W.promises.access(m, W.constants.F_OK);
+    } catch (x) {
+      if (x.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-list without rootDir to list the current directory, or check parent directories first.`
+        };
+      throw x;
+    }
+    const g = o && o.length > 0 ? o.map((x) => ({
+      value: x,
+      valueType: "pattern",
+      exclude: !1
+    })) : [{ value: "**", valueType: "pattern", exclude: !1 }], y = t.globsExclude || [], w = [...g, ...y], M = {
+      files: e ?? !1,
+      dirs: n ?? !1,
+      dateModified: f.includes("dateModified") || h.includes("dateModified"),
+      size: f.includes("size") || h.includes("size"),
+      countFiles: f.includes("countFiles") || h.includes("countFiles")
+    };
+    let E = null, b = null;
+    if (a || l)
+      try {
+        const x = Date.now(), T = l ? x - Fe(l) : null, v = a ? x - Fe(a) : null;
+        E = [T, v];
+      } catch (x) {
+        return {
+          error: x instanceof Error ? x.message : "Unknown error parsing time ago filter"
+        };
+      }
+    if (c || u)
+      try {
+        const x = c ? Be(c) : null, T = u ? Be(u) : null;
+        b = [x, T];
+      } catch (x) {
+        return {
+          error: x instanceof Error ? x.message : "Unknown error parsing size filter"
+        };
+      }
+    const $ = await Ir({
+      rootDir: m || null,
+      globs: w,
+      result: M,
+      dateModified: E,
+      totalSize: b
+    });
+    return $.items.length > Re ? {
+      error: `Number of paths (${$.items.length}) exceeds maximum allowed (${Re}). Consider using more specific glob patterns or filters to reduce the result set.`
+    } : {
+      output: Tr($, {
+        sort: d,
+        fields: f,
+        totals: !0
+      })
+    };
+  } catch (g) {
+    return { error: g instanceof Error ? g.message : "Unknown error" };
+  }
+}
+function Nr(r, t) {
+  r(
+    "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: ct.shape
+    },
+    async (s) => {
+      const o = await Er(s, t);
+      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 le = /* @__PURE__ */ new Map();
+function ie(r) {
+  return le.has(r) || le.set(r, {
+    fsSnapshotQueries: /* @__PURE__ */ new Map(),
+    fsSnapshots: /* @__PURE__ */ new Map()
+  }), le.get(r);
+}
+function Le(r) {
+  const t = r.match(
+    /^\s*(\d+(?:\.\d+)?)\s*([smhdwMY]|sec(onds?)?|min(utes?)?|hours?|days?|weeks?|months?|years?)\s*$/i
+  );
+  if (!t)
+    throw new Error(
+      `Invalid time ago format: "${r}". 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(t[1]);
+  let o = t[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(r) {
+  const t = r.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)\s*$/i);
+  if (!t)
+    throw new Error(
+      `Invalid size format: "${r}". 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(t[1]), o = t[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 ye = 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)'
+  ),
+  types: p.array(p.enum(["file", "dir"])).optional().describe(
+    "Types of items to include in the snapshot. If omitted, includes both files and 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'
+  )
+}), Ae = new Map(
+  [
+    "name",
+    "type",
+    "countMatched",
+    "size",
+    "dateModified"
+  ].map((r, t) => [r, t])
+);
+function kr(r, t) {
+  const s = Ae.get(r) ?? 1 / 0, o = Ae.get(t) ?? 1 / 0;
+  return s > o ? 1 : s < o ? -1 : 0;
+}
+async function ut(r, t, s) {
+  let o;
+  try {
+    o = ye.parse(r);
+  } catch (h) {
+    return {
+      error: B(h)
+    };
+  }
+  const {
+    name: e,
+    globs: n,
+    types: i,
+    minTimeAgo: a,
+    maxTimeAgo: l,
+    minTotalSize: c,
+    maxTotalSize: u
+  } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const f = ie(s.sessionId), d = H(
+    R.resolve(t.workingDir || "", o.rootDir || "")
+  );
+  try {
+    try {
+      await W.promises.access(d, W.constants.F_OK);
+    } catch (S) {
+      if (S.code === "ENOENT")
+        return {
+          error: `Directory does not exist: "${d}". 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 S;
+    }
+    const h = o.extraFields ? o.extraFields.map((S) => S === "lastModified" ? "dateModified" : S) : [];
+    h.includes("name") || h.push("name"), h.sort(kr);
+    const m = n && n.length > 0 ? n.map((S) => ({
+      value: S,
+      valueType: "pattern",
+      exclude: !1
+    })) : [{ value: "**", valueType: "pattern", exclude: !1 }], g = t.globsExclude || [], y = [...m, ...g];
+    let w = null, M = null;
+    if (a || l)
+      try {
+        const S = Date.now(), x = l ? S - Le(l) : null, T = a ? S - Le(a) : null;
+        w = [x, T];
+      } catch (S) {
+        return {
+          error: S instanceof Error ? S.message : "Unknown error parsing time ago filter"
+        };
+      }
+    if (c || u)
+      try {
+        const S = c ? Pe(c) : null, x = u ? Pe(u) : null;
+        M = [S, x];
+      } catch (S) {
+        return {
+          error: S instanceof Error ? S.message : "Unknown error parsing size filter"
+        };
+      }
+    const E = i ? i.includes("file") : !0, b = i ? i.includes("dir") : !0, $ = {
+      name: e,
+      rootDir: d,
+      globs: y,
+      matchFiles: E,
+      matchDirs: b,
+      dateModified: w,
+      totalSize: M,
+      fields: h
+    };
+    return f.fsSnapshotQueries.set(e, $), {
+      snapshotQuery: $
+    };
+  } catch (h) {
+    return {
+      error: h instanceof Error ? h.message : "Unknown error"
+    };
+  }
+}
+function Or(r, t) {
+  r(
+    "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: ye.shape
+    },
+    async (s, o) => {
+      const e = await ut(s, t, 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 ne(r) {
+  const { idToNode: t, idToChildIds: s } = r, o = t.get(null);
+  if (o == null)
+    throw new Error(
+      "Impossible behavior: root node (id: null) not found in idToNode"
+    );
+  const e = /* @__PURE__ */ new Map();
+  return t.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) => t.get(n) ?? null,
+    getId: (n) => e.get(n) ?? null,
+    getChilds: (n) => {
+      let i = e.get(n);
+      if (i == null)
+        if (n === t.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((l) => {
+        const c = t.get(l);
+        if (c == null)
+          throw new Error(
+            `Child node with id '${l}' not found in idToNode`
+          );
+        return c;
+      });
+    }
+  };
+}
+function dt(r, t, s) {
+  let o = null;
+  for (let e = 0, n = t.length; e < n; e++) {
+    const i = t[e], a = r(i), l = a == null ? null : dt(r, a, s), c = s(i, l);
+    c != null && (o == null && (o = []), o.push(c));
+  }
+  return o;
+}
+function ft(r) {
+  const { getId: t, getChilds: s, rootNodes: o, createSnapshotNode: e } = r, n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), l = dt(
+    s,
+    o,
+    (u, f) => {
+      const d = e(u, f);
+      if (u != null && d != null) {
+        const h = t(u);
+        n.set(h, d), i.set(d, h);
+      }
+      return d != null && f != null && a.set(
+        i.get(d),
+        f.map((h) => i.get(h))
+      ), d;
+    }
+  ), c = e(null, l);
+  if (c == null)
+    throw new Error("Impossible behavior: rootNode == null");
+  return n.set(null, c), l != null && a.set(
+    null,
+    l.map((u) => i.get(u))
+  ), {
+    idToNode: n,
+    idToChildIds: a
+  };
+}
+function he(r) {
+  return r = r != null ? H(r).replace(/\/$/, "") : null, !r || r === "." ? null : r;
+}
+async function Dr(r) {
+  const t = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), o = R.resolve(r.rootDir || "."), n = {
+    path: ".",
+    name: R.basename(o),
+    type: "dir",
+    isMatched: !1,
+    dateModified: null,
+    size: 0
+  };
+  t.set(null, n);
+  const i = await at({
+    rootDir: o,
+    globs: r.globs
+  });
+  return await it({
+    paths: [o],
+    walkLinks: !0,
+    matchPath: lt({
+      globs: i,
+      rootDir: o,
+      noCase: !0
+    }),
+    handlePath: async ({ path: a, stat: l, itemStat: c }) => {
+      const u = R.relative(o, a), f = l.isDirectory(), d = l.isFile();
+      if (!f && !d)
+        return !0;
+      const h = he(u || "."), m = f ? "dir" : "file", g = f ? null : l.mtimeMs, y = l.size;
+      let w = !0;
+      if (d && !r.matchFiles && (w = !1), f && !r.matchDirs && (w = !1), w && d && r.dateModified && g != null) {
+        const [$, S] = r.dateModified;
+        ($ != null && g < $ || S != null && g > S) && (w = !1);
+      }
+      if (w && d && r.totalSize && y != null) {
+        const [$, S] = r.totalSize;
+        ($ != null && y < $ || S != null && y > S) && (w = !1);
+      }
+      if (f && !w) {
+        if (!(c.countFiles && c.countFiles > 0)) return !1;
+      } else if (!w)
+        return !1;
+      const M = {
+        path: h ?? ".",
+        name: R.basename(a),
+        type: m,
+        dateModified: g,
+        size: y,
+        isMatched: w
+      };
+      if (h == null)
+        return n.dateModified = g, n.size = y, n.isMatched = w, !0;
+      t.set(h, M);
+      const E = he(H(R.dirname(h)));
+      let b = s.get(E);
+      return b || (b = [], s.set(E, b)), b.push(h), !0;
+    }
+  }), {
+    idToNode: t,
+    idToChildIds: s
+  };
+}
+const Rr = [
+  { name: "[ ]", match: (r) => r === 32, min: 2, max: 81 },
+  { name: "[\\t]", match: (r) => r === 9, min: 2, max: 20 },
+  { name: "[\\n]", match: (r) => r === 10, min: 2, max: 14 },
+  { name: "[-]", match: (r) => r === 45, min: 2, max: 16 },
+  { name: "[=]", match: (r) => r === 61, min: 2, max: 16 },
+  { name: "[_]", match: (r) => r === 95, min: 2, max: 16 },
+  { name: "[*]", match: (r) => r === 42, min: 2, max: 16 },
+  { name: "[.]", match: (r) => r === 46, min: 2, max: 16 },
+  { name: "[0-9]", match: (r) => r >= 48 && r <= 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 ze(r, t = Rr) {
+  const s = r.length;
+  if (s === 0) return 0;
+  const o = t.length;
+  if (o === 0)
+    return s;
+  let e = 0, n = 0;
+  for (; n < s; ) {
+    const i = r.charCodeAt(n);
+    let a = !1;
+    for (let l = 0; l < o; l++) {
+      const c = t[l];
+      if (c.match(i)) {
+        let u = 1;
+        for (; ++n < s && c.match(r.charCodeAt(n)) && u < c.max; )
+          u++;
+        if (u >= c.min) {
+          e++, a = !0;
+          break;
+        }
+      }
+    }
+    a || (n++, e++);
+  }
+  return e;
+}
+function ht(r) {
+  let t = 0;
+  return t += ze(r.textOpen) + 1, r.textClose != null && (t += ze(r.textClose) + 1), r.indent && (t += 1), t;
+}
+const Ue = ["B", "KB", "MB", "GB", "TB"], _e = 1024;
+function Fr(r) {
+  if (r == null) return "-";
+  let t = r ?? 0, s = 0;
+  for (; t >= _e && s < Ue.length - 1; )
+    t /= _e, s++;
+  return `${s === 0 ? t.toString() : t.toFixed(2)}${Ue[s]}`;
+}
+function Br(r) {
+  const s = Date.now() - r;
+  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), l = Math.floor(i / 30), c = Math.floor(i / 365);
+  return c > 0 ? `${c}Y` : l > 0 ? `${l}M` : a > 0 ? `${a}w` : i > 0 ? `${i}d` : n > 0 ? `${n}h` : e > 0 ? `${e}m` : `${o}s`;
+}
+function Lr(r) {
+  return function(s, o) {
+    const e = r.get(s), n = r.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 Pr(r) {
+  const t = r.fields ?? [];
+  return function(o, e) {
+    let n = "", i, a = 0;
+    const l = e ? e.length : 0;
+    let c = 1, u, f = 0, d = 0, h = 0, m = 0, g = null, y, w, M;
+    if (e)
+      for (let b = 0; b < e.length; b++) {
+        const $ = e[b];
+        a += $.countMatched, c += $.countTotal, f += $.tokens, d += $.tokensTotal, h += $.size, m += $.countFiles, $.dateModified != null && (g == null || $.dateModified > g) && (g = $.dateModified);
+      }
+    o ? (y = o.type, w = o.name, M = o.path, i = o.isMatched, i && (a += 1), o.type === "file" ? (h = o.size || 0, m = 1, g = o.dateModified || null) : o.dateModified != null && (g == null || o.dateModified > g) && (g = o.dateModified)) : (y = "dir", w = "<root>", M = ".", i = !0);
+    for (let b = 0, $ = t.length; b < $; b++) {
+      const S = t[b];
+      switch (b > 0 && (n += " "), S) {
+        case "dateModified":
+          n += g ? Br(g) : "-";
+          break;
+        case "size":
+          n += Fr(h);
+          break;
+        case "type":
+          n += y;
+          break;
+        case "name":
+          n += y === "dir" ? `${w}/` : w;
+          break;
+        case "countMatched":
+          n += a.toString();
+          break;
+      }
+    }
+    const E = {
+      indent: !0,
+      textOpen: n,
+      textClose: null
+    };
+    return u = ht(E), d += u, {
+      type: y,
+      name: w,
+      path: M,
+      isMatched: i,
+      countMatched: a,
+      countChilds: l,
+      countTotal: c,
+      tokens: u,
+      tokensChilds: f,
+      tokensTotal: d,
+      text: E,
+      size: h,
+      countFiles: m,
+      dateModified: g
+    };
+  };
+}
+async function Ar(r) {
+  const t = await Dr(r), s = ne(t), o = s.getChilds(s.root), e = ft({
+    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: Pr(r),
+    rootNodes: o ?? []
+  }), n = Lr(e.idToNode);
+  return e.idToChildIds.forEach((i) => {
+    i.sort(n);
+  }), ne(e);
+}
+const ae = p.object({
+  queryName: p.string().optional().describe("Name of previously created filesystem snapshot query, to use"),
+  query: ye.optional().describe(
+    "Filesystem snapshot query creation options JSON to automatically create query"
+  ),
+  name: p.string().describe(
+    "Unique name for the filesystem snapshot. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function be(r, t, s) {
+  let o;
+  try {
+    o = ae.parse(r);
+  } catch (u) {
+    return {
+      error: B(u)
+    };
+  }
+  const { name: e, queryName: n, query: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = ie(s.sessionId);
+  if (n && i)
+    return {
+      error: "Either queryName or query must be provided, not both"
+    };
+  let l, c = !1;
+  if (n) {
+    const u = a.fsSnapshotQueries.get(n);
+    if (!u)
+      return {
+        error: `Filesystem snapshot query "${n}" not found`
+      };
+    l = u;
+  } else if (i) {
+    const u = await ut(
+      i,
+      t,
+      s
+    );
+    if (u.error != null)
+      return {
+        error: u.error
+      };
+    l = u.snapshotQuery, c = !0;
+  } else
+    return {
+      error: "Either queryName or query must be provided"
+    };
+  try {
+    const u = await Ar(l), f = {
+      name: e,
+      query: l,
+      tree: u
+    };
+    return a.fsSnapshots.set(e, f), {
+      fsSnapshot: f,
+      queryCreated: c
+    };
+  } catch (u) {
+    return {
+      error: `Failed to create filesystem snapshot: ${u instanceof Error ? u.message : "Unknown error"}`
+    };
+  }
+}
+function zr(r, t) {
+  r(
+    "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: ae.shape
+    },
+    async (s, o) => {
+      const e = await be(s, t, 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 Ur {
+  _first = null;
+  _last = null;
+  _size = 0;
+  enqueue(t) {
+    const s = { item: t, next: null };
+    this._last ? this._last.next = s : this._first = s, this._last = s, this._size += 1;
+  }
+  dequeue() {
+    if (!this._first) return null;
+    const t = this._first.item;
+    return this._first = this._first.next, this._first || (this._last = null), this._size -= 1, t;
+  }
+  peek() {
+    return this._first ? this._first.item : null;
+  }
+  isEmpty() {
+    return this._first == null;
+  }
+  size() {
+    return this._size;
+  }
+}
+function _r(r) {
+  const t = new Ur(), {
+    tree: s,
+    limits: { maxCountTotal: o, maxTokensTotal: e, maxCountGroup: n, maxTokensGroup: i },
+    indexRangeGroupStrategy: a
+  } = r, l = s.getChilds(s.root);
+  l != null && l.length > 0 && t.enqueue({
+    reportNode: null,
+    node: s.root
+  });
+  let c = null, u = 0, f = 0;
+  for (; !t.isEmpty(); ) {
+    const { reportNode: d, node: h } = t.dequeue(), m = s.getChilds(h);
+    if (m == null || h.countChilds === 0 || m.length !== h.countChilds)
+      throw new Error(
+        "Impossible behavior: nodeChilds is null or length mismatch"
+      );
+    let g = t.size();
+    for (let w = 0; w < m.length; w++)
+      m[w].countChilds > 0 && (g += 1);
+    const y = g * a.tokens;
+    if (o != null && u + h.countChilds + g > o || e != null && f + h.tokensChilds + y > e) {
+      const w = [];
+      let M = null, E = 0;
+      for (let $ = 0, S = m.length; $ < S; $++) {
+        const x = m[$], T = E * a.tokens;
+        M != null && // Если общий лимит превышен, то не создаем новую группу, а продолжаем текущую. В случае достижения лимитов, последняя группа может содержать больше элементов, чем указано в лимитах группы, и это допустимо. Главное - дать в отчете полную картину.
+        !(o != null && u + 1 > o || e != null && f + a.tokens > e) && (n != null && M.countGrouped + 1 + E > n || i != null && M.tokensGrouped + x.tokens + T > i) && (w.push(M), u += 1, f += a.tokens, M = null, E = 0), M = a.add(M, x, $), x.countChilds > 0 && (E += 1);
+      }
+      M != null && (w.push(M), u += 1, f += a.tokens);
+      const b = w.map(($) => ({
+        text: a.getReportText($)
+      }));
+      if (d != null) {
+        if (d.childs != null)
+          throw new Error("Impossible behavior: reportNode.childs != null");
+        d.childs = b;
+      } else {
+        if (c != null)
+          throw new Error("Impossible behavior: reportRootNodes != null");
+        c = b;
+      }
+    } else {
+      u += h.countChilds, f += h.tokensChilds;
+      const w = [];
+      for (let M = 0; M < m.length; M++) {
+        const E = m[M], b = {
+          text: E.text
+        };
+        w.push(b);
+        const $ = s.getChilds(E);
+        $ != null && $.length > 0 && t.enqueue({
+          reportNode: b,
+          node: E
+        });
+      }
+      if (d != null) {
+        if (d.childs != null)
+          throw new Error("Impossible behavior: reportNode.childs != null");
+        d.childs = w;
+      } else {
+        if (c != null)
+          throw new Error("Impossible behavior: reportRootNodes != null");
+        c = w;
+      }
+    }
+  }
+  return c ?? [];
+}
+function pt(r) {
+  const {
+    tree: t,
+    request: { parentNodeId: s, childsIndexRange: o, limits: e },
+    indexRangeGroupStrategy: n,
+    ...i
+  } = r;
+  let a;
+  if (s != null) {
+    const d = t.getNode(s);
+    if (d == null)
+      throw new Error(`Parent node "${s}" not found`);
+    a = d;
+  } else
+    a = t.root;
+  let l, c = t.getChilds(a) ?? [];
+  if (o != null) {
+    const [d, h] = o;
+    if (d < 0 || h <= d || h >= c.length)
+      throw new Error(
+        `Invalid index range: ${d}-${h} for root nodes length ${c.length}`
+      );
+    const m = [];
+    let g = null;
+    for (let y = d; y <= h; y++) {
+      const w = c[y];
+      m.push(w), g = n.add(g, w, y);
+    }
+    c = m, l = {
+      ...a,
+      text: n.getReportText(g),
+      countChilds: g.countGrouped,
+      tokensChilds: g.tokensGrouped
+    };
+  } else
+    l = a;
+  const u = {
+    countChilds: 1,
+    tokensChilds: l.tokens
+  }, f = {
+    ...t,
+    root: u,
+    getChilds: (d) => d === u ? [l] : d === l ? c : t.getChilds(d)
+  };
+  return _r({
+    tree: f,
+    limits: e,
+    indexRangeGroupStrategy: n,
+    ...i
+  });
+}
+function mt(r, t) {
+  if (r == null || r.length === 0)
+    return "No results found";
+  let s = "";
+  function o(e, n) {
+    for (let i = 0, a = e.length; i < a; i++) {
+      const l = e[i];
+      s += n, s += l.text.textOpen + `
+`, l.childs != null && l.childs.length > 0 && o(
+        l.childs,
+        l.text.indent ? n + "  " : n
+      ), l.text.textClose != null && (s += n, s += l.text.textClose + `
+`);
+    }
+  }
+  return o(r, ""), s;
+}
+class qr {
+  tokens = 16;
+  // +1 indent, +1 for line break
+  getReportText = (t) => ({
+    indent: !0,
+    textOpen: `[${t.indexRange[0]}-${t.indexRange[1]}] ${t.countMatched} matched ${t.tokensGrouped} tokens`,
+    textClose: null
+  });
+  add = (t, s, o) => t == null ? {
+    indexRange: [o, o],
+    countGrouped: 1,
+    countMatched: s.countMatched,
+    tokensGrouped: s.tokens
+  } : (t.indexRange[1] = o, t.countGrouped += 1, t.countMatched += s.countMatched, t.tokensGrouped += s.tokens, t);
+}
+const gt = p.object({
+  snapshotName: p.string().optional().describe("Name of previously created filesystem snapshot, to use"),
+  snapshot: ae.optional().describe(
+    "Filesystem snapshot creation options JSON 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 Gr(r, t, s) {
+  let o;
+  try {
+    o = gt.parse(r);
+  } catch (g) {
+    return {
+      error: B(g)
+    };
+  }
+  const {
+    snapshotName: e,
+    snapshot: n,
+    childsIndexRange: i
+    // maxCountTotal,
+    // maxTokensTotal,
+    // maxCountGroup,
+    // maxTokensGroup,
+  } = o, a = 60, l = 1e3, c = 25, u = 900;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const f = ie(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either snapshotName or snapshot must be provided, not both"
+    };
+  let d, h = !1, m = !1;
+  if (e) {
+    if (d = f.fsSnapshots.get(e), d == null)
+      return {
+        error: `Filesystem snapshot "${e}" not found`
+      };
+  } else if (n) {
+    const g = await be(
+      n,
+      t,
+      s
+    );
+    if (g.error != null)
+      return {
+        error: g.error
+      };
+    d = g.fsSnapshot, h = g.queryCreated, m = !0;
+  } else
+    return {
+      error: "Either snapshotName or snapshot must be provided"
+    };
+  try {
+    const g = he(o.parentPath), y = pt({
+      tree: d.tree,
+      request: {
+        parentNodeId: g,
+        childsIndexRange: i,
+        limits: {
+          maxCountTotal: a,
+          maxTokensTotal: l,
+          maxCountGroup: c,
+          maxTokensGroup: u
+        }
+      },
+      indexRangeGroupStrategy: new qr()
+    }), w = mt(y);
+    return {
+      fsSnapshot: d,
+      queryCreated: h,
+      snapshotCreated: m,
+      parentPath: g,
+      childsIndexRange: i,
+      report: w
+    };
+  } catch (g) {
+    return {
+      error: `Failed to browse filesystem snapshot: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+}
+function jr(r, t) {
+  r(
+    "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: gt.shape
+    },
+    async (s, o) => {
+      const e = await Gr(s, t, 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 (<root>/): ${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, c = (e.parentPath ? e.fsSnapshot.tree.getNode(e.parentPath) : e.fsSnapshot.tree.root).countChilds;
+        n += `   Showing indexes: ${i}-${a} of ${c}
+`;
+      }
+      return n += `
+${e.report}`, n;
+    }
+  );
+}
+function Jr(r) {
+  const t = [], s = r.tree, o = r.query.rootDir ?? ".";
+  function e(n) {
+    n.type === "file" && n.isMatched && t.push(o + "/" + n.path);
+    const i = s.getChilds(n);
+    if (i != null)
+      for (let a = 0; a < i.length; a++)
+        e(i[a]);
+  }
+  return e(s.root), t;
+}
+const qe = /* @__PURE__ */ new Map();
+function Kr(r) {
+  const t = H(r);
+  let s = qe.get(t);
+  return s == null && (s = new Ut(), qe.set(t, s)), s;
+}
+async function Wr(r) {
+  const { filePath: t, func: s } = r;
+  return Kr(t).lock(
+    () => Y({
+      pool: we,
+      count: 1,
+      func: s
+    })
+  );
+}
+const Ge = 10, X = 48, je = 57, ce = 36, Hr = 38, Qr = 39, Yr = 60, Vr = 62, Zr = 96, ee = 0, Je = 1, Ke = 2, We = 3, He = 4, Xr = 5;
+function es(r) {
+  const { content: t, pattern: s, replacement: o } = r, e = t.length, n = [0];
+  for (let b = 0; b < e; b++)
+    t.charCodeAt(b) === Ge && b + 1 < e && n.push(b + 1);
+  const i = n.length, a = [], l = [];
+  let c = null, u = null, f = null, d = 0;
+  if (o != null) {
+    const b = o.length;
+    let $ = !1;
+    for (let S = 0; S < b; S++)
+      if (o.charCodeAt(S) === ce) {
+        $ = !0;
+        break;
+      }
+    if ($) {
+      u = [], f = [];
+      let S = 0, x = 0;
+      for (; x < b; ) {
+        if (o.charCodeAt(x) !== ce || x + 1 >= b) {
+          x++;
+          continue;
+        }
+        const T = o.charCodeAt(x + 1);
+        let v = -1, L = 0, k = 2;
+        if (T === ce)
+          v = ee, L = "$";
+        else if (T === Hr)
+          v = Je;
+        else if (T === Zr)
+          v = Ke;
+        else if (T === Qr)
+          v = We;
+        else if (T >= X && T <= je) {
+          let I = x + 2;
+          for (; I < b; ) {
+            const C = o.charCodeAt(I);
+            if (C < X || C > je) break;
+            I++;
+          }
+          v = He, L = o.substring(x + 1, I), k = I - x;
+        } else if (T === Yr) {
+          let I = x + 2;
+          for (; I < b && o.charCodeAt(I) !== Vr; )
+            I++;
+          I < b && I > x + 2 && (v = Xr, L = o.substring(x + 2, I), k = I + 1 - x);
+        }
+        v >= 0 ? (x > S && (u.push(ee), f.push(o.substring(S, x))), u.push(v), f.push(L), x += k, S = x) : x++;
+      }
+      S < b && (u.push(ee), f.push(o.substring(S))), d = u.length;
+    } else
+      c = o;
+  }
+  let h = "", m = 0, g = 0;
+  s.lastIndex = 0;
+  let y;
+  for (; (y = s.exec(t)) !== null; ) {
+    const b = y.index, $ = y[0], S = $.length, x = b + S;
+    let T, v, L, k;
+    if (i === 1)
+      T = 0, v = 1, L = 0, k = e;
+    else {
+      let I = 0, C = i - 1;
+      for (; I < C; ) {
+        const N = I + C + 1 >> 1;
+        n[N] <= b ? I = N : C = N - 1;
+      }
+      if (T = I, S > 0) {
+        const N = x - 1;
+        for (C = i - 1; I < C; ) {
+          const O = I + C + 1 >> 1;
+          n[O] <= N ? I = O : C = O - 1;
+        }
+        v = I + 1;
+      } else
+        v = T + 1;
+      L = n[T], k = v < i ? n[v] : e;
+    }
+    if (a.push({
+      offset: [b, x],
+      lines: [T, v],
+      linesOffset: [L, k]
+    }), o != null) {
+      h += t.substring(m, b);
+      let I;
+      if (c != null)
+        I = c;
+      else {
+        I = "";
+        const N = y.groups, O = y.length - 1;
+        for (let K = 0; K < d; K++) {
+          const _ = u[K], A = f[K];
+          switch (_) {
+            case ee:
+              I += A;
+              break;
+            case Je:
+              I += $;
+              break;
+            case Ke:
+              I += t.substring(0, b);
+              break;
+            case We:
+              I += t.substring(x);
+              break;
+            case He: {
+              const P = A, U = P.length, z = P.charCodeAt(0) - X;
+              if (U >= 2) {
+                const q = P.charCodeAt(1) - X, D = z * 10 + q;
+                if (D >= 1 && D <= O) {
+                  I += y[D] ?? "", U > 2 && (I += P.substring(2));
+                  break;
+                }
+              }
+              z >= 1 && z <= O ? (I += y[z] ?? "", U > 1 && (I += P.substring(1))) : I += "$" + P;
+              break;
+            }
+            default:
+              N != null ? I += N[A] ?? "" : I += "$<" + A + ">";
+          }
+        }
+      }
+      h += I;
+      const C = b + g;
+      l.push({
+        offset: [C, C + I.length],
+        lines: [0, 0],
+        linesOffset: [0, 0]
+      }), g += I.length - S, m = x;
+    }
+    if (S === 0 && s.lastIndex++, !s.global)
+      break;
+  }
+  if (s.lastIndex = 0, o == null)
+    return { search: { content: t, matches: a }, replace: null };
+  h += t.substring(m);
+  const w = h.length, M = [0];
+  for (let b = 0; b < w; b++)
+    h.charCodeAt(b) === Ge && b + 1 < w && M.push(b + 1);
+  const E = M.length;
+  for (let b = 0, $ = l.length; b < $; b++) {
+    const S = l[b], x = S.offset[0], T = S.offset[1];
+    let v, L, k, I;
+    if (E === 1)
+      v = 0, L = 1, k = 0, I = w;
+    else {
+      let C = 0, N = E - 1;
+      for (; C < N; ) {
+        const O = C + N + 1 >> 1;
+        M[O] <= x ? C = O : N = O - 1;
+      }
+      if (v = C, T > x) {
+        const O = T - 1;
+        for (N = E - 1; C < N; ) {
+          const K = C + N + 1 >> 1;
+          M[K] <= O ? C = K : N = K - 1;
+        }
+        L = C + 1;
+      } else
+        L = v + 1;
+      k = M[v], I = L < E ? M[L] : w;
+    }
+    S.lines[0] = v, S.lines[1] = L, S.linesOffset[0] = k, S.linesOffset[1] = I;
+  }
+  return {
+    search: { content: t, matches: a },
+    replace: { content: h, matches: l }
+  };
+}
+function te(r, t, s, o) {
+  let e = 0, n = 0;
+  for (let u = 0; u < s; u++)
+    r.charCodeAt(u) === 10 && (n = u + 1, e++);
+  const i = e, a = n;
+  let l = s;
+  for (; l < o; l++)
+    r.charCodeAt(l) === 10 && e++;
+  const c = e + 1;
+  for (; l < t; l++)
+    if (r.charCodeAt(l) === 10)
+      return { startLine: i, endLine: c, startLineOfs: a, endLineOfs: l + 1 };
+  return { startLine: i, endLine: c, startLineOfs: a, endLineOfs: t };
+}
+function ts(r, t) {
+  const s = r.replace ?? r.search, o = t.replace ?? t.search, e = r.search.content, n = o.content, i = e.length, a = n.length, l = r.search.matches, c = s.matches, u = t.search.matches, f = o.matches, d = c.length, h = u.length, m = [], g = [];
+  let y = 0, w = 0, M = 0, E = 0, b = 0, $ = 0, S = 0, x = 0, T = 0, v = 0, L = 0, k = 0, I = 0, C = 0, N = 0, O = 0, K = 0, _ = 0, A = 0, P = 0, U = 0, z = 0, q = 0, D = 0;
+  for (; y < d || w < h; )
+    if (y < d && (b = c[y].offset[0], $ = c[y].offset[1]), w < h && (S = u[w].offset[0], x = u[w].offset[1]), y < d && w < h && b < x && S < $) {
+      K = b < S ? b : S, T = $ > x ? $ : x, L = y, k = w, y++, w++;
+      do {
+        for (v = T; y < d && c[y].offset[0] < T; )
+          $ = c[y].offset[1], $ > T && (T = $), y++;
+        for (; w < h && u[w].offset[0] < T; )
+          x = u[w].offset[1], x > T && (T = x), w++;
+      } while (T !== v);
+      I = 1 / 0, C = -1 / 0, _ = K, A = M;
+      for (let j = L; j < y; j++)
+        P = l[j].offset[0], U = l[j].offset[1], z = c[j].offset[0], q = c[j].offset[1], _ < z && (D = _ + A, D < I && (I = D), D = z + A, D > C && (C = D)), P < I && (I = P), U > C && (C = U), A += U - P - q + z, _ = q;
+      _ < T && (D = _ + A, D < I && (I = D), D = T + A, D > C && (C = D)), M = A, N = 1 / 0, O = -1 / 0, _ = K, A = E;
+      for (let j = k; j < w; j++)
+        P = u[j].offset[0], U = u[j].offset[1], z = f[j].offset[0], q = f[j].offset[1], _ < P && (D = _ + A, D < N && (N = D), D = P + A, D > O && (O = D)), z < N && (N = z), q > O && (O = q), A += q - z - U + P, _ = U;
+      _ < T && (D = _ + A, D < N && (N = D), D = T + A, D > O && (O = D)), E = A;
+      const G = te(e, i, I, C);
+      m.push({
+        offset: [I, C],
+        lines: [G.startLine, G.endLine],
+        linesOffset: [G.startLineOfs, G.endLineOfs]
+      });
+      const Z = te(n, a, N, O);
+      g.push({
+        offset: [N, O],
+        lines: [Z.startLine, Z.endLine],
+        linesOffset: [Z.startLineOfs, Z.endLineOfs]
+      });
+    } else if (w >= h || y < d && b <= S) {
+      P = l[y].offset[0], U = l[y].offset[1], z = c[y].offset[0], q = c[y].offset[1], N = z + E, O = q + E;
+      const G = te(n, a, N, O);
+      m.push(l[y]), g.push({
+        offset: [N, O],
+        lines: [G.startLine, G.endLine],
+        linesOffset: [G.startLineOfs, G.endLineOfs]
+      }), M += U - P - q + z, y++;
+    } else {
+      P = u[w].offset[0], U = u[w].offset[1], z = f[w].offset[0], q = f[w].offset[1], I = P + M, C = U + M;
+      const G = te(e, i, I, C);
+      m.push({
+        offset: [I, C],
+        lines: [G.startLine, G.endLine],
+        linesOffset: [G.startLineOfs, G.endLineOfs]
+      }), g.push(f[w]), E += q - z - U + P, w++;
+    }
+  return {
+    search: { content: e, matches: m },
+    replace: { content: n, matches: g }
+  };
+}
+async function rs(r) {
+  const { filePath: t, operations: s, dryRun: o } = r;
+  return s.length === 0 ? { filePath: t, result: null } : Wr({
+    filePath: t,
+    func: async () => {
+      let e;
+      try {
+        e = await W.promises.readFile(t, "utf-8");
+      } catch (a) {
+        return {
+          filePath: t,
+          result: null,
+          error: `Failed to read file: ${a instanceof Error ? a.message : a + ""}`
+        };
+      }
+      let n = null, i = !1;
+      for (let a = 0; a < s.length; a++) {
+        const l = s[a];
+        let c;
+        try {
+          c = new RegExp(l.pattern, l.flags ?? "");
+        } catch (d) {
+          return {
+            filePath: t,
+            result: null,
+            error: `Invalid RegExp pattern "${l.pattern}": ${d instanceof Error ? d.message : d + ""}`
+          };
+        }
+        const u = n?.replace?.content ?? e, f = es({
+          content: u,
+          pattern: c,
+          replacement: l.replacement
+        });
+        l.replacement != null && (i = !0), n == null ? n = f : n = ts(n, f);
+      }
+      if (i && n?.replace != null && !o) {
+        const a = n.replace.content;
+        if (a !== e)
+          try {
+            await W.promises.writeFile(t, a, "utf-8");
+          } catch (l) {
+            return {
+              filePath: t,
+              result: n,
+              error: `Failed to write file: ${l instanceof Error ? l.message : l + ""}`
+            };
+          }
+      }
+      return { filePath: t, result: n };
+    }
+  });
+}
+async function ss(r) {
+  const { filePaths: t, operations: s, dryRun: o } = r;
+  return { results: await Promise.all(
+    t.map(
+      (n) => rs({ filePath: n, operations: s, dryRun: o })
+    )
+  ) };
+}
+function os(r) {
+  if (r.length === 0)
+    return [];
+  const t = [...r].sort((n, i) => {
+    const a = n.lines[0], l = i.lines[0];
+    if (a > l) return 1;
+    if (a < l) return -1;
+    const c = n.lines[1], u = i.lines[1];
+    return c > u ? 1 : c < u ? -1 : 0;
+  }), s = [];
+  let o = [...t[0].lines], e = [...t[0].linesOffset];
+  for (let n = 1; n < t.length; n++) {
+    const i = t[n];
+    i.lines[0] <= o[1] ? i.lines[1] > o[1] && (o[1] = i.lines[1], e[1] = i.linesOffset[1]) : (s.push({
+      lines: o,
+      linesOffset: e
+    }), o = [...i.lines], e = [...i.linesOffset]);
+  }
+  return s.push({
+    lines: o,
+    linesOffset: e
+  }), s;
+}
+const ns = 6;
+function is(r) {
+  const { content: t, startLine: s } = r, o = r.padWidth ?? ns;
+  let e = "", n = 0, i = 0;
+  for (; n < t.length; ) {
+    const a = t.indexOf(`
+`, n), l = a === -1 ? t.length : a + 1;
+    e += String(s + i + 1).padStart(o) + "→" + t.substring(n, l), n = l, i++;
+  }
+  return e.length > 0 && !e.endsWith(`
+`) && (e += `
+`), e;
+}
+function ue(r) {
+  const { content: t, matches: s, outputLimit: o } = r;
+  if (s.length === 0)
+    return { output: "", truncated: !1 };
+  const e = os(s);
+  let n = "", i = !1;
+  for (let a = 0; a < e.length; a++) {
+    const l = e[a], c = t.substring(
+      l.linesOffset[0],
+      l.linesOffset[1]
+    ), u = is({
+      content: c,
+      startLine: l.lines[0]
+    }), f = a > 0 ? 2 : 0;
+    if (o != null && n.length + f + u.length > o) {
+      i = !0;
+      break;
+    }
+    a > 0 && (n += `⋮
+`), n += u;
+  }
+  return { output: n, truncated: i };
+}
+const Qe = "BEFORE", Ye = "AFTER";
+function as(r) {
+  const { result: t, outputLimit: s } = r;
+  if (t.replace == null) {
+    const m = ue({
+      content: t.search.content,
+      matches: t.search.matches,
+      outputLimit: s
+    });
+    return { output: m.output, truncated: m.truncated };
+  }
+  const o = `<${Qe}>
+`, e = `</${Qe}>
+`, n = `<${Ye}>
+`, i = `</${Ye}>
+`, a = o.length + e.length + n.length + i.length;
+  if (s != null && s < a)
+    return { output: "", truncated: !0 };
+  const l = s != null ? s - a : void 0, c = l != null ? Math.floor(l / 2) : void 0, u = ue({
+    content: t.search.content,
+    matches: t.search.matches,
+    outputLimit: c
+  }), f = l != null ? l - u.output.length : void 0, d = ue({
+    content: t.replace.content,
+    matches: t.replace.matches,
+    outputLimit: f
+  });
+  return { output: o + u.output + e + n + d.output + i, truncated: u.truncated || d.truncated };
+}
+const Ve = `
+... [output truncated] ...
+`;
+function ls(r) {
+  const { result: t, rootDir: s, outputLimit: o } = r, e = o - Ve.length;
+  let n = "", i = !1;
+  for (let a = 0; a < t.results.length; a++) {
+    const l = t.results[a], c = R.relative(s, l.filePath), u = n.length > 0 ? 1 : 0;
+    if (l.error != null) {
+      const h = c + `
+  ❌ ` + l.error + `
+`;
+      if (n.length + u + h.length > e) {
+        i = !0;
+        break;
+      }
+      u > 0 && (n += `
+`), n += h;
+      continue;
+    }
+    if (l.result == null || l.result.search.matches.length === 0)
+      continue;
+    const f = e - n.length - u - c.length - 1;
+    if (f <= 0) {
+      i = !0;
+      break;
+    }
+    const d = as({
+      result: l.result,
+      outputLimit: f
+    });
+    if (i = i || d.truncated, d.output.length > 0 && (u > 0 && (n += `
+`), n += c + `
+` + d.output), i)
+      break;
+  }
+  return i && (n += Ve), n;
+}
+const cs = p.object({
+  pattern: p.string().describe("JS RegExp pattern"),
+  flags: p.string().optional().describe("JS RegExp flags"),
+  replacement: p.string().optional().describe("JS replacement pattern. If omitted, search only")
+}), wt = p.object({
+  snapshotName: p.string().optional().describe("Name of previously created filesystem snapshot, to use"),
+  snapshot: ae.optional().describe(
+    "Filesystem snapshot creation options JSON to automatically create snapshot"
+  ),
+  operations: p.array(cs).describe("Search/replace operations to execute sequentially on each file"),
+  outputLimit: p.number().max(F).default(F).describe(
+    `Maximum output characters. Output exceeding this limit will be truncated. Maximum: ${F}. Default: ${F}`
+  ),
+  dryRun: p.boolean().optional().describe(
+    "Preview changes without writing files. When true, shows what would be replaced but does not modify files"
+  )
+});
+async function us(r, t, s) {
+  let o;
+  try {
+    o = wt.parse(r);
+  } catch (w) {
+    return {
+      error: B(w)
+    };
+  }
+  const { snapshotName: e, snapshot: n, operations: i, outputLimit: a, dryRun: l } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const c = ie(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either snapshotName or snapshot must be provided, not both"
+    };
+  let u, f = !1, d = !1;
+  if (e) {
+    if (u = c.fsSnapshots.get(e), u == null)
+      return {
+        error: `Filesystem snapshot "${e}" not found`
+      };
+  } else if (n) {
+    const w = await be(
+      n,
+      t,
+      s
+    );
+    if (w.error != null)
+      return {
+        error: w.error
+      };
+    u = w.fsSnapshot, f = w.queryCreated, d = !0;
+  } else
+    return {
+      error: "Either snapshotName or snapshot must be provided"
+    };
+  const h = Jr(u), m = u.query.rootDir ?? ".", g = await ss({
+    filePaths: h,
+    operations: i,
+    dryRun: l
+  });
+  return { output: ls({
+    result: g,
+    rootDir: m,
+    outputLimit: a
+  }), rootDir: m, fsSnapshot: u, queryCreated: f, snapshotCreated: d };
+}
+function ds(r, t) {
+  r(
+    "fs-snapshot-search-or-replace",
+    {
+      title: "Search/Replace File Contents in Snapshot",
+      description: "Search/replace file contents using JS RegExp. Use this to find text patterns or perform bulk replacements across snapshot files",
+      inputSchema: wt.shape
+    },
+    async (s, o) => {
+      const e = await us(
+        s,
+        t,
+        o
+      );
+      if (e.error != null)
+        return `Method: fs-snapshot-search-or-replace(${JSON.stringify(s)})
+❌ Error: ${e.error}`;
+      let n = `Method: fs-snapshot-search-or-replace(${JSON.stringify(s)})
+`;
+      return e.queryCreated && (n += `✅ Filesystem snapshot query "${e.fsSnapshot.query.name}" created successfully
+`), e.snapshotCreated && (n += `✅ Filesystem snapshot "${e.fsSnapshot.name}" created successfully
+`), n += `✅ Search/replace in snapshot "${e.fsSnapshot.name}":
+`, n += `Root directory (<root>/): ${e.rootDir}
+`, n += `
+${e.output}`, n;
+    }
+  );
+}
+function fs(r, t) {
+  t.list && Nr(r, t), t.snapshotQueryCreate && Or(r, t), t.snapshotCreate && zr(r, t), t.snapshotBrowse && jr(r, t), t.snapshotSearchOrReplace && ds(r, t), console.log(
+    `File manager:
+- Working directory: ${R.resolve(t.workingDir || "")}
+`
+  );
+}
+const de = /* @__PURE__ */ new Map();
+function J(r) {
+  return de.has(r) || de.set(r, {
+    browsers: /* @__PURE__ */ new Map(),
+    domSnapshotQueries: /* @__PURE__ */ new Map()
+  }), de.get(r);
+}
+const Se = 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 yt(r, t, s) {
+  let o;
+  try {
+    o = Se.parse(r);
+  } catch (c) {
+    return {
+      error: B(c)
+    };
+  }
+  const { name: e, browserType: n, muteAudio: i, devTools: a } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const l = J(s.sessionId);
+  try {
+    const u = await {
+      chromium: Jt,
+      firefox: jt,
+      webkit: Gt
+    }[n].launch({
+      headless: !1,
+      devtools: a,
+      args: i ? ["--mute-audio"] : void 0
+    }), f = {
+      name: e,
+      browserType: n,
+      browser: u,
+      contexts: /* @__PURE__ */ new Map()
+    };
+    return l.browsers.set(e, f), { browserInfo: f };
+  } catch (c) {
+    return {
+      error: `Failed to create browser: ${c instanceof Error ? c.message : "Unknown error"}`
+    };
+  }
+}
+function hs(r, t) {
+  r(
+    "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: Se.shape
+    },
+    async (s, o) => {
+      const e = await yt(s, t, 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 bt = p.object({});
+async function ps(r, t, s) {
+  let o;
+  try {
+    o = bt.parse(r);
+  } catch (i) {
+    return {
+      error: B(i)
+    };
+  }
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const e = J(s.sessionId);
+  return {
+    browserInfos: Array.from(e.browsers.values())
+  };
+}
+function ms(r, t) {
+  r(
+    "playwright-browser-list",
+    {
+      title: "List Browsers",
+      description: "List active browser instances",
+      inputSchema: bt.shape
+    },
+    async (s, o) => {
+      const e = await ps(s, t, 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 St = p.object({
+  names: p.array(p.string()).optional().describe(
+    "Names of browsers to close. If not specified, closes all browsers"
+  )
+});
+async function gs(r, t, s) {
+  let o;
+  try {
+    o = St.parse(r);
+  } catch (c) {
+    return {
+      error: B(c)
+    };
+  }
+  const { names: e } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const n = J(s.sessionId), i = [], a = [];
+  let l = [];
+  return e ? e.forEach((c) => {
+    const u = n.browsers.get(c);
+    u ? l.push(u) : a.push(`Browser "${c}" not found`);
+  }) : l = Array.from(n.browsers.values()), await Promise.all(
+    l.map(async (c) => {
+      try {
+        await c.browser.close(), n.browsers.delete(c.name), i.push(c);
+      } catch (u) {
+        a.push(
+          `Failed to close browser "${c.name}" (${c.browserType}): ${u instanceof Error ? u.message : "Unknown error"}`
+        );
+      }
+    })
+  ), {
+    closedBrowserInfos: i,
+    ...a.length > 0 && { errors: a }
+  };
+}
+function ws(r, t) {
+  r(
+    "playwright-browser-close",
+    {
+      title: "Close Browsers",
+      description: "Close browsers. Automatically closes all contexts and pages within the browsers",
+      inputSchema: St.shape
+    },
+    async (s, o) => {
+      const e = await gs(s, t, 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 xe = p.object({
+  browserName: p.string().optional().describe("Name of previously created browser, to use"),
+  browser: Se.optional().describe(
+    "Browser creation options JSON 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 xt(r, t, s) {
+  let o;
+  try {
+    o = xe.parse(r);
+  } catch (h) {
+    return {
+      error: B(h)
+    };
+  }
+  const { name: e, browserName: n, browser: i, isMobile: a, hasTouch: l, viewport: c } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const u = J(s.sessionId);
+  if (n && i)
+    return {
+      error: "Either browserName or browser must be provided, not both"
+    };
+  let f = !1, d;
+  if (n) {
+    if (d = u.browsers.get(n), !d)
+      return {
+        error: `Browser "${n}" not found`
+      };
+  } else if (i) {
+    const h = await yt(i, t, s);
+    if (h.error != null)
+      return {
+        error: h.error
+      };
+    d = h.browserInfo, f = !0;
+  } else
+    return {
+      error: "Either browserName or browser must be provided"
+    };
+  try {
+    const h = await d.browser.newContext({
+      isMobile: a,
+      hasTouch: l,
+      viewport: c
+    }), m = {
+      browserInfo: d,
+      name: e,
+      context: h,
+      pages: /* @__PURE__ */ new Map()
+    };
+    return d.contexts.set(e, m), {
+      browserInfoCreated: f,
+      browserInfo: d,
+      contextInfo: m
+    };
+  } catch (h) {
+    return {
+      error: `Failed to create context: ${h instanceof Error ? h.message : "Unknown error"} in browser "${d.name}" (${d.browserType})`
+    };
+  }
+}
+function ys(r, t) {
+  r(
+    "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: xe.shape
+    },
+    async (s, o) => {
+      const e = await xt(s, t, 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 $t = p.object({
+  browserName: p.string().optional().describe(
+    "Name of browser to list contexts from. If not specified, lists contexts from all browsers"
+  )
+});
+async function bs(r, t, s) {
+  let o;
+  try {
+    o = $t.parse(r);
+  } catch (a) {
+    return {
+      error: B(a)
+    };
+  }
+  const { browserName: e } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const n = J(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 l = Array.from(a.contexts.values());
+      l.length > 0 && i.push({
+        browserInfo: a,
+        contexts: l
+      });
+    }
+  return {
+    contextsByBrowser: i
+  };
+}
+function Ss(r, t) {
+  r(
+    "playwright-context-list",
+    {
+      title: "List Browser Contexts",
+      description: "List active browser contexts",
+      inputSchema: $t.shape
+    },
+    async (s, o) => {
+      const e = await bs(s, t, 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((l) => l.name).join(", ")}`
+      ).join(`
+`), n;
+    }
+  );
+}
+const It = 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 xs(r, t, s) {
+  let o;
+  try {
+    o = It.parse(r);
+  } catch (u) {
+    return {
+      error: B(u)
+    };
+  }
+  const { names: e, browserName: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = J(s.sessionId), a = [], l = [];
+  let c = [];
+  if (n) {
+    const u = i.browsers.get(n);
+    if (!u)
+      return {
+        error: `Browser "${n}" not found`
+      };
+    e ? e.forEach((f) => {
+      const d = u.contexts.get(f);
+      d ? c.push(d) : l.push(
+        `Context "${f}" not found in browser "${u.name}" (${u.browserType})`
+      );
+    }) : c = Array.from(u.contexts.values());
+  } else if (e)
+    for (const u of i.browsers.values())
+      e.forEach((f) => {
+        const d = u.contexts.get(f);
+        d ? c.push(d) : l.push(
+          `Context "${f}" not found in browser "${u.name}" (${u.browserType})`
+        );
+      });
+  else
+    for (const u of i.browsers.values())
+      c.push(...Array.from(u.contexts.values()));
+  return await Promise.all(
+    c.map(async (u) => {
+      try {
+        await u.context.close(), u.browserInfo.contexts.delete(u.name), a.push(u);
+      } catch (f) {
+        l.push(
+          `Failed to close context "${u.name}" (${u.browserInfo.name}) (${u.browserInfo.browserType}): ${f instanceof Error ? f.message : "Unknown error"}`
+        );
+      }
+    })
+  ), {
+    closedContextInfos: a,
+    ...l.length > 0 && { errors: l }
+  };
+}
+function $s(r, t) {
+  r(
+    "playwright-context-close",
+    {
+      title: "Close Browser Contexts",
+      description: "Close browser contexts. Automatically closes all pages within the contexts",
+      inputSchema: It.shape
+    },
+    async (s, o) => {
+      const e = await xs(s, t, 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 Is() {
+  class r {
+    prevId = 0;
+    objectToId = /* @__PURE__ */ new WeakMap();
+    idToObject = /* @__PURE__ */ new Map();
+    cleanupRegistry;
+    constructor() {
+      this.cleanupRegistry = new FinalizationRegistry((l) => {
+        this.idToObject.delete(l);
+      });
+    }
+    getOrCreateId(l) {
+      let c = this.objectToId.get(l);
+      return c == null && (c = ++this.prevId, this.objectToId.set(l, c), this.idToObject.set(c, new WeakRef(l)), this.cleanupRegistry.register(l, c)), c;
+    }
+    getObject(l) {
+      const c = this.idToObject.get(l);
+      if (!c)
+        return null;
+      const u = c.deref();
+      return u ?? (this.idToObject.delete(l), null);
+    }
+  }
+  function t(a, l, c) {
+    let u = null;
+    for (let f = 0, d = l.length; f < d; f++) {
+      const h = l[f], m = a(h), g = m == null ? null : t(a, m, c), y = c(h, g);
+      y != null && (u == null && (u = []), u.push(y));
+    }
+    return u;
+  }
+  function s(a) {
+    const { getId: l, getChilds: c, rootNodes: u, createSnapshotNode: f } = a, d = /* @__PURE__ */ new Map(), h = /* @__PURE__ */ new Map(), m = /* @__PURE__ */ new Map(), g = t(
+      c,
+      u,
+      (w, M) => {
+        const E = f(w, M);
+        if (w != null && E != null) {
+          const b = l(w);
+          d.set(b, E), h.set(E, b);
+        }
+        return E != null && M != null && m.set(
+          h.get(E),
+          M.map((b) => h.get(b))
+        ), E;
+      }
+    ), y = f(null, g);
+    if (y == null)
+      throw new Error("Impossible behavior: rootNode == null");
+    return d.set(null, y), g != null && m.set(
+      null,
+      g.map((w) => h.get(w))
+    ), {
+      idToNode: d,
+      idToChildIds: m
+    };
+  }
+  const o = (a) => a instanceof HTMLElement ? a.childNodes : null;
+  function e(a) {
+    return function(c, u) {
+      const f = u != null && u.length > 0;
+      let d = !1, h = null, m = null;
+      if (c instanceof HTMLElement) {
+        if (h = n.getOrCreateId(c), m = c.tagName.toLowerCase(), d = c.matches(a.cssSelector), !d && !f)
+          return null;
+      } else if (c == null)
+        h = null, m = null, d = !1;
+      else
+        return null;
+      return {
+        uid: h,
+        tagName: m,
+        isMatched: d
+      };
+    };
+  }
+  const n = new r();
+  function i(a) {
+    const l = e(a);
+    return s({
+      getId: (c) => n.getOrCreateId(c),
+      getChilds: o,
+      createSnapshotNode: l,
+      rootNodes: [window.document.documentElement]
+    });
+  }
+  window.__mcp_playwright_tool_tx4byhar35_createDomSnapshotTreeRawDom = i;
+}
+const Ms = `(function (){function __name(fn){return fn};${Is.toString()}; setupPageGlobals();})()`, $e = p.object({
+  contextName: p.string().optional().describe("Name of previously created context, to use"),
+  context: xe.optional().describe(
+    "Context creation options JSON to automatically create context"
+  ),
+  name: p.string().describe(
+    "Unique name for the page. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function Mt(r, t, s) {
+  let o;
+  try {
+    o = $e.parse(r);
+  } catch (f) {
+    return {
+      error: B(f)
+    };
+  }
+  const { name: e, contextName: n, context: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = J(s.sessionId);
+  if (n && i)
+    return {
+      error: "Either contextName or context must be provided, not both"
+    };
+  let l = !1, c = !1, u;
+  if (n) {
+    for (const f of a.browsers.values())
+      if (f.contexts.has(n)) {
+        u = f.contexts.get(n);
+        break;
+      }
+    if (!u)
+      return {
+        error: `Context "${n}" not found`
+      };
+  } else if (i) {
+    const f = await xt(i, t, s);
+    if (f.error != null)
+      return {
+        error: f.error
+      };
+    u = f.contextInfo, l = f.browserInfoCreated, c = !0;
+  } else
+    return {
+      error: "Either contextName or context must be provided"
+    };
+  try {
+    const f = await u.context.newPage();
+    await f.addInitScript(Ms), await f.goto("about:blank");
+    const d = {
+      contextInfo: u,
+      name: e,
+      page: f,
+      domSnapshots: /* @__PURE__ */ new Map()
+    };
+    return u.pages.set(e, d), {
+      browserInfoCreated: l,
+      contextInfoCreated: c,
+      pageInfo: d
+    };
+  } catch (f) {
+    return {
+      error: `Failed to create page: ${f instanceof Error ? f.message : "Unknown error"} in context "${u.name}" in browser "${u.browserInfo.name}" (${u.browserInfo.browserType})`
+    };
+  }
+}
+function Ts(r, t) {
+  r(
+    "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: $e.shape
+    },
+    async (s, o) => {
+      const e = await Mt(s, t, 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 Tt = 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 Cs(r, t, s) {
+  let o;
+  try {
+    o = Tt.parse(r);
+  } catch (l) {
+    return {
+      error: B(l)
+    };
+  }
+  const { contextName: e, browserName: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = J(s.sessionId), a = [];
+  if (n) {
+    const l = i.browsers.get(n);
+    if (!l)
+      return {
+        error: `Browser "${n}" not found`
+      };
+    if (e) {
+      const c = l.contexts.get(e);
+      if (!c)
+        return {
+          error: `Context "${e}" not found in browser "${l.name}" (${l.browserType})`
+        };
+      const u = Array.from(c.pages.values());
+      u.length > 0 && a.push({
+        contextInfo: c,
+        pages: u
+      });
+    } else
+      for (const c of l.contexts.values()) {
+        const u = Array.from(c.pages.values());
+        u.length > 0 && a.push({
+          contextInfo: c,
+          pages: u
+        });
+      }
+  } else if (e)
+    for (const l of i.browsers.values()) {
+      const c = l.contexts.get(e);
+      if (c) {
+        const u = Array.from(c.pages.values());
+        u.length > 0 && a.push({
+          contextInfo: c,
+          pages: u
+        });
+      }
+    }
+  else
+    for (const l of i.browsers.values())
+      for (const c of l.contexts.values()) {
+        const u = Array.from(c.pages.values());
+        u.length > 0 && a.push({
+          contextInfo: c,
+          pages: u
+        });
+      }
+  return {
+    pagesByContext: a
+  };
+}
+function vs(r, t) {
+  r(
+    "playwright-page-list",
+    {
+      title: "List Pages",
+      description: "List active pages",
+      inputSchema: Tt.shape
+    },
+    async (s, o) => {
+      const e = await Cs(s, t, 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((l) => l.name).join(", ")}`
+      ).join(`
+`), n;
+    }
+  );
+}
+const Ct = 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 Es(r, t, s) {
+  let o;
+  try {
+    o = Ct.parse(r);
+  } catch (f) {
+    return {
+      error: B(f)
+    };
+  }
+  const { names: e, contextName: n, browserName: i } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const a = J(s.sessionId), l = [], c = [];
+  let u = [];
+  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((h) => {
+        const m = d.pages.get(h);
+        m ? u.push(m) : c.push(
+          `Page "${h}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+        );
+      }) : u = Array.from(d.pages.values());
+    } else
+      for (const d of f.contexts.values())
+        e ? e.forEach((h) => {
+          const m = d.pages.get(h);
+          m ? u.push(m) : c.push(
+            `Page "${h}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+          );
+        }) : u.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((h) => {
+        const m = d.pages.get(h);
+        m ? u.push(m) : c.push(
+          `Page "${h}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+        );
+      }) : u.push(...Array.from(d.pages.values())));
+    }
+  else
+    for (const f of a.browsers.values())
+      for (const d of f.contexts.values())
+        e ? e.forEach((h) => {
+          const m = d.pages.get(h);
+          m ? u.push(m) : c.push(
+            `Page "${h}" not found in context "${d.name}" in browser "${f.name}" (${f.browserType})`
+          );
+        }) : u.push(...Array.from(d.pages.values()));
+  return await Promise.all(
+    u.map(async (f) => {
+      try {
+        await f.page.close(), f.contextInfo.pages.delete(f.name), l.push(
+          `${f.name} (${f.contextInfo.name}) (${f.contextInfo.browserInfo.name}) (${f.contextInfo.browserInfo.browserType})`
+        );
+      } catch (d) {
+        c.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: l,
+    ...c.length > 0 && { errors: c }
+  };
+}
+function Ns(r, t) {
+  r(
+    "playwright-page-close",
+    {
+      title: "Close Pages",
+      description: "Close pages",
+      inputSchema: Ct.shape
+    },
+    async (s, o) => {
+      const e = await Es(s, t, 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 vt = p.object({
+  pageName: p.string().optional().describe("Name of previously created page to navigate"),
+  page: $e.optional().describe(
+    "Page creation options JSON 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 ks(r, t, s) {
+  let o;
+  try {
+    o = vt.parse(r);
+  } catch (m) {
+    return {
+      error: B(m)
+    };
+  }
+  const { pageName: e, page: n, url: i, timeout: a, waitUntil: l } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const c = J(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either pageName or page must be provided, not both"
+    };
+  let u = !1, f = !1, d = !1, h;
+  if (e) {
+    for (const m of c.browsers.values()) {
+      for (const g of m.contexts.values())
+        if (g.pages.has(e)) {
+          h = g.pages.get(e);
+          break;
+        }
+      if (h) break;
+    }
+    if (!h)
+      return {
+        error: `Page "${e}" not found`
+      };
+  } else if (n) {
+    const m = await Mt(n, t, s);
+    if (m.error != null)
+      return {
+        error: m.error
+      };
+    h = m.pageInfo, u = m.browserInfoCreated, f = m.contextInfoCreated, d = !0;
+  } else
+    return {
+      error: "Either pageName or page must be provided"
+    };
+  try {
+    const m = await h.page.goto(i, {
+      timeout: a * 1e3,
+      waitUntil: l
+    });
+    return m ? {
+      browserInfoCreated: u,
+      contextInfoCreated: f,
+      pageInfoCreated: d,
+      pageInfo: h,
+      status: m.status()
+    } : {
+      browserInfoCreated: u,
+      contextInfoCreated: f,
+      pageInfoCreated: d,
+      pageInfo: h,
+      status: 200
+    };
+  } catch (m) {
+    return {
+      error: `Failed to navigate to "${i}": ${m instanceof Error ? m.message : "Unknown error"}`
+    };
+  }
+}
+function Os(r, t) {
+  r(
+    "playwright-page-goto",
+    {
+      title: "Navigate Page",
+      description: "Navigate page to URL. Use for manual browser interaction",
+      inputSchema: vt.shape
+    },
+    async (s, o) => {
+      const e = await ks(s, t, 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 Ie = 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 Et(r, t, s) {
+  let o;
+  try {
+    o = Ie.parse(r);
+  } catch (l) {
+    return {
+      error: B(l)
+    };
+  }
+  const { name: e, cssSelector: n } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const i = J(s.sessionId), a = {
+    name: e,
+    cssSelector: n
+  };
+  return i.domSnapshotQueries.set(e, a), {
+    snapshotQuery: a
+  };
+}
+function Ds(r, t) {
+  r(
+    "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: Ie.shape
+    },
+    async (s, o) => {
+      const e = await Et(s, t, 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 Rs(r) {
+  return function(s, o) {
+    let e, n = 0;
+    const i = o ? o.length : 0;
+    let a = 1, l = 0, c = 0, u, f;
+    if (o)
+      for (let m = 0; m < o.length; m++) {
+        const g = o[m];
+        n += g.countMatched, a += g.countTotal, l += g.tokens, c += g.tokensTotal;
+      }
+    s ? (u = s.uid, f = s.tagName, e = s.isMatched, e && (n += 1)) : (u = null, f = null, e = !1);
+    let d;
+    f ? d = {
+      indent: !0,
+      textOpen: `<${f} uid:${u}>`,
+      textClose: `</${f}>`
+    } : d = {
+      indent: !0,
+      textOpen: `<root uid:${u}>`,
+      textClose: "</root>"
+    };
+    const h = ht(d);
+    return c += h, {
+      uid: u,
+      tagName: f,
+      isMatched: e,
+      countMatched: n,
+      countChilds: i,
+      countTotal: a,
+      tokens: h,
+      tokensChilds: l,
+      tokensTotal: c,
+      text: d
+    };
+  };
+}
+function Fs(r, t) {
+  const s = ne(t), o = s.getChilds(s.root), e = ft({
+    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: Rs(),
+    rootNodes: o ?? []
+  });
+  return ne(e);
+}
+const Me = 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: Ie.optional().describe(
+    "DOM snapshot query creation options JSON to automatically create query"
+  ),
+  name: p.string().describe(
+    "Unique name for the DOM snapshot. Recommended format: kebab-case-1, kebab-case-2, ..."
+  )
+});
+async function Nt(r, t, s) {
+  let o;
+  try {
+    o = Me.parse(r);
+  } catch (d) {
+    return {
+      error: B(d)
+    };
+  }
+  const { pageName: e, queryName: n, query: i, name: a } = o;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const l = J(s.sessionId);
+  let c;
+  for (const d of l.browsers.values()) {
+    for (const h of d.contexts.values())
+      if (h.pages.has(e)) {
+        c = h.pages.get(e);
+        break;
+      }
+    if (c) break;
+  }
+  if (!c)
+    return {
+      error: `Page "${e}" not found`
+    };
+  if (n && i)
+    return {
+      error: "Either queryName or query must be provided, not both"
+    };
+  let u, f = !1;
+  if (n) {
+    const d = l.domSnapshotQueries.get(n);
+    if (!d)
+      return {
+        error: `DOM snapshot query "${n}" not found`
+      };
+    u = d;
+  } else if (i) {
+    const d = await Et(
+      i,
+      t,
+      s
+    );
+    if (d.error != null)
+      return {
+        error: d.error
+      };
+    u = d.snapshotQuery, f = !0;
+  } else
+    return {
+      error: "Either queryName or query must be provided"
+    };
+  try {
+    const d = await c.page.evaluate(
+      (y) => {
+        const w = window.__mcp_playwright_tool_tx4byhar35_createDomSnapshotTreeRawDom;
+        if (!w)
+          throw new Error("DOM snapshot global function not initialized");
+        const M = w(y);
+        return {
+          idToNode: Array.from(M.idToNode.entries()),
+          idToChildIds: Array.from(M.idToChildIds.entries())
+        };
+      },
+      u
+    ), h = {
+      idToNode: new Map(d.idToNode),
+      idToChildIds: new Map(d.idToChildIds)
+    }, m = Fs(u, h), g = {
+      name: a,
+      query: u,
+      tree: m
+    };
+    return c.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 Bs(r, t) {
+  r(
+    "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: Me.shape
+    },
+    async (s, o) => {
+      const e = await Nt(s, t, 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 Ls {
+  tokens = 20;
+  getReportText = (t) => ({
+    indent: !0,
+    textOpen: `[${t.indexRange[0]}-${t.indexRange[1]}] see more ${t.countMatched} matched ${t.tokensGrouped} tokens`,
+    textClose: null
+  });
+  add = (t, s, o) => t == null ? {
+    indexRange: [o, o],
+    countGrouped: 1,
+    countMatched: s.countMatched,
+    tokensGrouped: s.tokens
+  } : (t.indexRange[1] = o, t.countGrouped += 1, t.countMatched += s.countMatched, t.tokensGrouped += s.tokens, t);
+}
+const kt = p.object({
+  snapshotName: p.string().optional().describe("Name of previously created DOM snapshot, to use"),
+  snapshot: Me.optional().describe(
+    "DOM snapshot creation options JSON 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 Ps(r, t, s) {
+  let o;
+  try {
+    o = kt.parse(r);
+  } catch (g) {
+    return {
+      error: B(g)
+    };
+  }
+  const {
+    snapshotName: e,
+    snapshot: n,
+    childsIndexRange: i
+    // maxCountTotal,
+    // maxTokensTotal,
+    // maxCountGroup,
+    // maxTokensGroup,
+  } = o, a = 60, l = 1e3, c = 25, u = 900;
+  if (!s.sessionId)
+    return {
+      error: "Session ID is required"
+    };
+  const f = J(s.sessionId);
+  if (e && n)
+    return {
+      error: "Either snapshotName or snapshot must be provided, not both"
+    };
+  let d, h = !1, m = !1;
+  if (e) {
+    for (const g of f.browsers.values()) {
+      for (const y of g.contexts.values()) {
+        for (const w of y.pages.values())
+          if (w.domSnapshots.has(e)) {
+            d = w.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 Nt(
+      n,
+      t,
+      s
+    );
+    if (g.error != null)
+      return {
+        error: g.error
+      };
+    d = g.domSnapshot, h = g.queryCreated, m = !0;
+  } else
+    return {
+      error: "Either snapshotName or snapshot must be provided"
+    };
+  try {
+    const g = o.parentUid, y = pt({
+      tree: d.tree,
+      request: {
+        parentNodeId: g,
+        childsIndexRange: i,
+        limits: {
+          maxCountTotal: a,
+          maxTokensTotal: l,
+          maxCountGroup: c,
+          maxTokensGroup: u
+        }
+      },
+      indexRangeGroupStrategy: new Ls()
+    }), w = mt(y);
+    return {
+      domSnapshot: d,
+      queryCreated: h,
+      snapshotCreated: m,
+      parentUid: g,
+      childsIndexRange: i,
+      report: w
+    };
+  } catch (g) {
+    return {
+      error: `Failed to browse DOM snapshot: ${g instanceof Error ? g.message : "Unknown error"}`
+    };
+  }
+}
+function As(r, t) {
+  r(
+    "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: kt.shape
+    },
+    async (s, o) => {
+      const e = await Ps(s, t, 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, c = (e.parentUid ? e.domSnapshot.tree.getNode(e.parentUid) : e.domSnapshot.tree.root).countChilds;
+        n += `   Showing indexes: ${i}-${a} of ${c}
+`;
+      }
+      return n += `
+${e.report}`, n;
+    }
+  );
+}
+function zs(r, t) {
+  t.browserCreate && hs(r, t), t.browserList && ms(r, t), t.browserClose && ws(r, t), t.contextCreate && ys(r, t), t.contextList && Ss(r, t), t.contextClose && $s(r, t), t.pageCreate && Ts(r, t), t.pageList && vs(r, t), t.pageClose && Ns(r, t), t.pageGoto && Os(r, t), t.domSnapshotQueryCreate && Ds(r, t), t.domSnapshotCreate && Bs(r, t), t.domSnapshotBrowse && As(r, t), console.log("Playwright manager");
+}
+function Us(r) {
+  const { logFilePath: t } = r;
+  return async function(o, e, n, i) {
+    await se({
+      logFilePath: t,
+      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 Ot() {
+  return `mcp_${(/* @__PURE__ */ new Date()).toISOString().substring(0, 19).replace(/T/, "_").replace(/:/g, "-")}.log`;
+}
+function _s(r) {
+  const t = re(), s = qs();
+  return t.use(s), t;
+}
+function qs(r) {
+  const t = re.Router();
+  return t.use((s, o, e) => {
+    s.method === "OPTIONS" ? o.status(403).send("CORS forbidden") : e();
+  }), t.use(re.json()), t;
+}
+function Gs(r) {
+  const t = re.Router();
+  return t.use(Kt({ authToken: r.authToken })), t.all("/mcp", Vt(r)), t;
+}
+function js(r, t) {
+  return r.use(Us({ logFilePath: t.logFilePath })), new Promise((s, o) => {
+    let e;
+    const n = () => {
+      s(e);
+    };
+    try {
+      e = t.host ? r.listen(t.port ?? 0, t.host, n) : r.listen(t.port ?? 0, n), e.addListener("error", (i) => {
+        o(i);
+      });
+    } catch (i) {
+      o(i);
+    }
+  });
+}
+function Js(r, t) {
+  if (!r.address())
+    throw new Error("Server address is not available. Check your DNS and host configuration.");
+  const o = r.address().family, e = r.address().port;
+  let n = r.address().address;
+  n === "::" ? n = "localhost" : o === "IPv6" && (n = `[${n}]`);
+  const i = `http://${o === "IPv6" ? `[${n}]` : n}:${e}`;
+  return `Project Tools - MCP Server Started
+
+Server Name: ${t.name}
+Server Version: ${t.version}
+Server URL: ${i}/mcp
+SSE Endpoint: ${i}/sse
+
+Log File: ${R.resolve(t.logFilePath)}`;
+}
+function Ks(r, t) {
+  const s = R.join(t.logDir, Ot()), o = mr(r, {
+    logFilePath: s
+  });
+  t.tools.processManager && pr(o, t.tools.processManager), t.tools.fsManager && fs(o, t.tools.fsManager), t.tools.playwrightManager && zs(o, {
+    ...t.tools.playwrightManager
+  });
+}
+async function fo(r) {
+  const t = R.join(r.logDir, Ot()), s = _s(), o = Gs({
+    ...r,
+    logFilePath: t,
+    createMcpServer: () => {
+      const n = new Dt({
+        title: r.title,
+        name: r.name,
+        version: r.version
+      });
+      return Ks(n, r), n;
+    }
+  });
+  s.use(o);
+  const e = await js(s, {
+    host: r.host,
+    port: r.port,
+    logFilePath: t
+  });
+  return console.log(
+    Js(e, {
+      title: r.title,
+      name: r.name,
+      version: r.version,
+      logFilePath: t
+    })
+  ), e;
+}
+export {
+  uo as A,
+  co as S,
+  lo as a,
+  ao as b,
+  vr as p,
+  fo as s
+};