@tarileo/avileo-catalog-cli 0.2.2 → 0.3.1

package/dist/index.js

@@ -14675,6 +14675,7 @@ var AgentHttpClient = class {
           headers: {
             ...formData || options.body === void 0 ? {} : { "content-type": "application/json" },
             ...operationId ? { "idempotency-key": operationId } : {},
+            ...options.approvalId ? { "x-avileo-approval-id": options.approvalId } : {},
             ...this.#apiKey ? { "x-avileo-agent-key": this.#apiKey } : {}
           },
           body,
@@ -14728,16 +14729,19 @@ var AGENT_CAPABILITY_ACTIONS = [
   "assets:read",
   "assets:write",
   "inventory:read",
-  "inventory:write"
+  "inventory:write",
+  "payments:read",
+  "payments:write"
 ];
 var AgentCapabilityActionSchema = external_exports.enum(AGENT_CAPABILITY_ACTIONS);
-var AGENT_CATALOG_KEY_PRESET_ACTIONS = [
+var AGENT_KEY_MODES = ["read", "mutate"];
+var AgentKeyModeSchema = external_exports.enum(AGENT_KEY_MODES);
+var AGENT_KEY_READ_ACTIONS = [
   "business:read",
   "catalog:read",
-  "catalog:write",
   "assets:read",
-  "assets:write",
-  "inventory:read"
+  "inventory:read",
+  "payments:read"
 ];
 var AgentGrantedActionsSchema = external_exports.array(AgentCapabilityActionSchema).min(1).max(AGENT_CAPABILITY_ACTIONS.length).refine((actions) => new Set(actions).size === actions.length, {
   message: "Las capacidades no pueden repetirse"
@@ -14909,7 +14913,7 @@ var AgentStorefrontDtoSchema = external_exports.object({
 }).strict();
 var AgentBusinessDtoSchema = external_exports.object({
   name: nonEmptyTextSchema.max(255),
-  businessMode: external_exports.literal("tienda"),
+  businessMode: external_exports.string().trim().min(1).max(50),
   currency: external_exports.string().trim().length(3),
   isActive: external_exports.literal(true),
   tenantState: external_exports.literal("active"),
@@ -15140,14 +15144,178 @@ var AgentCatalogImportResultDtoSchema = external_exports.object({
   updatedAt: timestampSchema,
   completedAt: timestampSchema.nullable()
 }).strict();
+var AGENT_OPERATION_NAMES = [
+  "catalog.products.create",
+  "catalog.products.update",
+  "catalog.products.deactivate",
+  "catalog.variants.create",
+  "catalog.variants.reorder",
+  "catalog.variants.update",
+  "catalog.variants.deactivate",
+  "catalog.categories.create",
+  "catalog.categories.update",
+  "catalog.categories.delete",
+  "catalog.tags.create",
+  "catalog.tags.update",
+  "catalog.tags.delete",
+  "catalog.assets.upload",
+  "catalog.assets.import",
+  "catalog.inventory.adjust",
+  "catalog.inventory.set",
+  "catalog.imports.preview",
+  "catalog.imports.apply",
+  "business.profile.update",
+  "catalog.client_keys.create"
+];
+var AgentOperationNameSchema = external_exports.enum(AGENT_OPERATION_NAMES);
+var AGENT_OPERATION_STATES = [
+  "awaiting_approval",
+  "approved",
+  "rejected",
+  "succeeded",
+  "failed",
+  "expired",
+  "conflict"
+];
+var AgentOperationStateSchema = external_exports.enum(AGENT_OPERATION_STATES);
+var AgentOperationProposalInputSchema = external_exports.object({
+  operationName: AgentOperationNameSchema,
+  payload: external_exports.record(external_exports.string(), external_exports.unknown())
+}).strict();
+var AgentOperationProposalDtoSchema = external_exports.object({
+  id: uuidSchema,
+  operationName: AgentOperationNameSchema,
+  state: external_exports.literal("awaiting_approval"),
+  input: external_exports.record(external_exports.string(), external_exports.unknown()),
+  summary: nonEmptyTextSchema.max(500),
+  diff: external_exports.record(external_exports.string(), external_exports.unknown()),
+  approvalUrl: external_exports.string().url(),
+  createdAt: timestampSchema,
+  expiresAt: timestampSchema
+}).strict();
+var AgentOperationStatusDtoSchema = external_exports.object({
+  id: uuidSchema,
+  operationName: AgentOperationNameSchema,
+  state: AgentOperationStateSchema,
+  input: external_exports.record(external_exports.string(), external_exports.unknown()),
+  summary: nonEmptyTextSchema.max(500),
+  diff: external_exports.record(external_exports.string(), external_exports.unknown()),
+  approvalUrl: external_exports.string().url(),
+  result: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  error: external_exports.record(external_exports.string(), external_exports.unknown()).nullable(),
+  approvedAt: timestampSchema.nullable(),
+  rejectedAt: timestampSchema.nullable(),
+  completedAt: timestampSchema.nullable(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  expiresAt: timestampSchema
+}).strict();
+var AgentOperationProposalEnvelopeSchema = external_exports.object({
+  success: external_exports.literal(true),
+  data: AgentOperationProposalDtoSchema
+}).strict();
+var AgentOperationStatusEnvelopeSchema = external_exports.object({
+  success: external_exports.literal(true),
+  data: AgentOperationStatusDtoSchema
+}).strict();
+var AgentOperationApplyEnvelopeSchema = external_exports.object({
+  success: external_exports.literal(true),
+  data: external_exports.record(external_exports.string(), external_exports.unknown())
+}).strict();
+var AGENT_PAYMENT_LINK_STATUSES = [
+  "awaiting_payment",
+  "verifying",
+  "under_review",
+  "confirmed",
+  "rejected",
+  "expired",
+  "cancelled"
+];
+var AgentPaymentLinkStatusSchema = external_exports.enum(AGENT_PAYMENT_LINK_STATUSES);
+var AGENT_PAYMENT_LINK_EXPECTED_METHODS = [
+  "yape",
+  "plin",
+  "transferencia",
+  "any"
+];
+var AgentPaymentLinkExpectedMethodSchema = external_exports.enum(AGENT_PAYMENT_LINK_EXPECTED_METHODS);
+var AGENT_PAYMENT_LINK_CONFIRMED_BY = ["ai", "gateway", "manual", "platform"];
+var AgentPaymentLinkConfirmedBySchema = external_exports.enum(AGENT_PAYMENT_LINK_CONFIRMED_BY);
+var AgentPaymentLinkExtractionDtoSchema = external_exports.object({
+  provider: external_exports.enum(["yape", "plin", "bbva_transfer", "unknown"]),
+  /** Detected amount in soles (major units), or null when illegible. */
+  detectedAmount: external_exports.number().nonnegative().multipleOf(0.01).nullable(),
+  currency: external_exports.string().length(3).nullable(),
+  operationNumber: external_exports.string().nullable(),
+  paidAt: timestampSchema.nullable(),
+  payerName: external_exports.string().nullable(),
+  recipientName: external_exports.string().nullable(),
+  confidence: external_exports.enum(["high", "medium", "low"]),
+  signals: external_exports.array(external_exports.string())
+}).strict();
+var AgentCreatePaymentLinkInputSchema = external_exports.object({
+  /** Amount in soles (major units); the backend stores amountMinor. */
+  amount: external_exports.number().positive().multipleOf(0.01).max(1e6),
+  currency: external_exports.string().trim().length(3).optional(),
+  concept: nonEmptyTextSchema.max(200).optional(),
+  expectedMethod: AgentPaymentLinkExpectedMethodSchema.optional(),
+  expiresInHours: external_exports.number().int().min(1).max(720).optional(),
+  customerPhone: nonEmptyTextSchema.max(20).optional(),
+  idempotencyKey: nonEmptyTextSchema.max(80).optional()
+}).strict();
+var AgentPaymentLinkBaseDtoSchema = external_exports.object({
+  id: uuidSchema,
+  /** Requested amount in soles (major units). */
+  amount: external_exports.number().positive().multipleOf(0.01),
+  currency: external_exports.string().length(3),
+  concept: external_exports.string().nullable(),
+  expectedMethod: AgentPaymentLinkExpectedMethodSchema,
+  status: AgentPaymentLinkStatusSchema,
+  confirmedBy: AgentPaymentLinkConfirmedBySchema.nullable(),
+  extraction: AgentPaymentLinkExtractionDtoSchema.nullable(),
+  expiresAt: timestampSchema,
+  createdAt: timestampSchema,
+  confirmedAt: timestampSchema.nullable().optional()
+}).strict();
+var AgentPaymentLinkDtoSchema = AgentPaymentLinkBaseDtoSchema.extend({
+  /** Persisted links can never recover the plaintext token URL. */
+  url: external_exports.null()
+}).strict();
+var AgentCreatedPaymentLinkDtoSchema = external_exports.discriminatedUnion("replayed", [
+  AgentPaymentLinkBaseDtoSchema.extend({
+    url: external_exports.string().url(),
+    replayed: external_exports.literal(false)
+  }).strict(),
+  AgentPaymentLinkBaseDtoSchema.extend({
+    url: external_exports.null(),
+    replayed: external_exports.literal(true)
+  }).strict()
+]);
+var isoDateOrTimestampSchema = external_exports.union([
+  external_exports.string().date(),
+  external_exports.string().datetime({ offset: true })
+]);
+var AgentPaymentLinkFilterInputSchema = AgentPaginationInputSchema.extend({
+  status: AgentPaymentLinkStatusSchema.optional(),
+  from: isoDateOrTimestampSchema.optional(),
+  to: isoDateOrTimestampSchema.optional()
+}).strict();
+var AgentPaymentLinkPageSchema = external_exports.object({
+  items: external_exports.array(AgentPaymentLinkDtoSchema),
+  total: external_exports.number().int().nonnegative()
+}).strict();
 var AGENT_DEVICE_AUTH_STATUSES = ["pending", "approved", "denied", "expired"];
-var AGENT_DEVICE_AUTH_DEFAULT_PERMISSIONS = [...AGENT_CATALOG_KEY_PRESET_ACTIONS];
+var AGENT_DEVICE_AUTH_DEFAULT_PERMISSIONS = [
+  ...AGENT_KEY_READ_ACTIONS
+];
 function parsePollResponse(value) {
   if (!AGENT_DEVICE_AUTH_STATUSES.includes(value.status)) {
     throw new Error("La API de Avileo devolvi\xF3 un estado de autorizaci\xF3n inv\xE1lido");
   }
   if (value.permissions) {
-    const parsed = value.permissions.map((permission) => AgentCapabilityActionSchema.parse(permission));
+    const parsed = value.permissions.map(
+      (permission) => AgentCapabilityActionSchema.parse(permission)
+    );
     return { ...value, permissions: parsed };
   }
   return value;
@@ -15165,10 +15333,13 @@ var AvileoAgentDeviceAuthClient = class {
   }
   async poll(deviceCode) {
     if (!deviceCode.trim()) throw new Error("deviceCode es obligatorio");
-    const result = await this.http.request("/api/v1/agent-auth/device/poll", {
-      method: "POST",
-      body: { deviceCode }
-    });
+    const result = await this.http.request(
+      "/api/v1/agent-auth/device/poll",
+      {
+        method: "POST",
+        body: { deviceCode }
+      }
+    );
     return parsePollResponse(result);
   }
 };
@@ -15191,6 +15362,9 @@ var AgentBusinessResource = class {
   get() {
     return this.http.request("/api/v1/agent/business");
   }
+  profile() {
+    return this.http.request("/api/v1/agent/business/profile");
+  }
 };
 var AgentProductsResource = class {
   constructor(http) {
@@ -15203,24 +15377,26 @@ var AgentProductsResource = class {
   get(productId) {
     return this.http.request(`/api/v1/agent/catalog/products/${encodeURIComponent(productId)}`);
   }
-  create(input) {
+  create(input, approvalId) {
     return this.http.request("/api/v1/agent/catalog/products", {
       method: "POST",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  update(productId, input) {
+  update(productId, input, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/products/${encodeURIComponent(productId)}`, {
       method: "PATCH",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  deactivate(productId) {
+  deactivate(productId, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/products/${encodeURIComponent(productId)}/deactivate`,
-      { method: "POST", mutation: true }
+      { method: "POST", mutation: true, approvalId }
     );
   }
 };
@@ -15237,29 +15413,30 @@ var AgentVariantsResource = class {
   get(variantId) {
     return this.http.request(`/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}`);
   }
-  create(productId, input) {
+  create(productId, input, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/products/${encodeURIComponent(productId)}/variants`,
-      { method: "POST", body: input, mutation: true }
+      { method: "POST", body: input, mutation: true, approvalId }
     );
   }
-  update(variantId, input) {
+  update(variantId, input, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}`, {
       method: "PATCH",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  deactivate(variantId) {
+  deactivate(variantId, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}/deactivate`,
-      { method: "POST", mutation: true }
+      { method: "POST", mutation: true, approvalId }
     );
   }
-  reorder(productId, input) {
+  reorder(productId, input, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/products/${encodeURIComponent(productId)}/variants/reorder`,
-      { method: "POST", body: input, mutation: true }
+      { method: "POST", body: input, mutation: true, approvalId }
     );
   }
 };
@@ -15274,24 +15451,27 @@ var AgentCategoriesResource = class {
   get(categoryId) {
     return this.http.request(`/api/v1/agent/catalog/categories/${encodeURIComponent(categoryId)}`);
   }
-  create(input) {
+  create(input, approvalId) {
     return this.http.request("/api/v1/agent/catalog/categories", {
       method: "POST",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  update(categoryId, input) {
+  update(categoryId, input, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/categories/${encodeURIComponent(categoryId)}`, {
       method: "PATCH",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  delete(categoryId) {
+  delete(categoryId, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/categories/${encodeURIComponent(categoryId)}`, {
       method: "DELETE",
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
 };
@@ -15306,24 +15486,27 @@ var AgentTagsResource = class {
   get(tagId) {
     return this.http.request(`/api/v1/agent/catalog/tags/${encodeURIComponent(tagId)}`);
   }
-  create(input) {
+  create(input, approvalId) {
     return this.http.request("/api/v1/agent/catalog/tags", {
       method: "POST",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  update(tagId, input) {
+  update(tagId, input, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/tags/${encodeURIComponent(tagId)}`, {
       method: "PATCH",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  delete(tagId) {
+  delete(tagId, approvalId) {
     return this.http.request(`/api/v1/agent/catalog/tags/${encodeURIComponent(tagId)}`, {
       method: "DELETE",
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
 };
@@ -15338,20 +15521,22 @@ var AgentAssetsResource = class {
   get(assetId) {
     return this.http.request(`/api/v1/agent/catalog/assets/${encodeURIComponent(assetId)}`);
   }
-  upload(file2) {
+  upload(file2, approvalId) {
     const body = new FormData();
     body.set("file", file2);
     return this.http.request("/api/v1/agent/catalog/assets/upload", {
       method: "POST",
       body,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
-  importFromUrl(input) {
+  importFromUrl(input, approvalId) {
     return this.http.request("/api/v1/agent/catalog/assets/import", {
       method: "POST",
       body: input,
-      mutation: true
+      mutation: true,
+      approvalId
     });
   }
 };
@@ -15370,16 +15555,16 @@ var AgentInventoryResource = class {
       `/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}/inventory/movements${queryString(filters)}`
     );
   }
-  adjust(variantId, input) {
+  adjust(variantId, input, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}/inventory/adjust`,
-      { method: "POST", body: input, mutation: true }
+      { method: "POST", body: input, mutation: true, approvalId }
     );
   }
-  set(variantId, input) {
+  set(variantId, input, approvalId) {
     return this.http.request(
       `/api/v1/agent/catalog/variants/${encodeURIComponent(variantId)}/inventory`,
-      { method: "PUT", body: input, mutation: true }
+      { method: "PUT", body: input, mutation: true, approvalId }
     );
   }
 };
@@ -15395,27 +15580,88 @@ var AgentImportsResource = class {
       mutation: true
     });
   }
-  apply(importId) {
-    return this.http.request(`/api/v1/agent/catalog/imports/${encodeURIComponent(importId)}/apply`, {
+  apply(importId, approvalId) {
+    return this.http.request(
+      `/api/v1/agent/catalog/imports/${encodeURIComponent(importId)}/apply`,
+      {
+        method: "POST",
+        mutation: true,
+        approvalId
+      }
+    );
+  }
+  get(importId) {
+    return this.http.request(`/api/v1/agent/catalog/imports/${encodeURIComponent(importId)}`);
+  }
+};
+var AgentOperationsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  propose(input) {
+    return this.http.request("/api/v1/agent/operations", {
       method: "POST",
+      body: input,
       mutation: true
     });
   }
-  get(importId) {
-    return this.http.request(`/api/v1/agent/catalog/imports/${encodeURIComponent(importId)}`);
+  proposeClientKey(name) {
+    return this.propose({
+      operationName: "catalog.client_keys.create",
+      payload: name === void 0 ? {} : { name }
+    });
+  }
+  get(operationId) {
+    return this.http.request(`/api/v1/agent/operations/${encodeURIComponent(operationId)}`);
+  }
+  apply(operationId) {
+    return this.http.request(`/api/v1/agent/operations/${encodeURIComponent(operationId)}/apply`, {
+      method: "POST",
+      mutation: true,
+      approvalId: operationId
+    });
+  }
+};
+var AgentPaymentLinksResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * Creates a payment link. `amount` is in soles (major units); the backend
+   * converts it to minor units — never convert it here. The URL is only
+   * non-null for the initial create response.
+   */
+  create(input) {
+    return this.http.request("/api/v1/agent/payment-links", {
+      method: "POST",
+      body: input,
+      mutation: true
+    }).then((response) => AgentCreatedPaymentLinkDtoSchema.parse(response));
+  }
+  /** Fetches a persisted link; `url` is always `null`. */
+  get(paymentLinkId) {
+    return this.http.request(`/api/v1/agent/payment-links/${encodeURIComponent(paymentLinkId)}`).then((response) => AgentPaymentLinkDtoSchema.parse(response));
+  }
+  /** Lists persisted links; every item has `url: null`. */
+  list(filter = {}) {
+    return this.http.request(`/api/v1/agent/payment-links${queryString(filter)}`).then((response) => AgentPaymentLinkPageSchema.parse(response));
   }
 };
 function createAvileoAgent(config2) {
   const http = new AgentHttpClient(config2);
   return {
     business: new AgentBusinessResource(http),
+    operations: new AgentOperationsResource(http),
     products: new AgentProductsResource(http),
     variants: new AgentVariantsResource(http),
     categories: new AgentCategoriesResource(http),
     tags: new AgentTagsResource(http),
     assets: new AgentAssetsResource(http),
     inventory: new AgentInventoryResource(http),
-    imports: new AgentImportsResource(http)
+    imports: new AgentImportsResource(http),
+    paymentLinks: new AgentPaymentLinksResource(http)
   };
 }
 
@@ -15554,7 +15800,8 @@ function emitFailure(failure) {
 function exitCodeFor(error51) {
   const candidate = error51;
   if (candidate.retryable) return 2;
-  if (candidate.status === 409 || /CONFLICT|IDEMPOTENCY|VERSION/.test(candidate.code ?? "")) return 4;
+  if (candidate.status === 409 || /CONFLICT|IDEMPOTENCY|VERSION/.test(candidate.code ?? ""))
+    return 4;
   if (candidate.status === 401 || candidate.status === 403 || candidate.status === 422 || /AUTH|PERMISSION|VALIDATION|UNSUPPORTED|QUOTA|POLICY/.test(candidate.code ?? "")) {
     return 3;
   }
@@ -15576,40 +15823,15 @@ function redact(value) {
     return Object.fromEntries(
       Object.entries(value).map(([key, item]) => [
         key,
-        /(?:api.?key|authorization|secret|token|password)/i.test(key) ? "[REDACTED]" : redact(item)
+        /(?:agent.?key|api.?key|authorization|secret|token|password)/i.test(key) ? "[REDACTED]" : redact(item)
       ])
     );
   }
   return value;
 }
 
-// src/commands/business.ts
-function registerBusinessCommands(root, getClient) {
-  const business = root.command("business").description("Consulta el negocio vinculado a la clave agente");
-  business.command("show").description("Muestra las capacidades seguras del negocio").action(async () => {
-    emitSuccess(await getClient().business.get());
-  });
-}
-
-// src/commands/catalog.ts
-import { basename } from "path";
-import { readFile, stat } from "fs/promises";
-function requireId(value, name) {
-  if (!value.trim()) throw new CliProtocolError("CLI_VALIDATION_ERROR", `${name} es obligatorio`);
-  return value;
-}
-async function readMutationInput(path) {
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile(path, "utf8"));
-  } catch {
-    throw new CliProtocolError("CLI_INPUT_ERROR", "No se pudo leer un objeto JSON desde --from");
-  }
-  if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
-    throw new CliProtocolError("CLI_VALIDATION_ERROR", "--from debe contener un objeto JSON");
-  }
-  return normalizeInput(parsed);
-}
+// src/commands/mutation.ts
+import { readFile } from "fs/promises";
 function normalizeInput(value) {
   const forbidden = {
     businessId: true,
@@ -15632,12 +15854,17 @@ function normalizeInput(value) {
   };
   return visit(value);
 }
-function withMutationOptions(command, includeFrom = true) {
-  if (includeFrom) command.requiredOption("--from <json-file>", "Objeto JSON estructurado");
-  return command.option("--apply", "Ejecuta la mutaci\xF3n despu\xE9s de validarla localmente");
-}
-function wantsApply(command) {
-  return Boolean(command.optsWithGlobals().apply);
+async function readMutationInput(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    throw new CliProtocolError("CLI_INPUT_ERROR", "No se pudo leer un objeto JSON desde --from");
+  }
+  if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+    throw new CliProtocolError("CLI_VALIDATION_ERROR", "--from debe contener un objeto JSON");
+  }
+  return normalizeInput(parsed);
 }
 function localResult(input, current) {
   if (current === void 0) return { validated: "local", input };
@@ -15647,12 +15874,60 @@ function localResult(input, current) {
   );
   return { validated: "local", current, changes };
 }
+
+// src/commands/business.ts
+function profileValues(profile) {
+  const values = profile.values;
+  if (!values || Array.isArray(values) || typeof values !== "object") return {};
+  return values;
+}
+function registerBusinessCommands(root, getClient) {
+  const business = root.command("business").description("Consulta el negocio vinculado a la clave agente");
+  business.command("show").description("Muestra las capacidades seguras del negocio").action(async () => {
+    emitSuccess(await getClient().business.get());
+  });
+  const profile = business.command("profile").description("Consulta o propone cambios al perfil del negocio");
+  profile.command("show").description("Muestra campos, valores y completitud del perfil").action(async () => {
+    emitSuccess(await getClient().business.profile());
+  });
+  profile.command("update").description("Previsualiza o propone cambios al perfil").requiredOption("--from <json-file>", "Valores de perfil en un objeto JSON").option("--apply", "Crea una propuesta para aprobaci\xF3n en Avileo").action(async (options, command) => {
+    const values = await readMutationInput(options.from);
+    if (!command.optsWithGlobals().apply) {
+      const current = await getClient().business.profile();
+      emitSuccess(localResult(values, profileValues(current)));
+      return;
+    }
+    emitSuccess(
+      await getClient().operations.propose({
+        operationName: "business.profile.update",
+        payload: { values }
+      })
+    );
+  });
+}
+
+// src/commands/catalog.ts
+import { createHash } from "crypto";
+import { readFile as readFile2, stat } from "fs/promises";
+import { basename, extname } from "path";
+function requireId(value, name) {
+  if (!value.trim()) throw new CliProtocolError("CLI_VALIDATION_ERROR", `${name} es obligatorio`);
+  return value;
+}
+function withMutationOptions(command, includeFrom = true) {
+  if (includeFrom) command.requiredOption("--from <json-file>", "Objeto JSON estructurado");
+  return command.option("--apply", "Solicita aprobaci\xF3n o ejecuta una mutaci\xF3n aprobada").option("--approval-id <uuid>", "Aprobaci\xF3n emitida por Avileo");
+}
+function wantsApply(command) {
+  return Boolean(command.optsWithGlobals().apply);
+}
 function addListOptions(command) {
   return command.option("--search <text>").option("--category-id <id>").option("--active <true|false>", "Filtra por estado activo", parseBoolean).option("--limit <number>", "M\xE1ximo de resultados", parseInteger).option("--offset <number>", "Desplazamiento", parseInteger);
 }
 function parseInteger(value) {
   const result = Number(value);
-  if (!Number.isInteger(result) || result < 0) throw new CliProtocolError("CLI_VALIDATION_ERROR", "Se esperaba un entero no negativo");
+  if (!Number.isInteger(result) || result < 0)
+    throw new CliProtocolError("CLI_VALIDATION_ERROR", "Se esperaba un entero no negativo");
   return result;
 }
 function parseBoolean(value) {
@@ -15660,12 +15935,17 @@ function parseBoolean(value) {
   if (value === "false") return false;
   throw new CliProtocolError("CLI_VALIDATION_ERROR", "Se esperaba true o false");
 }
-async function applyOrPreview(command, input, run, current) {
-  if (wantsApply(command)) {
-    emitSuccess(await run());
+async function applyOrPreview(command, input, getClient, operationName, payload, run, current) {
+  if (!wantsApply(command)) {
+    emitSuccess(localResult(input, current ? await current() : void 0));
     return;
   }
-  emitSuccess(localResult(input, current ? await current() : void 0));
+  const rawApprovalId = command.optsWithGlobals().approvalId;
+  if (typeof rawApprovalId === "string") {
+    emitSuccess(await run(requireId(rawApprovalId, "approvalId")));
+    return;
+  }
+  emitSuccess(await getClient().operations.propose({ operationName, payload }));
 }
 function registerCatalogCommands(root, getClient) {
   const catalog = root.command("catalog").description("Gestiona recursos de cat\xE1logo de Avileo");
@@ -15680,165 +15960,363 @@ function registerCatalogCommands(root, getClient) {
 function registerProductCommands(catalog, getClient) {
   const product = catalog.command("product");
   addListOptions(product.command("list")).action(async (options) => {
-    const { active: isActive, categoryId, ...filters } = options;
-    emitSuccess(await getClient().products.list({ ...filters, ...categoryId ? { categoryId } : {}, ...isActive === void 0 ? {} : { isActive } }));
+    const {
+      active: isActive,
+      categoryId,
+      ...filters
+    } = options;
+    emitSuccess(
+      await getClient().products.list({
+        ...filters,
+        ...categoryId ? { categoryId } : {},
+        ...isActive === void 0 ? {} : { isActive }
+      })
+    );
   });
-  product.command("get <productId>").action(async (productId) => emitSuccess(await getClient().products.get(requireId(productId, "productId"))));
-  withMutationOptions(product.command("create")).action(async (options, command) => {
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().products.create(input));
+  product.command("get <productId>").action(async (productId) => {
+    emitSuccess(await getClient().products.get(requireId(productId, "productId")));
   });
-  withMutationOptions(product.command("update <productId>")).action(async (productId, options, command) => {
-    const id = requireId(productId, "productId");
+  withMutationOptions(product.command("create")).action(async (options, command) => {
     const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().products.update(id, input), () => getClient().products.get(id));
-  });
-  withMutationOptions(product.command("deactivate <productId>"), false).action(async (productId, _options, command) => {
-    const id = requireId(productId, "productId");
-    const input = { isActive: false };
-    await applyOrPreview(command, input, () => getClient().products.deactivate(id), () => getClient().products.get(id));
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.products.create",
+      { body: input },
+      (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("deactivate <productId>"), false).action(
+    async (productId, _options, command) => {
+      const id = requireId(productId, "productId");
+      await applyOrPreview(
+        command,
+        { isActive: false },
+        getClient,
+        "catalog.products.deactivate",
+        { productId: id },
+        (approvalId) => getClient().products.deactivate(id, approvalId),
+        () => getClient().products.get(id)
+      );
+    }
+  );
 }
 function registerVariantCommands(catalog, getClient) {
   const variant = catalog.command("variant");
-  variant.command("list <productId>").action(async (productId) => emitSuccess(await getClient().variants.list(requireId(productId, "productId"))));
-  variant.command("get <variantId>").action(async (variantId) => emitSuccess(await getClient().variants.get(requireId(variantId, "variantId"))));
-  withMutationOptions(variant.command("create <productId>")).action(async (productId, options, command) => {
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().variants.create(requireId(productId, "productId"), input));
+  variant.command("list <productId>").action(async (productId) => {
+    emitSuccess(await getClient().variants.list(requireId(productId, "productId")));
   });
-  withMutationOptions(variant.command("update <variantId>")).action(async (variantId, options, command) => {
-    const id = requireId(variantId, "variantId");
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().variants.update(id, input), () => getClient().variants.get(id));
-  });
-  withMutationOptions(variant.command("deactivate <variantId>"), false).action(async (variantId, _options, command) => {
-    const id = requireId(variantId, "variantId");
-    const input = { isActive: false };
-    await applyOrPreview(command, input, () => getClient().variants.deactivate(id), () => getClient().variants.get(id));
-  });
-  withMutationOptions(variant.command("reorder <productId>")).action(async (productId, options, command) => {
-    const id = requireId(productId, "productId");
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().variants.reorder(id, input), () => getClient().variants.list(id));
+  variant.command("get <variantId>").action(async (variantId) => {
+    emitSuccess(await getClient().variants.get(requireId(variantId, "variantId")));
   });
+  withMutationOptions(variant.command("create <productId>")).action(
+    async (productId, options, command) => {
+      const id = requireId(productId, "productId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.variants.create",
+        { productId: id, body: input },
+        (approvalId) => getClient().variants.create(id, input, approvalId)
+      );
+    }
+  );
+  withMutationOptions(variant.command("update <variantId>")).action(
+    async (variantId, options, command) => {
+      const id = requireId(variantId, "variantId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.variants.update",
+        { variantId: id, body: input },
+        (approvalId) => getClient().variants.update(id, input, approvalId),
+        () => getClient().variants.get(id)
+      );
+    }
+  );
+  withMutationOptions(variant.command("deactivate <variantId>"), false).action(
+    async (variantId, _options, command) => {
+      const id = requireId(variantId, "variantId");
+      await applyOrPreview(
+        command,
+        { isActive: false },
+        getClient,
+        "catalog.variants.deactivate",
+        { variantId: id },
+        (approvalId) => getClient().variants.deactivate(id, approvalId),
+        () => getClient().variants.get(id)
+      );
+    }
+  );
+  withMutationOptions(variant.command("reorder <productId>")).action(
+    async (productId, options, command) => {
+      const id = requireId(productId, "productId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.variants.reorder",
+        { productId: id, body: input },
+        (approvalId) => getClient().variants.reorder(id, input, approvalId),
+        () => getClient().variants.list(id)
+      );
+    }
+  );
 }
 function registerCategoryCommands(catalog, getClient) {
   const category = catalog.command("category");
   category.command("list").action(async () => emitSuccess(await getClient().categories.list()));
-  category.command("get <categoryId>").action(async (categoryId) => emitSuccess(await getClient().categories.get(requireId(categoryId, "categoryId"))));
-  withMutationOptions(category.command("create")).action(async (options, command) => {
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().categories.create(input));
+  category.command("get <categoryId>").action(async (categoryId) => {
+    emitSuccess(await getClient().categories.get(requireId(categoryId, "categoryId")));
   });
-  withMutationOptions(category.command("update <categoryId>")).action(async (categoryId, options, command) => {
-    const id = requireId(categoryId, "categoryId");
+  withMutationOptions(category.command("create")).action(async (options, command) => {
     const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().categories.update(id, input), () => getClient().categories.get(id));
-  });
-  withMutationOptions(category.command("delete <categoryId>"), false).action(async (categoryId, _options, command) => {
-    const id = requireId(categoryId, "categoryId");
-    await applyOrPreview(command, { delete: true }, () => getClient().categories.delete(id), () => getClient().categories.get(id));
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.categories.create",
+      { body: input },
+      (approvalId) => getClient().categories.create(input, approvalId)
+    );
   });
+  withMutationOptions(category.command("update <categoryId>")).action(
+    async (categoryId, options, command) => {
+      const id = requireId(categoryId, "categoryId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.categories.update",
+        { categoryId: id, body: input },
+        (approvalId) => getClient().categories.update(id, input, approvalId),
+        () => getClient().categories.get(id)
+      );
+    }
+  );
+  withMutationOptions(category.command("delete <categoryId>"), false).action(
+    async (categoryId, _options, command) => {
+      const id = requireId(categoryId, "categoryId");
+      await applyOrPreview(
+        command,
+        { delete: true },
+        getClient,
+        "catalog.categories.delete",
+        { categoryId: id },
+        (approvalId) => getClient().categories.delete(id, approvalId),
+        () => getClient().categories.get(id)
+      );
+    }
+  );
 }
 function registerTagCommands(catalog, getClient) {
   const tag = catalog.command("tag");
   tag.command("list").action(async () => emitSuccess(await getClient().tags.list()));
-  tag.command("get <tagId>").action(async (tagId) => emitSuccess(await getClient().tags.get(requireId(tagId, "tagId"))));
+  tag.command("get <tagId>").action(async (tagId) => {
+    emitSuccess(await getClient().tags.get(requireId(tagId, "tagId")));
+  });
   withMutationOptions(tag.command("create")).action(async (options, command) => {
     const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().tags.create(input));
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.tags.create",
+      { body: input },
+      (approvalId) => getClient().tags.create(input, approvalId)
+    );
   });
   withMutationOptions(tag.command("update <tagId>")).action(async (tagId, options, command) => {
     const id = requireId(tagId, "tagId");
     const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().tags.update(id, input), () => getClient().tags.get(id));
-  });
-  withMutationOptions(tag.command("delete <tagId>"), false).action(async (tagId, _options, command) => {
-    const id = requireId(tagId, "tagId");
-    await applyOrPreview(command, { delete: true }, () => getClient().tags.delete(id), () => getClient().tags.get(id));
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.tags.update",
+      { tagId: id, body: input },
+      (approvalId) => getClient().tags.update(id, input, approvalId),
+      () => getClient().tags.get(id)
+    );
   });
+  withMutationOptions(tag.command("delete <tagId>"), false).action(
+    async (tagId, _options, command) => {
+      const id = requireId(tagId, "tagId");
+      await applyOrPreview(
+        command,
+        { delete: true },
+        getClient,
+        "catalog.tags.delete",
+        { tagId: id },
+        (approvalId) => getClient().tags.delete(id, approvalId),
+        () => getClient().tags.get(id)
+      );
+    }
+  );
 }
 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("get <assetId>").action(async (assetId) => emitSuccess(await getClient().assets.get(requireId(assetId, "assetId"))));
-  asset.command("upload").requiredOption("--file <path>", "Archivo local").option("--apply", "Sube el archivo").action(async (options, command) => {
+  asset.command("get <assetId>").action(async (assetId) => {
+    emitSuccess(await getClient().assets.get(requireId(assetId, "assetId")));
+  });
+  withMutationOptions(
+    asset.command("upload").requiredOption("--file <path>", "Archivo local"),
+    false
+  ).action(async (options, command) => {
     const filePath = options.file;
     const fileStat = await stat(filePath);
-    if (!fileStat.isFile()) throw new CliProtocolError("CLI_VALIDATION_ERROR", "--file debe apuntar a un archivo");
+    if (!fileStat.isFile()) {
+      throw new CliProtocolError("CLI_VALIDATION_ERROR", "--file debe apuntar a un archivo");
+    }
     if (!wantsApply(command)) {
-      emitSuccess({ validated: "local", file: basename(filePath), sizeBytes: fileStat.size });
+      emitSuccess({
+        validated: "local",
+        file: basename(filePath),
+        sizeBytes: fileStat.size
+      });
+      return;
+    }
+    const extension = extname(filePath).toLowerCase();
+    const mimeType = extension === ".jpg" || extension === ".jpeg" ? "image/jpeg" : extension === ".png" ? "image/png" : extension === ".webp" ? "image/webp" : void 0;
+    if (!mimeType) {
+      throw new CliProtocolError(
+        "CLI_VALIDATION_ERROR",
+        "Solo se permiten im\xE1genes JPEG, PNG o WebP"
+      );
+    }
+    const contents = await readFile2(filePath);
+    const file2 = new File([contents], basename(filePath), { type: mimeType });
+    const rawApprovalId = command.optsWithGlobals().approvalId;
+    if (typeof rawApprovalId === "string") {
+      emitSuccess(await getClient().assets.upload(file2, requireId(rawApprovalId, "approvalId")));
       return;
     }
-    const file2 = new File([await readFile(filePath)], basename(filePath));
-    emitSuccess(await getClient().assets.upload(file2));
+    emitSuccess(
+      await getClient().operations.propose({
+        operationName: "catalog.assets.upload",
+        payload: {
+          filename: file2.name,
+          mimeType: file2.type,
+          sizeBytes: file2.size,
+          contentHash: createHash("sha256").update(contents).digest("hex")
+        }
+      })
+    );
   });
   withMutationOptions(asset.command("import-url")).action(async (options, command) => {
     const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().assets.importFromUrl(input));
+    await applyOrPreview(
+      command,
+      input,
+      getClient,
+      "catalog.assets.import",
+      input,
+      (approvalId) => getClient().assets.importFromUrl(input, approvalId)
+    );
   });
 }
 function registerInventoryCommands(catalog, getClient) {
   const inventory = catalog.command("inventory");
-  inventory.command("get <variantId>").action(async (variantId) => emitSuccess(await getClient().inventory.get(requireId(variantId, "variantId"))));
-  inventory.command("movements <variantId>").option("--reason <reason>").option("--limit <number>", "M\xE1ximo de resultados", parseInteger).option("--offset <number>", "Desplazamiento", parseInteger).action(async (variantId, options) => emitSuccess(await getClient().inventory.listMovements(requireId(variantId, "variantId"), options)));
-  withMutationOptions(inventory.command("adjust <variantId>")).action(async (variantId, options, command) => {
-    const id = requireId(variantId, "variantId");
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().inventory.adjust(id, input), () => getClient().inventory.get(id));
+  inventory.command("get <variantId>").action(async (variantId) => {
+    emitSuccess(await getClient().inventory.get(requireId(variantId, "variantId")));
   });
-  withMutationOptions(inventory.command("set <variantId>")).action(async (variantId, options, command) => {
-    const id = requireId(variantId, "variantId");
-    const input = await readMutationInput(options.from);
-    await applyOrPreview(command, input, () => getClient().inventory.set(id, input), () => getClient().inventory.get(id));
+  inventory.command("movements <variantId>").option("--reason <reason>").option("--limit <number>", "M\xE1ximo de resultados", parseInteger).option("--offset <number>", "Desplazamiento", parseInteger).action(async (variantId, options) => {
+    emitSuccess(
+      await getClient().inventory.listMovements(requireId(variantId, "variantId"), options)
+    );
   });
-}
-async function resolveLocalFileSources(value, client) {
-  if (Array.isArray(value)) return Promise.all(value.map((item) => resolveLocalFileSources(item, client)));
-  if (!value || typeof value !== "object") return value;
-  const source = value;
-  if (source.kind === "file") {
-    if (typeof source.path !== "string" || Object.keys(source).length !== 2) {
-      throw new CliProtocolError(
-        "CLI_VALIDATION_ERROR",
-        'Una imagen local debe tener exactamente kind: "file" y path'
+  withMutationOptions(inventory.command("adjust <variantId>")).action(
+    async (variantId, options, command) => {
+      const id = requireId(variantId, "variantId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.inventory.adjust",
+        { variantId: id, body: input },
+        (approvalId) => getClient().inventory.adjust(id, input, approvalId),
+        () => getClient().inventory.get(id)
       );
     }
-    const fileStat = await stat(source.path);
-    if (!fileStat.isFile()) {
-      throw new CliProtocolError("CLI_VALIDATION_ERROR", "La ruta de imagen local debe apuntar a un archivo");
+  );
+  withMutationOptions(inventory.command("set <variantId>")).action(
+    async (variantId, options, command) => {
+      const id = requireId(variantId, "variantId");
+      const input = await readMutationInput(options.from);
+      await applyOrPreview(
+        command,
+        input,
+        getClient,
+        "catalog.inventory.set",
+        { variantId: id, body: input },
+        (approvalId) => getClient().inventory.set(id, input, approvalId),
+        () => getClient().inventory.get(id)
+      );
     }
-    const asset = await client.assets.upload(
-      new File([await readFile(source.path)], basename(source.path))
+  );
+}
+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"
     );
-    return { kind: "asset", assetId: asset.id };
   }
-  return Object.fromEntries(
-    await Promise.all(
-      Object.entries(source).map(async ([key, nested]) => [
-        key,
-        await resolveLocalFileSources(nested, client)
-      ])
-    )
-  );
+  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);
-    const normalizedInput = await resolveLocalFileSources(input, getClient());
-    emitSuccess(await getClient().imports.preview(normalizedInput));
+    rejectLocalFileSources(input);
+    emitSuccess(await getClient().imports.preview(input));
   });
-  imports.command("apply <importId>").option("--apply", "Encola la importaci\xF3n aprobada").action(async (importId, _options, command) => {
-    const id = requireId(importId, "importId");
-    if (!wantsApply(command)) {
-      emitSuccess({ validated: "local", importId: id, action: "apply" });
-      return;
+  withMutationOptions(imports.command("apply <importId>"), false).action(
+    async (importId, _options, command) => {
+      const id = requireId(importId, "importId");
+      await applyOrPreview(
+        command,
+        { importId: id, action: "apply" },
+        getClient,
+        "catalog.imports.apply",
+        { importId: id },
+        (approvalId) => getClient().imports.apply(id, approvalId)
+      );
     }
-    emitSuccess(await getClient().imports.apply(id));
+  );
+  imports.command("status <importId>").action(async (importId) => {
+    emitSuccess(await getClient().imports.get(requireId(importId, "importId")));
   });
-  imports.command("status <importId>").action(async (importId) => emitSuccess(await getClient().imports.get(requireId(importId, "importId"))));
 }
 
 // src/commands/auth.ts
@@ -15870,6 +16348,57 @@ function safeFinalResult(start, browserOpened, result) {
 function sleep(milliseconds) {
   return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
+function readAgentKeyFromTty(prompt = "Agent Key de Avileo: ") {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    throw new CliProtocolError(
+      "CLI_CONFIGURATION_ERROR",
+      "auth configure requiere una terminal interactiva; usa AVILEO_AGENT_API_KEY en CI/CD"
+    );
+  }
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const input = process.stdin;
+    const output = process.stderr;
+    const wasRaw = input.isRaw;
+    const cleanup = () => {
+      input.removeListener("data", onData);
+      input.pause();
+      if (wasRaw !== void 0) input.setRawMode(Boolean(wasRaw));
+    };
+    const finish = (result) => {
+      cleanup();
+      output.write("\n");
+      if (result instanceof Error) reject(result);
+      else resolve(result);
+    };
+    const onData = (chunk) => {
+      for (const character of String(chunk)) {
+        if (character === "") {
+          finish(
+            new CliProtocolError(
+              "CLI_CONFIGURATION_ERROR",
+              "Configuraci\xF3n cancelada por el usuario"
+            )
+          );
+          return;
+        }
+        if (character === "\r" || character === "\n") {
+          finish(value);
+          return;
+        }
+        if (character === "\x7F" || character === "\b") {
+          value = value.slice(0, -1);
+          continue;
+        }
+        value += character;
+      }
+    };
+    output.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    input.on("data", onData);
+  });
+}
 async function openWithExecutable(command, args) {
   return new Promise((resolve) => {
     const child = spawn(command, args, { stdio: "ignore", shell: false, detached: true });
@@ -15937,6 +16466,21 @@ async function login(options) {
   }
   throw new CliProtocolError("CLI_AUTH_TIMEOUT", "La autorizaci\xF3n expir\xF3 antes de ser aprobada");
 }
+async function configure(options) {
+  const apiKey = await options.readSecret("Agent Key de Avileo (no se mostrar\xE1): ");
+  saveLocalCredential(
+    {
+      apiKey,
+      ...options.env.AVILEO_AGENT_BASE_URL?.trim() ? { baseUrl: options.env.AVILEO_AGENT_BASE_URL.trim() } : {}
+    },
+    options.env
+  );
+  emitSuccess({
+    configured: true,
+    source: "local",
+    credentialPath: localCredentialPath(options.env)
+  });
+}
 async function status(options) {
   const credential = resolveCredential(options.env);
   if (!credential) {
@@ -15948,7 +16492,7 @@ async function status(options) {
   try {
     business = await options.getClient().business.get();
   } catch (error51) {
-    const code = error51.code;
+    const code = error51 && typeof error51 === "object" && "code" in error51 ? error51.code : void 0;
     businessLookupError = typeof code === "string" ? code : "LOOKUP_FAILED";
   }
   emitSuccess({
@@ -15970,6 +16514,7 @@ async function logout(options) {
 }
 function registerAuthCommands(root, options) {
   const auth = root.command("auth").description("Conecta la CLI con Avileo sin copiar claves en el chat");
+  auth.command("configure").description("Guarda una Agent Key existente sin mostrarla en pantalla").action(() => configure(options));
   auth.command("login").description("Autoriza esta CLI mediante un link temporal").action(() => login(options));
   auth.command("status").description("Muestra el estado de la credencial sin revelar secretos").action(() => status(options));
   auth.command("logout").description("Elimina solamente la credencial local").action(() => logout(options));
@@ -15996,11 +16541,32 @@ function createProgram(options = {}) {
     env: options.env ?? process.env,
     deviceAuthFactory: options.deviceAuthFactory ?? createAvileoAgentDeviceAuth,
     openBrowser: options.openBrowser ?? openVerificationUri,
+    readSecret: options.readSecret ?? readAgentKeyFromTty,
     getClient,
     json: () => Boolean(program.opts().json)
   });
   registerBusinessCommands(program, getClient);
   registerCatalogCommands(program, getClient);
+  const operation = program.command("operation").description("Consulta y aplica operaciones aprobadas en Avileo");
+  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");
+    }
+    emitSuccess(await getClient().operations.get(id));
+  });
+  operation.command("apply <id>").description("Aplica una operaci\xF3n aprobada").action(async (id) => {
+    if (!id.trim()) {
+      throw new CliProtocolError("CLI_VALIDATION_ERROR", "id es obligatorio");
+    }
+    emitSuccess(await getClient().operations.apply(id));
+  });
+  program.command("catalog-key").description("Gestiona la Client Key p\xFAblica del cat\xE1logo").command("create").requiredOption("--name <name>", "Nombre visible de la Client Key").description("Propone crear una Client Key para aprobaci\xF3n en Avileo").action(async (options2) => {
+    const name = options2.name.trim();
+    if (!name) {
+      throw new CliProtocolError("CLI_VALIDATION_ERROR", "name es obligatorio");
+    }
+    emitSuccess(await getClient().operations.proposeClientKey(name));
+  });
   const parseAsync3 = program.parseAsync.bind(program);
   program.parseAsync = (async (...args) => {
     try {