mlcl 1.0.0

package/build/commands/clone.js

@@ -0,0 +1,329 @@
+import fs from 'fs';
+import path from 'path';
+import { userConfig } from '../userConfig.js';
+import { userLoggedIn } from '../utilities/userLoggedIn.js';
+import { getPlan } from '../API/resource/molecule/utilities/getPlan.js';
+import { confirmSshKey } from '../API/resource/device/utilities/confirmSshKey.js';
+import * as API from '../API/index.js';
+import { logger } from '../logger.js';
+import { getErrorMessage } from '../utilities/getErrorMessage.js';
+import { cloneRepo } from './utilities/cloneRepo.js';
+import { checkoutSelectionBranch } from './utilities/checkoutSelectionBranch.js';
+import { enableMergeDrivers } from './utilities/enableMergeDrivers.js';
+import { cherryPick } from './utilities/cherryPick.js';
+import { asyncExec } from './utilities/asyncExec.js';
+import { convertTypeDocToJSDoc } from './utilities/convertTypeDocToJSDoc.js';
+import { convertNpmToYarn } from './utilities/convertNpmToYarn.js';
+import { convertTypeScriptToJavaScript } from './utilities/convertTypeScriptToJavaScript.js';
+/**
+ * Adds the `clone` command to the program.
+ */
+export const clone = (program) => {
+    program.command(`clone`)
+        .description(`clones your Molecule into \`project-name-api\` and/or \`project-name-app\``)
+        .argument(`<id>`, `your Molecule's ID`)
+        .argument(`[projectName]`, `a directory for your Molecule, usually something like \`project-name\``)
+        .action(async (id = ``, projectName = ``) => {
+        if (!id) {
+            logger.warn(`Molecule ID is required.`);
+            return;
+        }
+        const user = await userLoggedIn();
+        if (!user) {
+            return;
+        }
+        try {
+            logger.info(`Fetching your Molecule's clone information...`);
+            const { props, apiCommits, apiRepoUrl, appCommits, appRepoUrl, } = (await API.resource.molecule.readClone(id)).data;
+            const { name, apiSelectionHash, appSelectionHash, } = props;
+            if (((!apiSelectionHash || !apiRepoUrl)) && (!appSelectionHash || !appRepoUrl)) {
+                logger.warn(`Failed to fetch the necessary information to clone your Molecule. Please contact developer-support@molecule.dev so we can fix this.`);
+                return;
+            }
+            const moleculePlan = getPlan(props);
+            if (moleculePlan?.capabilities.forMolecules && moleculePlan?.capabilities.premium) {
+                const deviceId = userConfig.userIdsToDeviceIds?.[user.id] || ``;
+                if (!deviceId) {
+                    logger.warn(`No device ID for the current user. Try logging out and in again.`);
+                    return;
+                }
+                const confirmedSshKey = await confirmSshKey(deviceId, user.username);
+                if (!confirmedSshKey) {
+                    return;
+                }
+            }
+            projectName = projectName || name?.replace(/ /gi, `-`).replace(/[^A-z0-9-]/gi, ``).toLowerCase() || `your`;
+            const apiRepoPath = `${projectName}-api`;
+            const appRepoPath = `${projectName}-app`;
+            let apiError = false;
+            let appError = false;
+            if (apiSelectionHash && apiRepoUrl) {
+                let resetMergeDrivers = null;
+                const writeNewRepoConfig = async () => {
+                    const repoConfigPath = path.join(apiRepoPath, `.mlclrc.json`);
+                    logger.info(`Creating ${apiRepoPath}/.mlclrc.json...`);
+                    try {
+                        await fs.promises.access(repoConfigPath, fs.constants.R_OK | fs.constants.W_OK);
+                        logger.info(`${apiRepoPath}/.mlclrc.json already exists on your machine!`);
+                        apiError = true;
+                    }
+                    catch (error) {
+                        await fs.promises.writeFile(repoConfigPath, JSON.stringify({ id }, null, 2));
+                    }
+                };
+                try {
+                    await fs.promises.access(apiRepoPath, fs.constants.R_OK | fs.constants.W_OK);
+                    logger.warn(`Error cloning API: ${apiRepoPath} already exists on your machine!`);
+                    apiError = true;
+                }
+                catch (error) {
+                    try {
+                        await cloneRepo(apiRepoUrl, apiRepoPath);
+                    }
+                    catch (error) {
+                        logger.warn(`Error cloning API: ${getErrorMessage(error) || `Unknown error`}`);
+                        apiError = true;
+                    }
+                }
+                try {
+                    const createdEmptyBranch = await checkoutSelectionBranch(apiSelectionHash, apiRepoPath, `remotes/origin`);
+                    if (!createdEmptyBranch) {
+                        await writeNewRepoConfig();
+                        logger.info(`API is ready.`);
+                    }
+                    else if (apiCommits?.length) {
+                        const convert = {
+                            typeScriptToJavaScript: props.selection.apiLanguage === `JavaScript`,
+                            typeDocToJSDoc: props.selection.apiDocs === `JSDoc`,
+                            npmToYarn: props.selection.apiPackageManager === `Yarn`,
+                        };
+                        logger.info(`You are the first to assemble this particular Molecule API!`);
+                        resetMergeDrivers = enableMergeDrivers(apiRepoPath);
+                        logger.info(`Cherry picking the relevant commits...`);
+                        while (apiCommits.length) {
+                            const commit = apiCommits.shift();
+                            if (commit?.hash) {
+                                logger.info(`Cherry picking ${commit.hash.substring(0, 7)} (${commit.subject || `Unknown commit??? This should never happen!!!`})`);
+                                await cherryPick(commit.hash, apiRepoPath, `-x`);
+                            }
+                            else {
+                                logger.info(`No commit to cherry pick??? This should never happen!!!`);
+                            }
+                        }
+                        resetMergeDrivers();
+                        if (convert.typeDocToJSDoc || convert.npmToYarn || convert.typeScriptToJavaScript) {
+                            // Delete package-lock.json for any of these.
+                            try {
+                                const packageLockPath = path.join(apiRepoPath, `package-lock.json`);
+                                await fs.promises.unlink(packageLockPath);
+                            }
+                            catch (error) {
+                            }
+                        }
+                        if (convert.typeDocToJSDoc) {
+                            try {
+                                logger.info(`Converting TypeDoc to JSDoc...`);
+                                await convertTypeDocToJSDoc(apiRepoPath);
+                                await asyncExec(`git -C "${apiRepoPath}" add --all`);
+                                await asyncExec(`git -C "${apiRepoPath}" commit -m "convert typedoc to jsdoc"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        if (convert.npmToYarn) {
+                            try {
+                                logger.info(`Converting NPM to Yarn...`);
+                                await convertNpmToYarn(apiRepoPath);
+                                await asyncExec(`git -C "${apiRepoPath}" add --all`);
+                                await asyncExec(`git -C "${apiRepoPath}" commit -m "convert npm to yarn"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        if (convert.typeScriptToJavaScript) {
+                            try {
+                                logger.info(`Converting TypeScript to JavaScript...`);
+                                await convertTypeScriptToJavaScript(apiRepoPath);
+                                await asyncExec(`git -C "${apiRepoPath}" add --all`);
+                                await asyncExec(`git -C "${apiRepoPath}" commit -m "convert typescript to javascript"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        await writeNewRepoConfig();
+                        logger.info(`API is ready.`);
+                    }
+                    else {
+                        logger.warn(`Created an empty branch but no commits to cherry pick.`);
+                        apiError = true;
+                    }
+                }
+                catch (error) {
+                    if (resetMergeDrivers) {
+                        resetMergeDrivers();
+                    }
+                    logger.warn(`Error assembling API: ${getErrorMessage(error) || `Unknown error`}`);
+                    apiError = true;
+                }
+            }
+            if (appSelectionHash && appRepoUrl) {
+                let resetMergeDrivers = null;
+                const writeNewRepoConfig = async () => {
+                    const repoConfigPath = path.join(appRepoPath, `.mlclrc.json`);
+                    logger.info(`Creating ${appRepoPath}/.mlclrc.json...`);
+                    try {
+                        await fs.promises.access(repoConfigPath, fs.constants.R_OK | fs.constants.W_OK);
+                        logger.info(`${appRepoPath}/.mlclrc.json already exists on your machine!`);
+                        appError = true;
+                    }
+                    catch (error) {
+                        await fs.promises.writeFile(repoConfigPath, JSON.stringify({ id }, null, 2));
+                    }
+                };
+                try {
+                    await fs.promises.access(appRepoPath, fs.constants.R_OK | fs.constants.W_OK);
+                    logger.warn(`Error cloning app: ${appRepoPath} already exists on your machine!`);
+                    appError = true;
+                }
+                catch (error) {
+                    try {
+                        await cloneRepo(appRepoUrl, appRepoPath);
+                    }
+                    catch (error) {
+                        logger.warn(`Error cloning app: ${getErrorMessage(error) || `Unknown error`}`);
+                        appError = true;
+                    }
+                }
+                try {
+                    const createdEmptyBranch = await checkoutSelectionBranch(appSelectionHash, appRepoPath, `remotes/origin`);
+                    if (!createdEmptyBranch) {
+                        await writeNewRepoConfig();
+                        logger.info(`App is ready.`);
+                    }
+                    else if (appCommits?.length) {
+                        const convert = {
+                            typeScriptToJavaScript: props.selection.appLanguage === `JavaScript`,
+                            typeDocToJSDoc: props.selection.appDocs === `JSDoc`,
+                            npmToYarn: props.selection.appPackageManager === `Yarn`,
+                        };
+                        logger.info(`You are the first to assemble this particular Molecule app!`);
+                        resetMergeDrivers = enableMergeDrivers(appRepoPath);
+                        logger.info(`Cherry picking the relevant commits...`);
+                        while (appCommits.length) {
+                            const commit = appCommits.shift();
+                            if (commit?.hash) {
+                                logger.info(`Cherry picking ${commit.hash.substring(0, 7)} (${commit.subject || `Unknown commit??? This should never happen!!!`})`);
+                                await cherryPick(commit.hash, appRepoPath, `-x`);
+                            }
+                            else {
+                                logger.info(`No commit to cherry pick??? This should never happen!!!`);
+                            }
+                        }
+                        resetMergeDrivers();
+                        if (convert.typeDocToJSDoc || convert.npmToYarn || convert.typeScriptToJavaScript) {
+                            // Delete package-lock.json for any of these.
+                            try {
+                                const packageLockPath = path.join(appRepoPath, `package-lock.json`);
+                                await fs.promises.unlink(packageLockPath);
+                            }
+                            catch (error) {
+                            }
+                        }
+                        if (convert.typeDocToJSDoc) {
+                            try {
+                                logger.info(`Converting TypeDoc to JSDoc...`);
+                                await convertTypeDocToJSDoc(appRepoPath);
+                                await asyncExec(`git -C "${appRepoPath}" add --all`);
+                                await asyncExec(`git -C "${appRepoPath}" commit -m "convert typedoc to jsdoc"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        if (convert.npmToYarn) {
+                            try {
+                                logger.info(`Converting NPM to Yarn...`);
+                                await convertNpmToYarn(appRepoPath);
+                                await asyncExec(`git -C "${appRepoPath}" add --all`);
+                                await asyncExec(`git -C "${appRepoPath}" commit -m "convert npm to yarn"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        if (convert.typeScriptToJavaScript) {
+                            try {
+                                logger.info(`Converting TypeScript to JavaScript...`);
+                                await convertTypeScriptToJavaScript(appRepoPath);
+                                await asyncExec(`git -C "${appRepoPath}" add --all`);
+                                await asyncExec(`git -C "${appRepoPath}" commit -m "convert typescript to javascript"`);
+                            }
+                            catch (error) {
+                                logger.warn(`Error: ${getErrorMessage(error)}`);
+                                throw error;
+                            }
+                        }
+                        await writeNewRepoConfig();
+                        logger.info(`App is ready.`);
+                    }
+                    else {
+                        logger.warn(`Created an empty branch but no commits to cherry pick.`);
+                        appError = true;
+                    }
+                }
+                catch (error) {
+                    if (resetMergeDrivers) {
+                        resetMergeDrivers();
+                    }
+                    logger.warn(`Error assembling app: ${getErrorMessage(error) || `Unknown error`}`);
+                    appError = true;
+                }
+            }
+            if (apiSelectionHash && appSelectionHash) {
+                if (apiError || appError) {
+                    logger.info(`There may have been an error cloning your Molecule.`);
+                    logger.info(`If everything seems good, see \`${apiRepoPath}/README.md\` and \`${appRepoPath}/README.md\` to get started.`);
+                    logger.info(`If not, please contact developer-support@molecule.dev so we can fix this.`);
+                }
+                else {
+                    logger.info(`Your Molecule was successfully cloned!`);
+                    logger.info(`See \`${apiRepoPath}/README.md\` and \`${appRepoPath}/README.md\` to get started.`);
+                }
+            }
+            else if (apiSelectionHash) {
+                if (apiError) {
+                    logger.info(`There may have been an error cloning your Molecule API.`);
+                    logger.info(`If everything seems good, see \`${apiRepoPath}/README.md\` to get started.`);
+                    logger.info(`If not, please contact developer-support@molecule.dev so we can fix this.`);
+                }
+                else {
+                    logger.info(`Your Molecule API was successfully cloned!`);
+                    logger.info(`See \`${apiRepoPath}/README.md\` to get started.`);
+                }
+            }
+            else if (appSelectionHash) {
+                if (appError) {
+                    logger.info(`There may have been an error cloning your Molecule app.`);
+                    logger.info(`If everything seems good, see \`${appRepoPath}/README.md\` to get started.`);
+                    logger.info(`If not, please contact developer-support@molecule.dev so we can fix this.`);
+                }
+                else {
+                    logger.info(`Your Molecule app was successfully cloned!`);
+                    logger.info(`See \`${appRepoPath}/README.md\` to get started.`);
+                }
+            }
+        }
+        catch (error) {
+            logger.warn(`Error cloning Molecule: ${getErrorMessage(error) || `Unknown error`}`);
+            logger.warn(`Please contact developer-support@molecule.dev so we can fix this.`);
+        }
+    });
+};

package/build/commands/index.js

@@ -0,0 +1,17 @@
+/**
+ * Every available command and utilities.
+ *
+ * @module
+ */
+export * as utilities from './utilities/index.js';
+export * from './add-ssh-key.js';
+export * from './buy.js';
+export * from './clone.js';
+export * from './info.js';
+export * from './login.js';
+export * from './logout.js';
+export * from './remove-ssh-key.js';
+export * from './subscribe.js';
+export * from './unsubscribe.js';
+export * from './version.js';
+export * from './x-merge-json.js';

package/build/commands/info.js

@@ -0,0 +1,33 @@
+import open from 'open';
+import { userLoggedIn } from '../utilities/userLoggedIn.js';
+import { repoConfig } from '../repoConfig.js';
+import { logger } from '../logger.js';
+import { getErrorMessage } from '../utilities/getErrorMessage.js';
+/**
+ * Adds the `info` command to the program.
+ */
+export const info = (program) => {
+    program.command(`info`)
+        .description(`opens your Molecule's information on Molecule.dev`)
+        .action(async () => {
+        const user = await userLoggedIn();
+        if (!user) {
+            return;
+        }
+        if (!repoConfig?.id) {
+            logger.warn(`Not within a Molecule repository or \`.mlclrc.json\` not found.`);
+            return;
+        }
+        const url = `${process.env.WEB_ORIGIN}/#/${encodeURIComponent(repoConfig.id)}`;
+        const childProcess = await open(url);
+        childProcess.on(`error`, error => {
+            logger.warn(`Error opening the URL: ${getErrorMessage(error)}`);
+            logger.warn(`If your browser didn't open on its own, visit the following URL: ${url}`);
+        });
+        childProcess.on(`close`, code => {
+            if (code !== 0) {
+                logger.warn(`If your browser didn't open on its own, visit the following URL: ${url}`);
+            }
+        });
+    });
+};

package/build/commands/login.js

@@ -0,0 +1,20 @@
+import { userConfig } from '../userConfig.js';
+import { synchronizeUserConfig } from '../utilities/synchronizeUserConfig.js';
+import * as API from '../API/index.js';
+import { logger } from '../logger.js';
+/**
+ * Adds the `login` command to the program.
+ */
+export const login = (program) => {
+    program.command(`login`)
+        .description(`log into mlcl with your Molecule.dev account via the browser`)
+        .action(async () => {
+        await synchronizeUserConfig();
+        if (userConfig.user) {
+            logger.info(`Logged in as ${userConfig.user.username}.`);
+            logger.info(`If you would like to log in as another user, run \`mlcl logout\` first.`);
+            return;
+        }
+        await API.resource.user.utilities.logIn();
+    });
+};

package/build/commands/logout.js

@@ -0,0 +1,23 @@
+import { userConfig } from '../userConfig.js';
+import { synchronizeUserConfig } from '../utilities/synchronizeUserConfig.js';
+import { writeUserConfig } from '../utilities/writeUserConfig.js';
+import * as API from '../API/index.js';
+import { logger } from '../logger.js';
+/**
+ * Adds the `logout` command to the program.
+ */
+export const logout = (program) => {
+    program.command(`logout`)
+        .description(`logs out of your Molecule.dev account`)
+        .action(async () => {
+        await synchronizeUserConfig();
+        if (!userConfig?.user?.id) {
+            logger.warn(`Not logged in.`);
+            return;
+        }
+        API.resource.user.logOut();
+        delete userConfig.user;
+        writeUserConfig();
+        logger.info(`Logged out.`);
+    });
+};

package/build/commands/molecule/index.js

@@ -0,0 +1,11 @@
+/**
+ * The `molecule` API resource.
+ *
+ * @module
+ */
+import { client } from '../../client';
+export * as types from './types';
+export const read = (id) => (client.get(`molecules/${id}`));
+export const create = (props) => (client.post(`molecules`, props));
+export const update = (id, props) => (client.patch(`molecules/${id}`, props));
+export const updatePlan = (id, { planKey, receipt, quantity }) => (client.patch(`molecules/${id}/plan`, { planKey, receipt, quantity }));

package/build/commands/molecule/types.js

@@ -0,0 +1,6 @@
+/**
+ * Molecule type definitions.
+ *
+ * @module
+ */
+export {};

package/build/commands/remove-ssh-key.js

@@ -0,0 +1,36 @@
+import { userConfig } from '../userConfig.js';
+import { userLoggedIn } from '../utilities/userLoggedIn.js';
+import * as API from '../API/index.js';
+import { logger } from '../logger.js';
+import { getErrorMessage } from '../utilities/getErrorMessage.js';
+/**
+ * Adds the `remove-ssh-key` command to the program.
+ */
+export const removeSshKey = (program) => {
+    program.command(`remove-ssh-key`)
+        .description(`removes your current CLI device's SSH key from your Molecule.dev account`)
+        .action(async () => {
+        const user = await userLoggedIn();
+        if (!user) {
+            return;
+        }
+        const deviceId = userConfig.userIdsToDeviceIds?.[user.id] || ``;
+        if (!deviceId) {
+            logger.warn(`No device ID for the current user. Try logging out and in again.`);
+            return;
+        }
+        logger.info(`Removing public SSH key from the API...`);
+        try {
+            const { props } = (await API.resource.device.update(deviceId, { sshKey: `` })).data;
+            if (props.sshKey === ``) {
+                logger.info(`SSH key successfully removed!`);
+            }
+            else {
+                logger.info(`Failed to remove SSH key.`);
+            }
+        }
+        catch (error) {
+            logger.warn(`Failed to remove SSH key. ${getErrorMessage(error)}`);
+        }
+    });
+};

package/build/commands/select.js

@@ -0,0 +1,98 @@
+import * as utilities from './utilities/index.js';
+/**
+ * Adds the `select` command to the program.
+ */
+export const select = (program) => {
+    program.command(`select`)
+        .description(`manage the current selection`)
+        .argument(`[hash]`, `select by known hash/branch`)
+        .option(`--path <path>`, `the path to your Molecule configuration file`, `.mlclrc.json`)
+        .option(`--show`, `show the current selection`)
+        .option(`--appLanguage [appLanguage]`, `select app language`)
+        .option(`--appPackageManager [appPackageManager]`, `select app package manager`)
+        .option(`--appRenderer [appRenderer]`, `select app renderer`)
+        .option(`--appDocs [appDocs]`, `select app documentation library`)
+        .option(`--appTesting [appTesting]`, `select app testing library`)
+        .option(`--appLogging [appLogging]`, `select app logging library`)
+        .option(`--appPlatformSupport [appPlatformSupport]`, `select app platform support`)
+        .option(`--no-appPlatformSupport`, `disable app platform support`)
+        .option(`--appPlatforms [appPlatforms...]`, `select app platform(s)`)
+        .option(`--appUi [appUi]`, `select app UI library`)
+        .option(`--appThemes [appThemes...]`, `select app theme(s)`)
+        .option(`--userAuthentication [userAuthentication...]`, `select user authentication method(s)`)
+        .option(`--no-userAuthentication`, `disable user authentication`)
+        .option(`--oauthServers [oauthServers...]`, `select OAuth server(s)`)
+        .option(`--no-oauthServers [oauthServers...]`, `disable OAuth servers`)
+        .option(`--pushNotifications [pushNotifications]`, `enable/disable push notifications`)
+        .option(`--no-pushNotifications`, `disable push notifications`)
+        .option(`--paymentPlatforms [paymentPlatforms...]`, `select payment platform(s)`)
+        .option(`--no-paymentPlatforms`, `disable payment platforms`)
+        .option(`--appDeployment [appDeployment]`, `select app deployment method`)
+        .option(`--no-appDeployment`, `disable app deployment`)
+        .option(`--apiLanguage [apiLanguage]`, `select API language`)
+        .option(`--apiPackageManager [apiPackageManager]`, `select API package manager`)
+        .option(`--apiDocs [apiDocs]`, `select API documentation library`)
+        .option(`--apiTesting [apiTesting]`, `select API testing library`)
+        .option(`--apiLogging [apiLogging]`, `select API logging library`)
+        .option(`--apiDatabase [apiDatabase]`, `select API database`)
+        .option(`--apiEmails [apiEmails]`, `select API email method`)
+        .option(`--no-apiEmails`, `disable API emails`)
+        .option(`--apiUploads [apiUploads]`, `select API upload handler`)
+        .option(`--no-apiUploads`, `disable API uploads`)
+        .option(`--apiDeployment [apiDeployment]`, `select API deployment method`)
+        .option(`--no-apiDeployment`, `disable API deployment`)
+        .action(async (hash, options) => {
+        const path = options.path;
+        const config = utilities.readConfig(path);
+        if (!config) {
+            return;
+        }
+        let selection = config.selection;
+        if (hash) {
+            selection = config.selectionHashMap?.[hash.replace(/^mlcl-/, ``)];
+            if (!selection) {
+                console.warn(`Unknown hash.`);
+                return;
+            }
+        }
+        const showSelection = () => {
+            if (selection) {
+                console.info(`Current selection:`, selection);
+            }
+            else {
+                console.info(`No selection found in config.`);
+            }
+        };
+        if (options.show) {
+            showSelection();
+            return;
+        }
+        if (!selection) {
+            selection = {};
+        }
+        const selectionKeys = utilities.constants[`${config.type}SelectionKeys`];
+        for (const name of selectionKeys) {
+            if (options[name] === false) {
+                delete selection[name];
+            }
+            else if (typeof options[name] !== `undefined`) {
+                selection[name] = options[name];
+            }
+        }
+        for (const name in selection) {
+            if (!selectionKeys.some(selectionKey => selectionKey === name)) {
+                delete selection[name];
+            }
+        }
+        try {
+            config.selection = selection;
+            await utilities.checkoutSelectionBranch(config);
+            utilities.writeConfig(config, path);
+            console.info(`Updated config.`);
+            showSelection();
+        }
+        catch (error) {
+            console.warn(`Unable to checkout the selection's branch.`, error?.message);
+        }
+    });
+};

package/build/commands/set-api-key.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { userConfig } from '../userConfig.js';
+import { writeUserConfig } from '../utilities/writeUserConfig.js';
+import { repoConfig } from '../repoConfig.js';
+import { writeRepoConfig } from '../utilities/writeRepoConfig.js';
+import { getRepoRootPath } from './utilities/getRepoRootPath.js';
+import { getErrorMessage } from '../utilities/getErrorMessage.js';
+import * as API from '../API/index.js';
+import { logger } from '../logger.js';
+/**
+ * Adds the `set-api-key` command to the program.
+ */
+export const setApiKey = (program) => {
+    program.command(`set-api-key`)
+        .description(`updates the current repository's .env file with your MOLECULE_USER_ID and MOLECULE_USER_API_KEY`)
+        .option(`--new`, `forces a new API key`)
+        .action(async (options) => {
+        if (!userConfig?.user?.id) {
+            logger.warn(`Not logged in. Run \`mlcl login\` first.`);
+            return;
+        }
+        try {
+            const { apiKey } = options.new
+                ? (await API.resource.user.createApiKey(userConfig.user.id)).data
+                : (await API.resource.user.readApiKey(userConfig.user.id)).data;
+            if (!apiKey) {
+                throw new Error(`No API key.`);
+            }
+            const envPath = path.join(getRepoRootPath(), `.env`);
+            let envFileContents = ``;
+            if (fs.existsSync(envPath)) {
+                envFileContents = fs.readFileSync(envPath, `utf8`);
+                if (/^MOLECULE_USER_API_KEY=(.*)$/gm.test(envFileContents)) {
+                    envFileContents = envFileContents.replace(/^MOLECULE_USER_API_KEY=(.*)$/, `MOLECULE_USER_API_KEY=${apiKey}`);
+                }
+                else {
+                    envFileContents = `MOLECULE_USER_API_KEY=${apiKey}\n${envFileContents}`;
+                }
+                if (/^MOLECULE_USER_ID=(.*)$/gm.test(envFileContents)) {
+                    envFileContents = envFileContents.replace(/^MOLECULE_USER_ID=(.*)$/, `MOLECULE_USER_ID=${userConfig.user.id}`);
+                }
+                else {
+                    envFileContents = `MOLECULE_USER_ID=${userConfig.user.id}\n${envFileContents}`;
+                }
+            }
+            else {
+                envFileContents = `MOLECULE_USER_ID=${userConfig.user.id}\n`
+                    + `MOLECULE_USER_API_KEY=${apiKey}\n`;
+            }
+            fs.writeFileSync(envPath, envFileContents);
+            if (!userConfig.userSecrets) {
+                userConfig.userSecrets = {};
+            }
+            userConfig.userSecrets.apiKey = apiKey;
+            writeUserConfig();
+            logger.info(`Updated user .mlclrc.json file.`);
+            if (!repoConfig.userSecrets) {
+                repoConfig.userSecrets = {};
+            }
+            repoConfig.userSecrets.apiKey = apiKey;
+            repoConfig.user = userConfig.user;
+            writeRepoConfig();
+            logger.info(`Updated repo .mlclrc.json file.`);
+            logger.info(`Updated .env file with the following:`);
+            logger.info(`MOLECULE_USER_ID=${userConfig.user.id}`);
+            logger.info(`MOLECULE_USER_API_KEY=${apiKey}`);
+        }
+        catch (error) {
+            logger.warn(`Failed to set API key. ${getErrorMessage(error)}`);
+        }
+    });
+};