@reactionary/mcp 0.0.0-stage → 0.0.1

package/inspect.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { loadProjectRootEnv } from "./lib/load-project-root-env.js";
+loadProjectRootEnv(import.meta.url);
+const isSourceEntrypoint = import.meta.url.endsWith("/inspect.ts");
+const cliPath = fileURLToPath(
+  new URL(isSourceEntrypoint ? "./cli.ts" : "./cli.js", import.meta.url)
+);
+const host = process.env["MCP_HOST"] ?? "127.0.0.1";
+const port = process.env["MCP_PORT"] ?? process.env["PORT"] ?? "3000";
+const path = process.env["MCP_PATH"] ?? "/mcp";
+const serverUrl = `http://${host}:${port}${path}`;
+let serverProcess;
+let inspectorProcess;
+async function main() {
+  serverProcess = spawn(process.execPath, getServerArgs(), {
+    stdio: "inherit",
+    env: process.env
+  });
+  serverProcess.once("exit", (code, signal) => {
+    if (!inspectorProcess || inspectorProcess.exitCode !== null) {
+      return;
+    }
+    console.error(
+      `Reactionary MCP server exited before inspector closed: ${formatExit(
+        code,
+        signal
+      )}`
+    );
+    inspectorProcess.kill("SIGTERM");
+  });
+  await waitForServerStartup(serverProcess, serverUrl);
+  inspectorProcess = spawn(getPnpmCommand(), [
+    "dlx",
+    "@modelcontextprotocol/inspector",
+    "--web",
+    "--transport",
+    "http",
+    "--server-url",
+    serverUrl
+  ], {
+    stdio: "inherit",
+    env: process.env
+  });
+  const exitCode = await waitForExit(inspectorProcess);
+  await stopServer();
+  process.exit(exitCode);
+}
+function getServerArgs() {
+  if (!isSourceEntrypoint) {
+    return [cliPath];
+  }
+  return ["--loader", "@swc-node/register/esm", cliPath];
+}
+function getPnpmCommand() {
+  return process.platform === "win32" ? "pnpm.cmd" : "pnpm";
+}
+async function waitForServerStartup(child, url) {
+  const timeoutMs = process.env["MCP_INSPECTOR_STARTUP_TIMEOUT_MS"] ? Number.parseInt(process.env["MCP_INSPECTOR_STARTUP_TIMEOUT_MS"], 10) : 1e4;
+  if (!Number.isInteger(timeoutMs) || timeoutMs < 1) {
+    throw new Error(
+      `Invalid MCP_INSPECTOR_STARTUP_TIMEOUT_MS: ${process.env["MCP_INSPECTOR_STARTUP_TIMEOUT_MS"]}`
+    );
+  }
+  await Promise.race([
+    waitForReadyResponse(url, timeoutMs),
+    waitForEarlyExit(child)
+  ]);
+}
+async function waitForReadyResponse(url, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  let lastError;
+  while (Date.now() < deadline) {
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          accept: "application/json, text/event-stream",
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 0,
+          method: "initialize",
+          params: {
+            protocolVersion: "2025-06-18",
+            capabilities: {},
+            clientInfo: {
+              name: "@reactionary/mcp inspector launcher",
+              version: "0.0.0"
+            }
+          }
+        })
+      });
+      if (response.ok) {
+        return;
+      }
+      lastError = new Error(
+        `Readiness request failed with HTTP ${response.status}`
+      );
+    } catch (error) {
+      lastError = error;
+    }
+    await delay(100);
+  }
+  throw new Error(
+    `Timed out waiting for Reactionary MCP server at ${url}: ${formatError(lastError)}`
+  );
+}
+function waitForEarlyExit(child) {
+  return new Promise((_, reject) => {
+    child.once("error", reject);
+    child.once("exit", (code, signal) => {
+      reject(
+        new Error(
+          `Reactionary MCP server exited before it was ready: ${formatExit(
+            code,
+            signal
+          )}`
+        )
+      );
+    });
+  });
+}
+function delay(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+function waitForExit(child) {
+  return new Promise((resolve) => {
+    child.once("exit", (code) => {
+      resolve(code ?? 0);
+    });
+  });
+}
+async function stopServer() {
+  if (!serverProcess || serverProcess.exitCode !== null) {
+    return;
+  }
+  serverProcess.kill("SIGTERM");
+  await waitForExit(serverProcess);
+}
+function formatExit(code, signal) {
+  if (signal) {
+    return `signal ${signal}`;
+  }
+  return `code ${code ?? 0}`;
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+main().catch(async (error) => {
+  console.error(error);
+  await stopServer();
+  process.exit(1);
+});

package/lib/env-client-builder.js

@@ -0,0 +1,283 @@
+import {
+  ClientBuilder,
+  NoOpCache,
+  createInitialRequestContext
+} from "@reactionary/core";
+import { withAlgoliaCapabilities } from "@reactionary/algolia";
+import {
+  withCommercetoolsCapabilities
+} from "@reactionary/commercetools";
+import { withFakeCapabilities } from "@reactionary/fake";
+import { withMagentoCapabilities } from "@reactionary/magento";
+import { withMedusaCapabilities } from "@reactionary/medusa";
+import {
+  withMeilisearchCapabilities
+} from "@reactionary/meilisearch";
+import { withUnomiCapabilities } from "@reactionary/unomi";
+const providerSystems = [
+  "FAKE",
+  "MAGENTO",
+  "MEDUSA",
+  "COMMERCETOOLS",
+  "ALGOLIA",
+  "MEILISEARCH",
+  "UNOMI"
+];
+function createReactionaryClientFromEnv(options = {}) {
+  const env = options.env ?? process.env;
+  const enabledSystems = getEnabledReactionaryMCPProviderSystems(env);
+  if (enabledSystems.length === 0) {
+    throw new Error(getNoEnabledProviderSystemsMessage());
+  }
+  const context = {
+    ...createInitialRequestContext(),
+    ...options.contextOverrides
+  };
+  let builder = new ClientBuilder(context).withCache(
+    options.cache ?? new NoOpCache()
+  );
+  for (const system of enabledSystems) {
+    switch (system) {
+      case "ALGOLIA":
+        builder = builder.withCapability(
+          withAlgoliaCapabilities(getAlgoliaConfiguration(env), {
+            productSearch: { enabled: true },
+            productRecommendations: { enabled: true }
+          })
+        );
+        break;
+      case "COMMERCETOOLS":
+        builder = builder.withCapability(
+          withCommercetoolsCapabilities(getCommercetoolsConfiguration(env), {
+            cart: { enabled: true },
+            product: { enabled: true },
+            category: { enabled: true },
+            checkout: { enabled: true },
+            identity: { enabled: true },
+            inventory: { enabled: true },
+            order: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true },
+            productAssociations: { enabled: true },
+            productReviews: { enabled: true },
+            productList: { enabled: true },
+            orderSearch: { enabled: true },
+            companyRegistration: { enabled: true },
+            company: { enabled: true },
+            employee: { enabled: true },
+            employeeInvitation: { enabled: true },
+            store: { enabled: true },
+            profile: { enabled: true },
+            personalizationProfile: { enabled: true }
+          })
+        );
+        break;
+      case "FAKE":
+        builder = builder.withCapability(
+          withFakeCapabilities(getFakeConfiguration(), {
+            price: { enabled: true },
+            inventory: { enabled: true },
+            product: { enabled: true },
+            productReviews: { enabled: true },
+            productAssociations: { enabled: true },
+            featureFlag: { enabled: true }
+          })
+        );
+        break;
+      case "MAGENTO":
+        builder = builder.withCapability(
+          withMagentoCapabilities(getMagentoConfiguration(env), {
+            cart: { enabled: true },
+            product: { enabled: true },
+            category: { enabled: true },
+            identity: { enabled: true },
+            inventory: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true },
+            profile: { enabled: true },
+            orderSearch: { enabled: true },
+            checkout: { enabled: true },
+            productAssociations: { enabled: true },
+            productRecommendations: { enabled: true },
+            productReviews: { enabled: true }
+          })
+        );
+        break;
+      case "MEDUSA":
+        builder = builder.withCapability(
+          withMedusaCapabilities(getMedusaConfiguration(env), {
+            cart: { enabled: true },
+            product: { enabled: true },
+            category: { enabled: true },
+            checkout: { enabled: true },
+            identity: { enabled: true },
+            inventory: { enabled: true },
+            order: { enabled: true },
+            price: { enabled: true },
+            productSearch: { enabled: true },
+            productRecommendations: { enabled: true },
+            productAssociations: { enabled: true },
+            orderSearch: { enabled: true },
+            store: { enabled: true },
+            profile: { enabled: true },
+            personalizationProfile: { enabled: true },
+            employee: { enabled: true },
+            employeeInvitation: { enabled: true },
+            company: { enabled: true },
+            companyRegistration: { enabled: true }
+          })
+        );
+        break;
+      case "MEILISEARCH":
+        builder = builder.withCapability(
+          withMeilisearchCapabilities(getMeilisearchConfiguration(env), {
+            productSearch: { enabled: true },
+            orderSearch: { enabled: true },
+            productRecommendations: { enabled: true }
+          })
+        );
+        break;
+      case "UNOMI":
+        builder = builder.withCapability(
+          withUnomiCapabilities(getUnomiConfiguration(env), {
+            personalizationProfile: { enabled: true },
+            analytics: { enabled: false }
+          })
+        );
+        break;
+    }
+  }
+  return {
+    client: builder.build(),
+    enabledSystems
+  };
+}
+function getEnabledReactionaryMCPProviderSystems(env = process.env) {
+  return providerSystems.filter(
+    (system) => isEnvEnabled(env[`ENABLED_${system}`])
+  );
+}
+function getNoEnabledProviderSystemsMessage() {
+  return `No Reactionary provider system is enabled. Set one of ${providerSystems.map((system) => `ENABLED_${system}=true`).join(", ")}.`;
+}
+function isEnvEnabled(value) {
+  return value?.toLowerCase() === "true";
+}
+function getAlgoliaConfiguration(env) {
+  return {
+    apiKey: env["ALGOLIA_API_KEY"] || "",
+    appId: env["ALGOLIA_APP_ID"] || "",
+    indexName: env["ALGOLIA_INDEX"] || "",
+    useRecommendationsForBots: env["ALGOLIA_USE_RECOMMENDATIONS_FOR_BOTS"] === "true",
+    useBaseIndexNameForEnglishLocale: env["ALGOLIA_USE_BASE_INDEX_NAME_FOR_ENGLISH_LOCALE"] === "true"
+  };
+}
+function getMeilisearchConfiguration(env) {
+  return {
+    apiKey: env["MEILISEARCH_API_KEY"] || "",
+    apiUrl: env["MEILISEARCH_API_URL"] || "",
+    indexName: env["MEILISEARCH_INDEX"] || "",
+    useAIEmbedding: env["MEILISEARCH_USE_AI_EMBEDDING"] || void 0,
+    semanticRatio: env["MEILISEARCH_SEMANTIC_RATIO"] ? parseFloat(env["MEILISEARCH_SEMANTIC_RATIO"]) : 0.5,
+    orderIndexName: env["MEILISEARCH_ORDER_INDEX"] || "order",
+    useRecommendationsForBots: env["MEILISEARCH_USE_RECOMMENDATIONS_FOR_BOTS"] === "true"
+  };
+}
+function getUnomiConfiguration(env) {
+  return {
+    apiUrl: env["UNOMI_API_URL"] || "",
+    username: env["UNOMI_USERNAME"] || "",
+    password: env["UNOMI_PASSWORD"] || "",
+    scope: env["UNOMI_SCOPE"] || "",
+    profilePath: env["UNOMI_PROFILE_PATH"] || "/cxs/profiles"
+  };
+}
+function getMedusaConfiguration(env) {
+  return {
+    publishable_key: env["MEDUSA_PUBLISHABLE_KEY"] || "",
+    adminApiKey: env["MEDUSA_ADMIN_KEY"] || "",
+    apiUrl: env["MEDUSA_API_URL"] || "",
+    defaultCurrency: env["MEDUSA_DEFAULT_CURRENCY"] || "",
+    allCurrencies: []
+  };
+}
+function getMagentoConfiguration(env) {
+  return {
+    adminApiKey: env["MAGENTO_ADMIN_API_KEY"] || "",
+    baseUrl: env["MAGENTO_BASE_URL"] || "",
+    storeCode: env["MAGENTO_STORE_CODE"] || "",
+    authStoreCode: env["MAGENTO_AUTH_STORE_CODE"] || "default",
+    mediaUrl: env["MAGENTO_MEDIA_URL"] || void 0,
+    mediaSource: env["MAGENTO_MEDIA_SOURCE"] === "EXTERNAL" ? "EXTERNAL" : "DEFAULT",
+    defaultCurrency: env["MAGENTO_DEFAULT_CURRENCY"] || "",
+    rootCategoryId: env["MAGENTO_ROOT_CATEGORY_ID"] || "2",
+    graphqlUrl: env["MAGENTO_GRAPHQL_URL"] || void 0,
+    reviewRatingCode: env["MAGENTO_REVIEW_RATING_CODE"] || void 0,
+    allCurrencies: []
+  };
+}
+function getFakeConfiguration() {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0
+    },
+    seeds: {
+      product: 1,
+      search: 1,
+      category: 1
+    },
+    featureFlags: {
+      flags: [
+        {
+          key: "true-flag",
+          type: "boolean",
+          enabled: true
+        },
+        {
+          key: "string-flag",
+          type: "multivariate",
+          variants: ["red", "green", "blue"],
+          enabledVariant: "blue"
+        }
+      ]
+    }
+  };
+}
+function getCommercetoolsConfiguration(env) {
+  return {
+    apiUrl: env["CTP_API_URL"] || "",
+    authUrl: env["CTP_AUTH_URL"] || "",
+    clientId: env["CTP_CLIENT_ID"] || "",
+    clientSecret: env["CTP_CLIENT_SECRET"] || "",
+    projectKey: env["CTP_PROJECT_KEY"] || "",
+    scopes: parseCommaSeparatedEnvList(env["CTP_SCOPES"]),
+    paymentMethods: [
+      {
+        identifier: {
+          method: "stripe",
+          name: "Stripe",
+          paymentProcessor: "stripe"
+        },
+        isPunchOut: false,
+        description: "Stripe payment gateway"
+      }
+    ],
+    facetFieldsForSearch: parseCommaSeparatedEnvList(
+      env["CTP_FACET_FIELDS_FOR_SEARCH"]
+    ),
+    adminClientId: env["CTP_ADMIN_CLIENT_ID"] || void 0,
+    adminClientSecret: env["CTP_ADMIN_CLIENT_SECRET"] || void 0,
+    listPriceChannelKey: env["CTP_LIST_PRICE_CHANNEL_KEY"] || void 0,
+    customerPriceChannelKey: env["CTP_CUSTOMER_PRICE_CHANNEL_KEY"] || void 0
+  };
+}
+function parseCommaSeparatedEnvList(value) {
+  return (value || "").split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+export {
+  createReactionaryClientFromEnv,
+  getEnabledReactionaryMCPProviderSystems,
+  getNoEnabledProviderSystemsMessage,
+  parseCommaSeparatedEnvList
+};

package/lib/load-project-root-env.js

@@ -0,0 +1,40 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { config } from "dotenv";
+const workspaceRootMarkers = ["nx.json", "pnpm-workspace.yaml"];
+function loadProjectRootEnv(from = import.meta.url, env = process.env) {
+  const envPath = env["DOTENV_CONFIG_PATH"] ?? resolveProjectRootEnvPath(from);
+  if (!envPath) {
+    config();
+    return;
+  }
+  const result = config({ path: envPath });
+  if (!result.error) {
+    return;
+  }
+  const errorCode = result.error.code;
+  if (errorCode === "ENOENT" && env["DOTENV_CONFIG_PATH"] === void 0) {
+    return;
+  }
+  throw result.error;
+}
+function resolveProjectRootEnvPath(from = import.meta.url) {
+  let currentDirectory = dirname(fileURLToPath(from));
+  while (true) {
+    if (workspaceRootMarkers.some(
+      (marker) => existsSync(join(currentDirectory, marker))
+    )) {
+      return join(currentDirectory, ".env");
+    }
+    const parentDirectory = dirname(currentDirectory);
+    if (parentDirectory === currentDirectory) {
+      return void 0;
+    }
+    currentDirectory = parentDirectory;
+  }
+}
+export {
+  loadProjectRootEnv,
+  resolveProjectRootEnvPath
+};