Add the code

Author: oledid

.editorconfig

@@ -0,0 +1,34 @@
+root = true
+
+[*]
+indent_style = tab
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false
+indent_size = 4
+
+[*.{config,yml,json}]
+indent_style = space
+indent_size = 2
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{js,jsx,ts,tsx,cs,html,cshtml,py,md,ahk}]
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.ahk]
+end_of_line = crlf
+
+[cli.js]
+end_of_line = lf
+
+# Ignore paths
+[**/jspm_packages/**,**/node_modules/**,*.d.ts]
+charset = none
+end_of_line = none
+insert_final_newline = none
+trim_trailing_whitespace = none
+indent_style = none
+indent_size = none

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+dist
+data
+.vscode/launch.json

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "typescript.tsdk": "./node_modules/typescript/lib"
+}

README.md

@@ -0,0 +1,50 @@
+{
+  "name": "sync-github-forks-cli",
+  "version": "0.1.0",
+  "description": "Keeps github forks up to date using node, the github api and git",
+  "main": "dist/application.js",
+  "bin": {
+    "sync-github-forks": "dist/cli.js"
+  },
+  "scripts": {
+    "postinstall": "tsc",
+    "start": "tsc && node dist/cli.js",
+    "test": "npm run lint",
+    "lint": "tslint -c ./tslint.json src/**"
+  },
+  "files": [
+    "dist",
+    "src",
+    "test"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/oledid/sync-github-forks-cli.git"
+  },
+  "keywords": [
+    "sync",
+    "github",
+    "forks",
+    "node",
+    "api",
+    "git",
+    "fork",
+    "typescript"
+  ],
+  "author": "Ole Morten Didriksen <code@oledid.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/oledid/sync-github-forks-cli/issues"
+  },
+  "homepage": "https://github.com/oledid/sync-github-forks-cli#readme",
+  "devDependencies": {
+    "@types/bluebird": "^3.0.37",
+    "@types/node": "^7.0.4",
+    "tslint": "^4.4.2",
+    "typescript": "^2.1.5"
+  },
+  "dependencies": {
+    "bluebird": "^3.4.7",
+    "execa": "^0.6.0"
+  }
+}

package.json

@@ -0,0 +1,163 @@
+import * as Promise from "bluebird";
+import { Options } from "./options";
+import { GitHubService, RepoResult, DetailedRepoResult } from "./gitHubService";
+import { GitService } from "./gitService";
+import { Logger } from "./logger";
+
+export class Application {
+	constructor(
+		public options: Options,
+		public logger: Logger,
+		public githubService: GitHubService = new GitHubService(options, logger),
+		public gitService: GitService = new GitService(options, logger),
+		public maxGitHubConcurrency: number = 3,
+		public maxGitConcurrency: number = Infinity
+	) { }
+
+	main() {
+		if (this.options.isValid() === false) {
+			throw new Error("Invalid options");
+		}
+
+		this.start();
+	}
+
+	start() {
+		this.getForkedRepositories()
+			.then(repos => this.getRepositoryDetails(repos))
+			.then(values => this.syncRepositories(values))
+			.then(() => {
+				this.logger.log("Finished", null);
+				this.logger.flush();
+			})
+			.catch(err => {
+				throw Error(err);
+			});
+	}
+
+	getForkedRepositories(page: number = 1, repositories: Array<RepoResult> = new Array<RepoResult>()) {
+		this.logger.log("Looking for forked repositories at page " + page, null);
+		return this.githubService.getRepos(this.options.username, page)
+			.then(repos => {
+				if (repos.length === 0) {
+					return new Promise(resolve => {
+						resolve(repositories);
+					});
+				}
+				for (const repo of repos) {
+					if (repo.fork === true) {
+						repositories.push(repo);
+					}
+				}
+				return this.getForkedRepositories(page + 1, repositories);
+			});
+	}
+
+	getRepositoryDetails(repos: Array<RepoResult>) {
+		this.logger.log("Found " + repos.length + " forks. Fetching details...", null);
+		const queue = new Array<any>();
+		const results = new Array<DetailedRepoResult>();
+		for (const repo of repos) {
+			queue.push(new Promise((innerResolve, innerReject) => {
+				this.logger.log("Fetching details for repository", repo.full_name);
+				this.githubService.getRepo(this.options.username, repo.name)
+					.then(repoResult => {
+						innerResolve(repoResult);
+					})
+					.catch(err => {
+						innerReject(err);
+					});
+			}));
+		}
+		return Promise.map(queue, (item: DetailedRepoResult) => {
+			return item;
+		}, { concurrency: this.maxGitHubConcurrency });
+	}
+
+	syncRepositories(repos: Array<DetailedRepoResult>) {
+		const queue = new Array<any>();
+		const self = this;
+		for (const value of repos) {
+			queue.push(new Promise((resolve, reject) => {
+				self.syncRepository(value)
+					.then(() => {
+						resolve();
+					})
+					.catch(err => {
+						reject(err);
+					});
+			}));
+		}
+		return Promise.map(queue, (item: DetailedRepoResult) => {
+			return item;
+		}, { concurrency: this.maxGitConcurrency });
+	}
+
+	syncRepository(repo: DetailedRepoResult) {
+		return new Promise((resolve, reject) => {
+			this.cloneRepository(repo.name, repo.full_name, repo.clone_url)
+				.then(() => {
+					return this.gitService.setUpstream(repo.name, repo.full_name, repo.parent.clone_url);
+				})
+				.then(() => {
+					return this.gitService.pullUpstream(repo.name, repo.full_name, repo.default_branch);
+				})
+				.then(() => {
+					return this.gitService.pushOrigin(repo.name, repo.full_name, repo.default_branch);
+				})
+				.then(() => {
+					return this.trySyncMasterBranch(repo.name, repo.full_name, repo.default_branch);
+				})
+				.then(() => {
+					return this.gitService.syncTags(repo.name, repo.full_name);
+				})
+				.then(() => {
+					resolve();
+				})
+				.catch(err => {
+					reject(err);
+				});
+		});
+	}
+
+	cloneRepository(name: string, fullname: string, cloneUrl: string) {
+		this.logger.log("Cloning repository " + cloneUrl, fullname);
+		return new Promise((resolve, reject) => {
+			this.gitService.clone(name, cloneUrl)
+				.then(out => {
+					resolve();
+				})
+				.catch(err => {
+					if (err.toString().match(/destination path (.*) already exists and is not an empty directory/).length > 0) {
+						this.logger.log("Repository folder already existed. Continuing.", fullname);
+						resolve();
+					}
+					else {
+						reject(err);
+					}
+				});
+		});
+	}
+
+	trySyncMasterBranch(name: string, fullname: string, branch: string) {
+		return new Promise((resolve, reject) => {
+			if (branch === "master") {
+				resolve();
+				return;
+			}
+			this.logger.log("Trying to sync master branch", fullname);
+			this.gitService.pullUpstream(name, fullname, "master")
+				.then(() => {
+					return this.gitService.pushOrigin(name, fullname, "master");
+				})
+				.then(() => {
+					this.logger.log("Master branch synced", fullname);
+					resolve();
+				})
+				.catch(err => {
+					this.logger.log("Failed syncing master branch for repository", fullname);
+					resolve();
+				});
+		});
+	}
+}

src/application.ts

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { Application } from "./application";
+import { CliOptions, Options } from "./options";
+import { Logger } from "./logger";
+
+const options: Options = new CliOptions();
+const logger = new Logger(options);
+
+if (options.isValid() === false) {
+	logger.log(`Usage: ${options.appName} [github-username] [path-to-work-directory] [github-api-key]`, null);
+	process.exit(1);
+}
+
+const application = new Application(options, logger);
+try {
+	application.main();
+}
+catch (err) {
+	logger.error(err);
+	logger.flush();
+	process.exit(1);
+}

src/cli.ts

@@ -0,0 +1,76 @@
+import * as https from "https";
+import { Options } from "./options";
+import { Logger } from "./logger";
+
+export class GitHubService {
+	constructor(
+		public options: Options,
+		public logger: Logger
+	) { }
+
+	getRepos(username: string, pageNumber: number) {
+		return new Promise<Array<RepoResult>>((resolve, reject) => {
+			const url = `/users/${username}/repos?page=${pageNumber}&per_page=30`;
+			this.call(url, "GET", {}, result => { resolve(JSON.parse(result)); }, reject);
+		});
+	}
+
+	getRepo(username: string, name: string) {
+		return new Promise<DetailedRepoResult>((resolve, reject) => {
+			const url = `/repos/${username}/${name}`;
+			this.call(url, "GET", {}, result => { resolve(JSON.parse(result)); }, reject);
+		});
+	}
+
+	private call(url, method, parameterData, resolve, reject) {
+		const options = {
+			host: "api.github.com",
+			port: 443,
+			method: method,
+			path: url,
+			headers: {
+				"User-Agent": `${this.options.appName}/${this.options.version} (+${this.options.homepage})`,
+				"Authorization": `token ${this.options.apiToken}`,
+				"Content-Type": "application/json",
+				"Accept": "application/vnd.github.v3+json"
+			}
+		};
+
+		let output = "";
+
+		const req = https.request(options, res => {
+			res.setEncoding("utf8");
+
+			res.on("data", data => {
+				output += data;
+			});
+
+			res.on("end", () => {
+				resolve(output);
+			});
+		});
+
+		req.on("error", err => {
+			reject(err);
+		});
+
+		req.end();
+	};
+}
+
+export class RepoResult {
+	/* tslint:disable:variable-name */
+	id: number;
+	name: string;
+	full_name: string;
+	fork: boolean;
+	clone_url: string;
+	/* tslint:enable:variable-name */
+}
+
+export class DetailedRepoResult extends RepoResult {
+	/* tslint:disable:variable-name */
+	parent: RepoResult;
+	default_branch: string;
+	/* tslint:enable:variable-name */
+}