electron-ohos-hotreload 1.0.0

package/src/core/FileWatcher.js

@@ -0,0 +1,201 @@
+"use strict";
+/**
+ * FileWatcher.js — 主机侧文件监听
+ *
+ * 使用 Node.js 内置 fs.watch (Windows 支持 recursive: true)
+ * 跨平台兼容: Windows 用 recursive, 其他平台用递归遍历
+ */
+var fs = require("fs");
+var path = require("path");
+var utils = require("../utils");
+
+function FileWatcher(config) {
+  this.config = config;
+  this.watchers = [];
+  this.callback = null;
+  this.debounceTimer = null;
+  this.debounceMs = 500;
+}
+
+/** 设置变更回调 */
+FileWatcher.prototype.onChange = function (cb) {
+  this.callback = cb;
+};
+
+/** 启动监听 */
+FileWatcher.prototype.start = function () {
+  var self = this;
+  var dirs = this.extractWatchDirs();
+
+  var isWin = process.platform === "win32";
+
+  dirs.forEach(function (dir) {
+    if (!fs.existsSync(dir)) {
+      // 目录不存在，监听父目录
+      return;
+    }
+
+    try {
+      if (isWin) {
+        // Windows: recursive watch
+        var w = fs.watch(dir, { recursive: true }, function (eventType, filename) {
+          self.handleEvent(dir, filename);
+        });
+        self.watchers.push(w);
+      } else {
+        // Linux/macOS: 递归遍历
+        self.watchRecursive(dir);
+      }
+    } catch (e) {
+      // fs.watch 失败，回退到轮询
+    }
+  });
+
+  // 兜底轮询
+  self.startPolling(dirs);
+};
+
+/** 从 watch 模式提取监听目录 */
+FileWatcher.prototype.extractWatchDirs = function () {
+  var dirs = [];
+  var seen = {};
+  var patterns = this.config.watch || ["spec/**/*.ts"];
+
+  patterns.forEach(function (pattern) {
+    // 取模式中的目录部分
+    var dirPart = pattern.replace(/\/[^/]*$/, "");
+    if (dirPart.indexOf("/") >= 0) {
+      dirPart = dirPart.split("/")[0];
+    }
+    if (!dirPart || dirPart.indexOf("*") >= 0) dirPart = ".";
+    if (!seen[dirPart]) {
+      seen[dirPart] = true;
+      dirs.push(dirPart);
+    }
+  });
+
+  // 转绝对路径
+  var root = this.config.hapRoot;
+  return dirs.map(function (d) {
+    return path.isAbsolute(d) ? d : path.join(root, d);
+  }).filter(function (d) { return fs.existsSync(d); });
+};
+
+/** 递归 watch (Linux/macOS) */
+FileWatcher.prototype.watchRecursive = function (dir) {
+  var self = this;
+  try {
+    var w = fs.watch(dir, { recursive: false }, function (eventType, filename) {
+      self.handleEvent(dir, filename);
+    });
+    self.watchers.push(w);
+  } catch (e) {}
+
+  try {
+    var entries = fs.readdirSync(dir, { withFileTypes: true });
+    entries.forEach(function (entry) {
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") return;
+        self.watchRecursive(path.join(dir, entry.name));
+      }
+    });
+  } catch (e) {}
+};
+
+/** 处理文件事件 */
+FileWatcher.prototype.handleEvent = function (baseDir, filename) {
+  if (!filename) return;
+  if (!this.isWatchable(filename)) return;
+
+  var self = this;
+  clearTimeout(this.debounceTimer);
+  this.debounceTimer = setTimeout(function () {
+    if (self.callback) {
+      var full = path.join(baseDir, filename);
+      self.callback(full);
+    }
+  }, this.debounceMs);
+};
+
+/** 判断文件是否需要监听 */
+FileWatcher.prototype.isWatchable = function (filename) {
+  // 排除
+  if (filename.indexOf("node_modules") >= 0) return false;
+  if (filename.indexOf(".git") >= 0) return false;
+  if (filename.indexOf("dist") >= 0) return false;
+
+  // 只关心 .ts .js 文件
+  if (!filename.endsWith(".ts") && !filename.endsWith(".js")) return false;
+
+  // 排除 entry.js 本身 (产物)
+  if (filename === "entry.js") return false;
+
+  return true;
+};
+
+/** 兜底轮询 */
+FileWatcher.prototype.startPolling = function (dirs) {
+  var self = this;
+  var snapshots = {};
+  var interval = (this.config.pollInterval || 2000);
+
+  function snapshot(dir) {
+    var result = {};
+    function walk(d) {
+      try {
+        var entries = fs.readdirSync(d, { withFileTypes: true });
+        entries.forEach(function (entry) {
+          if (entry.name === "node_modules" || entry.name === ".git" || entry.name === "dist") return;
+          var full = path.join(d, entry.name);
+          if (entry.isDirectory()) {
+            walk(full);
+          } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".js"))) {
+            try {
+              var stat = fs.statSync(full);
+              result[full] = stat.mtimeMs;
+            } catch (e) {}
+          }
+        });
+      } catch (e) {}
+    }
+    walk(dir);
+    return result;
+  }
+
+  // 初始快照
+  dirs.forEach(function (dir) { snapshots[dir] = snapshot(dir); });
+
+  setInterval(function () {
+    dirs.forEach(function (dir) {
+      var current = snapshot(dir);
+      var prev = snapshots[dir] || {};
+      var changed = false;
+
+      Object.keys(current).forEach(function (file) {
+        if (prev[file] !== current[file]) {
+          changed = true;
+        }
+      });
+
+      if (changed) {
+        snapshots[dir] = current;
+        clearTimeout(self.debounceTimer);
+        self.debounceTimer = setTimeout(function () {
+          if (self.callback) self.callback("(polling)");
+        }, self.debounceMs);
+      } else {
+        snapshots[dir] = current;
+      }
+    });
+  }, interval);
+};
+
+/** 停止监听 */
+FileWatcher.prototype.stop = function () {
+  this.watchers.forEach(function (w) {
+    try { w.close(); } catch (e) {}
+  });
+  this.watchers = [];
+};
+
+module.exports = FileWatcher;

package/src/core/HdcBridge.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * HdcBridge.js — hdc 命令封装
+ *
+ * 自动查找 hdc 可执行文件:
+ *   1) DEVECO_SDK_HOME/toolchains/hdc[.exe]
+ *   2) 常见 Windows 路径
+ *   3) PATH 中的 hdc
+ */
+var fs = require("fs");
+var path = require("path");
+var os = require("os");
+var { execFile } = require("child_process");
+
+/** 查找 hdc */
+function findHdc() {
+  var isWin = os.platform() === "win32";
+  var isMac = os.platform() === "darwin";
+  var exe = isWin ? "hdc.exe" : "hdc";
+
+  // 1) DEVECO_SDK_HOME
+  var sdkHome = process.env.DEVECO_SDK_HOME;
+  if (sdkHome) {
+    // 尝试多个可能的子路径
+    var subPaths = [
+      path.join(sdkHome, "toolchains", exe),
+      path.join(sdkHome, "default", "openharmony", "toolchains", exe),
+      path.join(sdkHome, "default", "hms", "toolchains", exe),
+    ];
+    for (var i = 0; i < subPaths.length; i++) {
+      if (fs.existsSync(subPaths[i])) return subPaths[i];
+    }
+  }
+
+  // 2) 常见路径
+  var commonPaths;
+  if (isWin) {
+    commonPaths = [
+      "D:\\Program Files\\Huawei\\DevEco Studio\\sdk\\toolchains\\hdc.exe",
+      "D:\\Program Files\\Huawei\\DevEco Studio\\sdk\\default\\openharmony\\toolchains\\hdc.exe",
+      "C:\\Program Files\\Huawei\\DevEco Studio\\sdk\\toolchains\\hdc.exe",
+      "D:\\Tools\\Huawei\\sdk\\toolchains\\hdc.exe",
+    ];
+  } else if (isMac) {
+    commonPaths = [
+      "/Applications/DevEco-Studio.app/Contents/sdk/toolchains/hdc",
+      "/Applications/DevEco-Studio.app/Contents/sdk/default/openharmony/toolchains/hdc",
+      "/Applications/DevEco-Studio.app/Contents/sdk/default/hms/toolchains/hdc",
+      "/opt/huawei/sdk/toolchains/hdc",
+    ];
+  } else {
+    commonPaths = [
+      "/opt/huawei/sdk/toolchains/hdc",
+    ];
+  }
+  for (var j = 0; j < commonPaths.length; j++) {
+    if (fs.existsSync(commonPaths[j])) return commonPaths[j];
+  }
+
+  // 3) PATH
+  return "hdc";
+}
+
+/** 执行命令 (Promise) */
+function exec(cmd, args, opts) {
+  opts = opts || {};
+  return new Promise(function (resolve, reject) {
+    execFile(cmd, args, {
+      timeout: opts.timeout || 30000,
+      maxBuffer: 20 * 1024 * 1024,
+      windowsHide: true,
+    }, function (err, stdout, stderr) {
+      if (err) {
+        var msg = cmd + " " + args.join(" ") + " failed: " + (err.message || err);
+        if (stderr) msg += "\nstderr: " + stderr.trim();
+        reject(new Error(msg));
+      } else {
+        resolve({ stdout: stdout || "", stderr: stderr || "" });
+      }
+    });
+  });
+}
+
+function HdcBridge(bundleName) {
+  this.bundleName = bundleName;
+  this.hdcPath = findHdc();
+}
+
+/** hdc shell <command> */
+HdcBridge.prototype.shell = function (command, timeout) {
+  return exec(this.hdcPath, ["shell", command], { timeout: timeout || 30000 })
+    .then(function (r) { return (r.stdout || "").trim(); });
+};
+
+/** hdc file send <local> <remote> */
+HdcBridge.prototype.fileSend = function (localPath, remotePath) {
+  return exec(this.hdcPath, ["file", "send", localPath, remotePath])
+    .then(function (r) { return r.stdout.trim(); });
+};
+
+/** hdc file recv <remote> <local> */
+HdcBridge.prototype.fileRecv = function (remotePath, localPath) {
+  return exec(this.hdcPath, ["file", "recv", remotePath, localPath])
+    .then(function (r) { return r.stdout.trim(); });
+};
+
+/** hdc shell mkdir -p */
+HdcBridge.prototype.mkdir = function (remotePath) {
+  return this.shell("mkdir -p " + remotePath);
+};
+
+/** hdc shell touch */
+HdcBridge.prototype.touch = function (remotePath) {
+  return this.shell("touch " + remotePath);
+};
+
+/** hdc shell cat */
+HdcBridge.prototype.cat = function (remotePath) {
+  return this.shell("cat " + remotePath);
+};
+
+/** hdc shell rm -f */
+HdcBridge.prototype.rm = function (remotePath) {
+  return this.shell("rm -f " + remotePath);
+};
+
+/** force-stop 应用 */
+HdcBridge.prototype.forceStop = function () {
+  return this.shell("aa force-stop " + this.bundleName);
+};
+
+/** 启动 Ability */
+HdcBridge.prototype.startAbility = function (ability) {
+  ability = ability || "EntryAbility";
+  return this.shell("aa start -a " + ability + " -b " + this.bundleName);
+};
+
+/** 安装 HAP */
+HdcBridge.prototype.install = function (hapPath) {
+  return exec(this.hdcPath, ["install", hapPath])
+    .then(function (r) { return r.stdout.trim(); });
+};
+
+/** 卸载 */
+HdcBridge.prototype.uninstall = function () {
+  return exec(this.hdcPath, ["uninstall", this.bundleName])
+    .then(function (r) { return r.stdout.trim(); });
+};
+
+/** 检查设备是否连接 */
+HdcBridge.prototype.isDeviceConnected = function () {
+  return exec(this.hdcPath, ["list", "targets"])
+    .then(function (r) {
+      var lines = (r.stdout || "").trim().split("\n");
+      return lines.some(function (l) {
+        l = l.trim();
+        return l.length > 0 && l !== "[Empty]" && l.indexOf("No") !== 0;
+      });
+    })
+    .catch(function () { return false; });
+};
+
+/** 推送文件到 override 目录 (使用物理路径) */
+HdcBridge.prototype.pushOverride = function (localPath, remoteName, config) {
+  var remote = config.physicalOverrideDir + "/" + remoteName;
+  return this.fileSend(localPath, remote);
+};
+
+/** 读取结果文件 (使用物理路径) */
+HdcBridge.prototype.readResult = function (fileName, config) {
+  var remote = config.physicalResultDir + "/" + fileName;
+  return this.cat(remote).catch(function () { return ""; });
+};
+
+module.exports = HdcBridge;

package/src/core/StatusPoller.js

@@ -0,0 +1,72 @@
+"use strict";
+/**
+ * StatusPoller.js — 设备状态轮询
+ *
+ * 定期通过 hdc cat 读取设备上的 hot-status.json，
+ * 状态变化时通过事件回调通知上层。
+ */
+var HdcBridge = require("./HdcBridge");
+
+function StatusPoller(hdc, config) {
+  this.hdc = hdc;
+  this.config = config;
+  this.lastStatus = null;
+  this.timer = null;
+  this.listeners = { status: [], error: [] };
+}
+
+/** 注册事件回调 */
+StatusPoller.prototype.on = function (event, cb) {
+  if (!this.listeners[event]) this.listeners[event] = [];
+  this.listeners[event].push(cb);
+};
+
+StatusPoller.prototype.emit = function (event, data) {
+  var cbs = this.listeners[event] || [];
+  for (var i = 0; i < cbs.length; i++) {
+    try { cbs[i](data); } catch (e) {}
+  }
+};
+
+/** 启动轮询 */
+StatusPoller.prototype.start = function () {
+  var self = this;
+  var interval = this.config.statusPollInterval || 1000;
+
+  self.poll();
+  this.timer = setInterval(function () {
+    self.poll();
+  }, interval);
+};
+
+/** 停止轮询 */
+StatusPoller.prototype.stop = function () {
+  if (this.timer) {
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+};
+
+/** 重置 (每次重载前调用) */
+StatusPoller.prototype.reset = function () {
+  this.lastStatus = null;
+};
+
+/** 单次轮询 */
+StatusPoller.prototype.poll = function () {
+  var self = this;
+  self.hdc.readResult("hot-status.json", self.config).then(function (content) {
+    if (!content) return;
+    var status;
+    try { status = JSON.parse(content.trim()); } catch (e) { return; }
+    if (!status) return;
+
+    var statusKey = status.status + ":" + status.ts;
+    if (statusKey !== self.lastStatus) {
+      self.lastStatus = statusKey;
+      self.emit("status", status);
+    }
+  }).catch(function () {});
+};
+
+module.exports = StatusPoller;

package/src/utils.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * utils.js — 共享工具函数
+ */
+var fs = require("fs");
+var path = require("path");
+
+/** 去除 UTF-8 BOM */
+function stripBOM(content) {
+  if (typeof content === "string") {
+    if (content.charCodeAt(0) === 0xfeff) return content.slice(1);
+    return content;
+  }
+  if (Buffer.isBuffer(content)) {
+    if (content.length >= 3 && content[0] === 0xef && content[1] === 0xbb && content[2] === 0xbf) {
+      return content.slice(3).toString("utf8");
+    }
+    return content.toString("utf8");
+  }
+  return content;
+}
+
+/** 简易 JSON5 解析（处理注释、尾逗号） */
+function parseJson5(content) {
+  var cleaned = content
+    .replace(/\/\/.*$/gm, "")       // 单行注释
+    .replace(/\/\*[\s\S]*?\*\//g, "") // 多行注释
+    .replace(/,\s*([}\]])/g, "$1");   // 尾逗号
+  return JSON.parse(cleaned);
+}
+
+/** 读取并解析 JSON5 文件 */
+function readJson5(filePath) {
+  var content = fs.readFileSync(filePath, "utf8");
+  return parseJson5(content);
+}
+
+/** 简易 hash（用于 diff，非加密） */
+function simpleHash(str) {
+  var hash = 5381;
+  for (var i = 0; i < str.length; i++) {
+    hash = ((hash << 5) + hash + str.charCodeAt(i)) & 0x7fffffff;
+  }
+  return hash.toString(36);
+}
+
+/** 格式化毫秒 */
+function fmtMs(ms) {
+  if (ms < 1000) return ms + "ms";
+  return (ms / 1000).toFixed(1) + "s";
+}
+
+/** ANSI 颜色 */
+var c = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  gray: "\x1b[90m",
+};
+
+module.exports = {
+  stripBOM: stripBOM,
+  parseJson5: parseJson5,
+  readJson5: readJson5,
+  simpleHash: simpleHash,
+  fmtMs: fmtMs,
+  c: c,
+};

package/templates/hot-reload-agent.js

@@ -0,0 +1,186 @@
+"use strict";
+/**
+ * hot-reload-agent.js — 设备侧热加载核心
+ *
+ * 通过 package.json 的 main 字段被 Electron 加载。
+ * 不修改开发者的 main.js，由本文件接管启动流程。
+ *
+ * 优先级:
+ *   1) /data/storage/el2/base/files/hot/entry.js  (override, hdc 推送的开发者代码)
+ *   2) ./main.js                                    (开发者的原始入口，生产回退)
+ */
+var fs = require("fs");
+var path = require("path");
+var electron = require("electron");
+var app = electron.app;
+
+// ─── 路径常量 ───
+var OVERRIDE_DIR  = "/data/storage/el2/base/files/hot";
+var ENTRY_JS       = path.join(OVERRIDE_DIR, "entry.js");
+var CONFIG_JSON    = path.join(OVERRIDE_DIR, "hot-config.json");
+var TRIGGER_FILE   = path.join(OVERRIDE_DIR, ".reload-trigger");
+var STATUS_FILE    = "/data/storage/el2/base/files/hot-status.json";
+var LOG_FILE       = "/data/storage/el2/base/files/hot-harness.log";
+
+// 开发者原始入口（与 package.json 原 main 字段一致）
+var DEV_MAIN = path.join(__dirname, "main.js");
+
+// ─── 运行时配置 ───
+var config = {
+  strategy: "hard",  // "soft" | "hard" | "hard-first"
+  softTimeout: 5000
+};
+
+var currentModule = null;
+var reloadInProgress = false;
+
+// ─── 日志 & 状态 ───
+function log(msg) {
+  var line = new Date().toISOString() + " [agent] " + msg;
+  try { fs.appendFileSync(LOG_FILE, line + "\n"); } catch (e) {}
+}
+
+function writeStatus(status, extra) {
+  var s = Object.assign({
+    ts: Date.now(),
+    status: status,
+    pid: process.pid,
+    strategy: config.strategy
+  }, extra || {});
+  try { fs.writeFileSync(STATUS_FILE, JSON.stringify(s)); } catch (e) {}
+}
+
+function loadConfig() {
+  try {
+    var cfg = JSON.parse(fs.readFileSync(CONFIG_JSON, "utf8"));
+    if (cfg.strategy) config.strategy = cfg.strategy;
+    if (cfg.softTimeout) config.softTimeout = cfg.softTimeout;
+    log("config loaded: " + JSON.stringify(config));
+  } catch (e) {}
+}
+
+// ─── 加载开发者代码 ───
+function loadEntry() {
+  // 优先加载 override 目录的 entry.js（热加载代码）
+  if (fs.existsSync(ENTRY_JS)) {
+    log("loading entry.js from override");
+    return require(ENTRY_JS);
+  }
+
+  // 回退：加载开发者的 main.js
+  log("loading dev main.js");
+  return require(DEV_MAIN);
+}
+
+// ─── 软重载 ───
+function softReload() {
+  log("soft reload start");
+  writeStatus("soft-reloading");
+
+  try {
+    if (currentModule && typeof currentModule.cleanup === "function") {
+      try { currentModule.cleanup(); } catch (e) { log("cleanup error: " + e.message); }
+    }
+
+    // 失效 require.cache：override 目录 + 开发者入口
+    Object.keys(require.cache).forEach(function (key) {
+      if (key.indexOf(OVERRIDE_DIR) === 0 || key === DEV_MAIN) {
+        delete require.cache[key];
+      }
+    });
+
+    var mod = loadEntry();
+    currentModule = mod;
+    writeStatus("soft-ok", { loadTime: Date.now() });
+    log("soft reload done");
+    return true;
+  } catch (e) {
+    log("soft reload failed: " + (e.stack || e.message));
+    writeStatus("soft-fail", { error: e.message });
+    return false;
+  }
+}
+
+// ─── 硬重载 ───
+function hardReload() {
+  // hard 模式由主机侧 force-stop + aa start 重启，agent 不主动 quit
+  log("hard reload: waiting for host to restart");
+  writeStatus("hard-reloading");
+}
+
+// ─── 重载调度 ───
+function reload() {
+  if (reloadInProgress) {
+    log("reload already in progress, skipping");
+    return;
+  }
+  reloadInProgress = true;
+  loadConfig();
+
+  if (config.strategy === "hard") {
+    hardReload();
+    reloadInProgress = false;
+    return;
+  }
+
+  if (config.strategy === "soft") {
+    softReload();
+    reloadInProgress = false;
+    return;
+  }
+
+  // hard-first: 先 soft，失败后写状态等主机侧重启
+  var ok = softReload();
+  reloadInProgress = false;
+  if (!ok) {
+    log("soft failed, waiting for host to restart");
+    writeStatus("hard-reloading");
+  }
+}
+
+// ─── 文件监听 ───
+function startWatch() {
+  try { fs.mkdirSync(OVERRIDE_DIR, { recursive: true }); } catch (e) {}
+
+  try {
+    fs.watch(OVERRIDE_DIR, { persistent: false }, function (eventType, filename) {
+      if (filename === ".reload-trigger" || filename === "entry.js") {
+        log("watch event: " + eventType + " " + filename);
+        reload();
+      }
+    });
+    log("fs.watch active on " + OVERRIDE_DIR);
+  } catch (e) {
+    log("fs.watch failed, polling only: " + e.message);
+  }
+
+  var lastTriggerMtime = 0;
+  setInterval(function () {
+    try {
+      var stat = fs.statSync(TRIGGER_FILE);
+      if (stat.mtimeMs !== lastTriggerMtime) {
+        lastTriggerMtime = stat.mtimeMs;
+        log("polling detected trigger change");
+        reload();
+      }
+    } catch (e) {}
+  }, 2000);
+}
+
+// ─── 启动 ───
+app.whenReady().then(function () {
+  loadConfig();
+  writeStatus("agent-ready");
+  log("agent started, strategy=" + config.strategy);
+
+  try {
+    currentModule = loadEntry();
+    writeStatus("loaded");
+    log("first load done");
+  } catch (e) {
+    log("first load failed: " + (e.stack || e.message));
+    writeStatus("init-fail", { error: e.message });
+  }
+
+  startWatch();
+});