@apiosk/mcp 1.3.1 → 2.0.0

package/src/funding-options.mjs

@@ -1,255 +0,0 @@
-import { createHmac } from "node:crypto";
-
-import QRCode from "qrcode";
-
-const TRANSAK_API_URL = "https://api-gateway.transak.com";
-const ONRAMPER_WIDGET_URL = "https://buy.onramper.com";
-const BASE_EXPLORER_URL = "https://basescan.org";
-
-function trimString(value) {
-  return String(value || "").trim();
-}
-
-function boolFromEnv(value, defaultValue = true) {
-  const normalized = trimString(value).toLowerCase();
-  if (!normalized) return defaultValue;
-  if (["0", "false", "no", "off"].includes(normalized)) return false;
-  if (["1", "true", "yes", "on"].includes(normalized)) return true;
-  return defaultValue;
-}
-
-function qrImageUrl(value) {
-  return `https://api.qrserver.com/v1/create-qr-code/?size=280x280&data=${encodeURIComponent(value)}`;
-}
-
-function getOnramperConfig(env = process.env) {
-  return {
-    apiKey: trimString(env.ONRAMPER_API_KEY),
-    widgetSecret: trimString(env.ONRAMPER_WIDGET_SECRET),
-  };
-}
-
-function getTransakConfig(env = process.env) {
-  return {
-    apiKey: trimString(env.TRANSAK_API_KEY),
-    secret: trimString(env.TRANSAK_SECRET),
-    referrerDomain: trimString(env.APIOSK_TRANSAK_REFERRER_DOMAIN || "dashboard.apiosk.com"),
-  };
-}
-
-function buildOnramperWidgetUrl(address, env = process.env) {
-  const { apiKey, widgetSecret } = getOnramperConfig(env);
-  const normalizedAddress = trimString(address).toLowerCase();
-  const searchParams = new URLSearchParams({
-    apiKey,
-    mode: "buy",
-    defaultCrypto: "USDC",
-    defaultNetwork: "base",
-    onlyCryptoNetworks: "base",
-    networkWallets: `base:${normalizedAddress}`,
-  });
-
-  const signContent = `networkWallets=base:${normalizedAddress}`;
-  const signature = createHmac("sha256", widgetSecret)
-    .update(signContent)
-    .digest("hex");
-
-  searchParams.set("signature", signature);
-
-  return `${ONRAMPER_WIDGET_URL}/?${searchParams.toString()}`;
-}
-
-async function getTransakAccessToken(env = process.env, fetchImpl = globalThis.fetch) {
-  const { apiKey, secret } = getTransakConfig(env);
-  const response = await fetchImpl(`${TRANSAK_API_URL}/api/v2/auth/token`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      apiKey,
-      secretKey: secret,
-    }),
-  });
-
-  if (!response.ok) {
-    throw new Error("Failed to get Transak access token.");
-  }
-
-  const data = await response.json();
-  return String(data.accessToken || "");
-}
-
-async function createTransakFundingSession(address, env = process.env, fetchImpl = globalThis.fetch) {
-  const { apiKey, referrerDomain } = getTransakConfig(env);
-  const accessToken = await getTransakAccessToken(env, fetchImpl);
-
-  const sessionResponse = await fetchImpl(`${TRANSAK_API_URL}/api/v2/auth/session`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "access-token": accessToken,
-    },
-    body: JSON.stringify({
-      widgetParams: {
-        apiKey,
-        referrerDomain,
-        walletAddress: address,
-        cryptoCurrencyCode: "USDC",
-        network: "base",
-        defaultCryptoCurrency: "USDC",
-        defaultNetwork: "base",
-        disableWalletAddressForm: true,
-        themeColor: "0052FF",
-        hideMenu: true,
-      },
-    }),
-  });
-
-  if (!sessionResponse.ok) {
-    throw new Error("Failed to create Transak funding session.");
-  }
-
-  const sessionData = await sessionResponse.json();
-  return {
-    widget_url: sessionData.widgetUrl || null,
-    session_id: sessionData.sessionId || null,
-  };
-}
-
-async function buildQrBundle(address, options = {}) {
-  const env = options.env || process.env;
-  const includeDataUrl =
-    options.includeQrDataUrl === true || boolFromEnv(env.APIOSK_INCLUDE_QR_DATA_URL, false);
-  const qrEnabled = boolFromEnv(env.APIOSK_ENABLE_QR, true);
-  const transferUri = `ethereum:${address}@8453`;
-  const payload = address;
-  const bundle = {
-    qr_payload: payload,
-    transfer_uri: transferUri,
-    qr_image_url: qrImageUrl(payload),
-  };
-
-  if (!qrEnabled) {
-    return bundle;
-  }
-
-  try {
-    bundle.qr_code_terminal = await QRCode.toString(payload, {
-      type: "terminal",
-      small: true,
-    });
-    bundle.qr_code_terminal_format = "ansi";
-  } catch {
-    // Leave terminal QR unset if rendering fails.
-  }
-
-  if (includeDataUrl) {
-    try {
-      bundle.qr_code_data_url = await QRCode.toDataURL(payload, {
-        margin: 1,
-        width: 280,
-      });
-    } catch {
-      // Leave data URL unset if rendering fails.
-    }
-  }
-
-  return bundle;
-}
-
-function buildFundingProviders(address, env = process.env) {
-  const { apiKey: transakApiKey, secret: transakSecret } = getTransakConfig(env);
-  const { apiKey: onramperApiKey, widgetSecret: onramperWidgetSecret } = getOnramperConfig(env);
-
-  return [
-    {
-      id: "manual",
-      label: "Receive on Base",
-      description: "Send ETH or USDC on Base directly to this wallet address.",
-      available: true,
-      kind: "direct",
-      address,
-      explorer_url: `${BASE_EXPLORER_URL}/address/${address}`,
-    },
-    {
-      id: "transak",
-      label: "Transak",
-      description: "Direct card or bank checkout for Base USDC.",
-      available: Boolean(transakApiKey && transakSecret),
-      kind: "direct",
-      action_hint: "Call apiosk_configure with section='funding' and funding_provider='transak' to request a checkout URL.",
-    },
-    {
-      id: "onramper",
-      label: "Onramper",
-      description: "Multi-provider onramp with outsourced KYC.",
-      available: Boolean(onramperApiKey && onramperWidgetSecret),
-      kind: "aggregator",
-      action_hint: "Call apiosk_configure with section='funding' and funding_provider='onramper' to request a checkout URL.",
-    },
-  ];
-}
-
-export async function buildFundingOptions({
-  wallet,
-  env = process.env,
-  fetchImpl = globalThis.fetch,
-  fundingProvider = null,
-  includeQrDataUrl = false,
-} = {}) {
-  if (!wallet?.address) {
-    return null;
-  }
-
-  const address = trimString(wallet.address).toLowerCase();
-  const receiveOnBase = {
-    title: "Receive on Base",
-    description: "This address accepts both ETH and USDC on Base.",
-    address,
-    network: "Base",
-    accepted_assets: ["ETH", "USDC"],
-    explorer_url: `${BASE_EXPLORER_URL}/address/${address}`,
-    ...await buildQrBundle(address, { env, includeQrDataUrl }),
-  };
-
-  const providers = buildFundingProviders(address, env);
-  let selectedProvider = null;
-  const requestedProvider = trimString(fundingProvider).toLowerCase();
-
-  if (requestedProvider && requestedProvider !== "manual") {
-    const provider = providers.find((entry) => entry.id === requestedProvider);
-    if (provider) {
-      if (!provider.available) {
-        selectedProvider = {
-          ...provider,
-          error: `${provider.label} is not configured in this environment.`,
-        };
-      } else if (provider.id === "onramper") {
-        selectedProvider = {
-          ...provider,
-          widget_url: buildOnramperWidgetUrl(address, env),
-          opens_in: "browser",
-        };
-      } else if (provider.id === "transak") {
-        const session = await createTransakFundingSession(address, env, fetchImpl);
-        selectedProvider = {
-          ...provider,
-          ...session,
-          opens_in: "browser",
-        };
-      }
-    }
-  } else if (requestedProvider === "manual") {
-    selectedProvider = providers.find((entry) => entry.id === "manual") || null;
-  }
-
-  return {
-    receive_on_base: receiveOnBase,
-    providers,
-    selected_provider: selectedProvider,
-    notes: [
-      "Base mainnet only.",
-      "Manual funding works even when embedded onramp providers are unavailable.",
-      "Use the wallet address or QR code from this section to top up the wallet.",
-    ],
-  };
-}

package/src/gateway-management.mjs

@@ -1,107 +0,0 @@
-import { randomBytes } from "node:crypto";
-
-import { privateKeyToAccount } from "viem/accounts";
-
-function parseBody(text) {
-  if (!text) return null;
-
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-function pickMessage(payload, fallback) {
-  if (payload && typeof payload === "object") {
-    if (typeof payload.message === "string" && payload.message.trim()) {
-      return payload.message.trim();
-    }
-    if (typeof payload.error === "string" && payload.error.trim()) {
-      return payload.error.trim();
-    }
-  }
-
-  if (typeof payload === "string" && payload.trim()) {
-    return payload.trim();
-  }
-
-  return fallback;
-}
-
-export function buildWalletAuthMessage(action, resource, walletAddress, timestamp, nonce) {
-  return [
-    "Apiosk auth",
-    `action:${action}`,
-    `wallet:${String(walletAddress || "").toLowerCase()}`,
-    `resource:${resource}`,
-    `timestamp:${timestamp}`,
-    `nonce:${nonce}`,
-  ].join("\n");
-}
-
-async function signedRequest({
-  baseUrl,
-  path,
-  method = "GET",
-  body,
-  action,
-  resource,
-  wallet,
-  fetchImpl = globalThis.fetch,
-}) {
-  if (!fetchImpl) {
-    throw new Error("A fetch implementation is required.");
-  }
-
-  const account = privateKeyToAccount(wallet.private_key);
-  const timestamp = String(Math.floor(Date.now() / 1000));
-  const nonce = randomBytes(16).toString("hex");
-  const message = buildWalletAuthMessage(action, resource, wallet.address, timestamp, nonce);
-  const signature = await account.signMessage({ message });
-  const headers = new Headers({
-    accept: "application/json",
-    "x-wallet-address": wallet.address,
-    "x-wallet-signature": signature,
-    "x-wallet-timestamp": timestamp,
-    "x-wallet-nonce": nonce,
-  });
-
-  const init = {
-    method,
-    headers,
-  };
-
-  if (body !== undefined) {
-    headers.set("content-type", "application/json");
-    init.body = JSON.stringify(body);
-  }
-
-  const response = await fetchImpl(`${String(baseUrl).replace(/\/+$/, "")}${path}`, init);
-  const text = await response.text();
-  const payload = parseBody(text);
-
-  return { payload, response };
-}
-
-export async function requestGatewayManagement(options) {
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    const { response, payload } = await signedRequest(options);
-    if (response.ok) {
-      return payload;
-    }
-
-    if ((response.status === 401 || response.status === 403) && attempt === 0) {
-      continue;
-    }
-
-    throw new Error(
-      pickMessage(
-        payload,
-        `Gateway management request failed with HTTP ${response.status}`
-      )
-    );
-  }
-
-  throw new Error("Gateway management request failed.");
-}

package/src/listing-metadata.mjs

@@ -1,287 +0,0 @@
-function isObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function cloneJson(value, fallback) {
-  if (value === undefined) return fallback;
-  return JSON.parse(JSON.stringify(value));
-}
-
-function normalizePath(pathValue) {
-  const value = String(pathValue || "/").trim();
-  if (!value || value === "/") return "/";
-  return value.startsWith("/") ? value : `/${value}`;
-}
-
-function normalizeTags(tags = []) {
-  return Array.from(
-    new Set(
-      tags
-        .map((tag) => String(tag || "").trim().toLowerCase())
-        .filter(Boolean)
-    )
-  );
-}
-
-function defaultExecuteInputSchema() {
-  return {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-      operation: {
-        type: "string",
-        description: "Optional operation selector. Accepts an operation id, a path, or a METHOD /path key.",
-      },
-      input: {
-        description: "JSON payload forwarded to the selected operation.",
-      },
-      query: {
-        type: "object",
-        additionalProperties: true,
-        description: "Optional query parameter override for GET-style operations.",
-      },
-      path_params: {
-        type: "object",
-        additionalProperties: true,
-        description: "Optional path parameter override for routes that include placeholders.",
-      },
-    },
-  };
-}
-
-function defaultExecuteOutputSchema() {
-  return {
-    type: "object",
-    required: ["status", "result", "cost", "latency", "operation", "api", "upstream_status"],
-    properties: {
-      status: { type: "string", enum: ["success", "error"] },
-      result: {},
-      cost: { type: "number" },
-      latency: { type: "integer" },
-      operation: { type: "string" },
-      api: { type: "string" },
-      upstream_status: { type: "integer" },
-    },
-  };
-}
-
-function defaultOperations(priceUsd) {
-  return [
-    {
-      id: "/",
-      key: "GET /",
-      method: "GET",
-      path: "/",
-      price_usd: priceUsd,
-      payment_required: true,
-      description: "Forward a GET request to the API root.",
-    },
-    {
-      id: "/",
-      key: "POST /",
-      method: "POST",
-      path: "/",
-      price_usd: priceUsd,
-      payment_required: true,
-      description: "Forward a POST request to the API root.",
-    },
-  ];
-}
-
-function normalizeOperation(operation, priceUsd) {
-  const method = String(operation?.method || "POST").trim().toUpperCase();
-  const path = normalizePath(operation?.path || operation?.id || "/");
-  return {
-    ...cloneJson(operation, {}),
-    id: String(operation?.id || path),
-    key: String(operation?.key || `${method} ${path}`),
-    method,
-    path,
-    price_usd:
-      typeof operation?.price_usd === "number" && Number.isFinite(operation.price_usd)
-        ? operation.price_usd
-        : priceUsd,
-    payment_required:
-      typeof operation?.payment_required === "boolean" ? operation.payment_required : true,
-  };
-}
-
-function isDiagnosticOperationPath(path = "/") {
-  const normalized = normalizePath(path);
-  if (normalized === "/") return true;
-  return normalized.split("/").filter(Boolean).some((segment) =>
-    /^(health|status|metadata|docs?|openapi|swagger|ping|readyz?|livez?)$/i.test(segment)
-  );
-}
-
-function defaultOperationRank(operation = {}) {
-  const path = normalizePath(operation.path || operation.id || "/");
-  const trimmed = path.replace(/^\/+|\/+$/g, "");
-  const segments = trimmed ? trimmed.split("/").filter(Boolean).length : 0;
-  const method = String(operation.method || "POST").trim().toUpperCase();
-  const methodRank =
-    method === "POST"
-      ? 0
-      : method === "PUT"
-        ? 1
-        : method === "PATCH"
-          ? 2
-          : method === "DELETE"
-            ? 3
-            : method === "GET"
-              ? 4
-              : method === "HEAD"
-                ? 5
-                : 6;
-  return [
-    isDiagnosticOperationPath(path) ? 1 : 0,
-    /batch/i.test(path) ? 1 : 0,
-    segments,
-    path.length,
-    methodRank,
-    operation.payment_required === false ? 1 : 0,
-    `${method} ${path}`,
-  ];
-}
-
-function inferDefaultOperation(operations = []) {
-  const ranked = [...operations].sort((left, right) => {
-    const leftRank = defaultOperationRank(left);
-    const rightRank = defaultOperationRank(right);
-    for (let index = 0; index < leftRank.length; index += 1) {
-      if (leftRank[index] < rightRank[index]) return -1;
-      if (leftRank[index] > rightRank[index]) return 1;
-    }
-    return 0;
-  });
-  return ranked[0]?.id || operations[0]?.id || "/";
-}
-
-function inferReadOnlyHint(operations = [], slug = "", name = "", description = "") {
-  const allReadOnly =
-    operations.length > 0 &&
-    operations.every((operation) => operation.method === "GET" || operation.method === "HEAD");
-
-  if (allReadOnly) return true;
-
-  return /extract|lookup|watch|map|research|digest|diff|monitor|verify|metadata|status/i.test(
-    `${slug} ${name} ${description}`
-  );
-}
-
-function inferIdempotentHint(operations = []) {
-  return (
-    operations.length > 0 &&
-    operations.every((operation) => operation.method === "GET" || operation.method === "HEAD")
-  );
-}
-
-function normalizeListingGroup(listingGroup) {
-  const value = String(listingGroup || "").trim().toLowerCase();
-  return value || null;
-}
-
-export function resolveCategory(category, listingGroup) {
-  const explicit = String(category || "").trim().toLowerCase();
-  if (explicit) return explicit;
-
-  const normalizedGroup = normalizeListingGroup(listingGroup);
-  if (normalizedGroup === "datasets") return "dataset";
-  if (normalizedGroup === "compute") return "compute";
-  return "data";
-}
-
-function resolveProviderListingType(category, listingGroup, baseProvider = null) {
-  const explicit = String(baseProvider?.listing_type || "").trim().toLowerCase();
-  if (explicit) return explicit;
-
-  const normalizedGroup = normalizeListingGroup(listingGroup);
-  if (normalizedGroup === "datasets" || category === "dataset") return "dataset";
-  if (["service", "connector", "skill", "product"].includes(normalizedGroup || "")) {
-    return normalizedGroup;
-  }
-
-  return "api";
-}
-
-export function buildListingMetadata({
-  name,
-  slug,
-  description,
-  endpoint_url,
-  price_usd,
-  category,
-  listing_group,
-  listing_metadata = {},
-} = {}) {
-  const safeSlug = String(slug || "").trim();
-  const safeName = String(name || safeSlug || "Apiosk API").trim();
-  const safeDescription = String(description || "").trim();
-  const safeEndpointUrl = String(endpoint_url || "").trim();
-  const safePrice = Number(price_usd);
-  const normalizedCategory = resolveCategory(category, listing_group);
-  const base = isObject(listing_metadata) ? cloneJson(listing_metadata, {}) : {};
-  const operationsInput = Array.isArray(base.operations) ? base.operations : defaultOperations(safePrice);
-  const operations = operationsInput.map((operation) => normalizeOperation(operation, safePrice));
-  const inputSchema = cloneJson(
-    base.input_schema || base.mcp_tool?.inputSchema,
-    defaultExecuteInputSchema()
-  );
-  const outputSchema = cloneJson(
-    base.output_schema || base.mcp_tool?.outputSchema,
-    defaultExecuteOutputSchema()
-  );
-  const provider = {
-    type: "http_api",
-    origin_url: safeEndpointUrl,
-    ...cloneJson(base.provider, {}),
-    origin_url: safeEndpointUrl,
-    listing_type: resolveProviderListingType(normalizedCategory, listing_group, base.provider),
-  };
-  const mergedTags = normalizeTags([
-    ...(Array.isArray(base.tags) ? base.tags : []),
-    normalizedCategory,
-    "api",
-    "agent-ready",
-    "mcp-native",
-  ]);
-  const defaultOperation = String(base.default_operation || inferDefaultOperation(operations));
-  const readOnlyHint =
-    typeof base.mcp_tool?.annotations?.readOnlyHint === "boolean"
-      ? base.mcp_tool.annotations.readOnlyHint
-      : inferReadOnlyHint(operations, safeSlug, safeName, safeDescription);
-  const idempotentHint =
-    typeof base.mcp_tool?.annotations?.idempotentHint === "boolean"
-      ? base.mcp_tool.annotations.idempotentHint
-      : inferIdempotentHint(operations);
-
-  return {
-    ...base,
-    agent_native: true,
-    mcp_native: true,
-    metadata_path: String(base.metadata_path || "/metadata"),
-    execute_path: String(base.execute_path || "/execute"),
-    default_operation: defaultOperation,
-    cost_per_call: safePrice,
-    input_schema: inputSchema,
-    output_schema: outputSchema,
-    operations,
-    provider,
-    tags: mergedTags,
-    mcp_tool: {
-      ...cloneJson(base.mcp_tool, {}),
-      name: String(base.mcp_tool?.name || safeSlug),
-      title: String(base.mcp_tool?.title || safeName),
-      description: String(base.mcp_tool?.description || safeDescription || safeName),
-      inputSchema: inputSchema,
-      outputSchema: outputSchema,
-      annotations: {
-        readOnlyHint,
-        idempotentHint,
-        destructiveHint: false,
-        openWorldHint: false,
-        ...cloneJson(base.mcp_tool?.annotations, {}),
-      },
-    },
-  };
-}