@hszrdm/core 1.2.0 → 1.4.0

package/.medusa/server/src/core/store-mcp.js

@@ -0,0 +1,541 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStoreMcpRequest = handleStoreMcpRequest;
+const utils_1 = require("@medusajs/framework/utils");
+const node_crypto_1 = require("node:crypto");
+const zod_1 = require("zod");
+const MODERN_PROTOCOL = "2026-07-28";
+const LEGACY_PROTOCOL = "2025-11-25";
+const SERVER_NAME = "hszrdm-store";
+const SERVER_VERSION = "1.0.0";
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 100;
+const DEFAULT_RATE_LIMIT = 120;
+const TOOL_CACHE_TTL_MS = 300_000;
+const rateLimitBuckets = new Map();
+const pageSchema = zod_1.z.object({
+    limit: zod_1.z.number().int().min(1).max(MAX_LIMIT).optional(),
+    offset: zod_1.z.number().int().min(0).optional(),
+});
+const pageWithStatusSchema = pageSchema.extend({
+    status: zod_1.z.string().trim().min(1).optional(),
+});
+const idSchema = zod_1.z.object({ id: zod_1.z.string().trim().min(1) });
+const tools = [
+    {
+        name: "store_summary",
+        title: "Store summary",
+        description: "Return a compact read-only summary of the store, including counts for orders, products, customers, and sales channels.",
+        inputSchema: objectSchema({}),
+        parse: (input) => zod_1.z.object({}).parse(input ?? {}),
+        run: async (query) => {
+            const [orders, products, customers, salesChannels] = await Promise.all([
+                countEntity(query, "order"),
+                countEntity(query, "product"),
+                countEntity(query, "customer"),
+                countEntity(query, "sales_channel"),
+            ]);
+            return {
+                orders,
+                products,
+                customers,
+                sales_channels: salesChannels,
+            };
+        },
+    },
+    {
+        name: "orders_list",
+        title: "List orders",
+        description: "List recent orders with totals, payment status, fulfillment status, customer email, and timestamps. Read-only.",
+        inputSchema: objectSchema({
+            limit: integerSchema(1, MAX_LIMIT),
+            offset: integerSchema(0),
+            status: stringSchema(),
+        }),
+        parse: (input) => pageWithStatusSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { limit, offset, status } = input;
+            return query.graph({
+                entity: "order",
+                fields: [
+                    "id",
+                    "display_id",
+                    "email",
+                    "currency_code",
+                    "total",
+                    "subtotal",
+                    "tax_total",
+                    "shipping_total",
+                    "status",
+                    "fulfillment_status",
+                    "payment_status",
+                    "created_at",
+                    "updated_at",
+                ],
+                filters: status ? { status } : undefined,
+                pagination: page(limit, offset, { created_at: "DESC" }),
+            });
+        },
+    },
+    {
+        name: "order_get",
+        title: "Get order",
+        description: "Get one order by its Medusa order ID, including line items. Read-only.",
+        inputSchema: objectSchema({ id: stringSchema() }, ["id"]),
+        parse: (input) => idSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { id } = input;
+            const result = await query.graph({
+                entity: "order",
+                fields: [
+                    "id",
+                    "display_id",
+                    "email",
+                    "currency_code",
+                    "total",
+                    "subtotal",
+                    "discount_total",
+                    "tax_total",
+                    "shipping_total",
+                    "status",
+                    "fulfillment_status",
+                    "payment_status",
+                    "created_at",
+                    "updated_at",
+                    "items.id",
+                    "items.title",
+                    "items.subtitle",
+                    "items.quantity",
+                    "items.unit_price",
+                    "items.total",
+                    "items.variant_id",
+                    "items.product_id",
+                ],
+                filters: { id },
+                pagination: { take: 1 },
+            });
+            return result.data[0] ?? null;
+        },
+    },
+    {
+        name: "products_list",
+        title: "List products",
+        description: "List products with status, handle, thumbnail, and variants. Read-only.",
+        inputSchema: objectSchema({
+            limit: integerSchema(1, MAX_LIMIT),
+            offset: integerSchema(0),
+            status: stringSchema(),
+        }),
+        parse: (input) => pageWithStatusSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { limit, offset, status } = input;
+            return query.graph({
+                entity: "product",
+                fields: [
+                    "id",
+                    "title",
+                    "handle",
+                    "status",
+                    "thumbnail",
+                    "created_at",
+                    "updated_at",
+                    "variants.id",
+                    "variants.title",
+                    "variants.sku",
+                    "variants.manage_inventory",
+                ],
+                filters: status ? { status } : undefined,
+                pagination: page(limit, offset, { created_at: "DESC" }),
+            });
+        },
+    },
+    {
+        name: "product_get",
+        title: "Get product",
+        description: "Get one product by Medusa product ID, including variants and sales-channel membership. Read-only.",
+        inputSchema: objectSchema({ id: stringSchema() }, ["id"]),
+        parse: (input) => idSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { id } = input;
+            const result = await query.graph({
+                entity: "product",
+                fields: [
+                    "id",
+                    "title",
+                    "subtitle",
+                    "description",
+                    "handle",
+                    "status",
+                    "thumbnail",
+                    "created_at",
+                    "updated_at",
+                    "variants.id",
+                    "variants.title",
+                    "variants.sku",
+                    "variants.manage_inventory",
+                    "sales_channels.id",
+                    "sales_channels.name",
+                ],
+                filters: { id },
+                pagination: { take: 1 },
+            });
+            return result.data[0] ?? null;
+        },
+    },
+    {
+        name: "customers_list",
+        title: "List customers",
+        description: "List basic customer identity and account metadata. Addresses, credentials, and secrets are not exposed. Read-only.",
+        inputSchema: objectSchema({
+            limit: integerSchema(1, MAX_LIMIT),
+            offset: integerSchema(0),
+        }),
+        parse: (input) => pageSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { limit, offset } = input;
+            return query.graph({
+                entity: "customer",
+                fields: [
+                    "id",
+                    "email",
+                    "first_name",
+                    "last_name",
+                    "company_name",
+                    "has_account",
+                    "created_at",
+                    "updated_at",
+                ],
+                pagination: page(limit, offset, { created_at: "DESC" }),
+            });
+        },
+    },
+    {
+        name: "sales_channels_list",
+        title: "List sales channels",
+        description: "List configured Medusa sales channels. Read-only.",
+        inputSchema: objectSchema({
+            limit: integerSchema(1, MAX_LIMIT),
+            offset: integerSchema(0),
+        }),
+        parse: (input) => pageSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { limit, offset } = input;
+            return query.graph({
+                entity: "sales_channel",
+                fields: [
+                    "id",
+                    "name",
+                    "description",
+                    "is_disabled",
+                    "created_at",
+                    "updated_at",
+                ],
+                pagination: page(limit, offset, { created_at: "DESC" }),
+            });
+        },
+    },
+    {
+        name: "inventory_list",
+        title: "List inventory",
+        description: "List inventory items and stock levels by location, including stocked, reserved, incoming, and available quantities. Read-only.",
+        inputSchema: objectSchema({
+            limit: integerSchema(1, MAX_LIMIT),
+            offset: integerSchema(0),
+        }),
+        parse: (input) => pageSchema.parse(input ?? {}),
+        run: async (query, input) => {
+            const { limit, offset } = input;
+            return query.graph({
+                entity: "inventory_item",
+                fields: [
+                    "id",
+                    "sku",
+                    "title",
+                    "requires_shipping",
+                    "location_levels.id",
+                    "location_levels.stocked_quantity",
+                    "location_levels.reserved_quantity",
+                    "location_levels.incoming_quantity",
+                    "location_levels.available_quantity",
+                    "location_levels.location_id",
+                ],
+                pagination: page(limit, offset, { created_at: "DESC" }),
+            });
+        },
+    },
+];
+async function handleStoreMcpRequest(req, res) {
+    res.setHeader("Cache-Control", "private, no-store, max-age=0");
+    if (String(req.method || "POST").toUpperCase() !== "POST") {
+        res.setHeader("Allow", "POST");
+        return res.status(405).json({ error: "Method not allowed" });
+    }
+    const token = String(process.env.HSZRDM_MCP_TOKEN || "").trim();
+    if (!token) {
+        return res.status(503).json({
+            error: "HSZRDM Store MCP is disabled. Set HSZRDM_MCP_TOKEN to enable it.",
+        });
+    }
+    const authorization = header(req, "authorization");
+    if (!isValidBearerToken(authorization, token)) {
+        res.setHeader("WWW-Authenticate", 'Bearer realm="HSZRDM Store MCP"');
+        return res.status(401).json({ error: "Unauthorized" });
+    }
+    const allowedOrigins = csv(process.env.HSZRDM_MCP_ALLOWED_ORIGINS);
+    const origin = header(req, "origin");
+    if (origin && allowedOrigins.length && !allowedOrigins.includes(origin)) {
+        return res.status(403).json({ error: "Origin is not allowed" });
+    }
+    const allowedHosts = csv(process.env.HSZRDM_MCP_ALLOWED_HOSTS);
+    const host = header(req, "host")?.split(":")[0];
+    if (host && allowedHosts.length && !allowedHosts.includes(host)) {
+        return res.status(403).json({ error: "Host is not allowed" });
+    }
+    if (!consumeRateLimit(req, token)) {
+        res.setHeader("Retry-After", "60");
+        return res.status(429).json({ error: "MCP rate limit exceeded" });
+    }
+    const rpc = parseRpc(req.body);
+    if (!rpc.ok) {
+        return res.status(400).json(rpcError(null, -32600, rpc.message));
+    }
+    const request = rpc.request;
+    if (request.method === "notifications/initialized") {
+        return res.status(202).end();
+    }
+    const query = req.scope.resolve(utils_1.ContainerRegistrationKeys.QUERY);
+    const modern = isModernRequest(req, request);
+    try {
+        switch (request.method) {
+            case "server/discover":
+                return res.json(rpcResult(request.id, modernDiscoverResult()));
+            case "initialize":
+                return res.json(rpcResult(request.id, legacyInitializeResult(request.params)));
+            case "ping":
+                return res.json(rpcResult(request.id, completeResult(modern, {})));
+            case "tools/list":
+                return res.json(rpcResult(request.id, completeResult(modern, {
+                    tools: tools.map(publicTool),
+                    ...(modern
+                        ? { ttlMs: TOOL_CACHE_TTL_MS, cacheScope: "private" }
+                        : {}),
+                })));
+            case "tools/call":
+                return handleToolCall(query, request, res, modern);
+            default:
+                return res.status(404).json(rpcError(request.id, -32601, `Method not found: ${request.method}`));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Internal MCP error";
+        return res.status(500).json(rpcError(request.id, -32603, message));
+    }
+}
+async function handleToolCall(query, request, res, modern) {
+    const params = isRecord(request.params) ? request.params : {};
+    const name = typeof params.name === "string" ? params.name : "";
+    const tool = tools.find((candidate) => candidate.name === name);
+    if (!tool) {
+        return res.status(400).json(rpcError(request.id, -32602, `Unknown tool: ${name || "(missing name)"}`));
+    }
+    let input;
+    try {
+        input = tool.parse(params.arguments ?? {});
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Invalid tool arguments";
+        return res.json(rpcResult(request.id, completeResult(modern, {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        })));
+    }
+    try {
+        const value = await tool.run(query, input);
+        console.info(`[HSZRDM MCP] ${tool.name}`);
+        return res.json(rpcResult(request.id, completeResult(modern, {
+            content: [{ type: "text", text: JSON.stringify(value, null, 2) }],
+            structuredContent: value,
+        })));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Tool execution failed";
+        return res.json(rpcResult(request.id, completeResult(modern, {
+            content: [{ type: "text", text: message }],
+            isError: true,
+        })));
+    }
+}
+function publicTool(tool) {
+    return {
+        name: tool.name,
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    };
+}
+function modernDiscoverResult() {
+    return {
+        resultType: "complete",
+        supportedVersions: [MODERN_PROTOCOL],
+        capabilities: { tools: {} },
+        instructions: "Read-only HSZRDM commerce access backed by Medusa. Use tools to inspect orders, products, customers, sales channels, and inventory. No tool can modify store data.",
+        ttlMs: TOOL_CACHE_TTL_MS,
+        cacheScope: "private",
+        _meta: serverMeta(),
+    };
+}
+function legacyInitializeResult(params) {
+    const requested = isRecord(params) && typeof params.protocolVersion === "string"
+        ? params.protocolVersion
+        : LEGACY_PROTOCOL;
+    const protocolVersion = requested.startsWith("2025-") || requested === "2024-11-05"
+        ? requested
+        : LEGACY_PROTOCOL;
+    return {
+        protocolVersion,
+        capabilities: { tools: {} },
+        serverInfo: { name: SERVER_NAME, version: SERVER_VERSION },
+        instructions: "Read-only HSZRDM commerce access backed by Medusa. No tool can create, update, or delete store data.",
+    };
+}
+function completeResult(modern, value) {
+    if (!modern)
+        return value;
+    return {
+        resultType: "complete",
+        ...value,
+        _meta: serverMeta(),
+    };
+}
+function serverMeta() {
+    return {
+        "io.modelcontextprotocol/serverInfo": {
+            name: SERVER_NAME,
+            version: SERVER_VERSION,
+        },
+    };
+}
+function parseRpc(body) {
+    if (!isRecord(body) || body.jsonrpc !== "2.0" || typeof body.method !== "string") {
+        return { ok: false, message: "Invalid JSON-RPC request" };
+    }
+    return {
+        ok: true,
+        request: {
+            id: body.id ?? null,
+            method: body.method,
+            params: body.params ?? {},
+        },
+    };
+}
+function isModernRequest(req, request) {
+    if (request.method === "server/discover")
+        return true;
+    if (header(req, "mcp-protocol-version") === MODERN_PROTOCOL)
+        return true;
+    if (!isRecord(request.params) || !isRecord(request.params._meta))
+        return false;
+    return request.params._meta["io.modelcontextprotocol/protocolVersion"] === MODERN_PROTOCOL;
+}
+function rpcResult(id, result) {
+    return { jsonrpc: "2.0", id, result };
+}
+function rpcError(id, code, message) {
+    return {
+        jsonrpc: "2.0",
+        id,
+        error: { code, message },
+    };
+}
+function page(limit, offset, order) {
+    return {
+        take: Math.min(limit ?? DEFAULT_LIMIT, MAX_LIMIT),
+        skip: offset ?? 0,
+        ...(order ? { order } : {}),
+    };
+}
+async function countEntity(query, entity) {
+    const result = await query.graph({
+        entity,
+        fields: ["id"],
+        pagination: { take: 1, skip: 0 },
+    });
+    const count = result.metadata?.count;
+    return typeof count === "number" ? count : result.data.length;
+}
+function objectSchema(properties, required = []) {
+    return {
+        type: "object",
+        properties,
+        additionalProperties: false,
+        ...(required.length ? { required } : {}),
+    };
+}
+function integerSchema(minimum, maximum) {
+    return {
+        type: "integer",
+        minimum,
+        ...(maximum === undefined ? {} : { maximum }),
+    };
+}
+function stringSchema() {
+    return { type: "string", minLength: 1 };
+}
+function csv(value) {
+    return String(value || "")
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function header(req, name) {
+    const viaGetter = req.get?.(name);
+    if (viaGetter)
+        return viaGetter;
+    const raw = req.headers?.[name] ?? req.headers?.[name.toLowerCase()];
+    return Array.isArray(raw) ? String(raw[0] || "") : raw ? String(raw) : undefined;
+}
+function isValidBearerToken(authorization, expected) {
+    if (!authorization?.startsWith("Bearer "))
+        return false;
+    const provided = authorization.slice("Bearer ".length).trim();
+    const left = Buffer.from(provided);
+    const right = Buffer.from(expected);
+    if (left.length !== right.length)
+        return false;
+    return (0, node_crypto_1.timingSafeEqual)(left, right);
+}
+function consumeRateLimit(req, token) {
+    const configured = Number(process.env.HSZRDM_MCP_RATE_LIMIT_PER_MINUTE || DEFAULT_RATE_LIMIT);
+    const limit = Number.isFinite(configured) && configured > 0
+        ? Math.floor(configured)
+        : DEFAULT_RATE_LIMIT;
+    const minute = Math.floor(Date.now() / 60_000);
+    const forwarded = header(req, "x-forwarded-for")?.split(",")[0]?.trim();
+    const key = `${token.slice(0, 12)}:${forwarded || req.ip || "unknown"}`;
+    const current = rateLimitBuckets.get(key);
+    if (!current || current.minute !== minute) {
+        rateLimitBuckets.set(key, { minute, count: 1 });
+        pruneRateLimits(minute);
+        return true;
+    }
+    current.count += 1;
+    return current.count <= limit;
+}
+function pruneRateLimits(currentMinute) {
+    if (rateLimitBuckets.size < 500)
+        return;
+    for (const [key, value] of rateLimitBuckets) {
+        if (value.minute < currentMinute - 1)
+            rateLimitBuckets.delete(key);
+    }
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"store-mcp.js","sourceRoot":"","sources":["../../../../src/core/store-mcp.ts"],"names":[],"mappings":"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"}

package/.medusa/server/src/core/transactional-email.d.ts

@@ -2,6 +2,7 @@ type ResolveContainer = {
     resolve: (key: string) => unknown;
 };
 export type TransactionalEmailKind = "order_placed" | "payment_captured" | "fulfillment_created" | "shipment_created" | "order_canceled" | "payment_refunded";
+export declare function transactionalEmailEnabled(kind: TransactionalEmailKind): boolean;
 export declare function queueOrderLifecycleEmail(input: {
     container: ResolveContainer;
     kind: TransactionalEmailKind;
@@ -16,13 +17,19 @@ export declare function queueOrderLifecycleEmail(input: {
     template?: undefined;
 } | {
     skipped: boolean;
-    reason: "provider-disabled";
+    reason: "missing-email";
     orderId?: undefined;
     locale?: undefined;
     template?: undefined;
 } | {
     skipped: boolean;
-    reason: "missing-email";
+    orderId: string;
+    locale: string;
+    template: string;
+    reason?: undefined;
+} | {
+    skipped: boolean;
+    reason: "provider-disabled";
     orderId?: undefined;
     locale?: undefined;
     template?: undefined;
@@ -32,12 +39,6 @@ export declare function queueOrderLifecycleEmail(input: {
     orderId?: undefined;
     locale?: undefined;
     template?: undefined;
-} | {
-    skipped: boolean;
-    orderId: string;
-    locale: string;
-    template: string;
-    reason?: undefined;
 }>;
 export declare function resolveOrderIdForPayment(container: ResolveContainer, paymentId: string): Promise<string | null>;
 export declare function resolveRefundEmailContexts(container: ResolveContainer, paymentId: string): Promise<{