@tool-bridge/server 0.16.0 → 0.17.0

package/dist/chunk-U67V476Y.js

@@ -0,0 +1,35 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/dist/chunk-WW2IMPQK.js

@@ -0,0 +1,283 @@
+import {
+  upstreamError
+} from "./chunk-YASUMV2K.js";
+import {
+  createGuardedFetch
+} from "./chunk-U5UHT7CX.js";
+import {
+  TBError
+} from "./chunk-RVWZN3CI.js";
+
+// ../plugins/src/_runtime/providerHttp.ts
+function credentialLike(name) {
+  return /(?:^|-|_)(?:api[-_]?key|access[-_]?key|key|token|secret|auth(?:entication|orization)?|credentials?|pass(?:word)?|passwd|cookie|signature)(?:$|-|_)/i.test(name);
+}
+function addSecret(secrets, value) {
+  if (value === "") return;
+  secrets.add(value);
+  try {
+    const encoded = encodeURIComponent(value);
+    if (encoded !== value) secrets.add(encoded);
+  } catch {
+  }
+  const json = JSON.stringify(value);
+  const escaped = json.slice(1, -1);
+  if (escaped !== value) secrets.add(escaped);
+}
+function appendQuery(url, query, secrets) {
+  for (const [name, raw] of query ?? []) {
+    if (raw === void 0 || raw === null) continue;
+    const values = Array.isArray(raw) ? raw : [raw];
+    for (const value of values) {
+      const encoded = String(value);
+      url.searchParams.append(name, encoded);
+      if (credentialLike(name)) addSecret(secrets, encoded);
+    }
+  }
+}
+function collectUrlSecrets(url, secrets) {
+  for (const [name, value] of url.searchParams) {
+    if (credentialLike(name)) addSecret(secrets, value);
+  }
+}
+function collectHeaderSecrets(headers, sensitiveHeaders, secrets) {
+  for (const [name, value] of headers) {
+    if (!credentialLike(name) && !sensitiveHeaders.has(name.toLowerCase())) continue;
+    addSecret(secrets, value);
+    const authorization = /^([A-Za-z][A-Za-z0-9._~-]*)\s+(.+)$/.exec(value);
+    if (authorization === null) continue;
+    const scheme = authorization[1] ?? "";
+    const payload = authorization[2] ?? "";
+    addSecret(secrets, payload);
+    if (scheme.toLowerCase() !== "basic") continue;
+    try {
+      const binary = atob(payload);
+      addSecret(secrets, binary);
+      const separator = binary.indexOf(":");
+      if (separator >= 0) {
+        addSecret(secrets, binary.slice(0, separator));
+        addSecret(secrets, binary.slice(separator + 1));
+      }
+      const utf8 = new TextDecoder().decode(Uint8Array.from(binary, (char) => char.charCodeAt(0)));
+      addSecret(secrets, utf8);
+      const utf8Separator = utf8.indexOf(":");
+      if (utf8Separator >= 0) {
+        addSecret(secrets, utf8.slice(0, utf8Separator));
+        addSecret(secrets, utf8.slice(utf8Separator + 1));
+      }
+    } catch {
+    }
+  }
+}
+function collectJsonSecrets(value, secrets) {
+  const seen = /* @__PURE__ */ new Set();
+  const pending = [
+    { sensitive: false, value }
+  ];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    if (current.value === null || current.value === void 0) continue;
+    if (typeof current.value !== "object") {
+      if (current.sensitive) addSecret(secrets, String(current.value));
+      continue;
+    }
+    if (seen.has(current.value)) continue;
+    seen.add(current.value);
+    if (Array.isArray(current.value)) {
+      for (const item of current.value) pending.push({ sensitive: current.sensitive, value: item });
+      continue;
+    }
+    for (const [name, item] of Object.entries(current.value)) {
+      pending.push({ sensitive: current.sensitive || credentialLike(name), value: item });
+    }
+  }
+}
+function acceptedStatuses(values, service) {
+  const result = /* @__PURE__ */ new Set();
+  for (const value of values ?? []) {
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 100 || value > 599) {
+      throw new TBError("invalid_argument", `${service} acceptStatuses must contain HTTP status integers from 100 to 599`);
+    }
+    result.add(value);
+  }
+  return result;
+}
+var MAX_TIMEOUT_MS = 2147483647;
+function requestTimeout(timeoutMs, service) {
+  if (timeoutMs === void 0) {
+    return { cancel: () => {
+    }, race: (operation) => operation, signal: void 0 };
+  }
+  if (!Number.isFinite(timeoutMs) || !Number.isInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > MAX_TIMEOUT_MS) {
+    throw new TBError(
+      "invalid_argument",
+      `${service} timeoutMs must be an integer from 1 to ${MAX_TIMEOUT_MS}`
+    );
+  }
+  let signal;
+  try {
+    signal = AbortSignal.timeout(timeoutMs);
+  } catch {
+    throw new TBError("invalid_argument", `${service} timeoutMs is outside the supported range`);
+  }
+  let onAbort;
+  const expired = new Promise((_resolve, reject) => {
+    onAbort = () => reject(signal.reason ?? new DOMException("The operation timed out", "TimeoutError"));
+    if (signal.aborted) onAbort();
+    else signal.addEventListener("abort", onAbort, { once: true });
+  });
+  return {
+    cancel: () => signal.removeEventListener("abort", onAbort),
+    race: (operation) => Promise.race([operation, expired]),
+    signal
+  };
+}
+function redact(message, secrets) {
+  let safe = message.replace(/https?:\/\/[^\s)\]}>'"]+/gi, "[redacted-url]");
+  for (const secret of secrets) {
+    if (secret !== "") safe = safe.replaceAll(secret, "[redacted]");
+  }
+  return safe.slice(0, 500);
+}
+function redactError(error, secrets) {
+  const message = redact(error.message, secrets);
+  if (message === error.message) return error;
+  return new TBError(error.code, message, {
+    httpStatus: error.httpStatus,
+    retryable: error.retryable
+  });
+}
+async function readResponse(response, responseType, invalidJson, service, invalidJsonMessage) {
+  if (responseType === "empty" || response.status === 204 || response.status === 205) {
+    return { bodyKind: "empty", data: void 0, rawText: void 0 };
+  }
+  let raw;
+  try {
+    raw = await response.text();
+  } catch {
+    if (!response.ok) return { bodyKind: "empty", data: void 0, rawText: void 0 };
+    throw upstreamError(502, `${service} returned an unreadable response`);
+  }
+  if (raw === "") return { bodyKind: "empty", data: void 0, rawText: void 0 };
+  if (responseType === "json" && raw.trim() === "") return { bodyKind: "empty", data: void 0, rawText: raw };
+  if (responseType === "text") return { bodyKind: "text", data: raw, rawText: raw };
+  if (responseType === "auto" && !response.headers.get("content-type")?.toLowerCase().includes("json")) {
+    return { bodyKind: "text", data: raw, rawText: raw };
+  }
+  try {
+    return { bodyKind: "json", data: JSON.parse(raw), rawText: raw };
+  } catch {
+    if (!response.ok || invalidJson === "text") return { bodyKind: "invalid-json", data: raw, rawText: raw };
+    throw upstreamError(502, invalidJsonMessage ?? `${service} returned an invalid JSON response`);
+  }
+}
+function createProviderHttpClient(options) {
+  let fixedBaseUrl;
+  if (options.baseUrl !== void 0) {
+    try {
+      fixedBaseUrl = new URL(options.baseUrl);
+    } catch {
+      throw new TBError("invalid_argument", `${options.service} baseUrl must be a valid absolute URL`);
+    }
+  }
+  const guardedFetch = createGuardedFetch({
+    crossOriginRedirect: options.crossOriginRedirect ?? "error",
+    fetch: options.transport,
+    maxRedirects: options.maxRedirects,
+    sensitiveHeaders: options.sensitiveHeaders
+  });
+  const sensitiveHeaders = new Set(
+    (options.sensitiveHeaders ?? []).map((name) => name.toLowerCase())
+  );
+  return {
+    async request(request) {
+      const hasJson = Object.hasOwn(request, "json");
+      const hasBody = Object.hasOwn(request, "body");
+      if (hasJson && hasBody) {
+        throw new TBError("invalid_argument", `${options.service} request cannot contain both json and body`);
+      }
+      const accepted = acceptedStatuses(request.acceptStatuses, options.service);
+      let baseUrl = fixedBaseUrl;
+      if (request.baseUrl !== void 0) {
+        try {
+          baseUrl = new URL(request.baseUrl);
+        } catch {
+          throw new TBError("invalid_argument", `${options.service} baseUrl must be a valid absolute URL`);
+        }
+      }
+      if (baseUrl === void 0) {
+        throw new TBError("invalid_argument", `${options.service} request requires a baseUrl`);
+      }
+      const url = new URL(request.path.replace(/^\/+/, ""), baseUrl);
+      if (url.origin !== baseUrl.origin) {
+        throw new TBError("invalid_argument", `${options.service} request path must stay on the configured origin`);
+      }
+      const secrets = new Set(request.sensitiveValues ?? []);
+      for (const secret of [...secrets]) addSecret(secrets, secret);
+      collectUrlSecrets(url, secrets);
+      appendQuery(url, request.query, secrets);
+      const headers = new Headers(request.headers);
+      collectHeaderSecrets(headers, sensitiveHeaders, secrets);
+      if (hasJson) collectJsonSecrets(request.json, secrets);
+      if (hasJson && !headers.has("content-type")) headers.set("content-type", "application/json");
+      const timeout = requestTimeout(request.timeoutMs, options.service);
+      const signal = timeout.signal;
+      const completed = await (async () => {
+        try {
+          return await timeout.race((async () => {
+            const response2 = await guardedFetch(url, {
+              method: request.method ?? "GET",
+              headers,
+              body: hasJson ? JSON.stringify(request.json) : request.body,
+              ...signal === void 0 ? {} : { signal }
+            });
+            const parsed2 = await readResponse(
+              response2,
+              request.responseType ?? "json",
+              request.invalidJson ?? "error",
+              options.service,
+              request.invalidJsonMessage
+            );
+            return { parsed: parsed2, response: response2 };
+          })());
+        } catch (error) {
+          if (error instanceof TBError && signal?.aborted !== true) throw error;
+          const kind = signal?.aborted === true ? "timeout" : "network";
+          const rawMessage = error instanceof Error ? error.message : void 0;
+          const context = {
+            kind,
+            message: rawMessage === void 0 ? void 0 : redact(rawMessage, secrets)
+          };
+          const mapped = request.mapTransportError?.(context) ?? upstreamError(kind === "timeout" ? 504 : 502, `${options.service} request failed`);
+          throw redactError(mapped, secrets);
+        } finally {
+          timeout.cancel();
+        }
+      })();
+      const { parsed, response } = completed;
+      if (!response.ok && !accepted.has(response.status)) {
+        const mapped = request.mapError?.({
+          bodyKind: parsed.bodyKind,
+          data: parsed.data,
+          headers: response.headers,
+          rawText: parsed.rawText,
+          status: response.status,
+          statusText: response.statusText
+        }) ?? upstreamError(response.status, `${options.service} request failed with ${response.status}`);
+        throw redactError(mapped, secrets);
+      }
+      return {
+        bodyKind: parsed.bodyKind,
+        data: parsed.data,
+        headers: response.headers,
+        rawText: parsed.rawText,
+        status: response.status,
+        statusText: response.statusText
+      };
+    }
+  };
+}
+
+export {
+  createProviderHttpClient
+};

package/dist/{chunk-VK3V2WTY.js → chunk-YASUMV2K.js}

@@ -1,9 +1,7 @@
 import {
+  TBError,
   createPlugin
-} from "./chunk-GKX72JMJ.js";
-import {
-  TBError
-} from "./chunk-YB2FLNWI.js";
+} from "./chunk-RVWZN3CI.js";
 
 // ../plugins/src/_runtime/plugin.ts
 function requireApiKey(ctx, service) {
@@ -83,8 +81,8 @@ function upstreamError(status, message) {
 }
 
 export {
+  upstreamError,
   requireApiKey,
   requireCredential,
-  createProviderPlugin,
-  upstreamError
+  createProviderPlugin
 };

package/dist/{circleci-WV3ITU7Q.js → circleci-VSJ4O5FC.js}

@@ -1,29 +1,26 @@
+import {
+  createProviderHttpClient
+} from "./chunk-WW2IMPQK.js";
+import {
+  asJsonObject,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
 import {
   createProviderPlugin,
   requireApiKey,
   upstreamError
-} from "./chunk-VK3V2WTY.js";
-import {
-  guardedFetch
-} from "./chunk-2O27H4Y2.js";
-import "./chunk-GKX72JMJ.js";
+} from "./chunk-YASUMV2K.js";
+import "./chunk-U5UHT7CX.js";
 import {
   TBError,
   external_exports
-} from "./chunk-YB2FLNWI.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-RVWZN3CI.js";
+import "./chunk-U67V476Y.js";
 
 // ../plugins/src/circleci/api.ts
 var SERVICE = "circleci";
 var API_BASE = "https://circleci.com/api/v2";
-function text(value) {
-  if (typeof value !== "string") return void 0;
-  const trimmed = value.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
-function record(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
-}
+var http = createProviderHttpClient({ baseUrl: `${API_BASE}/`, service: SERVICE });
 function trimSlashes(value) {
   let start = 0;
   let end = value.length;
@@ -59,42 +56,26 @@ function errorMessage(payload, status) {
     const trimmed = payload.trim();
     if (trimmed !== "") return trimmed;
   }
-  const body = record(payload);
-  return text(body?.message) ?? text(body?.error) ?? `CircleCI \u8FD4\u56DE HTTP ${status}`;
-}
-function buildUrl(path, query) {
-  const url = new URL(`${API_BASE}${path}`);
-  for (const [key, value] of Object.entries(query ?? {})) {
-    if (value === void 0 || value === "") continue;
-    url.searchParams.set(key, value);
-  }
-  return url.toString();
+  const body = asJsonObject(payload);
+  return trimmedText(body?.message) ?? trimmedText(body?.error) ?? `CircleCI \u8FD4\u56DE HTTP ${status}`;
 }
 async function request(ctx, input) {
-  const headers = {
-    "circle-token": requireApiKey(ctx, SERVICE),
-    "accept": "application/json"
-  };
-  if (input.body !== void 0) headers["content-type"] = "application/json";
-  const response = await guardedFetch(buildUrl(input.path, input.query), {
+  const { data } = await http.request({
+    path: input.path,
     method: input.method ?? "GET",
-    headers,
-    body: input.body === void 0 ? void 0 : JSON.stringify(input.body)
+    query: Object.entries(input.query ?? {}).filter((entry) => {
+      const value = entry[1];
+      return value !== void 0 && value !== "";
+    }),
+    headers: {
+      "accept": "application/json",
+      "circle-token": requireApiKey(ctx, SERVICE)
+    },
+    ...input.body === void 0 ? {} : { json: input.body },
+    invalidJsonMessage: "CircleCI \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94",
+    mapError: ({ data: payload, status }) => upstreamError(status, errorMessage(payload, status))
   });
-  const body = await response.text();
-  let payload = {};
-  if (body.trim() !== "") {
-    try {
-      payload = JSON.parse(body);
-    } catch {
-      if (response.ok) {
-        throw new TBError("unavailable", "CircleCI \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94", { retryable: true });
-      }
-      payload = body;
-    }
-  }
-  if (!response.ok) throw upstreamError(response.status, errorMessage(payload, response.status));
-  return payload;
+  return data ?? {};
 }
 function getCurrentUser(_input, ctx) {
   return request(ctx, { path: "/me" });
@@ -106,7 +87,7 @@ function listPipelinesForProject(input, ctx) {
   return request(ctx, {
     path: `/project/${encodeURIComponent(projectSlug(input.projectSlug))}/pipeline`,
     // 入参是 camelCase 的 pageToken,上游 query 键却是连字符的 `page-token`。
-    query: { "branch": text(input.branch), "page-token": text(input.pageToken) }
+    query: { "branch": trimmedText(input.branch), "page-token": trimmedText(input.pageToken) }
   });
 }
 function getPipeline(input, ctx) {
@@ -115,11 +96,11 @@ function getPipeline(input, ctx) {
 function listWorkflowsByPipeline(input, ctx) {
   return request(ctx, {
     path: `/pipeline/${encodeURIComponent(input.pipelineId.trim())}/workflow`,
-    query: { "page-token": text(input.pageToken) }
+    query: { "page-token": trimmedText(input.pageToken) }
   });
 }
 function getWorkflowSummary(input, ctx) {
-  if (typeof input.allBranches === "boolean" && text(input.branch) !== void 0) {
+  if (typeof input.allBranches === "boolean" && trimmedText(input.branch) !== void 0) {
     throw new TBError("invalid_argument", "allBranches \u4E0E branch \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
   }
   const slug = encodeURIComponent(projectSlug(input.projectSlug));
@@ -128,7 +109,7 @@ function getWorkflowSummary(input, ctx) {
     path: `/insights/${slug}/workflows/${workflow}/summary`,
     query: {
       "all-branches": typeof input.allBranches === "boolean" ? String(input.allBranches) : void 0,
-      "branch": text(input.branch)
+      "branch": trimmedText(input.branch)
     }
   });
 }
@@ -146,19 +127,19 @@ function getJobArtifacts(input, ctx) {
 function listInsightsSummary(input, ctx) {
   return request(ctx, {
     path: `/insights/${encodeURIComponent(orgSlug(input.orgSlug))}/summary`,
-    query: { "reporting-window": text(input.reportingWindow) }
+    query: { "reporting-window": trimmedText(input.reportingWindow) }
   });
 }
 function triggerPipeline(input, ctx) {
-  const branch = text(input.branch);
-  const tag = text(input.tag);
+  const branch = trimmedText(input.branch);
+  const tag = trimmedText(input.tag);
   if (branch !== void 0 && tag !== void 0) {
     throw new TBError("invalid_argument", "branch \u4E0E tag \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
   }
   const body = {};
   if (branch !== void 0) body.branch = branch;
   if (tag !== void 0) body.tag = tag;
-  const parameters = record(input.parameters);
+  const parameters = asJsonObject(input.parameters);
   if (parameters !== void 0) body.parameters = parameters;
   return request(ctx, {
     method: "POST",