@thinkingai/ae-cli 6.0.22 → 6.0.27

package/dist/chunk-BXMXMUD7.js

@@ -0,0 +1,254 @@
+import {
+  PermissionError
+} from "./chunk-NOO24N7W.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-2NDGFQHW.js";
+import {
+  logger,
+  safeJsonParse
+} from "./chunk-YCLVYFK7.js";
+
+// src/core/capability-api.ts
+import { readFile } from "fs/promises";
+import { basename } from "path";
+var CapabilityGatewayError = class extends Error {
+  constructor(message, code, httpStatus, hint) {
+    super(message);
+    this.code = code;
+    this.httpStatus = httpStatus;
+    this.hint = hint;
+    this.name = "CapabilityGatewayError";
+  }
+  code;
+  httpStatus;
+  hint;
+};
+function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}) {
+  const base = host.replace(/\/+$/, "");
+  const cleanDomain = domain.replace(/^\/+|\/+$/g, "");
+  const cleanPath = pathAfterV1.replace(/^\/+|\/+$/g, "");
+  const gatewayPrefix = cleanDomain === "" ? "/api/cli/v1" : `/api/cli/${cleanDomain}/v1`;
+  const url = new URL(`${base}${gatewayPrefix}/${cleanPath}`);
+  for (const [key, value] of Object.entries(queryParams)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+async function permissionMessage(resp) {
+  const text = await resp.text().catch(() => "");
+  try {
+    const d = safeJsonParse(text);
+    const msg = d && (d.error?.message || (typeof d.error === "string" ? d.error : void 0) || d.message);
+    if (msg && typeof msg === "string") return msg;
+  } catch {
+  }
+  return "Permission denied for this resource (HTTP 403)";
+}
+function isInvalidCliTokenMessage(message) {
+  return /\byour token is invalid\b/i.test(message) || /\bcli[-_\s]?token\b.*\binvalid\b/i.test(message) || /\binvalid\b.*\bcli[-_\s]?token\b/i.test(message);
+}
+function parseCapabilityResponse(text) {
+  if (!text) return void 0;
+  try {
+    return safeJsonParse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapCapabilityEnvelope(body) {
+  if (body == null) {
+    throw new CapabilityGatewayError("Empty capability gateway response");
+  }
+  if (typeof body.ok === "boolean") {
+    if (body.ok) {
+      return body.data;
+    }
+    const err = body.error ?? {};
+    const code = nonEmptyString(err.code);
+    const message = nonEmptyString(err.message) ?? code ?? "Capability gateway request failed";
+    const hint = nonEmptyString(err.hint);
+    throw new CapabilityGatewayError(message, code, err.http_status ?? err.httpStatus, hint);
+  }
+  return body;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function buildCapabilityHttpError(resp, body) {
+  const fallback = `Capability gateway HTTP error: ${resp.status} ${resp.statusText}`.trim();
+  if (body && typeof body === "object") {
+    const err = body.error ?? body.data?.error ?? body;
+    const code = nonEmptyString(err.code) ?? nonEmptyString(err.errorCode) ?? nonEmptyString(body.code);
+    const message = nonEmptyString(err.message) ?? nonEmptyString(body.message);
+    const hint = nonEmptyString(err.hint) ?? nonEmptyString(body.hint);
+    const details = [code, message, hint ? `Hint: ${hint}` : void 0].filter(Boolean);
+    if (details.length > 0) {
+      return new CapabilityGatewayError(message ?? fallback, code, resp.status, hint);
+    }
+  }
+  if (typeof body === "string" && body.trim()) {
+    return new CapabilityGatewayError(`${fallback}: ${body.slice(0, 500)}`, void 0, resp.status);
+  }
+  return new CapabilityGatewayError(fallback, void 0, resp.status);
+}
+async function throwCapabilityHttpError(resp) {
+  const body = parseCapabilityResponse(await resp.text());
+  throw buildCapabilityHttpError(resp, body);
+}
+async function requestOnce(url, method, token, body) {
+  const headers = {
+    "cli-token": token,
+    "Accept": "application/json",
+    "X-Source": "ae-cli"
+  };
+  const init = { method, headers };
+  if (body !== void 0 && method !== "GET") {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  return fetch(url, init);
+}
+async function requestMultipartOnce(url, token, form) {
+  return fetch(url, {
+    method: "POST",
+    headers: {
+      "cli-token": token,
+      "Accept": "application/json",
+      "X-Source": "ae-cli"
+    },
+    body: form
+  });
+}
+async function requestDownloadOnce(url, token) {
+  return fetch(url, {
+    method: "GET",
+    headers: {
+      "cli-token": token,
+      "Accept": "*/*",
+      "X-Source": "ae-cli"
+    }
+  });
+}
+async function callGateway(host, domain, pathAfterV1, method, body) {
+  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1);
+  const token = await getCliToken(host);
+  let resp = await requestOnce(url, method, token, body);
+  let permissionMsg;
+  if (resp.status === 403) {
+    permissionMsg = await permissionMessage(resp);
+    if (!isInvalidCliTokenMessage(permissionMsg)) {
+      throw new PermissionError(permissionMsg);
+    }
+  }
+  if (resp.status === 401 || resp.status === 403 && permissionMsg) {
+    logger.warn(`Capability gateway request failed (${resp.status === 403 ? permissionMsg : "HTTP 401"}) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestOnce(url, method, newToken, body);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+async function executeCapability(host, domain, capabilityId, input = {}) {
+  return callGateway(host, domain, `capabilities/${capabilityId}/execute`, "POST", { input });
+}
+async function uploadInputFile(host, domain, projectId, purpose, filePath) {
+  const fileBytes = await readFile(filePath);
+  return uploadInputFileBytes(host, domain, projectId, purpose, fileBytes, basename(filePath));
+}
+async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, filename, contentType = "application/octet-stream") {
+  const url = buildCapabilityGatewayUrl(host, domain, "input-files");
+  const fileBuffer = bytes instanceof ArrayBuffer ? bytes : bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const form = new FormData();
+  form.append("project_id", String(projectId));
+  form.append("purpose", purpose);
+  form.append("file", new Blob([fileBuffer], { type: contentType }), filename);
+  const token = await getCliToken(host);
+  let resp = await requestMultipartOnce(url, token, form);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestMultipartOnce(url, newToken, form);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+async function downloadCapabilityArtifact(host, domain, runId, artifactId) {
+  const url = buildCapabilityGatewayUrl(
+    host,
+    domain,
+    `runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}/download`
+  );
+  const token = await getCliToken(host);
+  let resp = await requestDownloadOnce(url, token);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    logger.warn(`Capability gateway artifact download failed (HTTP 401) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestDownloadOnce(url, newToken);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return {
+    bytes: Buffer.from(await resp.arrayBuffer()),
+    contentType: resp.headers.get("content-type") ?? void 0,
+    contentDisposition: resp.headers.get("content-disposition") ?? void 0
+  };
+}
+async function callCapabilityApi(host, domain, action, method = "POST", params = {}) {
+  const isGet = method === "GET";
+  if (isGet) {
+    return callGateway(host, domain, action.replace(/^\/+|\/+$/g, ""), "GET");
+  }
+  return callGateway(host, domain, action.replace(/^\/+|\/+$/g, ""), method, params);
+}
+
+export {
+  CapabilityGatewayError,
+  buildCapabilityGatewayUrl,
+  executeCapability,
+  uploadInputFile,
+  uploadInputFileBytes,
+  downloadCapabilityArtifact,
+  callCapabilityApi
+};

package/dist/chunk-C4DH76LX.js

@@ -0,0 +1,59 @@
+import {
+  buildCapabilityGatewayUrl,
+  executeCapability
+} from "./chunk-BXMXMUD7.js";
+
+// src/core/capability-routing.ts
+var cliServiceRoutes = /* @__PURE__ */ new Map();
+function registerCapabilityGatewayRoute(cliService, route) {
+  cliServiceRoutes.set(cliService, route);
+}
+function resolveGatewayDomain(cliService, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const route = cliServiceRoutes.get(cliService);
+  if (!route) {
+    throw new Error(
+      `Capability gateway route not registered for CLI service '${cliService}'. Call registerCapabilityGatewayRoute() in commands/${cliService}/index.ts.`
+    );
+  }
+  return route.gatewayDomain;
+}
+
+// src/core/capability-command.ts
+function createCapabilityCommand(config) {
+  return {
+    service: config.cliService,
+    resource: config.resource,
+    command: config.command,
+    description: config.description,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate,
+    dryRun: (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return {
+        method: "POST",
+        url: buildCapabilityGatewayUrl(
+          ctx.host(),
+          gatewayDomain,
+          `capabilities/${config.capabilityId}/dry-run`
+        ),
+        body: { input }
+      };
+    },
+    execute: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return executeCapability(ctx.host(), gatewayDomain, config.capabilityId, input);
+    }
+  };
+}
+
+export {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain,
+  createCapabilityCommand
+};

package/dist/chunk-GWZ5MYWE.js

@@ -0,0 +1,209 @@
+import {
+  getAnalysisMappingPathForClusterMode
+} from "./chunk-KGJQCYVC.js";
+import {
+  PermissionError
+} from "./chunk-NOO24N7W.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-2NDGFQHW.js";
+import {
+  getActiveHost,
+  logger,
+  safeJsonParse
+} from "./chunk-YCLVYFK7.js";
+
+// src/core/mcp.ts
+async function permissionMessage(resp) {
+  const text = await resp.text().catch(() => "");
+  try {
+    const d = safeJsonParse(text);
+    const msg = d && (d.error?.message || (typeof d.error === "string" ? d.error : void 0) || d.message);
+    if (msg && typeof msg === "string") return msg;
+  } catch {
+  }
+  return "Permission denied for this resource (HTTP 403)";
+}
+function isInvalidCliTokenMessage(message) {
+  return /\b(cli[-_\s]?token|token)\b.*\binvalid\b/i.test(message) || /\binvalid\b.*\b(cli[-_\s]?token|token)\b/i.test(message);
+}
+var MCP_PROTOCOL_VERSION = "2025-11-25";
+var JSONRPC_VERSION = "2.0";
+var serviceMappingMap = /* @__PURE__ */ new Map();
+registerMcpMapping("analysis", {
+  componentName: "analysis",
+  mappingPath: "analysis"
+});
+registerMcpMapping("te_analysis_extend", {
+  componentName: "analysis",
+  mappingPath: "analysis-extend"
+});
+function registerMcpMapping(serviceName, mapping) {
+  serviceMappingMap.set(serviceName, mapping);
+}
+function registerMcpMappings(mappings) {
+  for (const [serviceName, mapping] of Object.entries(mappings)) {
+    serviceMappingMap.set(serviceName, mapping);
+  }
+}
+function getMcpMapping(serviceName) {
+  const mapping = serviceMappingMap.get(serviceName);
+  if (!mapping) {
+    throw new Error(`MCP mapping not found for service: '${serviceName}'. Please register it using registerMcpMapping() first.`);
+  }
+  if (serviceName === "analysis") {
+    return { ...mapping, mappingPath: getAnalysisMappingPathForClusterMode() };
+  }
+  return mapping;
+}
+function buildMcpUrl(host, serviceName) {
+  const mapping = getMcpMapping(serviceName);
+  const base = host.replace(/\/+$/, "");
+  return `${base}/mcp/${mapping.componentName}/http/${mapping.mappingPath}`;
+}
+function resolveMcpUrl(mcpUrlOverride, host, serviceName) {
+  if (mcpUrlOverride) {
+    return mcpUrlOverride;
+  }
+  return buildMcpUrl(host, serviceName);
+}
+var requestIdCounter = 1;
+function genRequestId() {
+  return requestIdCounter++;
+}
+function buildAuthHeaders(cliToken) {
+  return {
+    "cli-token": cliToken
+  };
+}
+async function mcpRequest(url, method, params = {}, hostOverride) {
+  const hostUrl = hostOverride || getActiveHost();
+  const token = await getCliToken(hostUrl);
+  const requestId = genRequestId();
+  const paramsWithMeta = {
+    ...params,
+    _meta: { progressToken: requestId }
+  };
+  const body = {
+    jsonrpc: JSONRPC_VERSION,
+    id: requestId,
+    method,
+    params: paramsWithMeta
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+    "X-Source": "ae-cli",
+    ...buildAuthHeaders(token)
+  };
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    let permissionMsg;
+    if (resp.status === 403) {
+      permissionMsg = await permissionMessage(resp);
+      if (!isInvalidCliTokenMessage(permissionMsg)) {
+        throw new PermissionError(permissionMsg);
+      }
+    }
+    if (resp.status === 401 || resp.status === 403 && permissionMsg) {
+      logger.warn(`MCP request failed (${resp.status === 403 ? permissionMsg : "HTTP 401"}) for ${hostUrl}, refreshing CLI token`);
+      clearCliToken(hostUrl);
+      const newToken = await getCliToken(hostUrl);
+      logger.info(`CLI token refreshed for ${hostUrl}`);
+      process.stderr.write(`[ae-cli] CLI token refreshed for ${hostUrl}
+`);
+      Object.assign(headers, buildAuthHeaders(newToken));
+      const retryResp = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (retryResp.status === 403) {
+        throw new PermissionError(await permissionMessage(retryResp));
+      }
+      if (!retryResp.ok) {
+        throw new Error(`MCP HTTP error: ${retryResp.status} ${retryResp.statusText}`);
+      }
+      const retryData = safeJsonParse(await retryResp.text());
+      if (retryData.error) {
+        throw new Error(`MCP error: ${retryData.error.message || JSON.stringify(retryData.error)}`);
+      }
+      return retryData.result;
+    }
+    throw new Error(`MCP HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(await resp.text());
+  if (data.error) {
+    throw new Error(`MCP error: ${data.error.message || JSON.stringify(data.error)}`);
+  }
+  return data.result;
+}
+async function callMcpTool(url, toolName, args = {}, hostOverride) {
+  const params = {
+    name: toolName,
+    arguments: args
+  };
+  logger.info(`MCP tool call: ${toolName}`);
+  const result = await mcpRequest(url, "tools/call", params, hostOverride);
+  if (result.isError) {
+    logger.warn(`MCP tool call failed: ${toolName}`);
+  }
+  return {
+    content: result.content.map((item) => {
+      if (item.type === "text") {
+        return { type: "text", text: item.text };
+      } else if (item.type === "image") {
+        return { type: "image", data: item.data, mimeType: item.mimeType };
+      } else {
+        return { type: "resource", ...item };
+      }
+    }),
+    isError: result.isError
+  };
+}
+function parseMcpResult(result) {
+  if (result.content.length > 0 && result.content[0].type === "text") {
+    const text = result.content[0].text || "";
+    let parsed;
+    try {
+      parsed = safeJsonParse(text);
+    } catch {
+      return text;
+    }
+    const errMsg = mcpResultErrorMessage(parsed);
+    if (errMsg !== null) {
+      if (/no_auth|auth_error|permission|forbidden|unauthor|\u65e0\u6743/i.test(errMsg)) {
+        throw new PermissionError(errMsg);
+      }
+      throw new Error(errMsg);
+    }
+    return parsed;
+  }
+  return result;
+}
+function mcpResultErrorMessage(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  if (parsed.success === true || parsed.ok === true) return null;
+  const e = parsed.error;
+  if (typeof e === "string" && e.trim()) return e;
+  if (e && typeof e === "object") {
+    const msg = typeof e.message === "string" && e.message || void 0;
+    const code = typeof e.code === "string" && e.code || void 0;
+    if (msg && code) return `${code}: ${msg}`;
+    if (msg || code) return msg || code;
+  }
+  return null;
+}
+
+export {
+  registerMcpMappings,
+  resolveMcpUrl,
+  callMcpTool,
+  parseMcpResult
+};

package/dist/{chunk-E34XH4GW.js → chunk-KCA6BA5D.js}

@@ -1,13 +1,13 @@
 import {
   SecureStoreAuthError,
-  clearToken,
   getToken,
+  invalidateAccessTokenForRetry,
   resolveHost
-} from "./chunk-U6QPKCN3.js";
+} from "./chunk-AJTH7LT3.js";
 import {
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-YCLVYFK7.js";
 
 // src/core/client.ts
 import WebSocket from "ws";
@@ -46,7 +46,7 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
   logger.api(method, url, resp.status, body, data);
   if (resp.status === 401) {
     if (retry) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       return request(method, modulePath, params, body, false, resolvedHost);
     }
     throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
@@ -56,7 +56,7 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
     throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
-    clearToken(resolvedHost);
+    invalidateAccessTokenForRetry(resolvedHost);
     return request(method, modulePath, params, body, false, resolvedHost);
   }
   if (data.return_code !== 0 && data.return_code !== void 0) {
@@ -89,7 +89,7 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
   logger.api("POST", url, resp.status, { upload: true }, data);
   if (resp.status === 401) {
     if (retry) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       return uploadRequest(modulePath, form, params, false, resolvedHost);
     }
     throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
@@ -99,7 +99,7 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
     throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
-    clearToken(resolvedHost);
+    invalidateAccessTokenForRetry(resolvedHost);
     return uploadRequest(modulePath, form, params, false, resolvedHost);
   }
   if (data.return_code !== 0 && data.return_code !== void 0) {
@@ -162,7 +162,7 @@ async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostU
   } catch (err) {
     const msg = err.message || "";
     if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       const newToken = await getToken(resolvedHost);
       return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
     }

package/dist/{chunk-XE2PI5DS.js → chunk-KGJQCYVC.js}

@@ -2,7 +2,7 @@ import {
   getSandboxClusterInfoFilePath,
   logger,
   safeReadJsonFile
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-YCLVYFK7.js";
 
 // src/core/cluster-info.ts
 import fs from "fs";

package/dist/chunk-LG5YT7P7.js

@@ -0,0 +1,59 @@
+import {
+  buildCapabilityGatewayUrl,
+  executeCapability
+} from "./chunk-YNQFYBDB.js";
+
+// src/core/capability-routing.ts
+var cliServiceRoutes = /* @__PURE__ */ new Map();
+function registerCapabilityGatewayRoute(cliService, route) {
+  cliServiceRoutes.set(cliService, route);
+}
+function resolveGatewayDomain(cliService, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const route = cliServiceRoutes.get(cliService);
+  if (!route) {
+    throw new Error(
+      `Capability gateway route not registered for CLI service '${cliService}'. Call registerCapabilityGatewayRoute() in commands/${cliService}/index.ts.`
+    );
+  }
+  return route.gatewayDomain;
+}
+
+// src/core/capability-command.ts
+function createCapabilityCommand(config) {
+  return {
+    service: config.cliService,
+    resource: config.resource,
+    command: config.command,
+    description: config.description,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate,
+    dryRun: (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return {
+        method: "POST",
+        url: buildCapabilityGatewayUrl(
+          ctx.host(),
+          gatewayDomain,
+          `capabilities/${config.capabilityId}/dry-run`
+        ),
+        body: { input }
+      };
+    },
+    execute: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return executeCapability(ctx.host(), gatewayDomain, config.capabilityId, input);
+    }
+  };
+}
+
+export {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain,
+  createCapabilityCommand
+};

package/dist/{chunk-2W7HULUD.js → chunk-MDJGDI6K.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-NOO24N7W.js";
 import {
   getCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-2NDGFQHW.js";
 import {
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-YCLVYFK7.js";
 
 // src/core/mcp-access.ts
 function buildUrl(host, path, params = {}) {