@01.software/cli 0.13.0 → 0.14.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 
 // src/lib/client.ts
 import {
-  CollectionClient,
+  ServerCollectionClient,
   ServerCommerceClient,
   TenantIntrospectionApi
 } from "@01.software/sdk/server";
@@ -491,11 +491,7 @@ function resolveClientCredentials(apiKeyFlag) {
   if (!publishableKey || !secretKey) {
     throw credentialError({
       message: t("AuthenticationRequired"),
-      steps: [
-        t("RunLoginToAuthenticate"),
-        t("PassApiKey"),
-        t("SetEnvVars")
-      ]
+      steps: [t("RunLoginToAuthenticate"), t("PassApiKey"), t("SetEnvVars")]
     });
   }
   if (!isValidBearerToken(secretKey)) {
@@ -510,7 +506,7 @@ function resolveClientOrThrow(apiKeyFlag) {
   const { publishableKey, secretKey } = resolveClientCredentials(apiKeyFlag);
   const serverOptions = { publishableKey, secretKey };
   return {
-    collections: new CollectionClient(
+    collections: new ServerCollectionClient(
       publishableKey,
       secretKey,
       void 0,
@@ -536,13 +532,13 @@ import { readFileSync as readFileSync2 } from "fs";
 import { basename } from "path";
 
 // src/lib/collections.ts
-import { COLLECTIONS } from "@01.software/sdk";
+import { SERVER_COLLECTIONS } from "@01.software/sdk";
 function validateCollection(name) {
-  if (COLLECTIONS.includes(name)) {
+  if (SERVER_COLLECTIONS.includes(name)) {
     return name;
   }
   const normalized = name.replace(/-/g, "").toLowerCase();
-  const suggestions = COLLECTIONS.filter((collection) => {
+  const suggestions = SERVER_COLLECTIONS.filter((collection) => {
     const candidate = collection.replace(/-/g, "").toLowerCase();
     return candidate.startsWith(normalized) || normalized.startsWith(candidate) || normalized.length >= 3 && candidate.includes(normalized);
   }).slice(0, 5);
@@ -955,40 +951,203 @@ var collectionSchemaResponseSchema = z.object({
 }).strict();
 
 // ../contracts/src/ecommerce/index.ts
+import { z as z3 } from "zod";
+
+// ../contracts/src/ecommerce/product-upsert.ts
 import { z as z2 } from "zod";
-var transactionStatusSchema = z2.enum([
+var IdSchema = z2.union([z2.string(), z2.number()]).transform(String);
+var RemovedLegacyMediaFieldSchema = z2.unknown().optional();
+var productFieldShape = {
+  id: IdSchema.optional(),
+  title: z2.string().min(1).optional(),
+  subtitle: z2.string().optional().nullable(),
+  description: z2.string().optional().nullable(),
+  status: z2.string().optional(),
+  slug: z2.string().optional(),
+  primaryMediaItemId: IdSchema.optional().nullable(),
+  thumbnail: IdSchema.optional().nullable(),
+  images: z2.array(IdSchema).optional(),
+  mediaSets: RemovedLegacyMediaFieldSchema,
+  vendor: z2.string().optional().nullable(),
+  productType: z2.string().optional().nullable(),
+  brand: IdSchema.optional().nullable(),
+  shippingPolicy: IdSchema.optional().nullable(),
+  weight: z2.number().int().min(0).optional().nullable(),
+  minOrderQuantity: z2.number().int().min(1).optional().nullable(),
+  maxOrderQuantity: z2.number().int().min(1).optional().nullable(),
+  isFeatured: z2.boolean().optional(),
+  publishedAt: z2.string().optional().nullable(),
+  categories: z2.array(IdSchema).optional(),
+  tags: z2.array(IdSchema).optional(),
+  metadata: z2.unknown().optional()
+};
+var PRODUCT_UPSERT_PRODUCT_FIELDS = Object.keys(
+  productFieldShape
+);
+var ProductFieldsSchema = z2.object(productFieldShape).passthrough();
+var OptionValueObjectSchema = z2.object({
+  id: IdSchema.optional(),
+  value: z2.string().min(1, "Option value `value` is required"),
+  slug: z2.string().optional(),
+  swatch: z2.object({
+    type: z2.enum(["color", "media"]).optional().nullable(),
+    color: z2.string().optional().nullable(),
+    mediaItemId: IdSchema.optional().nullable()
+  }).optional().nullable(),
+  thumbnail: RemovedLegacyMediaFieldSchema,
+  images: RemovedLegacyMediaFieldSchema,
+  metadata: z2.unknown().optional()
+});
+var OptionValueInputSchema = OptionValueObjectSchema.passthrough().superRefine(
+  (value, ctx) => {
+    if (Object.prototype.hasOwnProperty.call(value, "swatchColor")) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Option value field `swatchColor` was removed. Use nested `swatch.color` instead.",
+        path: ["swatchColor"]
+      });
+    }
+  }
+);
+var OptionInputSchema = z2.object({
+  id: IdSchema.optional(),
+  title: z2.string().min(1, "Option `title` is required"),
+  slug: z2.string().optional(),
+  values: z2.array(OptionValueInputSchema).min(1, "Each option must have at least one value")
+});
+var VariantOptionValueObjectSchema = z2.object({
+  valueSlug: z2.string().optional(),
+  valueId: IdSchema.optional(),
+  value: z2.string().optional()
+}).refine((data) => Boolean(data.valueSlug ?? data.valueId ?? data.value), {
+  message: "Variant option value object requires valueSlug, valueId, or value"
+});
+var VariantInputSchema = z2.object({
+  id: IdSchema.optional(),
+  optionValues: z2.union([
+    z2.record(
+      z2.string(),
+      z2.union([z2.string(), VariantOptionValueObjectSchema])
+    ),
+    z2.array(IdSchema)
+  ]).optional(),
+  sku: z2.string().optional().nullable(),
+  title: z2.string().optional().nullable(),
+  price: z2.number().min(0),
+  compareAtPrice: z2.number().min(0).optional().nullable(),
+  stock: z2.number().int().min(0).optional(),
+  isUnlimited: z2.boolean().optional(),
+  weight: z2.number().int().min(0).optional().nullable(),
+  requiresShipping: z2.boolean().optional(),
+  barcode: z2.string().optional().nullable(),
+  externalId: z2.string().optional().nullable(),
+  isActive: z2.boolean().optional(),
+  images: z2.array(IdSchema).optional(),
+  thumbnail: RemovedLegacyMediaFieldSchema,
+  featuredMediaItemId: RemovedLegacyMediaFieldSchema,
+  metadata: z2.unknown().optional()
+});
+var ProductUpsertObjectSchema = z2.object({
+  /** Required on graph edit when the server graph is non-empty (`productId` set); optional for first seed on an empty graph. */
+  graphRevision: z2.string().optional(),
+  productId: IdSchema.optional(),
+  product: ProductFieldsSchema.optional(),
+  options: z2.array(OptionInputSchema).max(10).optional().default([]),
+  variants: z2.array(VariantInputSchema).max(500).optional().default([])
+});
+var ProductUpsertSchema = ProductUpsertObjectSchema.superRefine(
+  (data, ctx) => {
+    const nestedProductId = data.product?.id;
+    if (data.productId != null && nestedProductId != null && String(data.productId) !== String(nestedProductId)) {
+      ctx.addIssue({
+        code: "custom",
+        message: "productId must match product.id when both are set on graph upsert.",
+        path: ["productId"]
+      });
+    }
+    const productId = data.productId ?? nestedProductId;
+    const isEdit = productId != null;
+    if (!isEdit && data.productId != null) {
+      ctx.addIssue({
+        code: "custom",
+        message: "productId is not allowed when creating a product.",
+        path: ["productId"]
+      });
+    }
+    if (!isEdit && !data.product?.title) {
+      ctx.addIssue({
+        code: "custom",
+        message: "Product `title` is required when creating a new product.",
+        path: ["product", "title"]
+      });
+    }
+    if (isEdit && data.product) {
+      for (const key of Object.keys(data.product)) {
+        if (key !== "id") {
+          ctx.addIssue({
+            code: "custom",
+            message: "Existing product graph upsert accepts only product identity. Save document fields through Payload.",
+            path: ["product", key]
+          });
+        }
+      }
+    }
+  }
+);
+
+// ../contracts/src/ecommerce/index.ts
+var transactionStatusSchema = z3.enum([
   "pending",
   "paid",
   "failed",
   "canceled"
 ]);
-var financialStatusSchema = z2.enum([
+var financialStatusSchema = z3.enum([
   "pending",
   "paid",
-  "failed",
   "canceled",
   "partially_refunded",
   "refunded"
 ]);
-var confirmationStatusSchema = z2.enum(["unconfirmed", "confirmed"]);
-var fulfillmentOrderStatusSchema = z2.enum([
+var orderDisplayFinancialStatusSchema = z3.enum([
+  "pending",
+  "paid",
+  "partially_refunded",
+  "refunded",
+  "voided"
+]);
+var confirmationStatusSchema = z3.enum(["unconfirmed", "confirmed"]);
+var fulfillmentOrderStatusSchema = z3.enum([
   "open",
   "in_progress",
   "on_hold",
   "canceled",
   "closed"
 ]);
-var shipmentStatusSchema = z2.enum([
+var shipmentStatusSchema = z3.enum([
   "pending",
   "shipped",
   "delivered",
   "canceled",
   "failed"
 ]);
-var orderStatusSchema = z2.enum([
+var orderDisplayFulfillmentStatusSchema = z3.enum([
+  "unfulfilled",
+  "in_progress",
+  "on_hold",
+  "shipped",
+  "fulfilled",
+  "canceled"
+]);
+var orderReturnStatusSchema = z3.enum([
+  "no_return",
+  "return_requested",
+  "in_progress",
+  "returned"
+]);
+var orderStatusSchema = z3.enum([
   "pending",
   "paid",
-  "failed",
   "canceled",
   "refunded",
   "preparing",
@@ -999,119 +1158,122 @@ var orderStatusSchema = z2.enum([
   "return_processing",
   "returned"
 ]);
-var entityIdSchema = z2.union([z2.string().min(1), z2.number()]).transform(String);
-var createOrderItemSchema = z2.object({
-  product: entityIdSchema,
+var entityIdSchema = z3.union([z3.string().min(1), z3.number()]).transform(String);
+var createOrderItemSchema = z3.object({
+  // `product` and `option` are storefront-optional: the create-order
+  // endpoint derives the product from the variant's parent and snapshots
+  // option selection from the variant.
+  product: entityIdSchema.optional(),
   variant: entityIdSchema,
-  option: entityIdSchema,
-  quantity: z2.number().int().positive("quantity must be a positive integer"),
-  unitPrice: z2.number().optional(),
-  totalPrice: z2.number().optional()
+  option: entityIdSchema.optional(),
+  quantity: z3.number().int().positive("quantity must be a positive integer"),
+  unitPrice: z3.number().optional(),
+  totalPrice: z3.number().optional()
 }).strict();
-var createOrderSchema = z2.object({
-  pgPaymentId: z2.string().min(1).optional(),
-  orderNumber: z2.string().min(1, "orderNumber is required"),
+var createOrderSchema = z3.object({
+  pgPaymentId: z3.string().min(1).optional(),
+  orderNumber: z3.string().min(1, "orderNumber is required"),
   customer: entityIdSchema.optional(),
-  customerSnapshot: z2.object({
-    name: z2.string().optional(),
-    email: z2.string().email("Invalid email format"),
-    phone: z2.string().optional()
+  customerSnapshot: z3.object({
+    name: z3.string().optional(),
+    email: z3.string().email("Invalid email format"),
+    phone: z3.string().optional()
   }).strict(),
-  shippingAddress: z2.object({
-    postalCode: z2.string().optional(),
-    address: z2.string().optional(),
-    detailAddress: z2.string().optional(),
-    deliveryMessage: z2.string().optional(),
-    recipientName: z2.string().optional(),
-    phone: z2.string().optional()
+  shippingAddress: z3.object({
+    postalCode: z3.string().optional(),
+    address: z3.string().optional(),
+    detailAddress: z3.string().optional(),
+    deliveryMessage: z3.string().optional(),
+    recipientName: z3.string().optional(),
+    phone: z3.string().optional()
   }).strict(),
-  orderItems: z2.array(createOrderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order"),
-  totalAmount: z2.number().nonnegative("totalAmount must be non-negative"),
-  shippingAmount: z2.number().min(0).optional(),
-  discountCode: z2.string().optional()
+  orderItems: z3.array(createOrderItemSchema).min(1, "At least one order item is required").max(100, "Maximum 100 items per order"),
+  totalAmount: z3.number().nonnegative("totalAmount must be non-negative"),
+  shippingAmount: z3.number().min(0).optional(),
+  discountCode: z3.string().optional()
 }).strict();
-var updateTransactionSchema = z2.object({
-  pgPaymentId: z2.string().min(1, "pgPaymentId is required").describe("PG payment ID (required)"),
+var updateTransactionSchema = z3.object({
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID (required)"),
   status: transactionStatusSchema.describe(
     "New transaction status (required)"
   ),
-  paymentMethod: z2.string().optional().describe("Payment method (optional)"),
-  receiptUrl: z2.string().optional().describe("Receipt URL (optional)"),
-  paymentKey: z2.string().min(1).optional().describe("Provider payment key for verified paid confirmation"),
-  amount: z2.number().int().positive().optional().describe("Provider-confirmed amount for verified paid confirmation")
+  paymentMethod: z3.string().optional().describe("Payment method (optional)"),
+  receiptUrl: z3.string().optional().describe("Receipt URL (optional)"),
+  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified paid confirmation"),
+  amount: z3.number().int().positive().optional().describe("Provider-confirmed amount for verified paid confirmation")
 }).strict();
-var providerSlugSchema = z2.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
-var confirmPaymentSchema = z2.object({
-  orderNumber: z2.string().min(1).optional(),
-  pgPaymentId: z2.string().min(1, "pgPaymentId is required").describe("Provider payment identifier stored on the transaction"),
+var providerSlugSchema = z3.string().trim().regex(/^[a-z0-9][a-z0-9_-]{0,63}$/, "pgProvider must be lowercase slug");
+var confirmPaymentSchema = z3.object({
+  orderNumber: z3.string().min(1).optional(),
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("Provider payment identifier stored on the transaction"),
   pgProvider: providerSlugSchema.describe(
     "Payment provider slug, e.g. toss, portone, stripe"
   ),
-  pgOrderId: z2.string().min(1).optional(),
-  amount: z2.number().int().nonnegative("amount must be non-negative").describe("Provider-confirmed amount in minor units"),
-  currency: z2.string().min(1).optional(),
-  paymentMethod: z2.string().optional(),
-  receiptUrl: z2.string().url().optional(),
-  approvedAt: z2.string().optional(),
-  providerStatus: z2.string().optional(),
-  providerEventId: z2.string().min(1).optional(),
-  confirmationSource: z2.enum([
+  pgOrderId: z3.string().min(1).optional(),
+  amount: z3.number().int().nonnegative("amount must be non-negative").describe("Provider-confirmed amount in minor units"),
+  currency: z3.string().min(1).optional(),
+  paymentMethod: z3.string().optional(),
+  receiptUrl: z3.string().url().optional(),
+  approvedAt: z3.string().optional(),
+  providerStatus: z3.string().optional(),
+  providerEventId: z3.string().min(1).optional(),
+  confirmationSource: z3.enum([
     "provider_webhook",
     "provider_lookup",
     "provider_api_confirm",
     "manual_server"
   ]).optional(),
-  paymentKey: z2.string().min(1).optional().describe(
+  paymentKey: z3.string().min(1).optional().describe(
     "Optional provider payment key from the client confirm handshake; stored for BFF/provider refund workflows (also accepted as metadata.tossPaymentKey). Local cancel does not read this field."
   ),
-  metadata: z2.record(z2.string(), z2.unknown()).optional()
+  metadata: z3.record(z3.string(), z3.unknown()).optional()
 }).strict();
-var returnReasonSchema = z2.enum([
+var returnReasonSchema = z3.enum([
   "change_of_mind",
   "defective",
   "wrong_delivery",
   "damaged",
   "other"
 ]);
-var restockActionSchema = z2.enum(["return_to_stock", "discard"]);
-var returnWithRefundItemSchema = z2.object({
-  orderItem: z2.union([z2.string().min(1), z2.number()]).transform(String),
-  quantity: z2.number().int().positive("quantity must be a positive integer"),
+var restockActionSchema = z3.enum(["return_to_stock", "discard"]);
+var returnWithRefundItemSchema = z3.object({
+  orderItem: z3.union([z3.string().min(1), z3.number()]).transform(String),
+  quantity: z3.number().int().positive("quantity must be a positive integer"),
   restockAction: restockActionSchema.default("return_to_stock"),
-  restockingFee: z2.number().min(0, "restockingFee must be non-negative").optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
+  restockingFee: z3.number().min(0, "restockingFee must be non-negative").optional().describe("Restocking fee charged for this line (ADR 0005 \xA7Gap 1)")
 }).strict();
-var returnWithRefundSchema = z2.object({
-  orderNumber: z2.string().min(1, "orderNumber is required").describe("Order number (required)"),
+var returnWithRefundSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
-  reasonDetail: z2.string().optional().describe("Detailed reason text (optional)"),
-  returnItems: z2.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
-  refundAmount: z2.number().min(0, "refundAmount must be non-negative").describe("Refund amount (required, min 0)"),
-  returnShippingFee: z2.number().min(0, "returnShippingFee must be non-negative").optional().describe(
+  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z3.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  refundAmount: z3.number().min(0, "refundAmount must be non-negative").describe("Refund amount (required, min 0)"),
+  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe(
     "Return shipping fee charged to the customer (ADR 0005 \xA7Gap 1)"
   ),
-  initialShippingRefundAmount: z2.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
-  initialShippingRefundOverrideNote: z2.string().min(1).optional().describe(
+  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   ),
-  pgPaymentId: z2.string().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
-  paymentKey: z2.string().min(1).optional().describe("Provider payment key for verified refund"),
-  refundReceiptUrl: z2.string().optional().describe("Refund receipt URL (optional)")
+  pgPaymentId: z3.string().min(1, "pgPaymentId is required").describe("PG payment ID for refund (required)"),
+  paymentKey: z3.string().min(1).optional().describe("Provider payment key for verified refund"),
+  refundReceiptUrl: z3.string().optional().describe("Refund receipt URL (optional)")
 }).strict();
-var createReturnSchema = z2.object({
-  orderNumber: z2.string().min(1, "orderNumber is required").describe("Order number (required)"),
+var createReturnSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number (required)"),
   reason: returnReasonSchema.optional().describe("Return reason (optional)"),
-  reasonDetail: z2.string().optional().describe("Detailed reason text (optional)"),
-  returnItems: z2.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
-  refundAmount: z2.number().min(0, "refundAmount must be non-negative").describe(
+  reasonDetail: z3.string().optional().describe("Detailed reason text (optional)"),
+  returnItems: z3.array(returnWithRefundItemSchema).min(1, "At least one return item is required").max(100, "Too many return items").describe("Array of products to return (required)"),
+  refundAmount: z3.number().min(0, "refundAmount must be non-negative").describe(
     "Line refund amount before initial shipping refund (required, min 0)"
   ),
-  returnShippingFee: z2.number().min(0, "returnShippingFee must be non-negative").optional().describe("Return shipping fee charged to the customer"),
-  initialShippingRefundAmount: z2.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
-  initialShippingRefundOverrideNote: z2.string().min(1).optional().describe(
+  returnShippingFee: z3.number().min(0, "returnShippingFee must be non-negative").optional().describe("Return shipping fee charged to the customer"),
+  initialShippingRefundAmount: z3.number().min(0, "initialShippingRefundAmount must be non-negative").optional().describe("Initial order shipping amount refunded to the customer"),
+  initialShippingRefundOverrideNote: z3.string().min(1).optional().describe(
     "Operator audit note required when overriding policy suggestion"
   )
 }).strict();
-var cancelReasonCodeSchema = z2.enum([
+var cancelReasonCodeSchema = z3.enum([
   "customer",
   "inventory",
   "fraud",
@@ -1119,45 +1281,45 @@ var cancelReasonCodeSchema = z2.enum([
   "staff",
   "other"
 ]);
-var idempotencyKeySchema = z2.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
+var idempotencyKeySchema = z3.string().trim().min(1, "idempotencyKey is required").max(255, "idempotencyKey must be 255 characters or fewer").regex(
   /^[\x21-\x7E]+$/,
   "idempotencyKey must contain only printable header-safe characters"
 );
-var cancelOrderSchema = z2.object({
-  orderNumber: z2.string().min(1, "orderNumber is required").describe("Order number to cancel"),
+var cancelOrderSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number to cancel"),
   reasonCode: cancelReasonCodeSchema.default("other").describe("Operator-selected cancel reason code"),
-  reasonDetail: z2.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
+  reasonDetail: z3.string().trim().max(2e3, "reasonDetail must be 2000 characters or fewer").optional().describe("Internal cancellation detail stored on the order")
 }).strict();
 var cancelOrderResponseBaseSchema = {
-  orderId: z2.string().min(1)
+  orderId: z3.string().min(1)
 };
 var unpaidLocalCancelCommittedResponseFields = {
-  refundedAmount: z2.literal(0),
-  providerRefunded: z2.literal(false)
+  refundedAmount: z3.literal(0),
+  providerRefunded: z3.literal(false)
 };
 var paidLocalCancelCommittedResponseFields = {
-  transactionId: z2.string().min(1),
-  refundedAmount: z2.literal(0),
-  providerRefunded: z2.literal(false),
-  refundPending: z2.literal(true)
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.literal(0),
+  providerRefunded: z3.literal(false),
+  refundPending: z3.literal(true)
 };
 var legacyProviderRefundResponseFields = {
-  transactionId: z2.string().min(1),
-  refundedAmount: z2.number().int().positive(),
-  refundSeq: z2.number().int().positive(),
-  providerRefunded: z2.literal(true)
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.number().int().positive(),
+  refundSeq: z3.number().int().positive(),
+  providerRefunded: z3.literal(true)
 };
 var alreadyCanceledResponseFields = {
-  refundedAmount: z2.number().int().nonnegative(),
-  providerRefunded: z2.literal(false)
+  refundedAmount: z3.number().int().nonnegative(),
+  providerRefunded: z3.literal(false)
 };
 var alreadyCanceledRefundPendingResponseFields = {
-  transactionId: z2.string().min(1),
-  refundedAmount: z2.number().int().nonnegative(),
-  providerRefunded: z2.literal(false),
-  refundPending: z2.literal(true)
+  transactionId: z3.string().min(1),
+  refundedAmount: z3.number().int().nonnegative(),
+  providerRefunded: z3.literal(false),
+  refundPending: z3.literal(true)
 };
-var cancelOrderReconciliationStatusSchema = z2.enum([
+var cancelOrderReconciliationStatusSchema = z3.enum([
   "paid",
   "preparing",
   "shipped",
@@ -1168,123 +1330,123 @@ var cancelOrderReconciliationStatusSchema = z2.enum([
   "returned",
   "refunded"
 ]);
-var cancelOrderResponseSchema = z2.union([
-  z2.object({
+var cancelOrderResponseSchema = z3.union([
+  z3.object({
     ...cancelOrderResponseBaseSchema,
     ...paidLocalCancelCommittedResponseFields,
-    status: z2.literal("canceled"),
-    cancelCommitted: z2.literal(true)
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(true)
   }).strict(),
-  z2.object({
+  z3.object({
     ...cancelOrderResponseBaseSchema,
     ...unpaidLocalCancelCommittedResponseFields,
-    status: z2.literal("canceled"),
-    cancelCommitted: z2.literal(true)
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(true)
   }).strict(),
-  z2.object({
+  z3.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledResponseFields,
-    status: z2.literal("canceled"),
-    cancelCommitted: z2.literal(false),
-    alreadyCanceled: z2.literal(true)
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(false),
+    alreadyCanceled: z3.literal(true)
   }).strict(),
-  z2.object({
+  z3.object({
     ...cancelOrderResponseBaseSchema,
     ...alreadyCanceledRefundPendingResponseFields,
-    status: z2.literal("canceled"),
-    cancelCommitted: z2.literal(false),
-    alreadyCanceled: z2.literal(true)
+    status: z3.literal("canceled"),
+    cancelCommitted: z3.literal(false),
+    alreadyCanceled: z3.literal(true)
   }).strict(),
-  z2.object({
+  z3.object({
     ...cancelOrderResponseBaseSchema,
     ...legacyProviderRefundResponseFields,
     status: cancelOrderReconciliationStatusSchema,
-    cancelCommitted: z2.literal(false),
-    reconciliationRequired: z2.literal(true)
+    cancelCommitted: z3.literal(false),
+    reconciliationRequired: z3.literal(true)
   }).strict()
 ]);
-var resolveCancelRefundOutcomeSchema = z2.enum(["succeeded", "failed"]);
-var resolveCancelRefundSchema = z2.object({
-  orderNumber: z2.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
+var resolveCancelRefundOutcomeSchema = z3.enum(["succeeded", "failed"]);
+var resolveCancelRefundSchema = z3.object({
+  orderNumber: z3.string().min(1, "orderNumber is required").describe("Order number whose pending cancel refund is being resolved"),
   idempotencyKey: idempotencyKeySchema.describe(
     "Stable key for this PG refund result report"
   ),
   outcome: resolveCancelRefundOutcomeSchema.describe(
     "PG refund result reported by the storefront or BFF"
   ),
-  refundedAmount: z2.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
-  pgProvider: z2.string().trim().min(1, "pgProvider is required").regex(
+  refundedAmount: z3.number().int("refundedAmount must be an integer minor-unit amount").nonnegative("refundedAmount must be nonnegative"),
+  pgProvider: z3.string().trim().min(1, "pgProvider is required").regex(
     /^[a-z0-9][a-z0-9_-]*$/,
     "pgProvider must be a lowercase provider slug"
   ),
-  pgRefundId: z2.string().trim().min(1).optional()
+  pgRefundId: z3.string().trim().min(1).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.outcome === "succeeded" && value.refundedAmount <= 0) {
     ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be positive when outcome is succeeded"
     });
   }
   if (value.outcome === "succeeded" && !value.pgRefundId) {
     ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       path: ["pgRefundId"],
       message: "pgRefundId is required when outcome is succeeded"
     });
   }
   if (value.outcome === "failed" && value.refundedAmount !== 0) {
     ctx.addIssue({
-      code: z2.ZodIssueCode.custom,
+      code: z3.ZodIssueCode.custom,
       path: ["refundedAmount"],
       message: "refundedAmount must be 0 when outcome is failed"
     });
   }
 });
-var resolveCancelRefundResponseSchema = z2.union([
-  z2.object({
-    orderId: z2.string().min(1),
-    transactionId: z2.string().min(1),
-    refundTransactionId: z2.string().min(1),
-    refundedAmount: z2.number().int().positive(),
-    refundStatus: z2.literal("succeeded"),
-    transactionStatus: z2.literal("refunded")
+var resolveCancelRefundResponseSchema = z3.union([
+  z3.object({
+    orderId: z3.string().min(1),
+    transactionId: z3.string().min(1),
+    refundTransactionId: z3.string().min(1),
+    refundedAmount: z3.number().int().positive(),
+    refundStatus: z3.literal("succeeded"),
+    transactionStatus: z3.literal("refunded")
   }).strict(),
-  z2.object({
-    orderId: z2.string().min(1),
-    transactionId: z2.string().min(1),
-    refundTransactionId: z2.string().min(1),
-    refundedAmount: z2.literal(0),
-    refundStatus: z2.literal("failed"),
-    transactionStatus: z2.literal("paid")
+  z3.object({
+    orderId: z3.string().min(1),
+    transactionId: z3.string().min(1),
+    refundTransactionId: z3.string().min(1),
+    refundedAmount: z3.literal(0),
+    refundStatus: z3.literal("failed"),
+    transactionStatus: z3.literal("paid")
   }).strict()
 ]);
 
 // src/commands/order.ts
-import { z as z3 } from "zod";
-var idSchema = z3.union([z3.string().min(1), z3.number()]).transform(String);
-var customerSnapshotSchema = z3.object({
-  email: z3.string().email("Invalid email format"),
-  name: z3.string().optional(),
-  phone: z3.string().optional()
+import { z as z4 } from "zod";
+var idSchema = z4.union([z4.string().min(1), z4.number()]).transform(String);
+var customerSnapshotSchema = z4.object({
+  email: z4.string().email("Invalid email format"),
+  name: z4.string().optional(),
+  phone: z4.string().optional()
 }).strict();
-var orderStatusSchema2 = z3.enum(["confirmed"]);
-var fulfillmentStatusSchema = z3.enum(["shipped", "delivered", "failed"]);
-var updateFulfillmentSchema = z3.object({
+var orderStatusSchema2 = z4.enum(["confirmed"]);
+var fulfillmentStatusSchema = z4.enum(["shipped", "delivered", "failed"]);
+var updateFulfillmentSchema = z4.object({
   fulfillmentId: idSchema,
   status: fulfillmentStatusSchema.optional(),
-  carrier: z3.string().min(1).optional(),
-  trackingNumber: z3.string().min(1).optional()
+  carrier: z4.string().min(1).optional(),
+  trackingNumber: z4.string().min(1).optional()
 }).refine(
   (value) => value.status !== void 0 || value.carrier !== void 0 || value.trackingNumber !== void 0,
   {
     message: "status, carrier, or trackingNumber is required"
   }
 );
-var fulfillmentItemsSchema = z3.array(
-  z3.object({
+var fulfillmentItemsSchema = z4.array(
+  z4.object({
     orderItem: idSchema,
-    quantity: z3.number().int().positive("quantity must be a positive integer")
+    quantity: z4.number().int().positive("quantity must be a positive integer")
   }).strict()
 ).min(1, "At least one fulfillment item is required").max(100, "Maximum 100 items per fulfillment");
 function registerOrderCommands(program2, getClient2, getFormat2) {
@@ -1361,6 +1523,34 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  order.command("cancel <orderNumber>").description("Cancel an eligible order").option(
+    "--reason-code <code>",
+    "Cancel reason (customer, inventory, fraud, declined, staff, other)"
+  ).option("--reason-detail <text>", "Internal cancellation detail").option("--dry-run", "Validate inputs without executing").action(async (orderNumber, opts) => {
+    try {
+      const data = parseWithSchema(
+        {
+          orderNumber,
+          ...opts.reasonCode ? { reasonCode: opts.reasonCode } : {},
+          ...opts.reasonDetail ? { reasonDetail: opts.reasonDetail } : {}
+        },
+        "cancel",
+        cancelOrderSchema
+      );
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "order cancel", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.cancelOrder(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
   order.command("checkout").description("Convert a cart to an order").requiredOption("--cart-id <id>", "Cart ID").option("--payment-id <id>", "Payment ID (optional for free orders)").requiredOption("--order-number <num>", "Order number").requiredOption("--customer <json>", "Customer snapshot (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
     try {
       const customerSnapshot = parseWithSchema(
@@ -1474,8 +1664,8 @@ function registerOrderCommands(program2, getClient2, getFormat2) {
 }
 
 // src/commands/return.ts
-import { z as z4 } from "zod";
-var returnStatusSchema = z4.enum([
+import { z as z5 } from "zod";
+var returnStatusSchema = z5.enum([
   "processing",
   "approved",
   "rejected",
@@ -1676,6 +1866,60 @@ function registerCartCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  cart.command("clear <cartId>").description("Remove all items from a cart").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "cart clear", data: { cartId } },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.clear({ cartId });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+  cart.command("apply-discount <cartId>").description("Apply a discount code to a cart").requiredOption("--code <code>", "Discount code").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      const data = { cartId, discountCode: opts.code };
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "cart apply-discount", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.applyDiscount(data);
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+  cart.command("remove-discount <cartId>").description("Remove the discount from a cart").option("--dry-run", "Validate inputs without executing").action(async (cartId, opts) => {
+    try {
+      if (opts.dryRun) {
+        printResult(
+          {
+            dryRun: true,
+            valid: true,
+            action: "cart remove-discount",
+            data: { cartId }
+          },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.cart.removeDiscount({ cartId });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
 }
 
 // src/commands/stock.ts
@@ -1697,14 +1941,31 @@ function registerStockCommands(program2, getClient2, getFormat2) {
 }
 
 // src/commands/transaction.ts
-import { z as z5 } from "zod";
-var transactionAmountSchema = z5.object({
-  amount: z5.string().regex(/^[1-9]\d*$/, "amount must be a positive integer").transform(Number)
+import { z as z6 } from "zod";
+var transactionAmountSchema = z6.object({
+  amount: z6.string().regex(/^[1-9]\d*$/, "amount must be a positive integer").transform(Number)
+});
+var confirmPaymentAmountSchema = z6.object({
+  amount: z6.string().regex(/^(0|[1-9]\d*)$/, "amount must be a non-negative integer").transform(Number)
+});
+var idempotencyKeyOptionSchema = z6.object({
+  idempotencyKey: idempotencyKeySchema
 });
 function parseTransactionAmount(value) {
   if (value === void 0) return void 0;
   return parseWithSchema({ amount: value }, "amount", transactionAmountSchema).amount;
 }
+function parseConfirmPaymentAmount(value) {
+  return parseWithSchema({ amount: value }, "amount", confirmPaymentAmountSchema).amount;
+}
+function parseIdempotencyKey(value) {
+  if (value === void 0) return void 0;
+  return parseWithSchema(
+    { idempotencyKey: value },
+    "idempotencyKey",
+    idempotencyKeyOptionSchema
+  ).idempotencyKey;
+}
 function registerTransactionCommands(program2, getClient2, getFormat2) {
   const tx = program2.command("transaction").description("Transaction management");
   tx.command("update").description("Update transaction status").requiredOption("--payment-id <id>", "Payment ID").requiredOption(
@@ -1738,6 +1999,132 @@ function registerTransactionCommands(program2, getClient2, getFormat2) {
       exitWithError(e);
     }
   });
+  tx.command("confirm-payment").description("Confirm a provider-verified payment for an order").requiredOption("--payment-id <id>", "Provider payment identifier (pgPaymentId)").requiredOption(
+    "--provider <slug>",
+    "Payment provider slug (toss, portone, stripe, ...)"
+  ).requiredOption(
+    "--amount <n>",
+    "Provider-confirmed amount in minor units"
+  ).option("--order-number <num>", "Order number").option("--pg-order-id <id>", "Provider order id").option("--currency <code>", "Currency code").option("--payment-method <method>", "Payment method").option("--receipt-url <url>", "Receipt URL").option("--approved-at <ts>", "Provider approval timestamp").option("--provider-status <status>", "Provider status").option("--provider-event-id <id>", "Provider event id (idempotency)").option("--idempotency-key <key>", "Idempotency key header override").option(
+    "--confirmation-source <src>",
+    "provider_webhook | provider_lookup | provider_api_confirm | manual_server"
+  ).option("--payment-key <key>", "Provider payment key").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+    try {
+      const data = parseWithSchema(
+        {
+          pgPaymentId: opts.paymentId,
+          pgProvider: opts.provider,
+          amount: parseConfirmPaymentAmount(opts.amount),
+          ...opts.orderNumber ? { orderNumber: opts.orderNumber } : {},
+          ...opts.pgOrderId ? { pgOrderId: opts.pgOrderId } : {},
+          ...opts.currency ? { currency: opts.currency } : {},
+          ...opts.paymentMethod ? { paymentMethod: opts.paymentMethod } : {},
+          ...opts.receiptUrl ? { receiptUrl: opts.receiptUrl } : {},
+          ...opts.approvedAt ? { approvedAt: opts.approvedAt } : {},
+          ...opts.providerStatus ? { providerStatus: opts.providerStatus } : {},
+          ...opts.providerEventId ? { providerEventId: opts.providerEventId } : {},
+          ...opts.confirmationSource ? { confirmationSource: opts.confirmationSource } : {},
+          ...opts.paymentKey ? { paymentKey: opts.paymentKey } : {}
+        },
+        "confirm-payment",
+        confirmPaymentSchema
+      );
+      const sdkParams = {
+        ...data,
+        ...opts.idempotencyKey !== void 0 ? { idempotencyKey: parseIdempotencyKey(opts.idempotencyKey) } : {}
+      };
+      if (opts.dryRun) {
+        printResult(
+          {
+            dryRun: true,
+            valid: true,
+            action: "transaction confirm-payment",
+            data: sdkParams
+          },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.orders.confirmPayment(
+        sdkParams
+      );
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/product.ts
+function registerProductCommands(program2, getClient2, getFormat2) {
+  const product = program2.command("product").description("Product management");
+  product.command("upsert").description("Create or update a product graph (options, values, variants)").requiredOption("--input <json>", "Product upsert input (JSON)").option("--dry-run", "Validate inputs without executing").action(async (opts) => {
+    try {
+      const data = parseWithSchema(
+        parseJson(opts.input, "input"),
+        "input",
+        ProductUpsertSchema
+      );
+      if (opts.dryRun) {
+        printResult(
+          { dryRun: true, valid: true, action: "product upsert", data },
+          getFormat2()
+        );
+        return;
+      }
+      const client = getClient2();
+      const result = await client.commerce.product.upsert(
+        data
+      );
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/discount.ts
+function registerDiscountCommands(program2, getClient2, getFormat2) {
+  const discount = program2.command("discount").description("Discount management");
+  discount.command("validate").description("Validate a discount code against an order amount").requiredOption("--code <code>", "Discount code").requiredOption(
+    "--order-amount <n>",
+    "Order amount",
+    (v) => parseInt(v, 10)
+  ).action(async (opts) => {
+    try {
+      const client = getClient2();
+      const result = await client.commerce.discounts.validate({
+        code: opts.code,
+        orderAmount: opts.orderAmount
+      });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
+}
+
+// src/commands/shipping.ts
+function registerShippingCommands(program2, getClient2, getFormat2) {
+  const shipping = program2.command("shipping").description("Shipping calculation");
+  shipping.command("calculate").description("Calculate shipping for an order amount").requiredOption(
+    "--order-amount <n>",
+    "Order amount",
+    (v) => parseInt(v, 10)
+  ).option("--shipping-policy-id <id>", "Shipping policy ID").option("--postal-code <code>", "Destination postal code").action(async (opts) => {
+    try {
+      const client = getClient2();
+      const result = await client.commerce.shipping.calculate({
+        orderAmount: opts.orderAmount,
+        ...opts.shippingPolicyId ? { shippingPolicyId: opts.shippingPolicyId } : {},
+        ...opts.postalCode ? { postalCode: opts.postalCode } : {}
+      });
+      printResult(result, getFormat2());
+    } catch (e) {
+      exitWithError(e);
+    }
+  });
 }
 
 // src/commands/auth.ts
@@ -1832,7 +2219,7 @@ async function exchangeCode(code) {
   }
 }
 function startAuthServer(options) {
-  return new Promise((resolve3, reject) => {
+  return new Promise((resolve2, reject) => {
     const server = createServer((req, res) => {
       if (!req.url) {
         res.writeHead(400).end();
@@ -1907,7 +2294,7 @@ Logged in successfully!`));
         );
         cleanup(4);
       }, TIMEOUT_MS);
-      resolve3({ port: addr.port, cleanup });
+      resolve2({ port: addr.port, cleanup });
     });
     server.on("error", (err) => {
       reject(err);
@@ -2046,25 +2433,17 @@ ${loginUrl}`));
 }
 
 // src/commands/schema.ts
-import { COLLECTIONS as COLLECTIONS2 } from "@01.software/sdk";
+import { SERVER_COLLECTIONS as SERVER_COLLECTIONS2 } from "@01.software/sdk";
 function registerSchemaCommands(program2, getClient2, getFormat2) {
   const schema = program2.command("schema").description("Collection schema introspection");
   schema.command("list").description("List available collections").action(() => {
-    printResult(COLLECTIONS2, getFormat2());
+    printResult(SERVER_COLLECTIONS2, getFormat2());
   });
   schema.command("show <collection>").description("Show collection field schema").action(async (collection) => {
     try {
-      if (!COLLECTIONS2.includes(collection)) {
-        const normalized = collection.replace(/-/g, "").toLowerCase();
-        const suggestions = COLLECTIONS2.filter((c) => {
-          const cn = c.replace(/-/g, "").toLowerCase();
-          return cn.startsWith(normalized) || normalized.startsWith(cn) || normalized.length >= 3 && cn.includes(normalized);
-        }).slice(0, 5);
-        const hint = suggestions.length > 0 ? `Did you mean: ${suggestions.join(", ")}?` : 'Run "01 schema list" for available collections.';
-        throw new Error(`Unknown collection "${collection}". ${hint}`);
-      }
+      const col = validateCollection(collection);
       const client = getClient2();
-      const result = await client.tenant.collectionSchema(collection);
+      const result = await client.tenant.collectionSchema(col);
       printResult(result, getFormat2());
     } catch (e) {
       exitWithError(e);
@@ -2111,98 +2490,8 @@ function registerFeatureCommands(program2, getClient2, getFormat2) {
   });
 }
 
-// src/commands/mcp.ts
-import { resolve, dirname } from "path";
-import { existsSync as existsSync2 } from "fs";
-import { spawn } from "child_process";
-import { fileURLToPath } from "url";
-var __dirname = dirname(fileURLToPath(import.meta.url));
-function getStdioEntryCandidates(baseDir = __dirname) {
-  const candidates = [
-    {
-      label: "packaged CLI artifact",
-      path: resolve(baseDir, "mcp/stdio.js")
-    }
-  ];
-  const roots = ["../../../..", "../../..", "../.."];
-  const entries = [
-    {
-      label: "monorepo build output",
-      path: "apps/mcp/dist/stdio.js"
-    },
-    {
-      label: "xmcp build output",
-      path: "apps/mcp/.xmcp/stdio.js"
-    }
-  ];
-  for (const entry of entries) {
-    for (const root of roots) {
-      candidates.push({
-        label: entry.label,
-        path: resolve(baseDir, root, entry.path)
-      });
-    }
-  }
-  return candidates;
-}
-function findStdioEntry(baseDir = __dirname) {
-  for (const candidate of getStdioEntryCandidates(baseDir)) {
-    if (existsSync2(candidate.path)) return candidate.path;
-  }
-  return null;
-}
-function formatMissingStdioEntryMessage(baseDir = __dirname) {
-  const checked = getStdioEntryCandidates(baseDir).map((candidate) => `  - ${candidate.label}: ${candidate.path}`).join("\n");
-  return [
-    "MCP stdio entry not found.",
-    "Checked:",
-    checked,
-    "Fix:",
-    "  - Monorepo checkout: run pnpm --filter mcp build.",
-    "  - Published CLI: reinstall or update @01.software/cli so dist/mcp/stdio.js is included."
-  ].join("\n");
-}
-function createMcpEnv(baseEnv, client) {
-  const env = {
-    ...baseEnv,
-    SOFTWARE_PUBLISHABLE_KEY: client.publishableKey,
-    SOFTWARE_SECRET_KEY: client.secretKey
-  };
-  delete env.SOFTWARE_TENANT_ID;
-  return env;
-}
-function registerMcpCommands(program2) {
-  program2.command("mcp").description("Start local MCP stdio server for trusted server-key workflows").addHelpText(
-    "after",
-    `
-Prerequisites:
-  Run 01 login, or set SOFTWARE_PUBLISHABLE_KEY and SOFTWARE_SECRET_KEY.
-  Local stdio exposes the full MCP tool surface; HTTP OAuth MCP uses the
-  narrower remote surface documented in the web integration guide.
-  In a monorepo checkout, build the stdio artifact first:
-    pnpm --filter mcp build
-`
-  ).action(() => {
-    const client = resolveClient(program2.opts().apiKey);
-    const stdioEntry = findStdioEntry();
-    if (!stdioEntry) {
-      exitWithError(new Error(formatMissingStdioEntryMessage()));
-    }
-    const child = spawn(process.execPath, [stdioEntry], {
-      env: createMcpEnv(process.env, client),
-      stdio: ["inherit", "inherit", "inherit"]
-    });
-    child.on("error", (err) => {
-      exitWithError(new Error(`Failed to start MCP server: ${err.message}`));
-    });
-    child.on("exit", (code) => {
-      process.exit(code ?? 0);
-    });
-  });
-}
-
 // src/commands/agent.ts
-import { COLLECTIONS as COLLECTIONS3 } from "@01.software/sdk";
+import { SERVER_COLLECTIONS as SERVER_COLLECTIONS3 } from "@01.software/sdk";
 
 // src/lib/agent-output.ts
 var PLAN_AGENT_ERROR_CODES = /* @__PURE__ */ new Set([
@@ -2366,7 +2655,7 @@ function hashAgentPlanEnvelope(input) {
 }
 
 // src/lib/agent-plan-id.ts
-import { resolve as resolve2, sep } from "path";
+import { resolve, sep } from "path";
 var PLAN_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 function assertValidPlanId(planId) {
   if (!PLAN_ID_PATTERN.test(planId)) {
@@ -2375,8 +2664,8 @@ function assertValidPlanId(planId) {
 }
 function safePlanPath(planDir, planId) {
   assertValidPlanId(planId);
-  const resolvedDir = resolve2(planDir);
-  const resolvedPath = resolve2(resolvedDir, `${planId}.json`);
+  const resolvedDir = resolve(planDir);
+  const resolvedPath = resolve(resolvedDir, `${planId}.json`);
   if (resolvedPath !== resolvedDir && !resolvedPath.startsWith(`${resolvedDir}${sep}`)) {
     throw agentPlanError("INVALID_INPUT", "Invalid plan token.");
   }
@@ -2987,7 +3276,10 @@ function parseWhere(value) {
   }
   throw invalidInput2("--where must be a JSON object", "where", value);
 }
-var AGENT_READ_OPERATIONS = ["query", "get"];
+var AGENT_READ_OPERATIONS = [
+  "query",
+  "get"
+];
 var AGENT_PLAN_OPERATIONS = [
   "plan:create",
   "plan:update",
@@ -2995,7 +3287,7 @@ var AGENT_PLAN_OPERATIONS = [
 ];
 function buildAgentManifest() {
   const collections = {};
-  for (const collection of COLLECTIONS3) {
+  for (const collection of SERVER_COLLECTIONS3) {
     const operations = isAgentPlanCollection(collection) ? [...AGENT_READ_OPERATIONS, ...AGENT_PLAN_OPERATIONS] : [...AGENT_READ_OPERATIONS];
     collections[collection] = {
       operations,
@@ -3024,7 +3316,9 @@ function registerAgentCommands(program2, getClient2) {
   );
   configureAgentParser2(
     agent.command("manifest").description("Print the Agent CLI protocol manifest").option("--pretty", "Print 2-space indented JSON").action((opts) => {
-      printAgentSuccess(buildAgentManifest(), { pretty: Boolean(opts.pretty) });
+      printAgentSuccess(buildAgentManifest(), {
+        pretty: Boolean(opts.pretty)
+      });
     })
   );
   configureAgentParser2(
@@ -3095,9 +3389,11 @@ registerReturnCommands(program, getClient, getFormat);
 registerCartCommands(program, getClient, getFormat);
 registerStockCommands(program, getClient, getFormat);
 registerTransactionCommands(program, getClient, getFormat);
+registerProductCommands(program, getClient, getFormat);
+registerDiscountCommands(program, getClient, getFormat);
+registerShippingCommands(program, getClient, getFormat);
 registerSchemaCommands(program, getClient, getFormat);
 registerFeatureCommands(program, getClient, getFormat);
-registerMcpCommands(program);
 registerAuthCommands(program);
 program.parse();
 //# sourceMappingURL=index.js.map