atmn 0.0.1 → 0.0.2

package/dist/app.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+type Props = {
+    name: string | undefined;
+};
+export default function App({ name }: Props): React.JSX.Element;
+export {};

package/dist/app.js

@@ -0,0 +1,7 @@
+import React from 'react';
+import { Text } from 'ink';
+export default function App({ name = 'Stranger' }) {
+    return (React.createElement(Text, null,
+        "Hello, ",
+        React.createElement(Text, { color: "green" }, name)));
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import Init from './commands/init.js';
+import { loadAutumnConfigFile } from './core/config.js';
+import Push from './commands/push.js';
+import Pull from './commands/pull.js';
+import AuthCommand from './commands/auth.js';
+import open from 'open';
+import chalk from 'chalk';
+import { writeConfig } from './core/config.js';
+import { FRONTEND_URL } from './constants.js';
+import { DEFAULT_CONFIG } from './constants.js';
+const VERSION = '1.0.0b';
+program
+    .command('push')
+    .description('Push changes to the remote repository')
+    .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 });
+});
+program
+    .command('pull')
+    .description('Pull changes from Autumn')
+    .option('-p, --prod', 'Pull from production')
+    .action(async () => {
+    const config = await loadAutumnConfigFile();
+    await Pull({ config });
+});
+program
+    .command('init')
+    .description('Initialize an Autumn project.')
+    .action(async () => {
+    writeConfig(DEFAULT_CONFIG); // just write an empty config to make the config file.
+    const config = await loadAutumnConfigFile();
+    await Init({ config });
+});
+program
+    .command('login')
+    .description('Authenticate with Autumn')
+    .option('-p, --prod', 'Authenticate with production')
+    .action(async () => {
+    await AuthCommand();
+});
+program
+    .command('dashboard')
+    .description('Open the Autumn dashboard in your browser')
+    .action(() => {
+    open(`${FRONTEND_URL}`);
+});
+program
+    .command('version')
+    .description('Show the version of Autumn')
+    .action(() => {
+    console.log(chalk.green(`Autumn v${VERSION}`));
+});
+program.parse();

package/dist/commands/auth.d.ts

@@ -0,0 +1 @@
+export default function AuthCommand(): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,63 @@
+import open from 'open';
+import chalk from 'chalk';
+import { input, password, confirm } from '@inquirer/prompts';
+import { storeToEnv, readFromEnv } from '../core/utils.js';
+import { getOTP } from '../core/auth.js';
+import { updateCLIStripeKeys } from '../core/api.js';
+import { FRONTEND_URL } from '../constants.js';
+const passwordTheme = {
+    style: {
+        answer: (text) => {
+            return chalk.magenta('*'.repeat(text.length));
+        },
+    },
+};
+const inputTheme = {
+    style: {
+        answer: (text) => {
+            return chalk.magenta(text);
+        },
+    },
+};
+export default async function AuthCommand() {
+    if (readFromEnv()) {
+        let shouldReauth = await confirm({
+            message: 'You are already authenticated. Would you like to re-authenticate?',
+            theme: inputTheme,
+        });
+        if (!shouldReauth) {
+            return;
+        }
+    }
+    open(`${FRONTEND_URL}/dev/cli`);
+    const otp = await input({
+        message: 'Enter OTP:',
+        theme: inputTheme,
+    });
+    const keyInfo = await getOTP(otp);
+    if (!keyInfo.stripe_connected) {
+        let connectStripe = await confirm({
+            message: "It seems like your organization doesn't have any Stripe keys connected. Would you like to connect them now?",
+            theme: inputTheme,
+        });
+        if (connectStripe) {
+            // Ask for stripe Keys
+            let stripeTestKey = await password({
+                message: 'Enter Stripe Test Secret Key:',
+                mask: '*',
+                theme: passwordTheme,
+            });
+            // let stripeLiveKey = await password({
+            // 	message: 'Enter Stripe Live Key:',
+            // 	mask: '*',
+            // 	theme: passwordTheme,
+            // })
+            await updateCLIStripeKeys(stripeTestKey, stripeTestKey, keyInfo.stripeFlowAuthKey);
+        }
+        else {
+            console.log(chalk.yellow("Okay, no worries. Go to the Autumn dashboard when you're ready!"));
+        }
+    }
+    storeToEnv(keyInfo.prodKey, keyInfo.sandboxKey);
+    console.log(chalk.green('Success! Keys have been stored locally. You may now use the CLI.'));
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+export default function Init({ config }: {
+    config: any;
+}): Promise<void>;

package/dist/commands/init.js

@@ -0,0 +1,26 @@
+import chalk from 'chalk';
+import Pull from './pull.js';
+import AuthCommand from './auth.js';
+import { readFromEnv } from '../core/utils.js';
+export default async function Init({ config }) {
+    // Try to read API key from .env first
+    let apiKey = readFromEnv();
+    if (apiKey) {
+        console.log(chalk.green('API key found. Pulling latest config...'));
+        await Pull({ config });
+        console.log(chalk.green('Project initialized and config pulled successfully!'));
+        return;
+    }
+    // If not found, run authentication
+    console.log(chalk.yellow('No API key found. Running authentication...'));
+    await AuthCommand();
+    // After authentication, try to read the key again
+    apiKey = readFromEnv();
+    if (apiKey) {
+        await Pull({ config });
+        console.log(chalk.green('Project initialized! You are now authenticated and config has been pulled.'));
+    }
+    else {
+        console.log(chalk.red('Authentication did not yield an API key. Please check your setup.'));
+    }
+}

package/dist/commands/pull.d.ts

@@ -0,0 +1,3 @@
+export default function Pull({ config }: {
+    config: any;
+}): Promise<void>;

package/dist/commands/pull.js

@@ -0,0 +1,28 @@
+import chalk from "chalk";
+import { getAllProducts, getFeatures, } from '../core/pull.js';
+import { productBuilder } from '../core/builders/products.js';
+import { featureBuilder } from '../core/builders/features.js';
+import { writeConfig } from '../core/config.js';
+import { importBuilder, exportBuilder } from '../core/builders/products.js';
+import { snakeCaseToCamelCase } from '../core/utils.js';
+export default async function Pull({ config }) {
+    console.log(chalk.green('Pulling products and features from Autumn...'));
+    const products = await getAllProducts();
+    const features = await getFeatures();
+    const productSnippets = products.map(product => productBuilder(product));
+    const featureSnippets = features.map(feature => featureBuilder(feature));
+    const autumnConfig = `
+${importBuilder()}
+
+// Features
+${featureSnippets.join('\n')}
+
+// Products
+${productSnippets.join('\n')}
+
+// Remember to update this when you make changes!
+${exportBuilder(products.map(product => product.id), features.map(feature => snakeCaseToCamelCase(feature.id)))}
+	`;
+    writeConfig(autumnConfig);
+    console.log(chalk.green('Success! Config has been updated.'));
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,5 @@
+export default function Push({ config, yes, prod, }: {
+    config: any;
+    yes: boolean;
+    prod: boolean;
+}): Promise<void>;

package/dist/commands/push.js

@@ -0,0 +1,47 @@
+import chalk from 'chalk';
+import { confirm } from '@inquirer/prompts';
+import { upsertProduct, checkForDeletables, upsertFeature, } from '../core/push.js';
+import { deleteFeature, deleteProduct } from '../core/api.js';
+import { FRONTEND_URL } from '../constants.js';
+export default async function Push({ config, yes, prod, }) {
+    let { features, products } = config;
+    let { featuresToDelete, productsToDelete } = await checkForDeletables(features, products);
+    for (let productId of productsToDelete) {
+        let shouldDelete = yes ||
+            (await confirm({
+                message: `Delete product [${productId}]?`,
+            }));
+        if (shouldDelete) {
+            await deleteProduct(productId);
+            console.log(chalk.green(`Product [${productId}] deleted successfully!`));
+        }
+    }
+    for (let feature of features) {
+        console.log(chalk.green(`Pushing feature [${feature.id}]`));
+        await upsertFeature(feature);
+        console.log(chalk.green(`Pushed feature [${feature.id}]`));
+    }
+    for (let product of products) {
+        console.log(chalk.green(`Pushing product [${product.id}]`));
+        await upsertProduct(product);
+        console.log(chalk.green(`Pushed product [${product.id}]`));
+    }
+    for (let featureId of featuresToDelete) {
+        let shouldDelete = yes ||
+            (await confirm({
+                message: `Delete feature [${featureId}]?`,
+            }));
+        if (shouldDelete) {
+            await deleteFeature(featureId);
+            console.log(chalk.green(`Feature [${featureId}] deleted successfully!`));
+        }
+    }
+    const env = prod ? 'prod' : 'sandbox';
+    console.log(chalk.magentaBright(`Success! Changes have been pushed to ${env}.`));
+    if (prod) {
+        console.log(chalk.magentaBright(`You can view the products at ${FRONTEND_URL}/products`));
+    }
+    else {
+        console.log(chalk.magentaBright(`You can view the products at ${FRONTEND_URL}/sandbox/products`));
+    }
+}

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FRONTEND_URL = "http://app.useautumn.com";
+export declare const BACKEND_URL = "https://api.useautumn.com";
+export declare const DEFAULT_CONFIG = "import {\n\tfeature,\n\tproduct,\n\tpriceItem,\n\tfeatureItem,\n\tpricedFeatureItem,\n} from 'autumn-js/compose';\n\nconst seats = feature({\n\tid: 'seats',\n\tname: 'Seats',\n\ttype: 'continuous_use',\n});\n\nconst messages = feature({\n\tid: 'messages',\n\tname: 'Messages',\n\ttype: 'single_use',\n});\n\nconst pro = product({\n\tid: 'pro',\n\tname: 'Pro',\n\titems: [\n\t\t// 500 messages per month\n\t\tfeatureItem({\n\t\t\tfeature_id: messages.id,\n\t\t\tincluded_usage: 500,\n\t\t\tinterval: 'month',\n\t\t}),\n\n\t\t// $10 per seat per month\n\t\tpricedFeatureItem({\n\t\t\tfeature_id: seats.id,\n\t\t\tprice: 10,\n\t\t\tinterval: 'month',\n\t\t}),\n\n\t\t// $50 / month\n\t\tpriceItem({\n\t\t\tprice: 50,\n\t\t\tinterval: 'month',\n\t\t}),\n\t],\n});\n\nexport default {\n\tfeatures: [seats, messages],\n\tproducts: [pro],\n};\n";

package/dist/constants.js

@@ -0,0 +1,55 @@
+// export const FRONTEND_URL = 'http://localhost:3000';
+// export const BACKEND_URL = 'http://localhost:8080';
+export const FRONTEND_URL = 'http://app.useautumn.com';
+export const BACKEND_URL = 'https://api.useautumn.com';
+export const DEFAULT_CONFIG = `import {
+	feature,
+	product,
+	priceItem,
+	featureItem,
+	pricedFeatureItem,
+} from 'autumn-js/compose';
+
+const seats = feature({
+	id: 'seats',
+	name: 'Seats',
+	type: 'continuous_use',
+});
+
+const messages = feature({
+	id: 'messages',
+	name: 'Messages',
+	type: 'single_use',
+});
+
+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',
+		}),
+	],
+});
+
+export default {
+	features: [seats, messages],
+	products: [pro],
+};
+`;

package/dist/core/api.d.ts

@@ -0,0 +1,27 @@
+export declare function request({ method, base, path, data, headers, customAuth, throwOnError, }: {
+    method: string;
+    base: string;
+    path: string;
+    data?: any;
+    headers?: any;
+    customAuth?: string;
+    throwOnError?: boolean;
+}): Promise<any>;
+export declare function internalRequest({ method, path, data, headers, customAuth, }: {
+    method: string;
+    path: string;
+    data?: any;
+    headers?: any;
+    customAuth?: string;
+}): Promise<any>;
+export declare function externalRequest({ method, path, data, headers, customAuth, throwOnError, }: {
+    method: string;
+    path: string;
+    data?: any;
+    headers?: any;
+    customAuth?: string;
+    throwOnError?: boolean;
+}): Promise<any>;
+export declare function deleteFeature(id: string): Promise<any>;
+export declare function deleteProduct(id: string): Promise<any>;
+export declare function updateCLIStripeKeys(stripeTestKey: string, stripeLiveKey: string, stripeFlowAuthKey: string): Promise<any>;

package/dist/core/api.js

@@ -0,0 +1,75 @@
+import axios from 'axios';
+import chalk from 'chalk';
+import { BACKEND_URL } from '../constants.js';
+import { readFromEnv } from './utils.js';
+const INTERNAL_BASE = BACKEND_URL;
+const EXTERNAL_BASE = `${BACKEND_URL}/v1`;
+export async function request({ method, base, path, data, headers, customAuth, throwOnError = true, }) {
+    const apiKey = readFromEnv();
+    try {
+        const response = await axios.request({
+            method,
+            url: `${base}${path}`,
+            data,
+            headers: {
+                'Content-Type': 'application/json',
+                ...headers,
+                Authorization: customAuth || `Bearer ${apiKey}`,
+            },
+        });
+        return response.data;
+    }
+    catch (error) {
+        if (throwOnError) {
+            throw error;
+        }
+        console.error(chalk.red('Error occured when making API request:'), chalk.red(error.response.data.message || error.response.data.error));
+        process.exit(1);
+    }
+}
+export async function internalRequest({ method, path, data, headers, customAuth, }) {
+    return await request({
+        method,
+        base: INTERNAL_BASE,
+        path,
+        data,
+        headers,
+        customAuth,
+    });
+}
+export async function externalRequest({ method, path, data, headers, customAuth, throwOnError = false, }) {
+    return await request({
+        method,
+        base: EXTERNAL_BASE,
+        path,
+        data,
+        headers,
+        customAuth,
+        throwOnError,
+    });
+}
+export async function deleteFeature(id) {
+    return await externalRequest({
+        method: 'DELETE',
+        path: `/features/${id}`,
+    });
+}
+export async function deleteProduct(id) {
+    return await externalRequest({
+        method: 'DELETE',
+        path: `/products/${id}`,
+    });
+}
+export async function updateCLIStripeKeys(stripeTestKey, stripeLiveKey, stripeFlowAuthKey) {
+    return await internalRequest({
+        method: 'POST',
+        path: '/dev/cli/stripe',
+        data: {
+            stripeTestKey,
+            stripeLiveKey,
+            successUrl: 'https://useautumn.com',
+            defaultCurrency: 'usd',
+        },
+        customAuth: stripeFlowAuthKey,
+    });
+}

package/dist/core/auth.d.ts

@@ -0,0 +1 @@
+export declare function getOTP(otp: string): Promise<any>;

package/dist/core/auth.js

@@ -0,0 +1,8 @@
+import { internalRequest } from './api.js';
+export async function getOTP(otp) {
+    const response = await internalRequest({
+        method: 'GET',
+        path: `/dev/otp/${otp}`,
+    });
+    return response;
+}

package/dist/core/builders/features.d.ts

@@ -0,0 +1,2 @@
+import { Feature } from 'autumn-js/compose';
+export declare function featureBuilder(feature: Feature): string;

package/dist/core/builders/features.js

@@ -0,0 +1,10 @@
+import { snakeCaseToCamelCase } from '../utils.js';
+export function featureBuilder(feature) {
+    const snippet = `
+export const ${snakeCaseToCamelCase(feature.id)} = feature({
+    id: '${feature.id}',
+    name: '${feature.name}',
+    type: '${feature.type}',
+})`;
+    return snippet;
+}

package/dist/core/builders/products.d.ts

@@ -0,0 +1,7 @@
+import { ProductItem, Product } from 'autumn-js/compose';
+export declare function importBuilder(): string;
+export declare function exportBuilder(productIds: string[], featureIds: string[]): string;
+export declare function productBuilder(product: Product): string;
+export declare function pricedFeatureItemBuilder(item: ProductItem): string;
+export declare function featureItemBuilder(item: ProductItem): string;
+export declare function priceItemBuilder(item: ProductItem): string;

package/dist/core/builders/products.js

@@ -0,0 +1,71 @@
+import { snakeCaseToCamelCase } from '../utils.js';
+const ItemBuilders = {
+    priced_feature: pricedFeatureItemBuilder,
+    feature: featureItemBuilder,
+    price: priceItemBuilder,
+};
+export function importBuilder() {
+    return `
+import {
+	feature,
+	product,
+	featureItem,
+	pricedFeatureItem,
+	priceItem,
+} from 'autumn-js/compose';
+    `;
+}
+export function exportBuilder(productIds, featureIds) {
+    const snippet = `
+export default {
+    products: [${productIds.map(id => `${id}Plan`).join(', ')}],
+    features: [${featureIds.map(id => `${id}`).join(', ')}]
+}
+    `;
+    return snippet;
+}
+export function productBuilder(product) {
+    const snippet = `
+export const ${product.id}Plan = product({
+    id: '${product.id}',
+    name: '${product.name}',
+    items: [${product.items
+        .map((item) => `${ItemBuilders[item.type](item)}`)
+        .join('           ')}     ]
+})
+`;
+    return snippet;
+}
+// Item Builders
+export function pricedFeatureItemBuilder(item) {
+    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
+    const snippet = `
+        pricedFeatureItem({
+            feature_id: ${snakeCaseToCamelCase(item.feature_id)}.id,
+            price: ${item.price},${intervalLine}
+            included_usage: ${item.included_usage},
+            billing_units: ${item.billing_units},
+            usage_model: '${item.usage_model}',
+        }),
+`;
+    return snippet;
+}
+export function featureItemBuilder(item) {
+    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
+    const snippet = `
+        featureItem({
+            feature_id: ${snakeCaseToCamelCase(item.feature_id)}.id,
+            included_usage: ${item.included_usage},${intervalLine}
+        }),
+`;
+    return snippet;
+}
+export function priceItemBuilder(item) {
+    const intervalLine = item.interval == null ? '' : `\n            interval: '${item.interval}',`;
+    const snippet = `
+        priceItem({
+            price: ${item.price},${intervalLine}
+        }),
+`;
+    return snippet;
+}

package/dist/core/config.d.ts

@@ -0,0 +1,2 @@
+export declare function loadAutumnConfigFile(): Promise<any>;
+export declare function writeConfig(config: string): void;

package/dist/core/config.js

@@ -0,0 +1,25 @@
+import path from 'path';
+import fs from 'fs';
+import createJiti from 'jiti';
+import { pathToFileURL } from 'url';
+import { resolve } from 'path';
+export async function loadAutumnConfigFile() {
+    const configPath = path.join(process.cwd(), 'autumn.config.ts');
+    const absolutePath = resolve(configPath);
+    const fileUrl = pathToFileURL(absolutePath).href;
+    // Dynamic import the TypeScript config file
+    const jiti = createJiti(import.meta.url);
+    const mod = await jiti.import(fileUrl);
+    const def = mod.default || mod;
+    if (!def.products || !Array.isArray(def.products)) {
+        throw new Error("You must export a products field that is an array of products.");
+    }
+    if (!def.features || !Array.isArray(def.features)) {
+        throw new Error("You must export a features field that is an array of products.");
+    }
+    return def;
+}
+export function writeConfig(config) {
+    const configPath = path.join(process.cwd(), 'autumn.config.ts');
+    fs.writeFileSync(configPath, config);
+}

package/dist/core/pull.d.ts

@@ -0,0 +1,17 @@
+export declare function getProducts(ids: string[]): Promise<{
+    id: string;
+    name: string;
+    items: {
+        type?: "feature" | "priced_feature" | null | undefined;
+        feature_id?: string | null | undefined;
+        included_usage?: number | "inf" | null | undefined;
+        interval?: "minute" | "hour" | "day" | "week" | "month" | "quarter" | "semi_annual" | "year" | null | undefined;
+        usage_model?: "prepaid" | "pay_per_use" | null | undefined;
+        price?: number | null | undefined;
+        billing_units?: number | null | undefined;
+    }[];
+    is_add_on?: boolean | undefined;
+    is_default?: boolean | undefined;
+}[]>;
+export declare function getAllProducts(): Promise<any>;
+export declare function getFeatures(): Promise<any>;

package/dist/core/pull.js

@@ -0,0 +1,22 @@
+import { externalRequest } from './api.js';
+export async function getProducts(ids) {
+    const products = await Promise.all(ids.map(id => externalRequest({
+        method: 'GET',
+        path: `/products/${id}`,
+    })));
+    return products.map(product => product);
+}
+export async function getAllProducts() {
+    const { list } = await externalRequest({
+        method: 'GET',
+        path: '/products',
+    });
+    return list.map(product => product);
+}
+export async function getFeatures() {
+    const { list } = await externalRequest({
+        method: 'GET',
+        path: '/features',
+    });
+    return list.map(feature => feature);
+}

package/dist/core/push.d.ts

@@ -0,0 +1,7 @@
+import { Feature, Product } from 'autumn-js/compose';
+export declare function checkForDeletables(currentFeatures: Feature[], currentProducts: Product[]): Promise<{
+    featuresToDelete: any;
+    productsToDelete: any;
+}>;
+export declare function upsertFeature(feature: Feature): Promise<any>;
+export declare function upsertProduct(product: Product): Promise<any>;

package/dist/core/push.js

@@ -0,0 +1,67 @@
+import { externalRequest } from './api.js';
+import { getFeatures, getAllProducts } from './pull.js';
+export async function checkForDeletables(currentFeatures, currentProducts) {
+    const features = await getFeatures(); // Get from AUTUMN
+    const featureIds = features.map(feature => feature.id);
+    const currentFeatureIds = currentFeatures.map(feature => feature.id);
+    const featuresToDelete = featureIds.filter(featureId => !currentFeatureIds.includes(featureId));
+    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 { featuresToDelete, productsToDelete };
+}
+export async function upsertFeature(feature) {
+    try {
+        const response = await externalRequest({
+            method: 'POST',
+            path: `/features`,
+            data: feature,
+            throwOnError: true,
+            // data: {
+            // 	...feature,
+            // 	config: {
+            // 		filters: [{property: '', operator: '', value: []}],
+            // 		usage_type: 'single_use',
+            // 	},
+            // },
+        });
+        return response.data;
+    }
+    catch (error) {
+        // If the first request fails, try posting to the specific feature ID endpoint
+        const response = await externalRequest({
+            method: 'POST',
+            path: `/features/${feature.id}`,
+            data: feature,
+            // data: {
+            // 	...feature,
+            // 	config: {
+            // 		filters: [{property: '', operator: '', value: []}],
+            // 		usage_type: 'single_use',
+            // 	},
+            // },
+        });
+        return response.data;
+    }
+}
+export async function upsertProduct(product) {
+    try {
+        const response = await externalRequest({
+            method: 'POST',
+            path: `/products`,
+            data: product,
+            throwOnError: true,
+        });
+        return response.data;
+    }
+    catch (error) {
+        // If the first request fails, try posting to the specific product ID endpoint
+        const response = await externalRequest({
+            method: 'POST',
+            path: `/products/${product.id}`,
+            data: product,
+        });
+        return response.data;
+    }
+}

package/dist/core/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function snakeCaseToCamelCase(value: string): string;
+export declare function storeToEnv(prodKey: string, sandboxKey: string): void;
+export declare function readFromEnv(): string;

package/dist/core/utils.js

@@ -0,0 +1,26 @@
+import fs from 'fs';
+import chalk from 'chalk';
+export function snakeCaseToCamelCase(value) {
+    return value.replace(/_([a-z])/g, (match, letter) => letter.toUpperCase());
+}
+export function storeToEnv(prodKey, sandboxKey) {
+    const envPath = `${process.cwd()}/.env`;
+    const envVars = `# AUTUMN_SECRET_KEY=${prodKey}\nAUTUMN_SECRET_KEY=${sandboxKey}\n`;
+    if (fs.existsSync(envPath)) {
+        fs.appendFileSync(envPath, envVars);
+        console.log(chalk.green('.env file found. Appended keys.'));
+    }
+    else {
+        fs.writeFileSync(envPath, envVars);
+        console.log(chalk.green('.env file not found. Created new .env file and wrote keys.'));
+    }
+}
+export function readFromEnv() {
+    const envPath = `${process.cwd()}/.env`;
+    if (!fs.existsSync(envPath)) {
+        return undefined;
+    }
+    const envContent = fs.readFileSync(envPath, 'utf-8');
+    const match = envContent.match(/^AUTUMN_SECRET_KEY=(.*)$/m);
+    return match ? match[1] : undefined;
+}

package/package.json

@@ -1,12 +1,65 @@
 {
-  "name": "atmn",
-  "version": "0.0.1",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "John Yeo",
-  "license": "ISC"
+	"name": "atmn",
+	"version": "0.0.2",
+	"license": "MIT",
+	"bin": "dist/cli.js",
+	"main": "dist/cli.js",
+	"type": "module",
+	"engines": {
+		"node": ">=16"
+	},
+	"scripts": {
+		"build": "tsc",
+		"dev": "tsc --watch",
+		"test2": "prettier --check . && xo && ava",
+		"test": "node ./dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"package.json",
+		"README.md"
+	],
+	"dependencies": {
+		"@inquirer/prompts": "^7.6.0",
+		"autumn-js": "workspace:*",
+		"axios": "^1.10.0",
+		"commander": "^14.0.0",
+		"dotenv": "^17.2.0",
+		"inquirer": "^12.7.0",
+		"jiti": "^2.4.2",
+		"open": "^10.1.2"
+	},
+	"devDependencies": {
+		"@sindresorhus/tsconfig": "^3.0.1",
+		"@types/node": "^24.0.10",
+		"@types/react": "^18.0.32",
+		"@vdemedes/prettier-config": "^2.0.1",
+		"ava": "^5.2.0",
+		"chalk": "^5.2.0",
+		"eslint-config-xo-react": "^0.27.0",
+		"eslint-plugin-react": "^7.32.2",
+		"eslint-plugin-react-hooks": "^4.6.0",
+		"ink-testing-library": "^3.0.0",
+		"prettier": "^2.8.7",
+		"ts-node": "^10.9.1",
+		"typescript": "^5.0.3",
+		"xo": "^0.53.1"
+	},
+	"ava": {
+		"extensions": {
+			"ts": "module",
+			"tsx": "module"
+		},
+		"nodeArguments": [
+			"--loader=ts-node/esm"
+		]
+	},
+	"xo": {
+		"extends": "xo-react",
+		"prettier": true,
+		"rules": {
+			"react/prop-types": "off"
+		}
+	},
+	"prettier": "@vdemedes/prettier-config"
 }

package/readme.md

@@ -0,0 +1,25 @@
+# cli
+
+> This readme is automatically generated by [create-ink-app](https://github.com/vadimdemedes/create-ink-app)
+
+## Install
+
+```bash
+$ npm install --global cli
+```
+
+## CLI
+
+```
+$ cli --help
+
+  Usage
+    $ cli
+
+  Options
+    --name  Your name
+
+  Examples
+    $ cli --name=Jane
+    Hello, Jane
+```