@zqagent/core 0.2.20 → 0.3.7

package/dist/internal/update/controller.cjs

@@ -0,0 +1,1035 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/update/controller.ts
+var controller_exports = {};
+__export(controller_exports, {
+  UpdateController: () => UpdateController,
+  evaluateManifest: () => evaluateManifest,
+  updaterChannel: () => updaterChannel,
+  updaterUrl: () => updaterUrl
+});
+module.exports = __toCommonJS(controller_exports);
+
+// ../../node_modules/.pnpm/tsup@8.5.1_postcss@8.5.26_supports-color@7.2.0_tsx@4.23.12_typescript@5.9.3/node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/update/controller.ts
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// src/update/downloader.ts
+var import_node_crypto2 = require("crypto");
+var fs = __toESM(require("fs"), 1);
+var import_node_stream = require("stream");
+var import_promises = require("stream/promises");
+var import_node_child_process = require("child_process");
+var path = __toESM(require("path"), 1);
+
+// src/update/version.ts
+var PATTERN = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parseVersion(input) {
+  const m = PATTERN.exec(input.trim());
+  if (!m) return null;
+  const pre = m[4] ? m[4].split(".").map((part) => /^\d+$/.test(part) ? Number(part) : part) : [];
+  return {
+    major: Number(m[1]),
+    minor: Number(m[2]),
+    patch: Number(m[3]),
+    pre
+  };
+}
+function comparePre(a, b) {
+  if (a.length === 0 && b.length === 0) return 0;
+  if (a.length === 0) return 1;
+  if (b.length === 0) return -1;
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i];
+    const y = b[i];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (typeof x === "number" && typeof y === "number") {
+      if (x !== y) return x < y ? -1 : 1;
+    } else if (typeof x === "number") {
+      return -1;
+    } else if (typeof y === "number") {
+      return 1;
+    } else if (x !== y) {
+      return x < y ? -1 : 1;
+    }
+  }
+  return 0;
+}
+function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  if (va.major !== vb.major) return va.major < vb.major ? -1 : 1;
+  if (va.minor !== vb.minor) return va.minor < vb.minor ? -1 : 1;
+  if (va.patch !== vb.patch) return va.patch < vb.patch ? -1 : 1;
+  return comparePre(va.pre, vb.pre);
+}
+
+// src/update/manifest.ts
+var PLATFORM_NAMES = {
+  darwin: "macos",
+  linux: "linux",
+  win32: "windows"
+};
+var LIBC_VARIANT = "";
+function platformKey(platform = process.platform, arch = process.arch) {
+  const base = `${PLATFORM_NAMES[platform] ?? platform}-${arch}`;
+  return LIBC_VARIANT ? `${base}-${LIBC_VARIANT}` : base;
+}
+var SHA256_HEX = /^[0-9a-f]{64}$/;
+function isRecord(v) {
+  return typeof v === "object" && v !== null;
+}
+function parseManifest(raw, opts = {}) {
+  if (!isRecord(raw)) return { error: "\u6E05\u5355\u4E0D\u662F JSON \u5BF9\u8C61" };
+  const version = typeof raw.version === "string" ? raw.version.trim() : "";
+  if (!parseVersion(version)) return { error: `\u6E05\u5355 version \u975E\u6CD5\uFF1A${String(raw.version)}` };
+  if (raw.minimumVersion !== void 0) {
+    if (typeof raw.minimumVersion !== "string" || !parseVersion(raw.minimumVersion)) {
+      return { error: `\u6E05\u5355 minimumVersion \u975E\u6CD5\uFF1A${String(raw.minimumVersion)}` };
+    }
+  }
+  if (!isRecord(raw.binaries)) return { error: "\u6E05\u5355\u7F3A\u5C11 binaries" };
+  const binaries = {};
+  for (const [key, value] of Object.entries(raw.binaries)) {
+    if (!isRecord(value)) return { error: `binaries.${key} \u4E0D\u662F\u5BF9\u8C61` };
+    const url = typeof value.url === "string" ? value.url.trim() : "";
+    const sha256 = typeof value.sha256 === "string" ? value.sha256.trim().toLowerCase() : "";
+    if (!url) return { error: `binaries.${key} \u7F3A\u5C11 url` };
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch {
+      return { error: `binaries.${key}.url \u975E\u6CD5\uFF1A${url}` };
+    }
+    if (parsed.protocol !== "https:" && !opts.allowInsecureUrl) {
+      return { error: `binaries.${key}.url \u5FC5\u987B\u662F https\uFF1A${url}` };
+    }
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+      return { error: `binaries.${key}.url \u534F\u8BAE\u4E0D\u652F\u6301\uFF1A${url}` };
+    }
+    if (!SHA256_HEX.test(sha256)) {
+      return { error: `binaries.${key}.sha256 \u9700\u4E3A 64 \u4F4D\u5C0F\u5199 hex` };
+    }
+    const size = typeof value.size === "number" && value.size > 0 ? value.size : void 0;
+    binaries[key] = { url, sha256, ...size ? { size } : {} };
+  }
+  if (Object.keys(binaries).length === 0) return { error: "\u6E05\u5355 binaries \u4E3A\u7A7A" };
+  return {
+    manifest: {
+      version,
+      ...typeof raw.minimumVersion === "string" ? { minimumVersion: raw.minimumVersion } : {},
+      ...typeof raw.notes === "string" ? { notes: raw.notes } : {},
+      ...typeof raw.publishedAt === "string" ? { publishedAt: raw.publishedAt } : {},
+      ...typeof raw.channel === "string" ? { channel: raw.channel } : {},
+      binaries
+    }
+  };
+}
+
+// src/update/signature.ts
+var import_node_crypto = require("crypto");
+function parsePublicKey(input) {
+  const text = input.trim();
+  if (!text) return null;
+  try {
+    if (text.includes("BEGIN PUBLIC KEY")) {
+      return (0, import_node_crypto.createPublicKey)({ key: text, format: "pem" });
+    }
+    return (0, import_node_crypto.createPublicKey)({
+      key: Buffer.from(text, "base64"),
+      format: "der",
+      type: "spki"
+    });
+  } catch {
+    return null;
+  }
+}
+function verifySignature(data, signatureBase64, publicKey) {
+  try {
+    const sig = Buffer.from(signatureBase64.trim(), "base64");
+    if (sig.length !== 64) return false;
+    return (0, import_node_crypto.verify)(null, data, publicKey, sig);
+  } catch {
+    return false;
+  }
+}
+
+// src/update/downloader.ts
+var MAX_BINARY_BYTES = 400 * 1024 * 1024;
+var MANIFEST_TIMEOUT_MS = 15e3;
+var DOWNLOAD_TIMEOUT_MS = 10 * 6e4;
+async function fetchManifest(url, publicKey, opts = {}) {
+  let raw;
+  let sig;
+  try {
+    const [mRes, sRes] = await Promise.all([
+      fetch(url, { signal: AbortSignal.timeout(MANIFEST_TIMEOUT_MS) }),
+      fetch(`${url}.sig`, { signal: AbortSignal.timeout(MANIFEST_TIMEOUT_MS) })
+    ]);
+    if (!mRes.ok) return { error: `\u6E05\u5355\u8BF7\u6C42\u5931\u8D25 HTTP ${mRes.status}` };
+    if (!sRes.ok) return { error: `\u7B7E\u540D\u8BF7\u6C42\u5931\u8D25 HTTP ${sRes.status}` };
+    raw = Buffer.from(await mRes.arrayBuffer());
+    sig = (await sRes.text()).trim();
+  } catch (err) {
+    return { error: `\u62C9\u53D6\u6E05\u5355\u5931\u8D25\uFF1A${err.message}` };
+  }
+  if (!sig) return { error: "\u7B7E\u540D\u6587\u4EF6\u4E3A\u7A7A" };
+  if (!verifySignature(raw, sig, publicKey)) {
+    return { error: "\u6E05\u5355\u7B7E\u540D\u6821\u9A8C\u5931\u8D25\uFF08\u516C\u94A5\u4E0D\u5339\u914D\u6216\u5185\u5BB9\u88AB\u7BE1\u6539\uFF09" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw.toString("utf-8"));
+  } catch (err) {
+    return { error: `\u6E05\u5355\u4E0D\u662F\u5408\u6CD5 JSON\uFF1A${err.message}` };
+  }
+  const { manifest, error } = parseManifest(parsed, opts);
+  if (!manifest) return { error };
+  return { manifest, raw };
+}
+async function downloadBinary(bin, destPath, log = () => {
+}) {
+  const partPath = `${destPath}.part`;
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  fs.rmSync(partPath, { force: true });
+  let res;
+  try {
+    res = await fetch(bin.url, { signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS) });
+  } catch (err) {
+    return { error: `\u4E0B\u8F7D\u5931\u8D25\uFF1A${err.message}` };
+  }
+  if (!res.ok) return { error: `\u4E0B\u8F7D\u5931\u8D25 HTTP ${res.status}` };
+  if (!res.body) return { error: "\u4E0B\u8F7D\u54CD\u5E94\u6CA1\u6709 body" };
+  const expected = bin.size && bin.size > 0 ? bin.size : void 0;
+  const limit = expected ? Math.max(expected * 2, 1024 * 1024) : MAX_BINARY_BYTES;
+  const hash = (0, import_node_crypto2.createHash)("sha256");
+  let bytes = 0;
+  try {
+    const source = import_node_stream.Readable.fromWeb(res.body);
+    await (0, import_promises.pipeline)(
+      source,
+      async function* (chunks) {
+        for await (const chunk of chunks) {
+          bytes += chunk.length;
+          if (bytes > limit) throw new Error(`\u4EA7\u7269\u8D85\u8FC7\u5927\u5C0F\u4E0A\u9650\uFF08>${limit} \u5B57\u8282\uFF09`);
+          hash.update(chunk);
+          yield chunk;
+        }
+      },
+      fs.createWriteStream(partPath, { mode: 493 })
+    );
+  } catch (err) {
+    fs.rmSync(partPath, { force: true });
+    return { error: `\u4E0B\u8F7D\u4E2D\u65AD\uFF1A${err.message}` };
+  }
+  const actual = hash.digest("hex");
+  if (actual !== bin.sha256) {
+    fs.rmSync(partPath, { force: true });
+    return { error: `SHA-256 \u4E0D\u5339\u914D\uFF08\u671F\u671B ${bin.sha256.slice(0, 12)}\u2026\uFF0C\u5B9E\u9645 ${actual.slice(0, 12)}\u2026\uFF09` };
+  }
+  if (expected && bytes !== expected) {
+    fs.rmSync(partPath, { force: true });
+    return { error: `\u4EA7\u7269\u5927\u5C0F\u4E0D\u5339\u914D\uFF08\u671F\u671B ${expected}\uFF0C\u5B9E\u9645 ${bytes}\uFF09` };
+  }
+  fs.rmSync(destPath, { force: true });
+  fs.renameSync(partPath, destPath);
+  fs.chmodSync(destPath, 493);
+  log(`\u5DF2\u4E0B\u8F7D ${path.basename(destPath)}\uFF08${Math.round(bytes / 1024 / 1024)}MB\uFF0C\u6821\u9A8C\u901A\u8FC7\uFF09`);
+  return { bytes };
+}
+function selfCheck(binPath, expectedVersion) {
+  try {
+    const r = (0, import_node_child_process.spawnSync)(binPath, ["--version"], {
+      timeout: 2e4,
+      encoding: "utf-8",
+      env: { ...process.env, ZQAGENT_AUTO_UPDATE: "0" }
+    });
+    if (r.error) return { ok: false, error: `\u6267\u884C\u81EA\u68C0\u5931\u8D25\uFF1A${r.error.message}` };
+    if (r.status !== 0) return { ok: false, error: `\u81EA\u68C0\u9000\u51FA\u7801 ${r.status}\uFF1A${(r.stderr || "").trim()}` };
+    const out = `${r.stdout ?? ""}${r.stderr ?? ""}`;
+    if (!out.includes(expectedVersion)) {
+      return { ok: false, error: `\u81EA\u68C0\u7248\u672C\u4E0D\u7B26\uFF08\u671F\u671B ${expectedVersion}\uFF0C\u8F93\u51FA\uFF1A${out.trim().slice(0, 120)}\uFF09` };
+    }
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: `\u81EA\u68C0\u5F02\u5E38\uFF1A${err.message}` };
+  }
+}
+
+// src/update/platform.ts
+var fs2 = __toESM(require("fs"), 1);
+var os = __toESM(require("os"), 1);
+var path2 = __toESM(require("path"), 1);
+var import_node_child_process2 = require("child_process");
+var import_node_module = require("module");
+function currentVersion() {
+  const injected = "0.3.7"?.trim();
+  if (injected) return injected;
+  try {
+    const req = (0, import_node_module.createRequire)(importMetaUrl);
+    const pkg = req("../../package.json");
+    if (pkg?.version) return pkg.version;
+  } catch {
+  }
+  return "dev";
+}
+function isSeaRuntime() {
+  if (process.env.ZQAGENT_SEA === "1") return true;
+  const base = path2.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
+  return base !== "node" && base !== "nodejs";
+}
+var DEFAULT_SERVICE_NAME = "zqagent";
+var DEFAULT_SERVICE_LABEL = "com.zqagent.node";
+function serviceManagerFromCgroup(cgroup, serviceName = DEFAULT_SERVICE_NAME) {
+  const unitName = `${serviceName}.service`;
+  for (const line of cgroup.split("\n")) {
+    const idx = line.lastIndexOf(":");
+    if (idx < 0) continue;
+    const unitPath = line.slice(idx + 1).trim();
+    if (unitPath.split("/").includes(unitName)) return "systemd";
+  }
+  return null;
+}
+function launchdDomain() {
+  const uid = typeof process.getuid === "function" ? process.getuid() : -1;
+  return uid === 0 ? "system" : `gui/${uid}`;
+}
+function launchdLabel() {
+  return process.env.ZQAGENT_SERVICE_LABEL?.trim() || DEFAULT_SERVICE_LABEL;
+}
+function launchdPlistPath() {
+  const label = launchdLabel();
+  const uid = typeof process.getuid === "function" ? process.getuid() : -1;
+  if (uid === 0) return `/Library/LaunchDaemons/${label}.plist`;
+  return path2.join(os.homedir(), "Library", "LaunchAgents", `${label}.plist`);
+}
+function serviceManagerFromLaunchctl(output, pid, execPath, sea = true) {
+  const pidMatch = /^\s*pid = (\d+)\s*$/m.exec(output);
+  if (pidMatch && Number(pidMatch[1]) === pid) return "launchd";
+  const program = /^\s*program = (.+?)\s*$/m.exec(output);
+  if (program) {
+    const shown = program[1].replace(/^"|"$/g, "");
+    if (path2.resolve(shown) === path2.resolve(execPath)) return "launchd";
+  }
+  if (!sea && /^\s*state = /m.test(output)) return "launchd";
+  return null;
+}
+function parseLaunchdEnvironment(xml) {
+  const out = {};
+  const marker = xml.indexOf("<key>EnvironmentVariables</key>");
+  if (marker < 0) return out;
+  const open = xml.indexOf("<dict>", marker);
+  if (open < 0) return out;
+  const close = xml.indexOf("</dict>", open);
+  if (close < 0) return out;
+  const body = xml.slice(open + "<dict>".length, close);
+  for (const m of body.matchAll(/<key>([^<]+)<\/key>\s*<string>([^<]*)<\/string>/g)) {
+    out[m[1]] = m[2];
+  }
+  return out;
+}
+function detectServiceManager() {
+  if (process.platform === "darwin") return detectLaunchd();
+  if (process.platform !== "linux") return null;
+  const serviceName = process.env.ZQAGENT_SERVICE_NAME?.trim() || DEFAULT_SERVICE_NAME;
+  try {
+    return serviceManagerFromCgroup(
+      fs2.readFileSync("/proc/self/cgroup", "utf8"),
+      serviceName
+    );
+  } catch {
+    return null;
+  }
+}
+function detectLaunchd() {
+  try {
+    const res = (0, import_node_child_process2.spawnSync)(
+      "launchctl",
+      ["print", `${launchdDomain()}/${launchdLabel()}`],
+      { encoding: "utf8", timeout: 3e3 }
+    );
+    if (res.status !== 0 || !res.stdout) return null;
+    return serviceManagerFromLaunchctl(
+      res.stdout,
+      process.pid,
+      process.execPath,
+      isSeaRuntime()
+    );
+  } catch {
+    return null;
+  }
+}
+function serviceManager() {
+  const v = process.env.ZQAGENT_SERVICE_MANAGER?.trim().toLowerCase();
+  if (v === "systemd" || v === "launchd") return v;
+  return detectServiceManager();
+}
+function parseServiceEnvironment(raw) {
+  const out = {};
+  for (const token of raw.trim().split(/\s+/)) {
+    const idx = token.indexOf("=");
+    if (idx > 0) out[token.slice(0, idx)] = token.slice(idx + 1);
+  }
+  return out;
+}
+var cachedServiceEnv = null;
+function readServiceEnvironment() {
+  const serviceName = process.env.ZQAGENT_SERVICE_NAME?.trim() || DEFAULT_SERVICE_NAME;
+  try {
+    const res = (0, import_node_child_process2.spawnSync)(
+      "systemctl",
+      ["show", serviceName, "--property=Environment", "--value", "--no-pager"],
+      { encoding: "utf8", timeout: 3e3 }
+    );
+    if (res.status !== 0 || !res.stdout) return {};
+    return parseServiceEnvironment(res.stdout);
+  } catch {
+    return {};
+  }
+}
+function serviceEnvValue(key) {
+  if (process.platform === "darwin") {
+    if (serviceManager() !== "launchd") return void 0;
+    cachedLaunchdEnv ??= readLaunchdEnvironment();
+    return cachedLaunchdEnv[key];
+  }
+  if (process.platform !== "linux") return void 0;
+  if (serviceManager() !== "systemd") return void 0;
+  cachedServiceEnv ??= readServiceEnvironment();
+  return cachedServiceEnv[key];
+}
+var cachedLaunchdEnv = null;
+function readLaunchdEnvironment() {
+  try {
+    return parseLaunchdEnvironment(fs2.readFileSync(launchdPlistPath(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function selfUpdateCapability(hasPublicKey) {
+  if (!isSeaRuntime()) {
+    return {
+      ok: false,
+      reason: "\u5F53\u524D\u4E0D\u662F\u5355\u6587\u4EF6\uFF08SEA\uFF09\u5F62\u6001\uFF1A\u8BF7\u7528 npm \u5347\u7EA7\uFF08npm i -g @zqagent/cli@latest\uFF09"
+    };
+  }
+  if (!serviceManager()) {
+    return {
+      ok: false,
+      reason: "\u672A\u88AB systemd/launchd \u6258\u7BA1\uFF1A\u8BF7\u7528 deploy/service/install.sh \u5B89\u88C5\uFF0C\u6216\u624B\u52A8\u5347\u7EA7"
+    };
+  }
+  if (!hasPublicKey) {
+    return { ok: false, reason: "\u672A\u914D\u7F6E ZQAGENT_UPDATE_PUBKEY\uFF0C\u65E0\u6CD5\u9A8C\u7B7E\uFF0C\u5DF2\u7981\u7528\u81EA\u52A8\u66F4\u65B0" };
+  }
+  return { ok: true };
+}
+
+// src/update/installer.ts
+var fs4 = __toESM(require("fs"), 1);
+var path4 = __toESM(require("path"), 1);
+
+// src/update/state.ts
+var fs3 = __toESM(require("fs"), 1);
+var path3 = __toESM(require("path"), 1);
+function updatesDir(dataDir) {
+  return path3.join(dataDir, "updates");
+}
+function statePath(dataDir) {
+  return path3.join(updatesDir(dataDir), "state.json");
+}
+function loadState(dataDir) {
+  try {
+    const raw = fs3.readFileSync(statePath(dataDir), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed === "object" && parsed !== null) return parsed;
+  } catch {
+  }
+  return {};
+}
+function saveState(dataDir, state) {
+  const dir = updatesDir(dataDir);
+  fs3.mkdirSync(dir, { recursive: true });
+  const file = statePath(dataDir);
+  const tmp = `${file}.tmp`;
+  fs3.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf-8");
+  fs3.renameSync(tmp, file);
+}
+function patchState(dataDir, patch) {
+  const next = { ...loadState(dataDir), ...patch };
+  saveState(dataDir, next);
+  return next;
+}
+
+// src/update/installer.ts
+function backupDir(dataDir) {
+  return path4.join(updatesDir(dataDir), "backup");
+}
+function backupCurrent(dataDir, execPath, version) {
+  const dir = backupDir(dataDir);
+  fs4.mkdirSync(dir, { recursive: true });
+  const target = path4.join(dir, `zqagent-${version}${process.platform === "win32" ? ".exe" : ""}`);
+  fs4.copyFileSync(execPath, target);
+  fs4.chmodSync(target, 493);
+  return target;
+}
+function replaceExecutable(execPath, stagedPath) {
+  if (process.platform === "win32") {
+    const oldPath = `${execPath}.old`;
+    fs4.rmSync(oldPath, { force: true });
+    fs4.renameSync(execPath, oldPath);
+    fs4.copyFileSync(stagedPath, execPath);
+    fs4.chmodSync(execPath, 493);
+    return;
+  }
+  const tmp = `${execPath}.new`;
+  fs4.rmSync(tmp, { force: true });
+  try {
+    fs4.copyFileSync(stagedPath, tmp);
+    fs4.chmodSync(tmp, 493);
+    fs4.renameSync(tmp, execPath);
+  } catch (err) {
+    fs4.rmSync(tmp, { force: true });
+    throw err;
+  }
+  fs4.rmSync(stagedPath, { force: true });
+}
+function installStaged(opts) {
+  const log = opts.log ?? (() => {
+  });
+  const from = currentVersion();
+  log(`\u6B63\u5728\u5B89\u88C5 v${opts.version}\uFF08\u5F53\u524D v${from}\uFF09`);
+  const backupPath = backupCurrent(opts.dataDir, opts.execPath, from);
+  log(`\u5DF2\u5907\u4EFD\u5F53\u524D\u7248\u672C\u5230 ${path4.basename(backupPath)}`);
+  replaceExecutable(opts.execPath, opts.stagedPath);
+  return patchState(opts.dataDir, {
+    stagedVersion: void 0,
+    stagedPath: void 0,
+    pendingVersion: opts.version,
+    previousVersion: from,
+    backupVersion: from,
+    backupPath,
+    installedExecPath: opts.execPath,
+    lastError: void 0,
+    failureCount: 0,
+    failedVersion: void 0
+  });
+}
+function rollback(dataDir, execPath, log = () => {
+}) {
+  const state = readRollbackTarget(dataDir);
+  if (!state?.backupPath || !state.backupVersion) return null;
+  if (!fs4.existsSync(state.backupPath)) return null;
+  log(`\u6B63\u5728\u56DE\u6EDA\u5230 v${state.backupVersion}`);
+  if (process.platform === "win32") {
+    fs4.rmSync(`${execPath}.old`, { force: true });
+    fs4.renameSync(execPath, `${execPath}.old`);
+    fs4.copyFileSync(state.backupPath, execPath);
+    fs4.chmodSync(execPath, 493);
+  } else {
+    const tmp = `${execPath}.rollback`;
+    fs4.copyFileSync(state.backupPath, tmp);
+    fs4.chmodSync(tmp, 493);
+    fs4.renameSync(tmp, execPath);
+  }
+  patchState(dataDir, {
+    pendingVersion: state.backupVersion,
+    previousVersion: currentVersion(),
+    // 不让自动更新立刻把刚回滚掉的版本再装回来
+    skippedVersion: currentVersion(),
+    backupPath: void 0,
+    backupVersion: void 0
+  });
+  return state.backupVersion;
+}
+function readRollbackTarget(dataDir) {
+  try {
+    const raw = fs4.readFileSync(path4.join(updatesDir(dataDir), "state.json"), "utf-8");
+    const s = JSON.parse(raw);
+    if (s.backupPath && s.backupVersion) return s;
+  } catch {
+  }
+  return null;
+}
+
+// src/update/controller.ts
+var DEFAULT_BASE = "https://agent.cd-zq.com/downloads/zqagent";
+function env(key) {
+  const v = process.env[key]?.trim();
+  if (v) return v;
+  const fromService = serviceEnvValue(key)?.trim();
+  return fromService ? fromService : void 0;
+}
+function num(key, fallback) {
+  const n = Number(env(key));
+  return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+function updaterChannel() {
+  return env("ZQAGENT_UPDATE_CHANNEL") ?? "stable";
+}
+function updaterUrl(channel = updaterChannel()) {
+  return env("ZQAGENT_UPDATE_URL") ?? `${DEFAULT_BASE}/${channel}.json`;
+}
+function nextIntervalMs() {
+  const base = num("ZQAGENT_UPDATE_INTERVAL_MS", 6 * 60 * 60 * 1e3);
+  const jitter = base * 0.15 * (Math.random() * 2 - 1);
+  return Math.max(6e4, Math.round(base + jitter));
+}
+function evaluateManifest(base, manifest) {
+  if (!parseVersion(base.currentVersion) || compareVersions(manifest.version, base.currentVersion) <= 0) {
+    return {
+      ...base,
+      updateAvailable: false,
+      latestVersion: manifest.version,
+      reason: `\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF08v${base.currentVersion}\uFF09`
+    };
+  }
+  if (manifest.minimumVersion && compareVersions(base.currentVersion, manifest.minimumVersion) < 0) {
+    return {
+      ...base,
+      updateAvailable: false,
+      latestVersion: manifest.version,
+      manualUpgradeRequired: manifest.minimumVersion,
+      reason: `\u5F53\u524D\u7248\u672C\u8FC7\u4F4E\uFF0C\u9700\u624B\u52A8\u5347\u7EA7\u5230 >= ${manifest.minimumVersion}`
+    };
+  }
+  return {
+    ...base,
+    updateAvailable: true,
+    latestVersion: manifest.version,
+    ...manifest.notes ? { notes: manifest.notes } : {}
+  };
+}
+var UpdateController = class {
+  constructor(opts, currentVersion2 = currentVersion()) {
+    this.opts = opts;
+    this.currentVersion = currentVersion2;
+    this.log = opts.log ?? ((msg) => console.log(`[update] ${msg}`));
+  }
+  opts;
+  currentVersion;
+  log;
+  timer = null;
+  stopped = false;
+  checking = false;
+  installing = false;
+  /**
+   * 进行中的「等空闲」被要求立刻执行。
+   *
+   * 用户点「立即更新」时若已有一个在等空闲的任务，不能回一句「已有任务在进行中」
+   * 就完事——那个任务可能正因为某个 running 会话而永远等下去。置位后
+   * `waitForIdle` 下一拍直接放行。
+   */
+  forceRequested = false;
+  startedAt = Date.now();
+  lastCheckAt;
+  /** 公钥（未配置时禁用自更新：无法验签就不能替换可执行文件） */
+  get publicKey() {
+    return parsePublicKey(env("ZQAGENT_UPDATE_PUBKEY") ?? "");
+  }
+  get autoUpdateOff() {
+    return env("ZQAGENT_AUTO_UPDATE") === "0";
+  }
+  get enabled() {
+    return !this.autoUpdateOff && selfUpdateCapability(Boolean(this.publicKey)).ok;
+  }
+  manifestUrl() {
+    return this.opts.url ?? updaterUrl();
+  }
+  /** 启动调度并核对上次更新结果 */
+  start() {
+    this.reconcile();
+    if (this.autoUpdateOff) {
+      this.log("\u81EA\u52A8\u66F4\u65B0\u5DF2\u5173\u95ED\uFF08ZQAGENT_AUTO_UPDATE=0\uFF09");
+      return;
+    }
+    const cap = selfUpdateCapability(Boolean(this.publicKey));
+    if (!cap.ok) {
+      this.log(`\u81EA\u52A8\u66F4\u65B0\u672A\u542F\u7528\uFF1A${cap.reason}`);
+      return;
+    }
+    this.log(
+      `\u81EA\u52A8\u66F4\u65B0\u5DF2\u542F\u7528\uFF08v${this.currentVersion}\uFF0C\u901A\u9053 ${updaterChannel()}\uFF0C\u7531 ${serviceManager()} \u6258\u7BA1\uFF09`
+    );
+    this.schedule(num("ZQAGENT_UPDATE_INITIAL_DELAY_MS", 5 * 60 * 1e3));
+  }
+  stop() {
+    this.stopped = true;
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = null;
+  }
+  /** 启动时对账：确认上次更新是否成功、清理失效的暂存/备份状态 */
+  reconcile() {
+    const state = loadState(this.opts.dataDir);
+    const current = this.currentVersion;
+    if (state.stagedPath && !fs5.existsSync(state.stagedPath)) {
+      patchState(this.opts.dataDir, { stagedVersion: void 0, stagedPath: void 0 });
+    }
+    const patch = { runningVersion: current };
+    if (state.pendingVersion && state.pendingVersion === current) {
+      patch.pendingVersion = void 0;
+      this.log(`\u5DF2\u66F4\u65B0\u5230 v${current}\uFF08\u6B64\u524D v${state.previousVersion ?? "?"}\uFF09`);
+    } else if (state.pendingVersion) {
+      this.log(
+        `\u6CE8\u610F\uFF1A\u4E0A\u6B21\u5B89\u88C5 v${state.pendingVersion} \u672A\u751F\u6548\uFF0C\u5F53\u524D\u4ECD\u4E3A v${current}` + (state.backupPath ? "\uFF1B\u53EF\u6267\u884C update --rollback \u6062\u590D\u5907\u4EFD" : "")
+      );
+      patch.pendingVersion = void 0;
+    }
+    patchState(this.opts.dataDir, patch);
+    if (process.platform === "win32") {
+      fs5.rmSync(`${process.execPath}.old`, { force: true });
+    }
+  }
+  schedule(delayMs) {
+    if (this.stopped) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.tick();
+    }, delayMs);
+    this.timer.unref();
+  }
+  async tick() {
+    try {
+      await this.check();
+    } catch (err) {
+      this.log(`\u68C0\u67E5\u66F4\u65B0\u5931\u8D25\uFF1A${err.message}`);
+    }
+    this.schedule(nextIntervalMs());
+  }
+  /**
+   * 只读检查：拉清单比对版本，不下载、不改 state。
+   *
+   * 供远端 `self_update --action check` 与 UI 展示用；与定时器 `check()` 不同，
+   * 这里不加 `checking` 锁、不写 `lastCheckAt`，因此不会干扰自动更新流程。
+   */
+  async inspect() {
+    const base = {
+      currentVersion: this.currentVersion,
+      channel: updaterChannel(),
+      manifestUrl: this.manifestUrl()
+    };
+    const key = this.publicKey;
+    const cap = selfUpdateCapability(Boolean(key));
+    if (!cap.ok) {
+      return { ...base, updateAvailable: false, reason: `\u81EA\u66F4\u65B0\u4E0D\u53EF\u7528\uFF1A${cap.reason}` };
+    }
+    const res = await fetchManifest(base.manifestUrl, key, {
+      allowInsecureUrl: env("ZQAGENT_UPDATE_INSECURE") === "1"
+    });
+    if (!res.manifest) {
+      return {
+        ...base,
+        updateAvailable: false,
+        reason: `\u66F4\u65B0\u68C0\u67E5\u5931\u8D25\uFF1A${res.error ?? "\u6E05\u5355\u6821\u9A8C\u5931\u8D25"}`
+      };
+    }
+    return evaluateManifest(base, res.manifest);
+  }
+  /**
+   * 远端触发安装：先同步给出结论（受理/无需更新），安装本身在后台跑。
+   *
+   * 必须「先回执、后安装」：安装成功后进程会 `exit(70)` 交给 systemd 拉起新版本，
+   * 如果等到安装完成再回执，回执永远发不出去（表现为网关超时）。
+   *
+   * 复用定时器同一条 `check()` 路径：验签、下载、自检、失败计数、安装后自检与
+   * 回滚保护全都一致，只是把 `installMode` 设为 `force` 时不等待空闲。
+   */
+  async requestInstall(force = false, opts = {}) {
+    const fromVersion = this.currentVersion;
+    const cap = selfUpdateCapability(Boolean(this.publicKey));
+    if (!cap.ok) {
+      return { accepted: false, fromVersion, message: `\u81EA\u66F4\u65B0\u4E0D\u53EF\u7528\uFF1A${cap.reason}` };
+    }
+    const info = await this.inspect();
+    if (!info.updateAvailable) {
+      return {
+        accepted: false,
+        fromVersion,
+        ...info.latestVersion ? { toVersion: info.latestVersion } : {},
+        message: info.reason ?? "\u5DF2\u662F\u6700\u65B0\u7248\u672C"
+      };
+    }
+    if (this.checking || this.installing) {
+      if (force) this.forceRequested = true;
+      return {
+        accepted: true,
+        fromVersion,
+        toVersion: info.latestVersion,
+        message: force ? `\u5DF2\u8BF7\u6C42\u7ACB\u5373\u5B89\u88C5 v${info.latestVersion}\uFF08\u6253\u65AD\u6B64\u524D\u7684\u7B49\u5F85\uFF09` : `\u5DF2\u6709\u66F4\u65B0\u4EFB\u52A1\u5728\u8FDB\u884C\u4E2D\uFF08\u76EE\u6807 v${info.latestVersion}\uFF09\uFF0C\u53EF\u5728\u7A0D\u540E\u7528 status \u67E5\u770B\u7ED3\u679C`
+      };
+    }
+    void this.check(force, false, true, {
+      ...opts,
+      // 用户显式请求：跳过「启动满 10 分钟」这道只为自动更新设的闸门
+      requireUptime: false
+    }).catch((err) => {
+      this.recordFailure(info.latestVersion, `\u5B89\u88C5\u5931\u8D25\uFF1A${err.message}`);
+    });
+    return {
+      accepted: true,
+      fromVersion,
+      toVersion: info.latestVersion,
+      message: force ? `\u5F00\u59CB\u5B89\u88C5 v${info.latestVersion}\uFF08\u7ACB\u5373\u91CD\u542F\uFF09` : `\u5F00\u59CB\u5B89\u88C5 v${info.latestVersion}\uFF08\u7B49\u5F85\u8282\u70B9\u7A7A\u95F2\u540E\u91CD\u542F\uFF09`
+    };
+  }
+  /**
+   * 检查并准备更新；`installMode` 为 true 时下载后立即安装（不再等空闲）。
+   * 返回可读结论，供 CLI `update --check` 使用。
+   */
+  async check(installMode = false, dryRun = false, ignoreSkip = false, ctx = {}) {
+    const key = this.publicKey;
+    const cap = selfUpdateCapability(Boolean(key));
+    if (!cap.ok) return `\u672A\u542F\u7528\u81EA\u52A8\u66F4\u65B0\uFF1A${cap.reason}`;
+    if (this.checking) return "\u5DF2\u6709\u68C0\u67E5\u5728\u8FDB\u884C\u4E2D";
+    this.checking = true;
+    try {
+      const current = this.currentVersion;
+      const url = this.manifestUrl();
+      this.log(`\u68C0\u67E5\u66F4\u65B0\uFF1A${url}`);
+      const res = await fetchManifest(url, key, {
+        allowInsecureUrl: env("ZQAGENT_UPDATE_INSECURE") === "1"
+      });
+      if (!res.manifest) {
+        this.recordFailure(void 0, res.error ?? "\u6E05\u5355\u6821\u9A8C\u5931\u8D25");
+        return `\u66F4\u65B0\u68C0\u67E5\u5931\u8D25\uFF1A${res.error}`;
+      }
+      const manifest = res.manifest;
+      this.lastCheckAt = (/* @__PURE__ */ new Date()).toISOString();
+      patchState(this.opts.dataDir, { lastCheckAt: this.lastCheckAt });
+      if (!parseVersion(current) || compareVersions(manifest.version, current) <= 0) {
+        patchState(this.opts.dataDir, {
+          stagedVersion: void 0,
+          stagedPath: void 0,
+          lastError: void 0
+        });
+        this.log(`\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF08v${current}\uFF09`);
+        return `\u5DF2\u662F\u6700\u65B0\u7248\u672C\uFF08v${current}\uFF09`;
+      }
+      if (manifest.minimumVersion && compareVersions(current, manifest.minimumVersion) < 0) {
+        this.recordFailure(manifest.version, `\u5F53\u524D\u7248\u672C\u8FC7\u4F4E\uFF0C\u9700\u624B\u52A8\u5347\u7EA7\u5230 >= ${manifest.minimumVersion}`);
+        return `\u9700\u8981\u624B\u52A8\u5347\u7EA7\uFF1A\u5F53\u524D v${current} \u4F4E\u4E8E\u6700\u4F4E\u8981\u6C42 v${manifest.minimumVersion}`;
+      }
+      if (dryRun) {
+        const notes = manifest.notes ? `\uFF1A${manifest.notes}` : "";
+        return `\u53D1\u73B0\u65B0\u7248\u672C v${manifest.version}\uFF08\u5F53\u524D v${current}\uFF09${notes}`;
+      }
+      const state = loadState(this.opts.dataDir);
+      if (!ignoreSkip && state.skippedVersion === manifest.version) {
+        const msg = `v${manifest.version} \u5DF2\u88AB\u56DE\u6EDA\uFF0C\u81EA\u52A8\u66F4\u65B0\u8DF3\u8FC7\uFF08\u624B\u52A8 update --now \u53EF\u5F3A\u5236\u5B89\u88C5\uFF09`;
+        this.log(msg);
+        return msg;
+      }
+      if (state.skippedVersion && compareVersions(manifest.version, state.skippedVersion) > 0) {
+        patchState(this.opts.dataDir, { skippedVersion: void 0 });
+      }
+      const maxFailures = num("ZQAGENT_UPDATE_MAX_FAILURES", 3);
+      if (state.failedVersion === manifest.version && (state.failureCount ?? 0) >= maxFailures) {
+        const msg = `v${manifest.version} \u5DF2\u8FDE\u7EED\u5931\u8D25 ${state.failureCount} \u6B21\uFF0C\u8DF3\u8FC7\uFF08\u7B49\u5F85\u4E0B\u4E00\u7248\u672C\uFF09`;
+        this.log(msg);
+        return msg;
+      }
+      const platform = platformKey();
+      const bin = manifest.binaries[platform];
+      if (!bin) {
+        const available = Object.keys(manifest.binaries).join(", ") || "\uFF08\u7A7A\uFF09";
+        const msg = `\u6E05\u5355\u6CA1\u6709\u5F53\u524D\u5E73\u53F0\uFF08${platform}\uFF09\u7684\u4EA7\u7269\uFF1B\u6E05\u5355\u63D0\u4F9B\uFF1A${available}`;
+        this.log(msg);
+        return msg;
+      }
+      let stagedPath = state.stagedPath;
+      if (!(state.stagedVersion === manifest.version && stagedPath && fs5.existsSync(stagedPath))) {
+        stagedPath = path5.join(
+          updatesDir(this.opts.dataDir),
+          "staged",
+          `zqagent-${manifest.version}${process.platform === "win32" ? ".exe" : ""}`
+        );
+        const dl = await downloadBinary(bin, stagedPath, this.log);
+        if (dl.error) {
+          this.recordFailure(manifest.version, dl.error);
+          return `\u4E0B\u8F7D\u5931\u8D25\uFF1A${dl.error}`;
+        }
+        const selfTest = selfCheck(stagedPath, manifest.version);
+        if (!selfTest.ok) {
+          fs5.rmSync(stagedPath, { force: true });
+          this.recordFailure(manifest.version, selfTest.error ?? "\u81EA\u68C0\u5931\u8D25");
+          return `\u5B89\u88C5\u5305\u81EA\u68C0\u5931\u8D25\uFF1A${selfTest.error}`;
+        }
+        patchState(this.opts.dataDir, {
+          stagedVersion: manifest.version,
+          stagedPath,
+          lastError: void 0,
+          failureCount: 0,
+          failedVersion: void 0
+        });
+      }
+      this.log(
+        `v${manifest.version} \u5DF2\u5C31\u7EEA${manifest.notes ? `\uFF1A${manifest.notes}` : ""}`
+      );
+      await this.installWhenIdle(manifest.version, stagedPath, installMode, ctx);
+      return `v${manifest.version} \u5DF2\u5C31\u7EEA`;
+    } finally {
+      this.checking = false;
+    }
+  }
+  recordFailure(version, error) {
+    const state = loadState(this.opts.dataDir);
+    const sameVersion = version !== void 0 && state.failedVersion === version;
+    patchState(this.opts.dataDir, {
+      lastError: error,
+      failedVersion: version ?? state.failedVersion,
+      failureCount: sameVersion ? (state.failureCount ?? 0) + 1 : 1
+    });
+    this.log(error);
+  }
+  /** 等待节点连续空闲后安装；`installMode` 立即安装 */
+  async installWhenIdle(version, stagedPath, installMode, ctx = {}) {
+    if (this.installing) return;
+    this.installing = true;
+    try {
+      if (!installMode) {
+        const idleMs = num("ZQAGENT_UPDATE_IDLE_MS", 60 * 1e3);
+        this.log(
+          `\u7B49\u5F85\u7A7A\u95F2\u540E\u5B89\u88C5 v${version}\uFF08\u9700\u8FDE\u7EED\u7A7A\u95F2 ${Math.round(idleMs / 1e3)}s${ctx.excludeSessionId ? "\uFF0C\u5DF2\u6392\u9664\u53D1\u8D77\u66F4\u65B0\u7684\u4F1A\u8BDD" : ""}\uFF09`
+        );
+        const ok = await this.waitForIdle(ctx);
+        if (!ok) {
+          this.installing = false;
+          return;
+        }
+      }
+      this.applyUpdate(version, stagedPath);
+    } catch (err) {
+      this.installing = false;
+      this.recordFailure(version, `\u5B89\u88C5\u5931\u8D25\uFF1A${err.message}`);
+    }
+  }
+  waitForIdle(ctx = {}) {
+    const requireUptime = ctx.requireUptime !== false;
+    const minUptime = requireUptime ? num("ZQAGENT_UPDATE_MIN_UPTIME_MS", 10 * 60 * 1e3) : 0;
+    const idleMs = num("ZQAGENT_UPDATE_IDLE_MS", 60 * 1e3);
+    let idleSince = null;
+    return new Promise((resolve2) => {
+      const timer = setInterval(() => {
+        if (this.stopped) {
+          clearInterval(timer);
+          resolve2(false);
+          return;
+        }
+        if (this.forceRequested) {
+          this.forceRequested = false;
+          clearInterval(timer);
+          resolve2(true);
+          return;
+        }
+        const ready = Date.now() - this.startedAt >= minUptime;
+        if (!ready || !this.opts.isIdle(ctx.excludeSessionId)) {
+          idleSince = null;
+          return;
+        }
+        idleSince ??= Date.now();
+        if (Date.now() - idleSince >= idleMs) {
+          clearInterval(timer);
+          resolve2(true);
+        }
+      }, 1e3);
+      timer.unref();
+    });
+  }
+  applyUpdate(version, stagedPath) {
+    this.opts.prepareExit?.();
+    const execPath = process.execPath;
+    installStaged({
+      dataDir: this.opts.dataDir,
+      execPath,
+      stagedPath,
+      version,
+      log: this.log
+    });
+    const verify2 = selfCheck(execPath, version);
+    if (!verify2.ok) {
+      const restored = rollback(this.opts.dataDir, execPath, this.log);
+      patchState(this.opts.dataDir, { skippedVersion: version });
+      this.recordFailure(
+        version,
+        `\u5B89\u88C5\u540E\u81EA\u68C0\u5931\u8D25\uFF08${verify2.error ?? "\u672A\u77E5\u9519\u8BEF"}\uFF09` + (restored ? `\uFF0C\u5DF2\u56DE\u6EDA\u5230 v${restored}` : "\uFF0C\u56DE\u6EDA\u5931\u8D25\uFF0C\u9700\u4EBA\u5DE5\u5904\u7406")
+      );
+      process.exit(1);
+    }
+    this.log(`\u5DF2\u5B89\u88C5 v${version}\uFF0C\u6B63\u5728\u91CD\u542F\u2026`);
+    process.exit(70);
+  }
+  /**
+   * 用备份回滚；返回恢复到的版本。
+   *
+   * 目标路径优先取上次安装记录的路径：`zqagent update --rollback` 可能由 node 进程执行
+   * （如 install.sh 内），此时 `process.execPath` 是 node 本身，绝不能拿它做替换。
+   */
+  rollbackNow() {
+    const state = loadState(this.opts.dataDir);
+    const target = state.installedExecPath ?? (isSeaRuntime() ? process.execPath : null);
+    if (!target) {
+      this.log("\u65E0\u6CD5\u786E\u5B9A\u8282\u70B9\u53EF\u6267\u884C\u6587\u4EF6\u4F4D\u7F6E\uFF08\u7F3A\u5C11\u5B89\u88C5\u8BB0\u5F55\uFF09\uFF1B\u8BF7\u7528 deploy/service/install.sh rollback");
+      return null;
+    }
+    return rollback(this.opts.dataDir, target, this.log);
+  }
+  status() {
+    const state = loadState(this.opts.dataDir);
+    const cap = selfUpdateCapability(Boolean(this.publicKey));
+    return {
+      enabled: !this.autoUpdateOff && cap.ok,
+      reason: cap.reason,
+      currentVersion: this.currentVersion,
+      channel: updaterChannel(),
+      manifestUrl: this.manifestUrl(),
+      serviceManager: serviceManager(),
+      lastCheckAt: this.lastCheckAt ?? state.lastCheckAt,
+      stagedVersion: state.stagedVersion,
+      pendingVersion: state.pendingVersion,
+      previousVersion: state.previousVersion,
+      backupVersion: state.backupVersion,
+      lastError: state.lastError
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UpdateController,
+  evaluateManifest,
+  updaterChannel,
+  updaterUrl
+});
+//# sourceMappingURL=controller.cjs.map