@flemist/mcp-project-tools 1.0.2 → 3.0.0

package/build/startMcpServer-B-xjEzCx.js

@@ -1,1692 +0,0 @@
-import express from "express";
-import * as cors from "cors";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { randomBytes } from "crypto";
-import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import * as fs from "fs";
-import fs__default from "fs";
-import * as path from "path";
-import path__default from "path";
-import { spawn } from "child_process";
-import { z } from "zod";
-import treeKill from "tree-kill";
-import { Pool, poolRunWait } from "@flemist/time-limits";
-import { priorityCreate } from "@flemist/priority-queue";
-import { useAbortController, combineAbortSignals } from "@flemist/async-utils";
-import os from "node:os";
-import picomatch from "picomatch";
-function createAuthMiddleware(options) {
-  const { authToken } = options;
-  return function authMiddleware(req, res, next) {
-    const token = req.query.token || req.headers.authorization?.replace("Bearer ", "");
-    if (token !== authToken) {
-      res.status(401).json({ error: "Unauthorized" });
-      return;
-    }
-    next();
-  };
-}
-async function logToFile(options) {
-  const { logFilePath, message, data } = options;
-  try {
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[TZ]/g, " ").trim();
-    const dataStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
-    const logData = `[${timestamp}] ${message}
-${dataStr}
-
-`;
-    await fs.promises.mkdir(path.dirname(logFilePath), { recursive: true });
-    await fs.promises.appendFile(logFilePath, logData);
-  } catch (err) {
-    console.error(`Failed to log "${message}":`, err);
-  }
-}
-const sessionsTransports = /* @__PURE__ */ new Map();
-function createStreamableHttpHandler(mcpServer, options) {
-  return async function streamableHttpHandler(req, res) {
-    const sessionId = req.headers["mcp-session-id"] || req.headers["x-session-id"] || req.query.token;
-    let transport;
-    if (req.method === "POST") {
-      await logToFile({
-        logFilePath: options.logFilePath,
-        message: "REQUEST",
-        data: req.body
-      });
-      if (sessionId && sessionsTransports.has(sessionId)) {
-        transport = sessionsTransports.get(sessionId);
-      } else {
-        transport = new StreamableHTTPServerTransport({
-          sessionIdGenerator: () => sessionId || randomBytes(16).toString("hex"),
-          onsessioninitialized: (id) => {
-            sessionsTransports.set(id, transport);
-            console.log(`Session initialized: ${id}`);
-          },
-          enableJsonResponse: options.enableJsonResponse || false
-        });
-        transport.onclose = () => {
-          if (transport.sessionId) {
-            sessionsTransports.delete(transport.sessionId);
-            console.log(`Session closed: ${transport.sessionId}`);
-          }
-        };
-        await mcpServer.connect(transport);
-        if (sessionId) {
-          sessionsTransports.set(sessionId, transport);
-        }
-      }
-      await transport.handleRequest(req, res, req.body);
-    } else if (req.method === "GET") {
-      if (sessionId && sessionsTransports.has(sessionId)) {
-        transport = sessionsTransports.get(sessionId);
-        await transport.handleRequest(req, res);
-      } else {
-        res.status(400).json({ error: "No valid session" });
-      }
-    } else {
-      res.status(405).json({ error: "Method not allowed" });
-    }
-  };
-}
-function extractCommand(options) {
-  const { commandLine } = options;
-  const match = commandLine.match(/^"([^"]+)"|^(\S+)/);
-  return match ? match[1] || match[2] : commandLine.split(" ")[0];
-}
-const processes = /* @__PURE__ */ new Map();
-let nextProcessId = 0;
-const MAX_PROCESSES = 10;
-const PROCESS_CLEANUP_TIME = 30 * 60 * 1e3;
-const OUTPUT_LIMIT = 2e3;
-const OUTPUT_THROTTLE_TIME = 500;
-const KILL_TIMEOUT = 5e3;
-function isCommandAllowed(options) {
-  const { commandLine, allowedCommands } = options;
-  const command = extractCommand({ commandLine });
-  return allowedCommands.some(
-    (allowed) => command === allowed || command.toLowerCase() === allowed.toLowerCase()
-  );
-}
-function getNextProcessId() {
-  return ++nextProcessId;
-}
-let autoKillInitialized = false;
-function autoKillChildProcesses() {
-  if (autoKillInitialized) {
-    return;
-  }
-  autoKillInitialized = true;
-  const kill = () => {
-    console.log("Auto-killing all child processes...");
-    for (const [id, process2] of Array.from(processes.entries())) {
-      if (process2.isRunning && process2.pid) {
-        try {
-          treeKill(process2.pid, "SIGKILL");
-        } catch (err) {
-          console.error(`Error killing process ${id}:`, err);
-        }
-      }
-    }
-    process.exit(0);
-  };
-  process.on("SIGINT", kill);
-  process.on("SIGTERM", kill);
-}
-function cleanupOldProcesses() {
-  const now = Date.now();
-  const toRemove = [];
-  for (const [id, process2] of Array.from(processes.entries())) {
-    if (!process2.isRunning && process2.endTime) {
-      const timeSinceEnd = now - process2.endTime.getTime();
-      if (timeSinceEnd > PROCESS_CLEANUP_TIME) {
-        toRemove.push(id);
-      }
-    }
-  }
-  for (const id of toRemove) {
-    processes.delete(id);
-  }
-}
-function updateProcessOutput(options) {
-  const { process: process2 } = options;
-  const now = Date.now();
-  const timeSinceLastUpdate = now - process2.lastOutputTime.getTime();
-  if (timeSinceLastUpdate >= OUTPUT_THROTTLE_TIME) {
-    process2.output += process2.localOutput;
-    process2.localOutput = "";
-    process2.lastOutputTime = new Date(now);
-    if (process2.output.length > OUTPUT_LIMIT) {
-      const removed = process2.output.length - OUTPUT_LIMIT;
-      const trimMessage = `
-... [${removed} characters trimmed] ...
-`;
-      const availableSpace = OUTPUT_LIMIT - trimMessage.length;
-      if (availableSpace > 0) {
-        const half = Math.floor(availableSpace / 2);
-        process2.output = process2.output.substring(0, half) + trimMessage + process2.output.substring(
-          process2.output.length - (availableSpace - half)
-        );
-      } else {
-        process2.output = process2.output.substring(0, OUTPUT_LIMIT);
-      }
-    }
-  }
-}
-function cropText(text, options) {
-  const limit = options.limit - 35;
-  if (text.length <= limit) return text;
-  const removedLength = text.length - limit;
-  const trimMessage = `
-... [${removedLength} characters trimmed] ...
-`;
-  const availableLength = limit - trimMessage.length;
-  if (availableLength <= 0) {
-    return text.substring(0, limit);
-  }
-  const half = Math.floor(availableLength / 2);
-  return text.substring(0, half) + trimMessage + text.substring(text.length - (availableLength - half));
-}
-const StatusSchema = z.object({
-  id: z.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: z.number().max(OUTPUT_LIMIT).default(OUTPUT_LIMIT).describe(
-    `Maximum number of output characters to return from the process. Output exceeding this limit will be cropped with beginning/end preserved. Maximum: ${OUTPUT_LIMIT} characters. Default: ${OUTPUT_LIMIT}.`
-  )
-});
-async function commandStatus(args, options) {
-  cleanupOldProcesses();
-  const parsedArgs = StatusSchema.parse(args);
-  const { id, outputLimit } = parsedArgs;
-  const process2 = processes.get(id);
-  if (!process2) {
-    return {
-      error: `Process ${id} 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.`
-    };
-  }
-  updateProcessOutput({ process: process2 });
-  const fullOutput = process2.output + process2.localOutput;
-  const formattedOutput = cropText(fullOutput, { limit: outputLimit });
-  process2.output = "";
-  process2.localOutput = "";
-  return {
-    id: process2.id,
-    cwd: path.relative(options.workingDir || "", process2.cwd),
-    commandLine: process2.commandLine,
-    pid: process2.pid,
-    startTime: process2.startTime.toISOString().replace(/[TZ]/g, " ").trim(),
-    endTime: process2.endTime?.toISOString().replace(/[TZ]/g, " ").trim(),
-    exitCode: process2.exitCode,
-    isRunning: process2.isRunning,
-    output: formattedOutput,
-    error: process2.error
-  };
-}
-function mcpRegisterToolProcessStatus(mcpRegisterTool, options) {
-  mcpRegisterTool(
-    "process-status",
-    {
-      title: "Get Host Machine Process Status",
-      description: "Get detailed status information about a process on the host machine, including execution details, captured output, exit code, and runtime status. Returns comprehensive process information for both running and completed processes. The output is cleared after retrieval to prevent duplication in subsequent calls. Useful for checking command execution results and monitoring process progress.",
-      inputSchema: StatusSchema.shape
-    },
-    async (args) => {
-      const result = await commandStatus(args, options);
-      const output = result.output || "";
-      delete result.output;
-      return `Method: process-status(${JSON.stringify(args)})
-${JSON.stringify(result, null, 2)}
-
-Output:
-${output}`.trim();
-    }
-  );
-}
-function killProcessById(pid) {
-  treeKill(pid, "SIGTERM", (err) => {
-    if (err && !err.message.includes("not found")) {
-      console.error(`Error sending SIGTERM to process ${pid}:`, err);
-    }
-  });
-  setTimeout(() => {
-    treeKill(pid, "SIGKILL", (err) => {
-      if (err && !err.message.includes("not found")) {
-        console.error(`Error sending SIGKILL to process ${pid}:`, err);
-      }
-    });
-  }, KILL_TIMEOUT);
-}
-const WaitSchema = z.object({
-  id: z.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: z.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: z.boolean().default(false).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: z.number().max(OUTPUT_LIMIT).default(OUTPUT_LIMIT).describe(
-    `Maximum number of output characters to capture and return from the process. Output exceeding this limit will be trimmed. Maximum: ${OUTPUT_LIMIT} characters. Default: ${OUTPUT_LIMIT}.`
-  )
-});
-async function commandWait(args, options) {
-  const parsedArgs = WaitSchema.parse(args);
-  const { id, waitTime, autoKill, outputLimit } = parsedArgs;
-  const process2 = processes.get(id);
-  if (!process2) {
-    return {
-      error: `Process ${id} 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 startWait = Date.now();
-  let waitTimeExceeded = false;
-  let autoKillExecuted = false;
-  if (waitTime !== void 0) {
-    const waitPromise = new Promise((resolve) => {
-      const checkInterval = setInterval(() => {
-        if (!process2.isRunning) {
-          clearInterval(checkInterval);
-          resolve();
-        } else if (Date.now() - startWait >= waitTime * 1e3) {
-          clearInterval(checkInterval);
-          waitTimeExceeded = true;
-          if (autoKill && process2.pid) {
-            killProcessById(process2.pid);
-            autoKillExecuted = true;
-          }
-          resolve();
-        }
-      }, 100);
-    });
-    await waitPromise;
-  }
-  const waitDuration = (Date.now() - startWait) / 1e3;
-  const status = await commandStatus(
-    { id, outputLimit },
-    { workingDir: options.workingDir }
-  );
-  return {
-    ...status,
-    waitDuration,
-    waitTimeExceeded,
-    autoKillExecuted
-  };
-}
-function mcpRegisterToolProcessWait(mcpRegisterTool, options) {
-  mcpRegisterTool(
-    "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. Useful for long-running commands like builds, installs, or tests where you need to wait for completion. Returns the final process status along with wait duration and timeout information. Can automatically terminate processes that exceed the wait time limit.",
-      inputSchema: WaitSchema.shape
-    },
-    async (args) => {
-      const result = await commandWait(args, options);
-      const output = result.output || "";
-      delete result.output;
-      return `Method: process-wait(${JSON.stringify(args)})
-${JSON.stringify(result, null, 2)}
-
-Output:
-${output}`.trim();
-    }
-  );
-}
-const RunSchema = z.object({
-  cwd: z.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: z.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: z.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: z.boolean().default(false).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: z.number().max(OUTPUT_LIMIT).default(OUTPUT_LIMIT).describe(
-    `Maximum number of output characters to capture and return from the process. Output exceeding this limit will be trimmed with beginning/end preserved and middle removed. Maximum: ${OUTPUT_LIMIT} characters. Default: ${OUTPUT_LIMIT}.`
-  )
-});
-async function commandRun(args, options) {
-  cleanupOldProcesses();
-  const parsedArgs = RunSchema.parse(args);
-  const { commandLine, waitTime, autoKill, outputLimit } = parsedArgs;
-  const { allowedCommands } = options;
-  const cwd = path.resolve(options.workingDir || "", parsedArgs.cwd || "");
-  if (!isCommandAllowed({ commandLine, allowedCommands })) {
-    return {
-      error: `Command not allowed: "${commandLine}". For security, only whitelisted commands can be executed on the host machine. Allowed commands: ${allowedCommands.join(", ")}. The command "${extractCommand({ commandLine })}" is not in the allowed list. To use this command, ask the user to add it to the allowedCommands configuration.`
-    };
-  }
-  const activeProcesses = Array.from(processes.values()).filter(
-    (o) => o.isRunning
-  );
-  if (activeProcesses.length >= MAX_PROCESSES) {
-    return {
-      error: `Maximum concurrent process limit reached (${MAX_PROCESSES} processes). Cannot start new process until existing processes complete. Use process-list to see active processes, or process-kill to terminate unnecessary processes.`
-    };
-  }
-  const id = getNextProcessId();
-  const processInfo = {
-    id,
-    cwd,
-    commandLine,
-    startTime: /* @__PURE__ */ new Date(),
-    isRunning: true,
-    output: "",
-    localOutput: "",
-    lastOutputTime: /* @__PURE__ */ new Date()
-  };
-  processes.set(id, processInfo);
-  try {
-    const child = spawn(commandLine, [], {
-      shell: true,
-      cwd,
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    processInfo.pid = child.pid;
-    const handleOutput = (data) => {
-      const text = data.toString();
-      processInfo.localOutput += text;
-      updateProcessOutput({ process: processInfo });
-      console.log(text);
-    };
-    child.stdout?.on("data", handleOutput);
-    child.stderr?.on("data", handleOutput);
-    child.on("close", (code) => {
-      processInfo.isRunning = false;
-      processInfo.endTime = /* @__PURE__ */ new Date();
-      processInfo.exitCode = code !== null ? code : void 0;
-      processInfo.output += processInfo.localOutput;
-      processInfo.localOutput = "";
-      if (processInfo.output.length > OUTPUT_LIMIT) {
-        const removed = processInfo.output.length - OUTPUT_LIMIT;
-        const trimMessage = `
-... [${removed} characters trimmed] ...
-`;
-        const availableSpace = OUTPUT_LIMIT - trimMessage.length;
-        if (availableSpace > 0) {
-          const half = Math.floor(availableSpace / 2);
-          processInfo.output = processInfo.output.substring(0, half) + trimMessage + processInfo.output.substring(
-            processInfo.output.length - (availableSpace - half)
-          );
-        } else {
-          processInfo.output = processInfo.output.substring(0, OUTPUT_LIMIT);
-        }
-      }
-      console.log(`Process ${id} (${commandLine}) exited with code ${code}`);
-    });
-    child.on("error", (err) => {
-      processInfo.isRunning = false;
-      processInfo.endTime = /* @__PURE__ */ new Date();
-      processInfo.error = err.message;
-      console.error(`Process ${id} error:`, err.message);
-    });
-    if (waitTime !== void 0) {
-      return commandWait(
-        { id, waitTime, autoKill, outputLimit },
-        { workingDir: options.workingDir }
-      );
-    }
-    return commandStatus(
-      { id, outputLimit },
-      { workingDir: options.workingDir }
-    );
-  } catch (err) {
-    processInfo.isRunning = false;
-    processInfo.endTime = /* @__PURE__ */ new Date();
-    processInfo.error = err instanceof Error ? err.message : "Unknown error";
-    return { error: processInfo.error };
-  }
-}
-function mcpRegisterToolProcessRun(mcpRegisterTool, options) {
-  mcpRegisterTool(
-    "process-run",
-    {
-      title: "Execute Command on Host Machine",
-      description: `Execute commands on the host machine. This tool allows running system commands that require host environment access, such as package managers (npm, pnpm, yarn), build tools, git operations, and other system utilities. Commands are executed in shell with full argument support. Returns process status and captured output. If waitTime is specified, waits for completion; otherwise returns immediately and you can check progress with process-wait or process-status. Security: Only whitelisted commands are allowed. Current allowed commands: ${options.allowedCommands.join(", ")}.`,
-      inputSchema: RunSchema.shape
-    },
-    async (args) => {
-      const result = await commandRun(args, options);
-      const output = result.output || "";
-      delete result.output;
-      return `Method: process-run(${JSON.stringify(args)})
-${JSON.stringify(result, null, 2)}
-
-Output:
-${output}`.trim();
-    }
-  );
-}
-const ListSchema$1 = z.object({
-  minOpenDateTime: z.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: z.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: z.boolean().default(false).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: z.array(z.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 commandList$1(args, options) {
-  cleanupOldProcesses();
-  const parsedArgs = ListSchema$1.parse(args);
-  const { minOpenDateTime, minCloseDateTime, activeOnly, fields } = parsedArgs;
-  let processList = Array.from(processes.values());
-  if (minOpenDateTime) {
-    const minDate = new Date(minOpenDateTime.replace(/[_\s]/g, "T"));
-    processList = processList.filter((p) => p.startTime >= minDate);
-  }
-  if (minCloseDateTime) {
-    const minDate = new Date(minCloseDateTime.replace(/[_\s]/g, "T"));
-    processList = processList.filter((p) => p.endTime && p.endTime >= minDate);
-  }
-  if (activeOnly) {
-    processList = processList.filter((p) => p.isRunning);
-  }
-  const result = processList.map((process2) => {
-    updateProcessOutput({ process: process2 });
-    let processData = {
-      id: process2.id,
-      cwd: path__default.relative(options.workingDir || "", process2.cwd),
-      commandLine: process2.commandLine,
-      pid: process2.pid,
-      startTime: process2.startTime.toISOString().replace(/[TZ]/g, " ").trim(),
-      endTime: process2.endTime?.toISOString().replace(/[TZ]/g, " ").trim(),
-      exitCode: process2.exitCode,
-      isRunning: process2.isRunning,
-      output: process2.output + process2.localOutput,
-      error: process2.error
-    };
-    if (fields) {
-      const filtered = {};
-      for (const field of fields) {
-        if (field in processData) {
-          filtered[field] = processData[field];
-        }
-      }
-      processData = filtered;
-    }
-    return processData;
-  });
-  return { processes: result };
-}
-function mcpRegisterToolProcessList(mcpRegisterTool, options) {
-  mcpRegisterTool(
-    "process-list",
-    {
-      title: "List Host Machine Processes",
-      description: "List all processes that have been executed on the host machine with filtering and field selection options. Shows both currently running and completed processes with their execution details, output, and status. Useful for monitoring command execution history, checking active processes, and retrieving results from completed commands. Supports datetime filtering to find processes within specific time ranges.",
-      inputSchema: ListSchema$1.shape
-    },
-    async (args) => {
-      const result = await commandList$1(args, options);
-      const output = result.output || "";
-      delete result.output;
-      return `Method: process-list(${JSON.stringify(args)})
-${JSON.stringify(result, null, 2)}
-
-Output:
-${output}`.trim();
-    }
-  );
-}
-const KillSchema = z.object({
-  id: z.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 commandKill(args) {
-  const parsedArgs = KillSchema.parse(args);
-  const { id } = parsedArgs;
-  const process2 = processes.get(id);
-  if (!process2) {
-    return {
-      error: `Process ${id} 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 (!process2.isRunning) {
-    return {
-      error: `Process ${id} 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 (!process2.pid) {
-    return {
-      error: `Process ${id} 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 {
-    killProcessById(process2.pid);
-    return { success: true, message: `Kill signal sent to process ${id}` };
-  } catch (err) {
-    return {
-      error: `Failed to terminate process ${id}: ${err instanceof Error ? err.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 mcpRegisterToolProcessKill(mcpRegisterTool) {
-  mcpRegisterTool(
-    "process-kill",
-    {
-      title: "Kill Host Machine Process",
-      description: "Forcibly terminate a running process on the host machine. Sends SIGTERM signal first for graceful shutdown, then SIGKILL after 5 seconds if the process is still running. Use this to stop runaway processes, hung commands, or long-running tasks that need to be cancelled. The process must be currently running to be terminated.",
-      inputSchema: KillSchema.shape
-    },
-    async (args) => {
-      const result = commandKill(args);
-      const output = result.output || "";
-      delete result.output;
-      return `Method: process-kill(${JSON.stringify(args)})
-${JSON.stringify(result, null, 2)}
-
-Output:
-${output}`.trim();
-    }
-  );
-}
-function mcpRegisterProcessManager(mcpRegisterTool, options) {
-  autoKillChildProcesses();
-  mcpRegisterToolProcessRun(mcpRegisterTool, {
-    workingDir: options.workingDir,
-    ...options.run
-  });
-  mcpRegisterToolProcessStatus(mcpRegisterTool, {
-    workingDir: options.workingDir
-  });
-  mcpRegisterToolProcessWait(mcpRegisterTool, {
-    workingDir: options.workingDir
-  });
-  mcpRegisterToolProcessList(mcpRegisterTool, {
-    workingDir: options.workingDir
-  });
-  mcpRegisterToolProcessKill(mcpRegisterTool);
-  console.log(
-    `Process manager:
-- Working directory: ${path.resolve(options.workingDir || "")}
-- Allowed commands: ${options.run.allowedCommands.join(", ")}
-`
-  );
-}
-function createMcpRegisterToolFunc(server, options) {
-  return function mcpRegisterTool(name, config, callback) {
-    const callbackNative = async (...args) => {
-      await logToFile({
-        logFilePath: options.logFilePath,
-        message: "REQUEST",
-        data: { name, args }
-      });
-      const result = await callback(...args);
-      await logToFile({
-        logFilePath: options.logFilePath,
-        message: "RESPONSE",
-        data: result
-      });
-      return {
-        content: [
-          {
-            type: "text",
-            text: result
-          }
-        ]
-      };
-    };
-    return server.registerTool(
-      name,
-      config,
-      callbackNative
-    );
-  };
-}
-function getDrive(path2) {
-  return path2.match(/^[/\\]?[^/\\]+/)[0];
-}
-function getFileId(path2, stat) {
-  return getDrive(path2) + "|" + stat.ino;
-}
-function pathResolve(_path) {
-  if (_path.endsWith(":")) {
-    _path += "/";
-  }
-  return path.resolve(_path);
-}
-const poolFs = new Pool(os.cpus().length);
-function addStats(totalStat, itemStat) {
-  totalStat.totalSize += itemStat.totalSize;
-  totalStat.maxFileDateModified = Math.max(
-    totalStat.maxFileDateModified,
-    itemStat.maxFileDateModified
-  );
-  totalStat.countFiles += itemStat.countFiles;
-  totalStat.countDirs += itemStat.countDirs;
-  totalStat.countLinks += itemStat.countLinks;
-}
-const walkPathHandleErrorDefault = function walkPathHandleErrorDefault2(err) {
-  if (err.code === "ENOENT") {
-    return true;
-  }
-  return false;
-};
-function _walkPaths(options) {
-  const items = options.paths;
-  if (!items || items.length === 0) {
-    return Promise.resolve({
-      totalSize: 0,
-      maxFileDateModified: 0,
-      countFiles: 0,
-      countDirs: 0,
-      countLinks: 0
-    });
-  }
-  const level = options.level ?? 0;
-  const walkedIds = options.walkedIds ?? /* @__PURE__ */ new Set();
-  const abortSignal = options.abortSignal;
-  const pool = options.pool ?? poolFs;
-  const handleError = options.handleError;
-  const priority = options.priority ?? priorityCreate(0);
-  const walkLinks = options.walkLinks ?? false;
-  const logOptions = options.log;
-  const handlePath = options.handlePath;
-  const matchPath = options.matchPath;
-  async function _handleError(err) {
-    if (handleError) {
-      if (await handleError(err)) {
-        return void 0;
-      }
-    }
-    if (walkPathHandleErrorDefault(err)) {
-      return void 0;
-    }
-    throw err;
-  }
-  function canLog(itemSize) {
-    if (!logOptions) {
-      return false;
-    }
-    if (logOptions.minTotalContentSize != null && itemSize < logOptions.minTotalContentSize) {
-      return false;
-    }
-    if (logOptions.maxNestedLevel != null && level > logOptions.maxNestedLevel) {
-      return false;
-    }
-    return true;
-  }
-  return useAbortController(async (_abortSignal) => {
-    const abortSignalCombined = combineAbortSignals(abortSignal, _abortSignal);
-    const totalStat = {
-      totalSize: 0,
-      maxFileDateModified: 0,
-      countFiles: 0,
-      countDirs: 0,
-      countLinks: 0
-    };
-    function logItem(itemPath, itemStat) {
-      if (canLog(itemStat.totalSize)) {
-        const sizeStr = itemStat.totalSize.toLocaleString("en-US").replace(/,/g, " ").padStart(19);
-        const message = `${sizeStr}: ${itemPath}`;
-        if (logOptions?.handleLog) {
-          logOptions.handleLog(message);
-        } else {
-          console.log(message);
-        }
-      }
-    }
-    async function _handlePath(itemPath, stat, itemStat, priority2) {
-      if (!handlePath) {
-        return true;
-      }
-      return await poolRunWait({
-        pool,
-        func: async () => {
-          try {
-            return await handlePath({
-              level,
-              path: itemPath,
-              stat,
-              itemStat,
-              totalStat,
-              abortSignal: abortSignalCombined
-            });
-          } catch (err) {
-            await _handleError(err);
-            return false;
-          }
-        },
-        count: 1,
-        priority: priority2,
-        abortSignal: abortSignalCombined
-      });
-    }
-    async function processItem(itemPath, index, matchResult) {
-      const stat = await poolRunWait({
-        pool,
-        func: () => fs__default.promises.lstat(itemPath).catch(_handleError),
-        count: 1,
-        priority: priorityCreate(index, priorityCreate(1, priority)),
-        abortSignal: abortSignalCombined
-      });
-      if (!stat) {
-        return null;
-      }
-      if (!matchResult && stat.isFile()) {
-        return null;
-      }
-      const itemId = getFileId(itemPath, stat);
-      if (walkedIds.has(itemId)) {
-        return null;
-      }
-      walkedIds.add(itemId);
-      let itemStat = {
-        totalSize: stat.size,
-        maxFileDateModified: stat.isDirectory() ? 0 : stat.mtimeMs,
-        countFiles: 0,
-        countDirs: 0,
-        countLinks: 0
-      };
-      const _priority = priorityCreate(
-        index,
-        priorityCreate(stat.isDirectory() ? 2 : 3, priority)
-      );
-      if (stat.isSymbolicLink()) {
-        if (walkLinks) {
-          const link = await poolRunWait({
-            pool,
-            func: () => fs__default.promises.readlink(itemPath).catch(_handleError).then((link2) => link2 ?? null),
-            count: 1,
-            priority: _priority,
-            abortSignal: abortSignalCombined
-          });
-          if (link) {
-            const linkedItemStat = await processItem(link, index, matchResult);
-            if (linkedItemStat) {
-              itemStat = linkedItemStat;
-            }
-          }
-        }
-        itemStat.countLinks = 1;
-        if (matchResult || itemStat.countFiles + itemStat.countDirs + itemStat.countLinks > 1) {
-          const shouldInclude = await _handlePath(
-            itemPath,
-            stat,
-            itemStat,
-            _priority
-          );
-          if (shouldInclude) {
-            addStats(totalStat, itemStat);
-            logItem(itemPath, itemStat);
-          }
-        }
-        return itemStat;
-      } else if (stat.isDirectory()) {
-        const dirItems = await poolRunWait({
-          pool,
-          func: () => fs__default.promises.readdir(itemPath).catch(_handleError),
-          count: 1,
-          priority,
-          abortSignal: abortSignalCombined
-        });
-        if (dirItems) {
-          for (let i = 0, len = dirItems.length; i < len; i++) {
-            dirItems[i] = path.join(itemPath, dirItems[i]);
-          }
-          itemStat = await _walkPaths({
-            ...options,
-            paths: dirItems,
-            abortSignal: abortSignalCombined,
-            priority: _priority,
-            level: level + 1,
-            walkedIds
-          });
-        }
-        itemStat.countDirs += 1;
-      } else if (stat.isFile()) {
-        itemStat.countFiles += 1;
-      }
-      if (matchResult || itemStat.countFiles + itemStat.countDirs + itemStat.countLinks > 1) {
-        const shouldInclude = await _handlePath(
-          itemPath,
-          stat,
-          itemStat,
-          _priority
-        );
-        if (shouldInclude) {
-          addStats(totalStat, itemStat);
-          logItem(itemPath, itemStat);
-        }
-      }
-      return itemStat;
-    }
-    const promises = [];
-    for (let i = 0, len = items.length; i < len; i++) {
-      const itemPath = pathResolve(items[i]);
-      const matchResult = matchPath ? matchPath(itemPath) : true;
-      if (matchResult === false) {
-        continue;
-      }
-      promises.push(processItem(itemPath, i, matchResult));
-    }
-    await Promise.all(promises);
-    return totalStat;
-  });
-}
-function walkPaths(options) {
-  return _walkPaths(options);
-}
-function globToRelative(glob, relativePath) {
-  if (!relativePath || relativePath === ".") {
-    return glob;
-  }
-  const exclude = glob.startsWith("^");
-  if (exclude) {
-    glob = glob.substring(1);
-  }
-  const negative = glob.startsWith("!");
-  if (negative) {
-    glob = glob.substring(1);
-  }
-  if (glob.startsWith("/")) {
-    if (relativePath.endsWith("/")) {
-      relativePath = relativePath.substring(0, relativePath.length - 1);
-    }
-    glob = relativePath + glob;
-  } else {
-    if (!relativePath.endsWith("/")) {
-      relativePath += "/";
-    }
-    if (glob.startsWith("./")) {
-      glob = relativePath + glob.substring(2);
-    } else if (glob.startsWith("../")) {
-      glob = relativePath + glob;
-    } else {
-      if (relativePath.startsWith("..")) {
-        relativePath = "";
-      }
-      if (glob.startsWith("**")) {
-        glob = relativePath + glob;
-      } else {
-        glob = relativePath + "**/" + glob;
-      }
-    }
-  }
-  glob = path.normalize(glob).replace(/\\/g, "/");
-  if (negative) {
-    glob = "!" + glob;
-  }
-  if (exclude) {
-    glob = "^" + glob;
-  }
-  return glob;
-}
-function globGitIgnoreToPicomatch(glob) {
-  const negative = glob.startsWith("!");
-  if (negative) {
-    glob = glob.substring(1);
-  }
-  if (glob.startsWith("/")) {
-    glob = glob.substring(1);
-  } else if (!glob.startsWith("**") && !glob.startsWith("../")) {
-    glob = `**/${glob}`;
-  }
-  if (negative) {
-    glob = "!" + glob;
-  }
-  return glob;
-}
-function globExclude(glob) {
-  return "^" + glob;
-}
-async function loadGlobsFromFile(filePath) {
-  const content = await fs.promises.readFile(filePath, "utf-8");
-  const lines = content.split("\n");
-  const globs = [];
-  lines.forEach((line) => {
-    line = line.trim();
-    if (!line || line.startsWith("#")) {
-      return;
-    }
-    globs.push(line);
-  });
-  return globs;
-}
-async function loadGlobs(options) {
-  const rootDir = options.rootDir ?? ".";
-  const result = [];
-  if (!options.globs?.length) {
-    return result;
-  }
-  const filesContainsGlobs = [];
-  options.globs.forEach((glob) => {
-    if (!glob.value) {
-      return;
-    }
-    if (glob.valueType === "file-contains-patterns") {
-      filesContainsGlobs.push(glob);
-    } else if (glob.valueType === "pattern") {
-      result.push(glob.exclude ? globExclude(glob.value) : glob.value);
-    }
-  });
-  if (filesContainsGlobs.length) {
-    await Promise.all(
-      filesContainsGlobs.map(async (glob) => {
-        await poolRunWait({
-          pool: poolFs,
-          count: 1,
-          func: async () => {
-            const filePath = path.resolve(rootDir, glob.value);
-            const globs = await loadGlobsFromFile(filePath);
-            const relativePath = path.relative(rootDir, path.dirname(filePath));
-            globs.forEach((globValue) => {
-              globValue = globGitIgnoreToPicomatch(globValue);
-              globValue = globToRelative(globValue, relativePath);
-              result.push(glob.exclude ? globExclude(globValue) : globValue);
-            });
-          }
-        });
-      })
-    );
-  }
-  return result;
-}
-function createMatchPath({
-  globs,
-  rootDir,
-  noCase
-}) {
-  const conditions = [];
-  globs.forEach((glob) => {
-    glob = glob.replace(/\\/g, "/").trim();
-    const exclude = glob.startsWith("^");
-    if (exclude) {
-      glob = glob.substring(1).trim();
-    }
-    const negative = glob.startsWith("!");
-    if (negative) {
-      glob = glob.substring(1).trim();
-    }
-    if (glob.startsWith("!") || glob.startsWith("^")) {
-      throw new Error(
-        `Invalid glob pattern: "${glob}". The syntax '${glob.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.`
-      );
-    }
-    if (glob.startsWith("/")) {
-      glob = "." + glob;
-    }
-    const globAbsolute = rootDir ? path.resolve(rootDir, glob).replace(/\\/g, "/") : glob;
-    if (!globAbsolute) {
-      return;
-    }
-    let matcher;
-    try {
-      matcher = picomatch(globAbsolute, {
-        nocase: noCase ?? false,
-        dot: true,
-        strictBrackets: true
-        // Validate bracket balance for patterns like "["
-      });
-    } catch (error) {
-      throw new Error(
-        `Invalid glob pattern: "${glob}". ${error instanceof Error ? error.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.`
-      );
-    }
-    conditions.push({
-      exclude,
-      negative,
-      debugInfo: globAbsolute,
-      match: matcher
-    });
-  });
-  return function matchPath(_path) {
-    _path = _path.replace(/\\/g, "/");
-    let include = null;
-    let exclude = false;
-    for (let i = 0, len = conditions.length; i < len; i++) {
-      const condition = conditions[i];
-      const conditionResult = condition.match(_path);
-      if (conditionResult) {
-        if (condition.exclude) {
-          exclude = !condition.negative;
-        } else {
-          include = !condition.negative;
-          exclude = false;
-        }
-      }
-    }
-    return exclude ? false : include;
-  };
-}
-async function getPathList(options) {
-  const rootDir = options.rootDir ?? ".";
-  const items = [];
-  const totals = {};
-  if (options.result.countFiles) {
-    totals.countFiles = 0;
-  }
-  if (options.result.size) {
-    totals.size = 0;
-  }
-  const globs = await loadGlobs({
-    rootDir,
-    globs: options.globs
-  });
-  await walkPaths({
-    paths: [rootDir],
-    walkLinks: true,
-    matchPath: createMatchPath({
-      globs,
-      rootDir,
-      noCase: true
-    }),
-    handlePath: async ({ path: itemPath, stat, itemStat }) => {
-      const relativePath = path.relative(rootDir, itemPath);
-      const isDir = stat.isDirectory();
-      const isFile = stat.isFile();
-      if (!isDir && !isFile) {
-        return true;
-      }
-      const _path = (relativePath || ".").replace(/\\/g, "/");
-      const type = isDir ? "dir" : "file";
-      const dateModified = isDir ? itemStat.maxFileDateModified || null : stat.mtimeMs;
-      const size = isDir ? itemStat.totalSize : stat.size;
-      const countFiles = isDir ? itemStat.countFiles : null;
-      const item = {
-        path: _path,
-        type
-      };
-      if (options.result.dateModified) {
-        item.dateModified = dateModified;
-      }
-      if (options.result.size) {
-        item.size = size;
-      }
-      if (options.result.countFiles) {
-        item.countFiles = countFiles;
-      }
-      if (options.dateModified && dateModified != null) {
-        const [minDate, maxDate] = options.dateModified;
-        if (minDate != null && dateModified < minDate || maxDate != null && dateModified > maxDate) {
-          return false;
-        }
-      }
-      if (options.totalSize && size != null) {
-        const [minSize, maxSize] = options.totalSize;
-        if (minSize != null && size < minSize || maxSize != null && size > maxSize) {
-          return false;
-        }
-      }
-      if (type === "file") {
-        totals.countFiles = (totals.countFiles ?? 0) + 1;
-      }
-      if (type === "file" && size != null) {
-        totals.size = (totals.size ?? 0) + size;
-      }
-      if (dateModified != null && (totals.dateModified == null || dateModified > totals.dateModified)) {
-        totals.dateModified = dateModified;
-      }
-      if (isDir && !options.result.dirs) {
-        return true;
-      }
-      if (isFile && !options.result.files) {
-        return true;
-      }
-      items.push(item);
-      return true;
-    }
-  });
-  return { items, totals };
-}
-const UNITS = ["B", "KB", "MB", "GB", "TB"];
-const UNIT_SIZE = 1024;
-function fileSizeFormat(bytes) {
-  if (bytes == null) return "-";
-  let value = bytes ?? 0;
-  let unitIndex = 0;
-  while (value >= UNIT_SIZE && unitIndex < UNITS.length - 1) {
-    value /= UNIT_SIZE;
-    unitIndex++;
-  }
-  const formatted = unitIndex === 0 ? value.toString() : value.toFixed(2);
-  return `${formatted}${UNITS[unitIndex]}`;
-}
-function timeAgoFormat(timestamp) {
-  const now = Date.now();
-  const diffMs = now - timestamp;
-  if (diffMs < 0) return "0s";
-  const diffSeconds = Math.floor(diffMs / 1e3);
-  const diffMinutes = Math.floor(diffSeconds / 60);
-  const diffHours = Math.floor(diffMinutes / 60);
-  const diffDays = Math.floor(diffHours / 24);
-  const diffWeeks = Math.floor(diffDays / 7);
-  const diffMonths = Math.floor(diffDays / 30);
-  const diffYears = Math.floor(diffDays / 365);
-  if (diffYears > 0) return `${diffYears}Y`;
-  if (diffMonths > 0) return `${diffMonths}M`;
-  if (diffWeeks > 0) return `${diffWeeks}w`;
-  if (diffDays > 0) return `${diffDays}d`;
-  if (diffHours > 0) return `${diffHours}h`;
-  if (diffMinutes > 0) return `${diffMinutes}m`;
-  return `${diffSeconds}s`;
-}
-function pathListSort(pathList, sort) {
-  if (!sort?.length) return pathList;
-  return [...pathList].sort((a, b) => {
-    for (let i = 0, len = sort.length; i < len; i++) {
-      const sortConfig = sort[i];
-      let aValue;
-      let bValue;
-      switch (sortConfig.field) {
-        case "type":
-          aValue = a.type;
-          bValue = b.type;
-          break;
-        case "path":
-          aValue = a.path;
-          bValue = b.path;
-          break;
-        case "dateModified":
-          aValue = a.dateModified;
-          bValue = b.dateModified;
-          break;
-        case "size":
-          aValue = a.size;
-          bValue = b.size;
-          break;
-        case "countFiles":
-          aValue = a.countFiles;
-          bValue = b.countFiles;
-          break;
-      }
-      if (aValue == null) {
-        if (bValue == null) {
-          continue;
-        }
-        return 1;
-      }
-      if (bValue == null) {
-        return -1;
-      }
-      const comparison = aValue > bValue ? 1 : aValue < bValue ? -1 : 0;
-      if (comparison !== 0) {
-        return sortConfig.desc ? -comparison : comparison;
-      }
-    }
-    return 0;
-  });
-}
-function pathListToString(pathListResult, options) {
-  const sortedList = pathListSort(pathListResult.items, options.sort ?? []);
-  const fields = options.fields && options.fields.length > 0 ? options.fields : [];
-  let result = "";
-  if (sortedList.length > 0 && fields.length > 0) {
-    for (let i = 0, len = fields.length; i < len; i++) {
-      const field = fields[i];
-      if (i > 0) result += " | ";
-      switch (field) {
-        case "dateModified":
-          result += "Time ago (s/m/h/d/w/M/Y)";
-          break;
-        case "size":
-          result += "Size (B/KB/MB/TB)";
-          break;
-        case "type":
-          result += "Type";
-          break;
-        case "path":
-          result += "Path";
-          break;
-        case "countFiles":
-          result += "Files Count";
-          break;
-      }
-    }
-    for (let i = 0, len = sortedList.length; i < len; i++) {
-      const item = sortedList[i];
-      result += "\n";
-      for (let j = 0, fieldsLen = fields.length; j < fieldsLen; j++) {
-        const field = fields[j];
-        if (j > 0) result += " | ";
-        switch (field) {
-          case "dateModified":
-            result += item.dateModified ? timeAgoFormat(item.dateModified) : "-";
-            break;
-          case "size":
-            result += fileSizeFormat(item.size);
-            break;
-          case "type":
-            result += item.type;
-            break;
-          case "path":
-            result += item.type === "dir" ? `${item.path}/` : item.path;
-            break;
-          case "countFiles":
-            if (item.type === "dir") {
-              result += item.countFiles != null ? item.countFiles.toString() : "-";
-            } else {
-              result += "-";
-            }
-            break;
-        }
-      }
-    }
-  }
-  {
-    if (result.length > 0) {
-      result += "\n---\n";
-    }
-    const totalSizeFormatted = fileSizeFormat(pathListResult.totals.size ?? 0);
-    const lastModifiedPart = pathListResult.totals.dateModified ? `, last modified ${timeAgoFormat(pathListResult.totals.dateModified)} ago` : "";
-    result += `Totals: ${pathListResult.totals.countFiles ?? 0} files in dirs, ${totalSizeFormatted}${lastModifiedPart}`;
-  }
-  return result;
-}
-const SERVER_NAME = "project-tools";
-const SERVER_VERSION = "1.0.0";
-const AUTH_TOKEN = "d00f70240703039df14c76176a055bce6b5484d2b552ba2c89820f03b8e5e60d";
-const MAX_FS_LIST_PATHS = 25e3;
-function parseTimeAgo(timeAgoStr) {
-  const match = timeAgoStr.match(
-    /^\s*(\d+(?:\.\d+)?)\s*([smhdwMY]|sec(onds?)?|min(utes?)?|hours?|days?|weeks?|months?|years?)\s*$/i
-  );
-  if (!match) {
-    throw new Error(
-      `Invalid time ago format: "${timeAgoStr}". 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 value = parseFloat(match[1]);
-  let unit = match[2];
-  if (unit !== "M") {
-    unit = unit.toLowerCase();
-    if (unit.startsWith("month")) {
-      unit = "M";
-    } else if (unit.length > 1) {
-      unit = unit[0];
-    }
-  }
-  switch (unit) {
-    case "s":
-      return value * 1e3;
-    case "m":
-      return value * 60 * 1e3;
-    case "h":
-      return value * 60 * 60 * 1e3;
-    case "d":
-      return value * 24 * 60 * 60 * 1e3;
-    case "w":
-      return value * 7 * 24 * 60 * 60 * 1e3;
-    case "M":
-      return value * 30 * 24 * 60 * 60 * 1e3;
-    case "y":
-      return value * 365 * 24 * 60 * 60 * 1e3;
-    default:
-      throw new Error(
-        `Unknown time unit: "${unit}". 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 parseSize(sizeStr) {
-  const match = sizeStr.match(/^\s*(\d+(?:\.\d+)?)\s*(B|KB|MB|GB|TB)\s*$/i);
-  if (!match) {
-    throw new Error(
-      `Invalid size format: "${sizeStr}". 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 value = parseFloat(match[1]);
-  const unit = match[2].toUpperCase();
-  switch (unit) {
-    case "B":
-      return value;
-    case "KB":
-      return value * 1024;
-    case "MB":
-      return value * 1024 * 1024;
-    case "GB":
-      return value * 1024 * 1024 * 1024;
-    case "TB":
-      return value * 1024 * 1024 * 1024 * 1024;
-    default:
-      throw new Error(
-        `Unknown size unit: "${unit}". 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 ListSchema = z.object({
-  rootDir: z.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: z.array(z.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: z.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: z.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: z.array(
-    z.object({
-      field: z.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: z.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: z.array(z.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: z.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: z.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: z.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: z.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 commandList(args, options) {
-  const parsedArgs = ListSchema.parse(args);
-  const {
-    globs,
-    showFiles,
-    showDirs,
-    sortBy,
-    minTimeAgo,
-    maxTimeAgo,
-    minTotalSize,
-    maxTotalSize
-  } = parsedArgs;
-  if (parsedArgs.fields && parsedArgs.fields.length > 0 && !parsedArgs.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 fields = parsedArgs.fields ? parsedArgs.fields.map((o) => {
-    if (o === "totalCountFiles") {
-      return "countFiles";
-    }
-    if (o === "lastModified") {
-      return "dateModified";
-    }
-    return o;
-  }) : [];
-  let sort = parsedArgs.sortBy?.map((o) => {
-    let field = o.field;
-    if (field === "totalCountFiles") {
-      field = "countFiles";
-    }
-    if (field === "lastModified") {
-      field = "dateModified";
-    }
-    return {
-      field,
-      desc: o.desc ?? false
-      // Default to ascending if not specified
-    };
-  }) || null;
-  if (!sort || sort.length === 0) {
-    sort = [{ field: "path", desc: false }];
-  }
-  const sortFields = sort?.map((o) => o.field) || [];
-  const rootDir = path.resolve(
-    options.workingDir || "",
-    parsedArgs.rootDir || ""
-  );
-  try {
-    try {
-      await fs.promises.access(rootDir, fs.constants.F_OK);
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        return {
-          error: `Directory does not exist: "${rootDir}". 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 err;
-    }
-    const userGlobs = globs && globs.length > 0 ? globs.map((g) => ({
-      value: g,
-      valueType: "pattern",
-      exclude: false
-    })) : [{ value: "**", valueType: "pattern", exclude: false }];
-    const excludeGlobs = options.globsExclude || [];
-    const globsConverted = [...userGlobs, ...excludeGlobs];
-    const result = {
-      files: showFiles ?? false,
-      dirs: showDirs ?? false,
-      dateModified: fields.includes("dateModified") || sortFields.includes("dateModified"),
-      size: fields.includes("size") || sortFields.includes("size"),
-      countFiles: fields.includes("countFiles") || sortFields.includes("countFiles")
-    };
-    let dateModifiedRange = null;
-    let totalSizeRange = null;
-    if (minTimeAgo || maxTimeAgo) {
-      try {
-        const now = Date.now();
-        const minDate = maxTimeAgo ? now - parseTimeAgo(maxTimeAgo) : null;
-        const maxDate = minTimeAgo ? now - parseTimeAgo(minTimeAgo) : null;
-        dateModifiedRange = [minDate, maxDate];
-      } catch (err) {
-        return {
-          error: err instanceof Error ? err.message : "Unknown error parsing time ago filter"
-        };
-      }
-    }
-    if (minTotalSize || maxTotalSize) {
-      try {
-        const minTotalSizeBytes = minTotalSize ? parseSize(minTotalSize) : null;
-        const maxTotalSizeBytes = maxTotalSize ? parseSize(maxTotalSize) : null;
-        totalSizeRange = [minTotalSizeBytes, maxTotalSizeBytes];
-      } catch (err) {
-        return {
-          error: err instanceof Error ? err.message : "Unknown error parsing size filter"
-        };
-      }
-    }
-    const pathListResult = await getPathList({
-      rootDir: rootDir || null,
-      globs: globsConverted,
-      result,
-      dateModified: dateModifiedRange,
-      totalSize: totalSizeRange
-    });
-    if (pathListResult.items.length > MAX_FS_LIST_PATHS) {
-      throw new Error(
-        `Number of paths (${pathListResult.items.length}) exceeds maximum allowed (${MAX_FS_LIST_PATHS}). Consider using more specific glob patterns or filters to reduce the result set.`
-      );
-    }
-    const formattedOutput = pathListToString(pathListResult, {
-      sort,
-      fields,
-      totals: true
-    });
-    return {
-      output: formattedOutput
-    };
-  } catch (err) {
-    return { error: err instanceof Error ? err.message : "Unknown error" };
-  }
-}
-function mcpRegisterToolFsList(mcpRegisterTool, options) {
-  mcpRegisterTool(
-    "fs-list",
-    {
-      title: "List Filesystem Paths",
-      description: `List files and directories with advanced filtering, sorting and formatting options. Features include: glob pattern filtering (gitignore-style syntax), date modification filters (modified within/before time ranges), size filters (binary units B/KB/MB/GB/TB), multi-field sorting (type/path/date/size/totalCountFiles), custom field selection, and formatted table output. Returns structured table text with pipe-separated columns. Use showFiles/showDirs to control what types are shown in report table. The totalCountFiles field shows total files count for directories. Supports complex queries like "all TypeScript files larger than 1KB modified in the last week".`,
-      inputSchema: ListSchema.shape
-    },
-    async (args) => {
-      const result = await commandList(args, options);
-      if (result.error) {
-        return `Method: fs-list(${JSON.stringify(args)})
-Error: ${result.error}`;
-      }
-      return `Method: fs-list(${JSON.stringify(args)})
-${result.output || JSON.stringify(result, null, 2)}`;
-    }
-  );
-}
-function mcpRegisterFsManager(mcpRegisterTool, options) {
-  mcpRegisterToolFsList(mcpRegisterTool, {
-    workingDir: options.workingDir || null,
-    ...options.list
-  });
-  console.log(
-    `File manager:
-- Working directory: ${path.resolve(options.workingDir || "")}
-`
-  );
-}
-function createErrorMiddleware(options) {
-  const { logFilePath } = options;
-  return async function errorErrorMiddleware(err, req, res, next) {
-    await logToFile({
-      logFilePath,
-      message: "ERROR",
-      data: {
-        request: {
-          url: req.url,
-          method: req.method,
-          headers: req.headers,
-          body: req.body
-        },
-        error: err.message,
-        stack: err.stack
-      }
-    });
-    res.status(500).send({
-      error: "Internal Server Error",
-      message: err.stack || err.message || err.toString()
-    });
-  };
-}
-function createLogFileName() {
-  const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(0, 19).replace(/T/, "_").replace(/:/g, "-");
-  return `mcp_${timestamp}.log`;
-}
-function createServer(options) {
-  const app = express();
-  const baseRouter = createBaseRouter();
-  app.use(baseRouter);
-  return app;
-}
-function createMcpServer(options) {
-  const mcpServer = new McpServer({
-    name: options.name,
-    version: options.version,
-    title: "Project Tools"
-  });
-  const mcpRouter = createMcpRouter(mcpServer, options);
-  return {
-    mcpServer,
-    mcpRouter
-  };
-}
-function createBaseRouter(options) {
-  const router = express.Router();
-  router.use(
-    cors.default({
-      origin: "*",
-      credentials: true,
-      allowedHeaders: [
-        "Content-Type",
-        "Authorization",
-        "X-Session-Id",
-        "mcp-session-id"
-      ],
-      exposedHeaders: ["mcp-session-id"]
-    })
-  );
-  router.use(express.json());
-  return router;
-}
-function createMcpRouter(mcpServer, options) {
-  const router = express.Router();
-  router.use(createAuthMiddleware({ authToken: options.authToken }));
-  router.all("/mcp", createStreamableHttpHandler(mcpServer, options));
-  return router;
-}
-function startServer(app, options) {
-  app.use(createErrorMiddleware({ logFilePath: options.logFilePath }));
-  return new Promise((resolve, reject) => {
-    let httpServer;
-    const callback = () => {
-      resolve(httpServer);
-    };
-    try {
-      httpServer = options.host ? app.listen(options.port ?? 0, options.host, callback) : app.listen(options.port ?? 0, callback);
-      httpServer.addListener("error", (err) => {
-        reject(err);
-      });
-    } catch (error) {
-      reject(error);
-    }
-  });
-}
-function getMcpServerDescription(httpServer, options) {
-  const family = httpServer.address().family;
-  const port = httpServer.address().port;
-  let host = httpServer.address().address;
-  if (host === "::") {
-    host = "localhost";
-  } else if (family === "IPv6") {
-    host = `[${host}]`;
-  }
-  const serverUrl = `http://${family === "IPv6" ? `[${host}]` : host}:${port}`;
-  return `Project Tools - MCP Server Started
-
-Server Name: ${options.name}
-Server Version: ${options.version}
-Server URL: ${serverUrl}/mcp
-SSE Endpoint: ${serverUrl}/sse
-
-Log File: ${path.resolve(options.logFilePath)}`;
-}
-async function startMcpServer(options) {
-  const logFilePath = path.join(options.logDir, createLogFileName());
-  const app = createServer();
-  const { mcpServer, mcpRouter } = createMcpServer({
-    ...options,
-    logFilePath
-  });
-  app.use(mcpRouter);
-  const mcpRegisterTool = createMcpRegisterToolFunc(mcpServer, {
-    logFilePath
-  });
-  if (options.tools.processManager) {
-    mcpRegisterProcessManager(mcpRegisterTool, options.tools?.processManager);
-  }
-  if (options.tools.fsManager) {
-    mcpRegisterFsManager(mcpRegisterTool, options.tools.fsManager);
-  }
-  const httpServer = await startServer(app, {
-    host: options.host,
-    port: options.port,
-    logFilePath
-  });
-  console.log(
-    getMcpServerDescription(httpServer, {
-      name: options.name,
-      version: options.version,
-      authToken: options.authToken,
-      logFilePath,
-      enableJsonResponse: options.enableJsonResponse
-    })
-  );
-  return httpServer;
-}
-export {
-  AUTH_TOKEN as A,
-  SERVER_VERSION as S,
-  SERVER_NAME as a,
-  startMcpServer as s
-};
-//# sourceMappingURL=startMcpServer-B-xjEzCx.js.map