@corva/create-app 0.49.0-0 → 0.49.0-2

package/lib/commands/attach.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import { runFlow } from '../flow.js';
+import { ATTACH_FLOW } from '../flows/attach.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { apiKeyOption } from '../options/api-key.js';
+import { appVersion } from '../options/app-version.js';
+import { envOption } from '../options/env.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+
+export const attachCommand = new Command('attach')
+  .description('Add app to live assets streams')
+  .argument('<project-directory>', 'Project directory to work with')
+  .addOption(apiKeyOption)
+  .addOption(envOption)
+  .addOption(silentOption)
+  .addOption(appVersion)
+  .addOption(originalCwdOption)
+  .action(async (dirName, options) => {
+    await runFlow(ATTACH_FLOW, { dirName: getRealWorkingDir(dirName, options), options });
+  });

package/lib/commands/create.js

@@ -0,0 +1,424 @@
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { clear } from 'node:console';
+import os from 'node:os';
+import { existsSync } from 'node:fs';
+
+import { Command, Option } from 'commander';
+import spawn from 'cross-spawn';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import figlet from 'figlet';
+import _ from 'lodash/fp.js';
+import inquirer from 'inquirer';
+
+import { originalCwdOption } from '../options/original-cwd.js';
+import { ensureBumpVersion, ensureLatestVersion } from '../helpers/cli-version.js';
+import { logger } from '../helpers/logger.js';
+import { IS_WINDOWS, resolveAppRuntime } from '../helpers/resolve-app-runtime.js';
+import { initVersioning } from '../helpers/versioning.js';
+import { copyFolderRecursiveSync, putVariablesInEnvFile } from '../helpers/utils.js';
+import { getDefaultsForPackageJson } from '../constants/package.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { Manifest } from '../flows/lib/manifest.js';
+import { fillManifest } from '../helpers/manifest.js';
+import { getManifestMandatoryKeys, manifestOptions } from '../constants/manifest.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const WRITE_TO_JSON_OPTS = {
+  spaces: 2,
+  EOL: os.EOL,
+};
+
+export const createCommand = new Command('create')
+  .description('Create a new app')
+  .argument('[project-directory]', 'project directory to work with', process.argv[process.argv.length - 1])
+  .addOption(originalCwdOption)
+  .usage(`${chalk.green('<project-directory>')} [options]`);
+
+manifestOptions().forEach((value) => {
+  const type = typeof value.default;
+  const cliType = type === 'undefined' ? (value.choices ? ' [string]' : '') : ` [${type}]`;
+  const alias = value.alias ? `-${value.alias}, ` : '';
+  const optionString = `${alias}--${value.name}${cliType}`;
+
+  const option = new Option(optionString, value.message);
+
+  if (value.choices) {
+    if (typeof value.choices === 'function') {
+      option.choices(value.choices());
+    } else {
+      option.choices(value.choices.map((choice) => `${typeof choice === 'object' ? choice.value : choice}`));
+    }
+  }
+
+  if (type === 'number') {
+    option.argParser(Number);
+  }
+
+  if (type !== 'undefined') {
+    option.default(value.default);
+  }
+
+  createCommand.addOption(option);
+});
+
+createCommand.version(fs.readJSONSync(join(__dirname, '../../package.json')).version);
+
+createCommand.action(async (dirName, options) => {
+  if (options.zip || options.release) {
+    options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+  }
+
+  startingMessage();
+
+  // NOTE: Default action
+  await createApp(dirName, options);
+});
+
+/**
+ *
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ */
+const getEnvManagementLink = (manifest) => {
+  if (manifest.isJs()) {
+    if (IS_WINDOWS) {
+      return 'https://github.com/coreybutler/nvm-windows';
+    }
+
+    return 'https://github.com/nvm-sh/nvm';
+  }
+
+  if (IS_WINDOWS) {
+    return 'https://github.com/pyenv-win/pyenv-win';
+  }
+
+  return 'https://github.com/pyenv/pyenv';
+};
+
+async function initPackage(projectName, opts) {
+  const manifest = new Manifest(fillManifest(opts));
+  const runtime = resolveAppRuntime(opts);
+
+  if (!(await runtime.isRuntimeAvailable())) {
+    throw new Error(
+      `Runtime "${opts.runtime}" is not available locally. Please proceed to ${chalk.green(
+        getEnvManagementLink(manifest),
+      )} to install it locally.`,
+    );
+  }
+
+  if (manifest.isUi()) {
+    await ensureLatestVersion();
+  }
+
+  const root = getRealWorkingDir(projectName, opts);
+
+  logger.log(`Creating a new Corva app in ${chalk.green(root)}.`);
+
+  await fs.ensureDir(root);
+
+  if ((await fs.readdir(root)).length) {
+    const shouldCleanup = await inquirer
+      .prompt([
+        {
+          message: `Directory "${root}" is not empty. Clean it to proceed?`,
+          name: 'cleanup',
+          type: 'confirm',
+        },
+      ])
+      .then(_.get('cleanup'));
+
+    if (shouldCleanup) {
+      await fs.emptyDir(root);
+    } else {
+      throw new Error(`Directory is not empty: ${root}`);
+    }
+  }
+
+  await fs.writeJSON(join(root, 'manifest.json'), manifest.manifest, WRITE_TO_JSON_OPTS);
+
+  await addTemplate(root, manifest, runtime);
+  await configureApp(root, manifest, runtime);
+
+  opts.dependenciesInstall && (await installDependencies(root, manifest, runtime));
+
+  opts.gitInit && (await initVersioning(root, manifest, runtime));
+
+  logger.log();
+  logger.log(`Success! Created ${chalk.green(manifest.name)} at ${chalk.yellow(root)}`);
+
+  helpCommands(manifest, runtime);
+
+  logger.log();
+}
+
+async function createApp(dirName, opts) {
+  const { isValid, values } = checkOptions(opts);
+
+  if (isValid) {
+    Object.keys(values).forEach((key) => {
+      logger.log(`${key} : ${values[key]}`);
+    });
+
+    return initPackage(dirName, opts);
+  }
+
+  console.log('Please fill your app Metadata');
+
+  const answers = await inquirer.prompt(manifestOptions(dirName), opts);
+
+  return initPackage(dirName, answers);
+}
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {*} runtime
+ */
+async function addTemplate(root, manifest, runtime) {
+  logger.log(chalk.green('Copying app template...'));
+  logger.log();
+
+  const cliRoot = resolve(__dirname, '..', '..');
+
+  const templateFolder = join(cliRoot, 'templates', manifest.templateName, runtime.language);
+
+  copyFolderRecursiveSync(templateFolder, root);
+
+  if (manifest.isNode()) {
+    copyFolderRecursiveSync(join(cliRoot, 'common', 'node'), root);
+  }
+
+  if (manifest.isPython()) {
+    copyFolderRecursiveSync(join(cliRoot, 'common', 'python'), root);
+  }
+
+  if (!manifest.isUi()) {
+    await putVariablesInEnvFile(root, manifest);
+  }
+
+  // We can't have .gitignore file in our templates.
+  // It's missing when @corva/create-app is installed.
+  // That's why we manually rename gitignore to .gitignore after copying template
+  const targetGitignore = join(root, '.gitignore');
+
+  fs.renameSync(join(root, 'gitignore'), targetGitignore);
+
+  if (runtime.language === 'typescript' && manifest.isNode()) {
+    await fs.appendFile(targetGitignore, '\n**/*.js\n');
+  }
+
+  logger.log(chalk.green('Done: copying app template!'));
+}
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {*} runtime
+ */
+async function configureApp(root, manifest, runtime) {
+  if (manifest.isJs()) {
+    await addNvmRc(root, manifest, runtime);
+    await addPackageJSON(root, manifest, runtime);
+  }
+
+  if (manifest.isNode()) {
+    await addTsConfigs(root, manifest, runtime);
+  }
+
+  if (manifest.isPython()) {
+    await addPythonConfigs(root, manifest, runtime);
+  }
+}
+
+const addNvmRc = async (root, manifest, runtime) => {
+  await fs.outputFile(join(root, '.nvmrc'), `${runtime.semver}\n`);
+};
+
+/**
+ *
+ * @param {string} root
+ * @param {Manifest} manifest
+ * @param {import('./helpers/resolve-app-runtime.js').Runtime} runtime
+ */
+const addPythonConfigs = async (root, manifest, runtime) => {
+  await fs.writeFile(resolve(root, '.python-version'), `${runtime.semver}\n`);
+  await fs.writeFile(resolve(root, '.python-virtualenv'), `${manifest.unix_name}\n`);
+};
+
+const addTsConfigs = (root, manifest, runtime) => {
+  if (runtime.language !== 'typescript') {
+    return;
+  }
+
+  return Promise.all([
+    fs.writeJson(
+      resolve(root, 'tsconfig.json'),
+      {
+        extends: `@tsconfig/node${runtime.version}/tsconfig.json`,
+        compilerOptions: {
+          inlineSourceMap: true,
+          strict: false,
+        },
+      },
+      WRITE_TO_JSON_OPTS,
+    ),
+    fs.writeJson(
+      resolve(root, 'tsconfig.build.json'),
+      {
+        extends: './tsconfig.json',
+        include: ['lib/**/*.ts', 'index.ts'],
+        exclude: ['node_modules', '**/*.spec.ts'],
+      },
+      WRITE_TO_JSON_OPTS,
+    ),
+  ]);
+};
+
+/**
+ *
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ */
+function addPackageJSON(root, manifest, runtime) {
+  const {
+    version,
+    description,
+    scripts,
+    dependencies,
+    devDependencies,
+    main,
+    license = 'UNLICENSED',
+    private: isPrivate = true,
+    ...rest
+  } = getDefaultsForPackageJson(manifest, runtime);
+
+  const packageJson = {
+    name: manifest.unix_name,
+    version,
+    description: manifest.description || description,
+    main,
+    private: isPrivate,
+    license,
+    engines: {
+      node: `^${runtime.version}`,
+      [runtime.packageManager]: '*',
+    },
+    scripts,
+    dependencies,
+    devDependencies,
+    ...rest,
+  };
+
+  return fs.writeJSON(join(root, 'package.json'), packageJson, WRITE_TO_JSON_OPTS);
+}
+
+/**
+ * @param {string} root
+ * @param {import('./flows/lib/manifest').Manifest} manifest
+ * @param {import('./helpers/resolve-app-runtime.js').Runtime} runtime
+ * @returns {Promise<void>}
+ * @throws {Error}
+ * @throws {import('child_process').ExecException}
+ * @throws {import('child_process').SpawnSyncReturns<Buffer>}
+ */
+async function installDependencies(root, manifest, runtime) {
+  const command = manifest.isJs() ? runtime.packageManager : 'make';
+
+  if (IS_WINDOWS && !manifest.isJs()) {
+    logger.log();
+    logger.log(`⚠️ ${chalk.yellow('Please install project dependencies manually')}`);
+
+    return;
+  }
+
+  const args = ['install'];
+  const opts = { stdio: ['inherit', 'inherit', 'pipe'], cwd: root };
+
+  if (process.env.CI && command === 'yarn') {
+    args.push('--cache-folder=".yarn-cache"');
+  }
+
+  logger.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
+
+  const nvmOpts = {
+    shell: true,
+    ...opts,
+  };
+
+  const proc =
+    manifest.isJs() && existsSync(`${os.homedir()}/.nvm/nvm.sh`)
+      ? spawn.sync(`\\. ${os.homedir()}/.nvm/nvm.sh && nvm i && ${command} ${args.join(' ')}`, nvmOpts)
+      : spawn.sync(command, args, opts);
+
+  if (proc.stderr) {
+    const error = proc.stderr
+      .toString('utf8')
+      .split('\n')
+      // NOTE: filter out warnings caused by @corva/ui peer dependencies
+      .filter((line) => !line.includes('@corva/ui'))
+      .join('\n');
+
+    console.log(error);
+  }
+
+  if (proc.status !== 0) {
+    console.error(`\`${command} ${args.join(' ')}\` failed`);
+
+    return;
+  }
+
+  logger.log(chalk.green('Successfull project install'));
+}
+
+async function helpCommands(manifest, { packageManager: displayedCommand }) {
+  if (!manifest.isUi()) {
+    return;
+  }
+
+  const useYarn = displayedCommand === 'yarn';
+
+  logger.log('Inside that directory, you can run several commands:');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} start`));
+  logger.log('    Starts the development server.');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}build`));
+  logger.log('    Bundles the app into static files for production.');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}zip`));
+  logger.log('    Bundles the app into ZIP file in app root directory');
+  logger.log();
+  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}release`));
+  logger.log('    Uploads the app ZIP to Corva');
+  logger.log();
+}
+
+function startingMessage() {
+  clear();
+  console.log(chalk.green('   Welcome to apps generator for:'));
+  console.log(chalk.cyan(figlet.textSync('CORVA.AI', { horizontalLayout: 'full' })));
+}
+
+function checkOptions(opts) {
+  let isValid = true;
+  const values = {};
+
+  getManifestMandatoryKeys(opts).forEach((key) => {
+    if (!opts[key]) {
+      isValid = false;
+    }
+
+    values[key] = opts[key];
+  });
+
+  return {
+    isValid,
+    values,
+  };
+}

package/lib/commands/release.js

@@ -0,0 +1,43 @@
+import { Command, Option } from 'commander';
+import { runFlow } from '../flow.js';
+import { RELEASE_FLOW } from '../flows/release.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { apiKeyOption } from '../options/api-key.js';
+import { bumpVersionOption } from '../options/bump-version.js';
+import { envOption } from '../options/env.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+import { ensureBumpVersion } from '../helpers/cli-version.js';
+
+export const releaseCommand = new Command('release')
+  .description('Release app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .argument('[patterns...]', 'Additional patterns to zip', [])
+  .addOption(bumpVersionOption)
+  .addOption(new Option('--ignored-files [string...]', 'Patterns to skip zip').default([]))
+  .addOption(silentOption)
+  .addOption(envOption)
+  .addOption(apiKeyOption)
+  .addOption(originalCwdOption)
+  .addOption(new Option('--notes [string]', 'Add custom notes to published app'))
+  .addOption(new Option('--label [string]', 'Put a label on the release').choices(['BETA', 'PROD']))
+  .addOption(new Option('--remove-on-fail [boolean]', 'Remove release if it fails during deployment').default(false))
+  .addOption(
+    new Option('--remove-on-success [boolean]', 'App package (.zip) will not be deleted after upload').default(true),
+  )
+  .addOption(
+    new Option(
+      '--remove-existing [boolean]',
+      'If package version is already taken - remove the previously published package and upload a new one',
+    ).default(false),
+  )
+  // .addOption(new Option('--zip-file-name [string]', 'Prebuilt zip file name in dir'))
+  .action(async (dirName, patterns, options) => {
+    options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+    await runFlow(RELEASE_FLOW, {
+      dirName: getRealWorkingDir(dirName, options),
+      patterns,
+      options,
+    });
+  });

package/lib/commands/rerun.js

@@ -0,0 +1,25 @@
+import { Command, Option } from 'commander';
+
+import { runFlow } from '../flow.js';
+import { RERUN_FLOW } from '../flows/rerun.js';
+import { getRealWorkingDir } from '../helpers/commands.js';
+import { apiKeyOption } from '../options/api-key.js';
+import { appVersion } from '../options/app-version.js';
+import { envOption } from '../options/env.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+
+export const rerunCommand = new Command('rerun')
+  .description('Rerun app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .addOption(apiKeyOption)
+  .addOption(envOption)
+  .addOption(silentOption)
+  .addOption(appVersion)
+  .addOption(new Option('--assets [assets...]', 'Assets IDs list', []).conflicts('companyId'))
+  .addOption(new Option('--company-id [number]', 'Company ID', []))
+  .addOption(new Option('--interval [number]', 'Interval for scheduler apps (exp. 1200)'))
+  .addOption(originalCwdOption)
+  .action(async (dirName, options) => {
+    await runFlow(RERUN_FLOW, { dirName: getRealWorkingDir(dirName, options), options });
+  });

package/lib/commands/zip.js

@@ -0,0 +1,32 @@
+import { Command, Option } from 'commander';
+import _ from 'lodash/fp.js';
+
+import { runFlow } from '../flow.js';
+import { ZIP_FLOW } from '../flows/zip.js';
+import { getRealWorkingDir, silencer } from '../helpers/commands.js';
+import { bumpVersionOption } from '../options/bump-version.js';
+import { originalCwdOption } from '../options/original-cwd.js';
+import { silentOption } from '../options/silent.js';
+import { ensureBumpVersion } from '../helpers/cli-version.js';
+
+export const zipCommand = new Command('zip')
+  .description('Bundle app')
+  .argument('<project-directory>', 'Project directory to work with')
+  .argument('[patterns...]', 'Additional patterns to zip', [])
+  .addOption(bumpVersionOption)
+  .addOption(new Option('--ignored-files [ignoredFiles...]', 'Patterns to skip zip', []))
+  .addOption(originalCwdOption)
+  .addOption(silentOption)
+  .action(
+    silencer(async (dirName, patterns, options) => {
+      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
+
+      console.log(getRealWorkingDir(dirName, options), options);
+
+      return runFlow(ZIP_FLOW, {
+        dirName: getRealWorkingDir(dirName, options),
+        patterns,
+        options,
+      }).then(_.get('zipFileName'));
+    }),
+  );

package/lib/constants/cli.js

@@ -3,6 +3,7 @@ export const APP_RUNTIMES = {
   // NODE12: 'nodejs12.x',
   // NODE14: 'nodejs14.x',
   NODE16: 'nodejs16.x',
+  NODE18: 'nodejs18.x',
   PYTHON3_8: 'python3.8',
   PYTHON3_9: 'python3.9',
 };

package/lib/flows/lib/manifest.js

@@ -11,7 +11,7 @@ const SCHEDULER_MAPPING = [SCHEDULER_TYPE_DATA_TIME, SCHEDULER_TYPE_DEPTH, SCHED
   {},
 );
 
-const NODE_RUNTIMES = [APP_RUNTIMES.NODE12, APP_RUNTIMES.NODE14, APP_RUNTIMES.NODE16];
+const NODE_RUNTIMES = [APP_RUNTIMES.NODE16, APP_RUNTIMES.NODE18];
 
 export class Manifest {
   constructor(manifest) {

package/lib/flows/steps/zip-file-list-resolve.js

@@ -5,7 +5,7 @@ import _ from 'lodash/fp.js';
 import { promises as fs } from 'node:fs';
 import { resolve } from 'node:path';
 import { promisify } from 'node:util';
-import { getIncreasedVersion } from '../../scripts/utils/version.js';
+import { getIncreasedVersion } from '../../helpers/cli-version.js';
 import { loadJson } from '../lib/json.js';
 import { StepError } from '../lib/step-error.js';
 

package/lib/{scripts/utils/version.js → helpers/cli-version.js}

@@ -5,7 +5,7 @@ import inquirer from 'inquirer';
 import { join } from 'path';
 import * as url from 'url';
 
-import { logger } from '../../helpers/logger.js';
+import { logger } from './logger.js';
 import fs from 'fs-extra';
 
 const npm = new NpmApi();
@@ -16,7 +16,7 @@ const code = chalk.cyan;
 const asterisks = '****************************************************************';
 
 const getCurrentVersion = async () =>
-  (await fs.readJSON(join(url.fileURLToPath(new URL('.', import.meta.url)), '../../../package.json'))).version;
+  (await fs.readJSON(join(url.fileURLToPath(new URL('.', import.meta.url)), '../../package.json'))).version;
 const getLatestVersion = async () => npm.repo('@corva/create-app').prop('version');
 
 // NOTE: Stop process and show error if version is outdated

package/lib/helpers/commands.js

@@ -0,0 +1,13 @@
+import { resolve } from 'node:path';
+
+export const silencer =
+  (handler) =>
+  async (...args) => {
+    const result = await handler(...args);
+
+    if (args[args.length - 2].silent && result) {
+      console.log(result);
+    }
+  };
+
+export const getRealWorkingDir = (relativePath, options) => resolve(options.originalCwd, relativePath);

package/lib/helpers/versioning.js

@@ -6,6 +6,25 @@ import { logger } from './logger.js';
 
 const debug = debugFn('cca:versioning');
 
+/**
+ *
+ * @param {string} root
+ */
+export async function initVersioning(root) {
+  logger.log();
+
+  if (!tryGitInit(root)) {
+    logger.log('Already in a git repository. Skipping git initialization.');
+
+    return;
+  }
+
+  if (tryGitCommit(root)) {
+    logger.log();
+    logger.log('Created git commit');
+  }
+}
+
 export function isInGitRepository(appPath) {
   try {
     execSync('git rev-parse --is-inside-work-tree', {
@@ -73,15 +92,3 @@ export function tryGitCommit(appPath) {
     return false;
   }
 }
-
-export function shouldUseYarn(appPath) {
-  try {
-    execSync('yarnpkg --version', { stdio: 'ignore', cwd: appPath });
-
-    return true;
-  } catch (e) {
-    debug(e);
-
-    return false;
-  }
-}

package/lib/main.js

@@ -1,71 +1,17 @@
-/* eslint-disable no-undef */
 import chalk from 'chalk';
-import { Command, CommanderError, Option } from 'commander';
-import figlet from 'figlet';
-import fs from 'fs-extra';
-import inquirer from 'inquirer';
-import os from 'node:os';
-import path, { resolve } from 'node:path';
+import { Command, CommanderError } from 'commander';
 import semver from 'semver';
 
-import * as manifestHelpers from './helpers/manifest.js';
-import * as utils from './helpers/utils.js';
-import * as versioning from './helpers/versioning.js';
-import { ensureBumpVersion, ensureLatestVersion, warnIfOutdated } from './scripts/utils/version.js';
-
-import * as manifestConstants from './constants/manifest.js';
-import { getDefaultsForPackageJson } from './constants/package.js';
-
-import spawn from 'cross-spawn';
-import _ from 'lodash/fp.js';
-import { clear } from 'node:console';
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import packageJson from '../package.json' assert { type: 'json' };
-import {
-  apiKeyOption,
-  appVersion,
-  bumpVersionOption,
-  envOption,
-  originalCwdOption,
-  silentOption,
-} from './bump-version.option.js';
+import { warnIfOutdated } from './helpers/cli-version.js';
 import { ERROR_ICON } from './constants/messages.js';
-import { runFlow } from './flow.js';
-import { ATTACH_FLOW } from './flows/attach.js';
-import { Manifest } from './flows/lib/manifest.js';
 import { StepError } from './flows/lib/step-error.js';
-import { RELEASE_FLOW } from './flows/release.js';
-import { RERUN_FLOW } from './flows/rerun.js';
-import { ZIP_FLOW } from './flows/zip.js';
 import { logger } from './helpers/logger.js';
-import { IS_WINDOWS, resolveAppRuntime } from './helpers/resolve-app-runtime.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const writejsonOptions = {
-  spaces: 2,
-  EOL: os.EOL,
-};
 
-const silencer =
-  (handler) =>
-  async (...args) => {
-    const result = await handler(...args);
-
-    if (args[args.length - 2].silent && result) {
-      console.log(result);
-    }
-  };
-
-const getRealWorkingDir = (relativePath, options) => resolve(options.originalCwd, relativePath);
-
-function startingMessage() {
-  clear();
-  console.log(chalk.green('   Welcome to apps generator for:'));
-  console.log(chalk.cyan(figlet.textSync('CORVA.AI', { horizontalLayout: 'full' })));
-}
+import { zipCommand } from './commands/zip.js';
+import { releaseCommand } from './commands/release.js';
+import { rerunCommand } from './commands/rerun.js';
+import { attachCommand } from './commands/attach.js';
+import { createCommand } from './commands/create.js';
 
 function checkNodeVersion() {
   logger.write('Checking node version...');
@@ -87,30 +33,6 @@ function checkNodeVersion() {
   logger.write('  ✅  \n');
 }
 
-function checkOptions(opts) {
-  let isValid = true;
-  const values = {};
-
-  manifestConstants.getManifestMandatoryKeys(opts).forEach((key) => {
-    if (!opts[key]) {
-      isValid = false;
-    }
-
-    values[key] = opts[key];
-  });
-
-  return {
-    isValid,
-    values,
-  };
-}
-
-// eslint-disable-next-line no-unused-vars
-const printDeprecationNotice = (param) =>
-  console.warn(
-    chalk.bgYellowBright`DEPRECATED OPTION: ${param}` + ` Use ${chalk.cyan(`create-corva-app ${param} .`)} instead`,
-  );
-
 export async function run() {
   const program = new Command('create-corva-app')
     .hook('preAction', async () => {
@@ -119,140 +41,12 @@ export async function run() {
       await warnIfOutdated();
     })
     .configureOutput({ writeErr: () => undefined })
-    .exitOverride();
-
-  const createCommand = program
-    .command('create', { isDefault: true })
-    .description('Create a new app')
-    .argument('[project-directory]', 'project directory to work with', process.argv[process.argv.length - 1])
-    .addOption(originalCwdOption)
-    .usage(`${chalk.green('<project-directory>')} [options]`);
-
-  manifestConstants.manifestOptions().forEach((value) => {
-    const type = typeof value.default;
-    const cliType = type === 'undefined' ? (value.choices ? ' [string]' : '') : ` [${type}]`;
-    const alias = value.alias ? `-${value.alias}, ` : '';
-    const optionString = `${alias}--${value.name}${cliType}`;
-
-    const option = new Option(optionString, value.message);
-
-    if (value.choices) {
-      if (typeof value.choices === 'function') {
-        option.choices(value.choices());
-      } else {
-        option.choices(value.choices.map((choice) => `${typeof choice === 'object' ? choice.value : choice}`));
-      }
-    }
-
-    if (type === 'number') {
-      option.argParser(Number);
-    }
-
-    if (type !== 'undefined') {
-      option.default(value.default);
-    }
-
-    createCommand.addOption(option);
-  });
-
-  createCommand.version(packageJson.version);
-
-  createCommand.action(async (dirName, options) => {
-    if (options.zip || options.release) {
-      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
-    }
-
-    startingMessage();
-
-    // NOTE: Default action
-    await createApp(dirName, options);
-  });
-
-  program
-    .command('zip')
-    .description('Bundle app')
-    .argument('<project-directory>', 'Project directory to work with')
-    .argument('[patterns...]', 'Additional patterns to zip', [])
-    .addOption(bumpVersionOption)
-    .addOption(new Option('--ignored-files [ignoredFiles...]', 'Patterns to skip zip', []))
-    .addOption(originalCwdOption)
-    .addOption(silentOption)
-    .action(
-      silencer(async (dirName, patterns, options) => {
-        options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
-
-        console.log(getRealWorkingDir(dirName, options), options);
-
-        return runFlow(ZIP_FLOW, {
-          dirName: getRealWorkingDir(dirName, options),
-          patterns,
-          options,
-        }).then(_.get('zipFileName'));
-      }),
-    );
-
-  program
-    .command('release')
-    .description('Release app')
-    .argument('<project-directory>', 'Project directory to work with')
-    .argument('[patterns...]', 'Additional patterns to zip', [])
-    .addOption(bumpVersionOption)
-    .addOption(new Option('--ignored-files [string...]', 'Patterns to skip zip').default([]))
-    .addOption(silentOption)
-    .addOption(envOption)
-    .addOption(apiKeyOption)
-    .addOption(originalCwdOption)
-    .addOption(new Option('--notes [string]', 'Add custom notes to published app'))
-    .addOption(new Option('--label [string]', 'Put a label on the release').choices(['BETA', 'PROD']))
-    .addOption(new Option('--remove-on-fail [boolean]', 'Remove release if it fails during deployment').default(false))
-    .addOption(
-      new Option('--remove-on-success [boolean]', 'App package (.zip) will not be deleted after upload').default(true),
-    )
-    .addOption(
-      new Option(
-        '--remove-existing [boolean]',
-        'If package version is already taken - remove the previously published package and upload a new one',
-      ).default(false),
-    )
-    // .addOption(new Option('--zip-file-name [string]', 'Prebuilt zip file name in dir'))
-    .action(async (dirName, patterns, options) => {
-      options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
-
-      await runFlow(RELEASE_FLOW, {
-        dirName: getRealWorkingDir(dirName, options),
-        patterns,
-        options,
-      });
-    });
-
-  program
-    .command('rerun')
-    .description('Rerun app')
-    .argument('<project-directory>', 'Project directory to work with')
-    .addOption(apiKeyOption)
-    .addOption(envOption)
-    .addOption(silentOption)
-    .addOption(appVersion)
-    .addOption(new Option('--assets [assets...]', 'Assets IDs list', []).conflicts('companyId'))
-    .addOption(new Option('--company-id [number]', 'Company ID', []))
-    .addOption(new Option('--interval [number]', 'Interval for scheduler apps (exp. 1200)'))
-    .addOption(originalCwdOption)
-    .action(async (dirName, options) => {
-      await runFlow(RERUN_FLOW, { dirName: getRealWorkingDir(dirName, options), options });
-    });
-
-  program
-    .command('attach')
-    .description('Add app to live assets streams')
-    .argument('<project-directory>', 'Project directory to work with')
-    .addOption(apiKeyOption)
-    .addOption(envOption)
-    .addOption(silentOption)
-    .addOption(appVersion)
-    .addOption(originalCwdOption)
-    .action(async (dirName, options) => {
-      await runFlow(ATTACH_FLOW, { dirName: getRealWorkingDir(dirName, options), options });
-    });
+    .exitOverride()
+    .addCommand(createCommand, { isDefault: true })
+    .addCommand(zipCommand)
+    .addCommand(releaseCommand)
+    .addCommand(rerunCommand)
+    .addCommand(attachCommand);
 
   try {
     await program.parseAsync(process.argv);
@@ -313,339 +107,3 @@ const handleCommanderError = (program, e) => {
     }
   }
 };
-
-/**
- *
- * @param {import('./flows/lib/manifest').Manifest} manifest
- */
-const getEnvManagementLink = (manifest) => {
-  if (manifest.isJs()) {
-    if (IS_WINDOWS) {
-      return 'https://github.com/coreybutler/nvm-windows';
-    }
-
-    return 'https://github.com/nvm-sh/nvm';
-  }
-
-  if (IS_WINDOWS) {
-    return 'https://github.com/pyenv-win/pyenv-win';
-  }
-
-  return 'https://github.com/pyenv/pyenv';
-};
-
-async function initPackage(projectName, opts) {
-  const manifest = new Manifest(manifestHelpers.fillManifest(opts));
-  const runtime = resolveAppRuntime(opts);
-
-  if (!(await runtime.isRuntimeAvailable())) {
-    throw new Error(
-      `Runtime "${opts.runtime}" is not available locally. Please proceed to ${chalk.green(
-        getEnvManagementLink(manifest),
-      )} to install it locally.`,
-    );
-  }
-
-  if (manifest.isUi()) {
-    await ensureLatestVersion();
-  }
-
-  const root = getRealWorkingDir(projectName, opts);
-
-  logger.log(`Creating a new Corva app in ${chalk.green(root)}.`);
-
-  await fs.ensureDir(root);
-
-  if ((await fs.readdir(root)).length) {
-    const shouldCleanup = await inquirer
-      .prompt([
-        {
-          message: `Directory "${root}" is not empty. Clean it to proceed?`,
-          name: 'cleanup',
-          type: 'confirm',
-        },
-      ])
-      .then(_.get('cleanup'));
-
-    if (shouldCleanup) {
-      await fs.emptyDir(root);
-    } else {
-      throw new Error(`Directory is not empty: ${root}`);
-    }
-  }
-
-  await fs.writeJSON(path.join(root, 'manifest.json'), manifest.manifest, writejsonOptions);
-
-  await addTemplate(root, manifest, runtime);
-  await configureApp(root, manifest, runtime);
-
-  opts.dependenciesInstall && (await installDependencies(root, manifest, runtime));
-
-  opts.gitInit && (await initVersioning(root, manifest, runtime));
-
-  logger.log();
-  logger.log(`Success! Created ${chalk.green(manifest.name)} at ${chalk.yellow(root)}`);
-
-  helpCommands(manifest, runtime);
-
-  logger.log();
-}
-
-async function createApp(dirName, opts) {
-  const { isValid, values } = checkOptions(opts);
-
-  if (isValid) {
-    Object.keys(values).forEach((key) => {
-      logger.log(`${key} : ${values[key]}`);
-    });
-
-    return initPackage(dirName, opts);
-  }
-
-  console.log('Please fill your app Metadata');
-
-  const answers = await inquirer.prompt(manifestConstants.manifestOptions(dirName), opts);
-
-  return initPackage(dirName, answers);
-}
-
-/**
- *
- * @param {string} root
- * @param {import('./flows/lib/manifest').Manifest} manifest
- * @param {*} runtime
- */
-async function addTemplate(root, manifest, runtime) {
-  logger.log(chalk.green('Copying app template...'));
-  logger.log();
-
-  const templateFolder = path.resolve(__dirname, '..', 'templates', manifest.templateName, runtime.language);
-
-  utils.copyFolderRecursiveSync(templateFolder, root);
-
-  if (manifest.isNode()) {
-    utils.copyFolderRecursiveSync(path.resolve(__dirname, '..', 'common', 'node'), root);
-  }
-
-  if (manifest.isPython()) {
-    utils.copyFolderRecursiveSync(path.resolve(__dirname, '..', 'common', 'python'), root);
-  }
-
-  if (!manifest.isUi()) {
-    await utils.putVariablesInEnvFile(root, manifest);
-  }
-
-  // We can't have .gitignore file in our templates.
-  // It's missing when @corva/create-app is installed.
-  // That's why we manually rename gitignore to .gitignore after copying template
-  const targetGitignore = path.join(root, '.gitignore');
-
-  fs.renameSync(path.join(root, 'gitignore'), targetGitignore);
-
-  if (runtime.language === 'typescript' && manifest.isNode()) {
-    await fs.appendFile(targetGitignore, '\n**/*.js\n');
-  }
-
-  logger.log(chalk.green('Done: copying app template!'));
-}
-
-/**
- *
- * @param {string} root
- * @param {import('./flows/lib/manifest').Manifest} manifest
- * @param {*} runtime
- */
-async function configureApp(root, manifest, runtime) {
-  if (manifest.isJs()) {
-    await addNvmRc(root, manifest, runtime);
-    await addPackageJSON(root, manifest, runtime);
-  }
-
-  if (manifest.isNode()) {
-    await addTsConfigs(root, manifest, runtime);
-  }
-
-  if (manifest.isPython()) {
-    await addPythonConfigs(root, manifest, runtime);
-  }
-}
-
-const addNvmRc = async (root, manifest, runtime) => {
-  await fs.outputFile(path.join(root, '.nvmrc'), `${runtime.semver}\n`);
-};
-
-/**
- *
- * @param {string} root
- * @param {Manifest} manifest
- * @param {import('./helpers/resolve-app-runtime.js').Runtime} runtime
- */
-const addPythonConfigs = async (root, manifest, runtime) => {
-  await fs.writeFile(path.resolve(root, '.python-version'), `${runtime.semver}\n`);
-  await fs.writeFile(path.resolve(root, '.python-virtualenv'), `${manifest.unix_name}\n`);
-};
-
-const addTsConfigs = (root, manifest, runtime) => {
-  if (runtime.language !== 'typescript') {
-    return;
-  }
-
-  return Promise.all([
-    fs.writeJson(
-      path.resolve(root, 'tsconfig.json'),
-      {
-        extends: `@tsconfig/node${runtime.version}/tsconfig.json`,
-        compilerOptions: {
-          inlineSourceMap: true,
-          strict: false,
-        },
-      },
-      writejsonOptions,
-    ),
-    fs.writeJson(
-      path.resolve(root, 'tsconfig.build.json'),
-      {
-        extends: './tsconfig.json',
-        include: ['lib/**/*.ts', 'index.ts'],
-        exclude: ['node_modules', '**/*.spec.ts'],
-      },
-      writejsonOptions,
-    ),
-  ]);
-};
-
-/**
- *
- * @param {string} root
- * @param {import('./flows/lib/manifest').Manifest} manifest
- */
-function addPackageJSON(root, manifest, runtime) {
-  const {
-    version,
-    description,
-    scripts,
-    dependencies,
-    devDependencies,
-    main,
-    license = 'UNLICENSED',
-    private: isPrivate = true,
-    ...rest
-  } = getDefaultsForPackageJson(manifest, runtime);
-
-  const packageJson = {
-    name: manifest.unix_name,
-    version,
-    description: manifest.description || description,
-    main,
-    private: isPrivate,
-    license,
-    engines: {
-      node: `^${runtime.version}`,
-      [runtime.packageManager]: '*',
-    },
-    scripts,
-    dependencies,
-    devDependencies,
-    ...rest,
-  };
-
-  return fs.writeJSON(path.join(root, 'package.json'), packageJson, writejsonOptions);
-}
-
-/**
- * @param {string} root
- * @param {import('./flows/lib/manifest').Manifest} manifest
- * @param {import('./helpers/resolve-app-runtime.js').Runtime} runtime
- * @returns {Promise<void>}
- * @throws {Error}
- * @throws {import('child_process').ExecException}
- * @throws {import('child_process').SpawnSyncReturns<Buffer>}
- */
-async function installDependencies(root, manifest, runtime) {
-  const command = manifest.isJs() ? runtime.packageManager : 'make';
-
-  if (IS_WINDOWS && !manifest.isJs()) {
-    logger.log();
-    logger.log(`⚠️ ${chalk.yellow('Please install project dependencies manually')}`);
-
-    return;
-  }
-
-  const args = ['install'];
-  const opts = { stdio: ['inherit', 'inherit', 'pipe'], cwd: root };
-
-  if (process.env.CI && command === 'yarn') {
-    args.push('--cache-folder=".yarn-cache"');
-  }
-
-  logger.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
-
-  const proc =
-    manifest.isJs() && existsSync(`${os.homedir()}/.nvm/nvm.sh`)
-      ? spawn.sync(`\\. ${os.homedir()}/.nvm/nvm.sh && nvm i && ${command} ${args.join(' ')}`, {
-          shell: true,
-          ...opts,
-        })
-      : spawn.sync(command, args, opts);
-
-  if (proc.stderr) {
-    const error = proc.stderr
-      .toString('utf8')
-      .split('\n')
-      // NOTE: filter out warnings caused by @corva/ui peer dependencies
-      .filter((line) => !line.includes('@corva/ui'))
-      .join('\n');
-
-    console.log(error);
-  }
-
-  if (proc.status !== 0) {
-    console.error(`\`${command} ${args.join(' ')}\` failed`);
-
-    return;
-  }
-
-  logger.log(chalk.green('Successfull project install'));
-}
-
-/**
- *
- * @param {string} root
- */
-async function initVersioning(root) {
-  logger.log();
-
-  if (!versioning.tryGitInit(root)) {
-    logger.log('Already in a git repository. Skipping git initialization.');
-
-    return;
-  }
-
-  if (versioning.tryGitCommit(root)) {
-    logger.log();
-    logger.log('Created git commit');
-  }
-}
-
-async function helpCommands(manifest, { packageManager: displayedCommand }) {
-  if (!manifest.isUi()) {
-    return;
-  }
-
-  const useYarn = displayedCommand === 'yarn';
-
-  logger.log('Inside that directory, you can run several commands:');
-  logger.log();
-  logger.log(chalk.cyan(`  ${displayedCommand} start`));
-  logger.log('    Starts the development server.');
-  logger.log();
-  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}build`));
-  logger.log('    Bundles the app into static files for production.');
-  logger.log();
-  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}zip`));
-  logger.log('    Bundles the app into ZIP file in app root directory');
-  logger.log();
-  logger.log(chalk.cyan(`  ${displayedCommand} ${useYarn ? '' : 'run '}release`));
-  logger.log('    Uploads the app ZIP to Corva');
-  logger.log();
-}

package/lib/options/api-key.js

@@ -0,0 +1,6 @@
+import { Option } from 'commander';
+
+export const apiKeyOption = new Option(
+  '--api-key [string]',
+  'Pre generated API key for authorization during app upload',
+);

package/lib/options/app-version.js

@@ -0,0 +1,3 @@
+import { Option } from 'commander';
+
+export const appVersion = new Option('--app-version [number]', 'App version (exp. 1, 2, 3)');

package/lib/options/bump-version.js

@@ -0,0 +1,19 @@
+import { InvalidArgumentError, Option } from 'commander';
+import semver from 'semver';
+
+const flags = '--bump-version <string>';
+const description = 'Bump version';
+const choices = ['major', 'minor', 'patch', 'skip'];
+
+function argParser(value, previous) {
+  // eslint-disable-next-line no-invalid-this
+  if (this.argChoices.includes(value) || semver.valid(value)) {
+    return value;
+  }
+
+  throw new InvalidArgumentError(
+    // eslint-disable-next-line no-invalid-this
+    `Allowed choices are ${this.argChoices.map((choice) => `"${choice}"`).join(', ')} or a valid semver version.`,
+  );
+}
+export const bumpVersionOption = new Option(flags, description).choices(choices).argParser(argParser);

package/lib/options/env.js

@@ -0,0 +1,3 @@
+import { Option } from 'commander';
+
+export const envOption = new Option('--env [string]', 'Environment to use').choices(['qa', 'staging', 'production']);

package/lib/options/original-cwd.js

@@ -0,0 +1,3 @@
+import { Option } from 'commander';
+
+export const originalCwdOption = new Option('--original-cwd <string>').hideHelp();

package/lib/options/silent.js

@@ -0,0 +1,3 @@
+import { Option } from 'commander';
+
+export const silentOption = new Option('--silent [boolean]', 'Only log result of the operation').default(false);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@corva/create-app",
-  "version": "0.49.0-0",
+  "version": "0.49.0-2",
   "private": false,
   "description": "Create an app to use it in CORVA.AI",
   "keywords": [

package/lib/bump-version.option.js

@@ -1,40 +0,0 @@
-import chalk from 'chalk';
-import { InvalidArgumentError, Option } from 'commander';
-import semver from 'semver';
-
-const flags = '--bump-version <string>';
-const description = 'Bump version';
-const choices = ['major', 'minor', 'patch', 'skip'];
-
-function argParser(value, previous) {
-  // eslint-disable-next-line no-invalid-this
-  if (this.argChoices.includes(value) || semver.valid(value)) {
-    return value;
-  }
-
-  throw new InvalidArgumentError(
-    // eslint-disable-next-line no-invalid-this
-    `Allowed choices are ${this.argChoices.map((choice) => `"${choice}"`).join(', ')} or a valid semver version.`,
-  );
-}
-export const bumpVersionOption = new Option(flags, description).choices(choices).argParser(argParser);
-
-export const apiKeyOption = new Option(
-  '--api-key [string]',
-  'Pre generated API key for authorization during app upload',
-);
-
-export const appVersion = new Option('--app-version [number]', 'App version (exp. 1, 2, 3)');
-
-export const envOption = new Option('--env [string]', 'Environment to use').choices(['qa', 'staging', 'production']);
-
-export const silentOption = new Option('--silent [boolean]', 'Only log result of the operation').default(false);
-
-export const originalCwdOption = new Option('--original-cwd <string>').hideHelp();
-
-export const bumpVersionOptionDeprecated = new Option(
-  flags,
-  chalk.bgYellow`DEPRECATED` + ` Use with ${chalk.cyan`zip`} or ${chalk.cyan`release`} command instead`,
-)
-  .choices(choices)
-  .argParser(argParser);