@tarileo/avileo-catalog-cli 0.3.1 → 0.3.2

package/README.md

@@ -2,24 +2,43 @@
 
 The Avileo tenant-agent command line interface for a registered business with effective catalog-agent access.
 
-For a first-time human connection, use the temporary device authorization link:
+The origin-pinning contract below describes this checkout. A package version in
+`package.json` does not prove npm availability: `0.3.2` has not been published
+by this release closure. Public handoff must wait for the operator's verified
+package version/artifact and an activated destination. Never substitute an older
+CLI that lacks these flags or silently pair with the integrated deployment.
+
+For an authorized local-source session, build the workspace SDK first and run
+the CLI from the repository root:
 
 ```sh
-npx --yes @tarileo/avileo-catalog-cli@0.3.1 auth login --json
+bun run --filter @tarileo/avileo-sdk build
+bun apps/avileo/agent-cli/src/index.ts auth login --base-url <origin> --json
 ```
 
-The CLI prints only the verification URI, user code and status, opens the link
-with a safe executable when available, polls until approval, and stores the new
-Agent Key locally with `0600` permissions. The key is never printed or placed
-in the URL. Use `auth status --json` to inspect the source (`environment` or
-`local`) without revealing the key, and `auth logout --json` to remove only the
-local credential; remote revocation remains an Avileo action.
+Hereafter `avileo` means that same verified CLI command prefix. Pass only the
+explicit API origin supplied by the operator; package source and API destination
+are independent decisions.
+
+The CLI prints only the verification URI, user code, status and pinned
+`baseUrl`, opens the link with a safe executable when available, polls until
+approval, and stores the new Agent Key locally with `0600` permissions. The key
+is never printed or placed in the URL. Use `auth status --json` to inspect the
+source (`environment` or `local`) and the pinned origin without revealing the
+key, and `auth logout --json` to remove only the local credential; remote
+revocation remains an Avileo action.
+
+Origins must use HTTPS, except plain HTTP for local development hosts
+(loopback, private or Tailscale addresses). Without `--base-url` or
+`AVILEO_AGENT_BASE_URL`, the CLI pairs with production
+(`https://avileo.theelena.me`) and pins it. If the pinned origin fails, fix the
+target; the CLI never falls back to another origin on its own.
 
 If Avileo has already issued an Agent Key, configure it without putting the
 secret in shell history, process arguments or JSON:
 
 ```sh
-avileo auth configure --json
+avileo auth configure --base-url <origin> --json
 ```
 
 The command reads the key without echoing it and stores it locally. For CI/CD
@@ -27,7 +46,19 @@ and automated agents, continue injecting `AVILEO_AGENT_API_KEY`.
 Environment credentials always take priority over the local credential file.
 Never pass an Agent Key through flags, prompts or JSON input.
 
-`AVILEO_AGENT_BASE_URL` remains the development/test endpoint override.
+`--base-url` wins over `AVILEO_AGENT_BASE_URL`, which remains the advanced
+development/test override: set it before `auth login` or `auth configure` so
+the origin is pinned with the credential. Commands reject
+`CLI_ORIGIN_CONFLICT` when the variable points to a different origin than the
+pinned credential — remove the override or re-authenticate with
+`auth login --base-url <origin>`; an existing key is never sent to another
+host. Invalid or unsafe origins fail with `CLI_ORIGIN_UNSUPPORTED`.
+
+Local credentials created before origin pinning must be authorized again with
+`auth login --base-url <origin>`. A stored key without a bound origin fails
+with `CLI_CONFIGURATION_ERROR` before any request; the CLI cannot infer its
+destination safely and does not migrate it to production or an environment
+override.
 
 Use `--from <json-file>` for structured mutation input. Direct mutations validate
 locally by default; pass `--apply` only after reviewing the result. The CLI is

package/dist/index.js

@@ -15670,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();
@@ -15700,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 {
@@ -15712,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);
@@ -15760,7 +15810,7 @@ function createClientFromEnvironment({
   }
   return clientFactory({
     apiKey: credential.apiKey,
-    ...credential.baseUrl ? { baseUrl: credential.baseUrl } : {}
+    baseUrl: credential.baseUrl
   });
 }
 var CliConfigurationError = class extends Error {
@@ -15770,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 {
@@ -16426,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(
@@ -16445,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) {
@@ -16454,30 +16524,20 @@ 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,
-      ...options.env.AVILEO_AGENT_BASE_URL?.trim() ? { baseUrl: options.env.AVILEO_AGENT_BASE_URL.trim() } : {}
-    },
-    options.env
-  );
+  saveLocalCredential({ apiKey, baseUrl }, options.env);
   emitSuccess({
     configured: true,
     source: "local",
+    baseUrl,
     credentialPath: localCredentialPath(options.env)
   });
 }
@@ -16498,7 +16558,7 @@ async function status(options) {
   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 } : {}
   });
@@ -16514,8 +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("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("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));
 }