How to use the dugite.GitProcess.exec function in dugite

async function pushRelease (branch) {
  const pushDetails = await GitProcess.exec(['push', 'origin', `HEAD:${branch}`, '--follow-tags'], ELECTRON_DIR)
  if (pushDetails.exitCode === 0) {
    console.log(`${pass} Successfully pushed the release.  Wait for ` +
      `release builds to finish before running "npm run release".`)
  } else {
    console.log(`${fail} Error pushing the release: ${pushDetails.stderr}`)
    process.exit(1)
  }
}

async function mergeReleaseIntoBranch (branchName) {
  console.log(`Merging release branch into ${branchName}.`)
  let mergeArgs = ['merge', 'release', '--squash']
  let mergeDetails = await GitProcess.exec(mergeArgs, gitDir)
  if (mergeDetails.exitCode === 0) {
    return true
  } else {
    const error = GitProcess.parseError(mergeDetails.stderr)
    if (error === GitError.MergeConflicts) {
      console.log(`${fail} Could not merge release branch into ${branchName} ` +
        `due to merge conflicts.`)
      return false
    } else {
      console.log(`${fail} Could not merge release branch into ${branchName} ` +
        `due to an error: ${mergeDetails.stderr}.`)
      process.exit(1)
    }
  }
}

async diff(filePath: string, compareWithCommit: string): Promise {
		try {
			let args = ['diff', filePath];
			if (compareWithCommit) {
				args = ['diff', compareWithCommit, '--', filePath];
			}

			const result = await GitProcess.exec(args, this.path);
			return result.stdout.trim();
		} catch (e) {
			return '';
		}
	}

export async function fetch(repository: Repository, remoteName: string, branch: string) {
	const result = await GitProcess.exec(
		[
			'fetch',
			remoteName,
			branch
		],
		repository.path
	);

	if (result.exitCode !== 0) {
		throw (result.stderr);
	}
}

export async function getBranch(repository: Repository, name: string): Promise {
	if (name === 'HEAD') {
		return getHEAD(repository);
	}

	const result = await GitProcess.exec(['rev-parse', name], repository.path);

	if (!result.stdout) {
		return Promise.reject(new Error('No such branch'));
	}

	const commit = result.stdout.trim();

	try {
		const res2 = await GitProcess.exec(['rev-parse', '--symbolic-full-name', name + '@{u}'], repository.path);
		const fullUpstream = res2.stdout.trim();
		const match = /^refs\/remotes\/([^/]+)\/(.+)$/.exec(fullUpstream);

		if (!match) {
			throw new Error(`Could not parse upstream branch: ${fullUpstream}`);
		}

		const upstream = { remote: match[1], name: match[2] };
		const res3 = await GitProcess.exec(['rev-list', '--left-right', name + '...' + fullUpstream], repository.path);

		let ahead = 0, behind = 0;
		let i = 0;

		while (i < res3.stdout.length) {
			switch (res3.stdout.charAt(i)) {
				case '<': ahead++; break;

async diffHashed(hash0: string, hash1: string) {
		try {
			const args = ['diff', hash0, hash1];
			const result = await GitProcess.exec(args, this.path);
			return result.stdout.trim();
		} catch (e) {
			return '';
		}
	}

async getBranch(name: string): Promise {
		if (name === 'HEAD') {
			return this.getHEAD();
		}

		const result = await GitProcess.exec(['rev-parse', name], this.path);

		if (result.exitCode !== 0 || !result.stdout) {
			return null;
		}

		const commit = result.stdout.trim();

		try {
			const res2 = await GitProcess.exec(['rev-parse', '--symbolic-full-name', name + '@{u}'], this.path);
			const fullUpstream = res2.stdout.trim();
			const match = /^refs\/remotes\/([^/]+)\/(.+)$/.exec(fullUpstream);

			if (!match) {
				throw new Error(`Could not parse upstream branch: ${fullUpstream}`);
			}

			const upstream = { remote: match[1], name: match[2] };
			const res3 = await GitProcess.exec(['rev-list', '--left-right', name + '...' + fullUpstream], this.path);

			let ahead = 0, behind = 0;
			let i = 0;

			while (i < res3.stdout.length) {
				switch (res3.stdout.charAt(i)) {
					case '<': ahead++; break;

const runGit = async (dir, args) => {
  const response = await GitProcess.exec(args, dir)
  if (response.exitCode !== 0) {
    throw new Error(response.stderr.trim())
  }
  return response.stdout.trim()
}

export default async ({ repoPromise }: GitConfig): Promise => {
  await repoPromise;
  await GitProcess.exec(['fetch'], DIR_REPO());
  await GitProcess.exec(['merge', 'origin/master', 'master'], DIR_REPO());
  await ensureFile(FILE_RESTORE());
  await copyFile(FILE_BACKUP(), FILE_RESTORE());
};