@mcpc-tech/cli 0.1.50 → 0.1.52

package/index.mjs

@@ -509,7 +509,7 @@ var require_cross_spawn = __commonJS({
     var cp = __require("child_process");
     var parse2 = require_parse();
     var enoent = require_enoent();
-    function spawn2(command, args, options) {
+    function spawn3(command, args, options) {
       const parsed = parse2(command, args, options);
       const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
       enoent.hookChildProcess(spawned, parsed);
@@ -521,8 +521,8 @@ var require_cross_spawn = __commonJS({
       result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
       return result;
     }
-    module.exports = spawn2;
-    module.exports.spawn = spawn2;
+    module.exports = spawn3;
+    module.exports.spawn = spawn3;
     module.exports.sync = spawnSync;
     module.exports._parse = parse2;
     module.exports._enoent = enoent;
@@ -3030,6 +3030,7 @@ data:
   async handleGetRequest(req) {
     const acceptHeader = req.headers.get("accept");
     if (!acceptHeader?.includes("text/event-stream")) {
+      this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
       return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
     }
     const sessionError = this.validateSession(req);
@@ -3047,6 +3048,7 @@ data:
       }
     }
     if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
       return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
     }
     const encoder2 = new TextEncoder();
@@ -3086,6 +3088,7 @@ data:
    */
   async replayEvents(lastEventId) {
     if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
       return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
     }
     try {
@@ -3093,9 +3096,11 @@ data:
       if (this._eventStore.getStreamIdForEventId) {
         streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
         if (!streamId) {
+          this.onerror?.(new Error("Invalid event ID format"));
           return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
         }
         if (this._streamMapping.get(streamId) !== void 0) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
           return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
         }
       }
@@ -3161,7 +3166,8 @@ data:
 `;
       controller.enqueue(encoder2.encode(eventData));
       return true;
-    } catch {
+    } catch (error) {
+      this.onerror?.(error);
       return false;
     }
   }
@@ -3169,6 +3175,7 @@ data:
    * Handles unsupported requests (PUT, PATCH, etc.)
    */
   handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
     return new Response(JSON.stringify({
       jsonrpc: "2.0",
       error: {
@@ -3191,14 +3198,17 @@ data:
     try {
       const acceptHeader = req.headers.get("accept");
       if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
         return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
       }
       const ct = req.headers.get("content-type");
       if (!ct || !ct.includes("application/json")) {
+        this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
         return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
       }
       const requestInfo = {
-        headers: Object.fromEntries(req.headers.entries())
+        headers: Object.fromEntries(req.headers.entries()),
+        url: new URL(req.url)
       };
       let rawMessage;
       if (options?.parsedBody !== void 0) {
@@ -3207,6 +3217,7 @@ data:
         try {
           rawMessage = await req.json();
         } catch {
+          this.onerror?.(new Error("Parse error: Invalid JSON"));
           return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
         }
       }
@@ -3218,14 +3229,17 @@ data:
           messages = [JSONRPCMessageSchema.parse(rawMessage)];
         }
       } catch {
+        this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
         return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
       }
       const isInitializationRequest = messages.some(isInitializeRequest);
       if (isInitializationRequest) {
         if (this._initialized && this.sessionId !== void 0) {
+          this.onerror?.(new Error("Invalid Request: Server already initialized"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
         }
         if (messages.length > 1) {
+          this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
           return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
         }
         this.sessionId = this.sessionIdGenerator?.();
@@ -3351,13 +3365,16 @@ data:
       return void 0;
     }
     if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
       return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
     }
     const sessionId = req.headers.get("mcp-session-id");
     if (!sessionId) {
+      this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
       return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
     }
     if (sessionId !== this.sessionId) {
+      this.onerror?.(new Error("Session not found"));
       return this.createJsonErrorResponse(404, -32001, "Session not found");
     }
     return void 0;
@@ -3378,6 +3395,7 @@ data:
   validateProtocolVersion(req) {
     const protocolVersion = req.headers.get("mcp-protocol-version");
     if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
       return this.createJsonErrorResponse(400, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
     }
     return void 0;
@@ -3584,7 +3602,7 @@ var StreamableHTTPServerTransport = class {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/std__cli/parse_args.js
-var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.+?))?$/s;
+var FLAG_REGEXP = /^(?:-(?:(?<doubleDash>-)(?<negated>no-)?)?)(?<key>.+?)(?:=(?<value>.*))?$/s;
 var LETTER_REGEXP = /[A-Za-z]/;
 var NUMBER_REGEXP = /-?\d+(\.\d*)?(e-?\d+)?$/;
 var HYPHEN_REGEXP = /^(-|--)[^-]/;
@@ -3595,12 +3613,19 @@ var NON_WHITESPACE_REGEXP = /\S/;
 function isNumber(string3) {
   return NON_WHITESPACE_REGEXP.test(string3) && Number.isFinite(Number(string3));
 }
+function isConstructorOrProto(obj, key) {
+  return key === "constructor" && typeof obj[key] === "function" || key === "__proto__";
+}
 function setNested(object5, keys, value, collect = false) {
   keys = [
     ...keys
   ];
   const key = keys.pop();
-  keys.forEach((key2) => object5 = object5[key2] ??= {});
+  for (const k of keys) {
+    if (isConstructorOrProto(object5, k)) return;
+    object5 = object5[k] ??= {};
+  }
+  if (isConstructorOrProto(object5, key)) return;
   if (collect) {
     const v = object5[key];
     if (Array.isArray(v)) {
@@ -3731,7 +3756,7 @@ function parseArgs(args, options) {
       let key = groups.key;
       let value = groups.value;
       if (doubleDash2) {
-        if (value) {
+        if (value != null) {
           if (booleanSet.has(key)) value = parseBooleanString(value);
           setArgument(key, value, arg, true);
           continue;
@@ -3769,6 +3794,10 @@ function parseArgs(args, options) {
           setArgument(letter, next, arg, true);
           continue;
         }
+        if (next === "=") {
+          setArgument(letter, "", arg, true);
+          continue argsLoop;
+        }
         if (LETTER_REGEXP.test(letter)) {
           const groups2 = VALUE_REGEXP.exec(next)?.groups;
           if (groups2) {
@@ -3845,7 +3874,7 @@ function parseArgs(args, options) {
 import { mkdir, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join as join3, resolve as resolve4 } from "node:path";
-import process4 from "node:process";
+import process5 from "node:process";
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/large-result.js
 import { mkdtemp, writeFile } from "node:fs/promises";
@@ -4263,7 +4292,7 @@ Usage:
 - ${toolName}({ skill: "skill-name" }) - Load main SKILL.md content
 - ${toolName}({ skill: "skill-name", ref: "path/to/file" }) - Load reference file
 
-Note: For scripts/ and assets/, use appropriate tools directly.`;
+Note: For scripts/, use the bash tool with the script path to execute.`;
 }
 function createSkillsPlugin(options) {
   const { paths } = options;
@@ -4371,11 +4400,15 @@ Available skills: ${available.join(", ")}` : "\n\nNo skills available.";
           try {
             const content = await readFile(join2(meta.basePath, "SKILL.md"), "utf-8");
             const body = extractBody(content);
+            const skillPathInfo = `
+---
+Skill path: ${meta.basePath}
+`;
             return {
               content: [
                 {
                   type: "text",
-                  text: body
+                  text: body + skillPathInfo
                 }
               ]
             };
@@ -4402,6 +4435,152 @@ Available skills: ${available.join(", ")}` : "\n\nNo skills available.";
   };
 }
 
+// __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/plugins/bash.js
+import { spawn } from "node:child_process";
+import process2 from "node:process";
+var DEFAULT_MAX_BYTES = 1e5;
+var DEFAULT_MAX_LINES = 2e3;
+var DEFAULT_TIMEOUT_MS = 6e4;
+function truncateOutput(stdout, stderr, maxBytes = DEFAULT_MAX_BYTES, maxLines = DEFAULT_MAX_LINES) {
+  const fullOutput = (stderr ? `STDERR:
+${stderr}
+
+STDOUT:
+` : "") + stdout;
+  const lines = fullOutput.split("\n");
+  if (lines.length > maxLines) {
+    const truncatedLines = lines.slice(-maxLines);
+    return {
+      output: `[OUTPUT TRUNCATED] Showing last ${maxLines} lines of ${lines.length} total
+
+` + truncatedLines.join("\n"),
+      truncated: true
+    };
+  }
+  if (fullOutput.length > maxBytes) {
+    const truncatedBytes = fullOutput.slice(-maxBytes);
+    return {
+      output: `[OUTPUT TRUNCATED] Showing last ${maxBytes} bytes of ${fullOutput.length} total
+
+` + truncatedBytes,
+      truncated: true
+    };
+  }
+  return {
+    output: fullOutput,
+    truncated: false
+  };
+}
+function executeBash(command, cwd2, timeoutMs) {
+  return new Promise((resolve5) => {
+    const stdout = [];
+    const stderr = [];
+    const proc = spawn("bash", [
+      "-c",
+      command
+    ], {
+      cwd: cwd2,
+      stdio: [
+        "ignore",
+        "pipe",
+        "pipe"
+      ]
+    });
+    proc.stdout?.on("data", (data) => {
+      stdout.push(data.toString());
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr.push(data.toString());
+    });
+    proc.on("close", (code) => {
+      resolve5({
+        stdout: stdout.join(""),
+        stderr: stderr.join(""),
+        exitCode: code
+      });
+    });
+    proc.on("error", (err) => {
+      resolve5({
+        stdout: "",
+        stderr: err.message,
+        exitCode: null
+      });
+    });
+    setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve5({
+        stdout: stdout.join(""),
+        stderr: stderr.join("") + "\n\n[TIMEOUT] Command execution timed out",
+        exitCode: null
+      });
+    }, timeoutMs);
+  });
+}
+function createBashPlugin(options = {}) {
+  const { maxBytes, maxLines, timeoutMs } = {
+    maxBytes: DEFAULT_MAX_BYTES,
+    maxLines: DEFAULT_MAX_LINES,
+    timeoutMs: DEFAULT_TIMEOUT_MS,
+    ...options
+  };
+  let serverRef = null;
+  return {
+    name: "plugin-bash",
+    version: "1.0.0",
+    // Store server reference for tool registration
+    configureServer: (server) => {
+      serverRef = server;
+    },
+    // Register bash tool with agent name prefix
+    composeStart: (context2) => {
+      if (!serverRef) return;
+      const agentName = context2.serverName;
+      const toolName = `${agentName}__bash`;
+      serverRef.tool(toolName, "Execute a bash command and return its output.\n\nUse this for:\n- Running shell commands\n- Executing scripts\n- System operations\n\nNote: Output is truncated if too large.", {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The bash command to execute"
+          },
+          cwd: {
+            type: "string",
+            description: "Optional: Working directory for the command (defaults to current directory)"
+          }
+        },
+        required: [
+          "command"
+        ]
+      }, async (args) => {
+        const cwd2 = args.cwd || process2.cwd();
+        const result = await executeBash(args.command, cwd2, timeoutMs);
+        const { output, truncated } = truncateOutput(result.stdout, result.stderr, maxBytes, maxLines);
+        let finalOutput = output;
+        if (result.exitCode !== null && result.exitCode !== 0) {
+          finalOutput = `[EXIT CODE: ${result.exitCode}]
+` + finalOutput;
+        }
+        if (truncated) {
+          finalOutput += `
+
+[Note: Output was truncated]`;
+        }
+        return {
+          content: [
+            {
+              type: "text",
+              text: finalOutput
+            }
+          ],
+          isError: result.exitCode !== null && result.exitCode !== 0
+        };
+      }, {
+        internal: true
+      });
+    }
+  };
+}
+
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/defaults.js
 import { createCodeExecutionPlugin } from "@mcpc-tech/plugin-code-execution";
 
@@ -5246,12 +5425,29 @@ function writeFoldedLines(count) {
   if (count > 1) return "\n".repeat(count - 1);
   return "";
 }
+var Scanner = class {
+  source;
+  #length;
+  position = 0;
+  constructor(source) {
+    source += "\0";
+    this.source = source;
+    this.#length = source.length;
+  }
+  peek(offset = 0) {
+    return this.source.charCodeAt(this.position + offset);
+  }
+  next() {
+    this.position += 1;
+  }
+  eof() {
+    return this.position >= this.#length - 1;
+  }
+};
 var LoaderState = class {
-  input;
-  length;
+  #scanner;
   lineIndent = 0;
   lineStart = 0;
-  position = 0;
   line = 0;
   onWarning;
   allowDuplicateKeys;
@@ -5261,44 +5457,40 @@ var LoaderState = class {
   tagMap = /* @__PURE__ */ new Map();
   anchorMap = /* @__PURE__ */ new Map();
   constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
-    this.input = input;
+    this.#scanner = new Scanner(input);
     this.onWarning = onWarning;
     this.allowDuplicateKeys = allowDuplicateKeys;
     this.implicitTypes = schema.implicitTypes;
     this.typeMap = schema.typeMap;
-    this.length = input.length;
     this.readIndent();
   }
   skipWhitespaces() {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (isWhiteSpace(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
   skipComment() {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== SHARP) return;
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     while (ch !== 0 && !isEOL(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
   readIndent() {
-    let char = this.peek();
-    while (char === SPACE) {
+    let ch = this.#scanner.peek();
+    while (ch === SPACE) {
       this.lineIndent += 1;
-      char = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
   }
-  peek(offset = 0) {
-    return this.input.charCodeAt(this.position + offset);
-  }
-  next() {
-    this.position += 1;
-    return this.peek();
-  }
   #createError(message) {
-    const mark = markToString(this.input, this.position, this.line, this.position - this.lineStart);
+    const mark = markToString(this.#scanner.source, this.#scanner.position, this.line, this.#scanner.position - this.lineStart);
     return new SyntaxError(`${message} ${mark}`);
   }
   dispatchWarning(message) {
@@ -5343,7 +5535,7 @@ var LoaderState = class {
   }
   captureSegment(start, end, checkJson) {
     if (start < end) {
-      const result = this.input.slice(start, end);
+      const result = this.#scanner.source.slice(start, end);
       if (checkJson) {
         for (let position = 0; position < result.length; position++) {
           const character = result.charCodeAt(position);
@@ -5361,21 +5553,21 @@ var LoaderState = class {
     let detected = false;
     const result = [];
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch !== MINUS) {
         break;
       }
-      const following = this.peek(1);
+      const following = this.#scanner.peek(1);
       if (!isWhiteSpaceOrEOL(following)) {
         break;
       }
       detected = true;
-      this.position++;
+      this.#scanner.next();
       if (this.skipSeparationSpace(true, -1)) {
         if (this.lineIndent <= nodeIndent) {
           result.push(null);
-          ch = this.peek();
+          ch = this.#scanner.peek();
           continue;
         }
       }
@@ -5388,7 +5580,7 @@ var LoaderState = class {
       });
       if (newState) result.push(newState.result);
       this.skipSeparationSpace(true, -1);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) {
         throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
       } else if (this.lineIndent < nodeIndent) {
@@ -5444,7 +5636,7 @@ var LoaderState = class {
     } else {
       if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
         this.line = startLine || this.line;
-        this.position = startPos || this.position;
+        this.#scanner.position = startPos || this.#scanner.position;
         throw this.#createError("Cannot store mapping pair: duplicated key");
       }
       Object.defineProperty(result, keyNode, {
@@ -5458,37 +5650,37 @@ var LoaderState = class {
     return result;
   }
   readLineBreak() {
-    const ch = this.peek();
+    const ch = this.#scanner.peek();
     if (ch === LINE_FEED) {
-      this.position++;
+      this.#scanner.next();
     } else if (ch === CARRIAGE_RETURN) {
-      this.position++;
-      if (this.peek() === LINE_FEED) {
-        this.position++;
+      this.#scanner.next();
+      if (this.#scanner.peek() === LINE_FEED) {
+        this.#scanner.next();
       }
     } else {
       throw this.#createError("Cannot read line: line break not found");
     }
     this.line += 1;
-    this.lineStart = this.position;
+    this.lineStart = this.#scanner.position;
   }
   skipSeparationSpace(allowComments, checkIndent) {
     let lineBreaks = 0;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       this.skipWhitespaces();
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (allowComments) {
         this.skipComment();
-        ch = this.peek();
+        ch = this.#scanner.peek();
       }
       if (isEOL(ch)) {
         this.readLineBreak();
-        ch = this.peek();
+        ch = this.#scanner.peek();
         lineBreaks++;
         this.lineIndent = 0;
         this.readIndent();
-        ch = this.peek();
+        ch = this.#scanner.peek();
       } else {
         break;
       }
@@ -5499,9 +5691,9 @@ var LoaderState = class {
     return lineBreaks;
   }
   testDocumentSeparator() {
-    let ch = this.peek();
-    if ((ch === MINUS || ch === DOT) && ch === this.peek(1) && ch === this.peek(2)) {
-      ch = this.peek(3);
+    let ch = this.#scanner.peek();
+    if ((ch === MINUS || ch === DOT) && ch === this.#scanner.peek(1) && ch === this.#scanner.peek(2)) {
+      ch = this.#scanner.peek(3);
       if (ch === 0 || isWhiteSpaceOrEOL(ch)) {
         return true;
       }
@@ -5509,34 +5701,34 @@ var LoaderState = class {
     return false;
   }
   readPlainScalar(tag, anchor, nodeIndent, withinFlowCollection) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (isWhiteSpaceOrEOL(ch) || isFlowIndicator(ch) || ch === SHARP || ch === AMPERSAND || ch === ASTERISK || ch === EXCLAMATION || ch === VERTICAL_LINE || ch === GREATER_THAN || ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE || ch === PERCENT || ch === COMMERCIAL_AT || ch === GRAVE_ACCENT) {
       return;
     }
     let following;
     if (ch === QUESTION || ch === MINUS) {
-      following = this.peek(1);
+      following = this.#scanner.peek(1);
       if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
         return;
       }
     }
     let result = "";
-    let captureEnd = this.position;
-    let captureStart = this.position;
+    let captureEnd = this.#scanner.position;
+    let captureStart = this.#scanner.position;
     let hasPendingContent = false;
     let line = 0;
     while (ch !== 0) {
       if (ch === COLON) {
-        following = this.peek(1);
+        following = this.#scanner.peek(1);
         if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) {
           break;
         }
       } else if (ch === SHARP) {
-        const preceding = this.peek(-1);
+        const preceding = this.#scanner.peek(-1);
         if (isWhiteSpaceOrEOL(preceding)) {
           break;
         }
-      } else if (this.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) {
         break;
       } else if (isEOL(ch)) {
         line = this.line;
@@ -5545,10 +5737,10 @@ var LoaderState = class {
         this.skipSeparationSpace(false, -1);
         if (this.lineIndent >= nodeIndent) {
           hasPendingContent = true;
-          ch = this.peek();
+          ch = this.#scanner.peek();
           continue;
         } else {
-          this.position = captureEnd;
+          this.#scanner.position = captureEnd;
           this.line = line;
           this.lineStart = lineStart;
           this.lineIndent = lineIndent;
@@ -5559,13 +5751,14 @@ var LoaderState = class {
         const segment2 = this.captureSegment(captureStart, captureEnd, false);
         if (segment2) result += segment2;
         result += writeFoldedLines(this.line - line);
-        captureStart = captureEnd = this.position;
+        captureStart = captureEnd = this.#scanner.position;
         hasPendingContent = false;
       }
       if (!isWhiteSpace(ch)) {
-        captureEnd = this.position + 1;
+        captureEnd = this.#scanner.position + 1;
       }
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
     const segment = this.captureSegment(captureStart, captureEnd, false);
     if (segment) result += segment;
@@ -5578,22 +5771,23 @@ var LoaderState = class {
     };
   }
   readSingleQuotedScalar(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== SINGLE_QUOTE) return;
     let result = "";
-    this.position++;
-    let captureStart = this.position;
-    let captureEnd = this.position;
-    ch = this.peek();
+    this.#scanner.next();
+    let captureStart = this.#scanner.position;
+    let captureEnd = this.#scanner.position;
+    ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch === SINGLE_QUOTE) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         if (ch === SINGLE_QUOTE) {
-          captureStart = this.position;
-          this.position++;
-          captureEnd = this.position;
+          captureStart = this.#scanner.position;
+          this.#scanner.next();
+          captureEnd = this.#scanner.position;
         } else {
           if (anchor !== null) this.anchorMap.set(anchor, result);
           return {
@@ -5607,31 +5801,31 @@ var LoaderState = class {
         const segment = this.captureSegment(captureStart, captureEnd, true);
         if (segment) result += segment;
         result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
-        captureStart = captureEnd = this.position;
-      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        captureStart = captureEnd = this.#scanner.position;
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
         throw this.#createError("Unexpected end of the document within a single quoted scalar");
       } else {
-        this.position++;
-        captureEnd = this.position;
+        this.#scanner.next();
+        captureEnd = this.#scanner.position;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     throw this.#createError("Unexpected end of the stream within a single quoted scalar");
   }
   readDoubleQuotedScalar(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== DOUBLE_QUOTE) return;
     let result = "";
-    this.position++;
-    let captureEnd = this.position;
-    let captureStart = this.position;
+    this.#scanner.next();
+    let captureEnd = this.#scanner.position;
+    let captureStart = this.#scanner.position;
     let tmp;
-    ch = this.peek();
+    ch = this.#scanner.peek();
     while (ch !== 0) {
       if (ch === DOUBLE_QUOTE) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        this.position++;
+        this.#scanner.next();
         if (anchor !== null) this.anchorMap.set(anchor, result);
         return {
           tag,
@@ -5641,19 +5835,21 @@ var LoaderState = class {
         };
       }
       if (ch === BACKSLASH) {
-        const segment = this.captureSegment(captureStart, this.position, true);
+        const segment = this.captureSegment(captureStart, this.#scanner.position, true);
         if (segment) result += segment;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         if (isEOL(ch)) {
           this.skipSeparationSpace(false, nodeIndent);
         } else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
           result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
-          this.position++;
+          this.#scanner.next();
         } else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
           let hexLength = tmp;
           let hexResult = 0;
           for (; hexLength > 0; hexLength--) {
-            ch = this.next();
+            this.#scanner.next();
+            ch = this.#scanner.peek();
             if ((tmp = hexCharCodeToNumber(ch)) >= 0) {
               hexResult = (hexResult << 4) + tmp;
             } else {
@@ -5661,28 +5857,28 @@ var LoaderState = class {
             }
           }
           result += codepointToChar(hexResult);
-          this.position++;
+          this.#scanner.next();
         } else {
           throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
         }
-        captureStart = captureEnd = this.position;
+        captureStart = captureEnd = this.#scanner.position;
       } else if (isEOL(ch)) {
         const segment = this.captureSegment(captureStart, captureEnd, true);
         if (segment) result += segment;
         result += writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
-        captureStart = captureEnd = this.position;
-      } else if (this.position === this.lineStart && this.testDocumentSeparator()) {
+        captureStart = captureEnd = this.#scanner.position;
+      } else if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
         throw this.#createError("Unexpected end of the document within a double quoted scalar");
       } else {
-        this.position++;
-        captureEnd = this.position;
+        this.#scanner.next();
+        captureEnd = this.#scanner.position;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     throw this.#createError("Unexpected end of the stream within a double quoted scalar");
   }
   readFlowCollection(tag, anchor, nodeIndent) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     let terminator;
     let isMapping = true;
     let result = {};
@@ -5696,7 +5892,8 @@ var LoaderState = class {
       return;
     }
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     let readNext = true;
     let valueNode = null;
     let keyNode = null;
@@ -5708,9 +5905,9 @@ var LoaderState = class {
     const overridableKeys = /* @__PURE__ */ new Set();
     while (ch !== 0) {
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (ch === terminator) {
-        this.position++;
+        this.#scanner.next();
         const kind = isMapping ? "mapping" : "sequence";
         return {
           tag,
@@ -5725,10 +5922,10 @@ var LoaderState = class {
       keyTag = keyNode = valueNode = null;
       isPair = isExplicitPair = false;
       if (ch === QUESTION) {
-        following = this.peek(1);
+        following = this.#scanner.peek(1);
         if (isWhiteSpaceOrEOL(following)) {
           isPair = isExplicitPair = true;
-          this.position++;
+          this.#scanner.next();
           this.skipSeparationSpace(true, nodeIndent);
         }
       }
@@ -5744,10 +5941,11 @@ var LoaderState = class {
         keyNode = newState.result;
       }
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if ((isExplicitPair || this.line === line) && ch === COLON) {
         isPair = true;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
         this.skipSeparationSpace(true, nodeIndent);
         const newState2 = this.composeNode({
           parentIndent: nodeIndent,
@@ -5765,10 +5963,11 @@ var LoaderState = class {
         result.push(keyNode);
       }
       this.skipSeparationSpace(true, nodeIndent);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (ch === COMMA) {
         readNext = true;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } else {
         readNext = false;
       }
@@ -5784,7 +5983,7 @@ var LoaderState = class {
     let textIndent = nodeIndent;
     let emptyLines = 0;
     let atMoreIndented = false;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     let folding = false;
     if (ch === VERTICAL_LINE) {
       folding = false;
@@ -5796,7 +5995,8 @@ var LoaderState = class {
     let result = "";
     let tmp = 0;
     while (ch !== 0) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
       if (ch === PLUS || ch === MINUS) {
         if (CHOMPING_CLIP === chomping) {
           chomping = ch === PLUS ? CHOMPING_KEEP : CHOMPING_STRIP;
@@ -5819,15 +6019,16 @@ var LoaderState = class {
     if (isWhiteSpace(ch)) {
       this.skipWhitespaces();
       this.skipComment();
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     while (ch !== 0) {
       this.readLineBreak();
       this.lineIndent = 0;
-      ch = this.peek();
+      ch = this.#scanner.peek();
       while ((!detectedIndent || this.lineIndent < textIndent) && ch === SPACE) {
         this.lineIndent++;
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
       if (!detectedIndent && this.lineIndent > textIndent) {
         textIndent = this.lineIndent;
@@ -5866,11 +6067,12 @@ var LoaderState = class {
       didReadContent = true;
       detectedIndent = true;
       emptyLines = 0;
-      const captureStart = this.position;
+      const captureStart = this.#scanner.position;
       while (!isEOL(ch) && ch !== 0) {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      const segment = this.captureSegment(captureStart, this.position, false);
+      const segment = this.captureSegment(captureStart, this.#scanner.position, false);
       if (segment) result += segment;
     }
     if (anchor !== null) this.anchorMap.set(anchor, result);
@@ -5893,11 +6095,11 @@ var LoaderState = class {
     let atExplicitKey = false;
     let detected = false;
     if (anchor !== null) this.anchorMap.set(anchor, result);
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
-      const following = this.peek(1);
+      const following = this.#scanner.peek(1);
       line = this.line;
-      pos = this.position;
+      pos = this.#scanner.position;
       if ((ch === QUESTION || ch === COLON) && isWhiteSpaceOrEOL(following)) {
         if (ch === QUESTION) {
           if (atExplicitKey) {
@@ -5915,7 +6117,7 @@ var LoaderState = class {
         } else {
           throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
         }
-        this.position += 1;
+        this.#scanner.next();
         ch = following;
       } else {
         const newState = this.composeNode({
@@ -5926,11 +6128,12 @@ var LoaderState = class {
         });
         if (!newState) break;
         if (this.line === line) {
-          ch = this.peek();
+          ch = this.#scanner.peek();
           this.skipWhitespaces();
-          ch = this.peek();
+          ch = this.#scanner.peek();
           if (ch === COLON) {
-            ch = this.next();
+            this.#scanner.next();
+            ch = this.#scanner.peek();
             if (!isWhiteSpaceOrEOL(ch)) {
               throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
             }
@@ -5987,7 +6190,7 @@ var LoaderState = class {
           keyTag = keyNode = valueNode = null;
         }
         this.skipSeparationSpace(true, -1);
-        ch = this.peek();
+        ch = this.#scanner.peek();
       }
       if (this.lineIndent > nodeIndent && ch !== 0) {
         throw this.#createError("Cannot read block: bad indentation of a mapping entry");
@@ -6010,30 +6213,35 @@ var LoaderState = class {
     let isNamed = false;
     let tagHandle = "";
     let tagName;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== EXCLAMATION) return;
     if (tag !== null) {
       throw this.#createError("Cannot read tag property: duplication of a tag property");
     }
-    ch = this.next();
+    this.#scanner.next();
+    ch = this.#scanner.peek();
     if (ch === SMALLER_THAN) {
       isVerbatim = true;
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     } else if (ch === EXCLAMATION) {
       isNamed = true;
       tagHandle = "!!";
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     } else {
       tagHandle = "!";
     }
-    let position = this.position;
+    let position = this.#scanner.position;
     if (isVerbatim) {
       do {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } while (ch !== 0 && ch !== GREATER_THAN);
-      if (this.position < this.length) {
-        tagName = this.input.slice(position, this.position);
-        ch = this.next();
+      if (!this.#scanner.eof()) {
+        tagName = this.#scanner.source.slice(position, this.#scanner.position);
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       } else {
         throw this.#createError("Cannot read tag property: unexpected end of stream");
       }
@@ -6041,19 +6249,20 @@ var LoaderState = class {
       while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
         if (ch === EXCLAMATION) {
           if (!isNamed) {
-            tagHandle = this.input.slice(position - 1, this.position + 1);
+            tagHandle = this.#scanner.source.slice(position - 1, this.#scanner.position + 1);
             if (!PATTERN_TAG_HANDLE.test(tagHandle)) {
               throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
             }
             isNamed = true;
-            position = this.position + 1;
+            position = this.#scanner.position + 1;
           } else {
             throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
           }
         }
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      tagName = this.input.slice(position, this.position);
+      tagName = this.#scanner.source.slice(position, this.#scanner.position);
       if (PATTERN_FLOW_INDICATORS.test(tagName)) {
         throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
       }
@@ -6073,32 +6282,36 @@ var LoaderState = class {
     throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
   }
   readAnchorProperty(anchor) {
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     if (ch !== AMPERSAND) return;
     if (anchor !== null) {
       throw this.#createError("Cannot read anchor property: duplicate anchor property");
     }
-    ch = this.next();
-    const position = this.position;
+    this.#scanner.next();
+    ch = this.#scanner.peek();
+    const position = this.#scanner.position;
     while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
-    if (this.position === position) {
+    if (this.#scanner.position === position) {
       throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
     }
-    return this.input.slice(position, this.position);
+    return this.#scanner.source.slice(position, this.#scanner.position);
   }
   readAlias() {
-    if (this.peek() !== ASTERISK) return;
-    let ch = this.next();
-    const position = this.position;
+    if (this.#scanner.peek() !== ASTERISK) return;
+    this.#scanner.next();
+    let ch = this.#scanner.peek();
+    const position = this.#scanner.position;
     while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) {
-      ch = this.next();
+      this.#scanner.next();
+      ch = this.#scanner.peek();
     }
-    if (this.position === position) {
+    if (this.#scanner.position === position) {
       throw this.#createError("Cannot read alias: alias name must contain at least one character");
     }
-    const alias = this.input.slice(position, this.position);
+    const alias = this.#scanner.source.slice(position, this.#scanner.position);
     if (!this.anchorMap.has(alias)) {
       throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
     }
@@ -6181,7 +6394,7 @@ var LoaderState = class {
       const cond = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext;
       const flowIndent = cond ? parentIndent : parentIndent + 1;
       if (allowBlockCollections) {
-        const blockIndent = this.position - this.lineStart;
+        const blockIndent = this.#scanner.position - this.lineStart;
         const blockSequenceState = this.readBlockSequence(tag, anchor, blockIndent);
         if (blockSequenceState) return this.resolveTag(blockSequenceState);
         const blockMappingState = this.readBlockMapping(tag, anchor, blockIndent, flowIndent);
@@ -6215,7 +6428,7 @@ var LoaderState = class {
         return this.resolveTag(plainScalarState);
       }
     } else if (indentStatus === 0 && CONTEXT_BLOCK_OUT === nodeContext && allowBlockCollections) {
-      const blockIndent = this.position - this.lineStart;
+      const blockIndent = this.#scanner.position - this.lineStart;
       const newState2 = this.readBlockSequence(tag, anchor, blockIndent);
       if (newState2) return this.resolveTag(newState2);
     }
@@ -6230,20 +6443,22 @@ var LoaderState = class {
   readDirectives() {
     let hasDirectives = false;
     let version = null;
-    let ch = this.peek();
+    let ch = this.#scanner.peek();
     while (ch !== 0) {
       this.skipSeparationSpace(true, -1);
-      ch = this.peek();
+      ch = this.#scanner.peek();
       if (this.lineIndent > 0 || ch !== PERCENT) {
         break;
       }
       hasDirectives = true;
-      ch = this.next();
-      let position = this.position;
+      this.#scanner.next();
+      ch = this.#scanner.peek();
+      let position = this.#scanner.position;
       while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
-        ch = this.next();
+        this.#scanner.next();
+        ch = this.#scanner.peek();
       }
-      const directiveName = this.input.slice(position, this.position);
+      const directiveName = this.#scanner.source.slice(position, this.#scanner.position);
       const directiveArgs = [];
       if (directiveName.length < 1) {
         throw this.#createError("Cannot read document: directive name length must be greater than zero");
@@ -6251,13 +6466,14 @@ var LoaderState = class {
       while (ch !== 0) {
         this.skipWhitespaces();
         this.skipComment();
-        ch = this.peek();
+        ch = this.#scanner.peek();
         if (isEOL(ch)) break;
-        position = this.position;
+        position = this.#scanner.position;
         while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
-          ch = this.next();
+          this.#scanner.next();
+          ch = this.#scanner.peek();
         }
-        directiveArgs.push(this.input.slice(position, this.position));
+        directiveArgs.push(this.#scanner.source.slice(position, this.#scanner.position));
       }
       if (ch !== 0) this.readLineBreak();
       switch (directiveName) {
@@ -6274,20 +6490,20 @@ var LoaderState = class {
           this.dispatchWarning(`unknown document directive "${directiveName}"`);
           break;
       }
-      ch = this.peek();
+      ch = this.#scanner.peek();
     }
     return hasDirectives;
   }
   readDocument() {
-    const documentStart = this.position;
+    const documentStart = this.#scanner.position;
     this.checkLineBreaks = false;
     this.tagMap = /* @__PURE__ */ new Map();
     this.anchorMap = /* @__PURE__ */ new Map();
     const hasDirectives = this.readDirectives();
     this.skipSeparationSpace(true, -1);
     let result = null;
-    if (this.lineIndent === 0 && this.peek() === MINUS && this.peek(1) === MINUS && this.peek(2) === MINUS) {
-      this.position += 3;
+    if (this.lineIndent === 0 && this.#scanner.peek() === MINUS && this.#scanner.peek(1) === MINUS && this.#scanner.peek(2) === MINUS) {
+      this.#scanner.position += 3;
       this.skipSeparationSpace(true, -1);
     } else if (hasDirectives) {
       throw this.#createError("Cannot read document: directives end mark is expected");
@@ -6300,21 +6516,21 @@ var LoaderState = class {
     });
     if (newState) result = newState.result;
     this.skipSeparationSpace(true, -1);
-    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.input.slice(documentStart, this.position))) {
+    if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.#scanner.source.slice(documentStart, this.#scanner.position))) {
       this.dispatchWarning("non-ASCII line breaks are interpreted as content");
     }
-    if (this.position === this.lineStart && this.testDocumentSeparator()) {
-      if (this.peek() === DOT) {
-        this.position += 3;
+    if (this.#scanner.position === this.lineStart && this.testDocumentSeparator()) {
+      if (this.#scanner.peek() === DOT) {
+        this.#scanner.position += 3;
         this.skipSeparationSpace(true, -1);
       }
-    } else if (this.position < this.length - 1) {
+    } else if (!this.#scanner.eof()) {
       throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
     }
     return result;
   }
   *readDocuments() {
-    while (this.position < this.length - 1) {
+    while (!this.#scanner.eof()) {
       yield this.readDocument();
     }
   }
@@ -6327,7 +6543,6 @@ function sanitizeInput(input) {
     if (!isEOL(input.charCodeAt(input.length - 1))) input += "\n";
     if (input.charCodeAt(0) === 65279) input = input.slice(1);
   }
-  input += "\0";
   return input;
 }
 function parse(content, options = {}) {
@@ -6345,10 +6560,10 @@ function parse(content, options = {}) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__plugin-markdown-loader/src/markdown-loader.js
-import process2 from "node:process";
+import process3 from "node:process";
 function replaceEnvVars(str2) {
   return str2.replace(/\$([A-Za-z_][A-Za-z0-9_]*)(?!\s*\()/g, (match, varName) => {
-    const value = process2.env[varName];
+    const value = process3.env[varName];
     if (value !== void 0) {
       return value;
     }
@@ -6447,18 +6662,19 @@ var defaultPlugin = markdownLoaderPlugin();
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/defaults.js
 import { resolve as resolve3 } from "node:path";
-import process3 from "node:process";
+import process4 from "node:process";
 var DEFAULT_SKILLS_PATHS = [
   ".agent/skills"
 ];
 var DEFAULT_CODE_EXECUTION_TIMEOUT = 3e5;
 function getGlobalPlugins(skillsPaths) {
-  const resolvedPaths = skillsPaths.map((p2) => resolve3(process3.cwd(), p2));
+  const resolvedPaths = skillsPaths.map((p2) => resolve3(process4.cwd(), p2));
   return [
     markdownLoaderPlugin(),
     createSkillsPlugin({
       paths: resolvedPaths
-    })
+    }),
+    createBashPlugin()
   ];
 }
 function getAgentPlugins() {
@@ -6487,7 +6703,7 @@ function getDefaultAgents() {
 }
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-var CLI_VERSION = "0.1.44";
+var CLI_VERSION = "0.1.52";
 function extractServerName(command, commandArgs) {
   for (const arg of commandArgs) {
     if (!arg.startsWith("-")) {
@@ -6547,7 +6763,7 @@ async function saveUserConfig(config, newAgentName) {
 async function createWrapConfig(args) {
   if (!args.mcpServers || args.mcpServers.length === 0) {
     console.error("Error: --wrap/--add requires at least one MCP server\nExample: mcpc --wrap --mcp-stdio 'npx -y @wonderwhy-er/desktop-commander'\nMultiple: mcpc --add --mcp-stdio 'npx -y server1' --mcp-http 'https://api.example.com'");
-    process4.exit(1);
+    process5.exit(1);
   }
   const mcpServers = {};
   const serverNames = [];
@@ -6670,7 +6886,7 @@ function parseMcpServer(cmdString, transportType) {
   };
 }
 function parseCLIArgs() {
-  const args = parseArgs(process4.argv.slice(2), {
+  const args = parseArgs(process5.argv.slice(2), {
     boolean: [
       "help",
       "version",
@@ -6759,15 +6975,15 @@ async function loadConfig() {
   const args = parseCLIArgs();
   if (args.version) {
     printVersion();
-    process4.exit(0);
+    process5.exit(0);
   }
   if (args.help) {
     printHelp();
-    process4.exit(0);
+    process5.exit(0);
   }
   if (args.cwd) {
-    const targetCwd = resolve4(process4.cwd(), args.cwd);
-    process4.chdir(targetCwd);
+    const targetCwd = resolve4(process5.cwd(), args.cwd);
+    process5.chdir(targetCwd);
     console.error(`Changed working directory to: ${targetCwd}`);
   }
   const mergeSkills = (config) => {
@@ -6779,7 +6995,7 @@ async function loadConfig() {
       ...args,
       saveConfig: true
     });
-    process4.exit(0);
+    process5.exit(0);
   }
   if (args.wrap) {
     return mergeSkills(await createWrapConfig({
@@ -6796,16 +7012,16 @@ async function loadConfig() {
       throw error;
     }
   }
-  if (process4.env.MCPC_CONFIG) {
+  if (process5.env.MCPC_CONFIG) {
     try {
-      const parsed = JSON.parse(process4.env.MCPC_CONFIG);
+      const parsed = JSON.parse(process5.env.MCPC_CONFIG);
       return mergeSkills(applyModeOverride(normalizeConfig(parsed), args.mode));
     } catch (error) {
       console.error("Failed to parse MCPC_CONFIG environment variable:", error);
       throw error;
     }
   }
-  const configUrl = args.configUrl || process4.env.MCPC_CONFIG_URL;
+  const configUrl = args.configUrl || process5.env.MCPC_CONFIG_URL;
   if (configUrl) {
     try {
       const headers = {
@@ -6826,7 +7042,7 @@ async function loadConfig() {
       throw error;
     }
   }
-  const configFile = args.configFile || process4.env.MCPC_CONFIG_FILE;
+  const configFile = args.configFile || process5.env.MCPC_CONFIG_FILE;
   if (configFile) {
     try {
       const config = await loadConfigFromFile(configFile);
@@ -6851,7 +7067,7 @@ async function loadConfig() {
       throw error;
     }
   }
-  const defaultJsonConfigPath = resolve4(process4.cwd(), "mcpc.config.json");
+  const defaultJsonConfigPath = resolve4(process5.cwd(), "mcpc.config.json");
   try {
     const config = await loadConfigFromFile(defaultJsonConfigPath);
     return mergeSkills(applyModeOverride(config, args.mode));
@@ -6866,7 +7082,7 @@ async function loadConfig() {
 }
 function replaceEnvVars2(str2) {
   return str2.replace(/\$([A-Z_][A-Z0-9_]*)/g, (_match, varName) => {
-    return process4.env[varName] || "";
+    return process5.env[varName] || "";
   });
 }
 function isMarkdownFile2(path) {
@@ -8168,6 +8384,147 @@ var ExperimentalServerTasks = class {
   requestStream(request, resultSchema, options) {
     return this._server.requestStream(request, resultSchema, options);
   }
+  /**
+   * Sends a sampling request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * For task-augmented requests, yields 'taskCreated' and 'taskStatus' messages
+   * before the final result.
+   *
+   * @example
+   * ```typescript
+   * const stream = server.experimental.tasks.createMessageStream({
+   *     messages: [{ role: 'user', content: { type: 'text', text: 'Hello' } }],
+   *     maxTokens: 100
+   * }, {
+   *     onprogress: (progress) => {
+   *         // Handle streaming tokens via progress notifications
+   *         console.log('Progress:', progress.message);
+   *     }
+   * });
+   *
+   * for await (const message of stream) {
+   *     switch (message.type) {
+   *         case 'taskCreated':
+   *             console.log('Task created:', message.task.taskId);
+   *             break;
+   *         case 'taskStatus':
+   *             console.log('Task status:', message.task.status);
+   *             break;
+   *         case 'result':
+   *             console.log('Final result:', message.result);
+   *             break;
+   *         case 'error':
+   *             console.error('Error:', message.error);
+   *             break;
+   *     }
+   * }
+   * ```
+   *
+   * @param params - The sampling request parameters
+   * @param options - Optional request options (timeout, signal, task creation params, onprogress, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  createMessageStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    if ((params.tools || params.toolChoice) && !clientCapabilities?.sampling?.tools) {
+      throw new Error("Client does not support sampling tools capability.");
+    }
+    if (params.messages.length > 0) {
+      const lastMessage = params.messages[params.messages.length - 1];
+      const lastContent = Array.isArray(lastMessage.content) ? lastMessage.content : [lastMessage.content];
+      const hasToolResults = lastContent.some((c) => c.type === "tool_result");
+      const previousMessage = params.messages.length > 1 ? params.messages[params.messages.length - 2] : void 0;
+      const previousContent = previousMessage ? Array.isArray(previousMessage.content) ? previousMessage.content : [previousMessage.content] : [];
+      const hasPreviousToolUse = previousContent.some((c) => c.type === "tool_use");
+      if (hasToolResults) {
+        if (lastContent.some((c) => c.type !== "tool_result")) {
+          throw new Error("The last message must contain only tool_result content if any is present");
+        }
+        if (!hasPreviousToolUse) {
+          throw new Error("tool_result blocks are not matching any tool_use from the previous message");
+        }
+      }
+      if (hasPreviousToolUse) {
+        const toolUseIds = new Set(previousContent.filter((c) => c.type === "tool_use").map((c) => c.id));
+        const toolResultIds = new Set(lastContent.filter((c) => c.type === "tool_result").map((c) => c.toolUseId));
+        if (toolUseIds.size !== toolResultIds.size || ![...toolUseIds].every((id) => toolResultIds.has(id))) {
+          throw new Error("ids of tool_result blocks and tool_use blocks from previous message do not match");
+        }
+      }
+    }
+    return this.requestStream({
+      method: "sampling/createMessage",
+      params
+    }, CreateMessageResultSchema, options);
+  }
+  /**
+   * Sends an elicitation request and returns an AsyncGenerator that yields response messages.
+   * The generator is guaranteed to end with either a 'result' or 'error' message.
+   *
+   * For task-augmented requests (especially URL-based elicitation), yields 'taskCreated'
+   * and 'taskStatus' messages before the final result.
+   *
+   * @example
+   * ```typescript
+   * const stream = server.experimental.tasks.elicitInputStream({
+   *     mode: 'url',
+   *     message: 'Please authenticate',
+   *     elicitationId: 'auth-123',
+   *     url: 'https://example.com/auth'
+   * }, {
+   *     task: { ttl: 300000 } // Task-augmented for long-running auth flow
+   * });
+   *
+   * for await (const message of stream) {
+   *     switch (message.type) {
+   *         case 'taskCreated':
+   *             console.log('Task created:', message.task.taskId);
+   *             break;
+   *         case 'taskStatus':
+   *             console.log('Task status:', message.task.status);
+   *             break;
+   *         case 'result':
+   *             console.log('User action:', message.result.action);
+   *             break;
+   *         case 'error':
+   *             console.error('Error:', message.error);
+   *             break;
+   *     }
+   * }
+   * ```
+   *
+   * @param params - The elicitation request parameters
+   * @param options - Optional request options (timeout, signal, task creation params, etc.)
+   * @returns AsyncGenerator that yields ResponseMessage objects
+   *
+   * @experimental
+   */
+  elicitInputStream(params, options) {
+    const clientCapabilities = this._server.getClientCapabilities();
+    const mode = params.mode ?? "form";
+    switch (mode) {
+      case "url": {
+        if (!clientCapabilities?.elicitation?.url) {
+          throw new Error("Client does not support url elicitation.");
+        }
+        break;
+      }
+      case "form": {
+        if (!clientCapabilities?.elicitation?.form) {
+          throw new Error("Client does not support form elicitation.");
+        }
+        break;
+      }
+    }
+    const normalizedParams = mode === "form" && params.mode === void 0 ? { ...params, mode: "form" } : params;
+    return this.requestStream({
+      method: "elicitation/create",
+      params: normalizedParams
+    }, ElicitResultSchema, options);
+  }
   /**
    * Gets the current status of a task.
    *
@@ -9367,7 +9724,7 @@ var Client = class extends Protocol {
 
 // __mcpc__cli_latest/node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
 var import_cross_spawn = __toESM(require_cross_spawn(), 1);
-import process5 from "node:process";
+import process6 from "node:process";
 import { PassThrough } from "node:stream";
 
 // __mcpc__cli_latest/node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js
@@ -9399,7 +9756,7 @@ function serializeMessage(message) {
 }
 
 // __mcpc__cli_latest/node_modules/@modelcontextprotocol/sdk/dist/esm/client/stdio.js
-var DEFAULT_INHERITED_ENV_VARS = process5.platform === "win32" ? [
+var DEFAULT_INHERITED_ENV_VARS = process6.platform === "win32" ? [
   "APPDATA",
   "HOMEDRIVE",
   "HOMEPATH",
@@ -9419,7 +9776,7 @@ var DEFAULT_INHERITED_ENV_VARS = process5.platform === "win32" ? [
 function getDefaultEnvironment() {
   const env = {};
   for (const key of DEFAULT_INHERITED_ENV_VARS) {
-    const value = process5.env[key];
+    const value = process6.env[key];
     if (value === void 0) {
       continue;
     }
@@ -9455,7 +9812,7 @@ var StdioClientTransport = class {
         },
         stdio: ["pipe", "pipe", this._serverParams.stderr ?? "inherit"],
         shell: false,
-        windowsHide: process5.platform === "win32" && isElectron(),
+        windowsHide: process6.platform === "win32" && isElectron(),
         cwd: this._serverParams.cwd
       });
       this._process.on("error", (error) => {
@@ -9563,7 +9920,7 @@ var StdioClientTransport = class {
   }
 };
 function isElectron() {
-  return "type" in process5;
+  return "type" in process6;
 }
 
 // __mcpc__cli_latest/node_modules/eventsource-parser/dist/index.js
@@ -10386,22 +10743,45 @@ async function auth(provider, options) {
   }
 }
 async function authInternal(provider, { serverUrl, authorizationCode, scope, resourceMetadataUrl, fetchFn }) {
+  const cachedState = await provider.discoveryState?.();
   let resourceMetadata;
   let authorizationServerUrl;
-  try {
-    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl }, fetchFn);
-    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
-      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+  let metadata;
+  let effectiveResourceMetadataUrl = resourceMetadataUrl;
+  if (!effectiveResourceMetadataUrl && cachedState?.resourceMetadataUrl) {
+    effectiveResourceMetadataUrl = new URL(cachedState.resourceMetadataUrl);
+  }
+  if (cachedState?.authorizationServerUrl) {
+    authorizationServerUrl = cachedState.authorizationServerUrl;
+    resourceMetadata = cachedState.resourceMetadata;
+    metadata = cachedState.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn });
+    if (!resourceMetadata) {
+      try {
+        resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl }, fetchFn);
+      } catch {
+      }
     }
-  } catch {
-  }
-  if (!authorizationServerUrl) {
-    authorizationServerUrl = new URL("/", serverUrl);
+    if (metadata !== cachedState.authorizationServerMetadata || resourceMetadata !== cachedState.resourceMetadata) {
+      await provider.saveDiscoveryState?.({
+        authorizationServerUrl: String(authorizationServerUrl),
+        resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+        resourceMetadata,
+        authorizationServerMetadata: metadata
+      });
+    }
+  } else {
+    const serverInfo = await discoverOAuthServerInfo(serverUrl, { resourceMetadataUrl: effectiveResourceMetadataUrl, fetchFn });
+    authorizationServerUrl = serverInfo.authorizationServerUrl;
+    metadata = serverInfo.authorizationServerMetadata;
+    resourceMetadata = serverInfo.resourceMetadata;
+    await provider.saveDiscoveryState?.({
+      authorizationServerUrl: String(authorizationServerUrl),
+      resourceMetadataUrl: effectiveResourceMetadataUrl?.toString(),
+      resourceMetadata,
+      authorizationServerMetadata: metadata
+    });
   }
   const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
-  const metadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, {
-    fetchFn
-  });
   let clientInformation = await Promise.resolve(provider.clientInformation());
   if (!clientInformation) {
     if (authorizationCode !== void 0) {
@@ -10656,6 +11036,26 @@ async function discoverAuthorizationServerMetadata(authorizationServerUrl, { fet
   }
   return void 0;
 }
+async function discoverOAuthServerInfo(serverUrl, opts) {
+  let resourceMetadata;
+  let authorizationServerUrl;
+  try {
+    resourceMetadata = await discoverOAuthProtectedResourceMetadata(serverUrl, { resourceMetadataUrl: opts?.resourceMetadataUrl }, opts?.fetchFn);
+    if (resourceMetadata.authorization_servers && resourceMetadata.authorization_servers.length > 0) {
+      authorizationServerUrl = resourceMetadata.authorization_servers[0];
+    }
+  } catch {
+  }
+  if (!authorizationServerUrl) {
+    authorizationServerUrl = String(new URL("/", serverUrl));
+  }
+  const authorizationServerMetadata = await discoverAuthorizationServerMetadata(authorizationServerUrl, { fetchFn: opts?.fetchFn });
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata,
+    resourceMetadata
+  };
+}
 async function startAuthorization(authorizationServerUrl, { metadata, clientInformation, redirectUrl, scope, state, resource }) {
   let authorizationUrl;
   if (metadata) {
@@ -11444,8 +11844,8 @@ var InMemoryTransport = class _InMemoryTransport {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/config.js
-import process6 from "node:process";
-var GEMINI_PREFERRED_FORMAT = process6.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
+import process7 from "node:process";
+var GEMINI_PREFERRED_FORMAT = process7.env.GEMINI_PREFERRED_FORMAT === "0" ? false : true;
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/json.js
 import { jsonrepair as jsonrepair2 } from "jsonrepair";
@@ -11518,20 +11918,8 @@ var cleanToolSchema = (schema) => {
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/mcp.js
 import { cwd } from "node:process";
-import process7 from "node:process";
+import process8 from "node:process";
 import { createHash } from "node:crypto";
-var mcpClientPool = /* @__PURE__ */ new Map();
-var mcpClientConnecting = /* @__PURE__ */ new Map();
-var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
-function defSignature(def) {
-  const defCopy = {
-    ...def
-  };
-  if (defCopy.transportType === "memory" || defCopy.transport) {
-    return `memory:${Date.now()}:${Math.random()}`;
-  }
-  return JSON.stringify(defCopy);
-}
 function createTransport(def) {
   const defAny = def;
   const explicitType = defAny.transportType || defAny.type;
@@ -11571,7 +11959,7 @@ function createTransport(def) {
       command: defAny.command,
       args: defAny.args,
       env: {
-        ...process7.env,
+        ...process8.env,
         ...defAny.env ?? {}
       },
       cwd: cwd()
@@ -11579,90 +11967,43 @@ function createTransport(def) {
   }
   throw new Error(`Unsupported transport configuration: ${JSON.stringify(def)}`);
 }
-async function getOrCreateMcpClient(defKey, def) {
-  const pooled = mcpClientPool.get(defKey);
-  if (pooled) {
-    pooled.refCount += 1;
-    return pooled.client;
-  }
-  const existingConnecting = mcpClientConnecting.get(defKey);
-  if (existingConnecting) {
-    const client = await existingConnecting;
-    const entry = mcpClientPool.get(defKey);
-    if (entry) entry.refCount += 1;
-    return client;
-  }
-  const transport = createTransport(def);
-  const connecting = (async () => {
-    const client = new Client({
-      name: `mcp_${shortHash(defSignature(def))}`,
-      version: "1.0.0"
-    });
-    await client.connect(transport, {
-      timeout: 6e4 * 10
-    });
-    return client;
-  })();
-  mcpClientConnecting.set(defKey, connecting);
-  try {
-    const client = await connecting;
-    mcpClientPool.set(defKey, {
-      client,
-      refCount: 1
-    });
-    return client;
-  } finally {
-    mcpClientConnecting.delete(defKey);
+function defSignature(def) {
+  const defCopy = {
+    ...def
+  };
+  if (defCopy.transportType === "memory" || defCopy.transport) {
+    return `memory:${Date.now()}:${Math.random()}`;
   }
+  return JSON.stringify(defCopy);
 }
-async function releaseMcpClient(defKey) {
-  const entry = mcpClientPool.get(defKey);
-  if (!entry) return;
-  entry.refCount -= 1;
-  if (entry.refCount <= 0) {
-    mcpClientPool.delete(defKey);
-    try {
-      await entry.client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
-    }
-  }
+var shortHash = (s) => createHash("sha256").update(s).digest("hex").slice(0, 8);
+async function createMcpClient(def) {
+  const transport = createTransport(def);
+  const client = new Client({
+    name: `mcp_${shortHash(defSignature(def))}`,
+    version: "1.0.0"
+  });
+  await client.connect(transport, {
+    timeout: 6e4 * 10
+  });
+  return client;
 }
-var cleanupAllPooledClients = async () => {
-  const entries = Array.from(mcpClientPool.entries());
-  mcpClientPool.clear();
-  await Promise.all(entries.map(async ([, { client }]) => {
-    try {
-      await client.close();
-    } catch (err) {
-      console.error("Error closing MCP client:", err);
-    }
-  }));
-};
-process7.once?.("exit", () => {
-  cleanupAllPooledClients();
-});
-process7.once?.("SIGINT", () => {
-  cleanupAllPooledClients().finally(() => process7.exit(0));
-});
 async function composeMcpDepTools(mcpConfig, filterIn) {
   const allTools = {};
   const allClients = {};
-  const acquiredKeys = [];
+  const clientsToClose = [];
   for (const [name, definition] of Object.entries(mcpConfig.mcpServers)) {
     const def = definition;
     if (def.disabled) continue;
-    const defKey = shortHash(defSignature(def));
-    const serverId = name;
     try {
-      const client = await getOrCreateMcpClient(defKey, def);
-      acquiredKeys.push(defKey);
-      allClients[serverId] = client;
+      const client = await createMcpClient(def);
+      clientsToClose.push(client);
+      allClients[name] = client;
       const { tools } = await client.listTools();
       tools.forEach((tool2) => {
         const toolNameWithScope = `${name}.${tool2.name}`;
         const internalToolName = tool2.name;
-        const rawToolId = `${serverId}_${internalToolName}`;
+        const rawToolId = `${name}_${internalToolName}`;
         const toolId = sanitizePropertyKey(rawToolId);
         if (filterIn && !filterIn({
           action: internalToolName,
@@ -11674,7 +12015,7 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
         })) {
           return;
         }
-        const execute = (args) => allClients[serverId].callTool({
+        const execute = (args) => allClients[name].callTool({
           name: internalToolName,
           arguments: args
         }, void 0, {
@@ -11691,10 +12032,12 @@ async function composeMcpDepTools(mcpConfig, filterIn) {
     }
   }
   const cleanupClients = async () => {
-    await Promise.all(acquiredKeys.map((k) => releaseMcpClient(k)));
-    acquiredKeys.length = 0;
-    Object.keys(allTools).forEach((key) => delete allTools[key]);
-    Object.keys(allClients).forEach((key) => delete allClients[key]);
+    await Promise.all(clientsToClose.map((client) => {
+      try {
+        return client.close();
+      } catch {
+      }
+    }));
   };
   return {
     tools: allTools,
@@ -12266,7 +12609,7 @@ function endSpan(span, error) {
 }
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/executors/agentic/agentic-executor.js
-import process8 from "node:process";
+import process9 from "node:process";
 var AgenticExecutor = class {
   name;
   allToolNames;
@@ -12286,13 +12629,13 @@ var AgenticExecutor = class {
     this.logger = createLogger(`mcpc.agentic.${name}`, server);
     this.toolSchemaMap = new Map(toolNameToDetailList);
     try {
-      this.tracingEnabled = process8.env.MCPC_TRACING_ENABLED === "true";
+      this.tracingEnabled = process9.env.MCPC_TRACING_ENABLED === "true";
       if (this.tracingEnabled) {
         initializeTracing({
           enabled: true,
           serviceName: `mcpc-agentic-${name}`,
-          exportTo: process8.env.MCPC_TRACING_EXPORT ?? "otlp",
-          otlpEndpoint: process8.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
+          exportTo: process9.env.MCPC_TRACING_EXPORT ?? "otlp",
+          otlpEndpoint: process9.env.MCPC_TRACING_OTLP_ENDPOINT ?? "http://localhost:4318/v1/traces"
         });
       }
     } catch {
@@ -15006,12 +15349,12 @@ var ComposableMCPServer = class extends Server {
 };
 
 // __mcpc__cli_latest/node_modules/@jsr/mcpc__core/src/utils/common/env.js
-import process9 from "node:process";
-var isSCF = () => Boolean(process9.env.SCF_RUNTIME || process9.env.PROD_SCF);
+import process10 from "node:process";
+var isSCF = () => Boolean(process10.env.SCF_RUNTIME || process10.env.PROD_SCF);
 if (isSCF()) {
   console.log({
     isSCF: isSCF(),
-    SCF_RUNTIME: process9.env.SCF_RUNTIME
+    SCF_RUNTIME: process10.env.SCF_RUNTIME
   });
 }
 
@@ -15094,8 +15437,8 @@ var createApp = (config) => {
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/server.js
 import { OpenAPIHono as OpenAPIHono2 } from "@hono/zod-openapi";
-import process10 from "node:process";
-var port = Number(process10.env.PORT || "3002");
+import process11 from "node:process";
+var port = Number(process11.env.PORT || "3002");
 var hostname = "0.0.0.0";
 async function main() {
   const config = await loadConfig();