splitwise-mcp 2.0.8 → 2.0.10

package/dist/bundle.js

@@ -6,7 +6,11 @@ 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;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -3105,6 +3109,9 @@ var require_utils = __commonJS({
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3297,27 +3304,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3332,7 +3389,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3346,7 +3403,10 @@ var require_utils = __commonJS({
     module.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3570,12 +3630,12 @@ var require_schemes = __commonJS({
 var require_fast_uri = __commonJS({
   "node_modules/fast-uri/index.js"(exports, module) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse3(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse3(serialize(uri, options), options);
@@ -3642,19 +3702,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse3(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse3(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3679,12 +3729,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3719,7 +3769,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse3(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3730,6 +3789,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3750,6 +3810,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3788,14 +3853,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3804,7 +3873,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse3(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -28416,11 +28507,11 @@ var Protocol = class {
    *
    * The Protocol object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
    */
-  async connect(transport2) {
+  async connect(transport) {
     if (this._transport) {
       throw new Error("Already connected to a transport. Call close() before connecting to a new transport, or use a separate Protocol instance per connection.");
     }
-    this._transport = transport2;
+    this._transport = transport;
     const _onclose = this.transport?.onclose;
     this._transport.onclose = () => {
       _onclose?.();
@@ -30010,8 +30101,8 @@ var McpServer = class {
    *
    * The `server` object assumes ownership of the Transport, replacing any callbacks that have already been set, and expects that it is the only user of the Transport instance going forward.
    */
-  async connect(transport2) {
-    return await this.server.connect(transport2);
+  async connect(transport) {
+    return await this.server.connect(transport);
   }
   /**
    * Closes the connection.
@@ -30861,35 +30952,312 @@ var StdioServerTransport = class {
   }
 };
 
+// node_modules/@chrischall/mcp-utils/dist/server/index.js
+async function createMcpServer(opts) {
+  const server = new McpServer({ name: opts.name, version: opts.version });
+  if (opts.banner !== void 0) {
+    console.error(opts.banner);
+  }
+  const deps = opts.deps;
+  for (const register of opts.tools) {
+    await register(server, deps);
+  }
+  return server;
+}
+function withGracefulShutdown(server, opts = {}) {
+  const shouldExit = opts.exit ?? true;
+  let shuttingDown = false;
+  const handler = (signal) => {
+    if (shuttingDown)
+      return;
+    shuttingDown = true;
+    void (async () => {
+      try {
+        if (opts.onSignal)
+          await opts.onSignal(signal);
+        await server.close();
+      } catch (err) {
+        console.error(`[mcp-utils] error during graceful shutdown on ${signal}: ${err instanceof Error ? err.message : String(err)}`);
+      } finally {
+        if (shouldExit)
+          process.exit(0);
+      }
+    })();
+  };
+  process.on("SIGINT", () => handler("SIGINT"));
+  process.on("SIGTERM", () => handler("SIGTERM"));
+}
+async function runMcp(opts) {
+  const server = await createMcpServer(opts);
+  const shutdown = opts.shutdown ?? true;
+  if (shutdown !== false) {
+    withGracefulShutdown(server, shutdown === true ? {} : shutdown);
+  }
+  const spec = opts.transport ?? "stdio";
+  const transport = spec === "stdio" ? new StdioServerTransport() : spec;
+  await server.connect(transport);
+  return server;
+}
+
+// node_modules/@chrischall/mcp-utils/dist/errors/index.js
+var DEFAULT_ERROR_MESSAGE_MAX = 500;
+var BEARER_RE = /(bearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi;
+var JWT_RE = /\b[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{8,}\b/g;
+var BASIC_AUTH_RE = /(authorization\s*:\s*basic\s+)[A-Za-z0-9+/=_-]{6,}/gi;
+var SET_COOKIE_RE = /(\bset-cookie\s*:\s*)([^=;,\s]+)=[^;,\s]*/gi;
+var COOKIE_HEADER_RE = /((?<!set-)\bcookie\s*:\s*)((?:[^=;,\s]+=[^;,\s]*)(?:;\s*[^=;,\s]+=[^;,\s]*)*)/gi;
+var API_KEY_RE = new RegExp([
+  "sk-[A-Za-z0-9_-]{20,}(?![A-Za-z0-9_-])",
+  // OpenAI / Anthropic (incl. sk-ant-…)
+  "gh[pousr]_[A-Za-z0-9]{36,}\\b",
+  // GitHub ghp_/gho_/ghu_/ghs_/ghr_
+  "xox[baprs]-[A-Za-z0-9-]{10,}(?![A-Za-z0-9-])",
+  // Slack
+  "AIza[0-9A-Za-z_-]{35}(?![0-9A-Za-z_-])",
+  // Google API key (39 chars total)
+  "AKIA[0-9A-Z]{16}\\b",
+  // AWS access key id (20 chars total)
+  "whsec_[A-Za-z0-9]{16,}\\b"
+  // webhook signing secret (Stripe-style)
+].map((p) => `\\b${p}`).join("|"), "g");
+var QUERY_SECRET_RE = /([?&](?:access_token|refresh_token|client_secret|api_?key|signature|token|key|sig)=)[^&#\s"'<>`]+/gi;
+function redactSecrets(text) {
+  return text.replace(BEARER_RE, "$1[REDACTED]").replace(BASIC_AUTH_RE, "$1[REDACTED]").replace(SET_COOKIE_RE, "$1$2=[REDACTED]").replace(COOKIE_HEADER_RE, (_m, prefix, pairs) => `${prefix}${pairs.replace(/=[^;,\s]*/g, "=[REDACTED]")}`).replace(API_KEY_RE, "[REDACTED]").replace(QUERY_SECRET_RE, "$1[REDACTED]").replace(JWT_RE, "[REDACTED]");
+}
+function truncateErrorMessage(text, max = DEFAULT_ERROR_MESSAGE_MAX) {
+  const str = text === null || text === void 0 ? "" : String(text);
+  const redacted = redactSecrets(str);
+  if (redacted.length <= max)
+    return redacted;
+  return `${redacted.slice(0, max)}\u2026 [truncated]`;
+}
+
+// node_modules/@chrischall/mcp-utils/dist/response/index.js
+function textResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }]
+  };
+}
+
+// node_modules/@chrischall/mcp-utils/dist/config/index.js
+var PLACEHOLDER_RE = /^\$\{[^}]*\}$/;
+function readEnvVar(key, opts = {}) {
+  const env = opts.env ?? process.env;
+  const raw = env[key];
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (trimmed.length > 0 && trimmed !== "undefined" && trimmed !== "null" && !PLACEHOLDER_RE.test(trimmed)) {
+      return trimmed;
+    }
+  }
+  return opts.default;
+}
+async function loadDotenvSafely(opts = {}) {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      "dotenv"
+    );
+    const result = mod.config({
+      ...opts.path !== void 0 ? { path: opts.path } : {},
+      override: opts.override ?? false,
+      quiet: true
+    });
+    return result.error === void 0;
+  } catch {
+    return false;
+  }
+}
+
+// node_modules/@chrischall/mcp-utils/dist/http/index.js
+var DEFAULT_RETRY = { count: 1, delayMs: 2e3 };
+var defaultSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+var UnauthorizedError = class extends Error {
+  status = 401;
+  constructor(service) {
+    super(`Unauthorized (401) from ${service} \u2014 the token is missing, invalid, or expired.`);
+    this.name = "UnauthorizedError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var RateLimitedError = class extends Error {
+  status = 429;
+  constructor(service) {
+    super(`Rate limited (429) by ${service} after retries.`);
+    this.name = "RateLimitedError";
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var RequestTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(service, timeoutMs) {
+    super(`Request to ${service} timed out after ${timeoutMs}ms.`);
+    this.name = "RequestTimeoutError";
+    this.timeoutMs = timeoutMs;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var ApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+function hostOf(baseUrl) {
+  try {
+    return new URL(baseUrl).host;
+  } catch {
+    return baseUrl;
+  }
+}
+function createApiClient(opts) {
+  const base = opts.baseUrl.replace(/\/+$/, "");
+  const retry = opts.retry ?? DEFAULT_RETRY;
+  const service = opts.serviceName ?? hostOf(opts.baseUrl);
+  const doFetch = opts.fetchImpl ?? fetch;
+  const sleep = opts.sleep ?? defaultSleep;
+  const unauthorized = () => opts.onUnauthorized ? opts.onUnauthorized() : new UnauthorizedError(service);
+  const rateLimited = () => opts.onRateLimited ? opts.onRateLimited() : new RateLimitedError(service);
+  const retryStatuses = retry.statuses ?? [429];
+  const timeoutMs = opts.timeout;
+  const authHeader = (token) => !token ? {} : opts.tokenHeader ? { [opts.tokenHeader]: token } : { Authorization: `Bearer ${token}` };
+  function withTimeout(run) {
+    if (timeoutMs == null || timeoutMs <= 0)
+      return run(void 0);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    return run(controller.signal).catch((err) => {
+      if (err instanceof Error && err.name === "AbortError")
+        throw new RequestTimeoutError(service, timeoutMs);
+      throw err;
+    }).finally(() => clearTimeout(timer));
+  }
+  async function send(method, path, opt) {
+    const isMultipart = opt.formData !== void 0;
+    const hasJsonBody = !isMultipart && opt.body !== void 0;
+    const reqBody = isMultipart ? opt.formData : hasJsonBody ? JSON.stringify(opt.body) : void 0;
+    const query = opt.query ? buildQueryString(opt.query) : "";
+    const url2 = `${base}${path}${query}`;
+    const bodyInit = reqBody !== void 0 ? { body: reqBody } : {};
+    const fetchWith = (token, signal) => doFetch(url2, {
+      method,
+      headers: {
+        Accept: "application/json",
+        ...hasJsonBody ? { "Content-Type": "application/json" } : {},
+        ...opts.baseHeaders,
+        ...authHeader(token || void 0),
+        ...opt.headers
+      },
+      ...signal ? { signal } : {},
+      ...bodyInit
+    });
+    const once = () => withTimeout((signal) => opts.tokenManager ? opts.tokenManager.withAuth((token) => fetchWith(token, signal)) : (async () => fetchWith(await opts.getToken?.() || void 0, signal))());
+    let attempt = 0;
+    for (; ; ) {
+      const res = await once();
+      if (retryStatuses.includes(res.status) && attempt < retry.count) {
+        attempt += 1;
+        await sleep(retry.delayMs);
+        continue;
+      }
+      return res;
+    }
+  }
+  async function fetchJson(method, path, opt = {}) {
+    const res = await send(method, path, opt);
+    if (res.status === 401)
+      throw unauthorized();
+    if (res.status === 429)
+      throw rateLimited();
+    if (res.status === 204)
+      return void 0;
+    const text = await res.text();
+    if (!res.ok) {
+      throw new ApiError(res.status, formatApiError(res.status, method, path, text, { service }));
+    }
+    if (text.length === 0)
+      return void 0;
+    return JSON.parse(text);
+  }
+  async function fetchHtml(method, path, opt = {}) {
+    const headers = { Accept: "text/html,*/*", ...opt.headers };
+    const res = await send(method, path, { ...opt, headers });
+    if (res.status === 401)
+      throw unauthorized();
+    if (res.status === 429)
+      throw rateLimited();
+    const text = await res.text();
+    if (!res.ok) {
+      throw new ApiError(res.status, formatApiError(res.status, method, path, text, { service }));
+    }
+    return text;
+  }
+  return { fetchJson, fetchHtml };
+}
+function buildQueryString(params) {
+  const parts = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === void 0 || value === null || value === "")
+      continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null || item === "")
+          continue;
+        parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(item))}`);
+      }
+    } else {
+      parts.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+    }
+  }
+  return parts.length > 0 ? `?${parts.join("&")}` : "";
+}
+function formatApiError(status, method, path, errorText, opts = {}) {
+  const service = opts.service ?? "API";
+  const head = `${service} error ${status} for ${method.toUpperCase()} ${path}`;
+  const safe = truncateErrorMessage(errorText ?? "", opts.max).trim();
+  return safe.length > 0 ? `${head}: ${safe}` : head;
+}
+
+// node_modules/@chrischall/mcp-utils/dist/zod/index.js
+var PositiveInt = external_exports.number().int().positive();
+var NonNegInt = external_exports.number().int().nonnegative();
+var NonEmptyString = external_exports.string().min(1);
+var IsoDate = external_exports.iso.date();
+var IsoTime = external_exports.string().regex(/^([01]?\d|2[0-3]):[0-5]\d$/, "must be HH:MM (24h), e.g. 19:30");
+var NumericIdString = external_exports.string().regex(/^\d+$/, "must be a numeric id (digits only)").describe("A numeric id string (digits only), safe to interpolate into a URL path.");
+var SafePathSegment = external_exports.string().min(1).regex(/^[^/?#\s]+$/, 'must not contain "/", "?", "#", or whitespace').refine((v) => !v.includes(".."), 'must not contain ".."').describe('A single URL path segment, safe to interpolate: no "/", "..", "?", "#", or whitespace.');
+var schemaOrigin = external_exports.string().optional().describe("Portal origin (e.g. https://<vendor>.example.co) selecting which active session to use. Optional when only one session is active.");
+var schemaConfirm = external_exports.boolean().optional().describe("Must be true to proceed. Without this, the tool returns a preview.");
+var paginationSchema = {
+  offset: NonNegInt.default(0).describe("Number of items to skip (0-based)."),
+  limit: external_exports.number().int().min(1).max(200).default(50).describe("Maximum number of items to return (1-200).")
+};
+var pageSchema = {
+  page_num: PositiveInt.default(1).describe("1-based page number."),
+  page_size: external_exports.number().int().min(1).max(200).default(50).describe("Number of items per page (1-200).")
+};
+
 // src/client.ts
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
-try {
-  const { config: config2 } = await import("dotenv");
-  const __dirname = dirname(fileURLToPath(import.meta.url));
-  config2({ path: join(__dirname, "..", ".env"), override: false, quiet: true });
-} catch {
-}
-function readVar(key) {
-  const raw = process.env[key];
-  if (typeof raw !== "string") return void 0;
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return void 0;
-  if (trimmed === "undefined" || trimmed === "null") return void 0;
-  if (/^\$\{[^}]*\}$/.test(trimmed)) return void 0;
-  return trimmed;
-}
+var __dirname = dirname(fileURLToPath(import.meta.url));
+await loadDotenvSafely({ path: join(__dirname, "..", ".env"), override: false });
 var BASE_URL = "https://secure.splitwise.com/api/v3.0";
+var SERVICE_NAME = "Splitwise";
 var SplitwiseClient = class {
   apiKey;
   configError;
+  api;
   /**
    * Defer the config error so the server can still start (and respond to the
    * host's install-time smoke test) when SPLITWISE_API_KEY isn't set yet.
    * Tool calls re-raise the error at request time.
    */
   constructor() {
-    const key = readVar("SPLITWISE_API_KEY");
+    const key = readEnvVar("SPLITWISE_API_KEY");
     if (!key) {
       this.apiKey = null;
       this.configError = new Error("SPLITWISE_API_KEY environment variable is required");
@@ -30897,64 +31265,46 @@ var SplitwiseClient = class {
       this.apiKey = key;
       this.configError = null;
     }
+    this.api = createApiClient({
+      baseUrl: BASE_URL,
+      getToken: () => this.requireKey(),
+      serviceName: SERVICE_NAME,
+      retry: { count: 1, delayMs: 2e3 },
+      timeout: 3e4,
+      onUnauthorized: () => new Error("SPLITWISE_API_KEY is invalid or missing"),
+      onRateLimited: () => new Error("Rate limited by Splitwise API")
+    });
   }
   requireKey() {
     if (this.configError) throw this.configError;
     return this.apiKey;
   }
   async request(method, path, body) {
-    return this.doRequest(method, path, body, false);
-  }
-  async doRequest(method, path, body, isRetry) {
-    const headers = {
-      Authorization: `Bearer ${this.requireKey()}`,
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    };
-    const response = await fetch(`${BASE_URL}${path}`, {
-      method,
-      headers,
-      ...body !== void 0 ? { body: JSON.stringify(body) } : {}
-    });
-    if (response.status === 401) {
-      throw new Error("SPLITWISE_API_KEY is invalid or missing");
-    }
-    if (response.status === 429) {
-      if (!isRetry) {
-        await new Promise((r) => setTimeout(r, 2e3));
-        return this.doRequest(method, path, body, true);
-      }
-      throw new Error("Rate limited by Splitwise API");
-    }
-    if (!response.ok) {
-      throw new Error(
-        `Splitwise API error: ${response.status} ${response.statusText} for ${method} ${path}`
-      );
-    }
-    return response.json();
+    return this.api.fetchJson(method, path, body !== void 0 ? { body } : {});
   }
 };
+var client = new SplitwiseClient();
 
 // src/tools/user.ts
-function registerUserTools(server2, client2) {
-  server2.registerTool("sw_get_current_user", {
+function registerUserTools(server) {
+  server.registerTool("sw_get_current_user", {
     description: "Get the authenticated Splitwise user's profile (id, first_name, last_name, email). Use the returned id when building custom expense splits.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_current_user");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_current_user");
+    return textResult(data);
   });
-  server2.registerTool("sw_get_user", {
+  server.registerTool("sw_get_user", {
     description: "Get another Splitwise user's profile by id.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       id: external_exports.number().describe("User ID")
     }
   }, async ({ id }) => {
-    const data = await client2.request("GET", `/get_user/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", `/get_user/${id}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_update_user", {
+  server.registerTool("sw_update_user", {
     description: "Update the current user's profile fields. id must be the current user's id.",
     inputSchema: {
       id: external_exports.number().describe("User ID (must be the current user's id)"),
@@ -30973,31 +31323,31 @@ function registerUserTools(server2, client2) {
     if (password !== void 0) body.password = password;
     if (locale !== void 0) body.locale = locale;
     if (default_currency !== void 0) body.default_currency = default_currency;
-    const data = await client2.request("POST", `/update_user/${id}`, body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/update_user/${id}`, body);
+    return textResult(data);
   });
 }
 
 // src/tools/groups.ts
-function registerGroupTools(server2, client2) {
-  server2.registerTool("sw_list_groups", {
+function registerGroupTools(server) {
+  server.registerTool("sw_list_groups", {
     description: "List all Splitwise groups the current user belongs to. Returns id, name, and members for each group. Use this to resolve a group name to its id.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_groups");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_groups");
+    return textResult(data);
   });
-  server2.registerTool("sw_get_group", {
+  server.registerTool("sw_get_group", {
     description: "Get details of a single Splitwise group including all members and balances.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       id: external_exports.number().describe("Group ID")
     }
   }, async ({ id }) => {
-    const data = await client2.request("GET", `/get_group/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", `/get_group/${id}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_create_group", {
+  server.registerTool("sw_create_group", {
     description: "Create a new Splitwise group.",
     inputSchema: {
       name: external_exports.string().describe("Group name"),
@@ -31008,10 +31358,10 @@ function registerGroupTools(server2, client2) {
     const body = { name };
     if (group_type !== void 0) body.group_type = group_type;
     if (simplify_by_default !== void 0) body.simplify_by_default = simplify_by_default;
-    const data = await client2.request("POST", "/create_group", body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/create_group", body);
+    return textResult(data);
   });
-  server2.registerTool("sw_add_user_to_group", {
+  server.registerTool("sw_add_user_to_group", {
     description: "Add a user to a Splitwise group. Provide user_id (preferred, use sw_list_friends to resolve a name) or first_name + last_name + email to invite by email.",
     inputSchema: {
       group_id: external_exports.number().describe("Group ID"),
@@ -31030,50 +31380,50 @@ function registerGroupTools(server2, client2) {
       }
       body = { group_id, first_name, last_name, email: email3 };
     }
-    const data = await client2.request("POST", "/add_user_to_group", body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/add_user_to_group", body);
+    return textResult(data);
   });
-  server2.registerTool("sw_remove_user_from_group", {
+  server.registerTool("sw_remove_user_from_group", {
     description: "Remove a user from a Splitwise group.",
     inputSchema: {
       group_id: external_exports.number().describe("Group ID"),
       user_id: external_exports.number().describe("User ID to remove")
     }
   }, async ({ group_id, user_id }) => {
-    const data = await client2.request("POST", "/remove_user_from_group", { group_id, user_id });
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/remove_user_from_group", { group_id, user_id });
+    return textResult(data);
   });
-  server2.registerTool("sw_delete_group", {
+  server.registerTool("sw_delete_group", {
     description: "Soft-delete a Splitwise group.",
     annotations: { destructiveHint: true },
     inputSchema: {
       id: external_exports.number().describe("Group ID to delete")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/delete_group/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/delete_group/${id}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_undelete_group", {
+  server.registerTool("sw_undelete_group", {
     description: "Restore a soft-deleted Splitwise group.",
     inputSchema: {
       id: external_exports.number().describe("Group ID to restore")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/undelete_group/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/undelete_group/${id}`);
+    return textResult(data);
   });
 }
 
 // src/tools/friends.ts
-function registerFriendTools(server2, client2) {
-  server2.registerTool("sw_list_friends", {
+function registerFriendTools(server) {
+  server.registerTool("sw_list_friends", {
     description: "List all Splitwise friends with their id, first_name, last_name, and email. Use this to resolve a friend's name to a user_id before adding them to a group or building a custom expense split.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_friends");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_friends");
+    return textResult(data);
   });
-  server2.registerTool("sw_create_friend", {
+  server.registerTool("sw_create_friend", {
     description: "Add a Splitwise friend by email.",
     inputSchema: {
       user_email: external_exports.string().describe("Email of the user to add as a friend"),
@@ -31084,18 +31434,18 @@ function registerFriendTools(server2, client2) {
     const body = { user_email };
     if (user_first_name !== void 0) body.user_first_name = user_first_name;
     if (user_last_name !== void 0) body.user_last_name = user_last_name;
-    const data = await client2.request("POST", "/create_friend", body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/create_friend", body);
+    return textResult(data);
   });
-  server2.registerTool("sw_delete_friend", {
+  server.registerTool("sw_delete_friend", {
     description: "Remove a Splitwise friendship by user id.",
     annotations: { destructiveHint: true },
     inputSchema: {
       id: external_exports.number().describe("User ID of the friend to remove")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/delete_friend/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/delete_friend/${id}`);
+    return textResult(data);
   });
 }
 
@@ -31127,8 +31477,8 @@ var userShareSchema = external_exports.object({
   paid_share: external_exports.string().describe('Amount this user paid, e.g. "25.00"'),
   owed_share: external_exports.string().describe('Amount this user owes, e.g. "12.50"')
 });
-function registerExpenseTools(server2, client2) {
-  server2.registerTool("sw_list_expenses", {
+function registerExpenseTools(server) {
+  server.registerTool("sw_list_expenses", {
     description: "List or search Splitwise expenses. All filters are optional. Use group_id to filter by group, dated_after/dated_before for date ranges.",
     annotations: { readOnlyHint: true },
     inputSchema: {
@@ -31142,27 +31492,30 @@ function registerExpenseTools(server2, client2) {
       offset: external_exports.number().describe("Pagination offset").optional()
     }
   }, async (args) => {
-    const params = new URLSearchParams();
-    const filters = ["group_id", "friend_id", "dated_after", "dated_before", "updated_after", "updated_before", "limit", "offset"];
-    for (const key of filters) {
-      const val = args[key];
-      if (val !== void 0) params.append(key, String(val));
-    }
-    const qs = params.toString();
-    const data = await client2.request("GET", qs ? `/get_expenses?${qs}` : "/get_expenses");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const qs = buildQueryString({
+      group_id: args.group_id,
+      friend_id: args.friend_id,
+      dated_after: args.dated_after,
+      dated_before: args.dated_before,
+      updated_after: args.updated_after,
+      updated_before: args.updated_before,
+      limit: args.limit,
+      offset: args.offset
+    });
+    const data = await client.request("GET", `/get_expenses${qs}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_get_expense", {
+  server.registerTool("sw_get_expense", {
     description: "Get full details of a single Splitwise expense by id.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       id: external_exports.number().describe("Expense ID")
     }
   }, async ({ id }) => {
-    const data = await client2.request("GET", `/get_expense/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", `/get_expense/${id}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_create_expense", {
+  server.registerTool("sw_create_expense", {
     description: 'Create a Splitwise expense. Use split_equally:true to split evenly among group members, or provide a users array for custom per-person splits (paid_share and owed_share as decimal strings like "25.00"). cost must be a decimal string.',
     inputSchema: {
       group_id: external_exports.number().describe("Group to add expense to (use 0 for no group)"),
@@ -31177,10 +31530,10 @@ function registerExpenseTools(server2, client2) {
     }
   }, async (args) => {
     const body = buildExpenseBody(args);
-    const data = await client2.request("POST", "/create_expense", body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/create_expense", body);
+    return textResult(data);
   });
-  server2.registerTool("sw_update_expense", {
+  server.registerTool("sw_update_expense", {
     description: "Edit an existing Splitwise expense. Provide expense_id and any fields to change. For custom split updates, the full users array must be provided (the API replaces the entire split).",
     inputSchema: {
       expense_id: external_exports.number().describe("ID of the expense to update"),
@@ -31196,93 +31549,96 @@ function registerExpenseTools(server2, client2) {
   }, async (args) => {
     const { expense_id } = args;
     const body = buildExpenseBody(args);
-    const data = await client2.request("POST", `/update_expense/${expense_id}`, body);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/update_expense/${expense_id}`, body);
+    return textResult(data);
   });
-  server2.registerTool("sw_delete_expense", {
+  server.registerTool("sw_delete_expense", {
     description: "Soft-delete a Splitwise expense by id. Returns {success: true} on success. Use sw_undelete_expense to restore.",
     annotations: { destructiveHint: true },
     inputSchema: {
       id: external_exports.number().describe("Expense ID to delete")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/delete_expense/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/delete_expense/${id}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_undelete_expense", {
+  server.registerTool("sw_undelete_expense", {
     description: "Restore a soft-deleted Splitwise expense.",
     inputSchema: {
       id: external_exports.number().describe("Expense ID to restore")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/undelete_expense/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/undelete_expense/${id}`);
+    return textResult(data);
   });
 }
 
 // src/tools/utilities.ts
-function registerUtilityTools(server2, client2) {
-  server2.registerTool("sw_get_notifications", {
+function registerUtilityTools(server) {
+  server.registerTool("sw_get_notifications", {
     description: "Get recent Splitwise activity notifications for the current user.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_notifications");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_notifications");
+    return textResult(data);
   });
-  server2.registerTool("sw_get_categories", {
+  server.registerTool("sw_get_categories", {
     description: "Get the hierarchical list of Splitwise expense categories. Use the returned id as category_id when creating expenses.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_categories");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_categories");
+    return textResult(data);
   });
-  server2.registerTool("sw_get_currencies", {
+  server.registerTool("sw_get_currencies", {
     description: "Get all Splitwise-supported currency codes and units. Use the currency_code value when creating expenses in non-default currencies.",
     annotations: { readOnlyHint: true }
   }, async () => {
-    const data = await client2.request("GET", "/get_currencies");
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", "/get_currencies");
+    return textResult(data);
   });
-  server2.registerTool("sw_get_comments", {
+  server.registerTool("sw_get_comments", {
     description: "Get all comments on a Splitwise expense.",
     annotations: { readOnlyHint: true },
     inputSchema: {
       expense_id: external_exports.number().describe("Expense ID to get comments for")
     }
   }, async ({ expense_id }) => {
-    const data = await client2.request("GET", `/get_comments?expense_id=${expense_id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("GET", `/get_comments${buildQueryString({ expense_id })}`);
+    return textResult(data);
   });
-  server2.registerTool("sw_create_comment", {
+  server.registerTool("sw_create_comment", {
     description: "Add a comment to a Splitwise expense.",
     inputSchema: {
       expense_id: external_exports.number().describe("Expense ID to comment on"),
       content: external_exports.string().describe("Comment text")
     }
   }, async ({ expense_id, content }) => {
-    const data = await client2.request("POST", "/create_comment", { expense_id, content });
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", "/create_comment", { expense_id, content });
+    return textResult(data);
   });
-  server2.registerTool("sw_delete_comment", {
+  server.registerTool("sw_delete_comment", {
     description: "Delete a comment by id.",
     annotations: { destructiveHint: true },
     inputSchema: {
       id: external_exports.number().describe("Comment ID to delete")
     }
   }, async ({ id }) => {
-    const data = await client2.request("POST", `/delete_comment/${id}`);
-    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+    const data = await client.request("POST", `/delete_comment/${id}`);
+    return textResult(data);
   });
 }
 
 // src/index.ts
-var client = new SplitwiseClient();
-var server = new McpServer({ name: "splitwise-mcp", version: "2.0.8" });
-registerUserTools(server, client);
-registerGroupTools(server, client);
-registerFriendTools(server, client);
-registerExpenseTools(server, client);
-registerUtilityTools(server, client);
-console.error("[splitwise-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.");
-var transport = new StdioServerTransport();
-await server.connect(transport);
+await runMcp({
+  name: "splitwise-mcp",
+  version: "2.0.10",
+  // x-release-please-version
+  banner: "[splitwise-mcp] This project was developed and is maintained by AI (Claude Sonnet 4.6). Use at your own discretion.",
+  tools: [
+    registerUserTools,
+    registerGroupTools,
+    registerFriendTools,
+    registerExpenseTools,
+    registerUtilityTools
+  ]
+});