@asteby/storefront 0.10.0 → 0.11.0

package/dist/cli.js

@@ -0,0 +1,665 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { createInterface } from "readline";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/errors.ts
+var StorefrontError = class extends Error {
+  name = "StorefrontError";
+  status;
+  code;
+  field;
+  details;
+  url;
+  /** Scopes a `403 insufficient_scope` says the route needs (empty for any other error). */
+  requiredScopes;
+  constructor(init) {
+    super(init.message, init.cause === void 0 ? void 0 : { cause: init.cause });
+    this.status = init.status;
+    this.code = init.code;
+    this.field = init.field;
+    this.details = init.details;
+    this.url = init.url;
+    this.requiredScopes = init.requiredScopes ?? [];
+  }
+  /**
+   * Affected lines of a `409 insufficient_stock` (empty for any other error or a
+   * server older than contract 1.1). The cart is untouched: show the lines and
+   * let the buyer adjust or remove them.
+   */
+  get stockLines() {
+    const lines = this.details?.lines;
+    if (this.code !== "insufficient_stock" || !Array.isArray(lines)) return [];
+    return lines.filter((l) => typeof l === "object" && l !== null && typeof l.sku === "string");
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      status: this.status,
+      code: this.code,
+      message: this.message,
+      field: this.field,
+      ...this.requiredScopes.length ? { requiredScopes: this.requiredScopes } : {}
+    };
+  }
+};
+var STATUS_CODES = {
+  400: "validation",
+  401: "unauthorized",
+  403: "forbidden",
+  404: "not_found",
+  409: "conflict",
+  422: "invalid_state",
+  429: "rate_limited"
+};
+function defaultCodeForStatus(status) {
+  return STATUS_CODES[status] ?? (status >= 500 ? "server_error" : "invalid_response");
+}
+
+// src/geo.ts
+var RAD = Math.PI / 180;
+function isValidPoint(p) {
+  const { lat, lng } = p ?? {};
+  return Number.isFinite(lat) && Number.isFinite(lng) && Math.abs(lat) <= 90 && Math.abs(lng) <= 180 && !(lat === 0 && lng === 0);
+}
+
+// src/money.ts
+function isTokenPublishable(token) {
+  return typeof token === "string" && token.startsWith("pk_");
+}
+
+// src/query.ts
+function appendParams(search, params) {
+  if (!params) return search;
+  for (const [key, raw] of Object.entries(params)) {
+    const values = Array.isArray(raw) ? raw : [raw];
+    for (const v of values) {
+      if (v === void 0 || v === null || v === "") continue;
+      search.append(key, String(v));
+    }
+  }
+  return search;
+}
+function productListQuery(params = {}) {
+  const { filters, handles, ...rest } = params;
+  const search = appendParams(new URLSearchParams(), rest);
+  if (handles && handles.length > 0) search.set("handles", handles.join(","));
+  if (filters) {
+    for (const [key, raw] of Object.entries(filters)) {
+      const name = key.startsWith("filter.") ? key : `filter.${key}`;
+      appendParams(search, { [name]: raw });
+    }
+  }
+  return search;
+}
+
+// src/client.ts
+var OWN_OPTION_KEYS = /* @__PURE__ */ new Set(["headers", "timeoutMs", "customerToken", "clientIp", "idempotencyKey", "preview", "signal"]);
+var CLIENT_IP_HEADER = "X-Storefront-Client-IP";
+function normalizeClientIp(raw) {
+  if (!raw) return void 0;
+  let v = raw.trim();
+  if (v.startsWith("[") && v.endsWith("]")) v = v.slice(1, -1);
+  if (!v || v.length > 45 || /[\s,%/]/.test(v)) return void 0;
+  if (/^[0-9]{1,3}(\.[0-9]{1,3}){3}$/.test(v)) {
+    return v.split(".").every((o) => Number(o) <= 255) ? v : void 0;
+  }
+  if (!v.includes(":") || !/^[0-9a-fA-F:.]+$/.test(v) || v.split("::").length > 2) return void 0;
+  try {
+    new URL(`http://[${v}]/`);
+  } catch {
+    return void 0;
+  }
+  return v;
+}
+function generateIdempotencyKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return "idem-" + Date.now().toString(36) + "-" + Math.random().toString(36).slice(2) + Math.random().toString(36).slice(2);
+}
+function joinUrl(baseUrl, path) {
+  return baseUrl.replace(/\/+$/, "") + path;
+}
+function enc(segment) {
+  return encodeURIComponent(segment);
+}
+function linkSignals(signals) {
+  const active = signals.filter((s) => !!s);
+  if (active.length === 0) return { signal: void 0, cleanup: () => {
+  } };
+  if (active.length === 1) return { signal: active[0], cleanup: () => {
+  } };
+  const controller = new AbortController();
+  const listeners = [];
+  for (const s of active) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      break;
+    }
+    const on = () => controller.abort(s.reason);
+    s.addEventListener("abort", on, { once: true });
+    listeners.push([s, on]);
+  }
+  return {
+    signal: controller.signal,
+    cleanup: () => listeners.forEach(([s, on]) => s.removeEventListener("abort", on))
+  };
+}
+function scopeList(raw) {
+  return Array.isArray(raw) ? raw.filter((s) => typeof s === "string" && s.length > 0) : [];
+}
+async function readError(res, url) {
+  let body;
+  try {
+    const text = await res.text();
+    body = text ? JSON.parse(text) : void 0;
+  } catch {
+    body = void 0;
+  }
+  const e = body?.error;
+  const top = body;
+  const code = e?.code ?? (typeof top?.code === "string" ? top.code : void 0);
+  const requiredScopes = code === "insufficient_scope" ? scopeList(e?.required_scopes ?? top?.required_scopes ?? e?.details?.required_scopes) : [];
+  return new StorefrontError({
+    status: res.status,
+    code: code ?? defaultCodeForStatus(res.status),
+    ...requiredScopes.length ? { requiredScopes } : {},
+    message: e?.message ?? `Storefront API responded ${res.status}${res.statusText ? " " + res.statusText : ""}`,
+    ...e?.field ? { field: e.field } : {},
+    ...e?.details !== void 0 ? { details: e.details } : {},
+    url
+  });
+}
+function createStorefrontClient(config) {
+  if (!config.baseUrl) throw new TypeError("createStorefrontClient: baseUrl is required");
+  if (!config.token) throw new TypeError("createStorefrontClient: token is required");
+  const currentToken = () => {
+    const t = typeof config.token === "function" ? config.token() : config.token;
+    if (!t) throw new StorefrontError({ status: 0, code: "unauthorized", message: "Storefront token is empty (token source returned nothing)" });
+    return t;
+  };
+  const isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  const initialToken = typeof config.token === "string" ? config.token : "";
+  if (isBrowser && initialToken.startsWith("sk_")) {
+    console.warn("[@asteby/storefront] A private sk_ token is being used in a browser. Use a public pk_ token instead.");
+  }
+  async function request(spec) {
+    const fetchImpl = config.fetch ?? (globalThis.fetch ? globalThis.fetch.bind(globalThis) : void 0);
+    if (!fetchImpl) throw new TypeError("createStorefrontClient: no fetch available; pass `fetch` in options");
+    const options = spec.options ?? {};
+    const search = spec.query instanceof URLSearchParams ? spec.query : appendParams(new URLSearchParams(), spec.query);
+    const qs = search.toString();
+    const url = joinUrl(config.baseUrl, spec.path) + (qs ? `?${qs}` : "");
+    const headers = new Headers(config.headers);
+    headers.set("Accept", "application/json");
+    const token = currentToken();
+    headers.set("Authorization", `Bearer ${token}`);
+    if (config.locale) headers.set("Accept-Language", config.locale);
+    if (config.domain) headers.set("X-Storefront-Domain", storefrontDomainHeader(config.domain, config.market));
+    const customerToken = options.customerToken !== void 0 ? options.customerToken : config.customerToken;
+    if (customerToken) headers.set("X-Customer-Token", customerToken);
+    const clientIp = options.clientIp !== void 0 ? options.clientIp : config.clientIp;
+    const ip = isTokenPublishable(token) ? void 0 : normalizeClientIp(clientIp);
+    if (ip) headers.set(CLIENT_IP_HEADER, ip);
+    if (options.idempotencyKey) headers.set("Idempotency-Key", options.idempotencyKey);
+    if (spec.body !== void 0) headers.set("Content-Type", "application/json");
+    for (const [k, v] of Object.entries(options.headers ?? {})) headers.set(k, v);
+    const passthrough = {};
+    for (const [k, v] of Object.entries(options)) if (!OWN_OPTION_KEYS.has(k) && v !== void 0) passthrough[k] = v;
+    const timeoutMs = options.timeoutMs ?? config.timeoutMs;
+    const timeoutController = timeoutMs && timeoutMs > 0 ? new AbortController() : void 0;
+    const timer = timeoutController ? setTimeout(() => timeoutController.abort(new StorefrontError({ status: 0, code: "timeout", message: `Request timed out after ${timeoutMs}ms`, url })), timeoutMs) : void 0;
+    const linked = linkSignals([options.signal, timeoutController?.signal]);
+    const init = {
+      ...passthrough,
+      method: spec.method,
+      headers,
+      ...spec.body !== void 0 ? { body: JSON.stringify(spec.body) } : {},
+      ...linked.signal ? { signal: linked.signal } : {}
+    };
+    const ctx = { method: spec.method, url, path: spec.path, init, options };
+    const started = Date.now();
+    let res;
+    try {
+      const hooked = config.onRequest ? await config.onRequest(ctx) : void 0;
+      res = hooked instanceof Response ? hooked : await fetchImpl(url, init);
+    } catch (err) {
+      if (timeoutController?.signal.aborted) {
+        throw new StorefrontError({ status: 0, code: "timeout", message: `Request timed out after ${timeoutMs}ms`, url, cause: err });
+      }
+      if (options.signal?.aborted) {
+        throw new StorefrontError({ status: 0, code: "aborted", message: "Request aborted", url, cause: err });
+      }
+      if (err instanceof StorefrontError) throw err;
+      throw new StorefrontError({ status: 0, code: "network", message: err instanceof Error ? err.message : "Network error", url, cause: err });
+    } finally {
+      if (timer) clearTimeout(timer);
+      linked.cleanup();
+    }
+    if (config.onResponse) await config.onResponse({ ...ctx, response: res, durationMs: Date.now() - started });
+    if (res.status === 404 && spec.nullOn404) {
+      await res.text().catch(() => void 0);
+      return null;
+    }
+    if (res.status === 304) {
+      throw new StorefrontError({ status: 304, code: "not_modified", message: "Not modified", url });
+    }
+    if (!res.ok) throw await readError(res, url);
+    if (res.status === 204) return void 0;
+    const text = await res.text();
+    if (!text) return void 0;
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new StorefrontError({ status: res.status, code: "invalid_response", message: "Response is not valid JSON", url, cause: err });
+    }
+  }
+  const get = (path, query, options) => request({ method: "GET", path, ...query ? { query } : {}, ...options ? { options } : {} });
+  const getOrNull = (path, query, options) => request({ method: "GET", path, nullOn404: true, ...query ? { query } : {}, ...options ? { options } : {} });
+  const write = (method, path, body, options) => request({ method, path, ...body !== void 0 ? { body } : {}, ...options ? { options } : {} });
+  const cartPath = (id, rest = "") => `/storefront/carts/${enc(id)}${rest}`;
+  const previewQuery = (options) => options?.preview ? { preview: options.preview } : void 0;
+  const client = {
+    /** Resolved configuration (read-only). */
+    config: Object.freeze({ ...config }),
+    /** Low-level escape hatch: any route under `baseUrl`. */
+    request,
+    token: {
+      /**
+       * What the token in use is and can do (`GET {baseUrl}/_token`, a gateway route, not a `/storefront` one).
+       * Needs no scope, so it answers even when the token is under-provisioned: `missing_scopes` says what to repair.
+       */
+      introspect: (options) => get("/_token", void 0, options)
+    },
+    /** Returns a new client that sends the given buyer session token. */
+    withCustomerToken(customerToken) {
+      return createStorefrontClient({ ...config, customerToken });
+    },
+    /** Returns a new client that reports the shopper's IP (`X-Storefront-Client-IP`) on every call. */
+    withClientIp(clientIp) {
+      return createStorefrontClient({ ...config, clientIp: clientIp ?? null });
+    },
+    shop: {
+      get: (options) => get("/storefront/shop", void 0, options)
+    },
+    /**
+     * How the market formats, taxes, addresses and invoices (`fiscal_id` carries the tax-id pattern, the regimes,
+     * the invoice uses and the identity documents the buyer can upload). Cacheable; `null` when the organization
+     * has no region configured.
+     */
+    region: (options) => getOrNull("/storefront/region", void 0, options),
+    products: {
+      list: (params, options) => get("/storefront/products", productListQuery(params), options),
+      /** `null` when the product does not exist or is unpublished. */
+      get: (handle, options) => getOrNull(`/storefront/products/${enc(handle)}`, void 0, options),
+      recommendations: (handle, options) => get(`/storefront/products/${enc(handle)}/recommendations`, void 0, options)
+    },
+    collections: {
+      list: (params, options) => get("/storefront/collections", params, options),
+      /** `null` when the collection does not exist. */
+      get: (handle, options) => getOrNull(`/storefront/collections/${enc(handle)}`, void 0, options)
+    },
+    locations: {
+      /** Branches of the shop. With `postal_code` they come ordered by distance (`distance_km`). */
+      list: (params, options) => get("/storefront/locations", params, options),
+      /** `null` when the branch does not exist or is not visible. */
+      get: (id, options) => getOrNull(`/storefront/locations/${enc(id)}`, void 0, options),
+      /**
+       * Branches ordered by distance to a point, closest first. The server rounds the coordinates (0.01°, ~1 km)
+       * and never stores them; this client does not log or keep them either. The answer is `private, no-store`
+       * (it depends on the buyer's position), so do not put it in a shared cache. Note `onRequest` hooks and
+       * `fetch` wrappers do see the URL: do not log it. Throws `TypeError` for an invalid point.
+       */
+      nearest: (point, options) => {
+        if (!isValidPoint(point)) throw new TypeError("locations.nearest: lat/lng must be a valid point");
+        return get("/storefront/locations/nearest", { lat: point.lat, lng: point.lng }, { cache: "no-store", ...options });
+      }
+    },
+    stock: {
+      /** Stock for up to 250 SKUs. */
+      get: (skus, options) => get("/storefront/stock", { sku: skus }, options)
+    },
+    restock: {
+      /**
+       * "Notify me when it is back". Idempotent per contact + SKU; always answers `202 pending`.
+       * Only offered when `availability.notify_available` is true. Needs `customer:write`.
+       */
+      subscribe: (input, options) => write("POST", "/storefront/restock-subscriptions", input, options)
+    },
+    carts: {
+      create: (input = {}, options) => write("POST", "/storefront/carts", input, options),
+      /** `null` when the cart does not exist (e.g. expired cookie). */
+      get: (id, options) => getOrNull(cartPath(id), void 0, options),
+      addLines: (id, lines, options) => write("POST", cartPath(id, "/lines"), { lines }, options),
+      /** Quantity `0` removes the line. */
+      updateLines: (id, lines, options) => write("PATCH", cartPath(id, "/lines"), { lines }, options),
+      removeLines: (id, lineIds, options) => write("PATCH", cartPath(id, "/lines"), { lines: lineIds.map((lid) => ({ id: lid, quantity: 0 })) }, options),
+      setDiscountCodes: (id, codes, options) => write("PUT", cartPath(id, "/discount-codes"), { codes }, options),
+      setBuyer: (id, buyer, options) => write("PUT", cartPath(id, "/buyer"), buyer, options),
+      setShippingAddress: (id, address, options) => write("PUT", cartPath(id, "/shipping-address"), address, options),
+      deliveryOptions: (id, options) => get(cartPath(id, "/delivery-options"), void 0, options),
+      /** Payment providers active for the cart's market; send the chosen `key` as `payment_method`. */
+      paymentMethods: (id, options) => get(cartPath(id, "/payment-methods"), void 0, options),
+      setDelivery: (id, delivery, options) => write("PUT", cartPath(id, "/delivery"), delivery, options),
+      /** Order note (up to 1000 characters). `null` or empty clears it. */
+      setNote: (id, note, options) => write("PUT", cartPath(id, "/note"), { note }, options),
+      /**
+       * Asks for an invoice for this cart (`null` or `{ requested: false }` withdraws it). The server validates the
+       * data against the region BEFORE any charge: `422` with `field: 'invoice.<field>'` (e.g. `invoice.tax_regime`)
+       * names what to fix. `409 already_checked_out` when the cart is already an order. Checkout uses it when
+       * `CheckoutInput.invoice` is omitted.
+       */
+      setInvoice: (id, invoice, options) => write("PUT", cartPath(id, "/invoice"), invoice ?? { requested: false }, options),
+      /**
+       * Cross-sell suggestions: only sellable variants, with `unlocks` when adding one reaches the next
+       * discount tier. `first` 1-8 (default 4). `private, no-store`; ask on demand, not on every render.
+       */
+      recommendations: (id, params = {}, options) => get(cartPath(id, "/recommendations"), params, options),
+      /** Reserves stock and creates the order. Sends `Idempotency-Key` (auto-generated if omitted). */
+      checkout: (id, input, options = {}) => write("POST", cartPath(id, "/checkout"), input, {
+        ...options,
+        idempotencyKey: options.idempotencyKey ?? generateIdempotencyKey()
+      })
+    },
+    promotions: {
+      /** Public promotions and the entry pop-up announcement for the request's market (cacheable). */
+      list: (options) => get("/storefront/promotions", void 0, options)
+    },
+    checkouts: {
+      /** What to mount for an embedded checkout (public key, options, amount) and whether it can still be paid. Never cache. */
+      paymentConfig: (id, options) => getOrNull(`/storefront/checkouts/${enc(id)}/payment-config`, void 0, options),
+      /**
+       * Pays a checkout in the page. The browser brings only what the provider SDK returned (`provider_data`);
+       * the amount is the server's. `idempotencyKey` is REQUIRED (use `paymentIdempotencyKey(checkoutId, attempt)`):
+       * repeating a call with the same key never charges twice. Needs a server token (`checkout:write`).
+       */
+      pay: (id, input, options) => {
+        if (!options || typeof options.idempotencyKey !== "string" || !options.idempotencyKey.trim()) {
+          throw new TypeError("checkouts.pay: idempotencyKey is required");
+        }
+        return write("POST", `/storefront/checkouts/${enc(id)}/payment`, input, options);
+      },
+      /**
+       * Reads a placed checkout (same shape as the `carts.checkout` result). `order.number` is `null` until OPS
+       * has created the order (a few hundred ms after checkout); poll once or twice and, if it is still `null`,
+       * keep telling the buyer the number will arrive by email. Needs a server token (`checkout:write`).
+       * `null` when the checkout does not exist. Never cache.
+       */
+      get: (id, options) => getOrNull(`/storefront/checkouts/${enc(id)}`, void 0, options)
+    },
+    customer: {
+      /** Sends a one-time code by email or SMS/WhatsApp. */
+      requestOtp: (identifier, options) => write("POST", "/storefront/customer/otp", identifier, options),
+      /** Exchanges the code for a buyer session (`token` goes in `customerToken`). */
+      createSession: (input, options) => write("POST", "/storefront/customer/session", input, options),
+      /** What the store supports (password login, email verification, OTP channels). Drives which forms to show. */
+      capabilities: (options) => get("/storefront/customer/capabilities", void 0, options),
+      /**
+       * Creates an account with email + password. `verification_required` (202): a code was emailed, finish with
+       * `verifyRegistration`. `created` (201): the account exists and `session` is ready. `409` when the email is taken.
+       */
+      register: async (input, options) => {
+        const res = await write("POST", "/storefront/customer/register", input, options);
+        return res && "token" in res ? { status: "created", session: res } : { status: "verification_required" };
+      },
+      /** Confirms the emailed registration code and returns the new buyer session. */
+      verifyRegistration: (input, options) => write("POST", "/storefront/customer/register/verify", input, options),
+      /** Email + password login. `401` for wrong credentials. */
+      loginWithPassword: (input, options) => write("POST", "/storefront/customer/login", input, options),
+      /** Sets or changes the password of the signed-in buyer (`options.customerToken`, or a `withCustomerToken` client). */
+      setPassword: (input, options) => write("PUT", "/storefront/customer/password", input, options),
+      /** Resets a forgotten password with the code from `requestOtp({ email })`. */
+      resetPassword: (input, options) => write("POST", "/storefront/customer/password/reset", input, options),
+      get: (options) => get("/storefront/customer", void 0, options),
+      /** Updates the profile and the saved fiscal data; `fiscal: null` deletes the latter. `422` with `field: 'fiscal.<field>'`. */
+      update: (input, options) => write("PATCH", "/storefront/customer", input, options),
+      orders: (params, options) => get("/storefront/customer/orders", params, options),
+      /** `null` when the order does not exist or belongs to someone else. */
+      order: (id, options) => getOrNull(`/storefront/customer/orders/${enc(id)}`, void 0, options),
+      requestReturn: (orderId, input, options) => write("POST", `/storefront/customer/orders/${enc(orderId)}/returns`, input, options),
+      requestInvoice: (orderId, input, options) => write("POST", `/storefront/customer/orders/${enc(orderId)}/invoice`, input, options),
+      addresses: {
+        list: (options) => get("/storefront/customer/addresses", void 0, options),
+        create: (address, options) => write("POST", "/storefront/customer/addresses", address, options),
+        update: (id, address, options) => write("PATCH", `/storefront/customer/addresses/${enc(id)}`, address, options),
+        delete: (id, options) => write("DELETE", `/storefront/customer/addresses/${enc(id)}`, void 0, options)
+      }
+    },
+    content: {
+      theme: (options) => get("/storefront/content/theme", void 0, options),
+      /** `null` when the page does not exist. */
+      page: (handle, options) => getOrNull(`/storefront/content/pages/${enc(handle)}`, previewQuery(options), options),
+      /** `null` when the menu does not exist. */
+      menu: (handle, options) => getOrNull(`/storefront/content/menus/${enc(handle)}`, void 0, options),
+      articles: (params, options) => get("/storefront/content/articles", params, options),
+      /** `null` when the article does not exist. */
+      article: (handle, options) => getOrNull(`/storefront/content/articles/${enc(handle)}`, previewQuery(options), options)
+    }
+  };
+  return client;
+}
+function storefrontDomainHeader(domain, market) {
+  const host = domain.trim();
+  const code = (market ?? "").trim().toLowerCase();
+  return code && /^[a-z0-9_-]{1,32}$/.test(code) ? `${host}#${code}` : host;
+}
+
+// src/diagnose.ts
+function maskToken(token) {
+  if (!token) return "(sin token)";
+  const prefix = /^[a-z]{2}_/.exec(token)?.[0] ?? "";
+  return token.length <= prefix.length + 8 ? `${prefix}\u2026` : `${prefix}\u2026${token.slice(-4)}`;
+}
+function repairPath(connectionName) {
+  return `OPS \u2192 Conexiones y API \u2192 ${connectionName ?? "<conexi\xF3n>"} \u2192 Reparar permisos`;
+}
+
+// src/node.ts
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { hostname } from "os";
+var SDK_VERSION = true ? "0.11.0" : "dev";
+function writeFileAtomic(file, content, mode = 384) {
+  const dir = dirname(file);
+  mkdirSync(dir, { recursive: true });
+  const tmp = join(dir, `.${file.split("/").pop()}.${process.pid}.${Date.now().toString(36)}.tmp`);
+  const fd = openSync(tmp, "wx", mode);
+  try {
+    writeSync(fd, content);
+    fsyncSync(fd);
+  } catch (err) {
+    closeSync(fd);
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+  closeSync(fd);
+  try {
+    chmodSync(tmp, mode);
+    renameSync(tmp, file);
+  } catch (err) {
+    try {
+      unlinkSync(tmp);
+    } catch {
+    }
+    throw err;
+  }
+}
+var ConnectError = class extends Error {
+  constructor(kind, message, status = 0) {
+    super(message);
+    this.kind = kind;
+    this.status = status;
+  }
+  kind;
+  status;
+  name = "ConnectError";
+};
+var trimSlash = (u) => u.replace(/\/+$/, "");
+async function post(fetchImpl, url, body, bearer) {
+  let res;
+  try {
+    res = await fetchImpl(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", Accept: "application/json", ...bearer ? { Authorization: `Bearer ${bearer}` } : {} },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(15e3)
+    });
+  } catch {
+    throw new ConnectError("network", "No pudimos comunicarnos con OPS. Revisa la direcci\xF3n y tu conexi\xF3n a internet.");
+  }
+  const text = await res.text().catch(() => "");
+  if (!res.ok) {
+    if (res.status === 429) throw new ConnectError("rate_limited", "Demasiados intentos. Espera unos minutos e int\xE9ntalo de nuevo.", 429);
+    if (res.status === 401 || res.status === 403) throw new ConnectError("unauthorized", "OPS rechaz\xF3 la credencial de esta tienda.", res.status);
+    if (res.status >= 500) throw new ConnectError("server", "OPS no pudo atender la solicitud. Int\xE9ntalo de nuevo en un momento.", res.status);
+    throw new ConnectError("invalid_code", "El c\xF3digo no es v\xE1lido, ya se us\xF3 o venci\xF3. Genera uno nuevo en OPS \u2192 Conexiones y API.", res.status);
+  }
+  if (!text) return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ConnectError("invalid_response", "OPS respondi\xF3 algo que no entendimos.", res.status);
+  }
+}
+function assertRedeem(r) {
+  const o = r;
+  if (!o || typeof o.secret_token !== "string" || !o.secret_token || typeof o.connection_id !== "string" || !Array.isArray(o.scopes)) {
+    throw new ConnectError("invalid_response", "OPS respondi\xF3 algo que no entendimos.");
+  }
+}
+async function redeemConnectionCode(opts) {
+  const fetchImpl = opts.fetch ?? globalThis.fetch.bind(globalThis);
+  const client_info = { sdk_version: SDK_VERSION, hostname: hostname(), ...opts.siteUrl ? { site_url: opts.siteUrl } : {} };
+  const res = await post(fetchImpl, `${trimSlash(opts.opsUrl)}/api/connect/v1/redeem`, { code: opts.code.trim(), client_info });
+  assertRedeem(res);
+  return res;
+}
+var stateFileFor = (tokenFile) => `${tokenFile}.json`;
+function saveConnection(tokenFile, r, opsUrl = r.ops_url) {
+  const state = { ops_url: trimSlash(r.ops_url || opsUrl), connection_id: r.connection_id, environment: r.environment, scopes: r.scopes, rotate_after: r.rotate_after };
+  writeFileAtomic(stateFileFor(tokenFile), JSON.stringify(state, null, 2) + "\n");
+  writeFileAtomic(tokenFile, r.secret_token + "\n");
+}
+
+// src/cli.ts
+var HELP = `Uso: npx @asteby/storefront connect --ops <url> [--env-file <ruta>] [--token-file <ruta>] [--site <url>]
+
+Conecta esta tienda con OPS. El c\xF3digo de conexi\xF3n (K7QM-2XPA) se pide en la terminal; nunca va como argumento.
+
+  --ops          Direcci\xF3n de OPS (https://ops.ejemplo.com). Tambi\xE9n OPS_URL.
+  --token-file   D\xF3nde guardar la clave (por omisi\xF3n ./storefront_token). Modo 0600, escritura at\xF3mica.
+  --env-file     Archivo .env donde dejar SOLO OPS_URL y STOREFRONT_TOKEN_FILE (nunca la clave).
+  --site         Direcci\xF3n p\xFAblica de la tienda (opcional, informativa).`;
+function parseArgs(argv) {
+  const flags = {};
+  const [cmd, ...rest] = argv;
+  for (let i = 0; i < rest.length; i++) {
+    const a = rest[i];
+    const eq = a.indexOf("=");
+    const key = (eq > 0 ? a.slice(0, eq) : a).replace(/^--/, "");
+    if (!a.startsWith("--") || !["ops", "env-file", "token-file", "site", "code"].includes(key)) return { cmd, flags, bad: a };
+    if (key === "code") return { cmd, flags, bad: "--code (el c\xF3digo se pide en la terminal, no como argumento)" };
+    const val = eq > 0 ? a.slice(eq + 1) : rest[++i];
+    if (!val) return { cmd, flags, bad: a };
+    flags[key] = val;
+  }
+  return { cmd, flags };
+}
+function upsertEnv(text, values) {
+  const lines = text === "" ? [] : text.replace(/\n$/, "").split("\n");
+  for (const [k, v] of Object.entries(values)) {
+    const i = lines.findIndex((l) => new RegExp(`^\\s*(export\\s+)?${k}\\s*=`).test(l));
+    if (i >= 0) lines[i] = `${k}=${v}`;
+    else lines.push(`${k}=${v}`);
+  }
+  return lines.join("\n") + "\n";
+}
+async function runCli(argv, io) {
+  const { cmd, flags, bad } = parseArgs(argv);
+  if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+    io.stdout(HELP);
+    return cmd ? 0 : 1;
+  }
+  if (cmd !== "connect") {
+    io.stderr(`Comando desconocido: ${cmd}
+${HELP}`);
+    return 1;
+  }
+  if (bad) {
+    io.stderr(`Argumento no v\xE1lido: ${bad}
+${HELP}`);
+    return 1;
+  }
+  const env = io.env ?? process.env;
+  const cwd = io.cwd ?? process.cwd();
+  const opsUrl = (flags.ops ?? env.OPS_URL ?? "").trim().replace(/\/+$/, "");
+  if (!/^https?:\/\//.test(opsUrl)) {
+    io.stderr("Falta --ops con la direcci\xF3n de OPS (https://\u2026).");
+    return 1;
+  }
+  const tokenFile = resolve2(cwd, flags["token-file"] ?? "storefront_token");
+  const envFile = flags["env-file"] ? resolve2(cwd, flags["env-file"]) : null;
+  let code;
+  try {
+    code = (await io.promptCode()).trim();
+  } catch (err) {
+    io.stderr(err instanceof Error ? err.message : "No se pudo leer el c\xF3digo.");
+    return 1;
+  }
+  if (!code) {
+    io.stderr("No escribiste ning\xFAn c\xF3digo.");
+    return 1;
+  }
+  try {
+    const r = await redeemConnectionCode({ opsUrl, code, ...flags.site ? { siteUrl: flags.site } : {}, ...io.fetch ? { fetch: io.fetch } : {} });
+    saveConnection(tokenFile, r, opsUrl);
+    if (envFile) {
+      const current = existsSync2(envFile) ? readFileSync2(envFile, "utf8") : "";
+      if (/^\s*(export\s+)?STOREFRONT_TOKEN\s*=/m.test(current)) {
+        io.stderr("Aviso: tu .env a\xFAn tiene STOREFRONT_TOKEN con una clave anterior; b\xF3rrala, el archivo de clave tiene prioridad.");
+      }
+      writeFileAtomic(envFile, upsertEnv(current, { OPS_URL: r.ops_url || opsUrl, STOREFRONT_TOKEN_FILE: tokenFile }), 384);
+    }
+    io.stdout(`Conectada \u2713 \xB7 ${r.scopes.length} alcances \xB7 ${maskToken(r.secret_token)}`);
+    io.stdout(`Clave guardada en ${tokenFile} (modo 0600).${envFile ? ` Variables en ${envFile}.` : ` Usa STOREFRONT_TOKEN_FILE=${tokenFile}.`}`);
+    const base = `${(r.ops_url || opsUrl).replace(/\/+$/, "")}/api/gw`;
+    const sf = createStorefrontClient({ baseUrl: base, token: r.secret_token, ...io.fetch ? { fetch: io.fetch } : {}, timeoutMs: 1e4 });
+    try {
+      const info = await sf.token.introspect();
+      if (info.missing_scopes?.length) {
+        io.stderr(`Aviso: a la clave le faltan permisos (${info.missing_scopes.join(", ")}). Rep\xE1ralo en ${repairPath()}.`);
+      } else {
+        io.stdout(`Verificada con OPS \xB7 entorno ${info.environment}.`);
+      }
+    } catch {
+      io.stderr("Aviso: la clave se guard\xF3 pero no pudimos verificarla con OPS todav\xEDa.");
+    }
+    return 0;
+  } catch (err) {
+    io.stderr(err instanceof ConnectError ? err.message : "No se pudo completar la conexi\xF3n.");
+    return 1;
+  }
+}
+function ttyPrompt() {
+  if (!process.stdin.isTTY) return Promise.reject(new Error("El c\xF3digo se escribe en la terminal (TTY); no se acepta por argumento ni por tuber\xEDa."));
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((res) => rl.question("C\xF3digo de conexi\xF3n: ", (a) => (rl.close(), res(a))));
+}
+var entry = process.argv[1] ?? "";
+if (/(^|[\\/])(storefront|cli)(\.js)?$/.test(entry) && !process.env.VITEST) {
+  void runCli(process.argv.slice(2), {
+    stdout: (l) => console.log(l),
+    stderr: (l) => console.error(l),
+    promptCode: ttyPrompt
+  }).then((c) => process.exit(c));
+}
+export {
+  SDK_VERSION,
+  runCli,
+  upsertEnv
+};