constructor (public name) {
		
		shell.exec(`git clone [email protected]:vecbralis/meants-public.git ${name}`);
		shell.cd(name);
		shell.exec('npm install');

	}

	run(path, name) {

		if (path) {
			shell.exec(`mkdir -p app/models/${path}`);
		} else {
			path = null;
		}

		shell.exec(`cp -a node_modules/meants/examples/models/default.ts app/models/${path}/${name}.ts`);

		shell.echo(`New model created file path/name: app/models/${path} ${name}`);

	}

export function runCommandOnSameMachine(command: string, options: RemoteCommandOptions): Q.Promise<string> {
    var defer = Q.defer<string>();
    var stdErrWritten: boolean = false;

    if (!options) {
        tl.debug('Options not passed to runCommandOnRemoteMachine, setting defaults.');
        var options = new RemoteCommandOptions();
        options.failOnStdErr = true;
    }

    var cmdToRun = command;
    tl.debug('cmdToRun = ' + cmdToRun);

    shell.exec(cmdToRun, (err, stdout, stderr) => {
        if (err) {
            tl.debug('code = ' + err);
            defer.reject(tl.loc('RemoteCmdNonZeroExitCode', cmdToRun, err))
        } else {
            tl.debug('code = 0');
            if (stderr != '' && options.failOnStdErr === true) {
                defer.reject(tl.loc('RemoteCmdExecutionErr'));
            } else {
                defer.resolve('0');
            }
        }
    });
    return defer.promise;
}

export function exec(
  s: string,
  env: NodeJS.ProcessEnv | undefined,
  printFailure: boolean = true
): { stdout: string; code: number } {
  debug(s);
  if (env === undefined) {
    env = process.env;
  }
  const result = shell.exec(s, { silent: !DEBUG, env }) as any;

  if (result.code !== 0) {
    const failureObj = {
      command: s,
      code: result.code
    };
    if (!printFailure) {
      throw failureObj;
    }
    console.error(result.stdout);
    console.error(result.stderr);
    failWith("Command failed", failureObj);
  }

  return result;
}

/**
 * Calls any external programs to finish setting up the library
 */
function finalize() {
  console.log(colors.underline.white("Finalizing"))

  // Recreate Git folder
  let gitInitOutput = exec('git init "' + path.resolve(__dirname, "..") + '"', {
    silent: true
  }).stdout
  console.log(colors.green(gitInitOutput.replace(/(\n|\r)+/g, "")))

  // Remove post-install command
  let jsonPackage = path.resolve(__dirname, "..", "package.json")
  const pkg = JSON.parse(readFileSync(jsonPackage) as any)

  // Note: Add items to remove from the package file here
  delete pkg.scripts.postinstall

  writeFileSync(jsonPackage, JSON.stringify(pkg, null, 2))
  console.log(colors.green("Postinstall script has been removed"))

  // Initialize Husky
  fork(
    path.resolve(__dirname, "..", "node_modules", "husky", "bin", "install"),
    { silent: true }
  );
  console.log(colors.green("Git hooks set up"))

  console.log("\n")
}

 withAfterEach(async t => {
   await fse.ensureDir('out');
   const { stderr } = shell.exec('node dist/src/cp-cli test/assets out');
   t.equal(stderr, '');
   const stats = fse.statSync('out/foo.txt');
   t.true(stats.isFile());
 }),

function getUser() {
  var user_command = shell.exec("git config --get github.user")
  if (user_command.code !== 0 || !user_command.output.trim()) {
    return vscode.window.showInputBox({ prompt: "Enter your github username" })
  } else {
    return Promise.resolve(user_command.output.trim());
  }
}

  public run(): void {
    this.syncConfigFiles('settings.json')
    this.syncConfigFiles('keybindings.json')
    new ExtensionSyncer(this.configPath).run()

    if (process.platform === 'darwin') {
      exec('defaults write com.microsoft.VSCode ApplePressAndHoldEnabled -bool false')
    }
  }

 public static fromVSCode(): Extensions {
   return new Extensions(
     exec(`code --list-extensions`, { silent: true })
       .stdout.toString()
       .trim()
       .split('\n')
       .filter(name => name.length > 0)
   )
 }

export function $(cmd) {
  const result = shell.exec(cmd, {silent: true});
  if (result.code > 0) {
    console.log('$', cmd);
    console.log(result.stderr);
    process.exit(1);
  }
  return result.stdout.trim();
}

 return new Promise<ExecResult>((resolve, reject) => {
   shelljs.exec(cmdline, { async: true, silent: true }, (code, stdout, stderr) => {
     resolve({
       exitCode: code,
       stdout: stdout,
       stderr: stderr
     });
   });
 });

export function exec(cmdLine: string): Q.Promise<any> {
    var defer = Q.defer<any>();

    shell.exec(cmdLine, (code, output) => {
        defer.resolve({code: code, output: output});
    });

    return defer.promise;
}

 return new Promise((resolve, reject) => {
   shell.exec('ti project -o json' + project_flag, function(code, output) {
     if (code === 0) {
       resolve(JSON.parse(output));
     } else {
       console.log(output);
       reject(output);
     }
   })
 });

async function prepareQuickAppEnvironment (buildData: IBuildData) {
  let isReady = false
  let needDownload = false
  let needInstall = false
  const originalOutputDir = buildData.originalOutputDir
  console.log()
  if (fs.existsSync(path.join(buildData.originalOutputDir, 'sign'))) {
    needDownload = false
  } else {
    needDownload = true
  }
  if (needDownload) {
    const getSpinner = ora('开始下载快应用运行容器...').start()
    await downloadGithubRepoLatestRelease('NervJS/quickapp-container', buildData.appPath, originalOutputDir)
    await unzip(path.join(originalOutputDir, 'download_temp.zip'))
    getSpinner.succeed('快应用运行容器下载完成')
  } else {
    console.log(`${chalk.green('✔ ')} 快应用容器已经准备好`)
  }

  console.log()
  process.chdir(originalOutputDir)
  if (fs.existsSync(path.join(originalOutputDir, 'node_modules'))) {
    needInstall = false
  } else {
    needInstall = true
  }
  if (needInstall) {
    let command
    if (shouldUseYarn()) {
      command = 'NODE_ENV=development yarn install'
    } else if (shouldUseCnpm()) {
      command = 'NODE_ENV=development cnpm install'
    } else {
      command = 'NODE_ENV=development npm install'
    }
    const installSpinner = ora(`安装快应用依赖环境, 需要一会儿...`).start()
    const install = shelljs.exec(command, { silent: true })
    if (install.code === 0) {
      installSpinner.color = 'green'
      installSpinner.succeed('安装成功')
      console.log(`${install.stderr}${install.stdout}`)
      isReady = true
    } else {
      installSpinner.color = 'red'
      installSpinner.fail(chalk.red(`快应用依赖环境安装失败，请进入 ${path.basename(originalOutputDir)} 重新安装！`))
      console.log(`${install.stderr}${install.stdout}`)
      isReady = false
    }
  } else {
    console.log(`${chalk.green('✔ ')} 快应用依赖已经安装好`)
    isReady = true
  }
  return isReady
}

xspec(__filename, async function(_env, done) {
    this.timeout(5 * 60 * 1000);

    exec('rimraf package.json');
    exec('git clone --depth 1 https://github.com/angularclass/angular2-webpack-starter.git .');
    exec('yarn install');
    exec('rimraf node_modules/awesome-typescript-loader');
    ln('-s', _env.LOADER, './node_modules/awesome-typescript-loader');

    const wp = run('npm', ['run', 'webpack']);

    await wp.wait(
        stdout('[at-loader] Ok')
    );

    const code = await wp.alive();
    expect(code).eq(0);

    done();
});

 return new Promise<{ stdout: string; code: number }>((resolve, reject) => {
   debug(s);
   shell.exec(s, opts, (code, stdout, stderr) => {
     if (code !== 0) {
       console.error(stdout);
       console.error(stderr);
       reject({ command: s, code });
     }
     resolve({ stdout, code });
   });
 });

var resolveCapabilityViaShell = function(filteredEnv: any, command: string, args: string, capability: string) {
    var tool = shell.which(command);
    if (!tool) {
        return;
    }

    var val = shell.exec(command + ' ' + args, {silent:true}).output;
    if (val) {
        setCapability(filteredEnv, capability, val);
    }
}

/**
 * Calls all of the functions needed to setup the library
 * 
 * @param libraryName
 */
function setupLibrary(libraryName: string) {
  console.log(
    colors.cyan(
      "\nThanks for the info. The last few changes are being made... hang tight!\n\n"
    )
  )

  // Get the Git username and email before the .git directory is removed
  let username = exec("git config user.name").stdout.trim()
  let usermail = exec("git config user.email").stdout.trim()

  removeItems()

  modifyContents(libraryName, username, usermail)

  renameItems(libraryName)

  finalize()

  console.log(colors.cyan("OK, you're all set. Happy coding!! ;)\n"))
}

function getPass() {
  var password_command = shell.exec("git config --get github.password")
  if (password_command.code !== 0 || !password_command.output.trim()) {
    return vscode.window.showInputBox({
      prompt: "Enter your github password. \n" +
      "Read the docs for token based authentication.",
      password: true
    })
  } else {
    return Promise.resolve(password_command.output.trim());
  }
}

function checkDependency(serviceName: string, command: string, transform: (x: string) => string): void {
	const code = {
		success: 0,
		notFound: 127
	};
	const x = exec(command, { silent: true }) as any;
	if (x.code === code.success) {
		logInfo(`DEPS: ${serviceName} ${transform(x.stdout)}`);
	} else if (x.code === code.notFound) {
		logWarn(`Unable to find ${serviceName}`);
	}
}