@solumflow-app/crm-mcp-server 0.8.0 → 0.9.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { createClient } from "@solumflow-app/crm-client";
 
 // package.json
-var version = "0.8.0";
+var version = "0.9.0";
 
 // src/catalog-migration-tools.ts
 import { z as z4 } from "zod";
@@ -506,8 +506,8 @@ var page = {
 function more(nextCursor) {
   return nextCursor ? `More on the next page: cursor ${nextCursor}` : "";
 }
-function money(cents2, currency2) {
-  return `${(cents2 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
+function money(cents3, currency2) {
+  return `${(cents3 / 100).toFixed(2)} ${currency2.toUpperCase()}`;
 }
 function fieldsNotOnPageNote(slugs) {
   if (!slugs?.length) {
@@ -1280,7 +1280,11 @@ var CONFIGURATOR_LIMITS = {
   expandedParts: 200,
   repeatCount: 12,
   repeatDepth: 2,
-  annotations: 30
+  annotations: 30,
+  roomWallOptions: 12,
+  roomFloorOptions: 8,
+  focus: 60,
+  focusNames: 20
 };
 function jsonByteLength(value) {
   return new TextEncoder().encode(JSON.stringify(value)).length + jsonbSpacing(value);
@@ -1649,8 +1653,10 @@ var PRIMITIVE_PARAMS = {
   // A quarter of an elliptical shell in plan view, filling the block's width
   // and depth; `mirror` 0 bends it towards the right, 1 towards the left.
   arc_panel: { required: ["thickness"], optional: ["mirror"] },
-  // A thin strip that gives light.
-  led_strip: { required: [], optional: [] },
+  // A thin strip that gives light. `facing` is where the light goes: 0 down
+  // (the default: under a shelf, under a floating cabinet), 1 up, 2 forwards
+  // into the room, 3 back against the wall.
+  led_strip: { required: [], optional: ["facing"] },
   // A wall with a rectangular opening, measured from the block's own corner.
   niche_panel: {
     required: ["niche_x", "niche_y", "niche_width", "niche_height"],
@@ -1666,13 +1672,24 @@ var PRIMITIVE_PARAMS = {
 };
 var CONFIGURATOR_MODEL_PATH_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.glb$/;
 var CONFIGURATOR_FOLLOWS_PRESET = "preset";
+var MOTION_GROUP_PATTERN = /^[a-z](?:[a-z0-9_]|\{[ij]\}){0,39}$/;
+var MOTION_KINDS = ["hinge", "slide"];
+var MOTION_EDGES = ["bottom", "top", "left", "right"];
+var GeometryMotionSchema = z5.strictObject({
+  group: z5.string().regex(MOTION_GROUP_PATTERN, "configurator.invalidName"),
+  kind: z5.enum(MOTION_KINDS),
+  edge: z5.enum(MOTION_EDGES).optional(),
+  angle: FormulaSchema.optional(),
+  distance: FormulaSchema.optional()
+});
 var PrimitiveNodeFields = {
   id: ConfiguratorNameSchema,
   slot: ConfiguratorNameSchema,
   size: Vector3Schema,
   at: Vector3Schema,
   visible: FormulaSchema.optional(),
-  params: z5.record(ConfiguratorNameSchema, FormulaSchema).optional()
+  params: z5.record(ConfiguratorNameSchema, FormulaSchema).optional(),
+  motion: GeometryMotionSchema.optional()
 };
 var PrimitiveNodeSchema = z5.strictObject({
   ...PrimitiveNodeFields,
@@ -1762,6 +1779,26 @@ function geometryDocumentSchema(modelFile) {
   });
 }
 var GeometryDocumentSchema = geometryDocumentSchema(ModelPathSchema);
+function motionNames(nodes) {
+  const ids = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Set();
+  const walk = (list) => {
+    for (const node of list) {
+      ids.add(node.id);
+      if (node.type === "repeat") {
+        walk(node.children);
+      } else if (node.motion) {
+        groups.add(node.motion.group);
+      }
+    }
+  };
+  walk(nodes);
+  return { ids, groups };
+}
+function motionGroupMatches(template, name) {
+  const pattern = template.split(/\{[ij]\}/).join("[1-9][0-9]?");
+  return new RegExp(`^${pattern}$`).test(name);
+}
 function choiceModelBlocks(nodes) {
   const found = [];
   const walk = (list) => {
@@ -2001,6 +2038,32 @@ function geometryDocumentProblems(document, context = {}) {
         }
         checkFormula2(formula, [...nodePath, "params", key], scope);
       }
+      if (node.motion) {
+        const motion = node.motion;
+        const motionPath = [...nodePath, "motion"];
+        if (motion.angle !== void 0) {
+          checkFormula2(motion.angle, [...motionPath, "angle"], scope);
+        }
+        if (motion.distance !== void 0) {
+          checkFormula2(motion.distance, [...motionPath, "distance"], scope);
+        }
+        for (const placeholder of motion.group.match(/\{([ij])\}/g) ?? []) {
+          if (!scope.has(placeholder.slice(1, 2))) {
+            problems.push(
+              issue([...motionPath, "group"], "configurator.unknownName", {
+                name: placeholder
+              })
+            );
+          }
+        }
+        if (motion.kind === "hinge" && motion.distance !== void 0 || motion.kind === "slide" && (motion.edge !== void 0 || motion.angle !== void 0)) {
+          problems.push(
+            issue(motionPath, "configurator.motionMixed", {
+              kind: motion.kind
+            })
+          );
+        }
+      }
       if (node.follows !== void 0 && context.parameters) {
         problems.push(
           ...followProblems(node.follows, nodePath, {
@@ -2049,6 +2112,34 @@ function followProblems(follows, path, context) {
 
 // ../features/product-configurator/src/shared/configurator-structure.schema.ts
 import { z as z6 } from "zod";
+
+// ../features/product-configurator/src/shared/room-palette.ts
+var ROOM_WALL_PALETTE = [
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "gebroken-wit", label: "Gebroken wit", color: "#ece8e1" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "warm-grijs", label: "Warm grijs", color: "#b9b2a8" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "zand", label: "Zand", color: "#d6c5a8" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "saliegroen", label: "Saliegroen", color: "#a7b29c" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "nachtblauw", label: "Nachtblauw", color: "#2f3a4c" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "antraciet", label: "Antraciet", color: "#3d3d3f" }
+];
+var ROOM_FLOOR_PALETTE = [
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "licht-eiken", label: "Licht eiken", color: "#c8a77e" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "donker-eiken", label: "Donker eiken", color: "#6b4f38" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "betongrijs", label: "Betongrijs", color: "#9a9893" },
+  // i18n-exempt: the Dutch name of a colour in a palette that is also served to customers' own sites, where there is no catalogue
+  { code: "warm-beige", label: "Warm beige tegel", color: "#d9cbb7" }
+];
+
+// ../features/product-configurator/src/shared/configurator-structure.schema.ts
 var LabelSchema = z6.string().trim().min(1).max(80);
 var CONFIGURATOR_TEXTURE_PATH_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.(webp|jpg|jpeg)$/;
 var TexturePathSchema = z6.string().regex(CONFIGURATOR_TEXTURE_PATH_PATTERN, "configurator.invalidTexturePath");
@@ -2106,6 +2197,13 @@ var materialSchema = (picture) => z6.strictObject({
   opacity: z6.number().min(0.05).max(1).optional(),
   /** Gives light rather than reflecting it: a flame, a LED. */
   emissive: z6.boolean().optional(),
+  /**
+   * The colour temperature of a light, in kelvin: a LED strip sold as
+   * 3000 K glows and lights in that colour rather than in `color`, which
+   * stays the swatch's fallback. A strip that can do several (2700-6500 K)
+   * names the one to show: 4000 K.
+   */
+  kelvin: z6.number().int().min(1500).max(1e4).optional(),
   priceGroup: ConfiguratorCodeSchema.optional()
 });
 var ConfiguratorChoiceListSchema = choiceListSchema(TexturePathSchema);
@@ -2186,9 +2284,37 @@ var CONFIGURATOR_SCENE_LIGHTINGS = [
   "daylight"
 ];
 var CONFIGURATOR_SCENE_EDGES = ["soft", "sharp"];
+var RoomColorSchema = z6.strictObject({
+  code: ConfiguratorCodeSchema,
+  label: LabelSchema,
+  color: z6.string().regex(/^#[0-9a-f]{6}$/i, "configurator.invalidColor")
+});
+var roomSurfaceSchema = (max) => z6.strictObject({
+  /** The code shown first; absent is the first option. */
+  default: ConfiguratorCodeSchema.optional(),
+  /** Absent offers the package's own palette (`room-palette.ts`). */
+  options: z6.array(RoomColorSchema).min(1).max(max).optional()
+});
+var ConfiguratorRoomSchema = z6.strictObject({
+  wall: roomSurfaceSchema(CONFIGURATOR_LIMITS.roomWallOptions).optional(),
+  floor: roomSurfaceSchema(CONFIGURATOR_LIMITS.roomFloorOptions).optional(),
+  /** Millimetres of room beside the furniture on each side; 1500 by default. */
+  margin: z6.number().min(0).max(5e3).optional(),
+  /** Millimetres of floor in front of the wall; 3500 by default. */
+  depth: z6.number().min(1e3).max(1e4).optional()
+});
 var ConfiguratorSceneSchema = z6.strictObject({
   lighting: z6.enum(CONFIGURATOR_SCENE_LIGHTINGS).optional(),
-  edges: z6.enum(CONFIGURATOR_SCENE_EDGES).optional()
+  edges: z6.enum(CONFIGURATOR_SCENE_EDGES).optional(),
+  room: ConfiguratorRoomSchema.optional()
+});
+var FocusNameSchema = z6.string().regex(/^[a-z][a-z0-9_]{0,39}$/, "configurator.invalidName");
+var ConfiguratorFocusSchema = z6.strictObject({
+  param: ConfiguratorNameSchema,
+  when: ConfiguratorConditionSchema.optional(),
+  open: z6.array(FocusNameSchema).max(CONFIGURATOR_LIMITS.focusNames).optional(),
+  frame: z6.array(FocusNameSchema).min(1).max(CONFIGURATOR_LIMITS.focusNames).optional(),
+  night: z6.boolean().optional()
 });
 var structureObjectSchema = (files) => z6.strictObject({
   schemaVersion: z6.literal(1),
@@ -2222,6 +2348,8 @@ var structureObjectSchema = (files) => z6.strictObject({
     required: z6.boolean()
   }).optional(),
   rules: z6.array(ConfiguratorRuleSchema).max(CONFIGURATOR_LIMITS.rules),
+  /** What the picture opens and looks at when a choice changes. */
+  focus: z6.array(ConfiguratorFocusSchema).max(CONFIGURATOR_LIMITS.focus).optional(),
   priceRules: z6.array(ConfiguratorPriceRuleSchema).max(CONFIGURATOR_LIMITS.priceRules)
 });
 var ConfiguratorStructureObjectSchema = structureObjectSchema({
@@ -2505,6 +2633,78 @@ function configuratorStructureProblems(structure) {
       );
     }
   });
+  const shape = motionNames(structure.geometry.root);
+  const isGroup = (name) => [...shape.groups].some((template) => motionGroupMatches(template, name));
+  (structure.focus ?? []).forEach((focus, index) => {
+    const path = ["focus", index];
+    if (!parameters.has(focus.param)) {
+      problems.push(
+        issue([...path, "param"], "configurator.unknownParam", {
+          key: focus.param
+        })
+      );
+    }
+    if (focus.when) {
+      const conditionParam = parameters.get(focus.when.param);
+      const valueProblem = conditionParam ? conditionValueProblem(
+        focus.when.op,
+        focus.when.value,
+        conditionParam,
+        lists,
+        materials
+      ) : "configurator.unknownParam";
+      if (valueProblem) {
+        problems.push(
+          issue([...path, "when"], valueProblem, { key: focus.when.param })
+        );
+      }
+    }
+    (focus.open ?? []).forEach((name, nameIndex) => {
+      if (!isGroup(name)) {
+        problems.push(
+          issue(
+            [...path, "open", nameIndex],
+            "configurator.unknownMotionGroup",
+            {
+              name
+            }
+          )
+        );
+      }
+    });
+    (focus.frame ?? []).forEach((name, nameIndex) => {
+      if (!shape.ids.has(name) && !isGroup(name)) {
+        problems.push(
+          issue([...path, "frame", nameIndex], "configurator.unknownFrame", {
+            name
+          })
+        );
+      }
+    });
+  });
+  const room = structure.scene?.room;
+  for (const surface of ["wall", "floor"]) {
+    const own = room?.[surface];
+    const path = ["scene", "room", surface];
+    const codes = own?.options ? uniqueKeys(
+      own.options,
+      (option) => option.code,
+      [...path, "options"],
+      "code",
+      problems
+    ) : new Set(
+      (surface === "wall" ? ROOM_WALL_PALETTE : ROOM_FLOOR_PALETTE).map(
+        (option) => option.code
+      )
+    );
+    if (own?.default !== void 0 && !codes.has(own.default)) {
+      problems.push(
+        issue([...path, "default"], "configurator.unknownCode", {
+          code: own.default
+        })
+      );
+    }
+  }
   const geometryParameters = new Map(
     structure.parameters.map((parameter) => [
       parameter.key,
@@ -2962,6 +3162,13 @@ function onStep(value, step) {
 }
 
 // ../features/product-configurator/src/shared/expand-geometry.ts
+function motionGroupName(template, scope) {
+  return template.replace(
+    /\{([ij])\}/g,
+    (_, index) => String((scope[index] ?? 0) + 1)
+  );
+}
+var DEFAULT_HINGE_ANGLE = 90;
 function expandGeometry(document, inputs, chosen = { choices: {} }) {
   const issues = [];
   const parts = [];
@@ -3074,6 +3281,29 @@ function expandGeometry(document, inputs, chosen = { choices: {} }) {
         }
         params[key] = number2;
       }
+      let motion;
+      if (node.motion) {
+        const angle = node.motion.angle === void 0 ? DEFAULT_HINGE_ANGLE : evaluate(node.motion.angle, scope, [
+          ...nodePath,
+          "motion",
+          "angle"
+        ]);
+        const distance = node.motion.distance === void 0 ? null : evaluate(node.motion.distance, scope, [
+          ...nodePath,
+          "motion",
+          "distance"
+        ]);
+        if (angle === null || node.motion.distance !== void 0 && distance === null) {
+          return;
+        }
+        motion = {
+          group: motionGroupName(node.motion.group, scope),
+          kind: node.motion.kind,
+          edge: node.motion.edge ?? "bottom",
+          angle,
+          distance
+        };
+      }
       parts.push({
         key: `${node.id}${keySuffix}`,
         id: node.id,
@@ -3082,7 +3312,8 @@ function expandGeometry(document, inputs, chosen = { choices: {} }) {
         size,
         at,
         params,
-        ...model === void 0 ? {} : { model }
+        ...model === void 0 ? {} : { model },
+        ...motion === void 0 ? {} : { motion }
       });
       if (parts.length > CONFIGURATOR_LIMITS.expandedParts) {
         issues.push(
@@ -3701,15 +3932,422 @@ function registerServerInfoTool(server, info) {
   );
 }
 
-// src/tool-definitions-version.ts
+// src/shop-setup-tools.ts
 import { z as z11 } from "zod";
+var id = z11.string().uuid();
+var cents2 = z11.number().int().min(0).max(99999999);
+var region = z11.object({
+  countryCode: z11.string().regex(/^[A-Z]{2}$/).describe("Two capital letters, ISO 3166 (NL, BE, DE)."),
+  postcodeFrom: z11.string().max(20).nullable().default(null).describe("With postcodeTo: only this range of the country."),
+  postcodeTo: z11.string().max(20).nullable().default(null)
+});
+var discount = z11.object({
+  name: z11.string().min(1).max(120).describe("What the team sees it as."),
+  code: z11.string().max(40).nullable().describe(
+    "What a buyer types (upper-cased), or null for one that applies on its own."
+  ),
+  effect: z11.enum([
+    "tier_price",
+    "percent_off_lines",
+    "amount_off_lines",
+    "percent_off_order",
+    "amount_off_order",
+    "free_shipping"
+  ]).describe(
+    "tier_price: a lower price from tierMinQuantity of one product; *_lines: off each matching line; *_order: once off the whole order; free_shipping: no postage."
+  ),
+  percent: z11.number().nullable().describe("For a percentage: above 0, at most 100."),
+  amountCents: z11.number().int().nullable().describe("For an amount, in currency, as the account enters prices."),
+  currency: z11.string().regex(/^[A-Z]{3}$/).nullable().describe("Required beside amountCents (EUR)."),
+  tierMinQuantity: z11.number().int().nullable(),
+  minSubtotalCents: z11.number().int().nullable().describe("Only from this basket value, before discount."),
+  productIds: z11.array(id).max(500).describe("Empty: every product."),
+  categoryIds: z11.array(id).max(100),
+  objectIds: z11.array(id).max(20),
+  startsAt: z11.string().datetime({ offset: true }).nullable(),
+  endsAt: z11.string().datetime({ offset: true }).nullable(),
+  maxUses: z11.number().int().positive().nullable(),
+  maxUsesPerEmail: z11.number().int().positive().nullable(),
+  combinable: z11.boolean().describe(
+    "Whether it may count beside another discount on the same order."
+  )
+});
+function registerShopSetupTools(server, client) {
+  server.registerTool(
+    "check_shop_readiness",
+    {
+      title: "What the shop still misses",
+      description: "Everything that stops the shop from selling (blocker) or costs it sales (warning): no product for sale, products without a price, no shipping method, Stripe not connected or still in test mode, no revalidation webhook, no cookie banner, no visit tracking. Each finding names the tool that fixes it, or the screen in the app. Run it first, and again when you think you are done.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      try {
+        const readiness = await client.getShopReadiness();
+        return answer(
+          [
+            readiness.ready ? "Nothing blocks a sale." : "The shop cannot sell yet.",
+            ...readiness.findings.map(describeFinding)
+          ].join("\n"),
+          readiness
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "list_shipping_methods",
+    {
+      title: "List shipping zones and methods",
+      description: "Every shipping zone with the countries it covers and the methods under it (what each charges, whether it is on), and the shipping classes a flat rate may charge per class. Amounts in cents, as the account enters prices.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      try {
+        const setup = await client.getShippingSetup();
+        return answer(
+          setup.zones.length === 0 ? "No shipping zones yet: make one with upsert_shipping_zone." : setup.zones.map(describeZone).join("\n"),
+          setup
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_shipping_zone",
+    {
+      title: "Make or change a shipping zone",
+      description: "A zone is a name and the countries (or postcode ranges) it covers. Without id a new zone; with one, that zone renamed and its places replaced by these. Answers the zone id, for upsert_shipping_method.",
+      inputSchema: {
+        id: id.optional().describe("The zone to change; leave out for a new one."),
+        name: z11.string().min(1).max(80),
+        regions: z11.array(region).max(300).default([])
+      },
+      annotations: { idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const zone = await client.upsertShippingZone(input);
+        return answer(
+          `${input.id ? "Changed" : "Made"} zone "${input.name}" (id ${zone.id}).`,
+          zone
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_shipping_method",
+    {
+      title: "Make or change a shipping method",
+      description: "A way to post under a zone. flat_rate charges amountCents (and per class through classRates, noClassAmountCents for a product without one); free_shipping charges nothing, from freeThresholdCents of goods if given; local_pickup charges nothing. Without id a new method under zoneId; with one, that method changed -- its kind and zone are fixed once made.",
+      inputSchema: {
+        id: id.optional(),
+        zoneId: id,
+        kind: z11.enum(["flat_rate", "free_shipping", "local_pickup"]),
+        name: z11.string().min(1).max(80).describe("What the buyer chooses."),
+        enabled: z11.boolean().default(true),
+        amountCents: cents2.default(0),
+        noClassAmountCents: cents2.default(0),
+        taxRateId: id.nullish(),
+        freeThresholdCents: cents2.nullish(),
+        classRates: z11.array(z11.object({ classId: id, amountCents: cents2 })).max(100).default([])
+      },
+      annotations: { idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const method = await client.upsertShippingMethod(input);
+        return answer(
+          `${input.id ? "Changed" : "Made"} method "${input.name}" (id ${method.id}).`,
+          method
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "list_discounts",
+    {
+      title: "List discounts",
+      description: "The account discounts, newest first, at most 200: codes, the ones that apply on their own, and tier prices, with every condition and how many paid orders used each. Archived ones only with archived: true.",
+      inputSchema: { archived: z11.boolean().optional() },
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async ({ archived }) => {
+      try {
+        const discounts = await client.getDiscounts({ archived });
+        return answer(
+          discounts.length === 0 ? "No discounts." : discounts.map(describeDiscount).join("\n"),
+          discounts
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_discount",
+    {
+      title: "Make or change a discount",
+      description: "A code, a discount that applies on its own (code null), or a tier price. Every field is sent, null where it does not apply. Without id a new discount; with one, that discount replaced field by field. A code the account already has is refused (conflict). A discount is counted against maxUses when an order with it is paid.",
+      inputSchema: {
+        id: id.optional(),
+        discount
+      },
+      annotations: { idempotentHint: true }
+    },
+    async (input) => {
+      try {
+        const made = await client.upsertDiscount(input);
+        return answer(describeDiscount(made), made);
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "archive_discount",
+    {
+      title: "Archive a discount",
+      description: "Stops a discount from giving anything to a new cart or order; orders that used it keep it. archived: false brings it back. Deleting is left to a person in the app.",
+      inputSchema: {
+        id,
+        archived: z11.boolean().default(true)
+      },
+      annotations: { idempotentHint: true }
+    },
+    async ({ id: discountId, archived }) => {
+      try {
+        const result = await client.archiveDiscount(discountId, archived);
+        return answer(
+          archived ? "Archived." : "Brought back from the archive.",
+          result
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "get_payment_status",
+    {
+      title: "Can the shop take a payment",
+      description: "Whether a Stripe account is connected and ready for cards, whether Stripe still asks for something, and whether the account is in test mode. Read only: connecting Stripe and switching to live happen in the app, at the screen named in connectIn -- tell the person.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      try {
+        const status = await client.getPaymentStatus();
+        const sentence = !status.connected ? `Stripe is not connected (${status.status}). A person connects it in the app: ${status.connectIn}.` : [
+          "Stripe is connected",
+          status.testMode ? "in test mode: orders are test orders and no money moves" : "and live",
+          status.requirementsDue ? "Stripe still asks for details" : ""
+        ].filter(Boolean).join(", ") + ".";
+        return answer(sentence, status);
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "list_api_webhooks",
+    {
+      title: "List webhook addresses",
+      description: "The addresses the account tells about changes (products, categories, events, orders), with whether each is on, paused after failures, and how its last delivery went. The signing key is never shown again.",
+      annotations: { readOnlyHint: true, idempotentHint: true }
+    },
+    async () => {
+      try {
+        const hooks = await client.getApiWebhooks();
+        return answer(
+          hooks.length === 0 ? "No webhook addresses." : hooks.map(
+            (hook) => `- ${hook.name} (id ${hook.id}): ${hook.url}, ${hook.events.join(", ")}` + (hook.paused ? `, paused after ${hook.consecutiveFailures} failures` : hook.active ? "" : ", off")
+          ).join("\n"),
+          hooks
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+  server.registerTool(
+    "upsert_api_webhook",
+    {
+      title: "Make or change a webhook address",
+      description: "Point the account at the site revalidation route (with the SDK: https://<site>/api/solumflow/revalidate) so its cached pages follow a product the moment it changes. Without id a new address: the answer carries its signing key once -- put it in the site environment as SOLUMFLOW_WEBHOOK_KEY, it cannot be read back. https only, never a private network.",
+      inputSchema: {
+        id: id.optional(),
+        name: z11.string().min(1).max(80),
+        url: z11.string().url().max(2048),
+        events: z11.array(z11.string().min(1).max(60)).min(1).max(20).describe(
+          "For a shop: product.changed, product.deleted, category.changed."
+        )
+      },
+      annotations: { idempotentHint: false }
+    },
+    async (input) => {
+      try {
+        const result = await client.upsertApiWebhook(input);
+        return answer(
+          result.signingSecret ? `Made address ${result.id}. Its signing key is in this answer and nowhere else: set it as SOLUMFLOW_WEBHOOK_KEY in the site environment now.` : `Changed address ${result.id}.`,
+          result
+        );
+      } catch (error) {
+        return refusal(error, "shop:manage");
+      }
+    }
+  );
+}
+function describeFinding(finding) {
+  const examples = finding.examples?.length ? ` (${finding.examples.join(", ")})` : "";
+  return `- ${finding.severity}: ${finding.message}${examples} Fixed by ${finding.fixedBy}.`;
+}
+function describeZone(zone) {
+  const where = zone.isFallback ? "everywhere else" : zone.regions.map((place) => place.countryCode).join(", ") || "no places";
+  const methods = zone.methods.map(
+    (method) => `  - ${method.name} (${method.kind}, id ${method.id})${method.enabled ? "" : ", off"}: ` + (method.kind === "flat_rate" ? `${(method.amountCents / 100).toFixed(2)}` : method.freeThresholdCents !== null ? `free from ${(method.freeThresholdCents / 100).toFixed(2)}` : "free")
+  );
+  return [`- ${zone.name} (id ${zone.id}): ${where}`, ...methods].join("\n");
+}
+function describeDiscount(entry) {
+  const what = entry.percent !== null ? `${entry.percent}%` : entry.amountCents !== null && entry.currency ? money(entry.amountCents, entry.currency) : "";
+  return `- ${entry.name} (id ${entry.id}): ${entry.code ?? "no code"}, ${entry.effect}${what ? ` ${what}` : ""}, used ${entry.timesUsed}x` + (entry.archived ? ", archived" : "");
+}
+
+// src/shop-test-order-tool.ts
+import { z as z12 } from "zod";
+var PAID_POLLS = 10;
+var PAID_POLL_MS = 1500;
+function registerShopTestOrderTool(server, client, options = {}) {
+  const wait = options.wait ?? ((ms) => new Promise((done) => setTimeout(done, ms)));
+  server.registerTool(
+    "run_test_order",
+    {
+      title: "Place and pay a test order",
+      description: "Proves the shop end to end in Stripe test mode: puts one product in a cart, chooses postage, places the order, pays it with Stripe test card 4242, and reads the order back until it is paid (the invoice and the confirmation mail follow from there). Refused when the account is live -- no real money can move through this tool. Needs a key with shop:manage, cart:write, orders:write and orders:read.",
+      inputSchema: {
+        email: z12.string().email().describe(
+          "Where the confirmation goes: the shop owner, never a customer."
+        ),
+        productId: z12.string().uuid().optional().describe(
+          "The product to buy; leave out for the first one in stock."
+        ),
+        countryCode: z12.string().regex(/^[A-Z]{2}$/).default("NL").describe("Where it is posted, for a product that is posted."),
+        postalCode: z12.string().max(20).optional()
+      },
+      annotations: { idempotentHint: false }
+    },
+    async (input) => {
+      let scope = "shop:manage";
+      try {
+        const status = await client.getPaymentStatus();
+        if (!status.connected) {
+          return answer(
+            `Stripe is not connected, so there is nothing to pay with. A person connects it in the app: ${status.connectIn}.`,
+            status
+          );
+        }
+        if (!status.testMode) {
+          return answer(
+            `The account is live: a test order would be a real one. Switch the account to Stripe test mode in the app first (${status.connectIn}), or prove the shop with a real purchase by hand.`,
+            status
+          );
+        }
+        scope = "catalog:read";
+        const productId = input.productId ?? await firstProductForSale();
+        if (!productId) {
+          return answer(
+            "No product is for sale and in stock: there is nothing to order. check_shop_readiness says what is missing.",
+            null
+          );
+        }
+        scope = "cart:write";
+        const handle = await client.createCart({ email: input.email });
+        let cart = await client.addCartLine(handle.token, {
+          productId,
+          quantity: 1
+        });
+        if (cart.shipping.required) {
+          cart = await client.setCartShipping(handle.token, {
+            countryCode: input.countryCode,
+            postalCode: input.postalCode ?? null
+          });
+          const method = cart.shipping.methods[0];
+          if (!method) {
+            return answer(
+              `No shipping method delivers to ${input.countryCode}: add one with upsert_shipping_method.`,
+              cart
+            );
+          }
+          cart = await client.setCartShipping(handle.token, {
+            countryCode: input.countryCode,
+            postalCode: input.postalCode ?? null,
+            methodId: method.id
+          });
+        }
+        if (cart.problem) {
+          return answer(
+            `The cart cannot be ordered: ${cart.problem.message}`,
+            cart
+          );
+        }
+        scope = "orders:write";
+        const order = await client.submitCartOrder({
+          buyer: { email: input.email },
+          cartToken: handle.token,
+          ...cart.shipping.required ? {
+            shippingAddress: {
+              countryCode: input.countryCode,
+              ...input.postalCode ? { postalCode: input.postalCode } : {}
+            }
+          } : {}
+        });
+        scope = "shop:manage";
+        const payment = await client.payTestOrder(order.id);
+        scope = "orders:read";
+        const settled = await readUntilPaid(order.id);
+        const total = money(order.totalCents, order.currency);
+        return answer(
+          settled?.status === "paid" ? `Test order ${order.number} for ${total} is paid. The invoice and the confirmation mail to ${input.email} follow from here.` : `Test order ${order.number} for ${total}: Stripe says the payment ${payment.paymentStatus}, but the order still reads ${settled?.status ?? "unknown"}. The platform marks it paid when Stripe reaches its webhook; if that never happens, the webhook between Stripe and the platform is the place to look.`,
+          { order, payment, settled }
+        );
+      } catch (error) {
+        return refusal(error, scope);
+      }
+    }
+  );
+  async function firstProductForSale() {
+    const list = await client.getProducts({ limit: 50 });
+    return list.data.find(
+      (product) => product.inStock && product.priceFromCents !== null
+    )?.id;
+  }
+  async function readUntilPaid(orderId) {
+    let order = null;
+    for (let poll = 0; poll < PAID_POLLS; poll += 1) {
+      order = await client.getOrder(orderId);
+      if (order?.status === "paid") {
+        return order;
+      }
+      await wait(PAID_POLL_MS);
+    }
+    return order;
+  }
+}
+
+// src/tool-definitions-version.ts
+import { z as z13 } from "zod";
 import { createHash } from "crypto";
 function toolDefinitionsHash(tools) {
   const definitions = [...tools].sort((left, right) => left.name.localeCompare(right.name)).map(({ name, config }) => ({
     name,
     title: config.title ?? null,
     description: config.description ?? null,
-    inputSchema: config.inputSchema ? z11.toJSONSchema(z11.object(config.inputSchema), {
+    inputSchema: config.inputSchema ? z13.toJSONSchema(z13.object(config.inputSchema), {
       io: "input",
       unrepresentable: "any"
     }) : null,
@@ -3757,7 +4395,7 @@ function holdToolRegistrations(real) {
           description: `${config.description ?? ""} Definitions version ${version2}: send it as schemaHash and the answer tells you when these tool definitions are older than the server.`,
           inputSchema: {
             ...config.inputSchema,
-            schemaHash: z11.string().max(64).optional().describe(
+            schemaHash: z13.string().max(64).optional().describe(
               `The definitions version named in this tool's description (${version2}).`
             )
           }
@@ -3818,6 +4456,8 @@ async function main() {
   registerCatalogMigrationTools(held.server, client);
   registerEventTools(held.server, client);
   registerConfiguratorTools(held.server, client);
+  registerShopSetupTools(held.server, client);
+  registerShopTestOrderTool(held.server, client);
   held.publish();
   await server.connect(new StdioServerTransport());
   try {