findYarnVersion(path => {
  let result = spawnSync(
    'node',
    [path, '--cwd', 'app', 'install', '--force'],
    options
  )

  if (result.status !== 0) {
    process.exit(result.status)
  }

  result = spawnSync(
    'git',
    ['submodule', 'update', '--recursive', '--init'],
    options
  )

  if (result.status !== 0) {
    process.exit(result.status)
  }

  result = spawnSync('node', [path, 'compile:tslint'], options)

  if (result.status !== 0) {
    process.exit(result.status)
  }

  result = spawnSync('node', [path, 'compile:script'], options)

  if (result.status !== 0) {
    process.exit(result.status)
  }
})

export function detect(): DartSdkExecutableMap {
  let sdk: DartSdkExecutableMap;
  try {
    const dartExecutable = which.sync('dart');
    if (process.platform === 'win32') {
      sdk = {
        ANALYZER: 'dartanalyzer.bat',
        DARTDOCGEN: 'dartdoc.bat',
        DARTFMT: 'dartfmt.bat',
        PUB: 'pub.bat',
        VM: 'dart.exe'
      };
    } else {
      sdk = {
        ANALYZER: 'dartanalyzer',
        DARTDOCGEN: 'dartdoc',
        DARTFMT: 'dartfmt',
        PUB: 'pub',
        VM: 'dart'
      };
    }
    console.log('Dart SDK detected:', dartExecutable);
    console.log('- dart: ' + child_process.spawnSync(sdk.VM, ['--version']).stderr.toString().replace(/\n/g, ''));
    console.log('- pub: ' + child_process.spawnSync(sdk.PUB, ['--version']).stdout.toString().replace(/\n/g, ''));

    return sdk;
  } catch (e) {
    console.log('Dart SDK is not available.');
    return null;
  }
}

/** Returns the name and email of the Git user that creates this release build. */
function getCurrentGitUser() {
  const userName = spawnSync('git', ['config', 'user.name'], {cwd: buildConfig.projectDir})
    .stdout.toString().trim();

  const userEmail = spawnSync('git', ['config', 'user.email'], {cwd: buildConfig.projectDir})
    .stdout.toString().trim();

  return `${userName} <${userEmail}>`;
}

 it('should be able to use the d.ts', async () => {
   console.log(`${__filename} staging area: ${stagingPath}`);
   cp.spawnSync('npm', ['pack'], spawnOpts);
   const tarball = `${pkg.name}-${pkg.version}.tgz`;
   await (mvp as Function)(tarball, `${stagingPath}/googleapis.tgz`);
   await ncpp('test/fixtures/kitchen', `${stagingPath}/`);
   cp.spawnSync(
     'npm',
     ['install'],
     Object.assign({cwd: `${stagingPath}/`}, spawnOpts)
   );
 }).timeout(80000);

async function setup(): Promise<void> {
	console.log('*** Test data:', testDataPath);
	console.log('*** Preparing smoketest setup...');

	const keybindingsUrl = `https://raw.githubusercontent.com/Microsoft/vscode-docs/master/scripts/keybindings/doc.keybindings.${getKeybindingPlatform()}.json`;
	console.log('*** Fetching keybindings...');

	await new Promise((c, e) => {
		https.get(keybindingsUrl, res => {
			const output = fs.createWriteStream(keybindingsPath);
			res.on('error', e);
			output.on('error', e);
			output.on('close', c);
			res.pipe(output);
		}).on('error', e);
	});

	if (!fs.existsSync(workspacePath)) {
		console.log('*** Creating workspace file...');
		const workspace = {
			folders: [
				{
					path: toUri(path.join(testRepoLocalDir, 'public'))
				},
				{
					path: toUri(path.join(testRepoLocalDir, 'routes'))
				},
				{
					path: toUri(path.join(testRepoLocalDir, 'views'))
				}
			]
		};

		fs.writeFileSync(workspacePath, JSON.stringify(workspace, null, '\t'));
	}

	if (!fs.existsSync(testRepoLocalDir)) {
		console.log('*** Cloning test project repository...');
		cp.spawnSync('git', ['clone', testRepoUrl, testRepoLocalDir]);
	} else {
		console.log('*** Cleaning test project repository...');
		cp.spawnSync('git', ['fetch'], { cwd: testRepoLocalDir });
		cp.spawnSync('git', ['reset', '--hard', 'FETCH_HEAD'], { cwd: testRepoLocalDir });
		cp.spawnSync('git', ['clean', '-xdf'], { cwd: testRepoLocalDir });
	}

	console.log('*** Running npm install...');
	cp.execSync('npm install', { cwd: testRepoLocalDir, stdio: 'inherit' });

	console.log('*** Smoketest setup done!\n');
}

export function checkInstallation(executable: Executable, projectDir: string) {
  const child = spawnSync(executable, ['version'], {
    cwd: projectDir,
    shell: false,
  });
  return child.status === 0;
}

export function spawnSync(tool: string,
                          args: string[],
                          toolchain: Toolchain = 'default',
                          options?: child_process.SpawnOptions)
{
  return child_process.spawnSync(tool, toolchainPrefix(toolchain).concat(args), options);
}

function validateWorkspace(): void {
	try {
		let spawn = require("child_process").spawnSync;
		let rubocop = spawn(rubocopPath, ["-f", "j", vscode.workspace.rootPath], { cwd: vscode.workspace.rootPath });
		let rubocopOutput = JSON.parse(rubocop.stdout);
		let arr = [];
		for (var r = 0; r < rubocopOutput.files.length; r++) {
			var rubocopFile = rubocopOutput.files[r];
			let uri: vscode.Uri = vscode.Uri.file((path.join(vscode.workspace.rootPath, rubocopFile.path)));
			var offenses = rubocopFile.offenses;
			let diagnostics: vscode.Diagnostic[] = [];
			for (var i = 0; i < offenses.length; i++) {
				let _line = parseInt(offenses[i].location.line) - 1;
				let _start = parseInt(offenses[i].location.column) - 1;
				let _end = parseInt(_start + offenses[i].location.length);
				let diagRange = new vscode.Range(_line, _start, _line, _end);
				let diagMsg = `${offenses[i].message} (${offenses[i].cop_name})`;
				let diagSeverity = convertSeverity(offenses[i].severity);
				let diagnostic = new vscode.Diagnostic(diagRange, diagMsg, diagSeverity);
				diagnostics.push(diagnostic);
			}
			arr.push([uri, diagnostics]);
		}
		diagnosticCollection.clear();
		diagnosticCollection.set(arr);
	}
	catch(err) {
		console.log(err);
	}
	return;
}

export default function shellSpawnSync(args) {
	if (args === 'shell') {
		args = [platform() === 'win32' ? 'cmd.exe' : 'bash'];
	}
	
	if (prettyPrint) {
		console.log('::: %s', args.join(' '));
	}
	
	const child = spawnSync(args[0], args.slice(1), {
		stdio: 'inherit',
		cwd: process.cwd(),
		env: process.env,
	});
	if (child) {
		if (child.error) {
			console.error(`can't run command "${args[0]}"\n  %s`, child.error.message);
			return child.status || 127;
		} else {
			return child.status;
		}
	} else {
		console.error(`can't run command "${args[0]}"`);
		return 127;
	}
};

export function checkPublishBranch(version: string) {
  const versionType = getSemverVersionType(version);
  const branchName = spawnSync('git', ['symbolic-ref', '--short', 'HEAD'],
    {cwd: buildConfig.projectDir}).stdout.toString().trim();

  if (branchName === 'master') {
    if (versionType === 'major') {
      return;
    }

    throw `Publishing of "${versionType}" releases should not happen inside of the ` +
        `${bold('master')} branch.`;
  }

  const branchNameMatch = branchName.match(publishBranchNameRegex) || [];
  const branchDigits = branchNameMatch.slice(1, 4);

  if (branchDigits[2] === 'x' && versionType !== 'patch') {
    throw `Cannot publish a "${versionType}" release inside of a patch branch (${branchName})`;
  }

  if (branchDigits[1] === 'x' && versionType !== 'minor') {
    throw `Cannot publish a "${versionType}" release inside of a minor branch (${branchName})`;
  }

  throw `Cannot publish a "${versionType}" release from branch: "${branchName}". Releases should `
  + `be published from "master" or the according publish branch (e.g. "6.x", "6.4.x")`;
}

     vs.window.showErrorMessage(`Sorry! '${action}' encountered an error.`, "Report Issue").then(() => {
        try {
            const sb = new StringBuilder();
            sb.appendLine("Platform: " + process.platform);
            sb.appendLine();
            sb.appendLine("Exception:");
            sb.appendLine(serializeError(error));

            const uri = `https://github.com/joelday/vscode-docthis/issues/new?title=${
                encodeURIComponent(`Exception thrown in '${action}': ${error.message}`)
            }&body=${
                encodeURIComponent(sb.toString())
            }`;

            if (process.platform !== "win32") {
                openurl.open(uri, openErr => { console.error("Failed to launch browser", openErr); });
            } else {
                const proc = childProcess.spawnSync("cmd", [
                    "/c",
                    "start",
                    uri.replace(/[&]/g, "^&")
                ]);
            }
        }
        catch (reportErr) {
            reportError(reportErr, "Report Error");
        }
    });

function compileShader(projectDir, type, from, to, temp, platform, nokrafix) {
	let compiler = '';
	
	if (Project.koreDir !== '') {
		if (nokrafix) {
			compiler = path.resolve(Project.koreDir, 'Tools', 'kfx', 'kfx' + exec.sys());
		}
		else {
			compiler = path.resolve(Project.koreDir, 'Tools', 'krafix', 'krafix' + exec.sys());
		}
	}

	if (fs.existsSync(path.join(projectDir.toString(), 'Backends'))) {
		let libdirs = fs.readdirSync(path.join(projectDir.toString(), 'Backends'));
		for (let ld in libdirs) {
			let libdir = path.join(projectDir.toString(), 'Backends', libdirs[ld]);
			if (fs.statSync(libdir).isDirectory()) {
				let exe = path.join(libdir, 'krafix', 'krafix-' + platform + '.exe');
				if (fs.existsSync(exe)) {
					compiler = exe;
				}
			}
		}
	}

	if (compiler !== '') {
		child_process.spawnSync(compiler, [type, from, to, temp, platform]);
	}
}

export function terminate(process: ChildProcess, cwd?: string): boolean {
  if (isWindows) {
    try {
      // This we run in Atom execFileSync is available.
      // Ignore stderr since this is otherwise piped to parent.stderr
      // which might be already closed.
      let options: any = {
        stdio: ['pipe', 'pipe', 'ignore']
      }
      if (cwd) {
        options.cwd = cwd
      }
      cp.execFileSync(
        'taskkill',
        ['/T', '/F', '/PID', process.pid.toString()],
        options
      )
      return true
    } catch (err) {
      return false
    }
  } else if (isLinux || isMacintosh) {
    try {
      let cmd = join(pluginRoot, 'bin/terminateProcess.sh')
      let result = cp.spawnSync(cmd, [process.pid.toString()])
      return result.error ? false : true
    } catch (err) {
      return false
    }
  } else {
    process.kill('SIGKILL')
    return true
  }
}

/** Uploads the coverage results to the firebase database. */
function uploadResults(results: any): Promise<void> {
  let latestSha = spawnSync('git', ['rev-parse', 'HEAD']).stdout.toString().trim();
  let database = openFirebaseDashboardDatabase();

  return database.ref('coverage-reports').child(latestSha).set(results)
    .then(() => database.goOffline(), () => database.goOffline());
}

 /**
  * Spawns a child process running Git. The "stderr" output is inherited and will be printed
  * in case of errors. This makes it easier to debug failed commands.
  */
 private _spawnGitProcess(args: string[], printStderr = true): SpawnSyncReturns<string> {
   return spawnSync('git', args, {
     cwd: this.projectDir,
     stdio: ['pipe', 'pipe', printStderr ? 'inherit' : 'pipe'],
     encoding: 'utf8',
   });
 }

export function npmLoginInteractive(): boolean {
  return spawnSync('npm', ['login'], {
    stdio: 'inherit',
    shell: true,
    env: npmClientEnvironment,
  }).status === 0;
}

const which = async (type: string, prog: string, promise: () => Promise<any>) => {
  if (spawnSync('which', [prog]).status === 0) {
    await promise();
  } else {
    throw new Error(`${prog} is required to install ${type} packages`);
  }
};

 const copyApp = async (newDir: string, fixture = 'initial') => {
   const appBundlePath = path.resolve(process.execPath, '../../..')
   const newPath = path.resolve(newDir, 'Electron.app')
   cp.spawnSync('cp', ['-R', appBundlePath, path.dirname(newPath)])
   const appDir = path.resolve(newPath, 'Contents/Resources/app')
   await fs.mkdirp(appDir)
   await fs.copy(path.resolve(fixturesPath, 'auto-update', fixture), appDir)
   const plistPath = path.resolve(newPath, 'Contents', 'Info.plist')
   await fs.writeFile(
     plistPath,
     (await fs.readFile(plistPath, 'utf8')).replace('<key>BuildMachineOSBuild</key>', `<key>NSAppTransportSecurity</key>
     <dict>
         <key>NSAllowsArbitraryLoads</key>
         <true/>
         <key>NSExceptionDomains</key>
         <dict>
             <key>localhost</key>
             <dict>
                 <key>NSExceptionAllowsInsecureHTTPLoads</key>
                 <true/>
                 <key>NSIncludesSubdomains</key>
                 <true/>
             </dict>
         </dict>
     </dict><key>BuildMachineOSBuild</key>`)
   )
   return newPath
 }

/** Finds all files in the specified package dir where version placeholders are included. */
function findFilesWithPlaceholders(packageDir: string): string[] {
  const findCommand = buildPlaceholderFindCommand(packageDir);
  return spawnSync(findCommand.binary, findCommand.args).stdout
    .toString()
    .split(/[\n\r]/)
    .filter(String);
}

	compile(inFilename: string, outFilename: string) {
		if (fs.existsSync(outFilename)) return;

		//console.log("Compiling " + inFilename + " to " + outFilename);
		//console.log(emmccPath + " " + inFilename+ " " +includes+ " " +defines+ " " +"-c -o"+ " " +outFilename);

		//console.log(emmccPath + " " + inFilename+ " " +  includes+ " " +  defines+ " " + "-c -o"+ " " + outFilename);

		let params = [];
		params.push(inFilename);

		for (let i = 0; i < includesArray.length; i++) {
			params.push(includesArray[i]);
		}

		for (let i = 0; i < definesArray.length; i++) {
			params.push(definesArray[i]);
		}

		params.push("-c");
		params.push("-o");
		params.push(outFilename);

		//console.log(params);

		let res = child_process.spawnSync(emmccPath, params, {stdio: 'inherit'});
		if (res != null) {
			if (res.stdout != null && res.stdout.toString() != '')
				console.log("stdout: " + res.stdout);
			if (res.stderr != null && res.stderr.toString() != '')
				console.log("stderr: " + res.stderr);
			if (res.error != null)
				console.log(res.error);
		}
	}