lib/cli.js - incubator-weex-cli - Git at Google

 'use strict';

 const debug = require('debug')('weex:cli');

 const pkg = require('../package.json');
 const colors = require('colors/safe');
 const semver = require('semver');
 const spawn = require('cross-spawn');
 const path = require('path');
 const userhome = require('userhome');
 const yargsParser = require('yargs-parser');
 const fse = require('fs-extra');
 const got = require('got');
 const inquirer = require('inquirer');

 const {
   getNodeArgs,
   readJson,
   install,
   confirm
 } = require('../lib/utils');

 const {
   installUncaughtExceptionListener
 } = require('../lib/errors');

 const tabtab = require('./completion')
 const coreName = '@weex-cli/core';
 const homePrefix = '.wx';
 let argv

 // environment for running prepare
 let env = {}

 // data for cli instance
 let coreData

 // data in config.json
 let coreConfigurations = {
   version: '',
   name: '',
   is_next: false,
   next_version: '',
   local: '',
   last_update_time: '',
   update_time: 7
 }

 installUncaughtExceptionListener();

 // check if user has use `sudo` or not
 if (process.env.WEEX_ALLOW_SUDO) {
   console.log('root privileges downgrade skipped');
 } else {
   require('root-check')(`
   ${colors.red('Please don\'t use `sudo` to run the command.')}

   If you can't run without sudo, you may have problems during installation.
   Try to run ${colors.underline('sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}')} command to empower your folders.
   `);
 }

 // check if there has userhome floder
 if (!userhome()) {
   console.error(colors.red('ERROR: can not find HOME directory.'));
   this.process.exit(1);
 }

 // saving configuration into config.json
 const save = async (path, config) => {
   try {
     await fse.ensureFile(path)
     await fse.writeJson(path, config, {
       spaces: '\t'
     })
   } catch (err) {
     console.error(err)
   }
 }

 const cli = async (processArgv) => {
   let wantsCompiled;
   let command;
   argv = yargsParser(processArgv.slice(2))
   wantsCompiled = argv.compiled
   command = argv._[0]
   env = {
     cliVersion: pkg.version,
     coreName: coreName,
     coreRoot: userhome(homePrefix, 'core'),
     corePath: userhome(homePrefix, 'core/node_modules', coreName),
     moduleRoot: process.env.WEEX_MODULE_PATH ? process.env.WEEX_MODULE_PATH : userhome(homePrefix, 'modules'),
     templatePath: userhome(homePrefix, 'templates'),
     defaultWeexTemplateRepo: 'weex-templates',
     defaultWeexPlatformFloder: 'platforms',
     defaultWeexTemplate: 'webpack',
     defaultWeexPlatformTemplate: {
       ios: 'weex-playground-ios',
       android: 'weex-playground-android'
     },
     weexAndroidConfigFilename: 'android.config.json',
     weexIOSConfigFilename: 'ios.config.json',
     weexAndroidProjectPath: 'platforms/android',
     weexIOSProjectPath: 'platforms/ios',
     defaultWeexBundleTarget: 'dist',
     defaultWeexBundleEntry: 'index.js',
     defaultWeexBundleCommand: 'npm run dev',
     defaultPreviewWebCommand: 'npm start',
     defaultWeexPlatforms: ['ios', 'android'],
     platformConfigName: 'platforms.json',
     defaultWeexPluginTemplateRepo: 'weex-plugin-template',
     defaultWeexPluginProjectPath: 'plugins',
     defaultWeexPluginConfigName: 'plugins.json',
     registry: argv.registry || process.env.NPM_REGISTRY || 'https://registry.npm.taobao.org',
     moduleConfigFileName: 'stores.json',
     globalConfigFileName: 'config.json',
     home: userhome(homePrefix),
     trash: userhome(homePrefix, 'trash')
   };
   coreData = Object.assign({
     modules: {},
     configs: {},
     argv: processArgv,
   }, env);
   // prepare for running cli
   try {
     await prepare(command, env)
   } catch (error) {
     // TODO: pipe error to solutions.
     console.error(colors.red(`ERROR: ${error.stack || error}`))
   }

   // check if we're running in dev mode
   const devMode = await fse.exists(`${coreData.corePath}/src`);
   if (command === 'completion') {
     // Register complete command
     tabtab.start()
   } else if (!process.env.WEEX_CLI_TEST) {
     if (devMode && !wantsCompiled) {
       // hook into ts-node so we can run typescript on the fly
       require('ts-node').register({
         project: `${coreData.corePath}/tsconfig.json`
       })
       const TSCli = require(`${coreData.corePath}/src/cli/cli`).default;
       (new TSCli(coreData)).start()
     } else {
       try {
         const Cli = require(`${coreData.corePath}/lib/cli/cli`).default;
         (new Cli(coreData)).start()
       } catch (error) {
         debug(`Run cli error, ${error && error.stack}`)
         await prepare('repair', env)
       }
     }
   }
 }

 const initGlobalConfig = async () => {
   const taobao = `http://registry.npm.taobao.org`
   const npm = `http://registry.npmjs.org`

   if (process.env.WEEX_CLI_TEST) {
     return {
       telemetry: false,
       registry: 'https://registry.npmjs.org/'
     }
   }

   const questions = [{
     name: 'telemetry',
     type: 'confirm',
     message: 'May weex-toolkit anonymously report usage statistics to improve the tool over time?',
   },
   {
     name: 'registry',
     type: 'list',
     choices: [{
       name: 'use taobao (for Chinese)',
       value: taobao,
       short: 'taobao'
     },
     {
       name: 'use npm',
       value: npm,
       short: 'npm'
     }
     ],
     message: 'Which npm registry you perfer to use?',
   },
   ]
   const answer = await inquirer.prompt(questions)
   return {
     telemetry: answer.telemetry,
     registry: answer.registry
   }
 }

 const prepare = async (command, config) => {
   // TODO: check there has a new version of `weex-toolkit` or not
   let corePackageJson = {}
   let coreVersion
   let coreName = config.coreName;
   let needInstall = false
   const coreConfigurationsPath = path.join(config.coreRoot, config.globalConfigFileName)
   const hasConfig = await fse.exists(coreConfigurationsPath)
   let corePath = process.env.WEEX_CORE_PATH ? process.env.WEEX_CORE_PATH : config.corePath
   if (hasConfig) {
     debug('Has configuration file and try to readJson')
     coreConfigurations = await fse.readJson(coreConfigurationsPath)
     if (typeof coreConfigurations.telemetry === 'undefined') {
       const userConfigs = await initGlobalConfig()
       coreConfigurations = Object.assign({}, coreConfigurations, userConfigs)
       try {
         await save(coreConfigurationsPath, coreConfigurations)
       } catch (err) {
         console.log(err)
       }
     }
     coreData['configs'] = coreConfigurations
     corePath = process.env.WEEX_CORE_PATH ? process.env.WEEX_CORE_PATH : coreConfigurations.local ? coreConfigurations.local : config.corePath
   }
   if (fse.existsSync(path.join(corePath, 'package.json'))) {
     corePackageJson = await readJson(path.join(corePath, 'package.json'))
   }
   coreData['corePath'] = corePath
   if (fse.existsSync(path.join(config.moduleRoot, config.moduleConfigFileName))) {
     coreData['modules'] = await readJson(path.join(config.moduleRoot, config.moduleConfigFileName))
   }
   if (command === 'repair') {
     const repairModule = argv._[1];
     if (repairModule) {
       const arg = repairModule.split('@');
       if (arg.length > 1) {
         coreVersion = arg.pop();
         coreName = arg.join('@');
       } else {
         coreName = arg;
         coreVersion = 'latest';
       }
     } else {
       coreName = config.coreName
       coreVersion = 'latest'
     }
     // If repair module isn't the core module, pipe argv to the @weex-cli/core
     if (coreName !== config.coreName) {
       needInstall = false;
     } else {
       needInstall = true;
       debug(`start repair ${config.coreName}`)
       console.log(colors.yellow(`Start repair ${config.coreName}, please wait ...`));
     }
   } else {
     // checking if there has weex-cli/core
     if (!corePackageJson.name || !corePackageJson.version) {
       coreVersion = process.env.WEEX_CORE_VERSION || 'latest'
       debug('start install a new core')
       console.log(colors.yellow('Start installing Core, please wait ...'));
       needInstall = true;
     } else {
       if (hasConfig) {
         // while the has core configuration
         // fetching if there has new version
         if (new Date().getTime() - coreConfigurations.last_update_time <= 24 * 3600 * 1000 * (coreConfigurations.updateTimes || 7)) {
           return;
         }
         const latest = await got.get(
           config.registry + '/' + config.coreName + '/latest', {
             'json': true,
             'timeout': 60 * 1000,
             'retries': 0
           }
         );
         if (latest && latest.body) {
           debug('coreData from %s: %o', config.registry, latest.body);
           if (latest.body.version) {
             coreVersion = latest.body.version;
           }
           if (semver.gt(coreVersion, corePackageJson.version)) {
             const result = await confirm(
               'New version detected ' + colors.green(coreVersion) +
               ', the local version is ' + colors.dim(corePackageJson.version) +
               ', upgrade now？[Y/n]'
             );
             if (result) {
               console.log(colors.yellow(`upgrading ${corePackageJson.name} from ${corePackageJson.version} -> ${coreVersion} ...`));
               debug('start upgrade to latest core')
               console.log(colors.yellow(`Upgrading ${corePackageJson.name}, please wait ...`));
               needInstall = true;
             } else {
               let userConfigs = {}
               if (typeof config.telemetry === 'undefined') {
                 userConfigs = await initGlobalConfig()
               }
               coreConfigurations = Object.assign({
                 version: corePackageJson.version,
                 name: corePackageJson.name,
                 is_next: false,
                 next_version: coreVersion,
                 local: path.join(config.coreRoot, 'node_modules', corePackageJson.name),
                 last_update_time: (new Date()).getTime()
               }, userConfigs)
             }
           }
         }
       }
     }
   }

   if (needInstall) {
     try {
       await install(coreName, coreVersion, {
         root: config.coreRoot,
         trash: config.trash,
         force: argv.force || argv.f,
         registry: config.registry,
         ENVS: config.ENVS,
       });
     } catch (error) {
       if (error.stack.indexOf('module is locked') >= 0) {
         console.error(colors.red('\nThe module is locked, please check if there has another installing process.'))
         console.log(`Or you can run the command with ${colors.yellow('`-f`')} or ${colors.yellow('`--force`')} option to skip it.`)
         process.exit(0)
       }
     }
     const packageJson = await fse.readJson(path.join(config.coreRoot, 'node_modules', coreName, 'package.json'))
     let userConfigs = {}
     if (typeof config.telemetry === 'undefined') {
       userConfigs = await initGlobalConfig()
     }
     coreConfigurations = Object.assign({
       version: packageJson.version,
       name: packageJson.name,
       is_next: true,
       next_version: '',
       local: path.join(config.coreRoot, 'node_modules', coreName),
       last_update_time: (new Date()).getTime(),
       update_time: 7
     }, userConfigs)
   }
   try {
     await save(coreConfigurationsPath, coreConfigurations)
   } catch (err) {
     console.log(err)
   }
   return;
 }

 module.exports = cli;
	'use strict';

	const debug = require('debug')('weex:cli');

	const pkg = require('../package.json');
	const colors = require('colors/safe');
	const semver = require('semver');
	const spawn = require('cross-spawn');
	const path = require('path');
	const userhome = require('userhome');
	const yargsParser = require('yargs-parser');
	const fse = require('fs-extra');
	const got = require('got');
	const inquirer = require('inquirer');

	const {
	getNodeArgs,
	readJson,
	install,
	confirm
	} = require('../lib/utils');

	const {
	installUncaughtExceptionListener
	} = require('../lib/errors');

	const tabtab = require('./completion')
	const coreName = '@weex-cli/core';
	const homePrefix = '.wx';
	let argv

	// environment for running prepare
	let env = {}

	// data for cli instance
	let coreData

	// data in config.json
	let coreConfigurations = {
	version: '',
	name: '',
	is_next: false,
	next_version: '',
	local: '',
	last_update_time: '',
	update_time: 7
	}

	installUncaughtExceptionListener();

	// check if user has use `sudo` or not
	if (process.env.WEEX_ALLOW_SUDO) {
	console.log('root privileges downgrade skipped');
	} else {
	require('root-check')(`
	${colors.red('Please don\'t use `sudo` to run the command.')}

	If you can't run without sudo, you may have problems during installation.
	Try to run ${colors.underline('sudo chown -R $(whoami) $(npm config get prefix)/{lib/node_modules,bin,share}')} command to empower your folders.
	`);
	}

	// check if there has userhome floder
	if (!userhome()) {
	console.error(colors.red('ERROR: can not find HOME directory.'));
	this.process.exit(1);
	}

	// saving configuration into config.json
	const save = async (path, config) => {
	try {
	await fse.ensureFile(path)
	await fse.writeJson(path, config, {
	spaces: '\t'
	})
	} catch (err) {
	console.error(err)
	}
	}

	const cli = async (processArgv) => {
	let wantsCompiled;
	let command;
	argv = yargsParser(processArgv.slice(2))
	wantsCompiled = argv.compiled
	command = argv._[0]
	env = {
	cliVersion: pkg.version,
	coreName: coreName,
	coreRoot: userhome(homePrefix, 'core'),
	corePath: userhome(homePrefix, 'core/node_modules', coreName),
	moduleRoot: process.env.WEEX_MODULE_PATH ? process.env.WEEX_MODULE_PATH : userhome(homePrefix, 'modules'),
	templatePath: userhome(homePrefix, 'templates'),
	defaultWeexTemplateRepo: 'weex-templates',
	defaultWeexPlatformFloder: 'platforms',
	defaultWeexTemplate: 'webpack',
	defaultWeexPlatformTemplate: {
	ios: 'weex-playground-ios',
	android: 'weex-playground-android'
	},
	weexAndroidConfigFilename: 'android.config.json',
	weexIOSConfigFilename: 'ios.config.json',
	weexAndroidProjectPath: 'platforms/android',
	weexIOSProjectPath: 'platforms/ios',
	defaultWeexBundleTarget: 'dist',
	defaultWeexBundleEntry: 'index.js',
	defaultWeexBundleCommand: 'npm run dev',
	defaultPreviewWebCommand: 'npm start',
	defaultWeexPlatforms: ['ios', 'android'],
	platformConfigName: 'platforms.json',
	defaultWeexPluginTemplateRepo: 'weex-plugin-template',
	defaultWeexPluginProjectPath: 'plugins',
	defaultWeexPluginConfigName: 'plugins.json',
	registry: argv.registry \|\| process.env.NPM_REGISTRY \|\| 'https://registry.npm.taobao.org',
	moduleConfigFileName: 'stores.json',
	globalConfigFileName: 'config.json',
	home: userhome(homePrefix),
	trash: userhome(homePrefix, 'trash')
	};
	coreData = Object.assign({
	modules: {},
	configs: {},
	argv: processArgv,
	}, env);
	// prepare for running cli
	try {
	await prepare(command, env)
	} catch (error) {
	// TODO: pipe error to solutions.
	console.error(colors.red(`ERROR: ${error.stack \|\| error}`))
	}

	// check if we're running in dev mode
	const devMode = await fse.exists(`${coreData.corePath}/src`);
	if (command === 'completion') {
	// Register complete command
	tabtab.start()
	} else if (!process.env.WEEX_CLI_TEST) {
	if (devMode && !wantsCompiled) {
	// hook into ts-node so we can run typescript on the fly
	require('ts-node').register({
	project: `${coreData.corePath}/tsconfig.json`
	})
	const TSCli = require(`${coreData.corePath}/src/cli/cli`).default;
	(new TSCli(coreData)).start()
	} else {
	try {
	const Cli = require(`${coreData.corePath}/lib/cli/cli`).default;
	(new Cli(coreData)).start()
	} catch (error) {
	debug(`Run cli error, ${error && error.stack}`)
	await prepare('repair', env)
	}
	}
	}
	}

	const initGlobalConfig = async () => {
	const taobao = `http://registry.npm.taobao.org`
	const npm = `http://registry.npmjs.org`

	if (process.env.WEEX_CLI_TEST) {
	return {
	telemetry: false,
	registry: 'https://registry.npmjs.org/'
	}
	}

	const questions = [{
	name: 'telemetry',
	type: 'confirm',
	message: 'May weex-toolkit anonymously report usage statistics to improve the tool over time?',
	},
	{
	name: 'registry',
	type: 'list',
	choices: [{
	name: 'use taobao (for Chinese)',
	value: taobao,
	short: 'taobao'
	},
	{
	name: 'use npm',
	value: npm,
	short: 'npm'
	}
	],
	message: 'Which npm registry you perfer to use?',
	},
	]
	const answer = await inquirer.prompt(questions)
	return {
	telemetry: answer.telemetry,
	registry: answer.registry
	}
	}

	const prepare = async (command, config) => {
	// TODO: check there has a new version of `weex-toolkit` or not
	let corePackageJson = {}
	let coreVersion
	let coreName = config.coreName;
	let needInstall = false
	const coreConfigurationsPath = path.join(config.coreRoot, config.globalConfigFileName)
	const hasConfig = await fse.exists(coreConfigurationsPath)
	let corePath = process.env.WEEX_CORE_PATH ? process.env.WEEX_CORE_PATH : config.corePath
	if (hasConfig) {
	debug('Has configuration file and try to readJson')
	coreConfigurations = await fse.readJson(coreConfigurationsPath)
	if (typeof coreConfigurations.telemetry === 'undefined') {
	const userConfigs = await initGlobalConfig()
	coreConfigurations = Object.assign({}, coreConfigurations, userConfigs)
	try {
	await save(coreConfigurationsPath, coreConfigurations)
	} catch (err) {
	console.log(err)
	}
	}
	coreData['configs'] = coreConfigurations
	corePath = process.env.WEEX_CORE_PATH ? process.env.WEEX_CORE_PATH : coreConfigurations.local ? coreConfigurations.local : config.corePath
	}
	if (fse.existsSync(path.join(corePath, 'package.json'))) {
	corePackageJson = await readJson(path.join(corePath, 'package.json'))
	}
	coreData['corePath'] = corePath
	if (fse.existsSync(path.join(config.moduleRoot, config.moduleConfigFileName))) {
	coreData['modules'] = await readJson(path.join(config.moduleRoot, config.moduleConfigFileName))
	}
	if (command === 'repair') {
	const repairModule = argv._[1];
	if (repairModule) {
	const arg = repairModule.split('@');
	if (arg.length > 1) {
	coreVersion = arg.pop();
	coreName = arg.join('@');
	} else {
	coreName = arg;
	coreVersion = 'latest';
	}
	} else {
	coreName = config.coreName
	coreVersion = 'latest'
	}
	// If repair module isn't the core module, pipe argv to the @weex-cli/core
	if (coreName !== config.coreName) {
	needInstall = false;
	} else {
	needInstall = true;
	debug(`start repair ${config.coreName}`)
	console.log(colors.yellow(`Start repair ${config.coreName}, please wait ...`));
	}
	} else {
	// checking if there has weex-cli/core
	if (!corePackageJson.name \|\| !corePackageJson.version) {
	coreVersion = process.env.WEEX_CORE_VERSION \|\| 'latest'
	debug('start install a new core')
	console.log(colors.yellow('Start installing Core, please wait ...'));
	needInstall = true;
	} else {
	if (hasConfig) {
	// while the has core configuration
	// fetching if there has new version
	if (new Date().getTime() - coreConfigurations.last_update_time <= 24 * 3600 * 1000 * (coreConfigurations.updateTimes \|\| 7)) {
	return;
	}
	const latest = await got.get(
	config.registry + '/' + config.coreName + '/latest', {
	'json': true,
	'timeout': 60 * 1000,
	'retries': 0
	}
	);
	if (latest && latest.body) {
	debug('coreData from %s: %o', config.registry, latest.body);
	if (latest.body.version) {
	coreVersion = latest.body.version;
	}
	if (semver.gt(coreVersion, corePackageJson.version)) {
	const result = await confirm(
	'New version detected ' + colors.green(coreVersion) +
	', the local version is ' + colors.dim(corePackageJson.version) +
	', upgrade now？[Y/n]'
	);
	if (result) {
	console.log(colors.yellow(`upgrading ${corePackageJson.name} from ${corePackageJson.version} -> ${coreVersion} ...`));
	debug('start upgrade to latest core')
	console.log(colors.yellow(`Upgrading ${corePackageJson.name}, please wait ...`));
	needInstall = true;
	} else {
	let userConfigs = {}
	if (typeof config.telemetry === 'undefined') {
	userConfigs = await initGlobalConfig()
	}
	coreConfigurations = Object.assign({
	version: corePackageJson.version,
	name: corePackageJson.name,
	is_next: false,
	next_version: coreVersion,
	local: path.join(config.coreRoot, 'node_modules', corePackageJson.name),
	last_update_time: (new Date()).getTime()
	}, userConfigs)
	}
	}
	}
	}
	}
	}

	if (needInstall) {
	try {
	await install(coreName, coreVersion, {
	root: config.coreRoot,
	trash: config.trash,
	force: argv.force \|\| argv.f,
	registry: config.registry,
	ENVS: config.ENVS,
	});
	} catch (error) {
	if (error.stack.indexOf('module is locked') >= 0) {
	console.error(colors.red('\nThe module is locked, please check if there has another installing process.'))
	console.log(`Or you can run the command with ${colors.yellow('`-f`')} or ${colors.yellow('`--force`')} option to skip it.`)
	process.exit(0)
	}
	}
	const packageJson = await fse.readJson(path.join(config.coreRoot, 'node_modules', coreName, 'package.json'))
	let userConfigs = {}
	if (typeof config.telemetry === 'undefined') {
	userConfigs = await initGlobalConfig()
	}
	coreConfigurations = Object.assign({
	version: packageJson.version,
	name: packageJson.name,
	is_next: true,
	next_version: '',
	local: path.join(config.coreRoot, 'node_modules', coreName),
	last_update_time: (new Date()).getTime(),
	update_time: 7
	}, userConfigs)
	}
	try {
	await save(coreConfigurationsPath, coreConfigurations)
	} catch (err) {
	console.log(err)
	}
	return;
	}

	module.exports = cli;