atmn 0.0.21 → 0.0.23

package/dist/cli.cjs

@@ -0,0 +1,1455 @@
+#!/usr/bin/env node
+'use strict';
+
+var chalk8 = require('chalk');
+var commander = require('commander');
+var open = require('open');
+var prompts = require('@inquirer/prompts');
+var dotenv = require('dotenv');
+var fs = require('fs');
+var yoctoSpinner = require('yocto-spinner');
+var axios = require('axios');
+var prettier = require('prettier');
+var path = require('path');
+var createJiti = require('jiti');
+var url = require('url');
+var child_process = require('child_process');
+var v4 = require('zod/v4');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var chalk8__default = /*#__PURE__*/_interopDefault(chalk8);
+var open__default = /*#__PURE__*/_interopDefault(open);
+var dotenv__default = /*#__PURE__*/_interopDefault(dotenv);
+var fs__default = /*#__PURE__*/_interopDefault(fs);
+var yoctoSpinner__default = /*#__PURE__*/_interopDefault(yoctoSpinner);
+var axios__default = /*#__PURE__*/_interopDefault(axios);
+var prettier__default = /*#__PURE__*/_interopDefault(prettier);
+var path__default = /*#__PURE__*/_interopDefault(path);
+var createJiti__default = /*#__PURE__*/_interopDefault(createJiti);
+
+// ../node_modules/.pnpm/tsup@8.5.0_jiti@2.5.1_postcss@8.5.6_tsx@4.20.4_typescript@5.9.2_yaml@2.8.1/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+var notNullish = (value) => value !== null && value !== void 0;
+var nullish = (value) => value === null || value === void 0;
+function idToVar({
+  id,
+  prefix = "product"
+}) {
+  const processed = id.replace(/[-_](.)/g, (_, letter) => letter.toUpperCase()).replace(/[^a-zA-Z0-9_$]/g, "");
+  if (/^[0-9]/.test(processed)) {
+    return `${prefix}${processed}`;
+  }
+  if (/^[^a-zA-Z_$]/.test(processed)) {
+    return `${prefix}${processed}`;
+  }
+  return processed;
+}
+async function upsertEnvVar(filePath, varName, newValue) {
+  const content = fs__default.default.readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i]?.startsWith(`${varName}=`)) {
+      const shouldOverwrite = await prompts.confirm({
+        message: `${varName} already exists in .env. Overwrite?`,
+        default: false
+      });
+      if (shouldOverwrite) {
+        lines[i] = `${varName}=${newValue}`;
+        found = true;
+        break;
+      }
+    }
+  }
+  if (!found) {
+    lines.push(`${varName}=${newValue}`);
+  }
+  fs__default.default.writeFileSync(filePath, lines.join("\n"));
+}
+async function storeToEnv(prodKey, sandboxKey) {
+  const envPath = `${process.cwd()}/.env`;
+  const envLocalPath = `${process.cwd()}/.env.local`;
+  const envVars = `AUTUMN_PROD_SECRET_KEY=${prodKey}
+AUTUMN_SECRET_KEY=${sandboxKey}
+`;
+  if (fs__default.default.existsSync(envPath)) {
+    await upsertEnvVar(envPath, "AUTUMN_PROD_SECRET_KEY", prodKey);
+    await upsertEnvVar(envPath, "AUTUMN_SECRET_KEY", sandboxKey);
+    console.log(chalk8__default.default.green(".env file found. Updated keys."));
+  } else if (fs__default.default.existsSync(envLocalPath)) {
+    fs__default.default.writeFileSync(envPath, envVars);
+    console.log(
+      chalk8__default.default.green(
+        ".env.local found but .env not found. Created new .env file and wrote keys."
+      )
+    );
+  } else {
+    fs__default.default.writeFileSync(envPath, envVars);
+    console.log(
+      chalk8__default.default.green(
+        "No .env or .env.local file found. Created new .env file and wrote keys."
+      )
+    );
+  }
+}
+function getEnvVar(parsed, prodFlag) {
+  if (prodFlag) return parsed["AUTUMN_PROD_SECRET_KEY"];
+  return parsed["AUTUMN_SECRET_KEY"];
+}
+function readFromEnv(options) {
+  const envPath = `${process.cwd()}/.env`;
+  const envLocalPath = `${process.cwd()}/.env.local`;
+  const prodFlag = process.argv.includes("--prod") || process.argv.includes("-p");
+  if (prodFlag && process.env["AUTUMN_PROD_SECRET_KEY"]) {
+    return process.env["AUTUMN_PROD_SECRET_KEY"];
+  }
+  if (!prodFlag && process.env["AUTUMN_SECRET_KEY"]) {
+    return process.env["AUTUMN_SECRET_KEY"];
+  }
+  let secretKey = void 0;
+  if (fs__default.default.existsSync(envPath))
+    secretKey = getEnvVar(
+      dotenv__default.default.parse(fs__default.default.readFileSync(envPath, "utf-8")),
+      prodFlag
+    );
+  if (fs__default.default.existsSync(envLocalPath))
+    secretKey = getEnvVar(
+      dotenv__default.default.parse(fs__default.default.readFileSync(envLocalPath, "utf-8")),
+      prodFlag
+    );
+  if (!secretKey && !options?.bypass) {
+    if (prodFlag) {
+      console.error(
+        "[Error] atmn uses the AUTUMN_PROD_SECRET_KEY to call the Autumn production API. Please add it to your .env file or run `atmn login` to authenticate."
+      );
+      process.exit(1);
+    } else {
+      console.error(
+        "[Error] atmn uses the AUTUMN_SECRET_KEY to call the Autumn sandbox API. Please add it to your .env (or .env.local) file or run `atmn login` to authenticate."
+      );
+      process.exit(1);
+    }
+  }
+  return secretKey;
+}
+function initSpinner(message) {
+  const spinner = yoctoSpinner__default.default({
+    text: message
+  });
+  spinner.start();
+  return spinner;
+}
+async function isSandboxKey(apiKey) {
+  const prefix = apiKey.split("am_sk_")[1]?.split("_")[0];
+  if (prefix === "live") {
+    return false;
+  } else if (prefix === "test") return true;
+  else throw new Error("Invalid API key");
+}
+
+// source/constants.ts
+var FRONTEND_URL = "http://app.useautumn.com";
+var BACKEND_URL = "https://api.useautumn.com";
+var DEFAULT_CONFIG = `import {
+	feature,
+	product,
+	priceItem,
+	featureItem,
+	pricedFeatureItem,
+} from 'atmn';
+
+export const seats = feature({
+	id: 'seats',
+	name: 'Seats',
+	type: 'continuous_use',
+});
+
+export const messages = feature({
+	id: 'messages',
+	name: 'Messages',
+	type: 'single_use',
+});
+
+export const pro = product({
+	id: 'pro',
+	name: 'Pro',
+	items: [
+		// 500 messages per month
+		featureItem({
+			feature_id: messages.id,
+			included_usage: 500,
+			interval: 'month',
+		}),
+
+		// $10 per seat per month
+		pricedFeatureItem({
+			feature_id: seats.id,
+			price: 10,
+			interval: 'month',
+		}),
+
+		// $50 / month
+		priceItem({
+			price: 50,
+			interval: 'month',
+		}),
+	],
+});
+`;
+
+// source/core/api.ts
+var INTERNAL_BASE = BACKEND_URL;
+var EXTERNAL_BASE = `${BACKEND_URL}/v1`;
+async function request({
+  method,
+  base,
+  path: path2,
+  data,
+  headers,
+  customAuth,
+  throwOnError = true,
+  secretKey,
+  queryParams,
+  bypass
+}) {
+  const apiKey = secretKey || readFromEnv({ bypass });
+  try {
+    const response = await axios__default.default.request({
+      method,
+      url: `${base}${path2}`,
+      data,
+      params: queryParams,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+        Authorization: customAuth || `Bearer ${apiKey}`
+      }
+    });
+    return response.data;
+  } catch (error) {
+    if (throwOnError) {
+      throw error;
+    }
+    console.error("\n" + chalk8__default.default.bgRed.white.bold("  API REQUEST FAILED  "));
+    const methodPath = `${method.toUpperCase()} ${base}${path2}`;
+    console.error(chalk8__default.default.red(methodPath));
+    if (error instanceof axios.AxiosError) {
+      const status = error.response?.status;
+      const data2 = error.response?.data;
+      const code = data2?.code || data2?.error || "unknown_error";
+      const message = data2?.message || error.message || "An unknown error occurred";
+      if (status) {
+        console.error(chalk8__default.default.redBright(`[${status}] ${code}`));
+      }
+      console.error(chalk8__default.default.red(message));
+    } else if (error instanceof Error) {
+      console.error(chalk8__default.default.red(error.message));
+    } else {
+      console.error(chalk8__default.default.red(String(error)));
+    }
+    process.exit(1);
+  }
+}
+async function internalRequest({
+  method,
+  path: path2,
+  data,
+  headers,
+  customAuth
+}) {
+  return await request({
+    method,
+    base: INTERNAL_BASE,
+    path: path2,
+    data,
+    headers,
+    customAuth,
+    bypass: true
+  });
+}
+async function externalRequest({
+  method,
+  path: path2,
+  data,
+  headers,
+  customAuth,
+  throwOnError = false,
+  queryParams
+}) {
+  return await request({
+    method,
+    base: EXTERNAL_BASE,
+    path: path2,
+    data,
+    headers,
+    customAuth,
+    throwOnError,
+    queryParams
+  });
+}
+async function deleteFeature({ id }) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/features/${id}`
+  });
+}
+async function deleteProduct({
+  id,
+  allVersions
+}) {
+  return await externalRequest({
+    method: "DELETE",
+    path: `/products/${id}`,
+    queryParams: { all_versions: allVersions ? true : false }
+  });
+}
+async function updateCLIStripeKeys({
+  stripeSecretKey,
+  autumnSecretKey
+}) {
+  return await request({
+    base: EXTERNAL_BASE,
+    method: "POST",
+    path: "/organization/stripe",
+    data: { secret_key: stripeSecretKey },
+    secretKey: autumnSecretKey
+  });
+}
+
+// source/core/auth.ts
+async function getOTP(otp) {
+  const response = await internalRequest({
+    method: "GET",
+    path: `/dev/otp/${otp}`
+  });
+  return response;
+}
+
+// source/commands/auth.ts
+var passwordTheme = {
+  style: {
+    answer: (text) => {
+      return chalk8__default.default.magenta("*".repeat(text.length));
+    }
+  }
+};
+var inputTheme = {
+  style: {
+    answer: (text) => {
+      return chalk8__default.default.magenta(text);
+    }
+  }
+};
+async function AuthCommand() {
+  if (readFromEnv({ bypass: true })) {
+    let shouldReauth = await prompts.confirm({
+      message: "You are already authenticated. Would you like to re-authenticate?",
+      theme: inputTheme
+    });
+    if (!shouldReauth) return;
+  }
+  open__default.default(`${FRONTEND_URL}/dev/cli`);
+  const otp = await prompts.input({
+    message: "Enter OTP:",
+    theme: inputTheme
+  });
+  const keyInfo = await getOTP(otp);
+  if (!keyInfo.stripe_connected) {
+    let connectStripe = await prompts.confirm({
+      message: "It seems like your organization doesn't have any Stripe keys connected. Would you like to connect your Stripe test secret key now?",
+      theme: inputTheme
+    });
+    if (connectStripe) {
+      let stripeTestKey = await prompts.password({
+        message: "Enter Stripe Test Secret Key:",
+        mask: "*",
+        theme: passwordTheme
+      });
+      await updateCLIStripeKeys({
+        stripeSecretKey: stripeTestKey,
+        autumnSecretKey: keyInfo.sandboxKey
+      });
+      console.log(
+        chalk8__default.default.green(
+          "Stripe test secret key has been saved to your .env file. To connect your Stripe live secret key, please visit the Autumn dashboard here: https://app.useautumn.com/dev?tab=stripe"
+        )
+      );
+    } else {
+      console.log(
+        chalk8__default.default.yellow(
+          "Okay, no worries. Go to the Autumn dashboard when you're ready!"
+        )
+      );
+    }
+  }
+  await storeToEnv(keyInfo.prodKey, keyInfo.sandboxKey);
+  console.log(
+    chalk8__default.default.green(
+      "Success! Sandbox and production keys have been saved to your .env file.\n`atmn` uses the AUTUMN_SECRET_KEY to authenticate with the Autumn API."
+    )
+  );
+}
+async function getAllProducts(params) {
+  const { list: products } = await externalRequest({
+    method: "GET",
+    path: `/products`,
+    queryParams: { include_archived: params?.archived ? true : false }
+  });
+  return [...products];
+}
+async function getFeatures(params) {
+  const { list } = await externalRequest({
+    method: "GET",
+    path: "/features",
+    queryParams: { include_archived: params?.includeArchived ? true : false }
+  });
+  return list.map((feature) => feature);
+}
+var MAX_RECURSION_LIMIT = 500;
+async function getCustomers(limit = 100, offset = 0) {
+  const { list, total } = await externalRequest({
+    method: "GET",
+    path: `/customers?limit=${limit}&offset=${offset}`
+  });
+  const customers = list.map(
+    (customer) => ({
+      id: customer.id,
+      text: customer.name || customer.email || customer.id
+    })
+  );
+  if (offset + limit < total && offset < MAX_RECURSION_LIMIT) {
+    const remainingCustomers = await getCustomers(limit, offset + limit);
+    return [...customers, ...remainingCustomers];
+  } else if (offset >= MAX_RECURSION_LIMIT) {
+    console.log(
+      chalk8__default.default.red(
+        `Reached maximum recursion limit of ${MAX_RECURSION_LIMIT} customers. Exiting.`
+      )
+    );
+    process.exit(1);
+  }
+  return customers;
+}
+
+// source/core/builders/freeTrialBuilder.ts
+function freeTrialBuilder({ freeTrial }) {
+  return `free_trial: {
+		duration: '${freeTrial.duration}',
+		length: ${freeTrial.length},
+		unique_fingerprint: ${freeTrial.unique_fingerprint},
+		card_required: ${freeTrial.card_required},
+	},`;
+}
+
+// source/core/builders/productBuilder.ts
+var ItemBuilders = {
+  priced_feature: pricedFeatureItemBuilder,
+  feature: featureItemBuilder,
+  price: priceItemBuilder
+};
+function importBuilder() {
+  return `
+import {
+	feature,
+	product,
+	featureItem,
+	pricedFeatureItem,
+	priceItem,
+} from 'atmn';
+    `;
+}
+function productBuilder({
+  product,
+  features
+}) {
+  const snippet = `
+export const ${idToVar({ id: product.id, prefix: "product" })} = product({
+    id: '${product.id}',
+    name: '${product.name}',
+    items: [${product.items.map(
+    (item) => `${ItemBuilders[item.type]({
+      item,
+      features
+    })}`
+  ).join("           ")}     ],
+	${product.free_trial ? `${freeTrialBuilder({ freeTrial: product.free_trial })}` : ""}
+})
+`;
+  return snippet;
+}
+var getFeatureIdStr = ({
+  featureId,
+  features
+}) => {
+  if (nullish(featureId)) return "";
+  let feature = features.find((f) => f.id === featureId);
+  if (feature?.archived) return `"${featureId}"`;
+  return `${idToVar({ id: featureId, prefix: "feature" })}.id`;
+};
+var getItemFieldPrefix = () => {
+  return `
+            `;
+};
+var getResetUsageStr = ({
+  item,
+  features
+}) => {
+  if (!item.feature_id) return "";
+  const feature = features.find((f) => f.id === item.feature_id);
+  if (feature.type === "boolean" || feature.type === "credit_system") return "";
+  const defaultResetUsage = feature.type === "single_use" ? true : false;
+  if (notNullish(item.reset_usage_when_enabled) && item.reset_usage_when_enabled !== defaultResetUsage) {
+    return `${getItemFieldPrefix()}reset_usage_when_enabled: ${item.reset_usage_when_enabled},`;
+  }
+  return "";
+};
+var getIntervalStr = ({ item }) => {
+  if (item.interval == null) return ``;
+  return `${getItemFieldPrefix()}interval: '${item.interval}',`;
+};
+var getEntityFeatureIdStr = ({
+  item,
+  features
+}) => {
+  if (nullish(item.entity_feature_id)) return "";
+  const featureIdStr = getFeatureIdStr({
+    featureId: item.entity_feature_id,
+    features
+  });
+  return `${getItemFieldPrefix()}entity_feature_id: ${featureIdStr},`;
+};
+var getPriceStr = ({ item }) => {
+  if (item.tiers) {
+    return `
+		tiers: [
+			${item.tiers.map(
+      (tier) => `{ to: ${tier.to == "inf" ? "'inf'" : tier.to}, amount: ${tier.amount} }`
+    ).join(",\n			")}
+		],`;
+  }
+  if (item.price == null) return "";
+  return `price: ${item.price},`;
+};
+function pricedFeatureItemBuilder({
+  item,
+  features
+}) {
+  const intervalStr = getIntervalStr({ item });
+  const entityFeatureIdStr = getEntityFeatureIdStr({ item, features });
+  const resetUsageStr = getResetUsageStr({ item, features });
+  const priceStr = getPriceStr({ item });
+  const featureIdStr = getFeatureIdStr({ featureId: item.feature_id, features });
+  const snippet = `
+        pricedFeatureItem({
+            feature_id: ${featureIdStr},
+            ${priceStr}${intervalStr}
+            included_usage: ${item.included_usage == "inf" ? `"inf"` : item.included_usage},
+            billing_units: ${item.billing_units},
+            usage_model: '${item.usage_model}',${resetUsageStr}${entityFeatureIdStr}
+        }),
+`;
+  return snippet;
+}
+function featureItemBuilder({
+  item,
+  features
+}) {
+  const featureIdStr = getFeatureIdStr({ featureId: item.feature_id, features });
+  const entityFeatureIdStr = getEntityFeatureIdStr({ item, features });
+  const intervalStr = getIntervalStr({ item });
+  const resetUsageStr = getResetUsageStr({ item, features });
+  const snippet = `
+        featureItem({
+            feature_id: ${featureIdStr},
+            included_usage: ${item.included_usage == "inf" ? `"inf"` : item.included_usage},${intervalStr}${resetUsageStr}${entityFeatureIdStr}
+        }),
+`;
+  return snippet;
+}
+function priceItemBuilder({ item }) {
+  const intervalStr = getIntervalStr({ item });
+  const snippet = `
+        priceItem({
+            price: ${item.price},${intervalStr}
+        }),
+`;
+  return snippet;
+}
+
+// source/core/builders/featureBuilder.ts
+var creditSchemaBuilder = (feature) => {
+  if (feature.type == "credit_system") {
+    let creditSchema = feature.credit_schema || [];
+    return `
+    credit_schema: [
+        ${creditSchema.map(
+      (credit) => `{
+            metered_feature_id: '${credit.metered_feature_id}',
+            credit_cost: ${credit.credit_cost},
+        }`
+    ).join(",\n        ")}
+    ]`;
+  }
+  return "";
+};
+function featureBuilder(feature) {
+  const snippet = `
+export const ${idToVar({ id: feature.id, prefix: "feature" })} = feature({
+    id: '${feature.id}',
+    name: '${feature.name}',
+    type: '${feature.type}',${creditSchemaBuilder(feature)}
+})`;
+  return snippet;
+}
+var ProductItemIntervalEnum = v4.z.enum([
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "semi_annual",
+  "year"
+]);
+var UsageModelEnum = v4.z.enum(["prepaid", "pay_per_use"]);
+var ProductItemSchema = v4.z.object({
+  type: v4.z.enum(["feature", "priced_feature"]).nullish(),
+  feature_id: v4.z.string().nullish(),
+  included_usage: v4.z.union([v4.z.number(), v4.z.literal("inf")]).nullish(),
+  interval: ProductItemIntervalEnum.nullish(),
+  usage_model: UsageModelEnum.nullish(),
+  price: v4.z.number().nullish(),
+  tiers: v4.z.array(
+    v4.z.object({
+      amount: v4.z.number(),
+      to: v4.z.union([v4.z.number(), v4.z.literal("inf")])
+    })
+  ).nullish(),
+  billing_units: v4.z.number().nullish(),
+  // amount per billing unit (eg. $9 / 250 units)
+  reset_usage_when_enabled: v4.z.boolean().optional(),
+  entity_feature_id: v4.z.string().optional()
+});
+v4.z.object({
+  feature_id: v4.z.string(),
+  included_usage: v4.z.number().nullish(),
+  interval: ProductItemIntervalEnum.nullish()
+});
+v4.z.object({
+  price: v4.z.number().gt(0),
+  interval: ProductItemIntervalEnum.nullish()
+});
+
+// source/compose/models/composeModels.ts
+var FreeTrialSchema = v4.z.object({
+  duration: v4.z.enum(["day", "month", "year"]),
+  length: v4.z.number(),
+  unique_fingerprint: v4.z.boolean(),
+  card_required: v4.z.boolean()
+});
+var ProductSchema = v4.z.object({
+  id: v4.z.string().min(1),
+  name: v4.z.string().min(1),
+  is_add_on: v4.z.boolean().prefault(false).optional(),
+  is_default: v4.z.boolean().prefault(false).optional(),
+  items: v4.z.array(ProductItemSchema),
+  free_trial: FreeTrialSchema.optional()
+});
+var FeatureSchema = v4.z.object({
+  id: v4.z.string().min(1),
+  name: v4.z.string().optional(),
+  type: v4.z.enum(["boolean", "single_use", "continuous_use", "credit_system"]),
+  credit_schema: v4.z.array(
+    v4.z.object({
+      metered_feature_id: v4.z.string(),
+      credit_cost: v4.z.number()
+    })
+  ).optional(),
+  archived: v4.z.boolean().optional()
+});
+
+// source/core/config.ts
+function checkAtmnInstalled() {
+  try {
+    const packageJsonPath = path__default.default.join(process.cwd(), "package.json");
+    if (fs__default.default.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs__default.default.readFileSync(packageJsonPath, "utf-8"));
+      return !!(packageJson.dependencies?.atmn || packageJson.devDependencies?.atmn);
+    }
+    child_process.execSync(`node -e "require.resolve('atmn')"`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function installAtmn() {
+  const shouldInstall = await prompts.confirm({
+    message: "The atmn package is not installed. Would you like to install it now?",
+    default: true
+  });
+  if (!shouldInstall) {
+    console.log(
+      chalk8__default.default.yellow(
+        "Skipping installation. You can install atmn manually with your preferred package manager."
+      )
+    );
+    return false;
+  }
+  const packageManager = await prompts.select({
+    message: "Which package manager would you like to use?",
+    choices: [
+      { name: "npm", value: "npm" },
+      { name: "pnpm", value: "pnpm" },
+      { name: "bun", value: "bun" }
+    ],
+    default: "npm"
+  });
+  try {
+    console.log(chalk8__default.default.blue(`Installing atmn with ${packageManager}...`));
+    const installCommand = packageManager === "npm" ? "npm install atmn" : packageManager === "pnpm" ? "pnpm add atmn" : "bun add atmn";
+    child_process.execSync(installCommand, { stdio: "inherit" });
+    console.log(chalk8__default.default.green("atmn installed successfully!"));
+    return true;
+  } catch (error) {
+    console.error(chalk8__default.default.red("Failed to install atmn:"), error);
+    return false;
+  }
+}
+function isProduct(value) {
+  try {
+    ProductSchema.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isFeature(value) {
+  try {
+    FeatureSchema.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function loadAutumnConfigFile() {
+  const configPath = path__default.default.join(process.cwd(), "autumn.config.ts");
+  const absolutePath = path.resolve(configPath);
+  const fileUrl = url.pathToFileURL(absolutePath).href;
+  if (!checkAtmnInstalled()) {
+    const installed = await installAtmn();
+    if (!installed) {
+      throw new Error(
+        "atmn package is required but not installed. Please install it manually."
+      );
+    }
+  }
+  const jiti = createJiti__default.default(importMetaUrl);
+  const mod = await jiti.import(fileUrl);
+  const products = [];
+  const features = [];
+  const defaultExport = mod.default;
+  if (defaultExport && defaultExport.products && defaultExport.features) {
+    if (Array.isArray(defaultExport.products)) {
+      products.push(...defaultExport.products);
+    }
+    if (Array.isArray(defaultExport.features)) {
+      features.push(...defaultExport.features);
+    }
+  } else {
+    for (const [key, value] of Object.entries(mod)) {
+      if (key === "default") continue;
+      if (isProduct(value)) {
+        products.push(value);
+      } else if (isFeature(value)) {
+        features.push(value);
+      }
+    }
+  }
+  const secretKey = readFromEnv();
+  if (secretKey?.includes("live")) {
+    console.log(chalk8__default.default.magentaBright("Running in production environment..."));
+  } else {
+    console.log(chalk8__default.default.yellow("Running in sandbox environment..."));
+  }
+  return {
+    products,
+    features,
+    env: secretKey?.includes("live") ? "prod" : "sandbox"
+  };
+}
+function writeConfig(config) {
+  const configPath = path__default.default.join(process.cwd(), "autumn.config.ts");
+  fs__default.default.writeFileSync(configPath, config);
+}
+
+// source/commands/pull.ts
+async function Pull(options) {
+  console.log(chalk8__default.default.green("Pulling products and features from Autumn..."));
+  const products = await getAllProducts({ archived: options?.archived ?? false });
+  const features = await getFeatures({ includeArchived: true });
+  const productSnippets = products.map(
+    (product) => productBuilder({ product, features })
+  );
+  const featureSnippets = features.filter((feature) => !feature.archived).map((feature) => featureBuilder(feature));
+  const autumnConfig = `
+${importBuilder()}
+
+// Features${featureSnippets.join("\n")}
+
+// Products${productSnippets.join("\n")}
+	`;
+  const formattedConfig = await prettier__default.default.format(autumnConfig, {
+    parser: "typescript",
+    useTabs: true,
+    singleQuote: false
+  });
+  writeConfig(formattedConfig);
+  console.log(chalk8__default.default.green("Success! Config has been updated."));
+}
+
+// source/commands/init.ts
+async function Init() {
+  let apiKey = readFromEnv();
+  if (apiKey) {
+    console.log(chalk8__default.default.green("API key found. Pulling latest config..."));
+    await Pull();
+    console.log(
+      chalk8__default.default.green("Project initialized and config pulled successfully!")
+    );
+    return;
+  }
+  console.log(chalk8__default.default.yellow("No API key found. Running authentication..."));
+  await AuthCommand();
+  apiKey = readFromEnv();
+  if (apiKey) {
+    await Pull();
+    console.log(
+      chalk8__default.default.green(
+        "Project initialized! You are now authenticated and config has been pulled."
+      )
+    );
+  } else {
+    console.log(
+      chalk8__default.default.red(
+        "Authentication did not yield an API key. Please check your setup."
+      )
+    );
+  }
+}
+
+// source/core/nuke.ts
+async function nukeCustomers(customers) {
+  const s = initSpinner("Deleting customers");
+  const total = customers.length;
+  if (total === 0) {
+    s.success("Customers deleted successfully!");
+    return;
+  }
+  const concurrency = Math.max(
+    1,
+    Math.min(total, Number(process.env["ATM_DELETE_CONCURRENCY"] ?? 5) || 5)
+  );
+  let completed = 0;
+  const updateSpinner = () => {
+    s.text = `Deleting customers: ${completed} / ${total}`;
+  };
+  updateSpinner();
+  for (let i = 0; i < total; i += concurrency) {
+    const batch = customers.slice(i, i + concurrency);
+    await Promise.all(
+      batch.map(async (customer) => {
+        try {
+          await deleteCustomer(customer.id);
+        } finally {
+          completed++;
+          updateSpinner();
+        }
+      })
+    );
+  }
+  s.success("Customers deleted successfully!");
+}
+async function deleteCustomer(id) {
+  await externalRequest({
+    method: "DELETE",
+    path: `/customers/${id}`
+  });
+}
+async function nukeProducts(ids) {
+  const s = initSpinner("Deleting products");
+  for (const id of ids) {
+    s.text = `Deleting product [${id}] ${ids.indexOf(id) + 1} / ${ids.length}`;
+    await deleteProduct({ id, allVersions: true });
+  }
+  s.success("Products deleted successfully!");
+}
+async function nukeFeatures(ids) {
+  const s = initSpinner("Deleting features");
+  for (const id of ids) {
+    s.text = `Deleting feature [${id}] ${ids.indexOf(id) + 1} / ${ids.length}`;
+    await deleteFeature({ id });
+  }
+  s.success("Features deleted successfully!");
+}
+
+// source/core/requests/orgRequests.ts
+var getOrg = async () => {
+  const response = await externalRequest({
+    method: "GET",
+    path: "/organization"
+  });
+  return response;
+};
+
+// source/commands/nuke.ts
+async function promptAndConfirmNuke(orgName) {
+  console.log("\n" + chalk8__default.default.bgRed.white.bold("  DANGER: SANDBOX NUKE  "));
+  console.log(
+    chalk8__default.default.red(
+      `This is irreversible. You are about to permanently delete all data from the organization ` + chalk8__default.default.redBright.bold(orgName) + `
+
+Items to be deleted:
+  \u2022 ` + chalk8__default.default.yellowBright("customers") + `
+  \u2022 ` + chalk8__default.default.yellowBright("features") + `
+  \u2022 ` + chalk8__default.default.yellowBright("products") + `
+`
+    )
+  );
+  const shouldProceed = await prompts.confirm({
+    message: `Confirm to continue. This will delete ${chalk8__default.default.redBright.bold("all")} your ${chalk8__default.default.redBright.bold("products")}, ${chalk8__default.default.redBright.bold("features")} and ${chalk8__default.default.redBright.bold("customers")} from your sandbox environment. You will confirm twice.`,
+    default: false
+  });
+  if (!shouldProceed) {
+    console.log(chalk8__default.default.red("Aborting..."));
+    process.exit(1);
+  }
+  const finalConfirm = await prompts.confirm({
+    message: "Final confirmation: Are you absolutely sure? This action is irreversible.",
+    default: false
+  });
+  if (!finalConfirm) {
+    console.log(chalk8__default.default.red("Aborting..."));
+    process.exit(1);
+  }
+  const backupConfirm = await prompts.confirm({
+    message: `Would you like to backup your ${chalk8__default.default.magentaBright.bold("autumn.config.ts")} file before proceeding? (Recommended)`,
+    default: true
+  });
+  return backupConfirm;
+}
+async function Nuke() {
+  const apiKey = readFromEnv();
+  const isSandbox = await isSandboxKey(apiKey);
+  if (isSandbox) {
+    const org = await getOrg();
+    const backupConfirm = await promptAndConfirmNuke(org.name);
+    if (backupConfirm) {
+      fs__default.default.copyFileSync("autumn.config.ts", "autumn.config.ts.backup");
+      console.log(chalk8__default.default.green("Backup created successfully!"));
+    }
+    console.log(chalk8__default.default.red("Nuking sandbox..."));
+    const s = initSpinner(
+      `Preparing ${chalk8__default.default.yellowBright("customers")}, ${chalk8__default.default.yellowBright("features")} and ${chalk8__default.default.yellowBright("products")} for deletion...`
+    );
+    const products = await getAllProducts({ archived: true });
+    const features = await getFeatures();
+    const customers = await getCustomers();
+    s.success(
+      `Loaded all ${chalk8__default.default.yellowBright("customers")}, ${chalk8__default.default.yellowBright("features")} and ${chalk8__default.default.yellowBright("products")} for deletion`
+    );
+    features.sort((a, b) => {
+      if (a.type === "credit_system") {
+        return -1;
+      }
+      return 1;
+    });
+    try {
+      await nukeCustomers(customers);
+      await nukeProducts(products.map((product) => product.id));
+      await nukeFeatures(features.map((feature) => feature.id));
+    } catch (e) {
+      console.error(chalk8__default.default.red("Failed to nuke sandbox:"));
+      console.error(e);
+      process.exit(1);
+    }
+    console.log(chalk8__default.default.green("Sandbox nuked successfully!"));
+  } else {
+    console.log(chalk8__default.default.red`You can't nuke a prod environment!`);
+    process.exit(1);
+  }
+}
+
+// source/core/push.ts
+async function checkForDeletables(currentFeatures, currentProducts) {
+  const features = await getFeatures({ includeArchived: true });
+  const featureIds = features.map((feature) => feature.id);
+  const currentFeatureIds = currentFeatures.map((feature) => feature.id);
+  const featuresToDelete = featureIds.filter(
+    (featureId) => !currentFeatureIds.includes(featureId) && !features.archived
+  );
+  const products = await getAllProducts();
+  const productIds = products.map((product) => product.id);
+  const currentProductIds = currentProducts.map(
+    (product) => product.id
+  );
+  const productsToDelete = productIds.filter(
+    (productId) => !currentProductIds.includes(productId)
+  );
+  return {
+    allFeatures: features,
+    curFeatures: features.filter((feature) => !feature.archived),
+    curProducts: products,
+    featuresToDelete,
+    productsToDelete
+  };
+}
+var isDuplicate = (error) => {
+  return error.response && error.response.data && (error.response.data.code === "duplicate_feature_id" || error.response.data.code === "product_already_exists");
+};
+async function upsertFeature(feature, s) {
+  try {
+    const response = await externalRequest({
+      method: "POST",
+      path: `/features`,
+      data: feature,
+      throwOnError: true
+    });
+    return response.data;
+  } catch (error) {
+    if (isDuplicate(error)) {
+      const response = await externalRequest({
+        method: "POST",
+        path: `/features/${feature.id}`,
+        data: feature
+      });
+      return response.data;
+    }
+    console.error(
+      `
+Failed to push feature ${feature.id}: ${error.response?.data?.message || "Unknown error"}`
+    );
+    process.exit(1);
+  } finally {
+    s.text = `Pushed feature [${feature.id}]`;
+  }
+}
+async function checkProductForConfirmation({
+  curProducts,
+  product
+}) {
+  const curProduct = curProducts.find((p) => p.id === product.id);
+  if (!curProduct) {
+    return {
+      id: product.id,
+      will_version: false
+    };
+  }
+  const res1 = await externalRequest({
+    method: "GET",
+    path: `/products/${product.id}/has_customers`,
+    data: product
+  });
+  return {
+    id: product.id,
+    will_version: res1.will_version,
+    archived: res1.archived
+  };
+}
+async function upsertProduct({
+  curProducts,
+  product,
+  spinner,
+  shouldUpdate = true
+}) {
+  if (!shouldUpdate) {
+    spinner.text = `Skipping update to product ${product.id}`;
+    return {
+      id: product.id,
+      action: "skipped"
+    };
+  }
+  const curProduct = curProducts.find((p) => p.id === product.id);
+  if (!curProduct) {
+    await externalRequest({
+      method: "POST",
+      path: `/products`,
+      data: product
+    });
+    spinner.text = `Created product [${product.id}]`;
+    return {
+      id: product.id,
+      action: "create"
+    };
+  } else {
+    await externalRequest({
+      method: "POST",
+      path: `/products/${product.id}`,
+      data: product
+    });
+    spinner.text = `Updated product [${product.id}]`;
+    return {
+      id: product.id,
+      action: "updated"
+    };
+  }
+}
+
+// source/core/requests/featureRequests.ts
+var updateFeature = async ({
+  id,
+  update
+}) => {
+  return await externalRequest({
+    method: "POST",
+    path: `/features/${id}`,
+    data: update
+  });
+};
+var checkFeatureDeletionData = async ({
+  featureId
+}) => {
+  const res = await externalRequest({
+    method: "GET",
+    path: `/features/${featureId}/deletion_info`
+  });
+  return res;
+};
+
+// source/core/requests/prodRequests.ts
+var getProductDeleteInfo = async ({
+  productId
+}) => {
+  const response = await externalRequest({
+    method: "GET",
+    path: `/products/${productId}/deletion_info`
+  });
+  return response;
+};
+var updateProduct = async ({
+  productId,
+  update
+}) => {
+  const response = await externalRequest({
+    method: "POST",
+    path: `/products/${productId}`,
+    data: update
+  });
+  return response;
+};
+
+// source/commands/push.ts
+var createSpinner = ({ message }) => {
+  const spinner = yoctoSpinner__default.default({
+    text: message ?? ""
+  });
+  spinner.start();
+  return spinner;
+};
+var gatherProductDeletionDecisions = async ({
+  productsToDelete,
+  yes
+}) => {
+  const productDeletionDecisions = /* @__PURE__ */ new Map();
+  const batchCheckProducts = [];
+  for (const productId of productsToDelete) {
+    batchCheckProducts.push(getProductDeleteInfo({ productId }));
+  }
+  const checkProductResults = await Promise.all(batchCheckProducts);
+  for (let i = 0; i < productsToDelete.length; i++) {
+    const productId = productsToDelete[i];
+    const result = checkProductResults[i];
+    if (!productId) continue;
+    if (result && result.totalCount > 0) {
+      const otherCustomersText = result.totalCount > 1 ? ` and ${result.totalCount - 1} other customer(s)` : "";
+      const customerNameText = result.customerName || "Unknown Customer";
+      const shouldArchive = yes || await prompts.confirm({
+        message: `Product ${productId} has customer ${customerNameText}${otherCustomersText}. As such, you cannot delete it. Would you like to archive the product instead?`
+      });
+      productDeletionDecisions.set(
+        productId,
+        shouldArchive ? "archive" : "skip"
+      );
+    } else {
+      productDeletionDecisions.set(productId, "delete");
+    }
+  }
+  return productDeletionDecisions;
+};
+var handleProductDeletion = async ({
+  productsToDelete,
+  yes
+}) => {
+  const productDeletionDecisions = await gatherProductDeletionDecisions({
+    productsToDelete,
+    yes
+  });
+  for (const productId of productsToDelete) {
+    const decision = productDeletionDecisions.get(productId);
+    if (decision === "delete") {
+      const shouldDelete = yes || await prompts.confirm({
+        message: `Delete product [${productId}]?`
+      });
+      if (shouldDelete) {
+        const s = createSpinner({ message: `Deleting product [${productId}]` });
+        await deleteProduct({ id: productId });
+        s.success(`Product [${productId}] deleted successfully!`);
+      }
+    } else if (decision === "archive") {
+      const s = createSpinner({ message: `Archiving product [${productId}]` });
+      await updateProduct({ productId, update: { archived: true } });
+      s.success(`Product [${productId}] archived successfully!`);
+    }
+  }
+};
+var pushFeatures = async ({
+  features,
+  allFeatures,
+  yes
+}) => {
+  for (const feature of features) {
+    const isArchived = allFeatures.find(
+      (f) => f.id === feature.id
+    )?.archived;
+    if (isArchived) {
+      const shouldUnarchive = yes || await prompts.confirm({
+        message: `Feature ${feature.id} is currently archived. Would you like to un-archive it before pushing?`
+      });
+      if (shouldUnarchive) {
+        const s2 = createSpinner({
+          message: `Un-archiving feature [${feature.id}]`
+        });
+        await updateFeature({ id: feature.id, update: { archived: false } });
+        s2.success(`Feature [${feature.id}] un-archived successfully!`);
+      }
+    }
+  }
+  const batchFeatures = [];
+  const s = initSpinner(`Pushing features`);
+  for (const feature of features) {
+    batchFeatures.push(upsertFeature(feature, s));
+  }
+  await Promise.all(batchFeatures);
+  s.success(`Features pushed successfully!`);
+  console.log(chalk8__default.default.dim("\nFeatures pushed:"));
+  features.forEach((feature) => {
+    console.log(chalk8__default.default.cyan(`  \u2022 ${feature.id}`));
+  });
+  console.log();
+};
+var gatherProductDecisions = async ({
+  products,
+  curProducts,
+  yes
+}) => {
+  const productDecisions = /* @__PURE__ */ new Map();
+  const batchCheckProducts = [];
+  for (const product of products) {
+    batchCheckProducts.push(
+      checkProductForConfirmation({
+        curProducts,
+        product
+      })
+    );
+  }
+  const checkProductResults = await Promise.all(batchCheckProducts);
+  for (const result of checkProductResults) {
+    if (result.archived) {
+      const shouldUnarchive = yes || await prompts.confirm({
+        message: `Product ${result.id} is currently archived. Would you like to un-archive it before pushing?`
+      });
+      if (shouldUnarchive) {
+        const s = createSpinner({
+          message: `Un-archiving product [${result.id}]`
+        });
+        await updateProduct({ productId: result.id, update: { archived: false } });
+        s.success(`Product [${result.id}] un-archived successfully!`);
+        productDecisions.set(result.id, true);
+      } else {
+        productDecisions.set(result.id, false);
+      }
+    }
+    if (result.will_version) {
+      const shouldUpdate = yes || await prompts.confirm({
+        message: `Product ${result.id} has customers on it and updating it will create a new version.
+Are you sure you'd like to continue? `
+      });
+      productDecisions.set(result.id, shouldUpdate);
+    } else {
+      productDecisions.set(result.id, true);
+    }
+  }
+  return productDecisions;
+};
+var pushProducts = async ({
+  products,
+  curProducts,
+  productDecisions,
+  yes
+}) => {
+  const s2 = initSpinner(`Pushing products`);
+  const batchProducts = [];
+  for (const product of products) {
+    const shouldUpdate = productDecisions.get(product.id);
+    batchProducts.push(
+      upsertProduct({ curProducts, product, spinner: s2, shouldUpdate })
+    );
+  }
+  const prodResults = await Promise.all(batchProducts);
+  s2.success(`Products pushed successfully!`);
+  console.log(chalk8__default.default.dim("\nProducts pushed:"));
+  prodResults.forEach((result) => {
+    const action = result.action;
+    console.log(
+      chalk8__default.default.cyan(
+        `  \u2022 ${result.id} ${action === "skipped" ? `(${action})` : ""}`
+      )
+    );
+  });
+  console.log();
+  return prodResults;
+};
+var gatherFeatureDeletionDecisions = async ({
+  featuresToDelete,
+  yes
+}) => {
+  const featureDeletionDecisions = /* @__PURE__ */ new Map();
+  const batchCheckFeatures = [];
+  for (const featureId of featuresToDelete) {
+    batchCheckFeatures.push(checkFeatureDeletionData({ featureId }));
+  }
+  const checkFeatureResults = await Promise.all(batchCheckFeatures);
+  for (let i = 0; i < featuresToDelete.length; i++) {
+    const featureId = featuresToDelete[i];
+    const result = checkFeatureResults[i];
+    if (!featureId) continue;
+    if (result && result.totalCount > 0) {
+      const otherProductsText = result.totalCount > 1 ? ` and ${result.totalCount - 1} other products` : "";
+      const productNameText = result.productName || "Unknown Product";
+      const shouldArchive = yes || await prompts.confirm({
+        message: `Feature ${featureId} is being used by product ${productNameText}${otherProductsText}. As such, you cannot delete it. Would you like to archive the feature instead?`
+      });
+      featureDeletionDecisions.set(
+        featureId,
+        shouldArchive ? "archive" : "skip"
+      );
+    } else {
+      featureDeletionDecisions.set(featureId, "delete");
+    }
+  }
+  return featureDeletionDecisions;
+};
+var handleFeatureDeletion = async ({
+  featuresToDelete,
+  yes
+}) => {
+  const featureDeletionDecisions = await gatherFeatureDeletionDecisions({
+    featuresToDelete,
+    yes
+  });
+  for (const featureId of featuresToDelete) {
+    const decision = featureDeletionDecisions.get(featureId);
+    if (decision === "delete") {
+      const shouldDelete = yes || await prompts.confirm({
+        message: `Delete feature [${featureId}]?`
+      });
+      if (shouldDelete) {
+        const s = createSpinner({ message: `Deleting feature [${featureId}]` });
+        await deleteFeature({ id: featureId });
+        s.success(`Feature [${featureId}] deleted successfully!`);
+      }
+    } else if (decision === "archive") {
+      const s = createSpinner({ message: `Archiving feature [${featureId}]` });
+      await updateFeature({ id: featureId, update: { archived: true } });
+      s.success(`Feature [${featureId}] archived successfully!`);
+    }
+  }
+};
+var showSuccessMessage = ({ env, prod }) => {
+  console.log(
+    chalk8__default.default.magentaBright(`Success! Changes have been pushed to ${env}.`)
+  );
+  if (prod) {
+    console.log(
+      chalk8__default.default.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/products`
+      )
+    );
+  } else {
+    console.log(
+      chalk8__default.default.magentaBright(
+        `You can view the products at ${FRONTEND_URL}/sandbox/products`
+      )
+    );
+  }
+};
+async function Push({
+  config,
+  yes,
+  prod
+}) {
+  const { features, products, env } = config;
+  if (env === "prod") {
+    const shouldProceed = yes || await prompts.confirm({
+      message: "You are about to push products to your prod environment. Are you sure you want to proceed?",
+      default: false
+    });
+    if (!shouldProceed) {
+      console.log(chalk8__default.default.yellow("Aborting..."));
+      process.exit(1);
+    }
+  }
+  const { allFeatures, curProducts, featuresToDelete, productsToDelete } = await checkForDeletables(features, products);
+  await handleProductDeletion({ productsToDelete, yes });
+  await pushFeatures({ features, allFeatures, yes });
+  const productDecisions = await gatherProductDecisions({
+    products,
+    curProducts,
+    yes
+  });
+  await pushProducts({ products, curProducts, productDecisions, yes });
+  await handleFeatureDeletion({ featuresToDelete, yes });
+  showSuccessMessage({ env, prod });
+}
+
+// source/cli.ts
+var computedVersion = typeof VERSION !== "undefined" && VERSION ? VERSION : "dev";
+commander.program.version(computedVersion);
+commander.program.option("-p, --prod", "Push to production");
+commander.program.command("env").description("Check the environment of your API key").action(async () => {
+  const env = await isSandboxKey(readFromEnv() ?? "");
+  console.log(chalk8__default.default.green(`Environment: ${env ? "Sandbox" : "Production"}`));
+});
+commander.program.command("nuke").description("Permannently nuke your sandbox.").action(async () => {
+  await Nuke();
+});
+commander.program.command("push").description("Push changes to Autumn").option("-p, --prod", "Push to production").option("-y, --yes", "Confirm all deletions").action(async (options) => {
+  const config = await loadAutumnConfigFile();
+  await Push({ config, yes: options.yes, prod: options.prod });
+});
+commander.program.command("pull").description("Pull changes from Autumn").option("-p, --prod", "Pull from production").action(async (options) => {
+  await Pull({ archived: options.archived ?? false });
+});
+commander.program.command("init").description("Initialize an Autumn project.").action(async () => {
+  writeConfig(DEFAULT_CONFIG);
+  await Init();
+});
+commander.program.command("login").description("Authenticate with Autumn").option("-p, --prod", "Authenticate with production").action(async () => {
+  await AuthCommand();
+});
+commander.program.command("dashboard").description("Open the Autumn dashboard in your browser").action(() => {
+  open__default.default(`${FRONTEND_URL}`);
+});
+commander.program.command("version").alias("v").description("Show the version of Autumn").action(() => {
+  console.log(computedVersion);
+});
+var originalEmit = process.emitWarning;
+process.emitWarning = (warning, ...args) => {
+  const msg = typeof warning === "string" ? warning : warning.message;
+  if (msg.includes("url.parse()")) {
+    return;
+  }
+  return originalEmit(warning, ...args);
+};
+commander.program.parse();