@tarileo/avileo-catalog-cli 0.3.4 → 0.3.6

package/dist/index.js

@@ -6,7 +6,8 @@ var __export = (target, all) => {
 };
 
 // src/program.ts
-import { Command, CommanderError } from "commander";
+import { readFileSync as readFileSync2 } from "fs";
+import { Command } from "commander";
 
 // ../../../node_modules/.bun/zod@4.4.3/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -3046,13 +3047,13 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     }
     return propValues;
   });
-  const isObject3 = isObject;
+  const isObject4 = isObject;
   const catchall = def.catchall;
   let value;
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject3(input)) {
+    if (!isObject4(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -3179,7 +3180,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
     return (payload, ctx) => fn(shape, payload, ctx);
   };
   let fastpass;
-  const isObject3 = isObject;
+  const isObject4 = isObject;
   const jit = !globalConfig.jitless;
   const allowsEval2 = allowsEval;
   const fastEnabled = jit && allowsEval2.value;
@@ -3188,7 +3189,7 @@ var $ZodObjectJIT = /* @__PURE__ */ $constructor("$ZodObjectJIT", (inst, def) =>
   inst._zod.parse = (payload, ctx) => {
     value ?? (value = _normalized.value);
     const input = payload.value;
-    if (!isObject3(input)) {
+    if (!isObject4(input)) {
       payload.issues.push({
         expected: "object",
         code: "invalid_type",
@@ -14686,7 +14687,7 @@ var AgentHttpClient = class {
       } catch {
         abort.cancel();
         if (retry && attempt < 2) {
-          await new Promise((resolve) => setTimeout(resolve, retryDelayMs(attempt)));
+          await new Promise((resolve2) => setTimeout(resolve2, retryDelayMs(attempt)));
           continue;
         }
         throw new AgentNetworkError("No se pudo conectar con la API de Avileo", {
@@ -14697,7 +14698,7 @@ var AgentHttpClient = class {
       }
       abort.cancel();
       if (retry && isRetryableStatus(response.status) && attempt < 2) {
-        await new Promise((resolve) => setTimeout(resolve, retryDelayMs(attempt, response)));
+        await new Promise((resolve2) => setTimeout(resolve2, retryDelayMs(attempt, response)));
         continue;
       }
       let payload;
@@ -14822,6 +14823,73 @@ var UNIT_CATALOG = {
 };
 var UNIT_SLUGS = Object.keys(UNIT_CATALOG);
 var UnitSlugSchema = external_exports.enum(UNIT_SLUGS);
+var ASSET_METADATA_NAMESPACE = "avileoAsset";
+var nullableText = (max) => external_exports.string().trim().min(1).max(max).nullable();
+var tagsSchema = external_exports.array(
+  external_exports.string().trim().min(1).max(48).refine((tag) => !tag.includes(","), "Cada etiqueta debe ir separada, sin comas").transform((tag) => tag.toLowerCase())
+).max(20).transform((tags) => [...new Set(tags)]);
+var AssetVisualSchema = external_exports.object({
+  view: external_exports.enum(["front", "back", "side", "detail", "packaging", "lifestyle", "other"]).nullable(),
+  background: external_exports.enum(["light", "dark", "transparent", "mixed", "other"]).nullable(),
+  hasTransparency: external_exports.boolean().nullable(),
+  containsText: external_exports.boolean().nullable(),
+  containsPrices: external_exports.boolean().nullable()
+}).strict();
+var AssetPresentationSchema = external_exports.object({
+  version: external_exports.literal(1),
+  title: nullableText(160),
+  alt: nullableText(500),
+  tags: tagsSchema,
+  visual: AssetVisualSchema,
+  reviewStatus: external_exports.enum(["incomplete", "reviewed"])
+}).strict();
+var hasValues = (value) => Object.values(value).some((item) => item !== void 0);
+var AssetPresentationPatchSchema = AssetPresentationSchema.omit({ version: true }).partial().extend({
+  visual: AssetVisualSchema.partial().refine(hasValues, "Indica al menos un cambio visual").optional()
+}).strict().refine(hasValues, "Indica al menos un cambio de metadata");
+var AssetMetadataUpdateInputSchema = external_exports.object({
+  expectedRevision: external_exports.string().trim().min(1).max(128),
+  description: nullableText(1e3).optional(),
+  presentation: AssetPresentationPatchSchema.optional()
+}).strict().refine(
+  (input) => input.description !== void 0 || input.presentation !== void 0,
+  "Indica al menos un cambio"
+);
+var PublicAssetPresentationSchema = AssetPresentationSchema.omit({ reviewStatus: true });
+var readableVisualSchema = external_exports.object({
+  view: AssetVisualSchema.shape.view.catch(null),
+  background: AssetVisualSchema.shape.background.catch(null),
+  hasTransparency: AssetVisualSchema.shape.hasTransparency.catch(null),
+  containsText: AssetVisualSchema.shape.containsText.catch(null),
+  containsPrices: AssetVisualSchema.shape.containsPrices.catch(null)
+});
+var readablePresentationSchema = external_exports.object({
+  version: external_exports.literal(1),
+  title: AssetPresentationSchema.shape.title.catch(null),
+  alt: AssetPresentationSchema.shape.alt.catch(null),
+  tags: AssetPresentationSchema.shape.tags.catch(() => []),
+  visual: readableVisualSchema.catch(() => readableVisualSchema.parse({})),
+  reviewStatus: AssetPresentationSchema.shape.reviewStatus.catch("incomplete")
+});
+var metadataEnvelopeSchema = external_exports.object({
+  [ASSET_METADATA_NAMESPACE]: readablePresentationSchema
+});
+var CatalogAssetSchema = external_exports.object({
+  id: external_exports.string().uuid(),
+  filename: external_exports.string(),
+  originalName: external_exports.string(),
+  description: external_exports.string().nullable(),
+  url: external_exports.string().url(),
+  mimeType: external_exports.string(),
+  sizeBytes: external_exports.number().int().nonnegative(),
+  width: external_exports.number().int().nonnegative().nullable(),
+  height: external_exports.number().int().nonnegative().nullable(),
+  presentation: AssetPresentationSchema,
+  revision: external_exports.string().min(1).max(128),
+  createdAt: external_exports.string(),
+  updatedAt: external_exports.string(),
+  updatedByActorId: external_exports.string().nullable()
+}).strict();
 var uuidSchema = external_exports.string().uuid();
 var timestampSchema = external_exports.string().datetime({ offset: true });
 var nonEmptyTextSchema = external_exports.string().trim().min(1);
@@ -14844,7 +14912,13 @@ var AgentAssetDtoSchema = external_exports.object({
   sizeBytes: external_exports.number().int().nonnegative(),
   url: external_exports.string().url(),
   description: nullableTextSchema,
-  createdAt: timestampSchema
+  createdAt: timestampSchema,
+  presentation: AssetPresentationSchema.optional(),
+  revision: external_exports.string().min(1).max(128).optional(),
+  updatedAt: timestampSchema.optional(),
+  updatedByActorId: external_exports.string().nullable().optional(),
+  width: external_exports.number().int().positive().nullable().optional(),
+  height: external_exports.number().int().positive().nullable().optional()
 }).strict();
 var AgentCategoryDtoSchema = external_exports.object({
   id: uuidSchema,
@@ -14945,7 +15019,20 @@ var AgentProductFilterInputSchema = AgentPaginationInputSchema.extend({
   isActive: external_exports.coerce.boolean().optional()
 }).strict();
 var AgentAssetFilterInputSchema = AgentPaginationInputSchema.extend({
-  search: external_exports.string().trim().min(1).max(255).optional()
+  search: external_exports.string().trim().min(1).max(255).optional(),
+  tags: external_exports.union([external_exports.string().transform((value) => value.split(",")), external_exports.array(external_exports.string())]).pipe(
+    external_exports.array(
+      external_exports.string().trim().min(1).max(48).transform((tag) => tag.toLowerCase())
+    ).max(20)
+  ).transform((tags) => [...new Set(tags)]).optional(),
+  containsPrices: external_exports.union([external_exports.boolean(), external_exports.enum(["true", "false"]).transform((value) => value === "true")]).optional(),
+  reviewStatus: external_exports.enum(["incomplete", "reviewed"]).optional(),
+  mimeType: external_exports.string().trim().min(1).max(100).optional()
+}).strict();
+var AgentUpdateAssetInputSchema = AssetMetadataUpdateInputSchema;
+var AgentUpdateAssetPayloadSchema = external_exports.object({
+  assetId: uuidSchema,
+  body: AgentUpdateAssetInputSchema
 }).strict();
 var AgentInventoryMovementFilterInputSchema = AgentPaginationInputSchema.extend({
   reason: external_exports.string().trim().min(1).max(500).optional()
@@ -14957,6 +15044,18 @@ var AgentTagAssignmentInputSchema = external_exports.object({
 var imageAssetIdsSchema = external_exports.array(uuidSchema).max(8).refine((assetIds) => new Set(assetIds).size === assetIds.length, {
   message: "Las im\xE1genes no pueden repetirse"
 });
+var AgentProductImageSourceSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({ kind: external_exports.literal("asset"), assetId: uuidSchema }).strict(),
+  external_exports.object({ kind: external_exports.literal("temporary"), temporaryImageId: uuidSchema }).strict()
+]);
+var productImagesSchema = external_exports.array(AgentProductImageSourceSchema).max(8).refine(
+  (images) => new Set(
+    images.map(
+      (image) => image.kind === "asset" ? `asset:${image.assetId}` : `temporary:${image.temporaryImageId}`
+    )
+  ).size === images.length,
+  { message: "Las im\xE1genes no pueden repetirse" }
+);
 var AgentCreateVariantInputSchema = external_exports.object({
   name: nonEmptyTextSchema.max(50),
   sku: external_exports.string().trim().min(1).max(50).optional(),
@@ -14997,8 +15096,11 @@ var AgentUpdateProductInputSchema = external_exports.object({
   isActive: external_exports.boolean().optional(),
   description: nullableTextSchema.optional(),
   imageAssetIds: imageAssetIdsSchema.optional(),
+  images: productImagesSchema.optional(),
   tagAssignments: external_exports.array(AgentTagAssignmentInputSchema).max(20).optional()
-}).strict().refine((input) => Object.keys(input).length > 0, {
+}).strict().refine((input) => input.images === void 0 || input.imageAssetIds === void 0, {
+  message: "Usa images o imageAssetIds, no ambos"
+}).refine((input) => Object.keys(input).length > 0, {
   message: "Debes indicar al menos un campo para actualizar"
 });
 var AgentCreateCategoryInputSchema = external_exports.object({
@@ -15040,8 +15142,21 @@ var AgentBackendImportImageSourceSchema = external_exports.discriminatedUnion("k
   external_exports.object({
     kind: external_exports.literal("url"),
     url: httpsUrlSchema
+  }).strict(),
+  external_exports.object({
+    kind: external_exports.literal("temporary"),
+    temporaryImageId: uuidSchema
   }).strict()
 ]);
+var AgentCatalogImportTemporaryImageDtoSchema = external_exports.object({
+  id: uuidSchema,
+  url: external_exports.string().url(),
+  filename: nonEmptyTextSchema.max(255),
+  mimeType: nonEmptyTextSchema.max(100),
+  sizeBytes: external_exports.number().int().positive(),
+  contentHash: external_exports.string().regex(/^[a-f0-9]{64}$/),
+  expiresAt: timestampSchema
+}).strict();
 var ExternalRecordRefSchema = external_exports.object({
   source: nonEmptyTextSchema.max(100),
   externalId: external_exports.string().trim().min(1).max(500).optional(),
@@ -15162,6 +15277,7 @@ var AGENT_OPERATION_NAMES = [
   "catalog.tags.delete",
   "catalog.assets.upload",
   "catalog.assets.import",
+  "catalog.assets.update",
   "catalog.inventory.adjust",
   "catalog.inventory.set",
   "catalog.imports.preview",
@@ -15184,6 +15300,15 @@ var AgentOperationProposalInputSchema = external_exports.object({
   operationName: AgentOperationNameSchema,
   payload: external_exports.record(external_exports.string(), external_exports.unknown())
 }).strict();
+var AgentOperationBatchInputSchema = external_exports.object({
+  operationIds: external_exports.array(external_exports.string().trim().toLowerCase().uuid()).min(1).max(50).transform((ids) => [...new Set(ids)])
+}).strict();
+var AgentOperationBatchDtoSchema = external_exports.object({
+  id: uuidSchema,
+  operationIds: external_exports.array(uuidSchema).min(1).max(50),
+  approvalUrl: external_exports.string().url(),
+  createdAt: timestampSchema
+}).strict();
 var AgentOperationProposalDtoSchema = external_exports.object({
   id: uuidSchema,
   operationName: AgentOperationNameSchema,
@@ -15377,6 +15502,25 @@ var AgentBusinessResource = class {
     return this.http.request("/api/v1/agent/business/profile");
   }
 };
+async function uploadTemporaryImage(http, file2, options = {}) {
+  const body = new FormData();
+  body.set("file", file2);
+  const result = await http.request("/api/v1/agent/catalog/imports/images", {
+    method: "POST",
+    body,
+    dispatchIdempotency: true,
+    retry: options.retry
+  });
+  const parsed = AgentCatalogImportTemporaryImageDtoSchema.safeParse(result);
+  if (!parsed.success) {
+    throw new AgentError("La API de Avileo devolvi\xF3 una imagen temporal inv\xE1lida", {
+      code: "INVALID_RESPONSE",
+      status: 201,
+      retryable: false
+    });
+  }
+  return parsed.data;
+}
 var AgentProductsResource = class {
   constructor(http) {
     this.http = http;
@@ -15388,6 +15532,10 @@ var AgentProductsResource = class {
   get(productId) {
     return this.http.request(`/api/v1/agent/catalog/products/${encodeURIComponent(productId)}`);
   }
+  /** Stage bytes for a product gallery proposal; this does not create a permanent asset. */
+  uploadImage(file2, options) {
+    return uploadTemporaryImage(this.http, file2, options);
+  }
   create(input, approvalId) {
     return this.http.request("/api/v1/agent/catalog/products", {
       method: "POST",
@@ -15527,11 +15675,24 @@ var AgentAssetsResource = class {
   }
   http;
   list(filters = {}) {
-    return this.http.request(`/api/v1/agent/catalog/assets${queryString(filters)}`);
+    return this.http.request(
+      `/api/v1/agent/catalog/assets${queryString({
+        ...filters,
+        tags: filters.tags?.length ? filters.tags.join(",") : void 0
+      })}`
+    );
   }
   get(assetId) {
     return this.http.request(`/api/v1/agent/catalog/assets/${encodeURIComponent(assetId)}`);
   }
+  update(assetId, input, approvalId) {
+    return this.http.request(`/api/v1/agent/catalog/assets/${encodeURIComponent(assetId)}`, {
+      method: "PATCH",
+      body: input,
+      dispatchIdempotency: true,
+      approvalId
+    });
+  }
   upload(file2, approvalId) {
     const body = new FormData();
     body.set("file", file2);
@@ -15584,6 +15745,9 @@ var AgentImportsResource = class {
     this.http = http;
   }
   http;
+  uploadImage(file2, options) {
+    return uploadTemporaryImage(this.http, file2, options);
+  }
   preview(input) {
     return this.http.request("/api/v1/agent/catalog/imports/preview", {
       method: "POST",
@@ -15625,6 +15789,15 @@ var AgentOperationsResource = class {
   get(operationId) {
     return this.http.request(`/api/v1/agent/operations/${encodeURIComponent(operationId)}`);
   }
+  createBatch(input) {
+    return this.http.request("/api/v1/agent/operation-batches", {
+      method: "POST",
+      body: input
+    });
+  }
+  getBatch(batchId) {
+    return this.http.request(`/api/v1/agent/operation-batches/${encodeURIComponent(batchId)}`);
+  }
   apply(operationId) {
     return this.http.request(`/api/v1/agent/operations/${encodeURIComponent(operationId)}/apply`, {
       method: "POST",
@@ -16036,7 +16209,194 @@ function registerBusinessCommands(root, getClient) {
 // src/commands/catalog.ts
 import { createHash } from "crypto";
 import { readFile as readFile2, stat } from "fs/promises";
-import { basename, extname } from "path";
+import { basename as basename2, extname } from "path";
+
+// src/commands/import-images.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { constants } from "fs";
+import { open } from "fs/promises";
+import { basename, dirname as dirname2, resolve } from "path";
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+var MAX_TEMPORARY_IMAGES = 100;
+var MAX_TEMPORARY_BYTES = 100 * 1024 * 1024;
+function isObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function invalidInput(message) {
+  throw new CliProtocolError("CLI_VALIDATION_ERROR", message);
+}
+function imageMimeType(bytes) {
+  if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  const signature = bytes.subarray(0, 6).toString("ascii");
+  if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return void 0;
+}
+async function readImage(path, remainingBytes) {
+  const handle = await open(path, constants.O_RDONLY | constants.O_NONBLOCK).catch(
+    () => invalidInput("No se pudo abrir una imagen local del cat\xE1logo")
+  );
+  try {
+    const stats = await handle.stat();
+    if (!stats.isFile() || stats.size === 0 || stats.size > MAX_IMAGE_BYTES) {
+      invalidInput("Cada imagen local debe ser un archivo de entre 1 byte y 5 MiB");
+    }
+    if (stats.size > remainingBytes) {
+      invalidInput("Las im\xE1genes locales no pueden superar 100 MiB en total");
+    }
+    const buffer = Buffer.alloc(Math.min(stats.size + 1, MAX_IMAGE_BYTES + 1));
+    let length = 0;
+    while (length < buffer.length) {
+      const { bytesRead } = await handle.read(buffer, length, buffer.length - length, null);
+      if (bytesRead === 0) break;
+      length += bytesRead;
+    }
+    if (length === 0 || length !== stats.size || length > MAX_IMAGE_BYTES) {
+      invalidInput("La imagen local cambi\xF3 durante la lectura o supera 5 MiB");
+    }
+    const bytes = buffer.subarray(0, length);
+    const mimeType = imageMimeType(bytes);
+    if (!mimeType) invalidInput("Solo se permiten im\xE1genes JPEG, PNG, WebP o GIF");
+    return new File([bytes], basename(path), { type: mimeType });
+  } catch (error51) {
+    if (error51 instanceof CliProtocolError) throw error51;
+    invalidInput("No se pudo leer una imagen local del cat\xE1logo");
+  } finally {
+    await handle.close();
+  }
+}
+function localImageSources(inputPath) {
+  const paths = /* @__PURE__ */ new Map();
+  const placeholders = /* @__PURE__ */ new Map();
+  const baseDirectory = dirname2(resolve(inputPath));
+  const normalizeImages = (value) => {
+    if (!Array.isArray(value)) return value;
+    return value.map((source) => {
+      if (!isObject3(source) || source.kind !== "file") return source;
+      if (Object.keys(source).some((key) => key !== "kind" && key !== "path") || typeof source.path !== "string" || source.path.trim().length === 0 || source.path.includes("\0")) {
+        invalidInput("Cada imagen local requiere \xFAnicamente kind: file y un path v\xE1lido");
+      }
+      const path = resolve(baseDirectory, source.path);
+      let placeholder = paths.get(path);
+      if (!placeholder) {
+        placeholder = randomUUID2();
+        paths.set(path, placeholder);
+        placeholders.set(placeholder, path);
+      }
+      return { kind: "temporary", temporaryImageId: placeholder };
+    });
+  };
+  return { normalizeImages, paths: placeholders };
+}
+async function readLocalImages(paths) {
+  if (paths.size > MAX_TEMPORARY_IMAGES) {
+    invalidInput("La importaci\xF3n no puede preparar m\xE1s de 100 im\xE1genes locales \xFAnicas");
+  }
+  const files = /* @__PURE__ */ new Map();
+  let totalBytes = 0;
+  for (const [placeholder, path] of paths) {
+    const file2 = await readImage(path, MAX_TEMPORARY_BYTES - totalBytes);
+    totalBytes += file2.size;
+    files.set(placeholder, file2);
+  }
+  return files;
+}
+async function prepareCatalogImport(input, inputPath, imports) {
+  const { normalizeImages, paths } = localImageSources(inputPath);
+  const normalizeProduct = (value, includeVariants) => {
+    if (!isObject3(value)) return value;
+    return {
+      ...value,
+      ..."images" in value ? { images: normalizeImages(value.images) } : {},
+      ...includeVariants && Array.isArray(value.variants) ? { variants: value.variants.map((variant) => normalizeProduct(variant, false)) } : {}
+    };
+  };
+  const candidate = isObject3(input) && Array.isArray(input.products) ? { ...input, products: input.products.map((product) => normalizeProduct(product, true)) } : input;
+  const parsed = AgentCatalogImportPreviewInputSchema.safeParse(candidate);
+  if (!parsed.success) {
+    invalidInput("La lista de importaci\xF3n contiene campos inv\xE1lidos o no permitidos");
+  }
+  const files = await readLocalImages(paths);
+  const uploaded = /* @__PURE__ */ new Map();
+  for (const [placeholder, file2] of files) {
+    const temporary = await imports.uploadImage(file2);
+    uploaded.set(placeholder, temporary.id);
+  }
+  const replaceImages = (images) => images?.map((source) => {
+    if (source.kind !== "temporary") return source;
+    const id = uploaded.get(source.temporaryImageId);
+    return id ? { kind: "temporary", temporaryImageId: id } : source;
+  });
+  return {
+    ...parsed.data,
+    products: parsed.data.products.map((product) => ({
+      ...product,
+      ...product.images ? { images: replaceImages(product.images) } : {},
+      ...product.variants ? {
+        variants: product.variants.map((variant) => ({
+          ...variant,
+          ...variant.images ? { images: replaceImages(variant.images) } : {}
+        }))
+      } : {}
+    }))
+  };
+}
+
+// src/commands/product-images.ts
+async function prepareProductUpdate(input, inputPath, allowFiles = true) {
+  const { normalizeImages, paths } = localImageSources(inputPath);
+  const candidate = {
+    ...input,
+    ..."images" in input ? { images: normalizeImages(input.images) } : {}
+  };
+  if (!allowFiles && paths.size > 0) {
+    throw new CliProtocolError(
+      "CLI_VALIDATION_ERROR",
+      "Para aplicar im\xE1genes ya aprobadas, omite --from y usa --apply --approval-id. Los archivos cambiados requieren una nueva propuesta."
+    );
+  }
+  const parsed = AgentUpdateProductInputSchema.safeParse(candidate);
+  if (!parsed.success) {
+    throw new CliProtocolError(
+      "CLI_VALIDATION_ERROR",
+      "La actualizaci\xF3n contiene campos inv\xE1lidos: usa images o imageAssetIds, con hasta 8 im\xE1genes \xFAnicas y sin URLs."
+    );
+  }
+  const files = await readLocalImages(paths);
+  return { body: parsed.data, files };
+}
+function approvedProductUpdate(operation, approvalId, productId) {
+  const input = operation.input;
+  if (operation.id !== approvalId || operation.operationName !== "catalog.products.update" || !input || typeof input !== "object" || Array.isArray(input) || input.productId !== productId || Object.keys(input).some((key) => key !== "productId" && key !== "body")) {
+    throw new CliProtocolError(
+      "CLI_VALIDATION_ERROR",
+      "La aprobaci\xF3n no corresponde a esta actualizaci\xF3n de producto"
+    );
+  }
+  if (operation.state !== "approved" || !Number.isFinite(Date.parse(operation.expiresAt)) || Date.parse(operation.expiresAt) <= Date.now()) {
+    throw new CliProtocolError(
+      "CLI_VALIDATION_ERROR",
+      "La operaci\xF3n debe estar aprobada y vigente antes de aplicar"
+    );
+  }
+  const parsed = AgentUpdateProductInputSchema.safeParse(input.body);
+  if (!parsed.success) {
+    throw new CliProtocolError(
+      "CLI_VALIDATION_ERROR",
+      "El payload aprobado no es una actualizaci\xF3n de producto v\xE1lida"
+    );
+  }
+  return parsed.data;
+}
+
+// src/commands/catalog.ts
 function requireId(value, name) {
   if (!value.trim()) throw new CliProtocolError("CLI_VALIDATION_ERROR", `${name} es obligatorio`);
   return value;
@@ -16114,21 +16474,54 @@ function registerProductCommands(catalog, getClient) {
       (approvalId) => getClient().products.create(input, approvalId)
     );
   });
-  withMutationOptions(product.command("update <productId>")).action(
-    async (productId, options, command) => {
-      const id = requireId(productId, "productId");
-      const input = await readMutationInput(options.from);
-      await applyOrPreview(
-        command,
-        input,
-        getClient,
-        "catalog.products.update",
-        { productId: id, body: input },
-        (approvalId) => getClient().products.update(id, input, approvalId),
-        () => getClient().products.get(id)
-      );
+  withMutationOptions(
+    product.command("update <productId>").option("--from <json-file>", "Objeto JSON estructurado"),
+    false
+  ).action(async (productId, options, command) => {
+    const id = requireId(productId, "productId");
+    const { approvalId: rawApprovalId } = command.optsWithGlobals();
+    const approvalId = typeof rawApprovalId === "string" ? requireId(rawApprovalId, "approvalId") : void 0;
+    if (!options.from) {
+      if (!wantsApply(command) || !approvalId) {
+        throw new CliProtocolError(
+          "CLI_VALIDATION_ERROR",
+          "--from es obligatorio salvo al aplicar con --apply --approval-id"
+        );
+      }
+      const client = getClient();
+      const operation = await client.operations.get(approvalId);
+      const body = approvedProductUpdate(operation, approvalId, id);
+      emitSuccess(await client.products.update(id, body, approvalId));
+      return;
     }
-  );
+    const input = await readMutationInput(options.from);
+    const prepared = await prepareProductUpdate(input, options.from, approvalId === void 0);
+    if (wantsApply(command) && !approvalId) {
+      const uploaded = /* @__PURE__ */ new Map();
+      for (const [placeholder, file2] of prepared.files) {
+        const image = await getClient().products.uploadImage(file2);
+        uploaded.set(placeholder, image.id);
+      }
+      if (prepared.body.images) {
+        prepared.body.images = prepared.body.images.map((source) => {
+          if (source.kind !== "temporary") return source;
+          return {
+            kind: "temporary",
+            temporaryImageId: uploaded.get(source.temporaryImageId) ?? source.temporaryImageId
+          };
+        });
+      }
+    }
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.products.update",
+      { productId: id, body: prepared.body },
+      (approvalId2) => getClient().products.update(id, prepared.body, approvalId2),
+      () => getClient().products.get(id)
+    );
+  });
   withMutationOptions(product.command("deactivate <productId>"), false).action(
     async (productId, _options, command) => {
       const id = requireId(productId, "productId");
@@ -16305,10 +16698,38 @@ function registerTagCommands(catalog, getClient) {
 }
 function registerAssetCommands(catalog, getClient) {
   const asset = catalog.command("asset");
-  asset.command("list").option("--search <text>").option("--limit <number>", "M\xE1ximo de resultados", parseInteger).option("--offset <number>", "Desplazamiento", parseInteger).action(async (options) => emitSuccess(await getClient().assets.list(options)));
+  asset.command("list").option("--search <text>").option("--tags <tags>", "Etiquetas separadas por comas; deben coincidir todas").option("--contains-prices <true|false>", "Presencia de precios conocida", parseBoolean).option("--review-status <status>", "incomplete o reviewed").option("--mime-type <type>", "Formato MIME o prefijo image/").option("--limit <number>", "M\xE1ximo de resultados", parseInteger).option("--offset <number>", "Desplazamiento", parseInteger).action(async (options) => {
+    const parsed = AgentAssetFilterInputSchema.safeParse(options);
+    if (!parsed.success) {
+      throw new CliProtocolError("CLI_VALIDATION_ERROR", "Los filtros de assets no son v\xE1lidos");
+    }
+    emitSuccess(await getClient().assets.list(parsed.data));
+  });
   asset.command("get <assetId>").action(async (assetId) => {
     emitSuccess(await getClient().assets.get(requireId(assetId, "assetId")));
   });
+  withMutationOptions(
+    asset.command("update <assetId>").option("--diff", "Incluye la ficha actual")
+  ).action(async (assetId, options, command) => {
+    const id = requireId(assetId, "assetId");
+    const parsed = AssetMetadataUpdateInputSchema.safeParse(await readMutationInput(options.from));
+    if (!parsed.success) {
+      throw new CliProtocolError(
+        "CLI_VALIDATION_ERROR",
+        "Metadata inv\xE1lida: incluye expectedRevision y cambios de description o presentation"
+      );
+    }
+    const input = parsed.data;
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.assets.update",
+      { assetId: id, body: input },
+      (approvalId) => getClient().assets.update(id, input, approvalId),
+      options.diff ? () => getClient().assets.get(id) : void 0
+    );
+  });
   withMutationOptions(
     asset.command("upload").requiredOption("--file <path>", "Archivo local"),
     false
@@ -16321,7 +16742,7 @@ function registerAssetCommands(catalog, getClient) {
     if (!wantsApply(command)) {
       emitSuccess({
         validated: "local",
-        file: basename(filePath),
+        file: basename2(filePath),
         sizeBytes: fileStat.size
       });
       return;
@@ -16335,7 +16756,7 @@ function registerAssetCommands(catalog, getClient) {
       );
     }
     const contents = await readFile2(filePath);
-    const file2 = new File([contents], basename(filePath), { type: mimeType });
+    const file2 = new File([contents], basename2(filePath), { type: mimeType });
     const rawApprovalId = command.optsWithGlobals().approvalId;
     if (typeof rawApprovalId === "string") {
       emitSuccess(await getClient().assets.upload(file2, requireId(rawApprovalId, "approvalId")));
@@ -16406,27 +16827,13 @@ function registerInventoryCommands(catalog, getClient) {
     }
   );
 }
-function rejectLocalFileSources(value) {
-  if (Array.isArray(value)) {
-    for (const item of value) rejectLocalFileSources(item);
-    return;
-  }
-  if (!value || typeof value !== "object") return;
-  const source = value;
-  if (source.kind === "file") {
-    throw new CliProtocolError(
-      "CLI_VALIDATION_ERROR",
-      "Sube cada imagen local con catalog asset upload, apru\xE9bala y usa su assetId"
-    );
-  }
-  for (const nested of Object.values(source)) rejectLocalFileSources(nested);
-}
 function registerImportCommands(catalog, getClient) {
   const imports = catalog.command("import");
   imports.command("preview").requiredOption("--from <json-file>", "Lista estructurada para vista previa").action(async (options) => {
     const input = await readMutationInput(options.from);
-    rejectLocalFileSources(input);
-    emitSuccess(await getClient().imports.preview(input));
+    const client = getClient();
+    const prepared = await prepareCatalogImport(input, options.from, client.imports);
+    emitSuccess(await client.imports.preview(prepared));
   });
   withMutationOptions(imports.command("apply <importId>"), false).action(
     async (importId, _options, command) => {
@@ -16446,6 +16853,36 @@ function registerImportCommands(catalog, getClient) {
   });
 }
 
+// src/commands/operation-batches.ts
+function registerOperationBatchCommands(operation, getClient) {
+  const batch = operation.command("batch").description("Agrupa propuestas para revisarlas con un enlace corto");
+  batch.command("create").description("Crea un grupo de revisi\xF3n; no aprueba ni aplica sus operaciones").requiredOption(
+    "--from <json-file>",
+    "Objeto JSON con operationIds de las propuestas existentes"
+  ).action(async (options) => {
+    const parsed = AgentOperationBatchInputSchema.safeParse(
+      await readMutationInput(options.from)
+    );
+    if (!parsed.success) {
+      throw new CliProtocolError(
+        "CLI_VALIDATION_ERROR",
+        parsed.error.issues[0]?.message ?? "Grupo inv\xE1lido"
+      );
+    }
+    emitSuccess(await getClient().operations.createBatch(parsed.data));
+  });
+  batch.command("get <id>").description("Consulta un grupo y recupera su enlace corto de revisi\xF3n").action(async (id) => {
+    const parsed = AgentOperationBatchDtoSchema.shape.id.safeParse(id.trim());
+    if (!parsed.success) {
+      throw new CliProtocolError(
+        "CLI_VALIDATION_ERROR",
+        "El identificador del grupo debe ser un UUID v\xE1lido"
+      );
+    }
+    emitSuccess(await getClient().operations.getBatch(parsed.data));
+  });
+}
+
 // src/commands/auth.ts
 import { spawn } from "child_process";
 function safeStartResult(start, browserOpened) {
@@ -16473,7 +16910,7 @@ function safeFinalResult(start, browserOpened, result) {
   };
 }
 function sleep(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
 }
 function readAgentKeyFromTty(prompt = "Agent Key de Avileo: ") {
   if (!process.stdin.isTTY || !process.stderr.isTTY) {
@@ -16482,7 +16919,7 @@ function readAgentKeyFromTty(prompt = "Agent Key de Avileo: ") {
       "auth configure requiere una terminal interactiva; usa AVILEO_AGENT_API_KEY en CI/CD"
     );
   }
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let value = "";
     const input = process.stdin;
     const output = process.stderr;
@@ -16496,7 +16933,7 @@ function readAgentKeyFromTty(prompt = "Agent Key de Avileo: ") {
       cleanup();
       output.write("\n");
       if (result instanceof Error) reject(result);
-      else resolve(result);
+      else resolve2(result);
     };
     const onData = (chunk) => {
       for (const character of String(chunk)) {
@@ -16527,12 +16964,12 @@ function readAgentKeyFromTty(prompt = "Agent Key de Avileo: ") {
   });
 }
 async function openWithExecutable(command, args) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const child = spawn(command, args, { stdio: "ignore", shell: false, detached: true });
-    child.once("error", () => resolve(false));
+    child.once("error", () => resolve2(false));
     child.once("spawn", () => {
       child.unref();
-      resolve(true);
+      resolve2(true);
     });
   });
 }
@@ -16673,6 +17110,12 @@ function registerAuthCommands(root, options) {
 }
 
 // src/program.ts
+var CliVersionRequested = class extends Error {
+  constructor() {
+    super("version requested");
+    this.name = "CliVersionRequested";
+  }
+};
 function createProgram(options = {}) {
   const program = new Command();
   let client;
@@ -16683,10 +17126,15 @@ function createProgram(options = {}) {
     });
     return client;
   });
-  program.name("avileo").description("CLI seguro para el cat\xE1logo de un negocio Avileo").option("--json", "Emite la envoltura JSON versionada para automatizaci\xF3n");
+  const packageJson = JSON.parse(
+    readFileSync2(new URL("../package.json", import.meta.url), "utf8")
+  );
+  const cliVersion = typeof packageJson === "object" && packageJson !== null && "version" in packageJson && typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  program.name("avileo").description("CLI seguro para el cat\xE1logo de un negocio Avileo").version(cliVersion, "--version", "Muestra la versi\xF3n del paquete publicado").option("--json", "Emite la envoltura JSON versionada para automatizaci\xF3n");
   program.configureOutput({ writeErr: () => void 0 });
   program.exitOverride((error51) => {
     if (error51.code === "commander.helpDisplayed") return;
+    if (error51.code === "commander.version") throw new CliVersionRequested();
     throw new CliProtocolError("CLI_USAGE_ERROR", error51.message);
   });
   registerAuthCommands(program, {
@@ -16700,6 +17148,7 @@ function createProgram(options = {}) {
   registerBusinessCommands(program, getClient);
   registerCatalogCommands(program, getClient);
   const operation = program.command("operation").description("Consulta y aplica operaciones aprobadas en Avileo");
+  registerOperationBatchCommands(operation, getClient);
   operation.command("status <id>").description("Consulta el estado de una operaci\xF3n").action(async (id) => {
     if (!id.trim()) {
       throw new CliProtocolError("CLI_VALIDATION_ERROR", "id es obligatorio");
@@ -16724,7 +17173,9 @@ function createProgram(options = {}) {
     try {
       return await parseAsync3(...args);
     } catch (error51) {
-      if (error51 instanceof CommanderError && error51.code === "commander.helpDisplayed")
+      if (error51 instanceof CliVersionRequested) return program;
+      const errorCode = typeof error51 === "object" && error51 !== null && "code" in error51 ? String(error51.code) : "";
+      if (errorCode === "commander.helpDisplayed" || errorCode === "commander.version")
         return program;
       emitFailure(toFailure(error51));
       process.exitCode = exitCodeFor(error51);