@skyramp/mcp 0.0.63 → 0.0.64-rc.2

package/node_modules/playwright/lib/mcp/skyramp/traceRecordingBackend.js

@@ -0,0 +1,236 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var traceRecordingBackend_exports = {};
+__export(traceRecordingBackend_exports, {
+  TraceRecordingBackend: () => TraceRecordingBackend
+});
+module.exports = __toCommonJS(traceRecordingBackend_exports);
+var import_fs = __toESM(require("fs"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_browserServerBackend = require("../browser/browserServerBackend");
+var import_config = require("../browser/config");
+var import_browserContextFactory = require("../browser/browserContextFactory");
+var import_response = require("../browser/response");
+var import_log = require("../log");
+var import_skyRampExport = require("../test/skyRampExport");
+var import_exportTool = require("./exportTool");
+var import_types = require("./types");
+const traceDebug = (0, import_utilsBundle.debug)("pw:mcp:trace");
+class TraceRecordingBackend {
+  constructor(options) {
+    this._trackedActions = [];
+    this._initialized = false;
+    this._options = options || {};
+    this._outputDir = options?.outputDir || process.cwd();
+    this._tempDir = import_fs.default.mkdtempSync(import_path.default.join(import_os.default.tmpdir(), "skyramp-trace-"));
+    this._harPath = import_path.default.join(this._tempDir, "skyramp_network.har");
+  }
+  get trackedActions() {
+    return this._trackedActions;
+  }
+  async initialize(clientInfo) {
+    const headless = this._options.headless ?? (!!process.env.CI || import_os.default.platform() === "linux" && !process.env.DISPLAY);
+    const config = await (0, import_config.resolveConfig)({
+      browser: {
+        isolated: true,
+        launchOptions: { headless },
+        contextOptions: {
+          viewport: { width: 1280, height: 900 },
+          recordHar: { path: this._harPath, mode: "minimal" },
+          ignoreHTTPSErrors: true,
+          serviceWorkers: "block"
+        }
+      },
+      outputDir: this._tempDir,
+      timeouts: {
+        action: 15e3,
+        // 15s — modals and dynamic content need more time
+        navigation: 6e4
+      }
+    });
+    const factory = (0, import_browserContextFactory.contextFactory)(config);
+    this._browserBackend = new import_browserServerBackend.BrowserServerBackend(config, factory);
+    await this._browserBackend.initialize(clientInfo);
+    this._initialized = true;
+    traceDebug("TraceRecordingBackend initialized");
+  }
+  async listTools() {
+    const browserTools = await this._browserBackend.listTools();
+    return [...browserTools, (0, import_exportTool.exportZipMcpTool)()];
+  }
+  async callTool(name, args, progress) {
+    if (!this._initialized)
+      return { content: [{ type: "text", text: "### Error\nBackend not initialized. Call initialize() first." }], isError: true };
+    if (name === import_exportTool.exportZipSchema.name) {
+      const parsed = import_exportTool.exportZipSchema.inputSchema.parse(args || {});
+      try {
+        await this._browserBackend.callTool("browser_close", {});
+      } catch {
+      }
+      const handler = (0, import_exportTool.createExportZipHandler)({
+        trackedActions: this._trackedActions,
+        rootPath: this._outputDir,
+        harPath: this._harPath
+      });
+      return handler(parsed);
+    }
+    if (name === "browser_select_option") {
+      const result2 = await this._handleSelectOption(args || {});
+      return result2;
+    }
+    const timestampBeforeAction = Date.now();
+    const result = await this._browserBackend.callTool(name, args);
+    if (name === "browser_fill_form" && result.isError) {
+      const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
+      if (resultText.includes("not a <select> element") || resultText.includes("selectOption") && resultText.includes("Timeout")) {
+        const fields = args?.fields;
+        if (fields) {
+          const comboField = fields.find((f) => f.type === "combobox");
+          if (comboField) {
+            traceDebug("fill_form failed on combobox field, retrying with select fallback");
+            this._maybeTrackAction(name, args || {}, { content: result.content, isError: false }, timestampBeforeAction);
+            const selectResult = await this._handleSelectOption({
+              element: comboField.name || "dropdown",
+              ref: comboField.ref,
+              values: [comboField.value]
+            });
+            return selectResult;
+          }
+        }
+      }
+    }
+    this._maybeTrackAction(name, args || {}, result, timestampBeforeAction);
+    return result;
+  }
+  serverClosed() {
+    void this._autoExportAndClose().catch(import_log.logUnhandledError);
+  }
+  /**
+   * Handle browser_select_option with automatic fallback for custom dropdowns.
+   * 1. Try native selectOption first.
+   * 2. If it fails (not a <select> element), click the combobox to open it,
+   *    take a snapshot to find the options, then click the matching option.
+   */
+  async _handleSelectOption(args) {
+    const result = await this._browserBackend.callTool("browser_select_option", args);
+    const resultText = result.content?.[0]?.type === "text" ? result.content[0].text : "";
+    if (!result.isError) {
+      this._maybeTrackAction("browser_select_option", args, result);
+      return result;
+    }
+    const shouldFallback = resultText.includes("not a <select> element") || resultText.includes("selectOption") && resultText.includes("Timeout");
+    if (!shouldFallback)
+      return result;
+    traceDebug("selectOption failed on custom dropdown, trying combobox fallback");
+    const values = args.values || [];
+    if (!values.length)
+      return result;
+    const preSnapResult = await this._browserBackend.callTool("browser_snapshot", {});
+    if (preSnapResult.isError)
+      return preSnapResult;
+    const preSnapText = preSnapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+    const comboboxes = [...preSnapText.matchAll(/combobox[^\n]*\[ref=(\w+)\]/g)];
+    const clickableCombo = comboboxes.find((m) => m[0].includes("cursor=pointer"));
+    const comboRef = clickableCombo?.[1] || args.ref;
+    const clickResult = await this._browserBackend.callTool("browser_click", { element: args.element || "dropdown", ref: comboRef });
+    if (clickResult.isError)
+      return { content: [{ type: "text", text: `### Error
+Failed to open custom dropdown. The dropdown modal may not be visible yet. Try calling browser_snapshot first to check the page state, then ensure the form/modal is open before selecting an option.` }], isError: true };
+    this._maybeTrackAction("browser_click", { element: args.element || "dropdown", ref: comboRef }, clickResult);
+    const snapResult = await this._browserBackend.callTool("browser_snapshot", {});
+    if (snapResult.isError)
+      return snapResult;
+    const snapText = snapResult.content?.map((c) => c.type === "text" ? c.text : "").join("") || "";
+    const targetValue = values[0];
+    const candidates = [targetValue];
+    const lower = targetValue.toLowerCase();
+    if (lower === "true" || lower === "yes") candidates.push("Yes", "yes", "true", "True");
+    else if (lower === "false" || lower === "no") candidates.push("No", "no", "false", "False");
+    for (const candidate of candidates) {
+      const escaped = candidate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const pattern1 = new RegExp(`option\\s+"${escaped}"[^\\n]*\\[ref=(\\w+)\\]`, "i");
+      const match1 = snapText.match(pattern1);
+      if (match1) {
+        const optionClickResult = await this._browserBackend.callTool("browser_click", { element: `${candidate} option`, ref: match1[1] });
+        this._maybeTrackAction("browser_click", { element: `${candidate} option`, ref: match1[1] }, optionClickResult);
+        return optionClickResult;
+      }
+      const pattern2 = new RegExp(`option[^\\n]*\\[ref=(\\w+)\\][^\\n]*${escaped}`, "i");
+      const match2 = snapText.match(pattern2);
+      if (match2) {
+        const optionClickResult = await this._browserBackend.callTool("browser_click", { element: `${candidate} option`, ref: match2[1] });
+        this._maybeTrackAction("browser_click", { element: `${candidate} option`, ref: match2[1] }, optionClickResult);
+        return optionClickResult;
+      }
+    }
+    const optionLines = snapText.split("\n").filter((l) => l.includes("option")).join("\n");
+    return { content: [{ type: "text", text: `### Error
+Opened the custom dropdown but could not find a matching option for "${targetValue}". Available options:
+${optionLines}` }], isError: true };
+  }
+  _maybeTrackAction(toolName, args, result, timestamp) {
+    if (result.isError)
+      return;
+    if (toolName === "browser_press_key") {
+      const key = String(args.key || "").toLowerCase();
+      if (key.includes("control+") || key.includes("meta+"))
+        return;
+    }
+    const parsed = (0, import_response.parseResponse)(result);
+    const code = parsed?.code ?? "";
+    if (code || import_types.ARGS_ONLY_TOOLS.has(toolName)) {
+      this._trackedActions.push({
+        toolName,
+        args,
+        code,
+        timestamp: timestamp ?? Date.now()
+      });
+      traceDebug(`Tracked action: ${toolName} (total: ${this._trackedActions.length})`);
+    }
+  }
+  async _autoExportAndClose() {
+    if (this._trackedActions.length) {
+      try {
+        const outputZip = import_path.default.resolve(this._outputDir, "skyramp_export.zip");
+        const { jsonl: jsonlContent, actionCount } = (0, import_skyRampExport.buildJsonlContent)(this._trackedActions, "chromium", this._harPath);
+        await (0, import_skyRampExport.writeSkyrampZip)(outputZip, jsonlContent, this._harPath);
+        process.stderr.write(`[skyramp] Auto-exported ${actionCount} actions to ${outputZip}
+`);
+      } catch {
+      }
+    }
+    this._browserBackend?.serverClosed();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TraceRecordingBackend
+});

package/node_modules/playwright/lib/mcp/skyramp/types.js

@@ -0,0 +1,31 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+__export(types_exports, {
+  ARGS_ONLY_TOOLS: () => ARGS_ONLY_TOOLS,
+  TRACKABLE_TOOL_TYPES: () => TRACKABLE_TOOL_TYPES
+});
+module.exports = __toCommonJS(types_exports);
+const ARGS_ONLY_TOOLS = /* @__PURE__ */ new Set(["browser_navigate", "browser_press_key", "browser_navigate_back"]);
+const TRACKABLE_TOOL_TYPES = /* @__PURE__ */ new Set(["action", "input"]);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARGS_ONLY_TOOLS,
+  TRACKABLE_TOOL_TYPES
+});

package/node_modules/playwright/lib/mcp/terminal/cli.js

@@ -0,0 +1,296 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_child_process = require("child_process");
+var import_crypto = __toESM(require("crypto"));
+var import_fs = __toESM(require("fs"));
+var import_net = __toESM(require("net"));
+var import_os = __toESM(require("os"));
+var import_path = __toESM(require("path"));
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_socketConnection = require("./socketConnection");
+const debugCli = (0, import_utilsBundle.debug)("pw:cli");
+const packageJSON = require("../../../package.json");
+async function runCliCommand(sessionName, args) {
+  const session = await connectToDaemon(sessionName);
+  const result = await session.runCliCommand(args);
+  console.log(result);
+  session.dispose();
+}
+async function socketExists(socketPath) {
+  try {
+    const stat = await import_fs.default.promises.stat(socketPath);
+    if (stat?.isSocket())
+      return true;
+  } catch (e) {
+  }
+  return false;
+}
+class SocketSession {
+  constructor(connection) {
+    this._nextMessageId = 1;
+    this._callbacks = /* @__PURE__ */ new Map();
+    this._connection = connection;
+    this._connection.onmessage = (message) => this._onMessage(message);
+    this._connection.onclose = () => this.dispose();
+  }
+  async callTool(name, args) {
+    return this._send(name, args);
+  }
+  async runCliCommand(args) {
+    return await this._send("runCliCommand", { args });
+  }
+  async _send(method, params = {}) {
+    const messageId = this._nextMessageId++;
+    const message = {
+      id: messageId,
+      method,
+      params
+    };
+    await this._connection.send(message);
+    return new Promise((resolve, reject) => {
+      this._callbacks.set(messageId, { resolve, reject });
+    });
+  }
+  dispose() {
+    for (const callback of this._callbacks.values())
+      callback.reject(new Error("Disposed"));
+    this._callbacks.clear();
+    this._connection.close();
+  }
+  _onMessage(object) {
+    if (object.id && this._callbacks.has(object.id)) {
+      const callback = this._callbacks.get(object.id);
+      this._callbacks.delete(object.id);
+      if (object.error)
+        callback.reject(new Error(object.error));
+      else
+        callback.resolve(object.result);
+    } else if (object.id) {
+      throw new Error(`Unexpected message id: ${object.id}`);
+    } else {
+      throw new Error(`Unexpected message without id: ${JSON.stringify(object)}`);
+    }
+  }
+}
+function localCacheDir() {
+  if (process.platform === "linux")
+    return process.env.XDG_CACHE_HOME || import_path.default.join(import_os.default.homedir(), ".cache");
+  if (process.platform === "darwin")
+    return import_path.default.join(import_os.default.homedir(), "Library", "Caches");
+  if (process.platform === "win32")
+    return process.env.LOCALAPPDATA || import_path.default.join(import_os.default.homedir(), "AppData", "Local");
+  throw new Error("Unsupported platform: " + process.platform);
+}
+function playwrightCacheDir() {
+  return import_path.default.join(localCacheDir(), "ms-playwright");
+}
+function calculateSha1(buffer) {
+  const hash = import_crypto.default.createHash("sha1");
+  hash.update(buffer);
+  return hash.digest("hex");
+}
+function socketDirHash() {
+  return calculateSha1(__dirname);
+}
+function daemonSocketDir() {
+  return import_path.default.resolve(playwrightCacheDir(), "daemon", socketDirHash());
+}
+function daemonSocketPath(sessionName) {
+  const socketName = `${sessionName}.sock`;
+  if (import_os.default.platform() === "win32")
+    return `\\\\.\\pipe\\${socketDirHash()}-${socketName}`;
+  return import_path.default.resolve(daemonSocketDir(), socketName);
+}
+async function connectToDaemon(sessionName) {
+  const socketPath = daemonSocketPath(sessionName);
+  debugCli(`Connecting to daemon at ${socketPath}`);
+  if (await socketExists(socketPath)) {
+    debugCli(`Socket file exists, attempting to connect...`);
+    try {
+      return await connectToSocket(socketPath);
+    } catch (e) {
+      if (import_os.default.platform() !== "win32")
+        await import_fs.default.promises.unlink(socketPath).catch(() => {
+        });
+    }
+  }
+  const cliPath = import_path.default.join(__dirname, "../../../cli.js");
+  debugCli(`Will launch daemon process: ${cliPath}`);
+  const userDataDir = import_path.default.resolve(daemonSocketDir(), `${sessionName}-user-data`);
+  const child = (0, import_child_process.spawn)(process.execPath, [cliPath, "run-mcp-server", `--daemon=${socketPath}`, `--user-data-dir=${userDataDir}`], {
+    detached: true,
+    stdio: "ignore",
+    cwd: process.cwd()
+    // Will be used as root.
+  });
+  child.unref();
+  const maxRetries = 50;
+  const retryDelay = 100;
+  for (let i = 0; i < maxRetries; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    try {
+      return await connectToSocket(socketPath);
+    } catch (e) {
+      if (e.code !== "ENOENT")
+        throw e;
+      debugCli(`Retrying to connect to daemon at ${socketPath} (${i + 1}/${maxRetries})`);
+    }
+  }
+  throw new Error(`Failed to connect to daemon at ${socketPath} after ${maxRetries * retryDelay}ms`);
+}
+async function connectToSocket(socketPath) {
+  const socket = await new Promise((resolve, reject) => {
+    const socket2 = import_net.default.createConnection(socketPath, () => {
+      debugCli(`Connected to daemon at ${socketPath}`);
+      resolve(socket2);
+    });
+    socket2.on("error", reject);
+  });
+  return new SocketSession(new import_socketConnection.SocketConnection(socket));
+}
+function currentSessionPath() {
+  return import_path.default.resolve(daemonSocketDir(), "current-session");
+}
+async function getCurrentSession() {
+  try {
+    const session = await import_fs.default.promises.readFile(currentSessionPath(), "utf-8");
+    return session.trim() || "default";
+  } catch {
+    return "default";
+  }
+}
+async function setCurrentSession(sessionName) {
+  await import_fs.default.promises.mkdir(daemonSocketDir(), { recursive: true });
+  await import_fs.default.promises.writeFile(currentSessionPath(), sessionName);
+}
+async function canConnectToSocket(socketPath) {
+  return new Promise((resolve) => {
+    const socket = import_net.default.createConnection(socketPath, () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+async function listSessions() {
+  const dir = daemonSocketDir();
+  try {
+    const files = await import_fs.default.promises.readdir(dir);
+    const sessions = [];
+    for (const file of files) {
+      if (file.endsWith("-user-data")) {
+        const sessionName = file.slice(0, -"-user-data".length);
+        const socketPath = daemonSocketPath(sessionName);
+        const live = await canConnectToSocket(socketPath);
+        sessions.push({ name: sessionName, live });
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function resolveSessionName(args) {
+  if (args.session)
+    return args.session;
+  if (process.env.PLAYWRIGHT_CLI_SESSION)
+    return process.env.PLAYWRIGHT_CLI_SESSION;
+  return "default";
+}
+async function handleSessionCommand(args) {
+  const subcommand = args._[1];
+  if (!subcommand) {
+    const current = await getCurrentSession();
+    console.log(current);
+    return;
+  }
+  if (subcommand === "list") {
+    const sessions = await listSessions();
+    const current = await getCurrentSession();
+    console.log("Sessions:");
+    for (const session of sessions) {
+      const marker = session.name === current ? "->" : "  ";
+      const liveMarker = session.live ? " (live)" : "";
+      console.log(`${marker} ${session.name}${liveMarker}`);
+    }
+    if (sessions.length === 0)
+      console.log("   (no sessions)");
+    return;
+  }
+  if (subcommand === "set") {
+    const sessionName = args._[2];
+    if (!sessionName) {
+      console.error("Usage: playwright-cli session set <session-name>");
+      process.exit(1);
+    }
+    await setCurrentSession(sessionName);
+    console.log(`Current session set to: ${sessionName}`);
+    return;
+  }
+  console.error(`Unknown session subcommand: ${subcommand}`);
+  process.exit(1);
+}
+async function main() {
+  const argv = process.argv.slice(2);
+  const args = require("minimist")(argv);
+  const help = require("./help.json");
+  const commandName = args._[0];
+  if (args.version || args.v) {
+    console.log(packageJSON.version);
+    process.exit(0);
+  }
+  if (commandName === "session") {
+    await handleSessionCommand(args);
+    return;
+  }
+  const command = help.commands[commandName];
+  if (args.help || args.h) {
+    if (command) {
+      console.log(command);
+    } else {
+      console.log("playwright-cli - run playwright mcp commands from terminal\n");
+      console.log(help.global);
+    }
+    process.exit(0);
+  }
+  if (!command) {
+    console.error(`Unknown command: ${commandName}
+`);
+    console.log(help.global);
+    process.exit(1);
+  }
+  let sessionName = resolveSessionName(args);
+  if (sessionName === "default" && !args.session && !process.env.PLAYWRIGHT_CLI_SESSION)
+    sessionName = await getCurrentSession();
+  runCliCommand(sessionName, args).catch((e) => {
+    console.error(e.message);
+    process.exit(1);
+  });
+}
+main().catch((e) => {
+  console.error(e.message);
+  process.exit(1);
+});

package/node_modules/playwright/lib/mcp/terminal/command.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var command_exports = {};
+__export(command_exports, {
+  declareCommand: () => declareCommand,
+  parseCommand: () => parseCommand
+});
+module.exports = __toCommonJS(command_exports);
+function declareCommand(command) {
+  return command;
+}
+function parseCommand(command, args) {
+  const shape = command.args ? command.args.shape : {};
+  const argv = args["_"];
+  const options = command.options?.parse({ ...args, _: void 0 }) ?? {};
+  const argsObject = {};
+  let i = 0;
+  for (const name of Object.keys(shape))
+    argsObject[name] = argv[++i];
+  let parsedArgsObject = {};
+  try {
+    parsedArgsObject = command.args?.parse(argsObject) ?? {};
+  } catch (e) {
+    throw new Error(formatZodError(e));
+  }
+  const toolName = typeof command.toolName === "function" ? command.toolName(parsedArgsObject, options) : command.toolName;
+  const toolParams = command.toolParams(parsedArgsObject, options);
+  return { toolName, toolParams };
+}
+function formatZodError(error) {
+  const issue = error.issues[0];
+  if (issue.code === "invalid_type")
+    return `${issue.message} in <${issue.path.join(".")}>`;
+  return error.issues.map((i) => i.message).join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  declareCommand,
+  parseCommand
+});