@klappay/mcp 0.0.0-stage → 1.0.0

package/dist/start-4SOOSFNC.js

@@ -0,0 +1,620 @@
+#!/usr/bin/env node
+import {
+  SERVER_NAME
+} from "./chunk-FCIY5UOM.js";
+
+// src/start.ts
+import { loadCredentials } from "@klappay/cli/credentials";
+import { createClient } from "@klappay/node";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/environment.ts
+import {
+  CREDENTIALS_DISPLAY_PATH,
+  KlapCredentialsError,
+  detectEnvironment
+} from "@klappay/cli/credentials";
+var LOOPBACK_HOSTNAMES = ["localhost", "127.0.0.1", "[::1]"];
+var LIVE_WRITES_ENABLED_VALUE = "1";
+var LOGIN_COMMAND = "`klap login --api-key - --base-url <url>`";
+var LOGIN_HINT = `Run ${LOGIN_COMMAND} (from @klappay/cli) or set KLAP_API_KEY and KLAP_BASE_URL.`;
+var CREDENTIALS_ERROR_MESSAGES = {
+  invalid_api_key_prefix: `A key in ${CREDENTIALS_DISPLAY_PATH} does not start with klap_test_ or klap_live_. Run ${LOGIN_COMMAND} again.`,
+  invalid_credentials_file: `${CREDENTIALS_DISPLAY_PATH} is corrupted or has a key in the wrong environment slot. Run \`klap logout\` to remove it, then ${LOGIN_COMMAND} again.`,
+  credentials_path_symlink: `Refusing to read ${CREDENTIALS_DISPLAY_PATH}: it (or ~/.klap) is a symbolic link. Remove the link, then run ${LOGIN_COMMAND} to create a real ~/.klap directory.`,
+  no_credentials: `No API key in ${CREDENTIALS_DISPLAY_PATH}. ${LOGIN_HINT}`,
+  missing_environment_key: `${CREDENTIALS_DISPLAY_PATH} has no key for the requested environment. Run ${LOGIN_COMMAND} with that key, or change KLAP_ENV.`,
+  ambiguous_environment: `${CREDENTIALS_DISPLAY_PATH} has keys for both environments; set KLAP_ENV to test or live.`
+};
+function credentialsErrorMessage(err) {
+  if (Object.hasOwn(CREDENTIALS_ERROR_MESSAGES, err.code))
+    return CREDENTIALS_ERROR_MESSAGES[err.code];
+  return `Could not use ${CREDENTIALS_DISPLAY_PATH} (${err.code}). Run \`klap logout\`, then ${LOGIN_COMMAND} again.`;
+}
+function refuse(message) {
+  return { ok: false, message };
+}
+function presentValue(value) {
+  return value === void 0 || value === "" ? void 0 : value;
+}
+function parseEnvironment(value) {
+  if (value === void 0) return "test";
+  if (value === "test" || value === "live") return value;
+  return null;
+}
+function keyEnvironment(apiKey) {
+  try {
+    return detectEnvironment(apiKey);
+  } catch {
+    return null;
+  }
+}
+function baseUrlProblem(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return `${label} is not a valid URL.`;
+  }
+  if (url.username !== "" || url.password !== "") {
+    return `${label} must not contain a username or password.`;
+  }
+  if (url.protocol === "https:") return null;
+  if (url.protocol === "http:" && LOOPBACK_HOSTNAMES.includes(url.hostname)) return null;
+  return `${label} must use https:// (http:// is only allowed for localhost, 127.0.0.1 or [::1]).`;
+}
+function normalizedBaseUrl(value) {
+  const url = new URL(value);
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}`;
+}
+function keyMismatchMessage(source, keyEnv, wanted) {
+  return `${source} is a ${keyEnv} key, but the server is set to ${wanted} (KLAP_ENV${wanted === "test" ? " unset or test" : "=live"}). Refusing to start.`;
+}
+function resolveFromEnvKey(apiKey, baseUrl, environment, allowLiveWrites) {
+  if (baseUrl === void 0) {
+    return refuse("KLAP_API_KEY is set but KLAP_BASE_URL is not; set both.");
+  }
+  const urlProblem = baseUrlProblem(baseUrl, "KLAP_BASE_URL");
+  if (urlProblem) return refuse(urlProblem);
+  const keyEnv = keyEnvironment(apiKey);
+  if (keyEnv === null) return refuse("KLAP_API_KEY must start with klap_test_ or klap_live_.");
+  if (keyEnv !== environment) return refuse(keyMismatchMessage("KLAP_API_KEY", keyEnv, environment));
+  return { ok: true, apiKey, baseUrl, environment, allowLiveWrites, keySource: "env" };
+}
+async function loadConfigOrRefusal(loadConfig) {
+  try {
+    const config = await loadConfig();
+    return config ?? refuse(`No ${CREDENTIALS_DISPLAY_PATH} found. ${LOGIN_HINT}`);
+  } catch (err) {
+    if (err instanceof KlapCredentialsError) return refuse(credentialsErrorMessage(err));
+    const code = err instanceof Error && "code" in err ? String(err.code) : "unknown error";
+    return refuse(`Could not read ${CREDENTIALS_DISPLAY_PATH} (${code}).`);
+  }
+}
+async function resolveFromConfig(loadConfig, overrideBaseUrl, environment, allowLiveWrites) {
+  const loaded = await loadConfigOrRefusal(loadConfig);
+  if ("ok" in loaded) return loaded;
+  const apiKey = loaded.apiKeys[environment];
+  if (apiKey === void 0 || apiKey === "") {
+    return refuse(
+      `${CREDENTIALS_DISPLAY_PATH} has no ${environment} key. Run ${LOGIN_COMMAND} with a klap_${environment}_ key, or set KLAP_ENV to the environment you have a key for.`
+    );
+  }
+  const keyEnv = keyEnvironment(apiKey);
+  if (keyEnv !== environment) {
+    return refuse(
+      `The ${environment} slot in ${CREDENTIALS_DISPLAY_PATH} does not hold a klap_${environment}_ key. Run ${LOGIN_COMMAND} again.`
+    );
+  }
+  const urlProblem = baseUrlProblem(loaded.baseUrl, `The baseUrl in ${CREDENTIALS_DISPLAY_PATH}`);
+  if (urlProblem) return refuse(urlProblem);
+  if (overrideBaseUrl !== void 0) {
+    const overrideProblem = baseUrlProblem(overrideBaseUrl, "KLAP_BASE_URL");
+    if (overrideProblem) return refuse(overrideProblem);
+    if (normalizedBaseUrl(overrideBaseUrl) !== normalizedBaseUrl(loaded.baseUrl)) {
+      return refuse(
+        `KLAP_BASE_URL differs from the baseUrl stored in ${CREDENTIALS_DISPLAY_PATH}. A stored key is only ever sent to the base URL it was saved with \u2014 unset KLAP_BASE_URL, or set KLAP_API_KEY together with KLAP_BASE_URL instead.`
+      );
+    }
+  }
+  return {
+    ok: true,
+    apiKey,
+    baseUrl: loaded.baseUrl,
+    environment,
+    allowLiveWrites,
+    keySource: "config"
+  };
+}
+async function resolveServerEnvironment(vars, loadConfig) {
+  const environment = parseEnvironment(presentValue(vars.KLAP_ENV));
+  if (environment === null) return refuse('KLAP_ENV must be unset, "test" or "live".');
+  const allowLiveWrites = vars.KLAP_MCP_ALLOW_LIVE_WRITES === LIVE_WRITES_ENABLED_VALUE;
+  const apiKey = presentValue(vars.KLAP_API_KEY);
+  const baseUrl = presentValue(vars.KLAP_BASE_URL);
+  if (apiKey !== void 0) {
+    return resolveFromEnvKey(apiKey, baseUrl, environment, allowLiveWrites);
+  }
+  return resolveFromConfig(loadConfig, baseUrl, environment, allowLiveWrites);
+}
+
+// src/redact.ts
+var REDACTED_URL = "[unparseable url]";
+function redactUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return REDACTED_URL;
+  }
+  if (url.origin === "null") return REDACTED_URL;
+  return `${url.origin}${url.pathname}`;
+}
+function hostOf(baseUrl) {
+  try {
+    return new URL(baseUrl).host;
+  } catch {
+    return REDACTED_URL;
+  }
+}
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// package.json
+var version = "1.0.0";
+
+// src/tool-policy.ts
+function isToolAllowed(access, environment, allowLiveWrites) {
+  if (environment === "test") return true;
+  if (access === "read") return true;
+  if (access === "write") return allowLiveWrites;
+  return false;
+}
+
+// src/tools/charges.ts
+import {
+  ChargeSchema as ChargeSchema2,
+  CheckChargeRequestSchema,
+  CheckChargeResponseSchema,
+  CreateChargeSchema,
+  TimelineEventSchema
+} from "@klappay/types";
+import { z as z2 } from "zod";
+
+// src/ids.ts
+import { z } from "zod";
+var ID_BODY_MAX_LENGTH = 64;
+function prefixedIdSchema(prefix, label) {
+  return z.string().regex(
+    new RegExp(`^${prefix}_[A-Za-z0-9]{1,${ID_BODY_MAX_LENGTH}}$`),
+    `must be a ${label} id like ${prefix}_...`
+  ).describe(`A Klappay ${label} id (\`${prefix}_\` followed by letters and digits).`);
+}
+var ChargeIdSchema = prefixedIdSchema("ch", "charge");
+var WebhookIdSchema = prefixedIdSchema("wh", "webhook");
+var WebhookDeliveryIdSchema = prefixedIdSchema("ev", "webhook delivery");
+
+// src/result.ts
+import { KlapApiError } from "@klappay/node";
+import { ZodError } from "zod";
+var UNEXPECTED_ERROR_MESSAGE = "Unexpected error calling the Klap API";
+var UNEXPECTED_RESPONSE_CODE = "unexpected_response";
+var VALIDATION_ERROR_CODE = "validation_error";
+var ToolInputError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ToolInputError";
+  }
+};
+function toResult(payload, isError) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    structuredContent: payload,
+    ...isError ? { isError: true } : {}
+  };
+}
+function successResult(environment, data) {
+  return toResult({ ...data, environment }, false);
+}
+function describeForLog(err) {
+  if (!(err instanceof Error)) return typeof err;
+  const cause = err.cause instanceof Error ? ` (cause: ${err.cause.name}: ${err.cause.message})` : "";
+  return `${err.name}: ${err.message}${cause}`;
+}
+function zodIssuePaths(err) {
+  return err.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.code}`).join("; ");
+}
+function errorResult(environment, err) {
+  if (err instanceof KlapApiError) {
+    return toResult(
+      { environment, error: { code: err.code, status: err.status, message: err.message } },
+      true
+    );
+  }
+  if (err instanceof ToolInputError) {
+    return toResult(
+      { environment, error: { code: VALIDATION_ERROR_CODE, message: err.message } },
+      true
+    );
+  }
+  if (err instanceof ZodError) {
+    console.error(`klap-mcp: API response did not match the expected schema: ${zodIssuePaths(err)}`);
+    return toResult(
+      {
+        environment,
+        error: {
+          code: UNEXPECTED_RESPONSE_CODE,
+          message: "The Klap API returned a response this server does not recognize."
+        }
+      },
+      true
+    );
+  }
+  console.error(`klap-mcp: ${UNEXPECTED_ERROR_MESSAGE}: ${describeForLog(err)}`);
+  return toResult(
+    { environment, error: { code: "unexpected_error", message: UNEXPECTED_ERROR_MESSAGE } },
+    true
+  );
+}
+async function runTool(environment, action) {
+  try {
+    return successResult(environment, await action());
+  } catch (err) {
+    return errorResult(environment, err);
+  }
+}
+
+// src/tools/charge-output.ts
+import { ChargeSchema } from "@klappay/types";
+var ChargeWithoutMetadataSchema = ChargeSchema.omit({ metadata: true });
+
+// src/tools/charges.ts
+var CheckResponseWithoutMetadataSchema = CheckChargeResponseSchema.omit({ metadata: true });
+var TimelineSchema = z2.array(TimelineEventSchema);
+var CreateChargeToolInputSchema = CreateChargeSchema.innerType().omit({ escrow: true, redirectUrl: true }).strict();
+var GetChargeInputSchema = z2.object({
+  id: ChargeIdSchema,
+  includeMetadata: z2.boolean().default(false).describe(
+    "Include the charge's free-form `metadata` object (merchant-supplied data, may hold customer details). Omitted unless true."
+  )
+}).strict();
+var ChargeIdInputSchema = z2.object({ id: ChargeIdSchema }).strict();
+var CheckChargeInputSchema = CheckChargeRequestSchema.innerType().extend({ id: ChargeIdSchema }).strict();
+function validationMessage(error) {
+  return error.issues.map((issue) => issue.message).join("; ");
+}
+var chargeTools = [
+  {
+    name: "charges_get",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "charges_get",
+        {
+          title: "Get charge",
+          description: "Fetch one charge by id: status, settlement status, amounts, accepted payment pairs, split recipients and timestamps. `metadata` is left out unless includeMetadata is true.",
+          inputSchema: GetChargeInputSchema,
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        ({ id, includeMetadata }) => runTool(environment, async () => {
+          const charge = await client.charges.get(id);
+          const schema = includeMetadata ? ChargeSchema2 : ChargeWithoutMetadataSchema;
+          return { charge: schema.parse(charge) };
+        })
+      );
+    }
+  },
+  {
+    name: "charges_timeline",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "charges_timeline",
+        {
+          title: "Get charge timeline",
+          description: "List the lifecycle events of one charge in order (created, transfers detected, confirmed, settled, ...).",
+          inputSchema: ChargeIdInputSchema,
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        ({ id }) => runTool(environment, async () => ({
+          chargeId: id,
+          events: TimelineSchema.parse(await client.charges.getTimeline(id))
+        }))
+      );
+    }
+  },
+  {
+    name: "charges_create",
+    access: "write",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "charges_create",
+        {
+          title: "Create charge",
+          description: `Create a new ${environment} charge. Escrow charges and redirectUrl are not available through this server. Pass idempotencyKey to make a retry safe; without it every call creates a new charge.`,
+          inputSchema: CreateChargeToolInputSchema,
+          annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: true
+          }
+        },
+        (input) => runTool(environment, async () => ({
+          charge: ChargeWithoutMetadataSchema.parse(await client.charges.create(input))
+        }))
+      );
+    }
+  },
+  {
+    name: "charges_check",
+    access: "write",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "charges_check",
+        {
+          title: "Re-check charge on-chain",
+          description: "Ask the API to re-check a charge's payment on-chain now instead of waiting for the background pass. Optionally pass txHash together with network to verify one specific transaction. Never credits anything that is not really on-chain.",
+          inputSchema: CheckChargeInputSchema,
+          annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true
+          }
+        },
+        ({ id, ...hint }) => runTool(environment, async () => {
+          const request = CheckChargeRequestSchema.safeParse(hint);
+          if (!request.success) throw new ToolInputError(validationMessage(request.error));
+          const checked = await client.charges.check(id, request.data);
+          return { charge: CheckResponseWithoutMetadataSchema.parse(checked) };
+        })
+      );
+    }
+  }
+];
+
+// src/tools/metrics.ts
+import { MetricsQueryResultSchema, MetricsQuerySchema } from "@klappay/types";
+import { z as z3 } from "zod";
+var MetricsQueryInputSchema = z3.object({
+  query: MetricsQuerySchema.describe(
+    "The metrics query: a resource (charges, transactions or distributions), metrics to aggregate, an ISO 8601 dateRange, optional filters and groupBy."
+  )
+}).strict();
+var metricsTools = [
+  {
+    name: "metrics_query",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "metrics_query",
+        {
+          title: "Query business metrics",
+          description: "Run an aggregate query over this environment's charges, transactions or distributions (counts, sums, grouped by date bucket or dimension).",
+          inputSchema: MetricsQueryInputSchema,
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        ({ query }) => runTool(
+          environment,
+          async () => MetricsQueryResultSchema.parse(await client.metrics.query(query))
+        )
+      );
+    }
+  }
+];
+
+// src/tools/networks.ts
+import { CapabilitiesSchema } from "@klappay/types";
+var networkTools = [
+  {
+    name: "networks_get",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "networks_get",
+        {
+          title: "Get accepted networks",
+          description: "List the (token, network) payment pairs this environment accepts right now \u2014 the same list charges_create validates acceptedPayments against.",
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        () => runTool(environment, async () => CapabilitiesSchema.parse(await client.networks.get()))
+      );
+    }
+  }
+];
+
+// src/tools/sandbox.ts
+import { SandboxTriggerSchema } from "@klappay/types";
+var SandboxTriggerInputSchema = SandboxTriggerSchema.extend({ chargeId: ChargeIdSchema }).strict();
+var sandboxTools = [
+  {
+    name: "sandbox_trigger",
+    access: "sandbox",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "sandbox_trigger",
+        {
+          title: "Simulate sandbox charge event",
+          description: "Push a test charge into a payment state (confirmed, partially paid, overpaid, expired, underpaid, settled, settlement failed) without moving funds, and fire the matching webhook. Test environment only.",
+          inputSchema: SandboxTriggerInputSchema,
+          annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true
+          }
+        },
+        ({ chargeId, event, amount }) => runTool(environment, async () => ({
+          charge: ChargeWithoutMetadataSchema.parse(
+            await client.sandbox.trigger(chargeId, event, amount)
+          )
+        }))
+      );
+    }
+  }
+];
+
+// src/tools/status.ts
+var statusTools = [
+  {
+    name: "klap_status",
+    access: "read",
+    register(server, { environment, baseUrl }) {
+      server.registerTool(
+        "klap_status",
+        {
+          title: "Klap connection status",
+          description: "Show which Klap environment (test or live) and API host this server is connected to. Makes no API call.",
+          annotations: { readOnlyHint: true, openWorldHint: false }
+        },
+        () => successResult(environment, { host: hostOf(baseUrl) })
+      );
+    }
+  }
+];
+
+// src/tools/webhooks.ts
+import {
+  ListWebhookDeliveriesSchema,
+  PaginatedWebhookDeliveriesSchema,
+  WebhookListItemSchema
+} from "@klappay/types";
+import { z as z4 } from "zod";
+var WebhookListSchema = z4.array(WebhookListItemSchema);
+var ListDeliveriesInputSchema = ListWebhookDeliveriesSchema.extend({
+  webhookId: WebhookIdSchema
+}).strict();
+var RetryDeliveryInputSchema = z4.object({ webhookId: WebhookIdSchema, deliveryId: WebhookDeliveryIdSchema }).strict();
+var webhookTools = [
+  {
+    name: "webhooks_list",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "webhooks_list",
+        {
+          title: "List webhooks",
+          description: "List webhook endpoints and the events they subscribe to. Endpoint URLs are shown as origin + path only (credentials and query strings removed); secrets are never returned, only their display hint.",
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        () => runTool(environment, async () => {
+          const webhooks = WebhookListSchema.parse(await client.webhooks.list());
+          return {
+            webhooks: webhooks.map((webhook) => ({ ...webhook, url: redactUrl(webhook.url) }))
+          };
+        })
+      );
+    }
+  },
+  {
+    name: "webhooks_list_deliveries",
+    access: "read",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "webhooks_list_deliveries",
+        {
+          title: "List webhook deliveries",
+          description: "List one webhook's delivery attempts (event, status, attempts, response code), newest first. Paginate with limit and the previous page's nextCursor.",
+          inputSchema: ListDeliveriesInputSchema,
+          annotations: { readOnlyHint: true, openWorldHint: true }
+        },
+        ({ webhookId, ...page }) => runTool(environment, async () => {
+          const deliveries = await client.webhooks.listDeliveries(webhookId, page);
+          return { webhookId, ...PaginatedWebhookDeliveriesSchema.parse(deliveries) };
+        })
+      );
+    }
+  },
+  {
+    name: "webhooks_retry_delivery",
+    access: "write",
+    register(server, { client, environment }) {
+      server.registerTool(
+        "webhooks_retry_delivery",
+        {
+          title: "Retry webhook delivery",
+          description: "Re-send one past webhook delivery to its endpoint now. The receiving system will process the event again.",
+          inputSchema: RetryDeliveryInputSchema,
+          annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: false,
+            openWorldHint: true
+          }
+        },
+        ({ webhookId, deliveryId }) => runTool(environment, async () => {
+          await client.webhooks.retryDelivery(webhookId, deliveryId);
+          return { webhookId, deliveryId, retried: true };
+        })
+      );
+    }
+  }
+];
+
+// src/server.ts
+var ALL_TOOLS = [
+  ...statusTools,
+  ...chargeTools,
+  ...webhookTools,
+  ...networkTools,
+  ...metricsTools,
+  ...sandboxTools
+];
+function modeDescription(environment, allowLiveWrites) {
+  if (environment === "test") {
+    return "This is the TEST environment: sandbox data and no real funds. Read tools, charges_create, charges_check, webhooks_retry_delivery and sandbox_trigger are available.";
+  }
+  if (allowLiveWrites) {
+    return "This is the LIVE environment: real merchants, real payers and real funds. Live writes were explicitly enabled (KLAP_MCP_ALLOW_LIVE_WRITES=1): charges_create, charges_check and webhooks_retry_delivery act on real data \u2014 confirm with the user before calling them.";
+  }
+  return "This is the LIVE environment: real merchants, real payers and real funds. The server is read-only in live; write tools are not registered unless KLAP_MCP_ALLOW_LIVE_WRITES=1 is set.";
+}
+function buildInstructions(environment, baseUrl, allowLiveWrites) {
+  return [
+    `Klap Core API (${hostOf(baseUrl)}), environment: ${environment}.`,
+    modeDescription(environment, allowLiveWrites),
+    "Moving money out of a charge (escrow release/refund) and managing webhook endpoints or payout recipients are not available through this server."
+  ].join(" ");
+}
+function createServer(options) {
+  const { client, environment, baseUrl, allowLiveWrites } = options;
+  const server = new McpServer(
+    { name: SERVER_NAME, version },
+    { instructions: buildInstructions(environment, baseUrl, allowLiveWrites) }
+  );
+  for (const tool of ALL_TOOLS) {
+    if (isToolAllowed(tool.access, environment, allowLiveWrites)) {
+      tool.register(server, { client, environment, baseUrl });
+    }
+  }
+  return server;
+}
+
+// src/start.ts
+async function start() {
+  const resolved = await resolveServerEnvironment(
+    {
+      KLAP_ENV: process.env.KLAP_ENV,
+      KLAP_API_KEY: process.env.KLAP_API_KEY,
+      KLAP_BASE_URL: process.env.KLAP_BASE_URL,
+      KLAP_MCP_ALLOW_LIVE_WRITES: process.env.KLAP_MCP_ALLOW_LIVE_WRITES
+    },
+    loadCredentials
+  );
+  if (!resolved.ok) {
+    console.error(`${SERVER_NAME}: ${resolved.message}`);
+    process.exit(1);
+  }
+  const { apiKey, baseUrl, environment, allowLiveWrites } = resolved;
+  const client = createClient({ apiKey, baseUrl });
+  const server = createServer({ client, environment, baseUrl, allowLiveWrites });
+  await server.connect(new StdioServerTransport());
+  const writes = environment === "live" && allowLiveWrites ? " (live writes enabled)" : "";
+  console.error(`${SERVER_NAME}: ${environment} \u2192 ${hostOf(baseUrl)}${writes}`);
+}
+export {
+  start
+};
+//# sourceMappingURL=start-4SOOSFNC.js.map