postemi 0.0.0-stage → 1.0.0

package/dist/index.js

@@ -0,0 +1,2480 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_yargs = __toESM(require("yargs"));
+var import_helpers = require("yargs/helpers");
+
+// src/api.ts
+var import_crypto = require("crypto");
+
+// src/brand.ts
+var BRAND_ID = true ? "postemi" : "posty";
+var IS_POSTEMI = BRAND_ID === "postemi";
+var POSTY = {
+  name: "Posty",
+  cli: "posty",
+  envPrefix: "POSTY",
+  configDirName: ".posty",
+  defaultApiUrl: "https://posty.hu/api",
+  defaultAuthServer: "https://posty.hu/api",
+  clientName: "Posty CLI",
+  homepage: "https://posty.hu",
+  termsUrl: "https://posty.hu/aszf",
+  privacyUrl: "https://posty.hu/adatvedelem",
+  signupUrl: "https://posty.hu/regisztracio",
+  exampleTimezone: "Europe/Budapest",
+  exampleTimezoneCity: "Budapest",
+  tierList: "alap, pro, kreator or csapat",
+  basicPlanName: "Alap"
+};
+var POSTEMI = {
+  name: "Postemi",
+  cli: "postemi",
+  envPrefix: "POSTEMI",
+  configDirName: ".postemi",
+  // api.postemi.com serves the API at the root (its proxy adds /api), the
+  // same way api.posty.hu does.
+  defaultApiUrl: "https://api.postemi.com",
+  defaultAuthServer: "https://api.postemi.com",
+  clientName: "Postemi CLI",
+  homepage: "https://postemi.com",
+  termsUrl: "https://postemi.com/terms",
+  privacyUrl: "https://postemi.com/privacy",
+  signupUrl: "https://postemi.com/app/signup",
+  exampleTimezone: "Europe/London",
+  exampleTimezoneCity: "London",
+  tierList: "basic, pro, creator or team",
+  basicPlanName: "Basic"
+};
+var BRAND = IS_POSTEMI ? POSTEMI : POSTY;
+var envName = (name) => `${BRAND.envPrefix}_${name}`;
+function readEnv(name) {
+  const own = process.env[envName(name)];
+  if (own || !IS_POSTEMI) return own;
+  return process.env[`POSTY_${name}`];
+}
+function envSourceName(name) {
+  if (IS_POSTEMI && !process.env[envName(name)] && process.env[`POSTY_${name}`]) {
+    return `POSTY_${name}`;
+  }
+  return envName(name);
+}
+function writeEnv(name, value) {
+  process.env[envName(name)] = value;
+}
+var POSTEMI_TIER_ALIASES = {
+  basic: "alap",
+  team: "csapat"
+};
+function tierForApi(tier) {
+  var _a;
+  if (!IS_POSTEMI) return tier;
+  return (_a = POSTEMI_TIER_ALIASES[tier.trim().toLowerCase()]) != null ? _a : tier;
+}
+var NETWORK_REASONS = {
+  ENOTFOUND: "the host name does not resolve",
+  EAI_AGAIN: "the host name could not be looked up",
+  ECONNREFUSED: "the connection was refused",
+  ECONNRESET: "the connection was reset",
+  ETIMEDOUT: "the connection timed out",
+  UND_ERR_CONNECT_TIMEOUT: "the connection timed out",
+  CERT_HAS_EXPIRED: "the TLS certificate has expired",
+  DEPTH_ZERO_SELF_SIGNED_CERT: "the TLS certificate is self-signed"
+};
+function networkError(prefix, error, variable = "API_URL") {
+  var _a, _b, _c;
+  const plain = `${prefix}: ${error == null ? void 0 : error.message}`;
+  if (!IS_POSTEMI) return plain;
+  const code = (_b = (_a = error == null ? void 0 : error.cause) == null ? void 0 : _a.code) != null ? _b : error == null ? void 0 : error.code;
+  const reason = code ? (_c = NETWORK_REASONS[code]) != null ? _c : code : null;
+  return reason ? `${prefix}: ${reason} (${code}). Check the connection, or point ${envName(variable)} at another server.` : plain;
+}
+
+// src/api.ts
+function serverSentence(body) {
+  var _a, _b, _c;
+  const raw = (body != null ? body : "").trim();
+  let json = null;
+  try {
+    json = JSON.parse(raw);
+  } catch (e) {
+    return raw;
+  }
+  const pick = (value) => {
+    if (typeof value === "string" && value.trim()) return value.trim();
+    if (Array.isArray(value)) {
+      const parts = value.filter((part) => typeof part === "string" && part.trim());
+      return parts.length ? parts.join("; ") : null;
+    }
+    return null;
+  };
+  return (_c = (_b = (_a = pick(json == null ? void 0 : json.message)) != null ? _a : pick(json == null ? void 0 : json.msg)) != null ? _b : pick(json == null ? void 0 : json.detail)) != null ? _c : raw;
+}
+var ApiError = class extends Error {
+  constructor(status2, body) {
+    super(`API Error (${status2}): ${serverSentence(body)}`);
+    this.status = status2;
+    this.body = body;
+    this.name = "ApiError";
+  }
+  /** The credential itself was rejected (missing, unknown, expired). 401 only. */
+  get isAuthError() {
+    return this.status === 401;
+  }
+  /**
+   * A valid credential that is not allowed to do this: a scoped key on a
+   * route that needs a full-workspace one, a role below the payer, a closed
+   * registration. The body says which; the fix is never `auth:login`.
+   */
+  get isForbidden() {
+    return this.status === 403;
+  }
+  /** The body as JSON when it is JSON, else null. */
+  get json() {
+    try {
+      return JSON.parse(this.body);
+    } catch (e) {
+      return null;
+    }
+  }
+  /**
+   * The 403 of the scope guard: the credential is VALID and lacks a
+   * permission. Logging in again changes nothing; a key with the scope
+   * (or a higher role for its owner) does. Null for any other answer.
+   */
+  get missingScope() {
+    var _a, _b;
+    if (this.status !== 403) return null;
+    const body = this.json;
+    const msg = String((_b = (_a = body == null ? void 0 : body.msg) != null ? _a : body == null ? void 0 : body.message) != null ? _b : this.body);
+    if (!/missing the required permission/i.test(msg)) return null;
+    const required = Array.isArray(body == null ? void 0 : body.required) ? body.required : [];
+    const granted = Array.isArray(body == null ? void 0 : body.granted) ? body.granted : [];
+    const fromText = (msg.split(":")[1] || "").split(",").map((scope) => scope.trim()).filter(Boolean);
+    const missing = required.length ? required.filter((scope) => !granted.includes(scope)) : fromText;
+    return { missing, granted, role: body == null ? void 0 : body.role };
+  }
+  /**
+   * The 401 of the plan gate: the credential is valid, the workspace has no
+   * plan with API access. The billing commands still work.
+   */
+  get isPlanMissing() {
+    return this.status === 401 && /no subscription found|does not include api access|no plan with api access/i.test(
+      this.body
+    );
+  }
+  get isRateLimit() {
+    return this.status === 429;
+  }
+  /**
+   * The 403 a multi-workspace key gets when no workspace was named. Not an
+   * auth failure: the key is fine, the request is missing a choice, and the
+   * fix is `workspaces:use`, not `auth:login`.
+   */
+  get isWorkspaceChoice() {
+    return this.status === 403 && this.body.includes("spans several workspaces");
+  }
+};
+var PostyAPI = class {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.workspaceId = config.workspaceId;
+    this.apiUrl = config.apiUrl || BRAND.defaultApiUrl;
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.apiUrl}${endpoint}`;
+    const headers = __spreadValues(__spreadValues({
+      "Content-Type": "application/json",
+      Authorization: this.apiKey
+    }, this.workspaceHeader()), options.headers);
+    let response;
+    try {
+      response = await fetch(url, __spreadProps(__spreadValues({}, options), {
+        headers
+      }));
+    } catch (error) {
+      throw new Error(networkError(`Could not reach ${this.apiUrl}`, error));
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new ApiError(response.status, error);
+    }
+    return await response.json();
+  }
+  /**
+   * ONE IDEMPOTENCY KEY PER INVOCATION, REUSED ON ITS OWN RETRY.
+   *
+   * A timeout cannot tell a lost request from a lost answer, and resending a
+   * post blindly can publish it twice on a real account. So the post carries
+   * an `Idempotency-Key` (a fresh UUID for this command), and the one retry
+   * below, after a network failure or a 5xx, sends the SAME key: the server
+   * then hands back the post it already created instead of making another.
+   */
+  async createPost(data, idempotencyKey = (0, import_crypto.randomUUID)()) {
+    const send = () => this.request("/public/v1/posts", {
+      method: "POST",
+      body: JSON.stringify(data),
+      headers: { "Idempotency-Key": idempotencyKey }
+    });
+    try {
+      return await send();
+    } catch (error) {
+      const retryable = !(error instanceof ApiError) || [500, 502, 503, 504].includes(error.status);
+      if (!retryable) throw error;
+      await new Promise((resolve) => setTimeout(resolve, 1500));
+      return send();
+    }
+  }
+  async listPosts(filters = {}) {
+    const queryString = new URLSearchParams(
+      Object.entries(filters).reduce((acc, [key, value]) => {
+        if (value !== void 0 && value !== null) {
+          acc[key] = String(value);
+        }
+        return acc;
+      }, {})
+    ).toString();
+    const endpoint = queryString ? `/public/v1/posts?${queryString}` : "/public/v1/posts";
+    return this.request(endpoint, {
+      method: "GET"
+    });
+  }
+  /** One post (one channel) with its thread or comments. Other channels of its group stay. */
+  async deletePost(id) {
+    return this.request(`/public/v1/posts/${encodeURIComponent(id)}`, {
+      method: "DELETE"
+    });
+  }
+  /** The whole group: every channel of one multi-channel post. */
+  async deletePostGroup(group) {
+    return this.request(`/public/v1/posts/group/${encodeURIComponent(group)}`, {
+      method: "DELETE"
+    });
+  }
+  async findSlot(integrationId) {
+    return this.request(
+      `/public/v1/find-slot/${encodeURIComponent(integrationId)}`,
+      {
+        method: "GET"
+      }
+    );
+  }
+  async upload(file, filename) {
+    var _a;
+    const formData = new FormData();
+    const extension = ((_a = filename.split(".").pop()) == null ? void 0 : _a.toLowerCase()) || "";
+    const mimeTypes = {
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      webp: "image/webp",
+      avif: "image/avif",
+      bmp: "image/bmp",
+      tif: "image/tiff",
+      tiff: "image/tiff",
+      mp4: "video/mp4"
+    };
+    const type = mimeTypes[extension] || "application/octet-stream";
+    const blob = new Blob([new Uint8Array(file)], { type });
+    formData.append("file", blob, filename);
+    const url = `${this.apiUrl}/public/v1/upload`;
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        body: formData,
+        headers: __spreadValues({
+          Authorization: this.apiKey
+        }, this.workspaceHeader())
+      });
+    } catch (error) {
+      throw new Error(networkError(`Could not reach ${this.apiUrl}`, error));
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new ApiError(response.status, error);
+    }
+    return await response.json();
+  }
+  workspaceHeader() {
+    return this.workspaceId ? { showorg: this.workspaceId } : {};
+  }
+  async listWorkspaces() {
+    return await this.request("/public/v1/workspaces", {
+      method: "GET"
+    });
+  }
+  async getMissingContent(postId) {
+    return this.request(`/public/v1/posts/${postId}/missing`, {
+      method: "GET"
+    });
+  }
+  async updateReleaseId(postId, releaseId) {
+    return this.request(`/public/v1/posts/${postId}/release-id`, {
+      method: "PUT",
+      body: JSON.stringify({ releaseId })
+    });
+  }
+  async changePostStatus(postId, status2) {
+    return this.request(`/public/v1/posts/${postId}/status`, {
+      method: "PUT",
+      body: JSON.stringify({ status: status2 })
+    });
+  }
+  async getAnalytics(integrationId, date) {
+    return this.request(`/public/v1/analytics/${integrationId}?date=${encodeURIComponent(date)}`, {
+      method: "GET"
+    });
+  }
+  async getPostAnalytics(postId, date) {
+    return this.request(`/public/v1/analytics/post/${postId}?date=${encodeURIComponent(date)}`, {
+      method: "GET"
+    });
+  }
+  async listIntegrations(group) {
+    const query = group ? `?group=${encodeURIComponent(group)}` : "";
+    return this.request(`/public/v1/integrations${query}`, {
+      method: "GET"
+    });
+  }
+  async listGroups() {
+    return this.request("/public/v1/groups", {
+      method: "GET"
+    });
+  }
+  async getIntegrationSettings(integrationId) {
+    return this.request(`/public/v1/integration-settings/${integrationId}`, {
+      method: "GET"
+    });
+  }
+  async triggerIntegrationTool(integrationId, methodName, data) {
+    return this.request(`/public/v1/integration-trigger/${integrationId}`, {
+      method: "POST",
+      body: JSON.stringify({ methodName, data })
+    });
+  }
+  /**
+   * A browser upload link for a file this process does not hold. `upload`
+   * covers the file on disk; this covers the one on the person's phone.
+   */
+  async createUploadLink() {
+    return await this.request("/public/v1/upload-link", {
+      method: "POST",
+      body: JSON.stringify({})
+    });
+  }
+  async getUploadLinkFiles(id) {
+    return await this.request(
+      `/public/v1/upload-link/${encodeURIComponent(id)}`,
+      { method: "GET" }
+    );
+  }
+  /*
+    BILLING. These four answer without the plan gate on the server, so they
+    work for a workspace that has no subscription yet: they are how it gets
+    one. The checkout and the portal need an OAuth token or a full-workspace
+    key (the "whole workspace" box on the `auth:login` approval page);
+    a scoped key is refused with a sentence that says so.
+  */
+  async getPlans() {
+    return await this.request("/public/v1/plans", { method: "GET" });
+  }
+  async getSubscription() {
+    return await this.request("/public/v1/subscription", {
+      method: "GET"
+    });
+  }
+  /** Nothing is charged by this call; the person pays on the returned link. */
+  async createSubscriptionCheckout(tier, period) {
+    return await this.request("/public/v1/subscriptions/checkout", {
+      method: "POST",
+      body: JSON.stringify({ tier, period })
+    });
+  }
+  async getSubscriptionPortal() {
+    return await this.request("/public/v1/subscription/portal", {
+      method: "GET"
+    });
+  }
+  /*
+    FOTOAI (fotoai.hu). Generation with the key owner's OWN FotoAI account and
+    credits; the outputs are saved into this workspace's media library. A key
+    whose owner has not connected FotoAI gets 409 FOTOAI_NOT_CONNECTED with
+    `details.connect_url`, the page the person opens once. Needs media:write.
+  */
+  async fotoAiStatus() {
+    return this.request("/public/v1/fotoai/status", { method: "GET" });
+  }
+  async fotoAiModels(category) {
+    const query = category ? `?category=${encodeURIComponent(category)}` : "";
+    return this.request(`/public/v1/fotoai/models${query}`, { method: "GET" });
+  }
+  /** Spends nothing: the price, the balance and a quote_id valid 10 minutes. */
+  async fotoAiQuote(body) {
+    return this.request("/public/v1/fotoai/quote", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  /** SPENDS the key owner's FotoAI credits, at most the quoted price. */
+  async fotoAiGenerate(body) {
+    return this.request("/public/v1/fotoai/generations", {
+      method: "POST",
+      body: JSON.stringify(body)
+    });
+  }
+  async fotoAiGeneration(id) {
+    return this.request(`/public/v1/fotoai/generations/${encodeURIComponent(id)}`, {
+      method: "GET"
+    });
+  }
+  /** Imports any FotoAI generation of the key owner into the media library; repeatable. */
+  async fotoAiImport(id) {
+    return this.request(
+      `/public/v1/fotoai/generations/${encodeURIComponent(id)}/import`,
+      { method: "POST" }
+    );
+  }
+};
+
+// src/commands/auth.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_os2 = require("os");
+var import_readline = require("readline");
+
+// src/settings.ts
+var import_fs = require("fs");
+var import_path = require("path");
+var import_os = require("os");
+var SETTINGS_DIR = (0, import_path.join)((0, import_os.homedir)(), BRAND.configDirName);
+var SETTINGS_FILE = (0, import_path.join)(SETTINGS_DIR, "config.json");
+var KNOWN_SETTINGS = ["timezone", "workspace"];
+function settingsFilePath() {
+  return SETTINGS_FILE;
+}
+function loadSettings() {
+  try {
+    if (!(0, import_fs.existsSync)(SETTINGS_FILE)) return {};
+    const data = JSON.parse((0, import_fs.readFileSync)(SETTINGS_FILE, "utf-8"));
+    return data && typeof data === "object" ? data : {};
+  } catch (e) {
+    return {};
+  }
+}
+function getSetting(key) {
+  const value = loadSettings()[key];
+  return typeof value === "string" && value ? value : void 0;
+}
+function saveSetting(key, value) {
+  if (!(0, import_fs.existsSync)(SETTINGS_DIR)) {
+    (0, import_fs.mkdirSync)(SETTINGS_DIR, { recursive: true, mode: 448 });
+  }
+  const settings = loadSettings();
+  settings[key] = value;
+  (0, import_fs.writeFileSync)(SETTINGS_FILE, JSON.stringify(settings, null, 2) + "\n", {
+    encoding: "utf-8"
+  });
+}
+
+// src/output.ts
+function result(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function status(message) {
+  console.error(message);
+}
+function fail(context, error) {
+  console.error(`\u274C ${context}: ${(error == null ? void 0 : error.message) || error}`);
+  if (error instanceof ApiError && error.isWorkspaceChoice) {
+    console.error(
+      `This key spans several workspaces and none is selected. Run "${BRAND.cli} workspaces:list", then "${BRAND.cli} workspaces:use <id>" (or pass --workspace <id>).`
+    );
+  } else if (error instanceof ApiError && error.missingScope) {
+    const { missing, role } = error.missingScope;
+    console.error(
+      `This key is valid but lacks the permission ${missing.join(", ") || "this command needs"}${role ? ` (the key owner's role: ${role})` : ""}. Create a key that includes it in ${BRAND.name} (Settings, Developers), or ask a workspace owner.`
+    );
+  } else if (error instanceof ApiError && error.isPlanMissing) {
+    console.error(
+      `The credential is valid, but this workspace has no plan with API access yet. Run "${BRAND.cli} billing:plans", then "${BRAND.cli} billing:subscribe --tier <slug> --period <monthly|yearly>".`
+    );
+  } else if (error instanceof ApiError && error.isForbidden) {
+    console.error(
+      "The credential is valid but not allowed to do this. The message above says why."
+    );
+  } else if (error instanceof ApiError && error.isAuthError) {
+    console.error(
+      `Your credentials were rejected. Run "${BRAND.cli} auth:login" to re-authenticate, or check ${envName("API_KEY")}.`
+    );
+  }
+  if (error instanceof ApiError && error.isRateLimit) {
+    console.error(
+      "Rate limit hit (per key, per route, per hour). Back off \u2014 do not retry in a loop."
+    );
+  }
+  process.exit(1);
+}
+
+// src/dates.ts
+var HAS_DESIGNATOR = /(Z|[+-]\d{2}:?\d{2})$/i;
+var NAIVE_SHAPE = /^(\d{4})-(\d{2})-(\d{2})([T ](\d{2}):(\d{2})(:(\d{2}))?)?$/;
+var OFFSET_SHAPED = /^(Etc\/)?(UTC|GMT)?\s*[+-]?\d/i;
+function assertIanaTimezone(name, origin) {
+  const value = name.trim();
+  if (!value || OFFSET_SHAPED.test(value)) {
+    throw new Error(
+      `Invalid timezone "${name}" (from ${origin}): numeric offsets are not accepted as timezones \u2014 DST would be your problem to compute. Use an IANA name like "${BRAND.exampleTimezone}" (or put the offset inside the date string itself, e.g. "2026-12-31T12:00:00+01:00").`
+    );
+  }
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: value });
+  } catch (e) {
+    throw new Error(
+      `Unknown timezone "${name}" (from ${origin}). Use an IANA name like "${BRAND.exampleTimezone}" or "UTC".`
+    );
+  }
+  return value;
+}
+function resolveTimezone(flagValue) {
+  if (flagValue !== void 0) {
+    return {
+      name: assertIanaTimezone(flagValue, "--timezone"),
+      source: "--timezone"
+    };
+  }
+  const env = readEnv("TIMEZONE");
+  if (env) {
+    return {
+      name: assertIanaTimezone(env, envName("TIMEZONE")),
+      source: envName("TIMEZONE")
+    };
+  }
+  const stored = getSetting("timezone");
+  if (stored) {
+    return {
+      name: assertIanaTimezone(stored, `~/${BRAND.configDirName}/config.json`),
+      source: `config (${BRAND.cli} config:set timezone)`
+    };
+  }
+  return null;
+}
+function tzOffsetMinutes(instant, timeZone) {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  }).formatToParts(instant);
+  const get = (type) => {
+    var _a;
+    return Number((_a = parts.find((p) => p.type === type)) == null ? void 0 : _a.value);
+  };
+  const asUtc = Date.UTC(
+    get("year"),
+    get("month") - 1,
+    get("day"),
+    get("hour") % 24,
+    get("minute"),
+    get("second")
+  );
+  return Math.round((asUtc - instant.getTime()) / 6e4);
+}
+function zonedToUtc(y, mo, d, h, mi, s, timeZone) {
+  const guess = Date.UTC(y, mo - 1, d, h, mi, s);
+  let offset = tzOffsetMinutes(new Date(guess), timeZone);
+  let instant = guess - offset * 6e4;
+  const refined = tzOffsetMinutes(new Date(instant), timeZone);
+  if (refined !== offset) {
+    instant = guess - refined * 6e4;
+  }
+  return new Date(instant);
+}
+function naiveDateError(input, flagName) {
+  return new Error(
+    `Date "${input}" has no timezone, and no timezone is configured. The server would read it as UTC, silently shifting your post. Fix one of:
+  1. Explicit offset in the date:  ${flagName} "2026-12-31T12:00:00+01:00"  (or ...T12:00:00Z for UTC)
+  2. Timezone flag:                --timezone ${BRAND.exampleTimezone}
+  3. Environment variable:         export ${envName("TIMEZONE")}=${BRAND.exampleTimezone}
+  4. Save it once:                 ${BRAND.cli} config:set timezone ${BRAND.exampleTimezone}`
+  );
+}
+function resolveDateInput(input, timezone, flagName = "--date") {
+  var _a, _b, _c;
+  const value = input.trim();
+  if (HAS_DESIGNATOR.test(value)) {
+    const parsed = new Date(value);
+    if (isNaN(parsed.getTime())) {
+      throw new Error(
+        `Invalid date "${input}". Use ISO 8601, e.g. "2026-12-31T12:00:00Z" or "2026-12-31T12:00:00+01:00".`
+      );
+    }
+    return { iso: parsed.toISOString(), appliedTimezone: null };
+  }
+  const m = NAIVE_SHAPE.exec(value);
+  if (!m) {
+    throw new Error(
+      `Invalid date "${input}". Use ISO 8601 with an explicit offset ("2026-12-31T12:00:00Z"), or "YYYY-MM-DD HH:mm" together with a timezone (--timezone ${BRAND.exampleTimezone}).`
+    );
+  }
+  if (!timezone) {
+    throw naiveDateError(input, flagName);
+  }
+  const instant = zonedToUtc(
+    Number(m[1]),
+    Number(m[2]),
+    Number(m[3]),
+    Number((_a = m[5]) != null ? _a : 0),
+    Number((_b = m[6]) != null ? _b : 0),
+    Number((_c = m[8]) != null ? _c : 0),
+    timezone.name
+  );
+  if (isNaN(instant.getTime())) {
+    throw new Error(`Invalid date "${input}".`);
+  }
+  return { iso: instant.toISOString(), appliedTimezone: timezone };
+}
+
+// src/commands/auth.ts
+var CREDENTIALS_DIR = (0, import_path2.join)((0, import_os2.homedir)(), BRAND.configDirName);
+var CREDENTIALS_FILE = (0, import_path2.join)(CREDENTIALS_DIR, "credentials.json");
+var DEFAULT_AUTH_SERVER = BRAND.defaultAuthServer;
+var DEFAULT_API_URL = BRAND.defaultApiUrl;
+function loadCredentials() {
+  try {
+    if (!(0, import_fs2.existsSync)(CREDENTIALS_FILE)) return null;
+    const data = JSON.parse((0, import_fs2.readFileSync)(CREDENTIALS_FILE, "utf-8"));
+    if (!data.accessToken) return null;
+    return data;
+  } catch (e) {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  if (!(0, import_fs2.existsSync)(CREDENTIALS_DIR)) {
+    (0, import_fs2.mkdirSync)(CREDENTIALS_DIR, { recursive: true, mode: 448 });
+  }
+  (0, import_fs2.writeFileSync)(CREDENTIALS_FILE, JSON.stringify(credentials, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs2.chmodSync)(CREDENTIALS_FILE, 384);
+}
+function deleteCredentials() {
+  if ((0, import_fs2.existsSync)(CREDENTIALS_FILE)) {
+    (0, import_fs2.unlinkSync)(CREDENTIALS_FILE);
+  }
+}
+function openBrowser(url) {
+  const { spawn } = require("child_process");
+  const opts = { stdio: "ignore", detached: true };
+  const child = process.platform === "darwin" ? spawn("open", [url], opts) : process.platform === "win32" ? spawn("cmd", ["/c", "start", "", url], opts) : spawn("xdg-open", [url], opts);
+  child.on("error", () => {
+  });
+  child.unref();
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function ask(question) {
+  const rl = (0, import_readline.createInterface)({ input: process.stdin, output: process.stderr });
+  return new Promise(
+    (resolve) => rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer);
+    })
+  );
+}
+async function maybeConfigureTimezone() {
+  if (getSetting("timezone")) return;
+  if (!process.stdin.isTTY || !process.stderr.isTTY) return;
+  const detected = Intl.DateTimeFormat().resolvedOptions().timeZone;
+  const answer = (await ask(`
+Scheduling timezone: ${detected} \u2014 OK? [Y/n] `)).trim().toLowerCase();
+  let timezone = detected;
+  if (answer === "n" || answer === "no") {
+    const typed = (await ask(`Enter an IANA timezone name (e.g. ${BRAND.exampleTimezone}), or leave empty to skip: `)).trim();
+    if (!typed) {
+      console.error(
+        `Skipped. Dates without an explicit offset will be refused until you run: ${BRAND.cli} config:set timezone <IANA name>`
+      );
+      return;
+    }
+    try {
+      timezone = assertIanaTimezone(typed, "auth:login");
+    } catch (error) {
+      console.error(error.message);
+      console.error(
+        `Skipped. Set it later with: ${BRAND.cli} config:set timezone <IANA name>`
+      );
+      return;
+    }
+  } else if (answer && answer !== "y" && answer !== "yes") {
+    console.error(
+      `Skipped. Set it later with: ${BRAND.cli} config:set timezone <IANA name>`
+    );
+    return;
+  }
+  saveSetting("timezone", timezone);
+  console.error(
+    `\u2705 Scheduling timezone saved: ${timezone} (change it with "${BRAND.cli} config:set timezone <IANA name>")`
+  );
+}
+async function chooseWorkspace(creds) {
+  let workspaces;
+  try {
+    workspaces = await new PostyAPI({
+      apiKey: creds.accessToken,
+      apiUrl: creds.apiUrl
+    }).listWorkspaces();
+  } catch (e) {
+    return;
+  }
+  if (workspaces.length === 1) {
+    saveCredentials(__spreadProps(__spreadValues({}, creds), { organizationId: workspaces[0].id }));
+    console.error(`\u{1F3E2} Workspace: ${workspaces[0].name}`);
+    return;
+  }
+  if (workspaces.length < 2) return;
+  console.error("\nThis key reaches several workspaces:");
+  workspaces.forEach((w, i) => console.error(`  ${i + 1}. ${w.name}  (${w.id})`));
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    console.error(
+      `Pick one with: ${BRAND.cli} workspaces:use <id>   (or pass --workspace <id> on each command)`
+    );
+    return;
+  }
+  const answer = (await ask(`Work in which one? [1-${workspaces.length}] `)).trim();
+  const index = Number(answer) - 1;
+  const chosen = workspaces[index];
+  if (!chosen) {
+    console.error(`Skipped. Pick one later with: ${BRAND.cli} workspaces:use <id>`);
+    return;
+  }
+  saveCredentials(__spreadProps(__spreadValues({}, creds), { organizationId: chosen.id }));
+  console.error(`\u2705 Workspace: ${chosen.name} (change it with "${BRAND.cli} workspaces:use <id>")`);
+}
+async function authLogin(argv) {
+  const authServer = argv.authServer || readEnv("AUTH_SERVER") || DEFAULT_AUTH_SERVER;
+  console.log("\u{1F510} Starting device authorization flow...\n");
+  let deviceCode;
+  let userCode;
+  let verificationUri;
+  let expiresIn;
+  let interval;
+  try {
+    const response = await fetch(`${authServer}/device/code`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      // Shown on the approval page, so somebody can tell the login they just
+      // started from one they did not.
+      body: JSON.stringify(__spreadValues({
+        client_name: readEnv("CLIENT_NAME") || BRAND.clientName
+      }, IS_POSTEMI ? { brand: "postemi" } : {}))
+    });
+    if (!response.ok) {
+      const error = await response.text();
+      console.error(`\u274C Failed to start authorization (${response.status}): ${error}`);
+      process.exit(1);
+    }
+    const data = await response.json();
+    deviceCode = data.device_code;
+    userCode = data.user_code;
+    verificationUri = data.verification_uri;
+    expiresIn = data.expires_in;
+    interval = data.interval || 5;
+  } catch (error) {
+    console.error(`\u274C ${networkError(`Could not reach auth server at ${authServer}`, error, "AUTH_SERVER")}`);
+    process.exit(1);
+  }
+  console.log("  Your authorization code:\n");
+  console.log(`    \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510`);
+  console.log(`    \u2502    ${userCode}    \u2502`);
+  console.log(`    \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+`);
+  console.log(`  Open this URL and enter the code above:`);
+  console.log(`  ${verificationUri}
+`);
+  openBrowser(`${verificationUri}?code=${encodeURIComponent(userCode)}`);
+  console.log("  Waiting for authorization...\n");
+  const deadline = Date.now() + expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    try {
+      const response = await fetch(`${authServer}/device/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ device_code: deviceCode })
+      });
+      const data = await response.json();
+      if (response.ok && data.access_token) {
+        const creds = {
+          accessToken: data.access_token,
+          /*
+            Posty stores the API base the server names. The Postemi build
+            stores the host it logged in on (api.postemi.com): the server
+            names Posty's base for every brand, and the Postemi host is what
+            makes the API answer as Postemi.
+          */
+          apiUrl: IS_POSTEMI ? String(authServer).replace(/\/+$/, "") : data.api_url || DEFAULT_API_URL,
+          organizationId: data.organization_id
+        };
+        saveCredentials(creds);
+        console.log("\u2705 Successfully authenticated!");
+        console.log(`\u{1F4C1} Credentials saved to ${CREDENTIALS_FILE}`);
+        await chooseWorkspace(creds);
+        await maybeConfigureTimezone();
+        return;
+      }
+      if (data.error === "authorization_pending") {
+        continue;
+      }
+      if (data.error === "expired_token") {
+        console.error("\u274C Authorization expired. Please try again.");
+        process.exit(1);
+      }
+      console.error(`\u274C Authorization failed: ${data.error}`);
+      process.exit(1);
+    } catch (e) {
+      continue;
+    }
+  }
+  console.error("\u274C Authorization timed out. Please try again.");
+  process.exit(1);
+}
+var TERMS_URL = BRAND.termsUrl;
+var PRIVACY_URL = BRAND.privacyUrl;
+async function signupRequest(apiUrl, path, body) {
+  const response = await fetch(`${apiUrl}/public/v1${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const text = await response.text();
+  let data = text;
+  try {
+    data = JSON.parse(text);
+  } catch (e) {
+  }
+  return { status: response.status, data };
+}
+function shellWord(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function signupTimezone(argv) {
+  const chosen = argv.timezone || getSetting("timezone");
+  if (chosen) return String(chosen);
+  try {
+    return Intl.DateTimeFormat().resolvedOptions().timeZone || void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function refusal(data) {
+  var _a;
+  if (typeof data === "string") return data;
+  const message = (_a = data == null ? void 0 : data.msg) != null ? _a : data == null ? void 0 : data.message;
+  return Array.isArray(message) ? message.join("; ") : String(message != null ? message : JSON.stringify(data));
+}
+async function authSignup(argv) {
+  const email = String(argv.email || "").trim();
+  const apiUrl = String(
+    argv.apiUrl || readEnv("API_URL") || DEFAULT_API_URL
+  ).replace(/\/+$/, "");
+  const language = argv.language ? String(argv.language) : void 0;
+  const timezone = signupTimezone(argv);
+  const interactive = !!process.stdin.isTTY && !!process.stderr.isTTY;
+  if (!email.includes("@")) {
+    console.error("\u274C Give the e-mail address of the new account with --email.");
+    process.exit(1);
+  }
+  let code = argv.code ? String(argv.code).trim() : "";
+  try {
+    if (!code) {
+      const started = await signupRequest(apiUrl, "/signup/start", __spreadValues({
+        email
+      }, language ? { language } : {}));
+      if (started.status !== 202 && started.status !== 200) {
+        console.error(
+          `\u274C Could not send the code (HTTP ${started.status}): ${refusal(started.data)}`
+        );
+        process.exit(1);
+      }
+      status(`\u{1F4E7} A six-digit code was sent to ${email}. It is valid for 10 minutes.`);
+      status("   Accounts created this way have no free trial; a plan is chosen and paid for next.");
+      if (!interactive) {
+        const nextCommand = [
+          `${BRAND.cli} auth:signup`,
+          `--email ${shellWord(email)}`,
+          "--code <code>",
+          "--accept-terms",
+          ...argv.apiUrl ? [`--api-url ${shellWord(apiUrl)}`] : [],
+          ...language ? [`--language ${language}`] : [],
+          ...argv.workspaceName ? [`--workspace-name ${shellWord(String(argv.workspaceName))}`] : [],
+          ...timezone ? [`--timezone ${shellWord(timezone)}`] : []
+        ].join(" ");
+        result({
+          codeSent: true,
+          email,
+          trial: false,
+          terms: TERMS_URL,
+          privacy: PRIVACY_URL,
+          timezone: timezone != null ? timezone : null,
+          language: language != null ? language : null,
+          next: `Ask the person for the code, show them ${TERMS_URL} and ${PRIVACY_URL}, and when they agree run: ${nextCommand}`
+        });
+        return;
+      }
+      code = (await ask("Code from the e-mail: ")).trim();
+      if (!code) {
+        console.error("\u274C No code given. Run the command again with --code <code>.");
+        process.exit(1);
+      }
+    }
+    if (!/^[0-9]{6}$/.test(code)) {
+      console.error("\u274C The code is the six digits from the e-mail.");
+      process.exit(1);
+    }
+    status("");
+    status("To create the account the person must agree to:");
+    status(`  Terms of service:  ${TERMS_URL}`);
+    status(`  Privacy notice:    ${PRIVACY_URL}`);
+    let accepted = !!argv.acceptTerms;
+    if (!accepted && interactive) {
+      const answer = (await ask("Do you agree to both? [y/N] ")).trim().toLowerCase();
+      accepted = answer === "y" || answer === "yes" || answer === "i" || answer === "igen";
+    }
+    if (!accepted) {
+      console.error(
+        "\u274C No account was created: the terms were not accepted. Show the person the two links above; if they agree, run the command again with --accept-terms."
+      );
+      process.exit(1);
+    }
+    const completed = await signupRequest(apiUrl, "/signup/complete", __spreadValues(__spreadValues(__spreadValues({
+      email,
+      code,
+      acceptTerms: true
+    }, argv.workspaceName ? { workspaceName: String(argv.workspaceName) } : {}), timezone ? { timezone: String(timezone) } : {}), language ? { language } : {}));
+    if (completed.status === 409) {
+      console.error(`\u274C ${refusal(completed.data)}`);
+      console.error(`   Sign in instead: ${BRAND.cli} auth:login`);
+      process.exit(1);
+    }
+    if (completed.status !== 201 && completed.status !== 200) {
+      console.error(
+        `\u274C The account was not created (HTTP ${completed.status}): ${refusal(completed.data)}`
+      );
+      process.exit(1);
+    }
+    const data = completed.data || {};
+    if (!data.apiKey) {
+      console.error(`\u274C The server answered without a key. Sign in with: ${BRAND.cli} auth:login`);
+      process.exit(1);
+    }
+    if (loadCredentials()) {
+      status("\u2139\uFE0F  The credentials stored before are replaced by the new account's key.");
+    }
+    saveCredentials({
+      accessToken: data.apiKey,
+      apiUrl,
+      organizationId: data.workspaceId
+    });
+    status(`\u2705 Account created. Workspace: ${data.workspaceName}`);
+    status(`\u{1F4C1} Key saved to ${CREDENTIALS_FILE}`);
+    status("");
+    status("No free trial on this account. Next:");
+    status(`  ${BRAND.cli} billing:plans`);
+    status(`  ${BRAND.cli} billing:subscribe --tier <slug> --period <monthly|yearly>`);
+    status(`The person opens the checkout link and pays. This key then works for every command only on a plan with API access (apiAndMcpAccess: true in billing:plans); ${BRAND.basicPlanName} has none, so say so before the person picks it.`);
+    result({
+      created: true,
+      workspaceId: data.workspaceId,
+      workspaceName: data.workspaceName,
+      trial: false,
+      credentials: CREDENTIALS_FILE,
+      next: [
+        `${BRAND.cli} billing:plans`,
+        `${BRAND.cli} billing:subscribe --tier <slug> --period <monthly|yearly>`,
+        `${BRAND.cli} billing:status`
+      ],
+      note: `This key keeps working after the payment only on a plan with apiAndMcpAccess: true in billing:plans. ${BRAND.basicPlanName} has no API access: tell the person before they pay for it.`
+    });
+  } catch (error) {
+    console.error(`\u274C ${networkError(`Could not reach the ${BRAND.name} API at ${apiUrl}`, error)}`);
+    process.exit(1);
+  }
+}
+async function authLogout() {
+  const creds = loadCredentials();
+  if (!creds) {
+    console.log("\u2139\uFE0F  No stored credentials found.");
+    return;
+  }
+  deleteCredentials();
+  console.log("\u2705 Credentials removed.");
+}
+async function authStatus() {
+  var _a;
+  const envKey = readEnv("API_KEY");
+  const creds = loadCredentials();
+  const hint = (token) => `${token.split("_")[0]}_\u2026`;
+  const methodOf = (token) => token.startsWith("pos_") ? "oauth2" : "api-key";
+  const label = (m) => m === "oauth2" ? "OAuth token" : "API key";
+  let apiKey;
+  let apiUrl;
+  let method;
+  let source;
+  if (creds) {
+    method = methodOf(creds.accessToken);
+    source = "credentials-file";
+    apiKey = creds.accessToken;
+    apiUrl = creds.apiUrl;
+    status(`\u{1F510} Authentication method: ${label(method)} (stored by auth:login or auth:signup)`);
+    status(`\u{1F4E1} API URL: ${creds.apiUrl}`);
+    status(`\u{1F511} Credential: ${hint(creds.accessToken)}`);
+    if (creds.organizationId) {
+      status(`\u{1F3E2} Workspace: ${creds.organizationId}`);
+    }
+    status(`\u{1F4C1} Credentials file: ${CREDENTIALS_FILE}`);
+  } else if (envKey) {
+    method = methodOf(envKey);
+    source = "environment";
+    apiKey = envKey;
+    apiUrl = readEnv("API_URL") || DEFAULT_API_URL;
+    status(`\u{1F511} Authentication method: ${label(method)} (${envSourceName("API_KEY")})`);
+    status(`\u{1F511} Credential: ${hint(envKey)}`);
+  } else {
+    status("\u274C Not authenticated.");
+    status("");
+    status("Options:");
+    status(`  1. Device login: ${BRAND.cli} auth:login`);
+    status(`  2. New account: ${BRAND.cli} auth:signup --email <address>`);
+    status(`  3. API Key: export ${envName("API_KEY")}=your_api_key`);
+    result({ authenticated: false, reason: "no-credentials" });
+    process.exit(1);
+  }
+  status("");
+  status("\u{1F504} Verifying credentials...");
+  const workspaceId = getWorkspaceId();
+  const base = { method, source, apiUrl, workspace: workspaceId != null ? workspaceId : null };
+  let subscription;
+  try {
+    subscription = await new PostyAPI({
+      apiKey,
+      apiUrl,
+      workspaceId
+    }).getSubscription();
+  } catch (error) {
+    if (error instanceof ApiError && error.isWorkspaceChoice) {
+      status("\u2705 Credentials are valid, but this key spans several workspaces and none is selected.");
+      status(`   Run: ${BRAND.cli} workspaces:list, then ${BRAND.cli} workspaces:use <id>`);
+      result(__spreadProps(__spreadValues({ authenticated: true }, base), { reason: "choose-workspace" }));
+      process.exit(1);
+    }
+    if (error instanceof ApiError && error.status === 401) {
+      status("\u274C Credentials are expired or invalid. Please re-authenticate.");
+      status(
+        creds ? `   Run: ${BRAND.cli} auth:login` : `   Update your ${envName("API_KEY")} environment variable.`
+      );
+      result(__spreadProps(__spreadValues({ authenticated: false }, base), { reason: "rejected" }));
+      process.exit(1);
+    }
+    if (error instanceof ApiError) {
+      status(`\u26A0\uFE0F  Could not verify credentials (HTTP ${error.status}): ${serverSentence(error.body)}`);
+      result(__spreadProps(__spreadValues({ authenticated: null }, base), { reason: `http-${error.status}` }));
+      process.exit(1);
+    }
+    status(`\u26A0\uFE0F  Could not reach API to verify credentials: ${error.message}`);
+    result(__spreadProps(__spreadValues({ authenticated: null }, base), { reason: "unreachable" }));
+    process.exit(1);
+  }
+  if (!subscription.apiAndMcpAccess) {
+    const noPlan = subscription.state === "none" || subscription.state === "cancelled" || subscription.state === "read_only";
+    status(
+      noPlan ? "\u2705 Credentials are valid. This workspace has no plan yet, so only the billing commands work." : `\u2705 Credentials are valid. The current plan (${subscription.plan}) has no API access, so only the billing commands work.`
+    );
+    status(`   Next: ${BRAND.cli} billing:plans, then ${BRAND.cli} billing:subscribe --tier <slug> --period <monthly|yearly>`);
+    if (subscription.pendingCheckout) {
+      status(`   An unpaid checkout is waiting: ${subscription.pendingCheckout.checkoutUrl}`);
+    }
+    result(__spreadProps(__spreadValues({
+      authenticated: true
+    }, base), {
+      apiAccess: false,
+      plan: subscription.plan,
+      subscriptionState: subscription.state,
+      reason: noPlan ? "no-plan" : "plan-without-api-access"
+    }));
+    return;
+  }
+  let integrations = null;
+  try {
+    const list = await new PostyAPI({
+      apiKey,
+      apiUrl,
+      workspaceId
+    }).listIntegrations();
+    integrations = Array.isArray(list) ? list.length : null;
+  } catch (e) {
+  }
+  status(
+    `\u2705 Credentials are valid. Plan: ${(_a = subscription.plan) != null ? _a : "none"}${integrations === null ? "" : `, ${integrations} channel(s) connected`}.`
+  );
+  result(__spreadProps(__spreadValues({
+    authenticated: true
+  }, base), {
+    apiAccess: true,
+    plan: subscription.plan,
+    subscriptionState: subscription.state,
+    integrations
+  }));
+}
+
+// src/config.ts
+function getWorkspaceId() {
+  const fromEnv = readEnv("WORKSPACE");
+  if (fromEnv) return fromEnv;
+  const creds = loadCredentials();
+  if (creds == null ? void 0 : creds.organizationId) return creds.organizationId;
+  return getSetting("workspace");
+}
+function getConfig() {
+  const workspaceId = getWorkspaceId();
+  const creds = loadCredentials();
+  if (creds) {
+    return {
+      apiKey: creds.accessToken,
+      apiUrl: creds.apiUrl,
+      workspaceId
+    };
+  }
+  const apiKey = readEnv("API_KEY");
+  const apiUrl = readEnv("API_URL");
+  if (!apiKey) {
+    console.error("\u274C Error: No authentication found.");
+    console.error("Options:");
+    console.error(`  1. Device login: ${BRAND.cli} auth:login`);
+    console.error(`  2. API Key: export ${envName("API_KEY")}=your_api_key`);
+    process.exit(1);
+  }
+  return {
+    apiKey,
+    apiUrl,
+    workspaceId
+  };
+}
+
+// src/commands/posts.ts
+var import_fs3 = require("fs");
+var pairContentsWithMedia = (argv) => {
+  const read = (token, next, long, short) => {
+    if (token === `--${long}` || token === `-${short}`) {
+      return next === void 0 ? null : { value: next, consumed: 2 };
+    }
+    if (token.startsWith(`--${long}=`)) {
+      return { value: token.slice(long.length + 3), consumed: 1 };
+    }
+    return null;
+  };
+  const pairs = [];
+  for (let i = 0; i < argv.length; ) {
+    const content = read(argv[i], argv[i + 1], "content", "c");
+    if (content) {
+      pairs.push({ content: content.value });
+      i += content.consumed;
+      continue;
+    }
+    const media = read(argv[i], argv[i + 1], "media", "m");
+    if (media) {
+      if (!pairs.length) {
+        console.error("\u274C --media/-m must come after the --content/-c it belongs to");
+        process.exit(1);
+      }
+      const last = pairs[pairs.length - 1];
+      last.media = last.media ? `${last.media},${media.value}` : media.value;
+      i += media.consumed;
+      continue;
+    }
+    i += 1;
+  }
+  return pairs;
+};
+function timezoneForArgs(args) {
+  try {
+    return resolveTimezone(args.timezone);
+  } catch (error) {
+    console.error(`\u274C ${error.message}`);
+    process.exit(1);
+  }
+}
+function echoInterpretation(input, resolved) {
+  if (resolved.appliedTimezone) {
+    status(
+      `\u2139\uFE0F  Interpreted "${input}" as ${resolved.appliedTimezone.name} (via ${resolved.appliedTimezone.source}) \u2192 ${resolved.iso}`
+    );
+  }
+}
+async function getMissingContent(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.getMissingContent(args.id);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to get missing content", error);
+  }
+}
+async function connectPost(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.updateReleaseId(args.id, args.releaseId);
+    status(`\u2705 Post ${args.id} connected to release ${args.releaseId}`);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to connect post", error);
+  }
+}
+async function findSlot(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.findSlot(args.id);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to find a free slot", error);
+  }
+}
+async function createPost(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  let postData;
+  if (args.json) {
+    try {
+      const jsonPath = args.json;
+      if (!(0, import_fs3.existsSync)(jsonPath)) {
+        console.error(`\u274C JSON file not found: ${jsonPath}`);
+        process.exit(1);
+      }
+      const jsonContent = (0, import_fs3.readFileSync)(jsonPath, "utf-8");
+      postData = JSON.parse(jsonContent);
+    } catch (error) {
+      console.error(`\u274C Failed to parse JSON file: ${error.message}`);
+      process.exit(1);
+    }
+  } else {
+    const integrations = args.integrations ? args.integrations.split(",").map((id) => id.trim()) : [];
+    if (integrations.length === 0) {
+      console.error("\u274C At least one integration ID is required");
+      console.error("Use -i or --integrations to specify integration IDs");
+      console.error(`Run "${BRAND.cli} integrations:list" to see available integrations`);
+      process.exit(1);
+    }
+    const contents = Array.isArray(args.content) ? args.content : [args.content];
+    if (!contents[0]) {
+      console.error("\u274C At least one -c/--content is required");
+      process.exit(1);
+    }
+    const pairs = pairContentsWithMedia(process.argv);
+    if (pairs.length && pairs.length !== contents.length) {
+      console.error(
+        `\u274C Could not match --media to --content reliably (parsed ${pairs.length} content flags, yargs saw ${contents.length}).`
+      );
+      console.error("Pass the post structure with --json instead.");
+      process.exit(1);
+    }
+    const values = (pairs.length ? pairs : contents.map((content) => ({ content, media: void 0 }))).map(({ content, media }) => ({
+      content,
+      image: media ? media.split(",").filter((img) => img.trim()).map((img) => ({
+        id: Math.random().toString(36).substring(7),
+        path: img.trim()
+      })) : [],
+      delay: (args == null ? void 0 : args.delay) || 0
+    }));
+    let settings = void 0;
+    if (args.settings) {
+      try {
+        settings = typeof args.settings === "string" ? JSON.parse(args.settings) : args.settings;
+      } catch (error) {
+        console.error(`\u274C Failed to parse settings JSON: ${error.message}`);
+        process.exit(1);
+      }
+    }
+    const type = args.type || "schedule";
+    let dateIso;
+    if (!args.date && type === "now") {
+      dateIso = (/* @__PURE__ */ new Date()).toISOString();
+    } else {
+      const timezone = timezoneForArgs(args);
+      try {
+        const resolved = resolveDateInput(args.date, timezone, "--date");
+        dateIso = resolved.iso;
+        echoInterpretation(args.date, resolved);
+      } catch (error) {
+        console.error(`\u274C ${error.message}`);
+        process.exit(1);
+      }
+    }
+    postData = {
+      type,
+      creationMethod: "CLI",
+      date: dateIso,
+      shortLink: args.shortLink !== false,
+      tags: [],
+      posts: integrations.map((integrationId) => ({
+        integration: { id: integrationId },
+        value: values,
+        settings
+      }))
+    };
+  }
+  try {
+    const res = await api.createPost(postData);
+    status("\u2705 Post created successfully!");
+    if ((postData == null ? void 0 : postData.type) && postData.type !== "draft") {
+      status(
+        "Note: a key without posts:publish creates a DRAFT even when you asked to schedule \u2014 check the type in the response."
+      );
+    }
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to create post", error);
+  }
+}
+async function listPosts(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  const defaultStartDate = /* @__PURE__ */ new Date();
+  defaultStartDate.setDate(defaultStartDate.getDate() - 30);
+  const defaultEndDate = /* @__PURE__ */ new Date();
+  defaultEndDate.setDate(defaultEndDate.getDate() + 30);
+  const timezone = args.startDate || args.endDate ? timezoneForArgs(args) : null;
+  const resolve = (label, value, fallback) => {
+    if (!value) return fallback.toISOString();
+    try {
+      const resolved = resolveDateInput(value, timezone, label);
+      echoInterpretation(value, resolved);
+      return resolved.iso;
+    } catch (error) {
+      console.error(`\u274C ${error.message}`);
+      process.exit(1);
+    }
+  };
+  const filters = {
+    startDate: resolve("--startDate", args.startDate, defaultStartDate),
+    endDate: resolve("--endDate", args.endDate, defaultEndDate)
+  };
+  if (args.customer) {
+    filters.customer = args.customer;
+  }
+  try {
+    const res = await api.listPosts(filters);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to list posts", error);
+  }
+}
+async function changePostStatus(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.changePostStatus(args.id, args.status);
+    status(`\u2705 Post ${args.id} status changed to ${args.status}`);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to change post status", error);
+  }
+}
+async function deletePost(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.deletePost(args.id);
+    status(`\u2705 Post ${args.id} deleted successfully!`);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to delete post", error);
+  }
+}
+async function deletePostGroup(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.deletePostGroup(args.group);
+    status(`\u2705 Post group ${args.group} deleted from every channel`);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to delete post group", error);
+  }
+}
+
+// src/commands/integrations.ts
+async function listIntegrations(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.listIntegrations(args == null ? void 0 : args.group);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to list integrations", error);
+  }
+}
+async function listGroups() {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.listGroups();
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to list groups", error);
+  }
+}
+async function getIntegrationSettings(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.getIntegrationSettings(args.id);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to get integration settings", error);
+  }
+}
+async function triggerIntegrationTool(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  let data = {};
+  if (args.data) {
+    try {
+      data = JSON.parse(args.data);
+    } catch (error) {
+      console.error(`\u274C Failed to parse data JSON: ${error.message}`);
+      process.exit(1);
+    }
+  }
+  try {
+    const res = await api.triggerIntegrationTool(args.id, args.method, data);
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to trigger tool", error);
+  }
+}
+
+// src/commands/analytics.ts
+function daysArg(args) {
+  var _a;
+  const days = String((_a = args.days) != null ? _a : "7");
+  if (!/^\d+$/.test(days) || Number(days) < 1) {
+    console.error("\u274C --days must be a positive whole number of days, e.g. --days 30");
+    process.exit(1);
+  }
+  return days;
+}
+async function getAnalytics(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.getAnalytics(args.id, daysArg(args));
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to get analytics", error);
+  }
+}
+async function getPostAnalytics(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.getPostAnalytics(args.id, daysArg(args));
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to get post analytics", error);
+  }
+}
+
+// src/commands/upload.ts
+var import_fs4 = require("fs");
+var import_path3 = require("path");
+async function uploadFile(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  if (!(0, import_fs4.existsSync)(args.file)) {
+    console.error(`\u274C File not found: ${args.file}`);
+    process.exit(1);
+  }
+  try {
+    const fileBuffer = (0, import_fs4.readFileSync)(args.file);
+    const filename = (0, import_path3.basename)(args.file) || "file";
+    const res = await api.upload(fileBuffer, filename);
+    status("\u2705 File uploaded successfully!");
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to upload file", error);
+  }
+}
+async function createUploadLink() {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.createUploadLink();
+    status(
+      `\u{1F517} Upload link created. Open it in a browser, drop the files, then run: ${BRAND.cli} upload:files ${res.id}`
+    );
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to create an upload link", error);
+  }
+}
+async function listUploadLinkFiles(args) {
+  const config = getConfig();
+  const api = new PostyAPI(config);
+  try {
+    const res = await api.getUploadLinkFiles(args.id);
+    if (res.status === "empty") {
+      status('\u23F3 Nothing has arrived through this link yet. Ask the person to check the page says "uploaded", then run this again.');
+    } else {
+      status(`\u2705 ${res.count} file(s) arrived. Use each .path in posts:create -m`);
+    }
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to read the upload link", error);
+  }
+}
+
+// src/commands/config.ts
+function assertKnownKey(key) {
+  if (!KNOWN_SETTINGS.includes(key)) {
+    console.error(
+      `\u274C Unknown setting "${key}". Known settings: ${KNOWN_SETTINGS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  return key;
+}
+async function configSet(args) {
+  const key = assertKnownKey(args.key);
+  let value = String(args.value);
+  if (key === "timezone") {
+    try {
+      value = assertIanaTimezone(value, "config:set");
+    } catch (error) {
+      console.error(`\u274C ${error.message}`);
+      process.exit(1);
+    }
+  }
+  saveSetting(key, value);
+  status(`\u2705 ${key} = ${value} saved to ${settingsFilePath()}`);
+  result({ [key]: value });
+}
+async function configGet(args) {
+  var _a;
+  const settings = loadSettings();
+  if (args.key) {
+    const key = assertKnownKey(args.key);
+    result({ [key]: (_a = settings[key]) != null ? _a : null });
+    return;
+  }
+  result(settings);
+}
+
+// src/commands/workspaces.ts
+async function listWorkspaces() {
+  const api = new PostyAPI(getConfig());
+  try {
+    const res = await api.listWorkspaces();
+    result(res);
+    return res;
+  } catch (error) {
+    fail("Failed to list workspaces", error);
+  }
+}
+async function useWorkspace(args) {
+  const id = String(args.id || "").trim();
+  if (!id) {
+    fail("Failed to select workspace", new Error(`Give the workspace id, from "${BRAND.cli} workspaces:list"`));
+  }
+  const api = new PostyAPI(__spreadProps(__spreadValues({}, getConfig()), { workspaceId: void 0 }));
+  let workspaces;
+  try {
+    workspaces = await api.listWorkspaces();
+  } catch (error) {
+    fail("Failed to select workspace", error);
+  }
+  const chosen = workspaces.find((w) => w.id === id);
+  if (!chosen) {
+    fail(
+      "Failed to select workspace",
+      new Error(
+        `This credential cannot act on workspace ${id}. Available: ${workspaces.map((w) => `${w.name} (${w.id})`).join(", ") || "none"}`
+      )
+    );
+  }
+  const creds = loadCredentials();
+  if (creds) {
+    saveCredentials(__spreadProps(__spreadValues({}, creds), { organizationId: chosen.id }));
+    status(`\u2705 Workspace set to ${chosen.name} (saved with your login)`);
+  } else {
+    saveSetting("workspace", chosen.id);
+    status(`\u2705 Workspace set to ${chosen.name} (saved to ${settingsFilePath()})`);
+  }
+  result({ id: chosen.id, name: chosen.name, role: chosen.role });
+}
+async function currentWorkspace() {
+  const id = getWorkspaceId();
+  const api = new PostyAPI(getConfig());
+  try {
+    const workspaces = await api.listWorkspaces();
+    const current = workspaces.find((w) => w.current) || null;
+    if (!current && workspaces.length > 1) {
+      status(
+        `No workspace selected and this key spans several. Run: ${BRAND.cli} workspaces:use <id>`
+      );
+    }
+    result(current != null ? current : id ? { id, name: null } : null);
+  } catch (error) {
+    fail("Failed to read the current workspace", error);
+  }
+}
+
+// src/commands/billing.ts
+async function billingPlans() {
+  const api = new PostyAPI(getConfig());
+  try {
+    result(await api.getPlans());
+  } catch (error) {
+    fail("Failed to read the plans", error);
+  }
+}
+async function billingSubscribe(args) {
+  const tier = String(args.tier || "").trim();
+  const period = String(args.period || "").trim().toLowerCase();
+  if (!tier) {
+    fail(
+      "Failed to start the subscription",
+      new Error(`Give the plan with --tier (${BRAND.tierList}; see "${BRAND.cli} billing:plans")`)
+    );
+  }
+  if (period !== "monthly" && period !== "yearly") {
+    fail(
+      "Failed to start the subscription",
+      new Error("Give the period with --period monthly or --period yearly")
+    );
+  }
+  const api = new PostyAPI(getConfig());
+  try {
+    const checkout = await api.createSubscriptionCheckout(tierForApi(tier), period);
+    status(
+      `Checkout link for ${checkout.plan} (${checkout.period.toLowerCase()}, ${checkout.amount} ${checkout.currency}${checkout.trial ? `, ${checkout.trialDays}-day free trial` : ""}). The link expires at ${checkout.expiresAt}.`
+    );
+    status(
+      `The subscriber opens this link and pays in Stripe Checkout with their own Link wallet or card. Do not pay with a one-time or agent-issued card: the subscription renews and a one-time card fails at the first renewal. After paying, run "${BRAND.cli} billing:status" to confirm.`
+    );
+    const _a = checkout, { note: _note } = _a, json = __objRest(_a, ["note"]);
+    if (checkout.apiAndMcpAccess === false) {
+      status(
+        `The ${checkout.plan} plan has no API or MCP access: after the payment this key still reaches only the billing commands, and the person uses ${BRAND.name} in the web app. Tell the person before they pay; a plan with apiAndMcpAccess: true in "${BRAND.cli} billing:plans" keeps the CLI working.`
+      );
+    }
+    if (args.open) {
+      openBrowser(checkout.checkoutUrl);
+      status("Opened the checkout in the browser.");
+    }
+    result(json);
+  } catch (error) {
+    fail("Failed to start the subscription", error);
+  }
+}
+async function billingStatus() {
+  const api = new PostyAPI(getConfig());
+  try {
+    const subscription = await api.getSubscription();
+    if (subscription.pendingCheckout) {
+      const pending = subscription.pendingCheckout;
+      const when = (iso) => iso ? new Date(iso).toLocaleString() : "an unknown time";
+      status(
+        `A checkout for ${pending.plan}${pending.period ? ` (${pending.period.toLowerCase()})` : ""} started at ${when(pending.startedAt)} has not been paid yet. The link is in pendingCheckout.checkoutUrl and expires at ${when(pending.expiresAt)}.`
+      );
+    }
+    result(subscription);
+  } catch (error) {
+    fail("Failed to read the subscription", error);
+  }
+}
+async function billingManage(args) {
+  const api = new PostyAPI(getConfig());
+  try {
+    const portal = await api.getSubscriptionPortal();
+    const _a = portal, { note } = _a, json = __objRest(_a, ["note"]);
+    status(note);
+    if (args.open) {
+      openBrowser(portal.portalUrl);
+      status("Opened the billing portal in the browser.");
+    }
+    result(json);
+  } catch (error) {
+    fail("Failed to open the billing portal", error);
+  }
+}
+
+// src/commands/fotoai.ts
+var import_crypto2 = require("crypto");
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var failFotoAi = (context, error) => {
+  if (error instanceof ApiError) {
+    let body = null;
+    try {
+      body = JSON.parse(error.body);
+    } catch (e) {
+    }
+    if (error.status === 404 && !(body == null ? void 0 : body.code)) {
+      status("\u274C FotoAI is not available on this Posty server yet.");
+      process.exit(1);
+    }
+    if (body == null ? void 0 : body.code) {
+      const details = body.details || {};
+      status(`\u274C ${context}: ${body.msg || body.code} (${body.code})`);
+      if (details.connect_url) {
+        status(`Connect FotoAI in Posty once: ${details.connect_url}`);
+      }
+      if (details.topup_url) {
+        status(`FotoAI credits can be bought at ${details.topup_url}`);
+      }
+      if (typeof details.quote === "number") {
+        status(`The new price is ${details.quote / 1e3} credits. Quote again and confirm it.`);
+      }
+      if (body.retryAfter) {
+        status(`Try again in ${body.retryAfter} seconds.`);
+      }
+      process.exit(1);
+    }
+  }
+  fail(context, error);
+};
+var paramsOf = (args) => {
+  const params = {};
+  if (args.aspect) params.aspect = String(args.aspect);
+  if (args.duration) params.duration = Number(args.duration);
+  if (args.resolution) params.resolution = String(args.resolution);
+  return params;
+};
+async function fotoAiStatus() {
+  const api = new PostyAPI(getConfig());
+  try {
+    const current = await api.fotoAiStatus();
+    if (!current.connected) {
+      status(
+        current.needsReconnect ? `The FotoAI connection has expired. Connect again in Posty: ${current.connectUrl}` : `FotoAI is not connected. The person connects it once in Posty: ${current.connectUrl}`
+      );
+    }
+    result(current);
+  } catch (error) {
+    failFotoAi("Failed to read the FotoAI status", error);
+  }
+}
+async function fotoAiModels(args) {
+  const api = new PostyAPI(getConfig());
+  try {
+    const catalog = await api.fotoAiModels(args.category);
+    const models = (catalog.models || []).map((m) => {
+      var _a, _b;
+      return {
+        id: m.id,
+        name: m.name,
+        category: m.category,
+        can_use: !!m.can_use,
+        estimated_seconds: (_a = m.estimated_seconds) != null ? _a : null,
+        max_duration_seconds: (_b = m.max_duration_seconds) != null ? _b : null,
+        base_price_credits: (() => {
+          var _a2;
+          const prices = (((_a2 = m.price) == null ? void 0 : _a2.configs) || []).map((c) => Number(c.millicredits)).filter((n) => Number.isFinite(n) && n > 0);
+          return prices.length ? Math.min(...prices) / 1e3 : null;
+        })(),
+        params: (m.params || []).map((p) => {
+          var _a2;
+          return {
+            key: p.key,
+            default: (_a2 = p.default) != null ? _a2 : null,
+            options: (p.options || []).map((o) => o.value)
+          };
+        })
+      };
+    });
+    result({ catalog_version: catalog.catalog_version || null, models });
+  } catch (error) {
+    failFotoAi("Failed to list the FotoAI models", error);
+  }
+}
+async function fotoAiGet(args) {
+  var _a, _b;
+  const api = new PostyAPI(getConfig());
+  const deadline = Date.now() + Math.max(0, Number(args.wait) || 0) * 1e3;
+  try {
+    let current = await api.fotoAiImport(String(args.id));
+    while ((["queued", "running"].includes(current.status) || current.status === "completed" && !((_a = current.media) == null ? void 0 : _a.length) && !current.import_error) && Date.now() < deadline) {
+      await sleep2(3e3);
+      current = await api.fotoAiImport(String(args.id));
+    }
+    if ((_b = current.media) == null ? void 0 : _b.length) {
+      status(`Saved in the media library. Attach each media[].path with posts:create.`);
+    } else if (["queued", "running"].includes(current.status)) {
+      status(`Still ${current.status}. Run "${BRAND.cli} fotoai:get ${current.id} --wait 60" again.`);
+    }
+    result(current);
+  } catch (error) {
+    failFotoAi("Failed to read the FotoAI generation", error);
+  }
+}
+async function fotoAiGenerate(args) {
+  var _a;
+  const api = new PostyAPI(getConfig());
+  const request = {
+    model: String(args.model),
+    prompt: String(args.prompt),
+    params: paramsOf(args)
+  };
+  let quote;
+  try {
+    quote = await api.fotoAiQuote(request);
+  } catch (error) {
+    failFotoAi("Failed to price the FotoAI generation", error);
+  }
+  const balance = typeof quote.available_millicredits === "number" ? `, balance ${quote.available_millicredits / 1e3} credits` : "";
+  if (quote.insufficient) {
+    status(
+      `Not enough FotoAI credits: this costs ${quote.credits} credits${balance}.${quote.topup_url ? ` Buy credits at ${quote.topup_url}` : ""}`
+    );
+    result({ generated: false, quote });
+    process.exit(1);
+  }
+  if (!args.yes) {
+    status(
+      `This costs ${quote.credits} FotoAI credits${balance}. Nothing was spent. Run the same command with --yes to generate.`
+    );
+    result({ generated: false, quote });
+    return;
+  }
+  try {
+    const started = await api.fotoAiGenerate(__spreadProps(__spreadValues({}, request), {
+      quote_id: quote.quote_id,
+      idempotency_key: args.idempotencyKey || (0, import_crypto2.randomUUID)()
+    }));
+    status(`Generating (about ${(_a = started.estimated_seconds) != null ? _a : "?"} seconds), id ${started.id}.`);
+    if (!Number(args.wait)) {
+      status(`Run "${BRAND.cli} fotoai:get ${started.id} --wait 60" for the media paths.`);
+      result(started);
+      return;
+    }
+    await fotoAiGet({ id: started.id, wait: args.wait });
+  } catch (error) {
+    failFotoAi("Failed to start the FotoAI generation", error);
+  }
+}
+
+// src/index.ts
+var cli = (0, import_yargs.default)((0, import_helpers.hideBin)(process.argv)).scriptName(BRAND.cli).usage("$0 <command> [options]").option("workspace", {
+  alias: "w",
+  describe: `Workspace id this command acts on (overrides "${BRAND.cli} workspaces:use" and ${envName("WORKSPACE")})`,
+  type: "string",
+  global: true
+}).middleware((argv) => {
+  if (argv.workspace) {
+    writeEnv("WORKSPACE", String(argv.workspace));
+  }
+}).command(
+  "posts:create",
+  "Create a new post (schedule, draft, or publish now)",
+  (yargs2) => {
+    return yargs2.option("content", {
+      alias: "c",
+      describe: "Post/comment content (repeat for a thread: first is the post, the rest are comments)",
+      type: "string"
+    }).option("media", {
+      alias: "m",
+      describe: `Comma-separated media URLs for the corresponding -c (repeatable; URLs must come from "${BRAND.cli} upload")`,
+      type: "string"
+    }).option("integrations", {
+      alias: "i",
+      describe: `Comma-separated list of integration IDs (from "${BRAND.cli} integrations:list")`,
+      type: "string"
+    }).option("date", {
+      alias: "s",
+      describe: `Publish date. ALWAYS give ISO 8601 with an explicit offset ("2026-12-31T12:00:00Z" / "+01:00"), or a datetime without offset ("2026-12-31 12:00") together with a timezone (--timezone / ${envName("TIMEZONE")} / ${BRAND.cli} config:set timezone). A naive date with no timezone configured is an error. Required unless --type now or --json.`,
+      type: "string"
+    }).option("timezone", {
+      describe: `IANA timezone name (e.g. ${BRAND.exampleTimezone}) used to interpret --date when it has no explicit offset. Numeric offsets are not accepted here \u2014 put those in the date string.`,
+      type: "string"
+    }).option("type", {
+      alias: "t",
+      describe: 'Post type: "schedule" (default), "draft", or "now" (publish immediately)',
+      type: "string",
+      choices: ["schedule", "draft", "now"],
+      default: "schedule"
+    }).option("delay", {
+      alias: "d",
+      describe: "Delay in MINUTES between comments (default: 0)",
+      type: "number",
+      default: 0
+    }).option("json", {
+      alias: "j",
+      describe: "Path to JSON file with the full post structure (see examples/)",
+      type: "string"
+    }).option("shortLink", {
+      describe: "Use short links",
+      type: "boolean",
+      default: true
+    }).option("settings", {
+      describe: `Platform-specific settings as JSON string (schema: "${BRAND.cli} integrations:settings <id>")`,
+      type: "string"
+    }).check((argv) => {
+      if (!argv.json && !argv.content) {
+        throw new Error("Either --content or --json is required");
+      }
+      if (!argv.json && !argv.integrations) {
+        throw new Error("--integrations is required when not using --json");
+      }
+      if (!argv.json && !argv.date && argv.type !== "now") {
+        throw new Error("--date is required when not using --json (or use --type now to publish immediately)");
+      }
+      return true;
+    }).example(
+      '$0 posts:create -c "Hello World!" -s "2026-12-31T12:00:00Z" -i "integration-id"',
+      "Simple scheduled post (explicit UTC)"
+    ).example(
+      `$0 posts:create -c "Merry Christmas! \u{1F384}" -s "2026-12-24 18:00" --timezone ${BRAND.exampleTimezone} -i "integration-id"`,
+      "Local wall-clock time with an explicit IANA timezone"
+    ).example(
+      '$0 posts:create -c "This goes out right now" -t now -i "integration-id"',
+      "Publish immediately (no --date needed)"
+    ).example(
+      '$0 posts:create -c "Draft post" -s "2026-12-31T12:00:00Z" -t draft -i "integration-id"',
+      "Create draft post"
+    ).example(
+      '$0 posts:create -c "Main post" -m "img1.jpg,img2.jpg" -s "2026-12-31T12:00:00Z" -i "integration-id"',
+      `Post with multiple images (each URL from "${BRAND.cli} upload")`
+    ).example(
+      '$0 posts:create -c "Main post" -m "img1.jpg" -c "First comment" -m "img2.jpg" -c "Second comment" -m "img3.jpg,img4.jpg" -s "2026-12-31T12:00:00Z" -i "integration-id"',
+      "Post with comments, each having their own media"
+    ).example(
+      '$0 posts:create -c "Thread 1/3" -c "Thread 2/3" -c "Thread 3/3" -d 5 -s "2026-12-31T12:00:00Z" -i "integration-id"',
+      "X (Twitter) thread with 5 minute delay between comments"
+    ).example(
+      "$0 posts:create --json ./post.json",
+      "Complex post from JSON file"
+    ).example(
+      `$0 posts:create -c "Tweet content" -s "2026-12-31T12:00:00Z" --settings '{"who_can_reply_post":"everyone"}' -i "integration-id"`,
+      "X (Twitter) post with reply settings"
+    ).example(
+      `$0 posts:create -c "Video description" -s "2026-12-31T12:00:00Z" --settings '{"title":"My Video","type":"public"}' -i "youtube-id"`,
+      "YouTube post with title and visibility"
+    );
+  },
+  createPost
+).command(
+  "posts:list",
+  "List posts in a date range",
+  (yargs2) => {
+    return yargs2.option("startDate", {
+      describe: "Start date (ISO 8601 with explicit offset, or use --timezone). Default: 30 days ago",
+      type: "string"
+    }).option("endDate", {
+      describe: "End date (ISO 8601 with explicit offset, or use --timezone). Default: 30 days from now",
+      type: "string"
+    }).option("timezone", {
+      describe: `IANA timezone name (e.g. ${BRAND.exampleTimezone}) used to interpret --startDate/--endDate when they have no explicit offset`,
+      type: "string"
+    }).option("customer", {
+      describe: "Customer (group) ID (optional)",
+      type: "string"
+    }).example("$0 posts:list", "List posts (last 30 days to next 30 days)").example(
+      '$0 posts:list --startDate "2026-01-01T00:00:00Z" --endDate "2026-12-31T23:59:59Z"',
+      "List posts for a specific date range"
+    ).example(
+      '$0 posts:list --customer "customer-id"',
+      "List posts for a specific customer"
+    );
+  },
+  listPosts
+).command(
+  "posts:delete <id>",
+  "Delete one post (one channel). Other channels of the same group stay scheduled",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Post ID to delete (the id field of posts:list)",
+      type: "string"
+    }).example("$0 posts:delete abc123", "Delete only post abc123, with its thread or comments").epilogue("To delete a post from every channel it went to, use posts:delete-group <group>.");
+  },
+  deletePost
+).command(
+  "posts:delete-group <group>",
+  "Delete a whole group: the post on every channel it went to",
+  (yargs2) => {
+    return yargs2.positional("group", {
+      describe: "Group ID (the group field of posts:list)",
+      type: "string"
+    }).example("$0 posts:delete-group grp_9f8e7d6c", "Delete every channel of group grp_9f8e7d6c");
+  },
+  deletePostGroup
+).command(
+  "posts:find-slot <id>",
+  "Find the next free publishing slot for an integration",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Integration ID",
+      type: "string"
+    }).example(
+      "$0 posts:find-slot integration-123",
+      'Returns {"date": "..."} \u2014 the next free datetime, usable as posts:create --date'
+    );
+  },
+  findSlot
+).command(
+  "posts:missing <id>",
+  "List available content from the provider for a post with missing release ID",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Post ID",
+      type: "string"
+    }).example(
+      "$0 posts:missing post-123",
+      "Get available content to connect to a post"
+    );
+  },
+  getMissingContent
+).command(
+  "posts:status <id>",
+  "Change a post status between draft and schedule",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Post ID",
+      type: "string"
+    }).option("status", {
+      alias: "s",
+      describe: 'New status: "draft" or "schedule"',
+      type: "string",
+      choices: ["draft", "schedule"],
+      demandOption: true
+    }).example(
+      "$0 posts:status post-123 --status draft",
+      "Move a scheduled post back to draft (stops the running workflow)"
+    ).example(
+      "$0 posts:status post-123 --status schedule",
+      "Schedule a draft post so it is queued for publishing"
+    );
+  },
+  changePostStatus
+).command(
+  "posts:connect <id>",
+  "Connect a post to its published content by updating the release ID",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Post ID",
+      type: "string"
+    }).option("release-id", {
+      describe: "The platform-specific content ID to connect",
+      type: "string",
+      demandOption: true
+    }).example(
+      '$0 posts:connect post-123 --release-id "7321456789012345678"',
+      "Connect a post to its published content"
+    );
+  },
+  connectPost
+).command(
+  "integrations:list",
+  "List all connected integrations",
+  (yargs2) => {
+    return yargs2.option("group", {
+      describe: "Filter integrations by group (customer) ID",
+      type: "string"
+    }).example("$0 integrations:list", "List all connected integrations").example(
+      '$0 integrations:list --group "customer-id"',
+      "List integrations for a specific group"
+    );
+  },
+  listIntegrations
+).command(
+  "integrations:groups",
+  "List all groups (customers)",
+  {},
+  listGroups
+).command(
+  "integrations:settings <id>",
+  "Get settings schema, rules, max length and tools for an integration",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Integration ID",
+      type: "string"
+    }).example(
+      "$0 integrations:settings youtube-456",
+      "Get settings schema for a YouTube integration"
+    ).example(
+      "$0 integrations:settings instagram-123",
+      "Get settings schema and tools for an Instagram integration"
+    );
+  },
+  getIntegrationSettings
+).command(
+  "integrations:trigger <id> <method>",
+  "Trigger an integration tool to fetch additional data",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Integration ID",
+      type: "string"
+    }).positional("method", {
+      describe: 'Method name from the "tools" array of integrations:settings',
+      type: "string"
+    }).option("data", {
+      alias: "d",
+      describe: "Data to pass to the tool as JSON string",
+      type: "string"
+    }).example(
+      `$0 integrations:trigger instagram-123 audioSearch -d '{"q":"lofi","type":"music"}'`,
+      "Search Instagram audio for a Reel (the only tool on a supported channel)"
+    );
+  },
+  triggerIntegrationTool
+).command(
+  "analytics:platform <id>",
+  "Get analytics for a specific integration/channel",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Integration ID",
+      type: "string"
+    }).option("days", {
+      alias: ["d", "date"],
+      describe: "Number of days to look back (default: 7)",
+      type: "string",
+      default: "7"
+    }).example(
+      "$0 analytics:platform integration-123",
+      "Get last 7 days of analytics"
+    ).example(
+      "$0 analytics:platform integration-123 -d 30",
+      "Get last 30 days of analytics"
+    );
+  },
+  getAnalytics
+).command(
+  "analytics:post <id>",
+  "Get analytics for a specific post",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: "Post ID",
+      type: "string"
+    }).option("days", {
+      alias: ["d", "date"],
+      describe: "Number of days to look back (default: 7)",
+      type: "string",
+      default: "7"
+    }).example(
+      "$0 analytics:post post-123",
+      "Get last 7 days of post analytics"
+    ).example(
+      "$0 analytics:post post-123 -d 30",
+      "Get last 30 days of post analytics"
+    );
+  },
+  getPostAnalytics
+).command(
+  "upload <file>",
+  "Upload a media file; returns the URL to pass to posts:create -m",
+  (yargs2) => {
+    return yargs2.positional("file", {
+      describe: "File path to upload (jpeg/png/gif/webp/avif/bmp/tiff up to 10 MB, mp4 up to 1 GB)",
+      type: "string"
+    }).example("$0 upload ./image.png", "Upload an image; use the returned .path in posts:create -m");
+  },
+  uploadFile
+).command(
+  "upload:link",
+  "Get a browser upload link for a file that is not on this machine (e.g. on a phone)",
+  (yargs2) => {
+    return yargs2.example(
+      "$0 upload:link",
+      "Returns {id, url, expiresAt}. Show the url to the person; they drop files on it, signed out. Then run upload:files <id>"
+    );
+  },
+  createUploadLink
+).command(
+  "upload:files <id>",
+  "List the files that arrived through an upload link; each .path goes to posts:create -m",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: `The id returned by "${BRAND.cli} upload:link"`,
+      type: "string"
+    }).example(
+      "$0 upload:files kR3mQ7xP2nLa",
+      'Returns {status, count, files:[{id,name,path,type}]}; status "empty" means nothing has arrived yet'
+    );
+  },
+  listUploadLinkFiles
+).command(
+  "workspaces:list",
+  'List the workspaces this credential can act on ("current" marks the active one)',
+  {},
+  listWorkspaces
+).command(
+  "workspaces:use <id>",
+  "Make every following command act on this workspace",
+  (yargs2) => {
+    return yargs2.positional("id", {
+      describe: `Workspace id, from "${BRAND.cli} workspaces:list"`,
+      type: "string"
+    }).example("$0 workspaces:use 3f2a\u2026", "Switch the CLI to that workspace");
+  },
+  useWorkspace
+).command(
+  "workspaces:current",
+  "Show the workspace commands act on now",
+  {},
+  currentWorkspace
+).command(
+  "billing:plans",
+  IS_POSTEMI ? "Show the Postemi plans: prices, limits, the trial rule and the current tier" : "Show the Posty plans: prices in forint, limits, the trial rule and the current tier",
+  {},
+  billingPlans
+).command(
+  "billing:subscribe",
+  "Get a Stripe Checkout link for a plan. Nothing is charged; the subscriber opens the link and pays with their own wallet or card",
+  (yargs2) => {
+    return yargs2.option("tier", {
+      describe: `The plan: ${BRAND.tierList} (see "${BRAND.cli} billing:plans")`,
+      type: "string",
+      demandOption: true
+    }).option("period", {
+      describe: "How often the plan renews",
+      type: "string",
+      choices: ["monthly", "yearly"],
+      demandOption: true
+    }).option("open", {
+      describe: "Also open the link in this machine's browser",
+      type: "boolean",
+      default: false
+    }).example(
+      "$0 billing:subscribe --tier pro --period yearly",
+      "Print the checkout link as JSON"
+    ).example(
+      "$0 billing:subscribe --tier pro --period yearly --open",
+      "Print it and open it in the browser"
+    );
+  },
+  billingSubscribe
+).command(
+  "billing:status",
+  "Show the subscription state (none, trialing, active, past_due, read_only, cancelled) and any unpaid checkout",
+  {},
+  billingStatus
+).command(
+  "billing:manage",
+  "Get a link to the Stripe billing portal (plan change, cancel, invoices, card)",
+  (yargs2) => {
+    return yargs2.option("open", {
+      describe: "Also open the link in this machine's browser",
+      type: "boolean",
+      default: false
+    });
+  },
+  billingManage
+);
+if (!IS_POSTEMI) cli.command(
+  "fotoai:status",
+  "Show whether FotoAI (fotoai.hu) is connected for the key owner, as whom, and the FotoAI credit balance",
+  {},
+  fotoAiStatus
+).command(
+  "fotoai:models",
+  "List the FotoAI image and video models with their parameters and prices",
+  (yargs2) => {
+    return yargs2.option("category", {
+      describe: "Only image or only video models",
+      type: "string",
+      choices: ["image", "video"]
+    });
+  },
+  fotoAiModels
+).command(
+  "fotoai:generate",
+  "Price, and with --yes generate, an image or video with the key owner's own FotoAI credits; the result is saved into the media library",
+  (yargs2) => {
+    return yargs2.option("model", { alias: "m", describe: `A model id from "${BRAND.cli} fotoai:models"`, type: "string", demandOption: true }).option("prompt", { alias: "p", describe: "What to generate", type: "string", demandOption: true }).option("aspect", { describe: "Aspect ratio, e.g. 1:1, 4:5, 9:16, 16:9", type: "string" }).option("duration", { describe: "Video length in seconds (video models)", type: "number" }).option("resolution", { describe: "Resolution, when the model offers one (e.g. 2K)", type: "string" }).option("yes", { describe: "Spend the credits. Without it only the price is shown", type: "boolean", default: false }).option("wait", { describe: "Wait up to this many seconds for the result", type: "number", default: 0 }).option("idempotency-key", { describe: "Reuse on a retry so nothing is charged twice", type: "string" }).example('$0 fotoai:generate -m image.seedream-5-lite -p "k\xE1v\xE9 a teraszon" --aspect 4:5', "Show the price only").example('$0 fotoai:generate -m image.seedream-5-lite -p "k\xE1v\xE9 a teraszon" --aspect 4:5 --yes --wait 60', "Generate and print the media paths");
+  },
+  fotoAiGenerate
+).command(
+  "fotoai:get <id>",
+  "Show a FotoAI generation; once done, its outputs saved into the media library with paths for posts:create",
+  (yargs2) => {
+    return yargs2.positional("id", { describe: "The generation id", type: "string" }).option("wait", { describe: "Wait up to this many seconds while it runs", type: "number", default: 0 });
+  },
+  fotoAiGet
+);
+cli.command(
+  "config:set <key> <value>",
+  `Save a CLI setting to ~/${BRAND.configDirName}/config.json`,
+  (yargs2) => {
+    return yargs2.positional("key", {
+      describe: `Setting name. Known: "timezone" (an IANA name), "workspace" (an id; prefer "${BRAND.cli} workspaces:use")`,
+      type: "string"
+    }).positional("value", {
+      describe: "Setting value",
+      type: "string"
+    }).example(
+      `$0 config:set timezone ${BRAND.exampleTimezone}`,
+      `Interpret dates written without an explicit offset in ${BRAND.exampleTimezoneCity} time`
+    );
+  },
+  configSet
+).command(
+  "config:get [key]",
+  "Show saved CLI settings (all, or one key)",
+  (yargs2) => {
+    return yargs2.positional("key", {
+      describe: 'Setting name. Known: "timezone"',
+      type: "string"
+    }).example("$0 config:get", "Show all saved settings as JSON").example("$0 config:get timezone", "Show the saved timezone");
+  },
+  configGet
+).command(
+  "auth:login",
+  "Authenticate using the OAuth2 device flow (opens a browser)",
+  (yargs2) => {
+    return yargs2.option("auth-server", {
+      describe: `Auth server URL (default: ${BRAND.defaultApiUrl})`,
+      type: "string"
+    }).example(
+      "$0 auth:login",
+      "Login via OAuth2 device flow"
+    );
+  },
+  authLogin
+);
+cli.command(
+  "auth:signup",
+  `Create a NEW ${BRAND.name} account with a code sent to the e-mail address, and store its key. No free trial: the next step is billing:subscribe`,
+  (yargs2) => {
+    return yargs2.option("email", {
+      describe: "E-mail address of the new account; the code is sent there",
+      type: "string",
+      demandOption: true
+    }).option("code", {
+      describe: "The six-digit code from the e-mail (asked for when omitted on a terminal)",
+      type: "string"
+    }).option("accept-terms", {
+      describe: `The person has read ${BRAND.termsUrl} and ${BRAND.privacyUrl} and agrees`,
+      type: "boolean",
+      default: false
+    }).option("workspace-name", {
+      describe: "Name of the new workspace (default: the part of the address before the @)",
+      type: "string"
+    }).option("timezone", {
+      describe: `The person's IANA timezone for the account, e.g. ${BRAND.exampleTimezone} (default: the one saved by config:set, else the system time zone)`,
+      type: "string"
+    }).option("language", {
+      describe: "Language of the e-mail and the account",
+      type: "string",
+      choices: ["hu", "en", "de", "cs"]
+    }).option("api-url", {
+      describe: `API base URL (default: ${envName("API_URL")}, then ${BRAND.defaultApiUrl})`,
+      type: "string"
+    }).example(
+      "$0 auth:signup --email anna@example.com",
+      "Send the code, then ask for it and for the terms on the terminal"
+    ).example(
+      `$0 auth:signup --email anna@example.com --code 123456 --accept-terms --workspace-name "${IS_POSTEMI ? "Anna's Cafe" : "Anna K\xE1v\xE9z\xF3"}"`,
+      "Finish in one run (an agent, after the person read the code and agreed)"
+    );
+  },
+  authSignup
+);
+cli.command(
+  "auth:logout",
+  "Remove stored OAuth2 credentials",
+  {},
+  authLogout
+).command(
+  "auth:status",
+  "Show current authentication status and verify the credentials",
+  {},
+  authStatus
+).demandCommand(1, `Specify a command. Run "${BRAND.cli} --help" for the list.`).strict().help().alias("h", "help").version().alias("v", "version").wrap(Math.min(110, process.stdout.columns || 110)).epilogue(
+  `Output contract: results are JSON on stdout; status and errors go to stderr. Every failure exits 1.
+
+Authentication:
+  Device login: ${BRAND.cli} auth:login
+  API Key: export ${envName("API_KEY")}=your_api_key
+
+Workspaces: a credential may reach several. "${BRAND.cli} workspaces:list" shows them, "${BRAND.cli} workspaces:use <id>" picks the one commands act on (or pass --workspace <id> / ${envName("WORKSPACE")}).
+
+Dates: ALWAYS pass an explicit offset ("2026-12-31T12:00:00Z" / "+01:00"), or pass --timezone with an IANA name (e.g. ${BRAND.exampleTimezone}). A date without either is resolved via ${envName("TIMEZONE")}, then the timezone saved by "${BRAND.cli} config:set timezone" \u2014 and is an ERROR when none of those is set. Numeric offsets are never accepted as timezone values.
+
+For more information, visit: ${BRAND.homepage}`
+).parse();
+//# sourceMappingURL=index.js.map