gib-runs 2.0.0

package/gib-run.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+var path = require('path');
+var fs = require('fs');
+var assign = require('object-assign');
+var chalk = require('chalk');
+var gibRuns = require("./index");
+
+var opts = {
+	host: process.env.IP,
+	port: process.env.PORT,
+	open: true,
+	mount: [],
+	proxy: [],
+	middleware: [],
+	logLevel: 2,
+};
+
+var homeDir = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'];
+var configPath = path.join(homeDir, '.gib-runs.json');
+if (fs.existsSync(configPath)) {
+	var userConfig = fs.readFileSync(configPath, 'utf8');
+	assign(opts, JSON.parse(userConfig));
+	if (opts.ignorePattern) opts.ignorePattern = new RegExp(opts.ignorePattern);
+}
+
+for (var i = process.argv.length - 1; i >= 2; --i) {
+	var arg = process.argv[i];
+	if (arg.indexOf("--port=") > -1) {
+		var portString = arg.substring(7);
+		var portNumber = parseInt(portString, 10);
+		if (portNumber === +portString) {
+			opts.port = portNumber;
+			process.argv.splice(i, 1);
+		}
+	}
+	else if (arg.indexOf("--host=") > -1) {
+		opts.host = arg.substring(7);
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--open=") > -1) {
+		var open = arg.substring(7);
+		if (open.indexOf('/') !== 0) {
+			open = '/' + open;
+		}
+		switch (typeof opts.open) {
+			case "boolean":
+				opts.open = open;
+				break;
+			case "string":
+				opts.open = [opts.open, open];
+				break;
+			case "object":
+				opts.open.push(open);
+				break;
+		}
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--watch=") > -1) {
+		// Will be modified later when cwd is known
+		opts.watch = arg.substring(8).split(",");
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--ignore=") > -1) {
+		// Will be modified later when cwd is known
+		opts.ignore = arg.substring(9).split(",");
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--ignorePattern=") > -1) {
+		opts.ignorePattern = new RegExp(arg.substring(16));
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--no-css-inject") {
+		opts.noCssInject = true;
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--no-browser") {
+		opts.open = false;
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--browser=") > -1) {
+		opts.browser = arg.substring(10).split(",");
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--entry-file=") > -1) {
+		var file = arg.substring(13);
+		if (file.length) {
+			opts.file = file;
+			process.argv.splice(i, 1);
+		}
+	}
+	else if (arg === "--spa") {
+		opts.middleware.push("spa");
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--quiet" || arg === "-q") {
+		opts.logLevel = 0;
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--verbose" || arg === "-V") {
+		opts.logLevel = 3;
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--mount=") > -1) {
+		// e.g. "--mount=/components:./node_modules" will be ['/components', '<process.cwd()>/node_modules']
+		// split only on the first ":", as the path may contain ":" as well (e.g. C:\file.txt)
+		var match = arg.substring(8).match(/([^:]+):(.+)$/);
+		match[2] = path.resolve(process.cwd(), match[2]);
+		opts.mount.push([ match[1], match[2] ]);
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--wait=") > -1) {
+		var waitString = arg.substring(7);
+		var waitNumber = parseInt(waitString, 10);
+		if (waitNumber === +waitString) {
+			opts.wait = waitNumber;
+			process.argv.splice(i, 1);
+		}
+	}
+	else if (arg === "--version" || arg === "-v") {
+		var packageJson = require('./package.json');
+		console.log(chalk.cyan.bold('\n  🚀 ' + packageJson.name) + chalk.gray(' v' + packageJson.version));
+		console.log(chalk.gray('  Modern development server with live reload\n'));
+		console.log(chalk.gray('  Author: ') + chalk.white(packageJson.author));
+		console.log(chalk.gray('  Repository: ') + chalk.blue(packageJson.repository.url.replace('.git', '')) + '\n');
+		process.exit();
+	}
+	else if (arg.indexOf("--htpasswd=") > -1) {
+		opts.htpasswd = arg.substring(11);
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--cors") {
+		opts.cors = true;
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--https=") > -1) {
+		opts.https = arg.substring(8);
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--https-module=") > -1) {
+		opts.httpsModule = arg.substring(15);
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--proxy=") > -1) {
+		// split only on the first ":", as the URL will contain ":" as well
+		var match = arg.substring(8).match(/([^:]+):(.+)$/);
+		opts.proxy.push([ match[1], match[2] ]);
+		process.argv.splice(i, 1);
+	}
+	else if (arg.indexOf("--middleware=") > -1) {
+		opts.middleware.push(arg.substring(13));
+		process.argv.splice(i, 1);
+	}
+	else if (arg === "--help" || arg === "-h") {
+		console.log(chalk.cyan.bold('\n  🚀 GIB-RUNS') + chalk.gray(' - Modern Development Server\n'));
+		console.log(chalk.white('  Usage: ') + chalk.yellow('gib-runs') + chalk.gray(' [options] [path]\n'));
+		console.log(chalk.white('  Options:\n'));
+		console.log(chalk.yellow('    -v, --version          ') + chalk.gray('Display version'));
+		console.log(chalk.yellow('    -h, --help             ') + chalk.gray('Show this help'));
+		console.log(chalk.yellow('    -q, --quiet            ') + chalk.gray('Suppress logging'));
+		console.log(chalk.yellow('    -V, --verbose          ') + chalk.gray('Verbose logging'));
+		console.log(chalk.yellow('    --port=PORT            ') + chalk.gray('Set port (default: 8080)'));
+		console.log(chalk.yellow('    --host=HOST            ') + chalk.gray('Set host (default: 0.0.0.0)'));
+		console.log(chalk.yellow('    --open=PATH            ') + chalk.gray('Open browser to path'));
+		console.log(chalk.yellow('    --no-browser           ') + chalk.gray('Suppress browser launch'));
+		console.log(chalk.yellow('    --browser=BROWSER      ') + chalk.gray('Specify browser'));
+		console.log(chalk.yellow('    --ignore=PATH          ') + chalk.gray('Ignore paths (comma-separated)'));
+		console.log(chalk.yellow('    --watch=PATH           ') + chalk.gray('Watch specific paths'));
+		console.log(chalk.yellow('    --no-css-inject        ') + chalk.gray('Reload on CSS change'));
+		console.log(chalk.yellow('    --entry-file=PATH      ') + chalk.gray('Entry file for SPA'));
+		console.log(chalk.yellow('    --spa                  ') + chalk.gray('Single Page App mode'));
+		console.log(chalk.yellow('    --mount=ROUTE:PATH     ') + chalk.gray('Mount directory to route'));
+		console.log(chalk.yellow('    --wait=MS              ') + chalk.gray('Debounce reload (default: 100ms)'));
+		console.log(chalk.yellow('    --htpasswd=PATH        ') + chalk.gray('Enable HTTP auth'));
+		console.log(chalk.yellow('    --cors                 ') + chalk.gray('Enable CORS'));
+		console.log(chalk.yellow('    --https=PATH           ') + chalk.gray('HTTPS config module'));
+		console.log(chalk.yellow('    --https-module=MODULE  ') + chalk.gray('Custom HTTPS module'));
+		console.log(chalk.yellow('    --proxy=ROUTE:URL      ') + chalk.gray('Proxy requests'));
+		console.log(chalk.yellow('    --middleware=PATH      ') + chalk.gray('Add middleware\n'));
+		console.log(chalk.gray('  Examples:\n'));
+		console.log(chalk.gray('    gib-runs'));
+		console.log(chalk.gray('    gib-runs --port=3000 --open=/index.html'));
+		console.log(chalk.gray('    gib-runs dist --spa --no-browser\n'));
+		process.exit();
+	}
+	else if (arg === "--test") {
+		// Hidden param for tests to exit automatically
+		setTimeout(gibRuns.shutdown, 500);
+		process.argv.splice(i, 1);
+	}
+}
+
+// Patch paths
+var dir = opts.root = process.argv[2] || "";
+
+if (opts.watch) {
+	opts.watch = opts.watch.map(function(relativePath) {
+		return path.join(dir, relativePath);
+	});
+}
+if (opts.ignore) {
+	opts.ignore = opts.ignore.map(function(relativePath) {
+		return path.join(dir, relativePath);
+	});
+}
+
+gibRuns.start(opts);

package/index.js

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+var fs = require('fs'),
+	connect = require('connect'),
+	serveIndex = require('serve-index'),
+	logger = require('morgan'),
+	WebSocket = require('faye-websocket'),
+	path = require('path'),
+	http = require('http'),
+	send = require('send'),
+	open = require('open'),
+	es = require("event-stream"),
+	compression = require('compression'),
+	os = require('os'),
+	chokidar = require('chokidar'),
+	chalk = require('chalk');
+
+var INJECTED_CODE = fs.readFileSync(path.join(__dirname, "injected.html"), "utf8");
+
+var GibRuns = {
+	server: null,
+	watcher: null,
+	logLevel: 2,
+	startTime: null,
+	requestCount: 0,
+	reloadCount: 0
+};
+
+function escape(html){
+	return String(html)
+		.replace(/&(?!\w+;)/g, '&')
+		.replace(/</g, '&lt;')
+		.replace(/>/g, '&gt;')
+		.replace(/"/g, '&quot;');
+}
+
+// Based on connect.static(), but streamlined and with added code injecter
+function staticServer(root) {
+	var isFile = false;
+	try { // For supporting mounting files instead of just directories
+		isFile = fs.statSync(root).isFile();
+	} catch (e) {
+		if (e.code !== "ENOENT") throw e;
+	}
+	return function(req, res, next) {
+		if (req.method !== "GET" && req.method !== "HEAD") return next();
+		var reqpath = isFile ? "" : new URL(req.url, 'http://localhost').pathname;
+		var hasNoOrigin = !req.headers.origin;
+		var injectCandidates = [ new RegExp("</body>", "i"), new RegExp("</svg>"), new RegExp("</head>", "i")];
+		var injectTag = null;
+
+		function directory() {
+			var pathname = new URL(req.originalUrl, 'http://localhost').pathname;
+			res.statusCode = 301;
+			res.setHeader('Location', pathname + '/');
+			res.end('Redirecting to ' + escape(pathname) + '/');
+		}
+
+		function file(filepath /*, stat*/) {
+			var x = path.extname(filepath).toLocaleLowerCase(), match,
+					possibleExtensions = [ "", ".html", ".htm", ".xhtml", ".php", ".svg" ];
+			if (hasNoOrigin && (possibleExtensions.indexOf(x) > -1)) {
+				// TODO: Sync file read here is not nice, but we need to determine if the html should be injected or not
+				var contents = fs.readFileSync(filepath, "utf8");
+				for (var i = 0; i < injectCandidates.length; ++i) {
+					match = injectCandidates[i].exec(contents);
+					if (match) {
+						injectTag = match[0];
+						break;
+					}
+				}
+				if (injectTag === null && GibRuns.logLevel >= 3) {
+					console.warn(chalk.yellow("⚠ Failed to inject refresh script!"),
+						"Couldn't find any of the tags", injectCandidates, "from", filepath);
+				}
+			}
+		}
+
+		function error(err) {
+			if (err.status === 404) return next();
+			next(err);
+		}
+
+		function inject(stream) {
+			if (injectTag) {
+				// We need to modify the length given to browser
+				var len = INJECTED_CODE.length + res.getHeader('Content-Length');
+				res.setHeader('Content-Length', len);
+				var originalPipe = stream.pipe;
+				stream.pipe = function(resp) {
+					originalPipe.call(stream, es.replace(new RegExp(injectTag, "i"), INJECTED_CODE + injectTag)).pipe(resp);
+				};
+			}
+		}
+
+		send(req, reqpath, { root: root })
+			.on('error', error)
+			.on('directory', directory)
+			.on('file', file)
+			.on('stream', inject)
+			.pipe(res);
+	};
+}
+
+/**
+ * Rewrite request URL and pass it back to the static handler.
+ * @param staticHandler {function} Next handler
+ * @param file {string} Path to the entry point file
+ */
+function entryPoint(staticHandler, file) {
+	if (!file) return function(req, res, next) { next(); };
+
+	return function(req, res, next) {
+		req.url = "/" + file;
+		staticHandler(req, res, next);
+	};
+}
+
+/**
+ * Start gib-run server with advanced features
+ * @param host {string} Address to bind to (default: 0.0.0.0)
+ * @param port {number} Port number (default: 8080)
+ * @param root {string} Path to root directory (default: cwd)
+ * @param watch {array} Paths to exclusively watch for changes
+ * @param ignore {array} Paths to ignore when watching files for changes
+ * @param ignorePattern {regexp} Ignore files by RegExp
+ * @param noCssInject Don't inject CSS changes, just reload as with any other file change
+ * @param open {(string|string[])} Subpath(s) to open in browser, use false to suppress launch (default: server root)
+ * @param mount {array} Mount directories onto a route, e.g. [['/components', './node_modules']].
+ * @param logLevel {number} 0 = errors only, 1 = some, 2 = lots, 3 = verbose
+ * @param file {string} Path to the entry point file
+ * @param wait {number} Server will wait for all changes, before reloading
+ * @param htpasswd {string} Path to htpasswd file to enable HTTP Basic authentication
+ * @param middleware {array} Append middleware to stack
+ * @param compression {boolean} Enable gzip compression (default: true)
+ */
+GibRuns.start = function(options) {
+	options = options || {};
+	GibRuns.startTime = Date.now();
+	var host = options.host || '0.0.0.0';
+	var port = options.port !== undefined ? options.port : 8080; // 0 means random
+	var root = options.root || process.cwd();
+	var mount = options.mount || [];
+	var watchPaths = options.watch || [root];
+	GibRuns.logLevel = options.logLevel === undefined ? 2 : options.logLevel;
+	var openPath = (options.open === undefined || options.open === true) ?
+		"" : ((options.open === null || options.open === false) ? null : options.open);
+	if (options.noBrowser) openPath = null; // Backwards compatibility with 0.7.0
+	var file = options.file;
+	var staticServerHandler = staticServer(root);
+	var wait = options.wait === undefined ? 100 : options.wait;
+	var browser = options.browser || null;
+	var htpasswd = options.htpasswd || null;
+	var cors = options.cors || false;
+	var https = options.https || null;
+	var proxy = options.proxy || [];
+	var middleware = options.middleware || [];
+	var noCssInject = options.noCssInject;
+	var httpsModule = options.httpsModule;
+	var enableCompression = options.compression !== false;
+
+	if (httpsModule) {
+		try {
+			require.resolve(httpsModule);
+		} catch (e) {
+			console.error(chalk.red("HTTPS module \"" + httpsModule + "\" you've provided was not found."));
+			console.error("Did you do", "\"npm install " + httpsModule + "\"?");
+			return;
+		}
+	} else {
+		httpsModule = "https";
+	}
+
+	// Setup a web server
+	var app = connect();
+
+	// Enable compression for better performance
+	if (enableCompression) {
+		app.use(compression());
+	}
+
+	// Request counter middleware
+	app.use(function(req, res, next) {
+		GibRuns.requestCount++;
+		next();
+	});
+
+	// Add logger. Level 2 logs only errors
+	if (GibRuns.logLevel === 2) {
+		app.use(logger('dev', {
+			skip: function (req, res) { return res.statusCode < 400; }
+		}));
+	// Level 2 or above logs all requests
+	} else if (GibRuns.logLevel > 2) {
+		app.use(logger('dev'));
+	}
+	if (options.spa) {
+		middleware.push("spa");
+	}
+	// Add middleware
+	middleware.map(function(mw) {
+		if (typeof mw === "string") {
+			var ext = path.extname(mw).toLocaleLowerCase();
+			if (ext !== ".js") {
+				mw = require(path.join(__dirname, "middleware", mw + ".js"));
+			} else {
+				mw = require(mw);
+			}
+		}
+		app.use(mw);
+	});
+
+	// Use http-auth if configured
+	if (htpasswd !== null) {
+		var auth = require('http-auth');
+		var basic = auth.basic({
+			realm: "Please authorize",
+			file: htpasswd
+		});
+		// Create middleware wrapper for http-auth v4
+		app.use(function(req, res, next) {
+			var authHandler = basic.check(function() {
+				next();
+			});
+			authHandler(req, res);
+		});
+	}
+	if (cors) {
+		app.use(require("cors")({
+			origin: true, // reflecting request origin
+			credentials: true // allowing requests with credentials
+		}));
+	}
+	mount.forEach(function(mountRule) {
+		var mountPath = path.resolve(process.cwd(), mountRule[1]);
+		if (!options.watch) // Auto add mount paths to wathing but only if exclusive path option is not given
+			watchPaths.push(mountPath);
+		app.use(mountRule[0], staticServer(mountPath));
+		if (GibRuns.logLevel >= 1)
+			console.log('Mapping %s to "%s"', mountRule[0], mountPath);
+	});
+	proxy.forEach(function(proxyRule) {
+		var proxyUrl = new URL(proxyRule[1]);
+		var proxyOpts = {
+			protocol: proxyUrl.protocol,
+			host: proxyUrl.hostname,
+			port: proxyUrl.port,
+			pathname: proxyUrl.pathname,
+			via: true,
+			preserveHost: true
+		};
+		app.use(proxyRule[0], require('proxy-middleware')(proxyOpts));
+		if (GibRuns.logLevel >= 1)
+			console.log('Mapping %s to "%s"', proxyRule[0], proxyRule[1]);
+	});
+	app.use(staticServerHandler) // Custom static server
+		.use(entryPoint(staticServerHandler, file))
+		.use(serveIndex(root, { icons: true }));
+
+	var server, protocol;
+	if (https !== null) {
+		var httpsConfig = https;
+		if (typeof https === "string") {
+			httpsConfig = require(path.resolve(process.cwd(), https));
+		}
+		server = require(httpsModule).createServer(httpsConfig, app);
+		protocol = "https";
+	} else {
+		server = http.createServer(app);
+		protocol = "http";
+	}
+
+	// Handle server startup errors
+	server.addListener('error', function(e) {
+		if (e.code === 'EADDRINUSE') {
+			var serveURL = protocol + '://' + host + ':' + port;
+			console.log(chalk.yellow("⚠ " + serveURL + " is already in use. Trying another port..."));
+			setTimeout(function() {
+				server.listen(0, host);
+			}, 1000);
+		} else {
+			console.error(chalk.red("✖ Error: " + e.toString()));
+			GibRuns.shutdown();
+		}
+	});
+
+	// Handle successful server
+	server.addListener('listening', function(/*e*/) {
+		GibRuns.server = server;
+
+		var address = server.address();
+		var serveHost = address.address === "0.0.0.0" ? "127.0.0.1" : (host === "0.0.0.0" ? address.address : host);
+		var openHost = host === "0.0.0.0" ? "127.0.0.1" : host;
+
+		var serveURL = protocol + '://' + serveHost + ':' + address.port;
+		var openURL = protocol + '://' + openHost + ':' + address.port;
+
+		var serveURLs = [ serveURL ];
+		if (GibRuns.logLevel > 2 && address.address === "0.0.0.0") {
+			var ifaces = os.networkInterfaces();
+			serveURLs = Object.keys(ifaces)
+				.map(function(iface) {
+					return ifaces[iface];
+				})
+				// flatten address data, use only IPv4
+				.reduce(function(data, addresses) {
+					addresses.filter(function(addr) {
+						return addr.family === "IPv4";
+					}).forEach(function(addr) {
+						data.push(addr);
+					});
+					return data;
+				}, [])
+				.map(function(addr) {
+					return protocol + "://" + addr.address + ":" + address.port;
+				});
+		}
+
+		// Output with beautiful formatting
+		if (GibRuns.logLevel >= 1) {
+			console.log('\\n' + chalk.cyan.bold('━'.repeat(60)));
+			console.log(chalk.cyan.bold('  🚀 GIB-RUNS') + chalk.gray(' v2.0.0'));
+			console.log(chalk.cyan.bold('━'.repeat(60)));
+			console.log(chalk.white('  📁 Root:       ') + chalk.yellow(root));
+			console.log(chalk.white('  🌐 Local:      ') + chalk.green(serveURL));
+			
+			if (GibRuns.logLevel > 2 && serveURLs.length > 1) {
+				console.log(chalk.white('  🔗 Network:'));
+				serveURLs.forEach(function(urlItem) {
+					if (urlItem !== serveURL) {
+						console.log(chalk.white('     ') + chalk.green(urlItem));
+					}
+				});
+			}
+			
+			console.log(chalk.white('  🔄 Live Reload:') + chalk.green(' Enabled'));
+			if (enableCompression) {
+				console.log(chalk.white('  📦 Compression:') + chalk.green(' Enabled'));
+			}
+			if (cors) {
+				console.log(chalk.white('  🔓 CORS:       ') + chalk.green(' Enabled'));
+			}
+			if (https) {
+				console.log(chalk.white('  🔒 HTTPS:      ') + chalk.green(' Enabled'));
+			}
+			console.log(chalk.cyan.bold('━'.repeat(60)));
+			console.log(chalk.gray('  Press Ctrl+C to stop\\n'));
+		}
+
+		// Launch browser
+		if (openPath !== null)
+			if (typeof openPath === "object") {
+				openPath.forEach(function(p) {
+					open(openURL + p, {app: browser});
+				});
+			} else {
+				open(openURL + openPath, {app: browser});
+			}
+	});
+
+	// Setup server to listen at port
+	server.listen(port, host);
+
+	// WebSocket
+	var clients = [];
+	server.addListener('upgrade', function(request, socket, head) {
+		var ws = new WebSocket(request, socket, head);
+		ws.onopen = function() { ws.send('connected'); };
+
+		if (wait > 0) {
+			(function() {
+				var wssend = ws.send;
+				var waitTimeout;
+				ws.send = function() {
+					var args = arguments;
+					if (waitTimeout) clearTimeout(waitTimeout);
+					waitTimeout = setTimeout(function(){
+						wssend.apply(ws, args);
+					}, wait);
+				};
+			})();
+		}
+
+		ws.onclose = function() {
+			clients = clients.filter(function (x) {
+				return x !== ws;
+			});
+		};
+
+		clients.push(ws);
+	});
+
+	var ignored = [
+		function(testPath) { // Always ignore dotfiles (important e.g. because editor hidden temp files)
+			return testPath !== "." && /(^[.#]|(?:__|~)$)/.test(path.basename(testPath));
+		}
+	];
+	if (options.ignore) {
+		ignored = ignored.concat(options.ignore);
+	}
+	if (options.ignorePattern) {
+		ignored.push(options.ignorePattern);
+	}
+	// Setup file watcher
+	GibRuns.watcher = chokidar.watch(watchPaths, {
+		ignored: ignored,
+		ignoreInitial: true
+	});
+	function handleChange(changePath) {
+		GibRuns.reloadCount++;
+		var cssChange = path.extname(changePath) === ".css" && !noCssInject;
+		var relPath = path.relative(root, changePath);
+		var timestamp = new Date().toLocaleTimeString();
+		
+		if (GibRuns.logLevel >= 1) {
+			if (cssChange) {
+				console.log(chalk.magenta('  ⚡ [' + timestamp + '] CSS updated: ') + chalk.gray(relPath));
+			} else {
+				console.log(chalk.cyan('  🔄 [' + timestamp + '] File changed: ') + chalk.gray(relPath));
+			}
+		}
+		clients.forEach(function(ws) {
+			if (ws)
+				ws.send(cssChange ? 'refreshcss' : 'reload');
+		});
+	}
+	GibRuns.watcher
+		.on("change", handleChange)
+		.on("add", handleChange)
+		.on("unlink", handleChange)
+		.on("addDir", handleChange)
+		.on("unlinkDir", handleChange)
+		.on("ready", function () {
+			if (GibRuns.logLevel >= 1)
+				console.log(chalk.cyan("  ✓ Watching for file changes...\\n"));
+		})
+		.on("error", function (err) {
+			console.log(chalk.red("  ✖ Watcher Error: ") + err);
+		});
+
+	return server;
+};
+
+GibRuns.shutdown = function() {
+	if (GibRuns.logLevel >= 1 && GibRuns.startTime) {
+		var uptime = ((Date.now() - GibRuns.startTime) / 1000).toFixed(2);
+		console.log('\\n' + chalk.cyan.bold('━'.repeat(60)));
+		console.log(chalk.yellow('  👋 Shutting down GIB-RUNS...'));
+		console.log(chalk.gray('  📊 Statistics:'));
+		console.log(chalk.gray('     • Uptime: ') + chalk.white(uptime + 's'));
+		console.log(chalk.gray('     • Requests: ') + chalk.white(GibRuns.requestCount));
+		console.log(chalk.gray('     • Reloads: ') + chalk.white(GibRuns.reloadCount));
+		console.log(chalk.cyan.bold('━'.repeat(60)) + '\\n');
+	}
+	
+	var watcher = GibRuns.watcher;
+	if (watcher) {
+		watcher.close();
+	}
+	var server = GibRuns.server;
+	if (server)
+		server.close();
+};
+
+module.exports = GibRuns;