@theelena/catalog-cli 0.0.0-stage → 0.1.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,971 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { setTimeout as sleep } from "timers/promises";
+import {
+  createElenaAgentClient as createElenaAgentClient2,
+  elenaAgentImportPreviewRequestSchema,
+  elenaAgentProposalRequestSchema
+} from "@theelena/sdk/agent";
+
+// src/arguments.ts
+import {
+  elenaAgentApplyRequestSchema,
+  elenaAgentIdSchema,
+  elenaAgentPageQuerySchema,
+  elenaAgentRefSchema
+} from "@theelena/sdk/agent";
+
+// src/security.ts
+import {
+  elenaAgentConnectionOriginSchema,
+  elenaAgentErrorCodeSchema
+} from "@theelena/sdk/agent";
+var messages = {
+  INVALID_REQUEST: "Comando, configuraci\xF3n o archivo inv\xE1lido. Consulte --help.",
+  CREDENTIAL_REQUIRED: "Inicie sesi\xF3n o configure el par de variables de entorno protegidas.",
+  CREDENTIAL_INVALID: "Credencial no v\xE1lida. Inicie una nueva conexi\xF3n.",
+  CREDENTIAL_EXPIRED: "La credencial venci\xF3. Inicie una nueva conexi\xF3n.",
+  CREDENTIAL_REVOKED: "La credencial fue revocada. Inicie una nueva conexi\xF3n.",
+  ORIGIN_REJECTED: "El origen no coincide con la configuraci\xF3n fijada de la conexi\xF3n.",
+  TEMPORARY_UNAVAILABLE: "No se pudo confirmar la respuesta. Consulte el estado antes de repetir una mutaci\xF3n.",
+  PAIRING_CONSUMED: "La entrega ya fue consumida. Inicie otra conexi\xF3n y solicite revocar la credencial hu\xE9rfana.",
+  PAIRING_EXPIRED: "La conexi\xF3n venci\xF3. Inicie otra conexi\xF3n.",
+  PAIRING_DENIED: "El due\xF1o rechaz\xF3 la conexi\xF3n.",
+  VERSION_CONFLICT: "La versi\xF3n cambi\xF3. Relea el recurso y cree una nueva propuesta.",
+  MEDIA_INVALID: "Archivo local inv\xE1lido. Use JPEG, PNG o WebP est\xE1tico de hasta 10 MiB."
+};
+function exitFor(code) {
+  if ([
+    "INVALID_REQUEST",
+    "UNSUPPORTED_VERSION",
+    "CREDENTIAL_MIXED",
+    "CREDENTIAL_WRONG_FAMILY",
+    "INVALID_PRICE",
+    "UNCONFIRMED_DATA",
+    "MEDIA_INVALID"
+  ].includes(code))
+    return 2;
+  if ([
+    "CREDENTIAL_REQUIRED",
+    "CREDENTIAL_INVALID",
+    "CREDENTIAL_EXPIRED",
+    "CREDENTIAL_REVOKED",
+    "OWNER_REQUIRED",
+    "ORIGIN_REJECTED",
+    "APPROVAL_REQUIRED",
+    "APPROVAL_REJECTED",
+    "SCOPE_REQUIRED",
+    "MODE_READ_ONLY",
+    "API_ACCESS_DISABLED",
+    "RESTAURANT_NOT_APPROVED",
+    "PAIRING_DENIED"
+  ].includes(code))
+    return 3;
+  if ([
+    "QUOTA_EXCEEDED",
+    "RATE_LIMITED",
+    "TEMPORARY_UNAVAILABLE",
+    "INTERNAL_ERROR",
+    "PAIRING_PENDING"
+  ].includes(code))
+    return 5;
+  return 4;
+}
+var CliError = class extends Error {
+  code;
+  retryAfterSeconds;
+  constructor(code, retryAfterSeconds) {
+    super(messages[code] ?? `No se pudo completar la operaci\xF3n (${code}).`);
+    this.name = "CliError";
+    this.code = code;
+    if (Number.isInteger(retryAfterSeconds) && retryAfterSeconds >= 1 && retryAfterSeconds <= 3600) {
+      this.retryAfterSeconds = retryAfterSeconds;
+    }
+  }
+  toWire() {
+    return {
+      version: "1",
+      error: {
+        code: this.code,
+        message: this.message,
+        retryable: this.code === "RATE_LIMITED" || this.code === "TEMPORARY_UNAVAILABLE",
+        requestId: "cli-local",
+        ...this.retryAfterSeconds ? { retryAfterSeconds: this.retryAfterSeconds } : {}
+      }
+    };
+  }
+};
+function safeError(error) {
+  if (error instanceof CliError) return error;
+  if (error && typeof error === "object" && "code" in error) {
+    if (error.code === "REDIRECT_REJECTED") return new CliError("ORIGIN_REJECTED");
+    const parsed = elenaAgentErrorCodeSchema.safeParse(error.code);
+    if (parsed.success) {
+      const retry = "retryAfterSeconds" in error ? error.retryAfterSeconds : void 0;
+      return new CliError(parsed.data, typeof retry === "number" ? retry : void 0);
+    }
+  }
+  return new CliError("TEMPORARY_UNAVAILABLE");
+}
+function parse(schema, value) {
+  const result = schema.safeParse(value);
+  if (!result.success) throw new CliError("INVALID_REQUEST");
+  return result.data;
+}
+function origin(value) {
+  const valid = parse(elenaAgentConnectionOriginSchema, value);
+  if (new URL(valid).protocol !== "https:" && process.env.NODE_ENV !== "development") {
+    throw new CliError("INVALID_REQUEST");
+  }
+  if (credentialPattern.test(valid)) throw new CliError("INVALID_REQUEST");
+  return new URL(valid).origin;
+}
+function pinUrl(value, expectedOrigin) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CliError("ORIGIN_REJECTED");
+  }
+  if (url.origin !== expectedOrigin || url.protocol !== "https:" && !(process.env.NODE_ENV === "development" && url.protocol === "http:") || url.username || url.password || // eslint-disable-next-line no-control-regex -- Intentionally reject U+0000-U+001F in untrusted URLs.
+  /[\\\s\u0000-\u001f]/.test(value)) {
+    throw new CliError("ORIGIN_REJECTED");
+  }
+  return value;
+}
+var credentialPattern = /(?:elena_(?:sk|pk)_|\bsk_)[A-Za-z0-9_-]+/;
+var SecretGuard = class {
+  #secrets = /* @__PURE__ */ new Set();
+  add(value) {
+    if (value) this.#secrets.add(value);
+  }
+  contains(value) {
+    let candidate = value;
+    for (let layer = 0; layer < 3; layer++) {
+      if (credentialPattern.test(candidate) || [...this.#secrets].some((secret) => candidate.includes(secret)))
+        return true;
+      try {
+        const decoded = decodeURIComponent(candidate);
+        if (decoded === candidate) break;
+        candidate = decoded;
+      } catch {
+        break;
+      }
+    }
+    return false;
+  }
+  assertSafe(value) {
+    const serialized = typeof value === "string" ? value : JSON.stringify(value);
+    if (serialized && this.contains(serialized)) throw new CliError("INVALID_REQUEST");
+  }
+};
+
+// src/arguments.ts
+var grammar = {
+  "auth login": { args: 0, required: ["--base-url"], optional: ["--no-open"] },
+  "auth status": { args: 0, required: [], optional: [] },
+  "auth logout": { args: 0, required: [], optional: [] },
+  context: { args: 0, required: [], optional: [] },
+  "catalog categories list": { args: 0, required: [], optional: ["--cursor", "--limit"] },
+  "catalog categories get": { args: 1, required: [], optional: [] },
+  "catalog products list": { args: 0, required: [], optional: ["--cursor", "--limit"] },
+  "catalog products get": { args: 1, required: [], optional: [] },
+  "assets get": { args: 1, required: [], optional: [] },
+  "media stage": { args: 1, required: ["--idempotency-key"], optional: [] },
+  "media status": { args: 1, required: [], optional: [] },
+  "import preview": { args: 0, required: ["--file"], optional: [] },
+  "import status": { args: 1, required: [], optional: [] },
+  "operations propose": { args: 0, required: ["--file"], optional: [] },
+  "operations list": { args: 0, required: [], optional: ["--cursor", "--limit"] },
+  "operations status": { args: 1, required: [], optional: [] },
+  "operations apply": { args: 1, required: ["--revision", "--payload-hash"], optional: [] }
+};
+function integer(value) {
+  if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+    throw new CliError("INVALID_REQUEST");
+  return Number(value);
+}
+function argumentsFor(argv, guard) {
+  guard.assertSafe(argv);
+  const json = argv.includes("--json");
+  if (argv.filter((arg) => arg === "--json").length > 1) throw new CliError("INVALID_REQUEST");
+  const tokens = argv.filter((arg) => arg !== "--json");
+  if (tokens.length === 0 || tokens.length === 1 && tokens[0] === "--help")
+    return { command: "help", args: [], flags: {}, json };
+  if (tokens.length === 1 && tokens[0] === "--version")
+    return { command: "version", args: [], flags: {}, json };
+  const command = Object.keys(grammar).find(
+    (name) => name.split(" ").every((part, index) => tokens[index] === part)
+  );
+  if (!command) throw new CliError("INVALID_REQUEST");
+  const definition = grammar[command];
+  const rest = tokens.slice(command.split(" ").length);
+  if (rest.length === 1 && rest[0] === "--help")
+    return { command: "help", args: [], flags: {}, json };
+  const args = [];
+  const flags = /* @__PURE__ */ Object.create(null);
+  for (let index = 0; index < rest.length; index++) {
+    const token = rest[index];
+    if (!token.startsWith("-")) {
+      args.push(token);
+      continue;
+    }
+    if (!definition.required.includes(token) && !definition.optional.includes(token) || token in flags)
+      throw new CliError("INVALID_REQUEST");
+    if (token === "--no-open") {
+      flags[token] = "true";
+      continue;
+    }
+    const value = rest[++index];
+    if (!value || value.startsWith("-")) throw new CliError("INVALID_REQUEST");
+    flags[token] = value;
+  }
+  if (args.length !== definition.args || definition.required.some((flag) => !(flag in flags)))
+    throw new CliError("INVALID_REQUEST");
+  if (command === "auth login") origin(flags["--base-url"]);
+  if (definition.args === 1 && command !== "media stage") parse(elenaAgentIdSchema, args[0]);
+  if (command.endsWith(" list")) pageQuery(flags);
+  if (command === "media stage") parse(elenaAgentRefSchema, flags["--idempotency-key"]);
+  if (command === "operations apply") applyRequest(flags);
+  return { command, args, flags, json };
+}
+function pageQuery(flags) {
+  return parse(elenaAgentPageQuerySchema, {
+    version: "1",
+    ...flags["--cursor"] !== void 0 ? { cursor: flags["--cursor"] } : {},
+    ...flags["--limit"] !== void 0 ? { limit: integer(flags["--limit"]) } : {}
+  });
+}
+function applyRequest(flags) {
+  return parse(elenaAgentApplyRequestSchema, {
+    version: "1",
+    expectedRevision: integer(flags["--revision"]),
+    payloadHash: flags["--payload-hash"]
+  });
+}
+var HELP = `elena-catalog 0.1.0 \u2014 cat\xE1logo de un restaurante, con aprobaci\xF3n humana
+
+Comandos (salida JSON estable; --json disponible globalmente):
+  auth login --base-url <https-origin> [--no-open]
+  auth status
+  auth logout
+  context
+  catalog categories list [--cursor <cursor>] [--limit <n>]
+  catalog categories get <id>
+  catalog products list [--cursor <cursor>] [--limit <n>]
+  catalog products get <id>
+  assets get <id>
+  media stage <local-file> --idempotency-key <ref>
+  media status <staging-id>
+  import preview --file <json-file>
+  import status <import-id>
+  operations propose --file <json-file>
+  operations list [--cursor <cursor>] [--limit <n>]
+  operations status <operation-id>
+  operations apply <operation-id> --revision <n> --payload-hash <sha256>
+
+Conexi\xF3n: configure ELENA_AGENT_STAFF_ORIGIN con el origen HTTPS del panel.
+El navegador no se abre autom\xE1ticamente; use la URL literal y el c\xF3digo mostrados.
+Alternativa protegida: ELENA_AGENT_KEY + ELENA_AGENT_BASE_URL en el entorno.
+No escriba secretos en argumentos ni archivos JSON. No hay origen de producci\xF3n por defecto.
+La conexi\xF3n fija los or\xEDgenes. Para otro origen, cierre primero la sesi\xF3n local.
+Logout no revoca la clave remota ni elimina variables del proceso padre.
+Proponer no aplica. Aprueba el due\xF1o en el panel; apply exige revisi\xF3n y hash exactos.
+Actualizar reemplaza la proyecci\xF3n editable completa: relea antes de preparar el archivo.
+Publicar es una propuesta separada; disponibilidad no significa publicaci\xF3n.
+Archivos preview/propose: solicitud V1 completa, strict, m\xE1ximo 1 MiB.
+Im\xE1genes: archivos locales JPEG/PNG/WebP; m\xE1ximo 10 MiB. No URLs remotas.
+Salidas: 0 \xE9xito; 2 uso/schema; 3 acceso/aprobaci\xF3n; 4 conflicto/terminal fallido; 5 transitorio/red.
+`;
+
+// src/auth.ts
+import {
+  elenaAgentErrorSchema,
+  elenaAgentPairingPollResponseSchema,
+  elenaAgentPairingStartResponseSchema
+} from "@theelena/sdk/agent";
+
+// src/store.ts
+import { constants } from "fs";
+import { lstat, mkdir, open, rename, unlink } from "fs/promises";
+import { join, parse as parsePath, resolve } from "path";
+import { randomUUID } from "crypto";
+import { homedir } from "os";
+import {
+  createElenaAgentClient,
+  elenaAgentIdSchema as elenaAgentIdSchema2,
+  elenaAgentSecretSchema,
+  elenaAgentTimestampSchema
+} from "@theelena/sdk/agent";
+var CredentialSession = class {
+  #secret;
+  source;
+  baseUrl;
+  staffOrigin;
+  credentialId;
+  restaurantId;
+  expiresAt;
+  constructor(data, source, guard) {
+    guard.add(data.secret);
+    const secret = elenaAgentSecretSchema.safeParse(data.secret);
+    if (!secret.success) throw new CliError("CREDENTIAL_WRONG_FAMILY");
+    this.#secret = secret.data;
+    this.source = source;
+    this.baseUrl = origin(data.baseUrl);
+    this.staffOrigin = data.staffOrigin ? origin(data.staffOrigin) : void 0;
+    this.credentialId = data.credentialId ?? null;
+    this.restaurantId = data.restaurantId ?? null;
+    this.expiresAt = data.expiresAt ?? null;
+  }
+  client(factory = createElenaAgentClient) {
+    return factory({
+      baseUrl: this.baseUrl,
+      agentKey: this.#secret,
+      ...this.staffOrigin ? { staffOrigin: this.staffOrigin } : {}
+    });
+  }
+};
+function missing(error) {
+  return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+}
+async function rejectSymlinks(path) {
+  const absolute = resolve(path);
+  const root = parsePath(absolute).root;
+  let cursor = root;
+  for (const component of absolute.slice(root.length).split("/").filter(Boolean)) {
+    cursor = join(cursor, component);
+    try {
+      if ((await lstat(cursor)).isSymbolicLink()) throw new CliError("INVALID_REQUEST");
+    } catch (error) {
+      if (missing(error)) return;
+      throw error;
+    }
+  }
+}
+function checkPermissions(info, directory) {
+  const mode = directory ? 448 : 384;
+  if ((info.mode & 4095) !== mode || process.getuid && info.uid !== process.getuid() || (directory ? !info.isDirectory() : !info.isFile() || info.nlink !== 1)) {
+    throw new CliError("INVALID_REQUEST");
+  }
+}
+function profile(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new CliError("INVALID_REQUEST");
+  const fields = Object.keys(value).sort().join(",");
+  if (fields !== "baseUrl,credentialId,expiresAt,restaurantId,secret,staffOrigin,version")
+    throw new CliError("INVALID_REQUEST");
+  const data = value;
+  if (data.version !== "1") throw new CliError("INVALID_REQUEST");
+  return {
+    version: "1",
+    baseUrl: origin(data.baseUrl),
+    staffOrigin: origin(data.staffOrigin),
+    secret: parse(elenaAgentSecretSchema, data.secret),
+    credentialId: parse(elenaAgentIdSchema2, data.credentialId),
+    restaurantId: parse(elenaAgentIdSchema2, data.restaurantId),
+    expiresAt: parse(elenaAgentTimestampSchema, data.expiresAt)
+  };
+}
+var CredentialStore = class {
+  directory;
+  constructor(directory = join(homedir(), ".config", "elena-catalog")) {
+    this.directory = resolve(directory);
+  }
+  async #directory(create) {
+    await rejectSymlinks(this.directory);
+    try {
+      checkPermissions(await lstat(this.directory), true);
+    } catch (error) {
+      if (!missing(error)) throw error;
+      if (!create) return false;
+      await mkdir(this.directory, { recursive: true, mode: 448 });
+      await rejectSymlinks(this.directory);
+      checkPermissions(await lstat(this.directory), true);
+    }
+    return true;
+  }
+  async load(guard) {
+    if (!await this.#directory(false)) return null;
+    const path = join(this.directory, "credentials.json");
+    await rejectSymlinks(path);
+    let file;
+    try {
+      file = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    } catch (error) {
+      if (missing(error)) return null;
+      throw new CliError("INVALID_REQUEST");
+    }
+    try {
+      const info = await file.stat();
+      checkPermissions(info, false);
+      if (info.size > 8192) throw new CliError("INVALID_REQUEST");
+      let value;
+      try {
+        value = JSON.parse(await file.readFile("utf8"));
+      } catch {
+        throw new CliError("INVALID_REQUEST");
+      }
+      const data = profile(value);
+      return new CredentialSession(data, "store", guard);
+    } finally {
+      await file.close();
+    }
+  }
+  async save(input) {
+    const data = profile(input);
+    await this.#directory(true);
+    const path = join(this.directory, "credentials.json");
+    await rejectSymlinks(path);
+    try {
+      checkPermissions(await lstat(path), false);
+    } catch (error) {
+      if (!missing(error)) throw error;
+    }
+    const temporary = join(this.directory, `.credentials-${randomUUID()}`);
+    const file = await open(
+      temporary,
+      constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY | constants.O_NOFOLLOW,
+      384
+    );
+    try {
+      try {
+        await file.writeFile(JSON.stringify(data), "utf8");
+        await file.sync();
+      } finally {
+        await file.close();
+      }
+      await this.#directory(false);
+      await rejectSymlinks(path);
+      await rename(temporary, path);
+      const directory = await open(
+        this.directory,
+        constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW
+      );
+      try {
+        await directory.sync();
+      } finally {
+        await directory.close();
+      }
+    } finally {
+      try {
+        await unlink(temporary);
+      } catch (error) {
+        if (!missing(error)) throw error;
+      }
+    }
+  }
+  async remove() {
+    if (!await this.#directory(false)) return;
+    const path = join(this.directory, "credentials.json");
+    await rejectSymlinks(path);
+    try {
+      checkPermissions(await lstat(path), false);
+      await unlink(path);
+    } catch (error) {
+      if (!missing(error)) throw error;
+    }
+  }
+};
+async function resolveSession(store, env, guard) {
+  const key = env.ELENA_AGENT_KEY;
+  const baseUrl = env.ELENA_AGENT_BASE_URL;
+  guard.add(key);
+  if (key !== void 0 !== (baseUrl !== void 0)) throw new CliError("INVALID_REQUEST");
+  const stored = await store.load(guard);
+  if (key !== void 0 && baseUrl !== void 0) {
+    const base = origin(baseUrl);
+    if (stored && stored.baseUrl !== base) throw new CliError("ORIGIN_REJECTED");
+    const staffOrigin = env.ELENA_AGENT_STAFF_ORIGIN ? origin(env.ELENA_AGENT_STAFF_ORIGIN) : stored?.staffOrigin;
+    if (stored?.staffOrigin && staffOrigin !== stored.staffOrigin)
+      throw new CliError("ORIGIN_REJECTED");
+    return new CredentialSession({ secret: key, baseUrl: base, staffOrigin }, "environment", guard);
+  }
+  if (stored && env.ELENA_AGENT_STAFF_ORIGIN && origin(env.ELENA_AGENT_STAFF_ORIGIN) !== stored.staffOrigin)
+    throw new CliError("ORIGIN_REJECTED");
+  return stored;
+}
+
+// src/auth.ts
+async function pairingRequest(runtime, baseUrl, endpoint, body, schema) {
+  let response;
+  try {
+    response = await runtime.fetch(`${baseUrl}/api/v1/agent-access/pairing/${endpoint}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify(body),
+      redirect: "error",
+      credentials: "omit",
+      cache: "no-store",
+      signal: AbortSignal.timeout(3e4)
+    });
+  } catch {
+    throw new CliError("TEMPORARY_UNAVAILABLE");
+  }
+  if (response.redirected || response.status >= 300 && response.status < 400)
+    throw new CliError("ORIGIN_REJECTED");
+  if (response.url && new URL(response.url).origin !== baseUrl)
+    throw new CliError("ORIGIN_REJECTED");
+  let value;
+  try {
+    if (!response.body || Number(response.headers.get("content-length") ?? 0) > 1024 * 1024)
+      throw new Error();
+    const reader = response.body.getReader();
+    const chunks = [];
+    let size = 0;
+    try {
+      while (true) {
+        const chunk = await reader.read();
+        if (chunk.done) break;
+        size += chunk.value.byteLength;
+        if (size > 1024 * 1024) {
+          await reader.cancel();
+          throw new Error();
+        }
+        chunks.push(chunk.value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw new CliError("TEMPORARY_UNAVAILABLE");
+  }
+  if (!response.ok) {
+    const error = elenaAgentErrorSchema.safeParse(value);
+    if (!error.success) throw new CliError("TEMPORARY_UNAVAILABLE");
+    const retryHeader = response.headers.get("retry-after");
+    const headerSeconds = retryHeader ? /^\d+$/.test(retryHeader) ? Number(retryHeader) : Math.max(1, Math.ceil((Date.parse(retryHeader) - runtime.now()) / 1e3)) : 0;
+    const retry = Math.max(error.data.error.retryAfterSeconds ?? 0, headerSeconds);
+    if (!Number.isFinite(retry) || retry > 3600) throw new CliError(error.data.error.code);
+    throw new PairingServerError(error.data.error.code, retry || void 0);
+  }
+  if (response.status !== (endpoint === "start" ? 201 : 200)) throw new CliError("INVALID_REQUEST");
+  return parse(schema, value);
+}
+var PairingServerError = class extends CliError {
+};
+async function login(options) {
+  const { store, guard, runtime } = options;
+  const baseUrl = origin(options.baseUrl);
+  const staffOrigin = origin(options.staffOrigin);
+  const previous = await store.load(guard);
+  if (previous && (previous.baseUrl !== baseUrl || previous.staffOrigin !== staffOrigin))
+    throw new CliError("ORIGIN_REJECTED");
+  let retries = 0;
+  let start;
+  for (; ; ) {
+    try {
+      start = await pairingRequest(
+        runtime,
+        baseUrl,
+        "start",
+        { version: "1", label: "elena-catalog" },
+        elenaAgentPairingStartResponseSchema
+      );
+      break;
+    } catch (error) {
+      if (!(error instanceof PairingServerError) || !["RATE_LIMITED", "TEMPORARY_UNAVAILABLE"].includes(error.code) || retries++ >= 2)
+        throw error;
+      await runtime.sleep(Math.max(5, error.retryAfterSeconds ?? 5) * 1e3);
+    }
+  }
+  guard.add(start.deviceCode);
+  const verificationUrl = pinUrl(start.verificationUrl, staffOrigin);
+  guard.assertSafe(verificationUrl);
+  guard.assertSafe(start.userCode);
+  runtime.notify(
+    `Abra ${verificationUrl}
+C\xF3digo: ${start.userCode}
+La aprobaci\xF3n no ejecuta cambios. No comparta secretos.`
+  );
+  let expires = Math.min(Date.parse(start.expiresAt), runtime.now() + 6e5);
+  let delay = start.intervalSeconds;
+  retries = 0;
+  for (; ; ) {
+    if (runtime.now() + delay * 1e3 >= expires) throw new CliError("PAIRING_EXPIRED");
+    await runtime.sleep(delay * 1e3);
+    if (runtime.now() >= expires) throw new CliError("PAIRING_EXPIRED");
+    try {
+      const result = await pairingRequest(
+        runtime,
+        baseUrl,
+        "poll",
+        { version: "1", deviceCode: start.deviceCode },
+        elenaAgentPairingPollResponseSchema
+      );
+      if (result.status === "pending") {
+        expires = Math.min(expires, Date.parse(result.expiresAt));
+        delay = Math.max(5, result.intervalSeconds);
+        retries = 0;
+        continue;
+      }
+      guard.add(result.credential.secret);
+      if (result.credential.key.status !== "active" || Date.parse(result.credential.key.expiresAt) <= runtime.now())
+        throw new CliError("CREDENTIAL_EXPIRED");
+      try {
+        await store.save({
+          version: "1",
+          baseUrl,
+          staffOrigin,
+          secret: result.credential.secret,
+          credentialId: result.credential.key.id,
+          restaurantId: result.restaurant.id,
+          expiresAt: result.credential.key.expiresAt
+        });
+      } catch {
+        runtime.notify(
+          "No se pudo guardar la entrega \xFAnica. Solicite al due\xF1o revocar esta conexi\xF3n por su etiqueta antes de iniciar otra."
+        );
+        throw new CliError("INVALID_REQUEST");
+      }
+      return {
+        version: "1",
+        authenticated: true,
+        source: "store",
+        baseUrl,
+        credentialId: result.credential.key.id,
+        restaurantId: result.restaurant.id,
+        expiresAt: result.credential.key.expiresAt
+      };
+    } catch (error) {
+      if (error instanceof CliError && !(error instanceof PairingServerError) && error.code === "TEMPORARY_UNAVAILABLE") {
+        runtime.notify(
+          "La entrega \xFAnica puede haberse consumido. No vuelva a consultar ese c\xF3digo: solicite al due\xF1o revocar la conexi\xF3n hu\xE9rfana por su etiqueta e inicie otra conexi\xF3n."
+        );
+      }
+      if (!(error instanceof PairingServerError) || !["RATE_LIMITED", "TEMPORARY_UNAVAILABLE"].includes(error.code) || retries++ >= 2)
+        throw error;
+      delay = Math.max(5, error.retryAfterSeconds ?? 5);
+    }
+  }
+}
+async function authStatus(session, factory, now) {
+  if (!session)
+    return {
+      version: "1",
+      authenticated: false,
+      source: "none",
+      baseUrl: null,
+      credentialId: null,
+      restaurantId: null,
+      expiresAt: null
+    };
+  if (session.expiresAt && Date.parse(session.expiresAt) <= now) {
+    return {
+      version: "1",
+      authenticated: false,
+      source: session.source,
+      baseUrl: session.baseUrl,
+      credentialId: null,
+      restaurantId: null,
+      expiresAt: null
+    };
+  }
+  try {
+    const context = await session.client(factory).context.get();
+    if (session.credentialId && context.principal.credentialId !== session.credentialId || session.restaurantId && context.restaurant.id !== session.restaurantId)
+      throw new CliError("CREDENTIAL_INVALID");
+    return {
+      version: "1",
+      authenticated: Date.parse(context.principal.expiresAt) > now,
+      source: session.source,
+      baseUrl: session.baseUrl,
+      credentialId: context.principal.credentialId,
+      restaurantId: context.restaurant.id,
+      expiresAt: context.principal.expiresAt
+    };
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && ["CREDENTIAL_INVALID", "CREDENTIAL_EXPIRED", "CREDENTIAL_REVOKED"].includes(
+      String(error.code)
+    )) {
+      return {
+        version: "1",
+        authenticated: false,
+        source: session.source,
+        baseUrl: session.baseUrl,
+        credentialId: null,
+        restaurantId: null,
+        expiresAt: null
+      };
+    }
+    throw error;
+  }
+}
+
+// src/commands.ts
+import "@theelena/sdk/agent";
+async function readChanges(client, changes) {
+  const read = /* @__PURE__ */ new Set();
+  const readTarget = async (kind, id, revision) => {
+    const cacheKey = `${kind}:${id}:${revision}`;
+    if (read.has(cacheKey)) return;
+    if (kind === "product") {
+      const { product } = await client.catalog.products.get(id);
+      if (product.revision !== revision) throw new CliError("VERSION_CONFLICT");
+      if (product.isDraft) throw new CliError("REFERENCE_CONFLICT");
+    } else {
+      const { category } = await client.catalog.categories.get(id);
+      if (category.revision !== revision) throw new CliError("VERSION_CONFLICT");
+    }
+    read.add(cacheKey);
+  };
+  for (const change of changes) {
+    const kind = change.kind === "product.upsert" ? "product" : "category";
+    if (change.target.kind === "id") {
+      await readTarget(kind, change.target.id, change.target.expectedVersion);
+    } else if (change.target.expectedVersion !== null && !read.has(`${kind}:external`)) {
+      const cursors = /* @__PURE__ */ new Set();
+      let cursor;
+      do {
+        const query = { version: "1", limit: 100, ...cursor ? { cursor } : {} };
+        const page = kind === "product" ? await client.catalog.products.list(query) : await client.catalog.categories.list(query);
+        cursor = page.nextCursor ?? void 0;
+        if (cursor && cursors.has(cursor)) throw new CliError("INVALID_REQUEST");
+        if (cursor) cursors.add(cursor);
+      } while (cursor);
+      read.add(`${kind}:external`);
+    }
+    if (change.kind === "product.upsert" && change.data.category.kind === "id") {
+      await readTarget("category", change.data.category.id, change.data.category.expectedVersion);
+    }
+  }
+}
+async function proposalReread(client, request) {
+  const payload = request.payload;
+  if (payload.kind === "catalog") {
+    await readChanges(client, payload.changes);
+  } else if (payload.kind === "publication") {
+    for (const target of payload.products) {
+      const { product } = await client.catalog.products.get(target.id);
+      if (product.revision !== target.expectedVersion) throw new CliError("VERSION_CONFLICT");
+      if (product.isDraft) throw new CliError("REFERENCE_CONFLICT");
+    }
+  } else {
+    const preview = await client.imports.get(payload.importId);
+    if (preview.planHash !== payload.planHash) throw new CliError("VERSION_CONFLICT");
+    for (const ref of payload.selectedRefs) {
+      const row = preview.items.find((item) => item.ref === ref);
+      if (!row || row.classification === "invalid" || row.classification === "conflict")
+        throw new CliError("REFERENCE_CONFLICT");
+    }
+  }
+}
+async function wireCommand(client, parsed) {
+  const { command, args, flags } = parsed;
+  switch (command) {
+    case "context":
+      return client.context.get();
+    case "catalog categories list":
+      return client.catalog.categories.list(pageQuery(flags));
+    case "catalog categories get":
+      return client.catalog.categories.get(args[0]);
+    case "catalog products list":
+      return client.catalog.products.list(pageQuery(flags));
+    case "catalog products get":
+      return client.catalog.products.get(args[0]);
+    case "assets get":
+      return client.assets.get(args[0]);
+    case "media status":
+      return client.media.get(args[0]);
+    case "import status":
+      return client.imports.get(args[0]);
+    case "operations list":
+      return client.operations.list(pageQuery(flags));
+    case "operations status":
+      return client.operations.get(args[0]);
+    case "operations apply":
+      return client.operations.apply(args[0], applyRequest(flags));
+    default:
+      throw new CliError("INVALID_REQUEST");
+  }
+}
+
+// src/files.ts
+import { constants as constants2 } from "fs";
+import { open as open2 } from "fs/promises";
+import { basename, extname } from "path";
+import { createHash } from "crypto";
+import { ELENA_AGENT_LIMITS, elenaAgentMediaStageRequestSchema } from "@theelena/sdk/agent";
+async function localBytes(path, max) {
+  if (!path || /^[a-z][a-z\d+.-]*:/i.test(path) || path.includes("\0"))
+    throw new CliError("INVALID_REQUEST");
+  let file;
+  try {
+    file = await open2(path, constants2.O_RDONLY | constants2.O_NOFOLLOW | constants2.O_NONBLOCK);
+  } catch {
+    throw new CliError("INVALID_REQUEST");
+  }
+  try {
+    const info = await file.stat();
+    if (!info.isFile() || info.size < 1 || info.size > max) throw new CliError("INVALID_REQUEST");
+    const bytes = Buffer.alloc(Math.min(info.size + 1, max + 1));
+    let count = 0;
+    while (count < bytes.length) {
+      const result = await file.read(bytes, count, bytes.length - count, count);
+      if (result.bytesRead === 0) break;
+      count += result.bytesRead;
+    }
+    if (count !== info.size) throw new CliError("INVALID_REQUEST");
+    return bytes.subarray(0, count);
+  } finally {
+    await file.close();
+  }
+}
+async function requestFile(path, schema, guard) {
+  const bytes = await localBytes(path, ELENA_AGENT_LIMITS.jsonBytes);
+  let value;
+  try {
+    value = JSON.parse(bytes.toString("utf8"));
+  } catch {
+    throw new CliError("INVALID_REQUEST");
+  }
+  guard.assertSafe(value);
+  return parse(schema, value);
+}
+async function stagedFile(path, idempotencyKey, guard) {
+  const bytes = await localBytes(path, ELENA_AGENT_LIMITS.mediaBytes);
+  const extension = extname(path).toLowerCase();
+  let mimeType;
+  if (bytes.length >= 24 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) && extension === ".png") {
+    mimeType = "image/png";
+    const width = bytes.readUInt32BE(16);
+    const height = bytes.readUInt32BE(20);
+    if (!width || !height || width > 1e4 || height > 1e4 || width * height > 4e7 || bytes.includes(Buffer.from("acTL")))
+      throw new CliError("MEDIA_INVALID");
+  } else if (bytes.length >= 4 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255 && [".jpg", ".jpeg"].includes(extension)) {
+    mimeType = "image/jpeg";
+  } else if (bytes.length >= 20 && bytes.toString("ascii", 0, 4) === "RIFF" && bytes.toString("ascii", 8, 12) === "WEBP" && extension === ".webp") {
+    mimeType = "image/webp";
+    if (bytes.readUInt32LE(4) + 8 !== bytes.length || bytes.includes(Buffer.from("ANIM")) || bytes.toString("ascii", 12, 16) === "VP8X" && (bytes[20] & 2) !== 0)
+      throw new CliError("MEDIA_INVALID");
+  } else {
+    throw new CliError("MEDIA_INVALID");
+  }
+  const metadata = parse(elenaAgentMediaStageRequestSchema, {
+    version: "1",
+    idempotencyKey,
+    fileName: basename(path),
+    mimeType,
+    bytes: bytes.length,
+    sha256: createHash("sha256").update(bytes).digest("hex")
+  });
+  guard.assertSafe(metadata);
+  return { metadata, file: new Blob([new Uint8Array(bytes)], { type: mimeType }) };
+}
+
+// src/cli.ts
+async function runCli(argv, overrides = {}) {
+  const runtime = {
+    env: process.env,
+    store: new CredentialStore(),
+    createClient: createElenaAgentClient2,
+    fetch: globalThis.fetch,
+    stdout: (text) => {
+      process.stdout.write(text);
+    },
+    stderr: (text) => {
+      process.stderr.write(text);
+    },
+    sleep: (milliseconds) => sleep(milliseconds),
+    now: () => Date.now(),
+    ...overrides
+  };
+  const guard = new SecretGuard();
+  guard.add(runtime.env.ELENA_AGENT_KEY);
+  const print = (value) => {
+    guard.assertSafe(value);
+    runtime.stdout(`${JSON.stringify(value)}
+`);
+  };
+  try {
+    const parsed = argumentsFor(argv, guard);
+    if (parsed.command === "help") {
+      runtime.stdout(HELP);
+      return 0;
+    }
+    if (parsed.command === "version") {
+      runtime.stdout("0.1.0\n");
+      return 0;
+    }
+    if (parsed.command === "auth logout") {
+      await runtime.store.remove();
+      print({
+        version: "1",
+        loggedOut: true,
+        remoteRevoked: false,
+        environmentCredentialPresent: runtime.env.ELENA_AGENT_KEY !== void 0
+      });
+      return 0;
+    }
+    if (parsed.command === "auth login") {
+      if (runtime.env.ELENA_AGENT_KEY !== void 0 || runtime.env.ELENA_AGENT_BASE_URL !== void 0)
+        throw new CliError("INVALID_REQUEST");
+      const baseUrl = origin(parsed.flags["--base-url"]);
+      const staffOrigin = origin(runtime.env.ELENA_AGENT_STAFF_ORIGIN);
+      const result2 = await login({
+        baseUrl,
+        staffOrigin,
+        store: runtime.store,
+        guard,
+        runtime: {
+          fetch: runtime.fetch,
+          sleep: runtime.sleep,
+          now: runtime.now,
+          notify: (message) => {
+            guard.assertSafe(message);
+            runtime.stderr(`${message}
+`);
+          }
+        }
+      });
+      print(result2);
+      return 0;
+    }
+    const preview = parsed.command === "import preview" ? await requestFile(parsed.flags["--file"], elenaAgentImportPreviewRequestSchema, guard) : void 0;
+    const proposal = parsed.command === "operations propose" ? await requestFile(parsed.flags["--file"], elenaAgentProposalRequestSchema, guard) : void 0;
+    const media = parsed.command === "media stage" ? await stagedFile(parsed.args[0], parsed.flags["--idempotency-key"], guard) : void 0;
+    const session = await resolveSession(runtime.store, runtime.env, guard);
+    if (parsed.command === "auth status") {
+      const status = await authStatus(session, runtime.createClient, runtime.now());
+      print(status);
+      return session && !status.authenticated ? 3 : 0;
+    }
+    if (!session) throw new CliError("CREDENTIAL_REQUIRED");
+    if (session.expiresAt && Date.parse(session.expiresAt) <= runtime.now())
+      throw new CliError("CREDENTIAL_EXPIRED");
+    if (parsed.command.startsWith("operations ") && !session.staffOrigin)
+      throw new CliError("INVALID_REQUEST");
+    const client = session.client(runtime.createClient);
+    const context = await client.context.get();
+    if (Date.parse(context.principal.expiresAt) <= runtime.now())
+      throw new CliError("CREDENTIAL_EXPIRED");
+    if (session.restaurantId && context.restaurant.id !== session.restaurantId || session.credentialId && context.principal.credentialId !== session.credentialId)
+      throw new CliError("CREDENTIAL_INVALID");
+    let result;
+    if (parsed.command === "context") result = context;
+    else if (preview) result = await client.imports.preview(preview);
+    else if (proposal) {
+      await proposalReread(client, proposal);
+      result = await client.operations.propose(proposal);
+    } else if (media) result = await client.media.stage(media.metadata, media.file);
+    else result = await wireCommand(client, parsed);
+    if (result && typeof result === "object" && "approvalUrl" in result) {
+      if (!session.staffOrigin || typeof result.approvalUrl !== "string")
+        throw new CliError("ORIGIN_REJECTED");
+      pinUrl(result.approvalUrl, session.staffOrigin);
+    }
+    print(result);
+    if (result && typeof result === "object" && "state" in result && ["partial", "failed", "rejected", "expired", "cancelled"].includes(String(result.state)))
+      return 4;
+    return 0;
+  } catch (error) {
+    const safe = safeError(error);
+    runtime.stderr(`${JSON.stringify(safe.toWire())}
+`);
+    return exitFor(safe.code);
+  }
+}
+
+// src/index.ts
+process.exitCode = await runCli(process.argv.slice(2));

package/package.json

@@ -1,6 +1,36 @@
 {
   "name": "@theelena/catalog-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "CLI de catálogo de Elena con autorización humana y credenciales de restaurante",
+  "author": "Elena Tech",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "bin": {
+    "elena-catalog": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "package.json"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --maxWorkers=2"
+  },
+  "dependencies": {
+    "@theelena/sdk": "0.1.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22",
+    "tsup": "^8.5.1",
+    "typescript": "^5",
+    "vitest": "^4.1.9"
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.