@apiosk/mcp 1.7.0 → 2.0.0

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, {}),
-      },
-    },
-  };
-}

package/src/local-config.mjs

@@ -1,256 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { chmod, mkdir, readFile, rename, writeFile } from "node:fs/promises";
-
-const DEFAULT_CONNECT_HEADER_NAME = "X-Apiosk-Connect-Token";
-const DEFAULT_GATEWAY_URL = "https://gateway.apiosk.com";
-const DEFAULT_DASHBOARD_URL = "https://apiosk.com";
-const DEFAULT_CONTROL_PLANE_URL = "https://mcp.apiosk.com";
-const DEFAULT_CHAIN_ID = 8453;
-const DEFAULT_RPC_URL = "https://mainnet.base.org";
-const DEFAULT_USDC_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-
-function trimString(value) {
-  return String(value || "").trim();
-}
-
-function defaultApioskDir(env = process.env) {
-  const configured = trimString(env.APIOSK_HOME);
-  if (configured) return configured;
-
-  const home = trimString(env.HOME) || os.homedir();
-  return path.join(home, ".apiosk");
-}
-
-function normalizeWalletAddress(value, { optional = false } = {}) {
-  const normalized = trimString(value).toLowerCase();
-  if (!normalized && optional) return "";
-  if (!/^0x[a-f0-9]{40}$/.test(normalized)) {
-    throw new Error("Wallet address must use a 0x-prefixed 40-byte hex address.");
-  }
-  return normalized;
-}
-
-function normalizeConnectToken(value, { optional = false } = {}) {
-  const normalized = trimString(value);
-  if (!normalized && optional) return "";
-  if (!/^aw_[A-Za-z0-9_:-]+$/.test(normalized)) {
-    throw new Error("Connect token must match the Apiosk managed-token format.");
-  }
-  return normalized;
-}
-
-async function safeChmod(filePath, mode) {
-  try {
-    await chmod(filePath, mode);
-  } catch {
-    // Best effort only; not all environments support chmod.
-  }
-}
-
-async function writeAtomic(filePath, value) {
-  const dir = path.dirname(filePath);
-  const tempFile = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-
-  await mkdir(dir, { recursive: true });
-  await writeFile(tempFile, value, "utf8");
-  await safeChmod(tempFile, 0o600);
-  await rename(tempFile, filePath);
-  await safeChmod(filePath, 0o600);
-}
-
-export function createApioskLocalConfigPaths(env = process.env) {
-  const apioskDir = defaultApioskDir(env);
-  return {
-    apioskDir,
-    configFile: path.join(apioskDir, "config.json"),
-    connectEnvFile: path.join(apioskDir, "connect.env"),
-  };
-}
-
-export async function readLocalApioskConfig(env = process.env) {
-  const { configFile } = createApioskLocalConfigPaths(env);
-
-  try {
-    const raw = await readFile(configFile, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-      return null;
-    }
-    return parsed;
-  } catch (error) {
-    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
-      return null;
-    }
-    throw new Error(
-      `Could not read the local Apiosk config: ${
-        error instanceof Error ? error.message : String(error)
-      }`
-    );
-  }
-}
-
-export async function saveLocalApioskConfig(input = {}, env = process.env) {
-  const paths = createApioskLocalConfigPaths(env);
-  const existing = (await readLocalApioskConfig(env)) || {};
-  const gatewayUrl = trimString(input.gateway_url || DEFAULT_GATEWAY_URL).replace(/\/+$/, "");
-  const chainId = Number.parseInt(String(input.chain_id || DEFAULT_CHAIN_ID), 10) || DEFAULT_CHAIN_ID;
-  const walletAddress = normalizeWalletAddress(input.agent_wallet_address || input.wallet_address, {
-    optional: true,
-  });
-  const connectToken = normalizeConnectToken(input.connect_token, { optional: true });
-  const connectAuthorization = trimString(
-    input.connect_authorization || (connectToken ? `Bearer ${connectToken}` : "")
-  );
-  const connectHeaderName = trimString(input.connect_header_name || DEFAULT_CONNECT_HEADER_NAME);
-  const dailyLimitUsdc = Number.isFinite(Number(input.daily_limit_usdc))
-    ? Number(input.daily_limit_usdc)
-    : 100;
-  const perRequestLimitUsdc = Number.isFinite(Number(input.per_request_limit_usdc))
-    ? Number(input.per_request_limit_usdc)
-    : 1;
-
-  if (!connectToken && !connectAuthorization) {
-    throw new Error("A connect token or connect authorization value is required.");
-  }
-
-  const config = {
-    rpc_url: DEFAULT_RPC_URL,
-    chain_id: chainId,
-    usdc_contract: DEFAULT_USDC_CONTRACT,
-    gateway_url: gatewayUrl,
-    agent_wallet_address: walletAddress || null,
-    daily_limit_usdc: dailyLimitUsdc,
-    per_request_limit_usdc: perRequestLimitUsdc,
-    connect_token: connectToken || null,
-    connect_authorization: connectAuthorization || null,
-    connect_header_name: connectHeaderName || DEFAULT_CONNECT_HEADER_NAME,
-    control_plane_url:
-      trimString(existing.control_plane_url || env.APIOSK_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL).replace(
-        /\/+$/,
-        ""
-      ) || null,
-    dashboard_url:
-      trimString(existing.dashboard_url || env.APIOSK_DASHBOARD_URL || DEFAULT_DASHBOARD_URL).replace(/\/+$/, "") ||
-      null,
-    dashboard_session_token: trimString(existing.dashboard_session_token) || null,
-    dashboard_session_email: trimString(existing.dashboard_session_email) || null,
-    dashboard_session_expires_at: Number.isFinite(Number(existing.dashboard_session_expires_at))
-      ? Number(existing.dashboard_session_expires_at)
-      : null,
-  };
-
-  const connectEnv = [
-    `APIO_GATEWAY_URL=${gatewayUrl}`,
-    `APIO_CHAIN_ID=${chainId}`,
-    `APIO_AGENT_WALLET_ADDRESS=${walletAddress}`,
-    `APIO_CONNECT_TOKEN=${connectToken}`,
-    `APIO_CONNECT_AUTHORIZATION=${connectAuthorization}`,
-    `APIO_CONNECT_HEADER_NAME=${connectHeaderName || DEFAULT_CONNECT_HEADER_NAME}`,
-    `APIO_WALLET_DAILY_LIMIT_USDC=${dailyLimitUsdc}`,
-    `APIO_WALLET_PER_TX_LIMIT_USDC=${perRequestLimitUsdc}`,
-  ].join("\n");
-
-  await writeAtomic(paths.configFile, `${JSON.stringify(config, null, 2)}\n`);
-  await writeAtomic(paths.connectEnvFile, `${connectEnv}\n`);
-
-  return {
-    paths,
-    config,
-  };
-}
-
-export async function saveLocalApioskDashboardSession(input = {}, env = process.env) {
-  const paths = createApioskLocalConfigPaths(env);
-  const existing = (await readLocalApioskConfig(env)) || {};
-  const sessionToken = trimString(input.dashboard_session_token || input.session_token);
-
-  if (!sessionToken) {
-    throw new Error("A dashboard session token is required.");
-  }
-
-  const expiresAtRaw = input.dashboard_session_expires_at ?? input.expires_at;
-  const expiresAt = Number(expiresAtRaw);
-  const config = {
-    ...existing,
-    control_plane_url:
-      trimString(
-        input.control_plane_url || existing.control_plane_url || env.APIOSK_CONTROL_PLANE_URL || DEFAULT_CONTROL_PLANE_URL
-      ).replace(/\/+$/, "") || null,
-    dashboard_url:
-      trimString(input.dashboard_url || existing.dashboard_url || env.APIOSK_DASHBOARD_URL || DEFAULT_DASHBOARD_URL).replace(/\/+$/, "") ||
-      null,
-    dashboard_session_token: sessionToken,
-    dashboard_session_email:
-      trimString(input.dashboard_session_email || input.email || existing.dashboard_session_email) || null,
-    dashboard_session_expires_at: Number.isFinite(expiresAt)
-      ? expiresAt
-      : Number.isFinite(Number(existing.dashboard_session_expires_at))
-      ? Number(existing.dashboard_session_expires_at)
-      : null,
-  };
-
-  await writeAtomic(paths.configFile, `${JSON.stringify(config, null, 2)}\n`);
-
-  return {
-    paths,
-    config,
-  };
-}
-
-export function parseConnectString(raw) {
-  const lines = String(raw || "").split(/\r?\n/);
-  const parsed = {
-    gateway_url: "",
-    chain_id: DEFAULT_CHAIN_ID,
-    wallet_address: "",
-    connect_token: "",
-    connect_authorization: "",
-    connect_header_name: DEFAULT_CONNECT_HEADER_NAME,
-    daily_limit_usdc: 100,
-    per_request_limit_usdc: 1,
-  };
-
-  for (const line of lines) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-
-    const normalizedLine = trimmed.startsWith("export ") ? trimmed.slice(7) : trimmed;
-    const separatorIndex = normalizedLine.indexOf("=");
-    if (separatorIndex === -1) continue;
-
-    const key = normalizedLine.slice(0, separatorIndex).trim();
-    let value = normalizedLine.slice(separatorIndex + 1).trim();
-    if (
-      (value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))
-    ) {
-      value = value.slice(1, -1);
-    }
-
-    if (key === "APIO_GATEWAY_URL") parsed.gateway_url = value;
-    if (key === "APIO_CHAIN_ID") parsed.chain_id = Number.parseInt(value, 10) || DEFAULT_CHAIN_ID;
-    if (key === "APIO_AGENT_WALLET_ADDRESS") parsed.wallet_address = value;
-    if (key === "APIO_CONNECT_TOKEN") parsed.connect_token = value;
-    if (key === "APIO_CONNECT_AUTHORIZATION") parsed.connect_authorization = value;
-    if (key === "APIO_CONNECT_HEADER_NAME") parsed.connect_header_name = value || DEFAULT_CONNECT_HEADER_NAME;
-    if (key === "APIO_WALLET_DAILY_LIMIT_USDC") parsed.daily_limit_usdc = Number(value) || 100;
-    if (key === "APIO_WALLET_PER_TX_LIMIT_USDC") parsed.per_request_limit_usdc = Number(value) || 1;
-  }
-
-  if (!parsed.gateway_url || !parsed.wallet_address || !parsed.connect_token) {
-    throw new Error("Connect string is missing one of: APIO_GATEWAY_URL, APIO_AGENT_WALLET_ADDRESS, APIO_CONNECT_TOKEN.");
-  }
-
-  return {
-    gateway_url: trimString(parsed.gateway_url).replace(/\/+$/, ""),
-    chain_id: parsed.chain_id || DEFAULT_CHAIN_ID,
-    wallet_address: normalizeWalletAddress(parsed.wallet_address),
-    connect_token: normalizeConnectToken(parsed.connect_token),
-    connect_authorization:
-      trimString(parsed.connect_authorization) || `Bearer ${normalizeConnectToken(parsed.connect_token)}`,
-    connect_header_name: trimString(parsed.connect_header_name) || DEFAULT_CONNECT_HEADER_NAME,
-    daily_limit_usdc: parsed.daily_limit_usdc,
-    per_request_limit_usdc: parsed.per_request_limit_usdc,
-  };
-}