@tarileo/avileo-catalog-cli 0.3.0 → 0.3.2

package/dist/index.js

@@ -14729,18 +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_KEY_MODES = ["read", "mutate"];
 var AgentKeyModeSchema = external_exports.enum(AGENT_KEY_MODES);
-var AGENT_CATALOG_KEY_PRESET_ACTIONS = [
+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"
@@ -15221,9 +15222,91 @@ 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
+  ...AGENT_KEY_READ_ACTIONS
 ];
 function parsePollResponse(value) {
   if (!AGENT_DEVICE_AUTH_STATUSES.includes(value.status)) {
@@ -15540,6 +15623,32 @@ var AgentOperationsResource = class {
     });
   }
 };
+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 {
@@ -15551,7 +15660,8 @@ function createAvileoAgent(config2) {
     tags: new AgentTagsResource(http),
     assets: new AgentAssetsResource(http),
     inventory: new AgentInventoryResource(http),
-    imports: new AgentImportsResource(http)
+    imports: new AgentImportsResource(http),
+    paymentLinks: new AgentPaymentLinksResource(http)
   };
 }
 
@@ -15560,6 +15670,53 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSy
 import { randomUUID } from "crypto";
 import { homedir } from "os";
 import { dirname, join } from "path";
+import { isIP } from "net";
+var LOCAL_IPV4_HOST_PATTERN = /^(?:127\.|10\.|192\.168\.|169\.254\.|172\.(?:1[6-9]|2\d|3[01])\.|100\.(?:6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.)/;
+function isLocalHostname(hostname3) {
+  const host = hostname3.replace(/^\[|\]$/g, "").toLowerCase();
+  if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local")) return true;
+  if (host === "::1" || host === "::" || /^f[cd][0-9a-f]{2}:/.test(host)) return true;
+  if (host.includes(":")) return false;
+  if (!host.includes(".")) return true;
+  return isIP(host) === 4 && LOCAL_IPV4_HOST_PATTERN.test(host);
+}
+function normalizeApiBaseUrl(rawUrl) {
+  const candidate = rawUrl.trim().replace(/\/+$/, "");
+  if (!candidate) {
+    throw new CliOriginUnsupportedError("La URL base de la API est\xE1 vac\xEDa");
+  }
+  let parsed;
+  try {
+    parsed = new URL(candidate);
+  } catch {
+    throw new CliOriginUnsupportedError(`La URL base de la API no es v\xE1lida: ${candidate}`);
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    throw new CliOriginUnsupportedError(
+      `La URL base debe usar HTTPS (o HTTP local de desarrollo); se recibi\xF3 ${parsed.protocol}//`
+    );
+  }
+  if (parsed.protocol === "http:" && !isLocalHostname(parsed.hostname)) {
+    throw new CliOriginUnsupportedError(
+      "Solo se permite HTTP para hosts locales de desarrollo; usa un origen HTTPS"
+    );
+  }
+  if (parsed.username || parsed.password) {
+    throw new CliOriginUnsupportedError("La URL base no debe incluir credenciales embebidas");
+  }
+  if (parsed.search || parsed.hash) {
+    throw new CliOriginUnsupportedError("La URL base no debe incluir query ni fragmento");
+  }
+  return `${parsed.protocol}//${parsed.host}${parsed.pathname.replace(/\/+$/, "")}`;
+}
+function apiOrigin(baseUrl) {
+  const parsed = new URL(baseUrl);
+  return `${parsed.protocol}//${parsed.host}`;
+}
+function overrideBaseUrl(env) {
+  const raw = env.AVILEO_AGENT_BASE_URL?.trim();
+  return raw ? normalizeApiBaseUrl(raw) : void 0;
+}
 var AGENT_KEY_PATTERN = /^avileo_sk_[^\s]+$/;
 function normalizeAgentKey(value, message) {
   const key = value.trim();
@@ -15590,10 +15747,15 @@ function readLocalCredential(env = process.env) {
     throw new CliConfigurationError("La credencial local no es una Agent Key v\xE1lida");
   }
   const apiKey = normalizeAgentKey(record2.apiKey, "La credencial local no es una Agent Key v\xE1lida");
-  const baseUrl = typeof record2.baseUrl === "string" && record2.baseUrl.trim() ? record2.baseUrl.trim() : void 0;
-  return { apiKey, ...baseUrl ? { baseUrl } : {} };
+  if (typeof record2.baseUrl !== "string" || !record2.baseUrl.trim()) {
+    throw new CliConfigurationError(
+      "La credencial local no tiene un origen vinculado. Vuelve a autorizar con auth login --base-url <URL_DEL_PORTAL> antes de usarla."
+    );
+  }
+  return { apiKey, baseUrl: normalizeApiBaseUrl(record2.baseUrl) };
 }
 function resolveCredential(env = process.env) {
+  const override = overrideBaseUrl(env);
   const environmentValue = env.AVILEO_AGENT_API_KEY;
   if (environmentValue !== void 0) {
     return {
@@ -15602,31 +15764,29 @@ function resolveCredential(env = process.env) {
         "AVILEO_AGENT_API_KEY no es una Agent Key v\xE1lida"
       ),
       source: "environment",
-      ...env.AVILEO_AGENT_BASE_URL?.trim() ? { baseUrl: env.AVILEO_AGENT_BASE_URL.trim() } : {}
+      baseUrl: override ?? AVILEO_AGENT_API_URL
     };
   }
   const local = readLocalCredential(env);
   if (!local) return null;
-  return {
-    ...local,
-    source: "local",
-    ...env.AVILEO_AGENT_BASE_URL?.trim() ? { baseUrl: env.AVILEO_AGENT_BASE_URL.trim() } : {}
-  };
+  if (override && apiOrigin(local.baseUrl) !== apiOrigin(override)) {
+    throw new CliOriginConflictError(
+      `La credencial local est\xE1 vinculada al origen ${apiOrigin(local.baseUrl)}, pero AVILEO_AGENT_BASE_URL apunta a ${apiOrigin(override)}. La clave nunca se env\xEDa a otro origen: quita la variable de entorno o vuelve a autenticar con auth login --base-url ${apiOrigin(override)} para emitir una clave en ese origen.`
+    );
+  }
+  return { ...local, source: "local" };
 }
 function saveLocalCredential(credential, env = process.env) {
   const apiKey = normalizeAgentKey(
     credential.apiKey,
     "Solo se pueden guardar Agent Keys de Avileo"
   );
+  const baseUrl = normalizeApiBaseUrl(credential.baseUrl);
   const path = localCredentialPath(env);
   mkdirSync(dirname(path), { recursive: true, mode: 448 });
   const temporaryPath = `${path}.${randomUUID()}.tmp`;
-  writeFileSync(
-    temporaryPath,
-    `${JSON.stringify({ apiKey, ...credential.baseUrl ? { baseUrl: credential.baseUrl } : {} })}
-`,
-    { mode: 384 }
-  );
+  writeFileSync(temporaryPath, `${JSON.stringify({ apiKey, baseUrl })}
+`, { mode: 384 });
   chmodSync(temporaryPath, 384);
   renameSync(temporaryPath, path);
   chmodSync(path, 384);
@@ -15650,7 +15810,7 @@ function createClientFromEnvironment({
   }
   return clientFactory({
     apiKey: credential.apiKey,
-    ...credential.baseUrl ? { baseUrl: credential.baseUrl } : {}
+    baseUrl: credential.baseUrl
   });
 }
 var CliConfigurationError = class extends Error {
@@ -15660,6 +15820,20 @@ var CliConfigurationError = class extends Error {
     this.name = "CliConfigurationError";
   }
 };
+var CliOriginUnsupportedError = class extends CliConfigurationError {
+  code = "CLI_ORIGIN_UNSUPPORTED";
+  constructor(message) {
+    super(message);
+    this.name = "CliOriginUnsupportedError";
+  }
+};
+var CliOriginConflictError = class extends CliConfigurationError {
+  code = "CLI_ORIGIN_CONFLICT";
+  constructor(message) {
+    super(message);
+    this.name = "CliOriginConflictError";
+  }
+};
 
 // src/output.ts
 var CliProtocolError = class extends Error {
@@ -15720,34 +15894,8 @@ function redact(value) {
   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 { createHash } from "crypto";
-import { readFile, 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;
-}
-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,
@@ -15770,12 +15918,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", "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);
+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 };
@@ -15785,6 +15938,53 @@ 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);
 }
@@ -16071,7 +16271,7 @@ function registerAssetCommands(catalog, getClient) {
         "Solo se permiten im\xE1genes JPEG, PNG o WebP"
       );
     }
-    const contents = await readFile(filePath);
+    const contents = await readFile2(filePath);
     const file2 = new File([contents], basename(filePath), { type: mimeType });
     const rawApprovalId = command.optsWithGlobals().approvalId;
     if (typeof rawApprovalId === "string") {
@@ -16212,6 +16412,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 });
@@ -16239,9 +16490,15 @@ async function openVerificationUri(uri) {
   }
   return false;
 }
+function resolveSelectedBaseUrl(options) {
+  const explicit = options.baseUrl?.trim();
+  if (explicit) return normalizeApiBaseUrl(explicit);
+  const fromEnvironment = options.env.AVILEO_AGENT_BASE_URL?.trim();
+  return fromEnvironment ? normalizeApiBaseUrl(fromEnvironment) : AVILEO_AGENT_API_URL;
+}
 async function login(options) {
-  const baseUrl = options.env.AVILEO_AGENT_BASE_URL?.trim();
-  const deviceAuth = options.deviceAuthFactory(baseUrl ? { baseUrl } : {});
+  const baseUrl = resolveSelectedBaseUrl(options);
+  const deviceAuth = options.deviceAuthFactory({ baseUrl });
   const start = await deviceAuth.start({ name: "Avileo CLI" });
   const browserOpened = await options.openBrowser(start.verificationUri);
   process.stderr.write(
@@ -16258,7 +16515,7 @@ async function login(options) {
       continue;
     }
     if (result.status === "denied" || result.status === "expired") {
-      emitSuccess(safeFinalResult(start, browserOpened, result));
+      emitSuccess({ ...safeFinalResult(start, browserOpened, result), baseUrl });
       return;
     }
     if (!result.agentKey || !result.keyId || !result.businessId) {
@@ -16267,18 +16524,23 @@ async function login(options) {
         "La autorizaci\xF3n aprobada no devolvi\xF3 una credencial v\xE1lida"
       );
     }
-    saveLocalCredential(
-      {
-        apiKey: result.agentKey,
-        ...baseUrl ? { baseUrl } : {}
-      },
-      options.env
-    );
-    emitSuccess(safeFinalResult(start, browserOpened, result));
+    saveLocalCredential({ apiKey: result.agentKey, baseUrl }, options.env);
+    emitSuccess({ ...safeFinalResult(start, browserOpened, result), baseUrl });
     return;
   }
   throw new CliProtocolError("CLI_AUTH_TIMEOUT", "La autorizaci\xF3n expir\xF3 antes de ser aprobada");
 }
+async function configure(options) {
+  const baseUrl = resolveSelectedBaseUrl(options);
+  const apiKey = await options.readSecret("Agent Key de Avileo (no se mostrar\xE1): ");
+  saveLocalCredential({ apiKey, baseUrl }, options.env);
+  emitSuccess({
+    configured: true,
+    source: "local",
+    baseUrl,
+    credentialPath: localCredentialPath(options.env)
+  });
+}
 async function status(options) {
   const credential = resolveCredential(options.env);
   if (!credential) {
@@ -16290,13 +16552,13 @@ 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({
     configured: true,
     source: credential.source,
-    credentialPath: credential.source === "local" ? localCredentialPath(options.env) : void 0,
+    baseUrl: credential.baseUrl ?? AVILEO_AGENT_API_URL,
     business,
     ...businessLookupError ? { businessLookupError } : {}
   });
@@ -16312,7 +16574,15 @@ 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("login").description("Autoriza esta CLI mediante un link temporal").action(() => login(options));
+  auth.command("configure").description("Guarda una Agent Key existente sin mostrarla en pantalla").option("--base-url <url>", "Origen de la API donde se usar\xE1 la clave").action(
+    (commandOptions) => configure({ ...options, baseUrl: commandOptions.baseUrl })
+  );
+  auth.command("login").description("Autoriza esta CLI mediante un link temporal").option(
+    "--base-url <url>",
+    "Origen de la API a vincular; tiene prioridad sobre AVILEO_AGENT_BASE_URL"
+  ).action(
+    (commandOptions) => login({ ...options, baseUrl: commandOptions.baseUrl })
+  );
   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));
 }
@@ -16338,6 +16608,7 @@ 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)
   });