@funnelchat-hq/cli 0.0.0-stage → 0.1.1

package/dist/cli.js

@@ -0,0 +1,2341 @@
+#!/usr/bin/env node
+
+// src/http/pacer.ts
+var DEFAULT_RATE = 1;
+var MAX_RATE = 10;
+var Pacer = class {
+  constructor(ratePerSecond, clock, sleep) {
+    this.clock = clock;
+    this.sleep = sleep;
+    this.intervalMs = 1e3 / ratePerSecond;
+  }
+  clock;
+  sleep;
+  intervalMs;
+  #next = 0;
+  async wait(signal) {
+    const now = this.clock();
+    const start = Math.max(now, this.#next);
+    this.#next = start + this.intervalMs;
+    if (start > now) await this.sleep(start - now, signal);
+  }
+};
+var realSleep = (ms, signal) => new Promise((resolve2, reject) => {
+  if (signal?.aborted) {
+    reject(new Error("aborted"));
+    return;
+  }
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new Error("aborted"));
+  };
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve2();
+  }, ms);
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+
+// src/main.ts
+import { Command, CommanderError } from "commander";
+
+// src/errors.ts
+var ExitCode = {
+  OK: 0,
+  /** Something the CLI did not expect. */
+  UNEXPECTED: 1,
+  /** Wrong command, option or value; or `--resume` with options that differ from the original run. */
+  USAGE: 2,
+  /** No key, a key the API rejects (`401`), or a key without the permission the route needs (`403`). */
+  AUTH: 3,
+  /** The resource does not exist in the account (`404`). */
+  NOT_FOUND: 4,
+  /** A limit the CLI does not wait for: the daily cap or a `Retry-After` too long. Resumable. */
+  RATE_LIMITED: 5,
+  /** The API failed (`5xx`, `422`…) or could not be reached, after the retries. */
+  API: 6,
+  /** The output already exists: the CLI never overwrites a file. */
+  EXISTS: 7,
+  /** Interrupted with Ctrl+C. An export can be resumed. */
+  INTERRUPTED: 130
+};
+var CliError = class extends Error {
+  exitCode;
+  code;
+  hint;
+  details;
+  constructor(message, options) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = new.target.name;
+    this.exitCode = options.exitCode;
+    this.code = options.code;
+    this.hint = options.hint;
+    this.details = { ...options.details };
+  }
+};
+function usageError(message, hint) {
+  return new CliError(message, { exitCode: ExitCode.USAGE, code: "usage", ...hint ? { hint } : {} });
+}
+var ApiError = class extends CliError {
+  status;
+  /** The stable `error` code of the body (`daily_cap_exceeded`, `permission_denied`…), when there is one. */
+  apiCode;
+  /** Seconds from `Retry-After`, when present. */
+  retryAfter;
+  fieldErrors;
+  route;
+  domain;
+  /** `X-Request-Id` of the response, when it had one. */
+  requestId;
+  constructor(init) {
+    const record = isRecord(init.body) ? init.body : void 0;
+    const apiCode = typeof record?.error === "string" && record.error !== "" ? record.error : void 0;
+    const apiMessage = typeof record?.message === "string" && record.message !== "" ? record.message : void 0;
+    const fieldErrors = isRecord(record?.errors) ? record.errors : void 0;
+    const described = describe(init, apiCode, apiMessage, fieldErrors);
+    const { exitCode, message } = init.override ?? described;
+    const hint = withRequestId(init.override ? void 0 : described.hint, init.requestId);
+    super(message, {
+      exitCode,
+      code: apiCode ?? `http_${init.status}`,
+      ...hint ? { hint } : {},
+      details: {
+        status: init.status,
+        route: `${init.method} ${init.route}`,
+        ...apiCode ? { api_error: apiCode } : {},
+        ...init.retryAfter !== void 0 ? { retry_after: init.retryAfter } : {},
+        ...fieldErrors ? { errors: fieldErrors } : {},
+        ...init.requestId ? { request_id: init.requestId } : {},
+        ...init.override?.details
+      }
+    });
+    this.status = init.status;
+    this.apiCode = apiCode;
+    this.retryAfter = init.retryAfter;
+    this.fieldErrors = fieldErrors;
+    this.route = init.route;
+    this.domain = init.domain;
+    this.requestId = init.requestId;
+  }
+};
+function withRequestId(hint, requestId) {
+  if (!requestId) return hint;
+  const cite = `Request id (X-Request-Id): ${requestId}. Quote it, with the approximate time, if you report this to support.`;
+  return hint ? `${hint}
+${cite}` : cite;
+}
+function describe(init, apiCode, apiMessage, fieldErrors) {
+  const where = `${init.method} ${init.route}`;
+  const said = apiMessage ? `: ${apiMessage}` : ".";
+  const { status } = init;
+  if (status === 401) {
+    return {
+      exitCode: ExitCode.AUTH,
+      message: `The API rejected the key (401 on ${where})${said}`,
+      hint: "Check that the key is complete (with the `<id>|` at the start) and still active, and run `funnelchat login` again."
+    };
+  }
+  if (status === 403) {
+    const permission = init.permission ? ` This route needs \`${init.permission}\`.` : "";
+    return {
+      exitCode: ExitCode.AUTH,
+      message: `The key cannot use ${where} (403${apiCode ? ` ${apiCode}` : ""})${said}`,
+      hint: apiCode === "route_not_available" ? "No key enables it for now." : `Create a key with the missing permission.${permission}`
+    };
+  }
+  if (status === 404 && apiCode === "route_not_found") {
+    return {
+      exitCode: ExitCode.NOT_FOUND,
+      message: `The route does not exist in the API (404 route_not_found on ${where}).`,
+      hint: "The CLI only calls routes of the API reference: check that the base URL is the public API's (https://api.funnelchat.com) and that you have the latest version of the CLI."
+    };
+  }
+  if (status === 404) {
+    return { exitCode: ExitCode.NOT_FOUND, message: `Not found in your account (404 on ${where})${said}` };
+  }
+  if (status === 429) {
+    return { exitCode: ExitCode.RATE_LIMITED, message: `The API asked to wait (429${apiCode ? ` ${apiCode}` : ""} on ${where})${said}` };
+  }
+  if (status === 422 && fieldErrors) {
+    const first = Object.entries(fieldErrors)[0];
+    const detail = first ? ` ${first[0]}: ${first[1]?.[0] ?? ""}` : "";
+    return { exitCode: ExitCode.API, message: `The API did not accept the request (422 on ${where})${said}${detail ? `
+ ${detail}` : ""}` };
+  }
+  if (status === 500 && apiCode === "edge_misconfigured") {
+    return {
+      exitCode: ExitCode.API,
+      message: `The API is not available right now (500 edge_misconfigured on ${where}): the API's entry point is not configured to reach this area.`,
+      hint: "It is a problem on Funnelchat's side: please report it."
+    };
+  }
+  if (status === 502 && apiCode === "origin_unreachable") {
+    return {
+      exitCode: ExitCode.API,
+      message: `The API is not available right now (502 origin_unreachable on ${where}): the API's entry point could not reach the area that serves the route.`,
+      hint: "Try again in a few minutes; if it persists, please report it."
+    };
+  }
+  return { exitCode: ExitCode.API, message: `The API answered ${status}${apiCode ? ` ${apiCode}` : ""} on ${where}${said}` };
+}
+var ConnectionError = class extends CliError {
+  constructor(message, cause) {
+    super(message, { exitCode: ExitCode.API, code: "connection_error", hint: "Check your connection and the base URL, and try again.", cause });
+  }
+};
+var InterruptedError = class extends CliError {
+  constructor() {
+    super("Interrupted.", { exitCode: ExitCode.INTERRUPTED, code: "interrupted" });
+  }
+};
+function parseRetryAfter(value, now = Date.now()) {
+  if (value === null || value === void 0) return void 0;
+  const trimmed = value.trim();
+  if (trimmed === "") return void 0;
+  if (/^\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+  const date = Date.parse(trimmed);
+  if (Number.isNaN(date)) return void 0;
+  return Math.max(0, Math.ceil((date - now) / 1e3));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/version.ts
+var VERSION = "0.1.1";
+var PACKAGE_NAME = "@funnelchat-hq/cli";
+var USER_AGENT_PRODUCT = "funnelchat-cli";
+
+// src/http/pagination.ts
+function extractItems(body) {
+  if (Array.isArray(body)) return body;
+  if (isRecord(body) && Array.isArray(body.data)) return body.data;
+  return [];
+}
+function toInt(value) {
+  if (typeof value === "number" && Number.isInteger(value)) return value;
+  if (typeof value === "string" && /^\d+$/.test(value)) return Number(value);
+  return null;
+}
+function nextPageQuery(body) {
+  if (!isRecord(body)) return null;
+  for (const holder of [body.meta, body]) {
+    if (!isRecord(holder)) continue;
+    if ("next_cursor" in holder) {
+      return typeof holder.next_cursor === "string" && holder.next_cursor !== "" ? { cursor: holder.next_cursor } : null;
+    }
+    const current = toInt(holder.current_page);
+    const last = toInt(holder.last_page);
+    if (current !== null && last !== null) return current < last ? { page: current + 1 } : null;
+  }
+  const links = isRecord(body.links) ? body.links : void 0;
+  const nextUrl = links?.next ?? body.next_page_url;
+  if (typeof nextUrl === "string" && nextUrl !== "") {
+    const params = new URL(nextUrl, "https://placeholder.invalid").searchParams;
+    const cursor = params.get("cursor");
+    if (cursor) return { cursor };
+    const page = toInt(params.get("page"));
+    if (page !== null) return { page };
+  }
+  return null;
+}
+function followingPage(body, query) {
+  if (extractItems(body).length === 0) return null;
+  const next = nextPageQuery(body);
+  if (next === null) return null;
+  const unchanged = Object.entries(next).every(([key, value]) => String(query[key]) === String(value));
+  return unchanged ? null : next;
+}
+function totalOf(body) {
+  if (!isRecord(body) || !isRecord(body.meta)) return null;
+  return toInt(body.meta.total);
+}
+
+// src/http/url.ts
+function serializeQuery(query) {
+  if (!query) return "";
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) append(params, key, value);
+  return params.toString();
+}
+function append(params, key, value) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value)) {
+    const scalarKey = key.endsWith("[]") ? key : `${key}[]`;
+    const base = key.endsWith("[]") ? key.slice(0, -2) : key;
+    value.forEach((item, index) => {
+      if (isPlainObject(item) || Array.isArray(item)) append(params, `${base}[${index}]`, item);
+      else append(params, scalarKey, item);
+    });
+    return;
+  }
+  if (value instanceof Date) {
+    params.append(key, value.toISOString());
+    return;
+  }
+  if (isPlainObject(value)) {
+    for (const [child, childValue] of Object.entries(value)) append(params, `${key}[${child}]`, childValue);
+    return;
+  }
+  if (typeof value === "boolean") {
+    params.append(key, value ? "1" : "0");
+    return;
+  }
+  params.append(key, String(value));
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+function interpolatePath(template, params) {
+  return template.replace(/\{([^}]+)\}/g, (_, name) => {
+    const value = params?.[name];
+    if (value === void 0 || value === null || value === "") {
+      throw new TypeError(`Missing the path parameter "${name}" for ${template}.`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+function joinUrl(baseUrl, path, query) {
+  const base = baseUrl.replace(/\/+$/, "");
+  const suffix = path.startsWith("/") ? path : `/${path}`;
+  if (!query) return `${base}${suffix}`;
+  return `${base}${suffix}${suffix.includes("?") ? "&" : "?"}${query}`;
+}
+
+// src/http/client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 4;
+var DEFAULT_MAX_WAIT_SECONDS = 60;
+var INITIAL_BACKOFF_MS = 1e3;
+var MAX_BACKOFF_MS = 3e4;
+var ApiClient = class {
+  baseUrl;
+  /** Requests sent, retries included. */
+  requests = 0;
+  #apiKey;
+  #options;
+  constructor(options) {
+    this.#apiKey = options.apiKey;
+    this.#options = options;
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+  }
+  /** What `JSON.stringify(client)` shows: never the key. */
+  toJSON() {
+    return { baseUrl: this.baseUrl };
+  }
+  /** One `GET` of `route`, with retries. Returns the parsed body. */
+  async get(route, options = {}) {
+    return await this.#send(route, options);
+  }
+  /** One page of a listing route, and the query of the page after it. */
+  async page(route, options = {}) {
+    const body = await this.#send(route, options);
+    return { items: extractItems(body), body, next: followingPage(body, options.query ?? {}) };
+  }
+  /** Every item of every page of a listing route. */
+  async *all(route, options = {}) {
+    let query = { ...options.query };
+    for (; ; ) {
+      const page = await this.page(route, { ...options, query });
+      yield* page.items;
+      if (!page.next) return;
+      query = mergeNext(query, page.next);
+    }
+  }
+  async #send(route, options) {
+    const opts = this.#options;
+    const method = route.method;
+    const pathname = interpolatePath(route.path, options.path);
+    const url = joinUrl(this.baseUrl, pathname, serializeQuery(options.query));
+    const maxRetries = Math.max(0, opts.maxRetries ?? DEFAULT_MAX_RETRIES);
+    const maxWait = opts.maxWaitSeconds ?? DEFAULT_MAX_WAIT_SECONDS;
+    const retriesAllowed = method === "GET";
+    const random = opts.random ?? Math.random;
+    const headers = {
+      Accept: "application/json",
+      "Accept-Language": "es",
+      "User-Agent": `${USER_AGENT_PRODUCT}/${VERSION} node/${process.version}`,
+      Authorization: `Bearer ${this.#apiKey}`
+    };
+    for (let attempt = 0; ; attempt++) {
+      const canRetry = retriesAllowed && attempt < maxRetries;
+      await opts.pacer.wait(opts.signal);
+      this.requests++;
+      const started = opts.clock();
+      opts.log?.(`\u2192 ${method} ${url}${attempt > 0 ? ` (attempt ${attempt + 1})` : ""}`);
+      let response;
+      let text;
+      try {
+        ({ response, text } = await this.#attempt(method, url, headers));
+      } catch (error2) {
+        if (error2 instanceof InterruptedError) throw error2;
+        if (canRetry) {
+          const delay2 = backoffMs(attempt, random);
+          opts.log?.(`\u2190 ${describeConnectionError(error2)}; retrying in ${formatSeconds(delay2 / 1e3)}`);
+          await this.#sleep(delay2);
+          continue;
+        }
+        throw error2;
+      }
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      opts.log?.(`\u2190 ${response.status} in ${opts.clock() - started} ms${requestId ? ` \xB7 X-Request-Id ${requestId}` : ""}`);
+      const body = parseBody(response, text);
+      if (response.ok) return body;
+      const retryAfter = parseRetryAfter(response.headers.get("retry-after"), opts.clock());
+      const error = new ApiError({
+        status: response.status,
+        body,
+        retryAfter,
+        method,
+        route: route.path,
+        domain: route.domain,
+        permission: route.permission,
+        requestId
+      });
+      const retryable = response.status === 429 || response.status >= 500 && error.apiCode !== "edge_misconfigured";
+      if (!retryable) throw error;
+      if (retryAfter !== void 0 && retryAfter > maxWait) {
+        throw stopForLongWait(error, retryAfter, opts.clock());
+      }
+      if (!canRetry) {
+        if (response.status === 429) error.hint = [`Wait ${formatSeconds(retryAfter ?? 60)} and try again.`, error.hint].filter(Boolean).join("\n");
+        throw error;
+      }
+      const delay = retryAfter !== void 0 ? Math.ceil(retryAfter * 1e3) : backoffMs(attempt, random);
+      opts.log?.(`  ${response.status}${error.apiCode ? ` ${error.apiCode}` : ""}: waiting ${formatSeconds(delay / 1e3)}${retryAfter !== void 0 ? " (Retry-After)" : ""}`);
+      await this.#sleep(delay);
+    }
+  }
+  async #sleep(ms) {
+    try {
+      await this.#options.sleep(ms, this.#options.signal);
+    } catch (error) {
+      if (this.#options.signal?.aborted) throw new InterruptedError();
+      throw error;
+    }
+  }
+  async #attempt(method, url, headers) {
+    const signal = this.#options.signal;
+    if (signal?.aborted) throw new InterruptedError();
+    const timeoutMs = this.#options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const controller2 = new AbortController();
+    const onAbort = () => controller2.abort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller2.abort();
+    }, timeoutMs);
+    const classify = (cause) => {
+      if (signal?.aborted) return new InterruptedError();
+      if (timedOut) return new ConnectionError(`The Funnelchat API did not answer within ${timeoutMs / 1e3} s.`, cause);
+      return new ConnectionError(`Could not connect to the Funnelchat API (${hostOf(url)}).`, cause);
+    };
+    try {
+      let response;
+      try {
+        response = await this.#options.fetch(url, { method, headers, signal: controller2.signal });
+      } catch (error) {
+        throw classify(error);
+      }
+      try {
+        return { response, text: await response.text() };
+      } catch (error) {
+        throw classify(error);
+      }
+    } finally {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+    }
+  }
+};
+function mergeNext(query, next) {
+  const merged = { ...query, ...next };
+  if ("cursor" in next) delete merged.page;
+  if ("page" in next) delete merged.cursor;
+  return merged;
+}
+function backoffMs(attempt, random = Math.random) {
+  const base = Math.min(INITIAL_BACKOFF_MS * 2 ** attempt, MAX_BACKOFF_MS);
+  return Math.round(base * (1 - 0.25 * random()));
+}
+function stopForLongWait(error, retryAfter, now) {
+  const at = new Date(now + retryAfter * 1e3);
+  const when = `${formatSeconds(retryAfter)} (at ${at.toISOString().slice(11, 16)} UTC on ${at.toISOString().slice(0, 10)})`;
+  let message;
+  if (error.apiCode === "daily_cap_exceeded") {
+    const domain = error.domain ?? "this area";
+    message = `The daily cap of calls to ${domain} was reached for this key. It resets in ${when}.`;
+  } else {
+    message = `${error.message} The API asks to wait ${when}, longer than the CLI waits on its own.`;
+  }
+  return new ApiError({
+    status: error.status,
+    body: error.apiCode ? { error: error.apiCode } : null,
+    retryAfter,
+    method: "GET",
+    route: error.route,
+    domain: error.domain,
+    permission: null,
+    requestId: error.requestId,
+    override: {
+      message,
+      exitCode: error.status === 429 ? ExitCode.RATE_LIMITED : ExitCode.API,
+      details: { resets_at: at.toISOString() }
+    }
+  });
+}
+function formatSeconds(seconds) {
+  const s = Math.max(0, Math.ceil(seconds));
+  if (s < 60) return `${s} s`;
+  const h = Math.floor(s / 3600);
+  const m = Math.floor(s % 3600 / 60);
+  if (h === 0) return `${m} min${s % 60 ? ` ${s % 60} s` : ""}`;
+  return `${h} h${m ? ` ${m} min` : ""}`;
+}
+function parseBody(response, text) {
+  if (text === "") return null;
+  const type = response.headers.get("content-type") ?? "";
+  if (type.includes("json") || /^\s*[[{]/.test(text)) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+  return text.length <= 300 ? text : `${text.slice(0, 300)}\u2026`;
+}
+function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return url;
+  }
+}
+function describeConnectionError(error) {
+  return error instanceof Error ? error.message : "network error";
+}
+
+// src/http/redact.ts
+var KEY_SHAPE = /fc_[a-z]+_[A-Za-z0-9]{4,}/g;
+var REDACTED = "[key hidden]";
+var Redactor = class {
+  #secrets = [];
+  /** Adds a value to blank everywhere: the whole key and its secret part. */
+  add(key) {
+    if (!key) return;
+    const parts = [key, key.includes("|") ? key.slice(key.indexOf("|") + 1) : ""];
+    for (const part of parts) if (part.length >= 6 && !this.#secrets.includes(part)) this.#secrets.push(part);
+    this.#secrets.sort((a, b) => b.length - a.length);
+  }
+  redact(text) {
+    let out = text;
+    for (const secret of this.#secrets) out = out.split(secret).join(REDACTED);
+    return out.replace(KEY_SHAPE, REDACTED);
+  }
+};
+
+// src/config/store.ts
+import { chmodSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_FILE_NAME = "config.json";
+function configDir(env, platform = process.platform) {
+  if (env.FUNNELCHAT_CONFIG_DIR) return env.FUNNELCHAT_CONFIG_DIR;
+  if (platform === "win32" && env.APPDATA) return join(env.APPDATA, "funnelchat");
+  const base = env.XDG_CONFIG_HOME && env.XDG_CONFIG_HOME !== "" ? env.XDG_CONFIG_HOME : join(env.HOME ?? homedir(), ".config");
+  return join(base, "funnelchat");
+}
+function configPath(env) {
+  return join(configDir(env), CONFIG_FILE_NAME);
+}
+function loadConfig(env) {
+  const path = configPath(env);
+  if (!existsSync(path)) return { path, config: { version: 1, profiles: {} }, insecurePermissions: false };
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch (cause) {
+    throw new CliError(`Could not read the configuration file ${path}: it is not valid JSON.`, {
+      exitCode: ExitCode.USAGE,
+      code: "config_unreadable",
+      hint: "Fix it or delete it and run `funnelchat login` again.",
+      cause
+    });
+  }
+  const profiles = {};
+  if (isRecord(parsed) && isRecord(parsed.profiles)) {
+    for (const [name, value] of Object.entries(parsed.profiles)) {
+      if (!isRecord(value)) continue;
+      profiles[name] = {
+        ...typeof value.api_key === "string" ? { api_key: value.api_key } : {},
+        ...typeof value.base_url === "string" ? { base_url: value.base_url } : {},
+        ...typeof value.saved_at === "string" ? { saved_at: value.saved_at } : {}
+      };
+    }
+  }
+  const current = isRecord(parsed) && typeof parsed.current_profile === "string" ? parsed.current_profile : void 0;
+  const insecurePermissions = process.platform !== "win32" && (statSync(path).mode & 63) !== 0;
+  return { path, config: { version: 1, ...current ? { current_profile: current } : {}, profiles }, insecurePermissions };
+}
+function saveConfig(env, config) {
+  const dir = configDir(env);
+  mkdirSync(dir, { recursive: true, mode: 448 });
+  const path = join(dir, CONFIG_FILE_NAME);
+  const tmp = join(dir, `.${CONFIG_FILE_NAME}.${process.pid}.tmp`);
+  const fd = openSync(tmp, "w", 384);
+  try {
+    writeSync(fd, `${JSON.stringify(config, null, 2)}
+`);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  try {
+    chmodSync(tmp, 384);
+    renameSync(tmp, path);
+    chmodSync(path, 384);
+  } catch (error) {
+    rmSync(tmp, { force: true });
+    throw error;
+  }
+  return path;
+}
+
+// src/config/credentials.ts
+var PRODUCTION_URL = "https://api.funnelchat.com";
+var STAGING_URL = "https://api-staging.funnelchat.com";
+var DEFAULT_PROFILE = "default";
+var KEY_SHAPE2 = /^\d+\|fc_[a-z]+_[A-Za-z0-9]+$/;
+function activeProfileName(flags, env, config) {
+  return flags.profile ?? nonEmpty(env.FUNNELCHAT_PROFILE) ?? config.current_profile ?? DEFAULT_PROFILE;
+}
+function checkKeyShape(key) {
+  const trimmed = key.trim();
+  if (!KEY_SHAPE2.test(trimmed)) {
+    throw new CliError("The key does not have the shape of a Funnelchat key (`<id>|fc_live_\u2026`).", {
+      exitCode: ExitCode.AUTH,
+      code: "malformed_key",
+      hint: "Copy it in full from the Developers screen of your account, including the `<id>|` at the start."
+    });
+  }
+  return trimmed;
+}
+function resolveBaseUrl(flags, env, profileUrl) {
+  if (flags.baseUrl && flags.staging) throw usageError("Use --base-url or --staging, not both.");
+  const raw = flags.baseUrl ?? (flags.staging ? STAGING_URL : void 0) ?? nonEmpty(env.FUNNELCHAT_BASE_URL) ?? profileUrl ?? PRODUCTION_URL;
+  return checkBaseUrl(raw);
+}
+function checkBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw usageError(`The base URL is not valid: ${raw}`);
+  }
+  const local = ["localhost", "127.0.0.1", "[::1]", "::1"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) {
+    throw usageError(
+      `The base URL must be https (${raw}).`,
+      "http is only accepted for this machine (for example the sandbox at http://127.0.0.1:4010), so the key never travels unencrypted."
+    );
+  }
+  if (url.search || url.hash) throw usageError(`The base URL takes no query and no #: ${raw}`);
+  return url.toString().replace(/\/+$/, "");
+}
+function resolveCredentials(flags, env, config) {
+  const profileName = activeProfileName(flags, env, config);
+  const profile = config.profiles[profileName];
+  const envKey = nonEmpty(env.FUNNELCHAT_API_KEY);
+  if (flags.profile === void 0 && envKey) {
+    return { apiKey: checkKeyShape(envKey), keySource: "env", profile: profileName, baseUrl: resolveBaseUrl(flags, env, void 0) };
+  }
+  if (profile?.api_key) {
+    return { apiKey: checkKeyShape(profile.api_key), keySource: "profile", profile: profileName, baseUrl: resolveBaseUrl(flags, env, profile.base_url) };
+  }
+  if (flags.profile !== void 0) {
+    throw new CliError(`The "${flags.profile}" profile has no saved key.`, {
+      exitCode: ExitCode.AUTH,
+      code: "no_key",
+      hint: `Save it with \`funnelchat login --profile ${flags.profile}\`.`
+    });
+  }
+  throw new CliError("No API key.", {
+    exitCode: ExitCode.AUTH,
+    code: "no_key",
+    hint: "Set the FUNNELCHAT_API_KEY variable or save it with `funnelchat login`."
+  });
+}
+function nonEmpty(value) {
+  return value && value.trim() !== "" ? value.trim() : void 0;
+}
+
+// src/output.ts
+var Output = class {
+  constructor(stdout, stderr, redactor, options) {
+    this.stdout = stdout;
+    this.stderr = stderr;
+    this.redactor = redactor;
+    this.options = options;
+  }
+  stdout;
+  stderr;
+  redactor;
+  options;
+  get json() {
+    return this.options.json;
+  }
+  /** The result of a command: `data` with `--json`, the human lines otherwise. */
+  result(data, human) {
+    if (this.options.json) this.#write(this.stdout, `${JSON.stringify(data, null, 2)}
+`);
+    else this.#lines(this.stdout, human());
+  }
+  /** Progress of a long command (stderr). Silent with `--quiet` or `--json`. */
+  progress(line) {
+    if (!this.options.quiet && !this.options.json) this.#lines(this.stderr, line);
+  }
+  /** A note for people (stderr). Silent with `--json`. */
+  note(line) {
+    if (!this.options.json) this.#lines(this.stderr, line);
+  }
+  /** A warning (stderr), always shown. */
+  warn(line) {
+    this.#lines(this.stderr, `warning: ${line}`);
+  }
+  /** `--verbose` only (stderr). */
+  verbose(line) {
+    if (this.options.verbose) this.#lines(this.stderr, line);
+  }
+  error(error) {
+    const cliError = toCliError(error);
+    if (this.options.json) {
+      const body = {
+        error: {
+          code: cliError.code,
+          message: cliError.message,
+          ...cliError.hint ? { hint: cliError.hint } : {},
+          exit_code: cliError.exitCode,
+          ...cliError.details
+        }
+      };
+      this.#write(this.stderr, `${JSON.stringify(body)}
+`);
+    } else {
+      this.#lines(this.stderr, [`error: ${cliError.message}`, ...cliError.hint ? cliError.hint.split("\n").map((l) => `  ${l}`) : []]);
+      if (this.options.verbose && cliError.exitCode === ExitCode.UNEXPECTED && error instanceof Error && error.stack) {
+        this.#lines(this.stderr, error.stack);
+      }
+    }
+    return cliError.exitCode;
+  }
+  #lines(writer, lines) {
+    const text = Array.isArray(lines) ? lines.join("\n") : lines;
+    this.#write(writer, text.endsWith("\n") ? text : `${text}
+`);
+  }
+  #write(writer, text) {
+    writer.write(this.redactor.redact(text));
+  }
+};
+function toCliError(error) {
+  if (error instanceof CliError) return error;
+  const message = error instanceof Error ? error.message : String(error);
+  return new CliError(`Unexpected error: ${message}`, { exitCode: ExitCode.UNEXPECTED, code: "unexpected", cause: error });
+}
+function table(headers, rows) {
+  const cells = rows.map((row) => row.map((cell) => cell === null || cell === void 0 || cell === "" ? "-" : String(cell)));
+  const widths = headers.map((h, i) => Math.max(h.length, ...cells.map((row) => (row[i] ?? "").length)));
+  const line = (row) => row.map((cell, i) => i === row.length - 1 ? cell : cell.padEnd(widths[i] ?? 0)).join("  ");
+  return [line(headers), ...cells.map(line)];
+}
+
+// src/context.ts
+var Context = class {
+  constructor(io, globals) {
+    this.io = io;
+    this.globals = globals;
+    this.redactor.add(io.env.FUNNELCHAT_API_KEY);
+    this.out = new Output(io.stdout, io.stderr, this.redactor, { json: globals.json === true, quiet: globals.quiet === true, verbose: globals.verbose === true });
+  }
+  io;
+  globals;
+  redactor = new Redactor();
+  out;
+  #config;
+  #credentials;
+  #client;
+  #warnedConfig = false;
+  config() {
+    if (!this.#config) {
+      this.#config = loadConfig(this.io.env);
+      for (const profile of Object.values(this.#config.config.profiles)) this.redactor.add(profile.api_key);
+      if (this.#config.insecurePermissions && !this.#warnedConfig) {
+        this.#warnedConfig = true;
+        this.out.warn(`other users of this machine can read ${this.#config.path}. Fix it with: chmod 600 "${this.#config.path}"`);
+      }
+    }
+    return this.#config;
+  }
+  credentials() {
+    if (!this.#credentials) {
+      this.#credentials = resolveCredentials(this.globals, this.io.env, this.config().config);
+      this.redactor.add(this.#credentials.apiKey);
+    }
+    return this.#credentials;
+  }
+  client(overrides = {}) {
+    if (!overrides.apiKey && this.#client) return this.#client;
+    const apiKey = overrides.apiKey ?? this.credentials().apiKey;
+    const baseUrl = overrides.baseUrl ?? this.credentials().baseUrl;
+    this.redactor.add(apiKey);
+    const client = new ApiClient({
+      apiKey,
+      baseUrl,
+      fetch: this.io.fetch,
+      pacer: new Pacer(this.rate(), this.io.clock, this.io.sleep),
+      sleep: this.io.sleep,
+      clock: this.io.clock,
+      maxWaitSeconds: this.maxWait(),
+      log: (line) => this.out.verbose(line),
+      ...this.io.signal ? { signal: this.io.signal } : {}
+    });
+    if (!overrides.apiKey) this.#client = client;
+    return client;
+  }
+  /** Requests per second: `--rate`, then `FUNNELCHAT_RATE`, then 1. */
+  rate() {
+    const raw = this.globals.rate ?? this.io.env.FUNNELCHAT_RATE;
+    if (raw === void 0 || raw === "") return DEFAULT_RATE;
+    const value = Number(raw);
+    if (!Number.isFinite(value) || value <= 0 || value > MAX_RATE) {
+      throw usageError(`--rate must be a number greater than 0 and up to ${MAX_RATE} (requests per second): ${raw}`);
+    }
+    return value;
+  }
+  /** The longest `Retry-After` waited for by itself: `--max-wait`, by default 60 s. */
+  maxWait() {
+    const raw = this.globals.maxWait;
+    if (raw === void 0) return 60;
+    const value = Number(raw);
+    if (!Number.isInteger(value) || value < 0 || value > 3600) throw usageError(`--max-wait must be an integer from 0 to 3600 (seconds): ${raw}`);
+    return value;
+  }
+};
+
+// src/generated/routes.ts
+var SPEC_SOURCE = {
+  "sha256": "8bbbae569b4cab520884db98f28204156c1bd6c629578bee609343c193e0dadb",
+  "repository": "git@github.com:Funnelchat20/developers-portal.git",
+  "branch": "feat/openapi-unificada",
+  "commit": "0ef4abb008870ed8c7cae49a08900a81e5e57ed8",
+  "paths": 191
+};
+var routes = {
+  "me": {
+    "id": "me",
+    "method": "GET",
+    "path": "/api/v1/me",
+    "summary": "Ver mi cuenta",
+    "domain": "accounts",
+    "permission": "accounts:read",
+    "pagination": "none",
+    "plainArray": false,
+    "perPageMax": null,
+    "query": [],
+    "pending": null
+  },
+  "devicesList": {
+    "id": "devicesList",
+    "method": "GET",
+    "path": "/api/v1/devices",
+    "summary": "Listar n\xFAmeros",
+    "domain": "accounts",
+    "permission": "accounts:read",
+    "pagination": "page",
+    "plainArray": true,
+    "perPageMax": 100,
+    "query": [
+      "perPage"
+    ],
+    "pending": null
+  },
+  "deviceHealth": {
+    "id": "deviceHealth",
+    "method": "GET",
+    "path": "/api/v1/devices/{device}/health",
+    "summary": "Ver la salud de un n\xFAmero",
+    "domain": "accounts",
+    "permission": "accounts:read",
+    "pagination": "none",
+    "plainArray": false,
+    "perPageMax": null,
+    "query": [],
+    "pending": null
+  },
+  "contactsList": {
+    "id": "contactsList",
+    "method": "GET",
+    "path": "/api/v1/contacts",
+    "summary": "Listar contactos",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "page",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage",
+      "orderBy",
+      "orderByMethod",
+      "tag_ids[]",
+      "tag_mode",
+      "created_from",
+      "created_to",
+      "only_with_phone"
+    ],
+    "pending": null
+  },
+  "contactTags": {
+    "id": "contactTags",
+    "method": "GET",
+    "path": "/api/v1/contacts/{contact}/tags",
+    "summary": "Listar las etiquetas de un contacto",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "page",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage"
+    ],
+    "pending": null
+  },
+  "contactCustomFields": {
+    "id": "contactCustomFields",
+    "method": "GET",
+    "path": "/api/v1/contacts/{contact}/custom-fields",
+    "summary": "Listar los campos personalizados de un contacto",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "page",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage"
+    ],
+    "pending": null
+  },
+  "customFieldsList": {
+    "id": "customFieldsList",
+    "method": "GET",
+    "path": "/api/v1/custom-fields",
+    "summary": "Listar campos personalizados",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "page",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage",
+      "orderBy",
+      "orderByMethod"
+    ],
+    "pending": null
+  },
+  "conversationsList": {
+    "id": "conversationsList",
+    "method": "GET",
+    "path": "/api/v1/conversations",
+    "summary": "Listar conversaciones",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "cursor",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage",
+      "orderBy",
+      "deviceId",
+      "contactId",
+      "updated_since"
+    ],
+    "pending": null
+  },
+  "contactMessages": {
+    "id": "contactMessages",
+    "method": "GET",
+    "path": "/api/v1/contacts/{contactId}/messages",
+    "summary": "Listar los mensajes de un contacto",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "cursor",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage",
+      "updated_since"
+    ],
+    "pending": null
+  },
+  "templatesList": {
+    "id": "templatesList",
+    "method": "GET",
+    "path": "/api/v1/templates",
+    "summary": "Listar plantillas",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "page",
+    "plainArray": false,
+    "perPageMax": 100,
+    "query": [
+      "perPage",
+      "deviceId",
+      "status"
+    ],
+    "pending": null
+  },
+  "macStatus": {
+    "id": "macStatus",
+    "method": "GET",
+    "path": "/api/v1/mac/status",
+    "summary": "Ver el consumo de MACs",
+    "domain": "conversations",
+    "permission": "conversations:read",
+    "pagination": "none",
+    "plainArray": false,
+    "perPageMax": null,
+    "query": [],
+    "pending": null
+  }
+};
+
+// src/commands/account.ts
+var ACCOUNT_FIELDS = ["id", "name", "email", "role", "timezone", "locale", "effective_business_numbers_limit", "effective_agents_limit"];
+function accountSummary(me) {
+  const record = isRecord(me) && isRecord(me.data) && !("id" in me) ? me.data : me;
+  const out = {};
+  if (!isRecord(record)) return out;
+  for (const field of ACCOUNT_FIELDS) if (field in record) out[field] = record[field];
+  return out;
+}
+async function login(ctx, flags) {
+  const { config } = ctx.config();
+  const profile = activeProfileName(ctx.globals, ctx.io.env, config);
+  const baseUrl = resolveBaseUrl(ctx.globals, ctx.io.env, config.profiles[profile]?.base_url);
+  const raw = ctx.io.stdin.isTTY && ctx.io.stdin.setRawMode ? await promptHidden(ctx.io.stdin, ctx.io.stderr, "Paste your Funnelchat API key (it is not shown) and press Enter: ") : await readAll(ctx.io.stdin);
+  const key = checkKeyShape(raw);
+  ctx.redactor.add(key);
+  let account = null;
+  let verified = false;
+  if (flags.verify !== false) {
+    try {
+      account = accountSummary(await ctx.client({ apiKey: key, baseUrl }).get(routes.me));
+      verified = true;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 403) {
+        ctx.out.warn("the key is valid, but it lacks the accounts:read permission: `funnelchat whoami` and `funnelchat numbers` will not work with it.");
+        verified = true;
+      } else {
+        throw error;
+      }
+    }
+  }
+  config.profiles[profile] = { api_key: key, base_url: baseUrl, saved_at: new Date(ctx.io.clock()).toISOString() };
+  config.current_profile = profile;
+  const path = saveConfig(ctx.io.env, config);
+  if (ctx.io.env.FUNNELCHAT_API_KEY) ctx.out.warn("FUNNELCHAT_API_KEY is set: while it is, it wins over the saved profile (except with --profile).");
+  ctx.out.result({ profile, base_url: baseUrl, config_file: path, verified, account }, () => [
+    `Key saved in the "${profile}" profile (${path}, 0600 permissions).`,
+    ...account ? [`Account: ${String(account.name ?? "-")} (${String(account.email ?? "-")})`] : [],
+    ...baseUrl !== PRODUCTION_URL ? [`Base URL: ${baseUrl}`] : [],
+    ...!verified ? ["The key was not checked against the API (--no-verify)."] : []
+  ]);
+}
+function logout(ctx) {
+  const { config } = ctx.config();
+  const profile = activeProfileName(ctx.globals, ctx.io.env, config);
+  const existed = profile in config.profiles;
+  delete config.profiles[profile];
+  if (config.current_profile === profile) delete config.current_profile;
+  const path = existed ? saveConfig(ctx.io.env, config) : ctx.config().path;
+  ctx.out.result(
+    { profile, removed: existed, config_file: path },
+    () => existed ? `Deleted the key of the "${profile}" profile from ${path}.` : `The "${profile}" profile had no saved key.`
+  );
+  if (ctx.io.env.FUNNELCHAT_API_KEY) ctx.out.warn("FUNNELCHAT_API_KEY is still set in your environment.");
+}
+async function whoami(ctx) {
+  const credentials = ctx.credentials();
+  const account = accountSummary(await ctx.client().get(routes.me));
+  const keySource = credentials.keySource === "env" ? "from the FUNNELCHAT_API_KEY variable" : `from the "${credentials.profile}" profile`;
+  ctx.out.result({ account, key_source: credentials.keySource, profile: credentials.keySource === "profile" ? credentials.profile : null, base_url: credentials.baseUrl }, () => [
+    `Account: ${String(account.name ?? "-")} (${String(account.email ?? "-")})`,
+    `  id ${String(account.id ?? "-")} \xB7 role ${String(account.role ?? "-")} \xB7 time zone ${String(account.timezone ?? "-")} \xB7 language ${String(account.locale ?? "-")}`,
+    `Key: ${keySource} (not shown)`,
+    `Base URL: ${credentials.baseUrl}`
+  ]);
+}
+function profilesList(ctx) {
+  const { config, path } = ctx.config();
+  const active = activeProfileName(ctx.globals, ctx.io.env, config);
+  const rows = Object.entries(config.profiles).map(([name, profile]) => ({
+    name,
+    active: name === active,
+    base_url: profile.base_url ?? PRODUCTION_URL,
+    has_key: Boolean(profile.api_key),
+    saved_at: profile.saved_at ?? null
+  }));
+  ctx.out.result(
+    { config_file: path, active_profile: active, env_key: Boolean(ctx.io.env.FUNNELCHAT_API_KEY), profiles: rows },
+    () => rows.length === 0 ? `No saved profiles (${path}). Save one with \`funnelchat login\`.` : [
+      ...table(
+        ["", "profile", "base url", "key", "saved"],
+        rows.map((r) => [r.active ? "*" : "", r.name, r.base_url, r.has_key ? "yes" : "no", r.saved_at])
+      ),
+      ...ctx.io.env.FUNNELCHAT_API_KEY ? ["", "FUNNELCHAT_API_KEY is set: it wins over the active profile (except with --profile)."] : []
+    ]
+  );
+}
+function profilesUse(ctx, name) {
+  const { config } = ctx.config();
+  if (!config.profiles[name]) throw usageError(`There is no "${name}" profile.`, `Create it with \`funnelchat login --profile ${name}\`.`);
+  config.current_profile = name;
+  const path = saveConfig(ctx.io.env, config);
+  ctx.out.result({ active_profile: name, config_file: path }, () => `Active profile: "${name}".`);
+}
+function promptHidden(stdin, stderr, question) {
+  stderr.write(question);
+  return new Promise((resolve2, reject) => {
+    let value = "";
+    stdin.setEncoding?.("utf8");
+    stdin.setRawMode?.(true);
+    stdin.resume();
+    const finish = (error) => {
+      stdin.setRawMode?.(false);
+      stdin.pause();
+      stdin.removeAllListeners("data");
+      stderr.write("\n");
+      if (error) reject(error);
+      else resolve2(value.replace(/\[20[01]~/g, ""));
+    };
+    stdin.on("data", (chunk) => {
+      for (const ch of String(chunk)) {
+        if (ch === "\r" || ch === "\n" || ch === "") return finish();
+        if (ch === "") return finish(new InterruptedError());
+        if (ch === "\x7F" || ch === "\b") value = value.slice(0, -1);
+        else if (ch >= " ") value += ch;
+      }
+    });
+  });
+}
+function readAll(stdin) {
+  return new Promise((resolve2, reject) => {
+    let value = "";
+    stdin.setEncoding?.("utf8");
+    stdin.on("data", (chunk) => {
+      value += String(chunk);
+    });
+    stdin.on("end", () => resolve2(value.trim()));
+    stdin.on("error", reject);
+    stdin.resume();
+  });
+}
+
+// src/commands/common.ts
+function positiveInt(value, flag) {
+  if (!/^\d+$/.test(value) || Number(value) < 1 || !Number.isSafeInteger(Number(value))) {
+    throw usageError(`${flag} must be a positive integer: ${value}`);
+  }
+  return Number(value);
+}
+function idList(values, flag) {
+  const ids = [];
+  for (const value of values ?? []) {
+    for (const piece of value.split(",")) {
+      const trimmed = piece.trim();
+      if (trimmed === "") continue;
+      const id = positiveInt(trimmed, flag);
+      if (!ids.includes(id)) ids.push(id);
+    }
+  }
+  return ids;
+}
+function collect(value, previous) {
+  return [...previous ?? [], value];
+}
+function explicitOptions(command, names) {
+  return new Set(names.filter((name) => command.getOptionValueSource(name) === "cli"));
+}
+
+// src/dates.ts
+var DAY = /^(\d{4})-(\d{2})-(\d{2})$/;
+var DATE_TIME = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:?\d{2})$/i;
+function isValidDay(value) {
+  const match = DAY.exec(value);
+  if (!match) return false;
+  const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+  return !Number.isNaN(date.getTime()) && date.toISOString().slice(0, 10) === value;
+}
+function toApiDateTime(date) {
+  return `${date.toISOString().slice(0, 19)}+00:00`;
+}
+function parseSince(value, flag = "--since") {
+  if (isValidDay(value)) return `${value}T00:00:00+00:00`;
+  if (DATE_TIME.test(value)) {
+    const date = new Date(value.replace(" ", "T"));
+    if (!Number.isNaN(date.getTime())) return toApiDateTime(date);
+  }
+  throw usageError(
+    `${flag} must be a date (YYYY-MM-DD, from 00:00 UTC) or a date and time with a zone (2026-10-01T09:00:00-03:00): ${value}`
+  );
+}
+function parseContactBound(value, flag) {
+  if (isValidDay(value)) return value;
+  if (DATE_TIME.test(value)) {
+    const date = new Date(value.replace(" ", "T"));
+    if (!Number.isNaN(date.getTime())) return toApiDateTime(date);
+  }
+  throw usageError(`${flag} must be a YYYY-MM-DD date or a date and time with a zone: ${value}`);
+}
+function timestampForName(now) {
+  return new Date(now).toISOString().slice(0, 19).replace(/[-:]/g, "").replace("T", "-");
+}
+
+// src/export/csv.ts
+var CSV_BOM = "\uFEFF";
+var FORMULA_START = /^[=+\-@\t\r]/;
+var PLAIN_NUMBER = /^[+-]?\d+(\.\d+)?$/;
+function csvCell(value) {
+  if (value === null || value === void 0) return "";
+  let text = typeof value === "string" ? value : typeof value === "object" ? JSON.stringify(value) : String(value);
+  if (FORMULA_START.test(text) && !PLAIN_NUMBER.test(text)) text = `'${text}`;
+  return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+function csvRow(values) {
+  return `${values.map(csvCell).join(",")}\r
+`;
+}
+
+// src/export/files.ts
+import { createHash } from "crypto";
+import {
+  closeSync as closeSync2,
+  existsSync as existsSync2,
+  fstatSync,
+  fsyncSync as fsyncSync2,
+  ftruncateSync,
+  linkSync,
+  openSync as openSync2,
+  readSync,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  statSync as statSync2,
+  unlinkSync,
+  writeSync as writeSync2
+} from "fs";
+import { basename, dirname, join as join2 } from "path";
+function outputExists(path) {
+  return new CliError(`${path} already exists: the CLI never overwrites a file.`, {
+    exitCode: ExitCode.EXISTS,
+    code: "output_exists",
+    hint: "Choose another folder with --output-dir, or move that file.",
+    details: { path }
+  });
+}
+function sha256File(path) {
+  const hash = createHash("sha256");
+  const fd = openSync2(path, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(1 << 20);
+    for (; ; ) {
+      const read = readSync(fd, buffer, 0, buffer.length, null);
+      if (read === 0) break;
+      hash.update(buffer.subarray(0, read));
+    }
+  } finally {
+    closeSync2(fd);
+  }
+  return hash.digest("hex");
+}
+var LINK_UNSUPPORTED = /* @__PURE__ */ new Set(["EPERM", "ENOTSUP", "EOPNOTSUPP", "EXDEV", "ENOSYS", "EINVAL"]);
+function publish(partPath, finalPath) {
+  try {
+    linkSync(partPath, finalPath);
+  } catch (error) {
+    const code2 = error.code ?? "";
+    if (code2 === "EEXIST") {
+      if (sameFile(partPath, finalPath)) {
+        unlinkSync(partPath);
+        return;
+      }
+      throw outputExists(finalPath);
+    }
+    if (!LINK_UNSUPPORTED.has(code2)) throw error;
+    if (existsSync2(finalPath)) throw outputExists(finalPath);
+    renameSync2(partPath, finalPath);
+    return;
+  }
+  unlinkSync(partPath);
+}
+function sameFile(a, b) {
+  try {
+    const sa = statSync2(a);
+    const sb = statSync2(b);
+    return sa.ino === sb.ino && sa.dev === sb.dev;
+  } catch {
+    return false;
+  }
+}
+function writeNewFile(finalPath, content) {
+  if (existsSync2(finalPath)) throw outputExists(finalPath);
+  const partPath = `${finalPath}.part`;
+  const fd = openSync2(partPath, "w", 420);
+  try {
+    writeSync2(fd, content);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  const entry = { path: basename(finalPath), rows: 0, bytes: Buffer.byteLength(content), sha256: sha256File(partPath) };
+  publish(partPath, finalPath);
+  return entry;
+}
+function writeAtomic(path, content) {
+  const tmp = join2(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+  const fd = openSync2(tmp, "w", 384);
+  try {
+    writeSync2(fd, content);
+    fsyncSync2(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  try {
+    renameSync2(tmp, path);
+  } catch (error) {
+    rmSync2(tmp, { force: true });
+    throw error;
+  }
+}
+var PartFile = class _PartFile {
+  finalPath;
+  partPath;
+  #fd;
+  #offset;
+  #rows;
+  constructor(finalPath, fd, position) {
+    this.finalPath = finalPath;
+    this.partPath = `${finalPath}.part`;
+    this.#fd = fd;
+    this.#offset = position.offset;
+    this.#rows = position.rows;
+  }
+  /** Starts a new file. Fails if the final name already exists. */
+  static create(finalPath) {
+    if (existsSync2(finalPath)) throw outputExists(finalPath);
+    return new _PartFile(finalPath, openSync2(`${finalPath}.part`, "w", 420), { offset: 0, rows: 0 });
+  }
+  /**
+   * Reopens a `.part` at the position of the last checkpoint and drops whatever was written after it.
+   * Returns a {@link FileEntry} instead when the file was already published (the run stopped right
+   * after publishing it, before saving the state).
+   */
+  static resume(finalPath, position) {
+    const partPath = `${finalPath}.part`;
+    if (existsSync2(finalPath)) {
+      if (existsSync2(partPath) && sameFile(partPath, finalPath)) unlinkSync(partPath);
+      if (existsSync2(partPath)) throw outputExists(finalPath);
+      const size2 = statSync2(finalPath).size;
+      if (size2 !== position.offset) {
+        throw inconsistent(`${basename(finalPath)} is ${size2} bytes and the saved state says ${position.offset}`);
+      }
+      return { path: basename(finalPath), rows: position.rows, bytes: size2, sha256: sha256File(finalPath) };
+    }
+    if (!existsSync2(partPath)) {
+      if (position.offset === 0) return _PartFile.create(finalPath);
+      throw inconsistent(`falta ${basename(partPath)}`);
+    }
+    const fd = openSync2(partPath, "r+");
+    const size = fstatSync(fd).size;
+    if (size < position.offset) {
+      closeSync2(fd);
+      throw inconsistent(`${basename(partPath)} is ${size} bytes and the saved state says ${position.offset}`);
+    }
+    if (size > position.offset) ftruncateSync(fd, position.offset);
+    return new _PartFile(finalPath, fd, position);
+  }
+  get position() {
+    return { offset: this.#offset, rows: this.#rows };
+  }
+  get rows() {
+    return this.#rows;
+  }
+  /** Appends whole rows (each already ending in a newline). */
+  append(text, rows) {
+    const buffer = Buffer.from(text, "utf8");
+    let written = 0;
+    while (written < buffer.length) {
+      written += writeSync2(this.fd, buffer, written, buffer.length - written, this.#offset + written);
+    }
+    this.#offset += buffer.length;
+    this.#rows += rows;
+  }
+  /** Flushes to disk: call it before saving the position in the export state. */
+  sync() {
+    fsyncSync2(this.fd);
+  }
+  /** Syncs, closes, hashes and publishes the file under its final name. */
+  finalize() {
+    this.sync();
+    this.close();
+    const entry = { path: basename(this.finalPath), rows: this.#rows, bytes: this.#offset, sha256: sha256File(this.partPath) };
+    publish(this.partPath, this.finalPath);
+    return entry;
+  }
+  close() {
+    if (this.#fd !== null) {
+      closeSync2(this.#fd);
+      this.#fd = null;
+    }
+  }
+  get fd() {
+    if (this.#fd === null) throw new Error(`${this.partPath} is already closed.`);
+    return this.#fd;
+  }
+};
+function inconsistent(detail) {
+  return new CliError(`Cannot resume: the state of the export does not match the files (${detail}).`, {
+    exitCode: ExitCode.USAGE,
+    code: "resume_inconsistent",
+    hint: "Start the export again in another folder."
+  });
+}
+
+// src/export/session.ts
+import { closeSync as closeSync3, existsSync as existsSync3, mkdirSync as mkdirSync2, openSync as openSync3, readdirSync, readFileSync as readFileSync2, rmSync as rmSync3, statSync as statSync3, unlinkSync as unlinkSync2, writeSync as writeSync3 } from "fs";
+import { join as join3, resolve } from "path";
+var STATE_FILE = ".funnelchat-export.json";
+var LOCK_FILE = ".funnelchat-export.lock";
+var MANIFEST_FILE = "manifest.json";
+var ExportSession = class _ExportSession {
+  dir;
+  state;
+  #locked = true;
+  constructor(dir, state) {
+    this.dir = dir;
+    this.state = state;
+  }
+  static open(options) {
+    const dir = resolve(options.cwd, options.dir);
+    const statePath = join3(dir, STATE_FILE);
+    if (!options.resume) {
+      if (existsSync3(dir)) {
+        if (!statSync3(dir).isDirectory()) throw exists(dir, "Choose a folder with --output-dir.");
+        if (readdirSync(dir).length > 0) {
+          throw exists(
+            dir,
+            existsSync3(statePath) ? `There is an unfinished export in that folder: resume it with
+  funnelchat ${options.kind} export --output-dir ${quote(options.dir)} --resume` : "Choose a new or empty folder with --output-dir: the CLI never overwrites files."
+          );
+        }
+      }
+      mkdirSync2(dir, { recursive: true });
+      lock(dir);
+      const session2 = new _ExportSession(dir, options.initial());
+      session2.save();
+      return { session: session2 };
+    }
+    if (!existsSync3(statePath)) {
+      if (existsSync3(join3(dir, MANIFEST_FILE))) return { alreadyComplete: join3(dir, MANIFEST_FILE) };
+      throw usageError(`There is no export to resume in ${dir}.`, "Pass the same --output-dir as the export that was interrupted.");
+    }
+    const state = readState(statePath);
+    if (state.kind !== options.kind) {
+      throw usageError(`That folder holds a ${state.kind} export, not a ${options.kind} one.`, `Resume it with \`funnelchat ${state.kind} export --output-dir ${quote(options.dir)} --resume\`.`);
+    }
+    if (state.base_url !== options.baseUrl) {
+      throw usageError(`That export was made against ${state.base_url} and the base URL is now ${options.baseUrl}.`, "Resume it with the same base URL (and the same key) as the original.");
+    }
+    const differences = [...options.explicit].filter((key) => JSON.stringify(options.options[key] ?? null) !== JSON.stringify(state.options[key] ?? null)).map((key) => `${key}: original ${JSON.stringify(state.options[key] ?? null)}, now ${JSON.stringify(options.options[key] ?? null)}`);
+    if (differences.length) {
+      throw usageError(
+        `The options do not match those of the original export (${differences.join("; ")}).`,
+        "With --resume there is no need to repeat the options: the original ones are used."
+      );
+    }
+    lock(dir);
+    const session = new _ExportSession(dir, state);
+    session.state.runs += 1;
+    session.save();
+    return { session };
+  }
+  path(name) {
+    return join3(this.dir, name);
+  }
+  save() {
+    writeAtomic(join3(this.dir, STATE_FILE), `${JSON.stringify(this.state, null, 2)}
+`);
+  }
+  /** Writes the manifest (never over an existing one), deletes the state and releases the lock. */
+  complete(manifest) {
+    const entry = writeNewFile(join3(this.dir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}
+`);
+    rmSync3(join3(this.dir, STATE_FILE), { force: true });
+    this.release();
+    return entry;
+  }
+  release() {
+    if (!this.#locked) return;
+    this.#locked = false;
+    rmSync3(join3(this.dir, LOCK_FILE), { force: true });
+  }
+};
+function readState(path) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    throw usageError(`The state of the export (${path}) cannot be read.`, "Start the export again in another folder.");
+  }
+  if (!isRecord(parsed) || parsed.state_version !== 1 || typeof parsed.kind !== "string") {
+    throw usageError(`The state of the export (${path}) is not from this version of the CLI.`, "Start the export again in another folder.");
+  }
+  return parsed;
+}
+function lock(dir) {
+  const path = join3(dir, LOCK_FILE);
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const fd = openSync3(path, "wx", 384);
+      writeSync3(fd, String(process.pid));
+      closeSync3(fd);
+      return;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const pid = Number(readFileSync2(path, "utf8").trim());
+      if (Number.isInteger(pid) && pid > 0 && pid !== process.pid && isAlive(pid)) {
+        throw new CliError(`Another run of the CLI (process ${pid}) is using ${dir}.`, {
+          exitCode: ExitCode.EXISTS,
+          code: "export_locked",
+          hint: "Wait for it to finish, or stop it, and try again."
+        });
+      }
+      unlinkSync2(path);
+    }
+  }
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function exists(dir, hint) {
+  return new CliError(`The folder ${dir} already exists and is not empty.`, { exitCode: ExitCode.EXISTS, code: "output_exists", hint, details: { path: dir } });
+}
+function quote(value) {
+  return /^[\w./:@=-]+$/.test(value) ? value : `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
+}
+function baseManifest(state, used, finishedAt) {
+  return {
+    manifest_version: 1,
+    kind: state.kind,
+    generator: { name: PACKAGE_NAME, version: VERSION },
+    api: {
+      base_url: state.base_url,
+      spec: { source: SPEC_SOURCE.branch ? `developers-portal ${SPEC_SOURCE.branch}` : null, commit: SPEC_SOURCE.commit, sha256: SPEC_SOURCE.sha256 },
+      routes: used.map((route) => ({ route: `${route.method} ${route.path}`, pending: route.pending?.source ?? null }))
+    },
+    started_at: state.started_at,
+    finished_at: finishedAt,
+    runs: state.runs,
+    api_calls: state.api_calls,
+    options: state.options
+  };
+}
+
+// src/commands/export-common.ts
+function formatCount(n) {
+  return n.toLocaleString("en-US");
+}
+function countOf(n, singular, plural = `${singular}s`) {
+  return `${formatCount(n)} ${n === 1 ? singular : plural}`;
+}
+function finishExport(ctx, session, manifest, summary) {
+  const entry = session.complete(manifest);
+  ctx.out.result({ status: "complete", output_dir: session.dir, manifest_file: entry, manifest }, () => [
+    `Export complete: ${summary}.`,
+    `Manifest: ${session.path(entry.path)} (sha256 ${entry.sha256})`,
+    `Files: ${manifest.files.length} \xB7 API calls: ${manifest.api_calls.toLocaleString("en-US")}`
+  ]);
+}
+function withResumeHint(error, resumeCommand) {
+  const cliError = toCliError(error);
+  if (cliError.exitCode === ExitCode.USAGE || cliError.exitCode === ExitCode.EXISTS) return cliError;
+  const resume = `What was exported up to the last complete page is saved. To continue from there:
+  ${resumeCommand}`;
+  cliError.hint = cliError.hint ? `${cliError.hint}
+${resume}` : resume;
+  cliError.details.resume_command = resumeCommand;
+  return cliError;
+}
+
+// src/commands/contacts.ts
+var OPTION_NAMES = {
+  format: "format",
+  tag: "tag_ids",
+  tagMode: "tag_mode",
+  createdFrom: "created_from",
+  createdTo: "created_to",
+  onlyWithPhone: "only_with_phone",
+  tags: "with_tags",
+  customFields: "with_custom_fields"
+};
+var CONTACTS_FLAG_NAMES = Object.keys(OPTION_NAMES);
+var BASE_COLUMNS = [
+  "id",
+  "name",
+  "phone",
+  "email",
+  "whatsapp_id",
+  "whatsapp_username",
+  "country_code",
+  "status",
+  "created_at",
+  "device_id",
+  "adviser_id",
+  "active_conversation",
+  "unread_messages",
+  "favorite",
+  "lead_score",
+  "lead_score_category"
+];
+var PER_PAGE = 100;
+function normalize(flags) {
+  const format = (flags.format ?? "csv").toLowerCase();
+  if (format !== "csv" && format !== "jsonl") throw usageError(`--format must be csv or jsonl: ${flags.format}`);
+  const tagMode = flags.tagMode?.toLowerCase() ?? null;
+  if (tagMode !== null && !["any", "all", "exclude"].includes(tagMode)) throw usageError(`--tag-mode must be any, all or exclude: ${flags.tagMode}`);
+  const tagIds = idList(flags.tag, "--tag");
+  if (tagMode !== null && tagIds.length === 0) throw usageError("--tag-mode needs at least one --tag.");
+  if (Boolean(flags.createdFrom) !== Boolean(flags.createdTo)) {
+    throw usageError("--created-from and --created-to go together: the API needs both.", 'For "from a date until today", put today in --created-to.');
+  }
+  return {
+    format,
+    tag_ids: tagIds,
+    tag_mode: tagMode,
+    created_from: flags.createdFrom ? parseContactBound(flags.createdFrom, "--created-from") : null,
+    created_to: flags.createdTo ? parseContactBound(flags.createdTo, "--created-to") : null,
+    only_with_phone: flags.onlyWithPhone === true,
+    with_tags: flags.tags !== false,
+    with_custom_fields: flags.customFields !== false
+  };
+}
+function listQuery(options) {
+  return {
+    perPage: PER_PAGE,
+    orderBy: "id",
+    orderByMethod: "asc",
+    ...options.tag_ids.length ? { "tag_ids[]": options.tag_ids } : {},
+    ...options.tag_mode ? { tag_mode: options.tag_mode } : {},
+    ...options.created_from ? { created_from: options.created_from, created_to: options.created_to } : {},
+    ...options.only_with_phone ? { only_with_phone: true } : {}
+  };
+}
+async function contactsExport(ctx, flags, explicitFlags) {
+  const resume = flags.resume === true;
+  if (resume && !flags.outputDir) throw usageError("--resume needs the --output-dir of the export that was interrupted.");
+  const options = normalize(flags);
+  const { baseUrl } = ctx.credentials();
+  const client = ctx.client();
+  const dir = flags.outputDir ?? `funnelchat-contacts-export-${timestampForName(ctx.io.clock())}`;
+  const opened = ExportSession.open({
+    dir,
+    cwd: ctx.io.cwd,
+    kind: "contacts",
+    resume,
+    baseUrl,
+    options,
+    explicit: new Set([...explicitFlags].map((flag) => OPTION_NAMES[flag]).filter((name) => Boolean(name))),
+    initial: () => ({
+      state_version: 1,
+      kind: "contacts",
+      cli_version: VERSION,
+      base_url: baseUrl,
+      options,
+      started_at: new Date(ctx.io.clock()).toISOString(),
+      runs: 1,
+      api_calls: 0,
+      columns: null,
+      next: null,
+      done: false,
+      last_id: null,
+      file: { offset: 0, rows: 0 },
+      header_written: false,
+      api_total_at_start: null,
+      vanished: 0,
+      observed: { first_created_at: null, last_created_at: null }
+    })
+  });
+  if ("alreadyComplete" in opened) {
+    ctx.out.result({ status: "already_complete", manifest: opened.alreadyComplete }, () => `The export was already complete: ${opened.alreadyComplete}`);
+    return;
+  }
+  const session = opened.session;
+  const state = session.state;
+  const o = state.options;
+  const callsBefore = state.api_calls;
+  const countCalls = () => {
+    state.api_calls = callsBefore + client.requests;
+  };
+  const resumeCommand = `funnelchat contacts export --output-dir ${quote(dir)} --resume`;
+  const fileName = o.format === "csv" ? "contacts.csv" : "contacts.jsonl";
+  let file = null;
+  try {
+    ctx.out.progress(resume ? `Resuming the contacts export in ${session.dir}` : `Exporting contacts to ${session.dir}`);
+    if (o.format === "csv" && o.with_custom_fields && state.columns === null) {
+      const columns = [];
+      for await (const field of client.all(routes.customFieldsList, { query: { perPage: PER_PAGE, orderBy: "created_at", orderByMethod: "asc" } })) {
+        if (typeof field.id === "number") columns.push({ id: field.id, name: typeof field.name === "string" ? field.name : String(field.id) });
+      }
+      state.columns = columns;
+      countCalls();
+      session.save();
+    }
+    const opened2 = state.file.offset === 0 && !state.header_written ? PartFile.create(session.path(fileName)) : PartFile.resume(session.path(fileName), state.file);
+    let entry;
+    if (opened2 instanceof PartFile) {
+      file = opened2;
+      if (o.format === "csv" && !state.header_written) {
+        file.append(CSV_BOM + csvRow(csvHeader(o, state.columns ?? [])), 0);
+        file.sync();
+        state.header_written = true;
+        state.file = file.position;
+        session.save();
+      }
+      const baseQuery = listQuery(o);
+      while (!state.done) {
+        if (ctx.io.signal?.aborted) throw new InterruptedError();
+        const query = mergeNext(baseQuery, state.next ?? { page: 1 });
+        const page = await client.page(routes.contactsList, { query });
+        if (state.api_total_at_start === null) state.api_total_at_start = totalOf(page.body);
+        let text = "";
+        let rows = 0;
+        for (const contact of page.items) {
+          const id = typeof contact.id === "number" ? contact.id : Number(contact.id);
+          if (state.last_id !== null && id <= state.last_id) continue;
+          const enriched = await enrich(client, contact, id, o);
+          if (enriched === null) {
+            state.vanished++;
+          } else {
+            text += o.format === "csv" ? csvRow(csvValues(enriched, o, state.columns ?? [])) : `${JSON.stringify(enriched)}
+`;
+            rows++;
+            observe(state, contact.created_at);
+          }
+          state.last_id = state.last_id === null ? id : Math.max(state.last_id, id);
+        }
+        file.append(text, rows);
+        file.sync();
+        state.file = file.position;
+        state.next = page.next;
+        state.done = page.next === null;
+        countCalls();
+        session.save();
+        ctx.out.progress(`  contacts: ${formatCount(state.file.rows)}${state.api_total_at_start !== null ? ` of ${formatCount(state.api_total_at_start)}` : ""}`);
+      }
+      entry = file.finalize();
+      file = null;
+    } else {
+      entry = opened2;
+    }
+    const manifest = {
+      ...baseManifest(state, usedRoutes(o), new Date(ctx.io.clock()).toISOString()),
+      range: {
+        created_from: o.created_from,
+        created_to: o.created_to,
+        observed_first_created_at: state.observed.first_created_at,
+        observed_last_created_at: state.observed.last_created_at
+      },
+      counts: {
+        contacts: entry.rows,
+        ...state.api_total_at_start !== null ? { api_total_at_start: state.api_total_at_start } : {},
+        vanished_during_export: state.vanished
+      },
+      files: [entry],
+      notes: [
+        "Contacts ordered by ascending id, as GET /api/v1/contacts pages them (by page number).",
+        "If contacts are deleted during the export, paging by page number can skip some: compare counts.contacts with counts.api_total_at_start.",
+        ...o.with_tags ? ["Tags: GET /api/v1/contacts/{contact}/tags, one request per contact (the listing does not include them)."] : [],
+        ...o.with_custom_fields ? ["Custom fields: GET /api/v1/contacts/{contact}/custom-fields, one request per contact (the listing does not include them)."] : [],
+        ...o.format === "csv" ? ["CSV with a UTF-8 BOM and CRLF line endings. A cell that starts with =, +, - or @ (and is not a number) gets a ' in front so the spreadsheet does not run it as a formula."] : []
+      ]
+    };
+    finishExport(ctx, session, manifest, `${countOf(entry.rows, "contact")} in ${session.path(entry.path)}`);
+  } catch (error) {
+    throw withResumeHint(error, resumeCommand);
+  } finally {
+    file?.close();
+    session.release();
+  }
+}
+async function enrich(client, contact, id, o) {
+  try {
+    const tags = o.with_tags ? await all(client, routes.contactTags, id) : void 0;
+    const customFields = o.with_custom_fields ? await all(client, routes.contactCustomFields, id) : void 0;
+    return { ...contact, ...tags ? { tags } : {}, ...customFields ? { custom_fields: customFields } : {} };
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 404 && error.apiCode !== "route_not_found") return null;
+    throw error;
+  }
+}
+async function all(client, route, contact) {
+  const items = [];
+  for await (const item of client.all(route, { path: { contact }, query: { perPage: PER_PAGE } })) items.push(item);
+  return items;
+}
+function observe(state, createdAt) {
+  if (typeof createdAt !== "string" || createdAt === "") return;
+  const o = state.observed;
+  if (o.first_created_at === null || createdAt < o.first_created_at) o.first_created_at = createdAt;
+  if (o.last_created_at === null || createdAt > o.last_created_at) o.last_created_at = createdAt;
+}
+function csvHeader(o, columns) {
+  return [...BASE_COLUMNS, ...o.with_tags ? ["tags", "tag_ids"] : [], ...columns.map((c) => `custom_field:${c.name}`)];
+}
+function csvValues(contact, o, columns) {
+  const leadScore = isRecord(contact.lead_score) ? contact.lead_score : void 0;
+  const base = BASE_COLUMNS.map((column) => {
+    if (column === "lead_score") return leadScore?.score;
+    if (column === "lead_score_category") return leadScore?.category;
+    return contact[column];
+  });
+  const tags = Array.isArray(contact.tags) ? contact.tags : [];
+  const tagCells = o.with_tags ? [tags.map((t) => t.name).join("; "), tags.map((t) => t.id).join(";")] : [];
+  const fields = Array.isArray(contact.custom_fields) ? contact.custom_fields : [];
+  const fieldCells = columns.map((column) => {
+    const field = fields.find((f) => f.id === column.id) ?? fields.find((f) => f.name === column.name);
+    return field?.value;
+  });
+  return [...base, ...tagCells, ...fieldCells];
+}
+function usedRoutes(o) {
+  return [
+    routes.contactsList,
+    ...o.with_tags ? [routes.contactTags] : [],
+    ...o.with_custom_fields ? [routes.contactCustomFields] : [],
+    ...o.with_custom_fields && o.format === "csv" ? [routes.customFieldsList] : []
+  ];
+}
+
+// src/commands/conversations.ts
+import { readFileSync as readFileSync3, rmSync as rmSync4 } from "fs";
+var OPTION_NAMES2 = {
+  contact: "contact_ids",
+  device: "device_id",
+  since: "since",
+  partSize: "part_size"
+};
+var CONVERSATIONS_FLAG_NAMES = Object.keys(OPTION_NAMES2);
+var PER_PAGE2 = 100;
+var DEFAULT_PART_SIZE = 5e4;
+var CONVERSATIONS_FILE = "conversations.jsonl";
+function partName(index) {
+  return `messages-${String(index).padStart(5, "0")}.jsonl`;
+}
+function normalize2(flags) {
+  const contactIds = idList(flags.contact, "--contact");
+  const deviceId = flags.device ? positiveInt(flags.device, "--device") : null;
+  const partSize = flags.partSize ? positiveInt(flags.partSize, "--part-size") : DEFAULT_PART_SIZE;
+  return { contact_ids: contactIds, device_id: deviceId, since: flags.since ? parseSince(flags.since) : null, part_size: partSize };
+}
+async function conversationsExport(ctx, flags, explicitFlags) {
+  const resume = flags.resume === true;
+  if (resume && !flags.outputDir) throw usageError("--resume needs the --output-dir of the export that was interrupted.");
+  const options = normalize2(flags);
+  const { baseUrl } = ctx.credentials();
+  const client = ctx.client();
+  const dir = flags.outputDir ?? `funnelchat-conversations-export-${timestampForName(ctx.io.clock())}`;
+  const opened = ExportSession.open({
+    dir,
+    cwd: ctx.io.cwd,
+    kind: "conversations",
+    resume,
+    baseUrl,
+    options,
+    explicit: new Set([...explicitFlags].map((flag) => OPTION_NAMES2[flag]).filter((name) => Boolean(name))),
+    initial: () => ({
+      state_version: 1,
+      kind: "conversations",
+      cli_version: VERSION,
+      base_url: baseUrl,
+      options,
+      started_at: new Date(ctx.io.clock()).toISOString(),
+      runs: 1,
+      api_calls: 0,
+      phase: "list",
+      list: { next: null, done: false, contact_index: 0, file: { offset: 0, rows: 0 } },
+      conversations_file: null,
+      messages: { contact_index: 0, next: null, part_index: 1, part: { offset: 0, rows: 0 }, parts: [], total: 0 },
+      vanished_contacts: [],
+      observed: { first_message_time: null, last_message_time: null }
+    })
+  });
+  if ("alreadyComplete" in opened) {
+    ctx.out.result({ status: "already_complete", manifest: opened.alreadyComplete }, () => `The export was already complete: ${opened.alreadyComplete}`);
+    return;
+  }
+  const session = opened.session;
+  const state = session.state;
+  const o = state.options;
+  const callsBefore = state.api_calls;
+  const save = () => {
+    state.api_calls = callsBefore + client.requests;
+    session.save();
+  };
+  const checkAbort = () => {
+    if (ctx.io.signal?.aborted) throw new InterruptedError();
+  };
+  const resumeCommand = `funnelchat conversations export --output-dir ${quote(dir)} --resume`;
+  let file = null;
+  try {
+    ctx.out.progress(resume ? `Resuming the conversations export in ${session.dir}` : `Exporting conversations to ${session.dir}`);
+    if (state.phase === "list") {
+      const resumed = state.list.file.offset === 0 ? PartFile.create(session.path(CONVERSATIONS_FILE)) : PartFile.resume(session.path(CONVERSATIONS_FILE), state.list.file);
+      if (resumed instanceof PartFile) {
+        file = resumed;
+        const seen = new Set(readContactIds(file.partPath, state.list.file.offset));
+        if (o.contact_ids.length) {
+          for (let i = state.list.contact_index; i < o.contact_ids.length; i++) {
+            checkAbort();
+            const id = o.contact_ids[i];
+            const page = await client.page(routes.conversationsList, { query: { contactId: id, perPage: 1 } });
+            const conversation = page.items.find((item) => conversationContactId(item) === id);
+            if (!conversation) {
+              throw new CliError(`Contact ${id} does not exist in the account, or the key cannot see it.`, {
+                exitCode: ExitCode.NOT_FOUND,
+                code: "contact_not_found",
+                hint: "Check the id: it is the `id` of GET /api/v1/contacts."
+              });
+            }
+            if (!seen.has(id)) {
+              file.append(`${JSON.stringify(conversation)}
+`, 1);
+              seen.add(id);
+            }
+            file.sync();
+            state.list.file = file.position;
+            state.list.contact_index = i + 1;
+            save();
+          }
+          state.list.done = true;
+          save();
+        }
+        const baseQuery = {
+          perPage: PER_PAGE2,
+          orderBy: "asc",
+          ...o.device_id !== null ? { deviceId: o.device_id } : {},
+          ...o.since ? { updated_since: o.since } : {}
+        };
+        while (!state.list.done) {
+          checkAbort();
+          const query = state.list.next ? mergeNext(baseQuery, state.list.next) : baseQuery;
+          const page = await client.page(routes.conversationsList, { query });
+          let text = "";
+          let rows = 0;
+          for (const conversation of page.items) {
+            const id = conversationContactId(conversation);
+            if (!Number.isSafeInteger(id) || seen.has(id)) continue;
+            seen.add(id);
+            text += `${JSON.stringify(conversation)}
+`;
+            rows++;
+          }
+          file.append(text, rows);
+          file.sync();
+          state.list.file = file.position;
+          state.list.next = page.next;
+          state.list.done = page.next === null;
+          save();
+          ctx.out.progress(`  conversations: ${formatCount(state.list.file.rows)}`);
+        }
+        state.conversations_file = file.finalize();
+        file = null;
+      } else {
+        state.conversations_file = resumed;
+      }
+      state.phase = "messages";
+      save();
+    }
+    const conversationsFile = state.conversations_file;
+    const contactIds = readContactIds(session.path(conversationsFile.path));
+    const m = state.messages;
+    const rotate = () => {
+      if (!file) return;
+      m.parts.push(file.finalize());
+      file = null;
+      m.part_index++;
+      m.part = { offset: 0, rows: 0 };
+      save();
+    };
+    const currentPart = () => {
+      while (!file) {
+        const name = session.path(partName(m.part_index));
+        const reopened = m.part.offset === 0 ? PartFile.create(name) : PartFile.resume(name, m.part);
+        if (reopened instanceof PartFile) {
+          file = reopened;
+        } else {
+          m.parts.push(reopened);
+          m.part_index++;
+          m.part = { offset: 0, rows: 0 };
+          save();
+        }
+      }
+      return file;
+    };
+    if (m.part.offset > 0) currentPart();
+    if (file && file.rows >= o.part_size) rotate();
+    for (let i = m.contact_index; i < contactIds.length; i++) {
+      const contactId = contactIds[i];
+      let messages = 0;
+      for (; ; ) {
+        checkAbort();
+        const query = { perPage: PER_PAGE2, ...o.since ? { updated_since: o.since } : {}, ...m.next ?? {} };
+        let page;
+        try {
+          page = await client.page(routes.contactMessages, { path: { contactId }, query });
+        } catch (error) {
+          if (error instanceof ApiError && error.status === 404 && error.apiCode !== "route_not_found") {
+            state.vanished_contacts.push(contactId);
+            m.next = null;
+            break;
+          }
+          throw error;
+        }
+        const rows = o.device_id === null ? page.items : page.items.filter((message) => Number(message.device_id) === o.device_id);
+        if (rows.length) {
+          const part = currentPart();
+          part.append(rows.map((message) => `${JSON.stringify(message)}
+`).join(""), rows.length);
+          part.sync();
+          m.part = part.position;
+          for (const message of rows) observe2(state, message.time);
+        }
+        m.total += rows.length;
+        messages += rows.length;
+        m.next = page.next;
+        if (!page.next) m.contact_index = i + 1;
+        save();
+        if (file && file.rows >= o.part_size) rotate();
+        if (!page.next) break;
+      }
+      m.contact_index = i + 1;
+      m.next = null;
+      save();
+      ctx.out.progress(`  conversation ${formatCount(i + 1)} of ${formatCount(contactIds.length)} (contact ${contactId}): ${countOf(messages, "message")} \xB7 total ${formatCount(m.total)}`);
+    }
+    if (file) {
+      if (file.rows > 0) rotate();
+      else {
+        file.close();
+        rmSync4(file.partPath, { force: true });
+        file = null;
+      }
+    }
+    const manifest = {
+      ...baseManifest(state, [routes.conversationsList, routes.contactMessages], new Date(ctx.io.clock()).toISOString()),
+      range: {
+        since: o.since,
+        until: null,
+        observed_first_message_time: state.observed.first_message_time,
+        observed_last_message_time: state.observed.last_message_time
+      },
+      counts: {
+        conversations: contactIds.length,
+        messages: m.total,
+        message_parts: m.parts.length,
+        vanished_contacts: state.vanished_contacts.length
+      },
+      files: [conversationsFile, ...m.parts],
+      notes: [
+        "conversations.jsonl: one conversation per line, as GET /api/v1/conversations returns it (by contact_id, without repeats).",
+        "messages-NNNNN.jsonl: one message per line, as GET /api/v1/contacts/{contactId}/messages returns it; conversations in the order of conversations.jsonl and, within each one, from the newest message to the oldest (descending id, the API's order).",
+        ...o.since ? ['since is sent as updated_since: conversations and messages created or changed since that date. The API has no "until" filter.'] : [],
+        ...o.device_id !== null ? ["device_id picks the conversations on the API side (deviceId) and the messages on the CLI side: the API does not filter messages by number."] : [],
+        "observed_*_message_time: the time field of the messages, as the API returns it (YYYY-MM-DD HH:MM:SS, without a time zone)."
+      ]
+    };
+    finishExport(
+      ctx,
+      session,
+      manifest,
+      `${countOf(contactIds.length, "conversation")} and ${countOf(m.total, "message")} in ${countOf(m.parts.length, "part")}, in ${session.dir}`
+    );
+  } catch (error) {
+    throw withResumeHint(error, resumeCommand);
+  } finally {
+    file?.close();
+    session.release();
+  }
+}
+function conversationContactId(row) {
+  return Number(row.contact_id ?? row.id);
+}
+function readContactIds(path, limit) {
+  const content = readFileSync3(path).subarray(0, limit).toString("utf8");
+  const ids = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    if (line.trim() === "") continue;
+    const parsed = JSON.parse(line);
+    const id = isRecord(parsed) ? conversationContactId(parsed) : NaN;
+    if (Number.isSafeInteger(id)) ids.add(id);
+  }
+  return [...ids];
+}
+function observe2(state, time) {
+  if (typeof time !== "string" || time === "") return;
+  const o = state.observed;
+  if (o.first_message_time === null || time < o.first_message_time) o.first_message_time = time;
+  if (o.last_message_time === null || time > o.last_message_time) o.last_message_time = time;
+}
+
+// src/commands/mac.ts
+async function macStatus(ctx) {
+  const body = await ctx.client().get(routes.macStatus);
+  const status = isRecord(body) ? body : { value: body };
+  const n = (value) => typeof value === "number" ? value.toLocaleString("en-US") : "-";
+  const count = status.current_count ?? status.mac_count;
+  const limit = status.limit ?? status.cycle_capacity;
+  const remaining = status.remaining ?? status.total_available;
+  ctx.out.result({ mac: status }, () => [
+    `MACs in the period: ${n(count)} of ${n(limit)} (${n(status.usage_percentage)} %) \xB7 ${n(remaining)} left`,
+    `  state ${String(status.state ?? "-")} \xB7 cap enforcement ${status.enforcement_enabled === true ? "on" : status.enforcement_enabled === false ? "off" : "-"}`,
+    ...typeof status.inactive_contacts_count === "number" ? [`  contacts inactive by MAC: ${n(status.inactive_contacts_count)} (sends with a key to them get 429 mac_lockout_24h)`] : []
+  ]);
+}
+
+// src/commands/numbers.ts
+var OFFICIAL_PROVIDER = 2;
+var CAPABILITY_LABELS = {
+  contacts: "contacts",
+  conversations: "conversations",
+  templates: "templates",
+  health: "health and limit"
+};
+function capabilitiesOf(device) {
+  const official = Number(device.provider) === OFFICIAL_PROVIDER;
+  return ["contacts", "conversations", ...official ? ["templates", "health"] : []];
+}
+function connectionOf(device) {
+  return Number(device.provider) === OFFICIAL_PROVIDER ? "official" : "qr";
+}
+async function listDevices(ctx) {
+  const devices = [];
+  for await (const device of ctx.client().all(routes.devicesList, { query: { perPage: 100 } })) devices.push(device);
+  return devices;
+}
+async function numbersList(ctx) {
+  const devices = await listDevices(ctx);
+  const rows = devices.map((device) => ({
+    ...device,
+    connection: connectionOf(device),
+    cli_capabilities: capabilitiesOf(device)
+  }));
+  ctx.out.result(
+    { numbers: rows },
+    () => rows.length === 0 ? "The account has no numbers." : table(
+      ["id", "alias", "number", "connection", "connected", "health", "what the CLI reads"],
+      rows.map((d) => [
+        d.id,
+        d.alias,
+        d.number,
+        d.connection === "official" ? "official" : "QR",
+        Number(d.connected) === 1 ? "yes" : "no",
+        isRecord(d.health) ? String(d.health.state ?? "-") : null,
+        d.cli_capabilities.map((c) => CAPABILITY_LABELS[c]).join(", ")
+      ])
+    )
+  );
+}
+async function numbersHealth(ctx, ids) {
+  let targets;
+  const wanted = idList(ids, "number");
+  if (wanted.length) {
+    targets = wanted.map((id) => ({ id, label: String(id) }));
+  } else {
+    const devices = (await listDevices(ctx)).filter((d) => connectionOf(d) === "official");
+    targets = devices.map((d) => ({ id: Number(d.id), label: String(d.alias || d.number || d.id) }));
+    if (targets.length === 0) {
+      ctx.out.result({ numbers: [] }, () => "The account has no official numbers: health and limit exist only for the official WhatsApp API.");
+      return;
+    }
+  }
+  const results = [];
+  for (const target of targets) {
+    try {
+      const health = await ctx.client().get(routes.deviceHealth, { path: { device: target.id } });
+      results.push({ device_id: target.id, ...isRecord(health) ? health : { health } });
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 422 && error.apiCode === "device_not_meta") {
+        results.push({ device_id: target.id, error: "device_not_meta" });
+        continue;
+      }
+      throw error;
+    }
+  }
+  ctx.out.result(
+    { numbers: results },
+    () => table(
+      ["id", "state", "quality", "limit", "per day", "throughput", "updated", "stale"],
+      results.map((r) => {
+        if (r.error === "device_not_meta") return [r.device_id, "not an official number", null, null, null, null, null, null];
+        const h = isRecord(r.health) ? r.health : {};
+        return [
+          r.device_id,
+          str(h.state),
+          str(h.quality_level),
+          str(h.messaging_limit_tier),
+          h.messaging_limit_per_day === null || h.messaging_limit_per_day === void 0 ? "no limit reported" : Number(h.messaging_limit_per_day).toLocaleString("en-US"),
+          str(r.throughput_level),
+          str(h.last_fetched_at),
+          h.stale === true ? "yes" : h.stale === false ? "no" : null
+        ];
+      })
+    )
+  );
+}
+function str(value) {
+  return value === null || value === void 0 || value === "" ? null : String(value);
+}
+
+// src/commands/templates.ts
+var STATUSES = ["PENDING", "APPROVED", "REJECTED", "PENDING_DELETION", "PAUSED", "DISABLED", "ARCHIVED"];
+async function templatesList(ctx, flags) {
+  const status = flags.status?.toUpperCase();
+  if (status && !STATUSES.includes(status)) throw usageError(`--status must be one of ${STATUSES.join(", ")}: ${flags.status}`);
+  const query = {
+    perPage: 100,
+    ...flags.device ? { deviceId: positiveInt(flags.device, "--device") } : {},
+    ...status ? { status } : {}
+  };
+  const templates = [];
+  for await (const template of ctx.client().all(routes.templatesList, { query })) templates.push(template);
+  ctx.out.result(
+    { templates },
+    () => templates.length === 0 ? "No templates match those filters." : table(
+      ["id", "name", "language", "category", "status", "number"],
+      templates.map((t) => [t.id, t.name, t.language_code, t.category, t.status, t.device_id])
+    )
+  );
+}
+
+// src/main.ts
+var EXIT_CODES_HELP = `
+Exit codes:
+  0    all good
+  1    unexpected error
+  2    wrong usage (invalid option or value)
+  3    no key, a key the API rejects (401) or a missing permission (403)
+  4    not found in your account (404)
+  5    an API limit the CLI does not wait for (daily cap or a long Retry-After): it can be resumed
+  6    API or network error, after the retries
+  7    the output already exists: the CLI never overwrites a file
+  130  interrupted with Ctrl+C: an export can be resumed
+
+Environment variables:
+  FUNNELCHAT_API_KEY     the key (wins over the saved profile, except with --profile)
+  FUNNELCHAT_PROFILE     the profile to use
+  FUNNELCHAT_BASE_URL    the base URL
+  FUNNELCHAT_RATE        requests per second
+  FUNNELCHAT_CONFIG_DIR  where to keep the configuration
+
+The CLI only reads: it sends no messages and changes nothing in your account.`;
+async function run(argv, io) {
+  let exitCode = ExitCode.OK;
+  const program = new Command("funnelchat");
+  program.description("Export conversations and contacts from your Funnelchat account through the public API, and check your numbers, templates and MACs.").version(VERSION, "-V, --version", "Shows the version.").helpOption("-h, --help", "Shows the help.").helpCommand("help [command]", "Shows the help of a command.").option("--profile <name>", "Configuration profile to use.").option("--base-url <url>", "Base URL of the API (https://api.funnelchat.com by default).").option("--staging", "Uses the staging API (https://api-staging.funnelchat.com).").option("--json", "JSON output, for scripts.").option("-v, --verbose", "Shows every request to the API (never the key).").option("-q, --quiet", "No progress messages.").option("--rate <requests>", "Requests per second at most (1 by default).").option("--max-wait <seconds>", "How long to wait for a Retry-After on its own before stopping (60 by default).").addHelpText("after", EXIT_CODES_HELP).showSuggestionAfterError(true).exitOverride().configureOutput({
+    writeOut: (text) => io.stdout.write(text),
+    writeErr: (text) => io.stderr.write(text)
+  });
+  const action = (fn) => async (...args) => {
+    const command = args[args.length - 1];
+    const ctx = new Context(io, command.optsWithGlobals());
+    try {
+      await fn(ctx, command, ...args.slice(0, -1));
+      exitCode = ExitCode.OK;
+    } catch (error) {
+      exitCode = ctx.out.error(error);
+    }
+  };
+  program.command("login").description("Saves your API key in a profile (a file with 0600 permissions). Reads it from the keyboard without showing it, or from standard input.").option("--no-verify", "Does not check it against the API before saving it.").action(action((ctx, command) => login(ctx, command.opts())));
+  program.command("logout").description("Deletes the saved key of the active profile (or of --profile).").action(action((ctx) => logout(ctx)));
+  program.command("whoami").description("Shows which account the key belongs to, without showing the key.").action(action((ctx) => whoami(ctx)));
+  const profiles = program.command("profiles").description("Saved profiles.");
+  profiles.command("list", { isDefault: true }).description("Lists the profiles (never shows the keys).").action(action((ctx) => profilesList(ctx)));
+  profiles.command("use").argument("<name>", "Profile to activate.").description("Chooses the profile used by default.").action(action((ctx, _command, name) => profilesUse(ctx, name)));
+  const numbers = program.command("numbers").description("Your WhatsApp numbers.");
+  numbers.command("list").description("Lists the numbers, with their connection and what the CLI can export or read for each one.").action(action((ctx) => numbersList(ctx)));
+  numbers.command("health").argument("[numbers...]", "Ids of the numbers (all the official ones by default).").description("Health, quality, messaging limit and throughput of the official numbers.").action(action((ctx, _command, ids) => numbersHealth(ctx, ids ?? [])));
+  const contacts = program.command("contacts").description("Contacts.");
+  contacts.command("export").description("Exports the contacts with their tags and custom fields, as CSV or JSONL.").option("-o, --output-dir <dir>", "New or empty folder for the export (funnelchat-contacts-export-<date> by default).").option("--format <format>", "csv (default) or jsonl.").option("--tag <id>", "Only contacts with this tag (can be repeated or comma-separated).", collect).option("--tag-mode <mode>", "With several --tag: any (default), all or exclude (none of them).").option("--created-from <date>", "Created from this date (YYYY-MM-DD, the whole day). Goes with --created-to.").option("--created-to <date>", "Created up to this date (YYYY-MM-DD, the whole day). Goes with --created-from.").option("--only-with-phone", "Only contacts that can be messaged.").option("--no-tags", "Without tags (one request less per contact).").option("--no-custom-fields", "Without custom fields (one request less per contact).").option("--resume", "Resumes an interrupted export in --output-dir, from the last saved page.").action(
+    action((ctx, command) => contactsExport(ctx, command.opts(), explicitOptions(command, CONTACTS_FLAG_NAMES)))
+  );
+  const conversations = program.command("conversations").description("Conversations and their messages.");
+  conversations.command("export").description("Exports the messages of every conversation in JSONL parts, with a manifest.").option("-o, --output-dir <dir>", "New or empty folder for the export (funnelchat-conversations-export-<date> by default).").option("--contact <id>", "Only the conversation of this contact (can be repeated or comma-separated).", collect).option("--device <id>", "Only conversations of this number, and of them only its messages.").option("--since <date>", "Conversations and messages created or changed since this date (YYYY-MM-DD in UTC, or a date and time with a zone).").option("--part-size <messages>", `Messages per part (${DEFAULT_PART_SIZE.toLocaleString("en-US")} by default).`).option("--resume", "Resumes an interrupted export in --output-dir, from the last saved cursor.").action(
+    action(
+      (ctx, command) => conversationsExport(ctx, command.opts(), explicitOptions(command, CONVERSATIONS_FLAG_NAMES))
+    )
+  );
+  const templates = program.command("templates").description("WhatsApp templates.");
+  templates.command("list").description("Lists the templates, with their status and their number.").option("--device <id>", "Only those of this number.").option("--status <status>", "APPROVED, PENDING, REJECTED, PAUSED, DISABLED\u2026").action(action((ctx, command) => templatesList(ctx, command.opts())));
+  const mac = program.command("mac").description("Monthly active contacts (MACs).");
+  mac.command("status").description("How many MACs you have used in the period, the limit and how many are left.").action(action((ctx) => macStatus(ctx)));
+  for (const command of program.commands) {
+    command.exitOverride().configureOutput({ writeOut: (text) => io.stdout.write(text), writeErr: (text) => io.stderr.write(text) });
+    for (const sub of command.commands) {
+      sub.exitOverride().configureOutput({ writeOut: (text) => io.stdout.write(text), writeErr: (text) => io.stderr.write(text) });
+    }
+  }
+  try {
+    await program.parseAsync(argv, { from: "user" });
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      if (["commander.helpDisplayed", "commander.version", "commander.help"].includes(error.code)) return ExitCode.OK;
+      if (error.code === "commander.executeSubCommandAsync") return ExitCode.UNEXPECTED;
+      return ExitCode.USAGE;
+    }
+    throw error;
+  }
+  return exitCode;
+}
+
+// src/cli.ts
+var controller = new AbortController();
+var interrupted = false;
+process.on("SIGINT", () => {
+  if (interrupted) process.exit(130);
+  interrupted = true;
+  process.stderr.write("\nStopping\u2026 (Ctrl+C again to quit now)\n");
+  controller.abort();
+});
+if (typeof globalThis.fetch !== "function") {
+  process.stderr.write("error: this version of Node has no fetch. Use Node 18 or later.\n");
+  process.exit(1);
+}
+var code = await run(process.argv.slice(2), {
+  stdout: process.stdout,
+  stderr: process.stderr,
+  stdin: process.stdin,
+  env: process.env,
+  cwd: process.cwd(),
+  fetch: globalThis.fetch,
+  sleep: realSleep,
+  clock: Date.now,
+  signal: controller.signal
+});
+process.exitCode = code;
+//# sourceMappingURL=cli.js.map