electron-ohos-hotreload 1.0.0

package/src/commands/watch.js

@@ -0,0 +1,302 @@
+"use strict";
+/**
+ * eohr watch — 启动热加载循环
+ *
+ * 默认手动模式: 文件监听只记录变更，不自动推送。
+ * 开发者改完代码后按配置的组合键推送+重载。
+ * 触发键在 .eohr.config.json 的 triggerKey 中配置，默认 "ctrl+shift+x"。
+ *
+ * --auto 模式: 文件保存即自动推送。
+ *
+ * 支持的 triggerKey 格式:
+ *   "ctrl+shift+x"    Ctrl+Shift+X (默认)
+ *   "ctrl+r"          Ctrl+R
+ *   "ctrl+s"          Ctrl+S (注意: 终端可能拦截)
+ *   "f5"              F5
+ *   "space"           空格键
+ *   "enter"           回车键
+ *
+ * 组合键用 + 连接，修饰键: ctrl, alt, shift
+ * 主键: a-z, 0-9, f1-f12, space, enter
+ */
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var Config = require("../core/Config");
+var HdcBridge = require("../core/HdcBridge");
+var Bundler = require("../core/Bundler");
+var FileWatcher = require("../core/FileWatcher");
+var StatusPoller = require("../core/StatusPoller");
+var Dashboard = require("../core/Dashboard");
+var utils = require("../utils");
+var c = utils.c;
+
+/**
+ * 解析 triggerKey 配置，返回 { match: fn, display: string }
+ *
+ * raw 模式下终端按键编码:
+ *   Ctrl+A~Z  → \x01 ~ \x1a
+ *   Ctrl+Shift+X → 终端不直接支持，多数终端会发 Ctrl+X (\x18)
+ *   所以 ctrl+shift+x 实际匹配 ctrl+x (\x18)，显示为 Ctrl+Shift+X
+ *   Alt+X → \x1b + x
+ *   F5 → \x1b[15~
+ *   Space → \x20
+ *   Enter → \r
+ */
+function parseTriggerKey(triggerKey) {
+  triggerKey = (triggerKey || "ctrl+shift+x").toLowerCase().trim();
+
+  var parts = triggerKey.split("+");
+  var hasCtrl = parts.indexOf("ctrl") >= 0;
+  var hasAlt = parts.indexOf("alt") >= 0;
+  var hasShift = parts.indexOf("shift") >= 0;
+  var mainKey = parts[parts.length - 1]; // 最后一段是主键
+
+  // 构建显示名称
+  var displayParts = [];
+  if (hasCtrl) displayParts.push("Ctrl");
+  if (hasAlt) displayParts.push("Alt");
+  if (hasShift) displayParts.push("Shift");
+
+  var keyDisplayMap = {
+    "space": "Space", "enter": "Enter", "tab": "Tab", "esc": "Esc",
+    "f1": "F1", "f2": "F2", "f3": "F3", "f4": "F4", "f5": "F5",
+    "f6": "F6", "f7": "F7", "f8": "F8", "f9": "F9", "f10": "F10",
+    "f11": "F11", "f12": "F12",
+  };
+  displayParts.push(keyDisplayMap[mainKey] || mainKey.toUpperCase());
+  var display = displayParts.join("+");
+
+  // 构建匹配函数
+  var matcher;
+
+  if (hasCtrl) {
+    // Ctrl+字母: raw 模式下 \x01 (Ctrl+A) ~ \x1a (Ctrl+Z)
+    if (mainKey.length === 1 && mainKey >= "a" && mainKey <= "z") {
+      var ctrlCode = mainKey.charCodeAt(0) - 96; // a=1, b=2, ... z=26
+      var ctrlChar = String.fromCharCode(ctrlCode);
+
+      if (hasAlt) {
+        // Ctrl+Alt+X: \x1b + ctrlChar
+        matcher = function (data) { return data === "\x1b" + ctrlChar; };
+      } else {
+        // Ctrl+X or Ctrl+Shift+X (终端不区分 shift，都发 ctrl+x)
+        matcher = function (data) { return data === ctrlChar; };
+      }
+    } else {
+      // Ctrl + 非字母键，终端一般不支持
+      matcher = function () { return false; };
+    }
+  } else if (hasAlt) {
+    // Alt+X: \x1b + x
+    if (mainKey.length === 1) {
+      matcher = function (data) { return data === "\x1b" + mainKey; };
+    } else {
+      matcher = function () { return false; };
+    }
+  } else if (mainKey === "space") {
+    matcher = function (data) { return data === " " || data === "\x20"; };
+  } else if (mainKey === "enter") {
+    matcher = function (data) { return data === "\r" || data === "\n"; };
+  } else if (mainKey === "tab") {
+    matcher = function (data) { return data === "\t"; };
+  } else if (mainKey === "esc") {
+    matcher = function (data) { return data === "\x1b" && data.length === 1; };
+  } else if (mainKey.match(/^f\d{1,2}$/)) {
+    // F1~F12 转义序列
+    var fSeqs = {
+      "f1": ["\x1bOP", "\x1b[11~"],
+      "f2": ["\x1bOQ", "\x1b[12~"],
+      "f3": ["\x1bOR", "\x1b[13~"],
+      "f4": ["\x1bOS", "\x1b[14~"],
+      "f5": ["\x1b[15~", "\x1b[[E"],
+      "f6": ["\x1b[17~"],
+      "f7": ["\x1b[18~"],
+      "f8": ["\x1b[19~"],
+      "f9": ["\x1b[20~"],
+      "f10": ["\x1b[21~"],
+      "f11": ["\x1b[23~"],
+      "f12": ["\x1b[24~"],
+    };
+    var seqs = fSeqs[mainKey] || [];
+    matcher = function (data) {
+      for (var i = 0; i < seqs.length; i++) {
+        if (data.indexOf(seqs[i]) >= 0) return true;
+      }
+      return false;
+    };
+  } else if (mainKey.length === 1) {
+    // 单字符
+    matcher = function (data) { return data.trim().toLowerCase() === mainKey; };
+  } else {
+    matcher = function () { return false; };
+  }
+
+  return { match: matcher, display: display };
+}
+
+function run(opts) {
+  opts = opts || {};
+  var config = Config.load(opts);
+  var autoMode = !!opts.auto;
+  var dash = new Dashboard();
+  var hdc = new HdcBridge(config.bundleName);
+  var bundler = new Bundler(config);
+  var watcher = new FileWatcher(config);
+  var poller = new StatusPoller(hdc, config);
+
+  // 解析触发键
+  var triggerKey = opts.triggerKey || config.triggerKey || "ctrl+shift+x";
+  var parsed = parseTriggerKey(triggerKey);
+
+  var pendingChanges = [];
+
+  dash.banner(config);
+  dash.info("hdc: " + hdc.hdcPath);
+  dash.info(autoMode ? "模式: auto (保存即推送)" : "模式: manual (按 " + parsed.display + " 推送)");
+
+  // 1. 检查设备
+  hdc.isDeviceConnected().then(function (connected) {
+    if (!connected) {
+      dash.error("设备未连接，请检查 hdc list targets");
+      process.exit(1);
+    }
+
+    return hdc.mkdir(config.physicalOverrideDir);
+  }).then(function () {
+    var cfgJson = JSON.stringify({
+      strategy: config.strategy,
+      softTimeout: config.softTimeout,
+    });
+    var cfgTmp = path.join(os.tmpdir(), "eohr-hot-config.json");
+    fs.writeFileSync(cfgTmp, cfgJson);
+    return hdc.pushOverride(cfgTmp, "hot-config.json", config);
+  }).then(function () {
+    dash.info("首次推送...");
+    return doReloadCycle();
+  }).then(function () {
+    // 文件监听
+    watcher.onChange(function (file) {
+      if (autoMode) {
+        dash.fileChanged(file);
+        doReloadCycle().catch(function (err) {
+          dash.error("reload 失败: " + err.message);
+        });
+      } else {
+        pendingChanges.push(path.basename(file));
+        dash.filePending(file, parsed.display);
+      }
+    });
+    watcher.start();
+
+    // 状态轮询
+    poller.on("status", function (status) {
+      dash.statusUpdate(status);
+    });
+    poller.start();
+
+    if (autoMode) {
+      dash.watchingAuto();
+    } else {
+      dash.watchingManual(parsed.display);
+      startKeyboardInput();
+    }
+  }).catch(function (err) {
+    dash.error(err.message);
+    process.exit(1);
+  });
+
+  // 键盘交互: raw 模式捕获按键
+  function startKeyboardInput() {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+
+    process.stdin.on("data", function (data) {
+      // Ctrl+C
+      if (data === "\x03") {
+        console.log();
+        dash.info("停止热加载");
+        watcher.stop();
+        poller.stop();
+        process.exit(0);
+      }
+
+      // 触发键
+      if (parsed.match(data)) {
+        if (pendingChanges.length > 0) {
+          dash.info("推送 " + pendingChanges.length + " 个文件变更: " + pendingChanges.join(", "));
+          pendingChanges = [];
+        }
+        doReloadCycle().catch(function (err) {
+          dash.error("reload 失败: " + err.message);
+        });
+        return;
+      }
+
+      // 'q' 退出 (不区分大小写)
+      if (data === "q" || data === "Q") {
+        dash.info("停止");
+        watcher.stop();
+        poller.stop();
+        process.exit(0);
+        return;
+      }
+    });
+  }
+
+  // Ctrl+C 兜底
+  process.on("SIGINT", function () {
+    console.log();
+    dash.info("停止热加载");
+    watcher.stop();
+    poller.stop();
+    process.exit(0);
+  });
+
+  /** 打包 → 推送 → 重载 */
+  function doReloadCycle() {
+    var startTime = Date.now();
+
+    dash.bundling();
+    return bundler.bundle().then(function (result) {
+      if (!result.changed) {
+        console.log(c.dim + "(代码未变化)" + c.reset);
+        return;
+      }
+
+      dash.bundled(Date.now() - startTime);
+      bundler.lastHash = result.hash;
+
+      var tmpFile = path.join(os.tmpdir(), "eohr-entry.js");
+      fs.writeFileSync(tmpFile, result.code);
+
+      dash.sending();
+      return hdc.pushOverride(tmpFile, "entry.js", config).then(function () {
+        dash.sent();
+
+        if (config.strategy === "hard") {
+          // hard: 主机侧停应用 → 等 1 秒 → 重启应用
+          dash.info("重启应用...");
+          return hdc.forceStop().then(function () {
+            return new Promise(function (resolve) { setTimeout(resolve, 1000); });
+          }).then(function () {
+            return hdc.startAbility();
+          }).then(function () {
+            dash.reloadTriggered("hard (restart)");
+            poller.reset();
+          });
+        } else {
+          // soft / hard-first: touch 触发，agent 自己处理
+          var trigger = config.physicalOverrideDir + "/.reload-trigger";
+          return hdc.touch(trigger).then(function () {
+            dash.reloadTriggered(config.strategy);
+            poller.reset();
+          });
+        }
+      });
+    });
+  }
+}
+
+module.exports = run;

package/src/core/Bundler.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Bundler.js — esbuild 打包器
+ *
+ * 将开发者的入口文件 (TS/JS) + 依赖打包成单文件 entry.js
+ * 设备侧 agent 只需 require(entry.js) 即可运行开发者代码
+ *
+ * 设计:
+ *   - electron 标记为 external，运行时由 Electron 提供
+ *   - Node.js 内置模块 (fs, path, ...) 自动 external
+ *   - 项目 node_modules 中已有的依赖打进 bundle
+ *   - 项目 node_modules 中没有的依赖也标记 external（设备端运行时 require）
+ *   - sourcemap 内联，便于调试
+ */
+var fs = require("fs");
+var path = require("path");
+var utils = require("../utils");
+var stripBOM = utils.stripBOM;
+var simpleHash = utils.simpleHash;
+
+function Bundler(config) {
+  this.config = config;
+  this.lastHash = null;
+}
+
+/** 主打包入口 */
+Bundler.prototype.bundle = function () {
+  var self = this;
+  var projectRoot = this.config.hapRoot;
+  var entryFile = this.config.entry;
+
+  // 解析入口文件绝对路径
+  var entryAbs = path.isAbsolute(entryFile) ? entryFile : path.join(projectRoot, entryFile);
+
+  if (!fs.existsSync(entryAbs)) {
+    return Promise.reject(new Error("入口文件不存在: " + entryAbs));
+  }
+
+  // esbuild 打包
+  return self.esbuildBundle(entryAbs, projectRoot).then(function (output) {
+    var code = stripBOM(output);
+    var hash = simpleHash(code);
+    return {
+      code: code,
+      hash: hash,
+      changed: hash !== self.lastHash,
+    };
+  });
+};
+
+/** esbuild 打包 */
+Bundler.prototype.esbuildBundle = function (entryAbs, resolveDir) {
+  var esbuild = require("esbuild");
+
+  // Node.js 内置模块始终 external
+  var builtins = [
+    "fs", "path", "os", "crypto", "http", "https", "net", "child_process",
+    "stream", "url", "util", "events", "buffer", "querystring", "zlib",
+    "assert", "timers", "cluster", "dgram", "dns", "module", "readline",
+    "repl", "tls", "vm", "worker_threads", "perf_hooks", "process",
+  ];
+
+  // electron 始终 external
+  var external = ["electron"].concat(builtins);
+
+  return esbuild.build({
+    entryPoints: [entryAbs],
+    bundle: true,
+    platform: "node",
+    format: "cjs",
+    target: "node18",
+    external: external,
+    sourcemap: "inline",
+    write: false,
+    logLevel: "warning",
+    minify: false,
+    absWorkingDir: resolveDir,
+  }).then(function (result) {
+    if (!result.outputFiles || result.outputFiles.length === 0) {
+      throw new Error("esbuild produced no output");
+    }
+    return result.outputFiles[0].text;
+  });
+};
+
+module.exports = Bundler;

package/src/core/Config.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Config.js — 配置管理
+ *
+ * 自动从工程文件探测:
+ *   - AppScope/app.json5  → bundleName
+ *   - build-profile.json5 → hapRoot
+ *   - web_engine/.../resfile/resources/app/ → appDir
+ *
+ * 合并优先级: CLI 参数 > .eohr.config.json > 自动探测 > 默认值
+ */
+var fs = require("fs");
+var path = require("path");
+var utils = require("../utils");
+var readJson5 = utils.readJson5;
+
+var CONFIG_FILE = ".eohr.config.json";
+
+var DEFAULTS = {
+  entry: "src/main.ts",
+  strategy: "hard",
+  triggerKey: "ctrl+shift+x",
+  watch: null,
+  ignore: ["node_modules/**", "dist/**", ".git/**"],
+  overrideDir: "/data/storage/el2/base/files/hot",
+  resultDir: "/data/storage/el2/base/files",
+  userId: 100,
+  softTimeout: 5000,
+  pollInterval: 2000,
+  statusPollInterval: 1000,
+};
+
+/** 向上查找 build-profile.json5 所在目录 */
+function findHapRoot(startDir) {
+  var dir = startDir || process.cwd();
+  for (var i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(dir, "build-profile.json5"))) return dir;
+    var parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir || process.cwd();
+}
+
+/** 从 AppScope/app.json5 读 bundleName */
+function detectBundleName(hapRoot) {
+  var appJson5 = path.join(hapRoot, "AppScope", "app.json5");
+  try {
+    var app = readJson5(appJson5);
+    return app.app && app.app.bundleName;
+  } catch (e) { return null; }
+}
+
+/** 探测 app 目录 (resfile/resources/app/) */
+function detectAppDir(hapRoot) {
+  var candidates = [
+    path.join(hapRoot, "web_engine", "src", "main", "resources", "resfile", "resources", "app"),
+    path.join(hapRoot, "electron", "src", "main", "resources", "resfile", "resources", "app"),
+  ];
+  for (var i = 0; i < candidates.length; i++) {
+    if (fs.existsSync(candidates[i])) return candidates[i];
+  }
+  return null;
+}
+
+/** 探测开发者入口文件 */
+function detectEntry(hapRoot, appDir) {
+  // 1) app 目录下的 main.ts/main.js
+  if (appDir) {
+    var candidates = ["main.ts", "main.js", "index.ts", "index.js"];
+    for (var i = 0; i < candidates.length; i++) {
+      var p = path.join(appDir, candidates[i]);
+      if (fs.existsSync(p)) return path.relative(hapRoot, p).replace(/\\/g, "/");
+    }
+  }
+  // 2) 工程根目录 src/main.ts
+  var srcCandidates = ["src/main.ts", "src/main.js", "src/index.ts", "src/index.js"];
+  for (var j = 0; j < srcCandidates.length; j++) {
+    var sp = path.join(hapRoot, srcCandidates[j]);
+    if (fs.existsSync(sp)) return srcCandidates[j];
+  }
+  return DEFAULTS.entry;
+}
+
+/** 构建物理路径 */
+function buildPhysicalPaths(config) {
+  var bn = config.bundleName;
+  var uid = config.userId;
+  config.physicalOverrideDir = "/data/app/el2/" + uid + "/base/" + bn + "/files/hot";
+  config.physicalResultDir = "/data/app/el2/" + uid + "/base/" + bn + "/files";
+  return config;
+}
+
+/**
+ * 加载配置
+ * @param {object} cliOpts - CLI 参数覆盖
+ * @returns {object} 合并后的配置
+ */
+function load(cliOpts) {
+  cliOpts = cliOpts || {};
+  var hapRoot = cliOpts.hapRoot || findHapRoot(cliOpts.cwd);
+  var bundleName = null;
+  var appDir = null;
+
+  // 先读 .eohr.config.json
+  var userConfig = {};
+  var configPath = path.join(hapRoot, CONFIG_FILE);
+  if (fs.existsSync(configPath)) {
+    try { userConfig = JSON.parse(fs.readFileSync(configPath, "utf8")); } catch (e) {}
+  }
+
+  // 自动探测
+  bundleName = cliOpts.bundleName || userConfig.bundleName || detectBundleName(hapRoot);
+  appDir = cliOpts.appDir || userConfig.appDir || detectAppDir(hapRoot);
+
+  // 入口文件探测
+  var entry;
+  if (cliOpts.entry) {
+    entry = cliOpts.entry;
+  } else if (userConfig.entry) {
+    entry = userConfig.entry;
+  } else {
+    entry = detectEntry(hapRoot, appDir);
+  }
+
+  // 合并
+  var config = Object.assign({}, DEFAULTS, userConfig, {
+    hapRoot: hapRoot,
+    bundleName: bundleName,
+    appDir: appDir,
+    entry: entry,
+  }, cliOpts);
+
+  // 相对路径转绝对
+  if (config.appDir && !path.isAbsolute(config.appDir)) {
+    config.appDir = path.join(hapRoot, config.appDir);
+  }
+
+  // 自动生成 watch 列表：app 目录 + hapRoot/src
+  if (!config.watch) {
+    config.watch = [];
+    if (config.appDir) {
+      var appRel = path.relative(hapRoot, config.appDir).replace(/\\/g, "/");
+      if (appRel) {
+        config.watch.push(appRel + "/**/*.ts");
+        config.watch.push(appRel + "/**/*.js");
+      }
+    }
+    config.watch.push("src/**/*.ts");
+    config.watch.push("src/**/*.js");
+  }
+
+  // 物理路径
+  buildPhysicalPaths(config);
+
+  return config;
+}
+
+/** 保存配置到 .eohr.config.json */
+function save(config) {
+  var configPath = path.join(config.hapRoot, CONFIG_FILE);
+  var out = {
+    bundleName: config.bundleName,
+    hapRoot: config.hapRoot,
+    appDir: config.appDir,
+    entry: config.entry,
+    strategy: config.strategy,
+    triggerKey: config.triggerKey,
+    watch: config.watch,
+    ignore: config.ignore,
+    overrideDir: config.overrideDir,
+    physicalOverrideDir: config.physicalOverrideDir,
+    resultDir: config.resultDir,
+    physicalResultDir: config.physicalResultDir,
+    userId: config.userId,
+    softTimeout: config.softTimeout,
+    pollInterval: config.pollInterval,
+  };
+  fs.writeFileSync(configPath, JSON.stringify(out, null, 2));
+  return configPath;
+}
+
+module.exports = {
+  load: load,
+  save: save,
+  findHapRoot: findHapRoot,
+  detectBundleName: detectBundleName,
+  detectAppDir: detectAppDir,
+  detectEntry: detectEntry,
+  CONFIG_FILE: CONFIG_FILE,
+  DEFAULTS: DEFAULTS,
+};

package/src/core/Dashboard.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Dashboard.js — 终端实时输出面板
+ *
+ * 显示: 工程信息、文件变更、打包进度、推送进度、重载状态
+ */
+var path = require("path");
+var utils = require("../utils");
+var c = utils.c;
+var fmtMs = utils.fmtMs;
+
+function Dashboard() {
+  this.reloadCount = 0;
+  this.errorCount = 0;
+}
+
+Dashboard.prototype.banner = function (config) {
+  console.log();
+  console.log(c.bold + c.cyan + "  Electron OHOS Hot-Reload" + c.reset + c.dim + "  v1.0.0" + c.reset);
+  console.log(c.dim + "  ──────────────────────────────────────" + c.reset);
+  console.log("  Bundle:   " + (config.bundleName || "(unknown)"));
+  console.log("  Entry:    " + (config.entry || "(none)"));
+  console.log("  Strategy: " + (config.strategy || "hard"));
+  console.log("  HAP:      " + config.hapRoot);
+  console.log();
+};
+
+Dashboard.prototype.watchingAuto = function () {
+  console.log(c.cyan + "  [watching]" + c.reset + " auto 模式, 保存即推送");
+  console.log(c.dim + "  Press Ctrl+C to stop" + c.reset);
+  console.log();
+};
+
+Dashboard.prototype.watchingManual = function (keyName) {
+  console.log(c.cyan + "  [ready]" + c.reset + " manual 模式");
+  console.log(c.dim + "  ──────────────────────────────────────" + c.reset);
+  console.log("  " + c.bold + keyName + c.reset + "         推送并重载");
+  console.log("  " + c.bold + "s" + c.reset + "          查看设备状态");
+  console.log("  " + c.bold + "q" + c.reset + " / Ctrl+C  退出");
+  console.log();
+};
+
+Dashboard.prototype.filePending = function (file, keyName) {
+  var name = path.relative(process.cwd(), file);
+  console.log(c.gray + "  [pending] " + c.reset + name + c.dim + " (按 " + (keyName || "触发键") + " 推送)" + c.reset);
+};
+
+Dashboard.prototype.fileChanged = function (file) {
+  console.log(c.gray + "  [file] " + c.reset + path.relative(process.cwd(), file));
+};
+
+Dashboard.prototype.bundling = function () {
+  process.stdout.write(c.blue + "  [bundle]" + c.reset + " esbuild... ");
+};
+
+Dashboard.prototype.bundled = function (ms) {
+  console.log(c.dim + "(" + fmtMs(ms) + ")" + c.reset);
+};
+
+Dashboard.prototype.sending = function () {
+  process.stdout.write(c.blue + "  [send]" + c.reset + " hdc file send... ");
+};
+
+Dashboard.prototype.sent = function () {
+  console.log(c.green + "ok" + c.reset);
+};
+
+Dashboard.prototype.reloadTriggered = function (strategy) {
+  this.reloadCount++;
+  console.log(c.yellow + "  [reload]" + c.reset + " " + strategy + " triggered, waiting for status...");
+};
+
+Dashboard.prototype.statusUpdate = function (status) {
+  var icon = c.gray + "○" + c.reset;
+  var color = c.gray;
+
+  switch (status.status) {
+    case "agent-ready":
+      icon = c.cyan + "●" + c.reset;
+      color = c.cyan;
+      break;
+    case "soft-reloading":
+    case "hard-reloading":
+      icon = c.yellow + "●" + c.reset;
+      color = c.yellow;
+      break;
+    case "soft-ok":
+    case "loaded":
+      icon = c.green + "●" + c.reset;
+      color = c.green;
+      break;
+    case "soft-fail":
+    case "init-fail":
+      icon = c.red + "●" + c.reset;
+      color = c.red;
+      this.errorCount++;
+      break;
+    case "waiting":
+      icon = c.gray + "○" + c.reset;
+      break;
+    case "hard-reloading":
+      icon = c.yellow + "●" + c.reset;
+      color = c.yellow;
+      break;
+  }
+
+  var msg = "  " + icon + " " + color + status.status + c.reset;
+  if (status.error) {
+    msg += c.red + "  " + status.error + c.reset;
+  }
+  console.log(msg);
+};
+
+Dashboard.prototype.error = function (msg) {
+  this.errorCount++;
+  console.error(c.red + "  [error]" + c.reset + " " + msg);
+};
+
+Dashboard.prototype.info = function (msg) {
+  console.log(c.cyan + "  [info]" + c.reset + " " + msg);
+};
+
+Dashboard.prototype.stats_ = function () {
+  return "Reloads: " + this.reloadCount + " | Errors: " + this.errorCount;
+};
+
+module.exports = Dashboard;