@mcpc-tech/cli 0.1.52 → 0.1.54

package/server.cjs

@@ -543,10 +543,9 @@ var ProgressTokenSchema = z.union([z.string(), z.number().int()]);
 var CursorSchema = z.string();
 var TaskCreationParamsSchema = z.looseObject({
   /**
-   * Time in milliseconds to keep task results available after completion.
-   * If null, the task has unlimited lifetime until manually cleaned up.
+   * Requested duration in milliseconds to retain task from creation.
    */
-  ttl: z.union([z.number(), z.null()]).optional(),
+  ttl: z.number().optional(),
   /**
    * Time in milliseconds to wait between task status requests.
    */
@@ -846,7 +845,11 @@ var ClientCapabilitiesSchema = z.object({
   /**
    * Present if the client supports task creation.
    */
-  tasks: ClientTasksCapabilitySchema.optional()
+  tasks: ClientTasksCapabilitySchema.optional(),
+  /**
+   * Extensions that the client supports. Keys are extension identifiers (vendor-prefix/extension-name).
+   */
+  extensions: z.record(z.string(), AssertObjectSchema).optional()
 });
 var InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
   /**
@@ -908,7 +911,11 @@ var ServerCapabilitiesSchema = z.object({
   /**
    * Present if the server supports task creation.
    */
-  tasks: ServerTasksCapabilitySchema.optional()
+  tasks: ServerTasksCapabilitySchema.optional(),
+  /**
+   * Extensions that the server supports. Keys are extension identifiers (vendor-prefix/extension-name).
+   */
+  extensions: z.record(z.string(), AssertObjectSchema).optional()
 });
 var InitializeResultSchema = ResultSchema.extend({
   /**
@@ -1101,6 +1108,12 @@ var ResourceSchema = z.object({
    * The MIME type of this resource, if known.
    */
   mimeType: z.optional(z.string()),
+  /**
+   * The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known.
+   *
+   * This can be used by Hosts to display file sizes and estimate context window usage.
+   */
+  size: z.optional(z.number()),
   /**
    * Optional annotations for the client.
    */
@@ -2575,15 +2588,17 @@ var Response2 = class _Response {
       this.#init = init;
     }
     if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-      headers ||= init?.headers || { "content-type": "text/plain; charset=UTF-8" };
-      this[cacheKey] = [init?.status || 200, body, headers];
+      ;
+      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
     }
   }
   get headers() {
     const cache = this[cacheKey];
     if (cache) {
       if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(cache[2]);
+        cache[2] = new Headers(
+          cache[2] || { "content-type": "text/plain; charset=UTF-8" }
+        );
       }
       return cache[2];
     }
@@ -2682,6 +2697,50 @@ if (typeof global.crypto === "undefined") {
   global.crypto = import_crypto.default;
 }
 var outgoingEnded = Symbol("outgoingEnded");
+var incomingDraining = Symbol("incomingDraining");
+var DRAIN_TIMEOUT_MS = 500;
+var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
+var drainIncoming = (incoming) => {
+  const incomingWithDrainState = incoming;
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+    return;
+  }
+  incomingWithDrainState[incomingDraining] = true;
+  if (incoming instanceof import_http2.Http2ServerRequest) {
+    try {
+      ;
+      incoming.stream?.close?.(import_http2.constants.NGHTTP2_NO_ERROR);
+    } catch {
+    }
+    return;
+  }
+  let bytesRead = 0;
+  const cleanup = () => {
+    clearTimeout(timer);
+    incoming.off("data", onData);
+    incoming.off("end", cleanup);
+    incoming.off("error", cleanup);
+  };
+  const forceClose = () => {
+    cleanup();
+    const socket = incoming.socket;
+    if (socket && !socket.destroyed) {
+      socket.destroySoon();
+    }
+  };
+  const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
+  timer.unref?.();
+  const onData = (chunk) => {
+    bytesRead += chunk.length;
+    if (bytesRead > MAX_DRAIN_BYTES) {
+      forceClose();
+    }
+  };
+  incoming.on("data", onData);
+  incoming.on("end", cleanup);
+  incoming.on("error", cleanup);
+  incoming.resume();
+};
 var handleRequestError = () => new Response(null, {
   status: 400
 });
@@ -2708,15 +2767,32 @@ var flushHeaders = (outgoing) => {
 };
 var responseViaCache = async (res, outgoing) => {
   let [status, body, header] = res[cacheKey];
-  if (header instanceof Headers) {
+  let hasContentLength = false;
+  if (!header) {
+    header = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header instanceof Headers) {
+    hasContentLength = header.has("content-length");
     header = buildOutgoingHttpHeaders(header);
+  } else if (Array.isArray(header)) {
+    const headerObj = new Headers(header);
+    hasContentLength = headerObj.has("content-length");
+    header = buildOutgoingHttpHeaders(headerObj);
+  } else {
+    for (const key in header) {
+      if (key.length === 14 && key.toLowerCase() === "content-length") {
+        hasContentLength = true;
+        break;
+      }
+    }
   }
-  if (typeof body === "string") {
-    header["Content-Length"] = Buffer.byteLength(body);
-  } else if (body instanceof Uint8Array) {
-    header["Content-Length"] = body.byteLength;
-  } else if (body instanceof Blob) {
-    header["Content-Length"] = body.size;
+  if (!hasContentLength) {
+    if (typeof body === "string") {
+      header["Content-Length"] = Buffer.byteLength(body);
+    } else if (body instanceof Uint8Array) {
+      header["Content-Length"] = body.byteLength;
+    } else if (body instanceof Blob) {
+      header["Content-Length"] = body.size;
+    }
   }
   outgoing.writeHead(status, header);
   if (typeof body === "string" || body instanceof Uint8Array) {
@@ -2836,14 +2912,18 @@ var getRequestListener = (fetchCallback, options = {}) => {
               setTimeout(() => {
                 if (!incomingEnded) {
                   setTimeout(() => {
-                    incoming.destroy();
-                    outgoing.destroy();
+                    drainIncoming(incoming);
                   });
                 }
               });
             }
           };
         }
+        outgoing.on("finish", () => {
+          if (!incomingEnded) {
+            drainIncoming(incoming);
+          }
+        });
       }
       outgoing.on("close", () => {
         const abortController = req[abortControllerKey];
@@ -2858,7 +2938,7 @@ var getRequestListener = (fetchCallback, options = {}) => {
           setTimeout(() => {
             if (!incomingEnded) {
               setTimeout(() => {
-                incoming.destroy();
+                drainIncoming(incoming);
               });
             }
           });
@@ -6698,7 +6778,7 @@ function getDefaultAgents() {
 }
 
 // __mcpc__cli_latest/node_modules/@mcpc/cli/src/config/loader.js
-var CLI_VERSION = "0.1.52";
+var CLI_VERSION = "0.1.54";
 function extractServerName(command, commandArgs) {
   for (const arg of commandArgs) {
     if (!arg.startsWith("-")) {
@@ -7121,7 +7201,7 @@ function applyModeOverride(config, mode) {
     agent.options.mode = mode;
     if (mode === "ai_acp" && !agent.options.acpSettings) {
       agent.options.acpSettings = {
-        command: "claude-code-acp",
+        command: "claude-agent-acp",
         args: [],
         session: {}
       };
@@ -7542,6 +7622,10 @@ var Protocol = class {
     this._progressHandlers.clear();
     this._taskProgressTokens.clear();
     this._pendingDebouncedNotifications.clear();
+    for (const info of this._timeoutInfo.values()) {
+      clearTimeout(info.timeoutId);
+    }
+    this._timeoutInfo.clear();
     for (const controller of this._requestHandlerAbortControllers.values()) {
       controller.abort();
     }
@@ -7672,7 +7756,9 @@ var Protocol = class {
         await capturedTransport?.send(errorResponse);
       }
     }).catch((error) => this._onerror(new Error(`Failed to send response: ${error}`))).finally(() => {
-      this._requestHandlerAbortControllers.delete(request.id);
+      if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+        this._requestHandlerAbortControllers.delete(request.id);
+      }
     });
   }
   _onprogress(notification) {
@@ -9796,7 +9882,7 @@ var StdioClientTransport = class {
         },
         stdio: ["pipe", "pipe", this._serverParams.stderr ?? "inherit"],
         shell: false,
-        windowsHide: import_node_process5.default.platform === "win32" && isElectron(),
+        windowsHide: import_node_process5.default.platform === "win32",
         cwd: this._serverParams.cwd
       });
       this._process.on("error", (error) => {
@@ -9903,9 +9989,6 @@ var StdioClientTransport = class {
     });
   }
 };
-function isElectron() {
-  return "type" in import_node_process5.default;
-}
 
 // __mcpc__cli_latest/node_modules/eventsource-parser/dist/index.js
 var ParseError = class extends Error {
@@ -10650,12 +10733,12 @@ var AUTHORIZATION_CODE_RESPONSE_TYPE = "code";
 var AUTHORIZATION_CODE_CHALLENGE_METHOD = "S256";
 function selectClientAuthMethod(clientInformation, supportedMethods) {
   const hasClientSecret = clientInformation.client_secret !== void 0;
-  if (supportedMethods.length === 0) {
-    return hasClientSecret ? "client_secret_post" : "none";
-  }
-  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && supportedMethods.includes(clientInformation.token_endpoint_auth_method)) {
+  if ("token_endpoint_auth_method" in clientInformation && clientInformation.token_endpoint_auth_method && isClientAuthMethod(clientInformation.token_endpoint_auth_method) && (supportedMethods.length === 0 || supportedMethods.includes(clientInformation.token_endpoint_auth_method))) {
     return clientInformation.token_endpoint_auth_method;
   }
+  if (supportedMethods.length === 0) {
+    return hasClientSecret ? "client_secret_basic" : "none";
+  }
   if (hasClientSecret && supportedMethods.includes("client_secret_basic")) {
     return "client_secret_basic";
   }
@@ -10766,6 +10849,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
     });
   }
   const resource = await selectResourceURL(serverUrl, provider, resourceMetadata);
+  const resolvedScope = scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
   let clientInformation = await Promise.resolve(provider.clientInformation());
   if (!clientInformation) {
     if (authorizationCode !== void 0) {
@@ -10789,6 +10873,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
       const fullInformation = await registerClient(authorizationServerUrl, {
         metadata,
         clientMetadata: provider.clientMetadata,
+        scope: resolvedScope,
         fetchFn
       });
       await provider.saveClientInformation(fullInformation);
@@ -10832,7 +10917,7 @@ async function authInternal(provider, { serverUrl, authorizationCode, scope, res
     clientInformation,
     state,
     redirectUrl: provider.redirectUrl,
-    scope: scope || resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope,
+    scope: resolvedScope,
     resource
   });
   await provider.saveCodeVerifier(codeVerifier);
@@ -11150,7 +11235,7 @@ async function fetchToken(provider, authorizationServerUrl, { metadata, resource
     fetchFn
   });
 }
-async function registerClient(authorizationServerUrl, { metadata, clientMetadata, fetchFn }) {
+async function registerClient(authorizationServerUrl, { metadata, clientMetadata, scope, fetchFn }) {
   let registrationUrl;
   if (metadata) {
     if (!metadata.registration_endpoint) {
@@ -11165,7 +11250,10 @@ async function registerClient(authorizationServerUrl, { metadata, clientMetadata
     headers: {
       "Content-Type": "application/json"
     },
-    body: JSON.stringify(clientMetadata)
+    body: JSON.stringify({
+      ...clientMetadata,
+      ...scope !== void 0 ? { scope } : {}
+    })
   });
   if (!response.ok) {
     throw await parseErrorResponse(response);
@@ -12260,7 +12348,7 @@ var SystemPrompts = {
 </rules>
 
 <format>
-Get tool schemas: \`{ "tool": "man", "args": { "tools": ["tool1", "tool2"] } }\`
+Get tool definitions: \`{ "tool": "man", "args": { "tools": ["tool1", "tool2"] } }\`
 Execute a tool: \`{ "tool": "tool_name", "args": { /* parameters */ } }\`
 </format>`,
   /**
@@ -12385,7 +12473,7 @@ function createArgsDefFactory(_name, _allToolNames, _depGroups, _predefinedSteps
      *
      * Only two fields:
      * - `tool`: which tool to execute (enum includes "man" + all tool names)
-     * - `args`: object with parameters. For "man": { tools: ["a", "b"] }. For others: tool parameters.
+     * - `args`: object with parameters. For "man": { tools: ["a", "b"] } to fetch tool definitions (including input/output schemas). For others: tool parameters.
      */
     forAgentic: function(allToolNames) {
       const toolEnum = [
@@ -14337,11 +14425,12 @@ var ToolManager = class {
   /**
    * Register a tool in the registry
    */
-  registerTool(name, description, schema, callback, options = {}) {
+  registerTool(name, description, inputSchema, callback, options = {}) {
     this.toolRegistry.set(name, {
       callback,
       description,
-      schema
+      inputSchema,
+      outputSchema: options.outputSchema
     });
     if (options.hidden) {
       this.toolConfigs.set(name, {
@@ -14354,13 +14443,16 @@ var ToolManager = class {
   /**
    * Explicitly mark a tool as public (exposed to MCP clients)
    */
-  addPublicTool(name, description, schema) {
+  addPublicTool(name, description, inputSchema, outputSchema) {
     const existingTool = this.publicTools.find((t) => t.name === name);
     if (!existingTool) {
       this.publicTools.push({
         name,
         description,
-        inputSchema: schema
+        inputSchema,
+        ...outputSchema ? {
+          outputSchema
+        } : {}
       });
     }
     this.toolConfigs.set(name, {
@@ -14486,10 +14578,13 @@ var ToolManager = class {
   getHiddenToolSchema(name) {
     const tool2 = this.toolRegistry.get(name);
     const config = this.toolConfigs.get(name);
-    if (tool2 && config?.visibility?.hidden && tool2.schema) {
+    if (tool2 && config?.visibility?.hidden && tool2.inputSchema) {
       return {
         description: tool2.description,
-        schema: tool2.schema
+        inputSchema: tool2.inputSchema,
+        ...tool2.outputSchema ? {
+          outputSchema: tool2.outputSchema
+        } : {}
       };
     }
     return void 0;
@@ -14525,10 +14620,13 @@ var ToolManager = class {
       composedTools[name] = {
         name,
         description: tool2.description,
-        inputSchema: jsonSchema(tool2.schema || {
+        inputSchema: jsonSchema(tool2.inputSchema || {
           type: "object",
           properties: {}
         }),
+        ...tool2.outputSchema ? {
+          outputSchema: jsonSchema(tool2.outputSchema)
+        } : {},
         execute: tool2.callback
       };
     }
@@ -14545,10 +14643,13 @@ var ToolManager = class {
     return {
       name,
       description: tool2.description,
-      inputSchema: tool2.schema ?? {
+      inputSchema: tool2.inputSchema ?? {
         type: "object",
         properties: {}
       },
+      ...tool2.outputSchema ? {
+        outputSchema: tool2.outputSchema
+      } : {},
       execute: tool2.callback
     };
   }
@@ -14562,10 +14663,13 @@ var ToolManager = class {
       composedTools.push({
         name,
         description: tool2.description,
-        inputSchema: tool2.schema ?? {
+        inputSchema: tool2.inputSchema ?? {
           type: "object",
           properties: {}
         },
+        ...tool2.outputSchema ? {
+          outputSchema: tool2.outputSchema
+        } : {},
         execute: tool2.callback
       });
     }
@@ -14618,7 +14722,10 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
     const tempTool = {
       name: toolId,
       description: toolData.description,
-      inputSchema: toolData.schema || defaultSchema,
+      inputSchema: toolData.inputSchema || defaultSchema,
+      ...toolData.outputSchema ? {
+        outputSchema: toolData.outputSchema
+      } : {},
       execute: toolData.callback
     };
     const processedTool = await pluginManager.applyTransformToolHooks(tempTool, {
@@ -14630,7 +14737,9 @@ async function processToolsWithPlugins(server, _externalTools, mode) {
       },
       transformationIndex: 0
     });
-    toolManager.registerTool(toolId, processedTool.description || toolData.description, processedTool.inputSchema, processedTool.execute);
+    toolManager.registerTool(toolId, processedTool.description || toolData.description, processedTool.inputSchema, processedTool.execute, {
+      outputSchema: processedTool.outputSchema
+    });
   }
 }
 function buildDependencyGroups(toolNameToDetailList, hiddenToolNames, publicToolNames, server) {
@@ -14676,6 +14785,7 @@ var ComposableMCPServer = class extends Server {
   toolManager;
   logger = createLogger("mcpc.compose");
   fileLoaders = /* @__PURE__ */ new Map();
+  pluginsDisposed = false;
   // Legacy property for backward compatibility
   get toolNameMapping() {
     return this.toolManager.getToolNameMapping();
@@ -14804,9 +14914,13 @@ var ComposableMCPServer = class extends Server {
   }
   tool(name, description, paramsSchema, cb, options = {}) {
     const jsonSchemaObj = extractJsonSchema(paramsSchema);
-    this.toolManager.registerTool(name, description, jsonSchemaObj, cb, options);
+    const outputSchemaObj = options.outputSchema ? extractJsonSchema(options.outputSchema) : void 0;
+    this.toolManager.registerTool(name, description, jsonSchemaObj, cb, {
+      ...options,
+      outputSchema: outputSchemaObj
+    });
     if (!options.internal) {
-      this.toolManager.addPublicTool(name, description, jsonSchemaObj);
+      this.toolManager.addPublicTool(name, description, jsonSchemaObj, outputSchemaObj);
     }
     if (options.plugins) {
       for (const plugin of options.plugins) {
@@ -15063,9 +15177,12 @@ var ComposableMCPServer = class extends Server {
       return {
         name,
         description: tool2?.description || "",
-        inputSchema: tool2?.schema || {
+        inputSchema: tool2?.inputSchema || {
           type: "object"
-        }
+        },
+        ...tool2?.outputSchema ? {
+          outputSchema: tool2.outputSchema
+        } : {}
       };
     });
   }
@@ -15090,9 +15207,12 @@ var ComposableMCPServer = class extends Server {
     return Array.from(registry.entries()).map(([name, tool2]) => ({
       name,
       description: tool2?.description || "",
-      inputSchema: tool2?.schema || {
+      inputSchema: tool2?.inputSchema || {
         type: "object"
-      }
+      },
+      ...tool2?.outputSchema ? {
+        outputSchema: tool2.outputSchema
+      } : {}
     }));
   }
   /**
@@ -15151,11 +15271,21 @@ var ComposableMCPServer = class extends Server {
   async disposePlugins() {
     await this.pluginManager.dispose();
   }
+  /**
+   * Dispose plugins only once to avoid duplicated cleanup in chained handlers.
+   */
+  async disposePluginsOnce() {
+    if (this.pluginsDisposed) {
+      return;
+    }
+    this.pluginsDisposed = true;
+    await this.disposePlugins();
+  }
   /**
    * Close the server and ensure all plugins are disposed
    */
   async close() {
-    await this.disposePlugins();
+    await this.disposePluginsOnce();
     await super.close();
   }
   async compose(name, description, depsConfig = {
@@ -15224,7 +15354,9 @@ var ComposableMCPServer = class extends Server {
       });
     });
     Object.entries(tools).forEach(([toolId, tool2]) => {
-      this.toolManager.registerTool(toolId, tool2.description || "", tool2.inputSchema, tool2.execute);
+      this.toolManager.registerTool(toolId, tool2.description || "", tool2.inputSchema, tool2.execute, {
+        outputSchema: tool2.outputSchema
+      });
     });
     const registeredTools = this.toolManager.getRegisteredToolsAsComposed();
     const allTools = {
@@ -15260,16 +15392,20 @@ var ComposableMCPServer = class extends Server {
       server: this,
       toolNames: Object.keys(allTools)
     });
+    const previousOnClose = this.onclose;
     this.onclose = async () => {
       await cleanupClients();
-      await this.disposePlugins();
+      await this.disposePluginsOnce();
       await this.logger.info(`[${name}] Event: closed - cleaned up dependent clients and plugins`);
+      previousOnClose?.();
     };
+    const previousOnError = this.onerror;
     this.onerror = async (error) => {
       await this.logger.error(`[${name}] Event: error - ${error?.stack ?? String(error)}`);
       await cleanupClients();
-      await this.disposePlugins();
+      await this.disposePluginsOnce();
       await this.logger.info(`[${name}] Action: cleaned up dependent clients and plugins`);
+      previousOnError?.(error);
     };
     const toolNameToDetailList = Object.entries(allTools);
     const publicToolNames = this.getPublicToolNames();
@@ -15281,7 +15417,8 @@ var ComposableMCPServer = class extends Server {
         return;
       }
       this.tool(toolId, tool2.description || "", jsonSchema(tool2.inputSchema), tool2.execute, {
-        internal: false
+        internal: false,
+        outputSchema: tool2.outputSchema
       });
     });
     await this.pluginManager.triggerComposeEnd({