@mazjq/zhiro 0.0.0-stage → 0.1.2

package/dist/chunk-J2D7DYGW.js

@@ -0,0 +1,680 @@
+import {
+  VERSION
+} from "./chunk-NNH4ZG6F.js";
+import {
+  COUNTS_MAY_CHANGE,
+  MIGRATIONS,
+  SCHEMA_VERSION,
+  SchemaMismatch,
+  migrate,
+  openDb,
+  schemaOf
+} from "./chunk-5KCN32HQ.js";
+import {
+  configFile,
+  dbPath,
+  replaceConfig
+} from "./chunk-4JJEOOW2.js";
+import {
+  __name
+} from "./chunk-2SSYR7VW.js";
+
+// apps/daemon/src/upgrade.ts
+import { DatabaseSync } from "node:sqlite";
+import { createHash } from "node:crypto";
+import { closeSync, copyFileSync, existsSync, fsyncSync, lstatSync, openSync, readdirSync, readFileSync, readSync, renameSync, rmSync, statSync, statfsSync, writeSync } from "node:fs";
+import { join, relative } from "node:path";
+import YAML from "yaml";
+var UpgradeFailed = class extends Error {
+  static {
+    __name(this, "UpgradeFailed");
+  }
+  code = "UPGRADE_FAILED";
+};
+var KEPT = {
+  application: "1",
+  application_event: "1",
+  stage: "1",
+  fact: "1",
+  proposal: "1",
+  resume: "1",
+  document: "1",
+  deadline_override: "1",
+  company: "1",
+  position: "watch_priority is not null"
+};
+var userTables = /* @__PURE__ */ __name((db) => db.prepare("select name from sqlite_master where type = 'table' and name not like 'sqlite_%' and name <> 'schema_version' order by name").all().map((r) => r.name), "userTables");
+var columns = /* @__PURE__ */ __name((db, t) => db.prepare(`pragma table_info("${t}")`).all().map((c) => c.name), "columns");
+function digest(db, t, cols) {
+  const h = createHash("sha256");
+  const list = cols.map((c) => `"${c}"`).join(", ");
+  for (const r of db.prepare(`select ${list} from "${t}" where ${KEPT[t]} order by ${list}`).all()) h.update(JSON.stringify(cols.map((c) => r[c])));
+  return h.digest("hex");
+}
+__name(digest, "digest");
+function census(db, only) {
+  const counts2 = {}, digests = {};
+  for (const t of userTables(db)) counts2[t] = db.prepare(`select count(*) as n from "${t}"`).get().n;
+  for (const t of Object.keys(KEPT)) if (t in counts2) digests[t] = digest(db, t, only?.[t] ?? columns(db, t));
+  const structure = db.prepare("select type || ' ' || name as s from sqlite_master where name not like 'sqlite_%' order by s").all().map((r) => r.s);
+  return { counts: counts2, digests, structure };
+}
+__name(census, "census");
+function expectedStructure(migrations) {
+  const db = new DatabaseSync(":memory:");
+  try {
+    migrate(db, migrations);
+    return census(db).structure;
+  } finally {
+    db.close();
+  }
+}
+__name(expectedStructure, "expectedStructure");
+function compare(before, after, from, migrations) {
+  const problems = [];
+  const may = /* @__PURE__ */ new Set();
+  for (let v = from + 1; v <= migrations.length; v++) for (const t of COUNTS_MAY_CHANGE[v] ?? []) may.add(t);
+  const shared = {};
+  for (const t of Object.keys(KEPT)) {
+    const a2 = columns(after, t);
+    shared[t] = columns(before, t).filter((c) => a2.includes(c));
+  }
+  const b = census(before, shared), a = census(after, shared);
+  for (const [t, n] of Object.entries(b.counts)) {
+    if (may.has(t)) continue;
+    if (!(t in a.counts)) problems.push(`表 ${t} 不见了`);
+    else if (a.counts[t] !== n) problems.push(`表 ${t}：升级前 ${n} 行，升级后 ${a.counts[t]} 行`);
+  }
+  for (const [t, d] of Object.entries(b.digests)) if (!may.has(t) && a.digests[t] !== d) problems.push(`表 ${t} 的内容和升级前对不上`);
+  const want = expectedStructure(migrations);
+  const missing = want.filter((s) => !a.structure.includes(s)), extra = a.structure.filter((s) => !want.includes(s));
+  if (missing.length) problems.push(`缺少：${missing.join("、")}`);
+  if (extra.length) problems.push(`多出：${extra.join("、")}`);
+  const integrity = after.prepare("pragma integrity_check").all().map((r) => r.integrity_check);
+  if (integrity.join() !== "ok") problems.push(`完整性检查：${integrity.join("；").slice(0, 200)}`);
+  const fk = after.prepare("pragma foreign_key_check").all();
+  if (fk.length) problems.push(`${fk.length} 条外键指向不存在的行`);
+  return problems;
+}
+__name(compare, "compare");
+var journalPath = /* @__PURE__ */ __name((vault) => join(vault, "upgrade.json"), "journalPath");
+function writeDurable(path, text) {
+  const tmp = `${path}.tmp`;
+  const fd = openSync(tmp, "w");
+  try {
+    writeSync(fd, text, null, "utf8");
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  renameSync(tmp, path);
+}
+__name(writeDurable, "writeDurable");
+function recoverUpgrade(vault) {
+  const live = dbPath(vault);
+  let j = null;
+  try {
+    j = JSON.parse(readFileSync(journalPath(vault), "utf8"));
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw new UpgradeFailed(`升级记录 ${journalPath(vault)} 读不出来；数据没动，请把这个文件发给开发者，别删`);
+  }
+  const strays = /* @__PURE__ */ __name(() => {
+    for (const f of readdirSync(vault)) if (/^jobos\.db\.upgrade-[0-9a-z]+(-wal|-shm)?$/.test(f)) rmSync(join(vault, f), { force: true });
+  }, "strays");
+  if (!j) {
+    strays();
+    return "none";
+  }
+  const hasLive = existsSync(live), hasCand = existsSync(j.candidate), hasBackup = existsSync(j.backup);
+  let out;
+  if (hasLive && hasCand) out = "undone";
+  else if (!hasLive && hasCand && hasBackup) {
+    renameSync(j.candidate, live);
+    out = "finished";
+  } else if (hasLive && !hasCand) out = "finished";
+  else throw new UpgradeFailed(`升级在切换时中断，文件状态认不出来（数据库 ${hasLive ? "在" : "不在"}，升级副本 ${hasCand ? "在" : "不在"}，备份 ${hasBackup ? "在" : "不在"}）。备份 ${j.backup} 是升级前的原库，请不要删除任何文件`);
+  rmSync(journalPath(vault), { force: true });
+  strays();
+  return out;
+}
+__name(recoverUpgrade, "recoverUpgrade");
+var manifestOf = /* @__PURE__ */ __name((backup) => backup.replace(/\.db$/, ".json"), "manifestOf");
+function sha256(path) {
+  const h = createHash("sha256"), fd = openSync(path, "r"), buf = Buffer.alloc(1 << 20);
+  try {
+    let n;
+    while ((n = readSync(fd, buf, 0, buf.length, null)) > 0) h.update(buf.subarray(0, n));
+  } finally {
+    closeSync(fd);
+  }
+  return h.digest("hex");
+}
+__name(sha256, "sha256");
+function appOf(db) {
+  try {
+    return db.prepare("select value from meta where key = 'app_version'").get()?.value ?? "";
+  } catch {
+    return "";
+  }
+}
+__name(appOf, "appOf");
+var PRE = /^pre-v(\d+)-v(\d+)-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.db$/;
+function stalePreUpgrade(names) {
+  const ours = names.filter((f) => PRE.test(f)).sort((a, b) => PRE.exec(a)[3].localeCompare(PRE.exec(b)[3]));
+  return ours.slice(1, Math.max(1, ours.length - 3));
+}
+__name(stalePreUpgrade, "stalePreUpgrade");
+var preUpgradeBackups = /* @__PURE__ */ __name((vault) => {
+  try {
+    return readdirSync(join(vault, "backups")).filter((f) => PRE.test(f)).sort((a, b) => PRE.exec(b)[3].localeCompare(PRE.exec(a)[3]));
+  } catch {
+    return [];
+  }
+}, "preUpgradeBackups");
+function upgradeVault(vault, _lock, opts = {}) {
+  const migrations = opts.migrations ?? MIGRATIONS;
+  const target = migrations.length;
+  const log = opts.log ?? (() => {
+  });
+  recoverUpgrade(vault);
+  const live = dbPath(vault);
+  const have = schemaOf(live);
+  if (have === 0 || have === target) return null;
+  if (have > target) throw new SchemaMismatch("TOO_NEW", have, tooNewMessage(vault, have, target));
+  const t0 = Date.now();
+  const size = statSync(live).size + (existsSync(live + "-wal") ? statSync(live + "-wal").size : 0);
+  const fs = statfsSync(vault);
+  if (fs.bavail * fs.bsize < size * 2) throw new UpgradeFailed(`升级要先复制一份数据库，磁盘空间不够（需要约 ${(size * 2 / 1e9).toFixed(1)} GB）。数据没动；腾出空间后再启动`);
+  const id = Date.now().toString(36);
+  const candidate = `${live}.upgrade-${id}`;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backup = join(vault, "backups", `pre-v${have}-v${target}-${stamp}.db`);
+  let before, fromApp;
+  log(`升级数据库 v${have} → v${target}：先复制一份（原库不动）…`);
+  const src = new DatabaseSync(live);
+  try {
+    src.exec("pragma wal_checkpoint(TRUNCATE)");
+    fromApp = appOf(src);
+    src.exec(`vacuum into '${candidate.replace(/'/g, "''")}'`);
+  } catch (e) {
+    src.close();
+    rmSync(candidate, { force: true });
+    throw new UpgradeFailed(`复制数据库失败：${e?.message ?? e}。数据没动`);
+  }
+  src.close();
+  try {
+    opts.failAfterCopy?.();
+    const cand = new DatabaseSync(candidate);
+    const orig = new DatabaseSync(live, { readOnly: true });
+    try {
+      cand.exec("pragma foreign_keys = on");
+      log("在副本上升级…");
+      migrate(cand, migrations);
+      log("核对…");
+      const problems = compare(orig, cand, have, migrations);
+      if (problems.length) throw new UpgradeFailed(`升级后的副本没通过核对：${problems.join("；")}`);
+      before = census(orig);
+      cand.prepare("insert into upgrade_log(at, from_v, to_v, app_version, backup) values (?,?,?,?,?)").run((/* @__PURE__ */ new Date()).toISOString(), have, target, VERSION, relative(vault, backup));
+      cand.prepare("insert into meta(key, value) values ('app_version', ?) on conflict(key) do update set value = excluded.value").run(VERSION);
+      cand.exec("pragma wal_checkpoint(TRUNCATE)");
+    } finally {
+      orig.close();
+      cand.close();
+    }
+  } catch (e) {
+    for (const s of ["", "-wal", "-shm"]) rmSync(candidate + s, { force: true });
+    if (e instanceof UpgradeFailed) throw e;
+    throw new UpgradeFailed(`升级到 v${target} 失败：${String(e?.message ?? e).slice(0, 300)}。数据没动，原库照旧`);
+  }
+  if (existsSync(live + "-wal") && statSync(live + "-wal").size > 0) {
+    for (const s of ["", "-wal", "-shm"]) rmSync(candidate + s, { force: true });
+    throw new UpgradeFailed("原库还有没并进去的写入（别的进程在写？），这次不升级，数据没动");
+  }
+  const manifest = { kind: "pre-upgrade", fromSchema: have, toSchema: target, fromApp, toApp: VERSION, sha256: sha256(live), bytes: statSync(live).size, counts: before.counts, at: (/* @__PURE__ */ new Date()).toISOString() };
+  writeDurable(manifestOf(backup), JSON.stringify(manifest, null, 2));
+  writeDurable(journalPath(vault), JSON.stringify({ id, candidate, backup, at: (/* @__PURE__ */ new Date()).toISOString() }));
+  for (const s of ["-wal", "-shm"]) rmSync(live + s, { force: true });
+  renameSync(live, backup);
+  renameSync(candidate, live);
+  rmSync(journalPath(vault), { force: true });
+  for (const f of stalePreUpgrade(preUpgradeBackups(vault))) {
+    rmSync(join(vault, "backups", f), { force: true });
+    rmSync(join(vault, "backups", manifestOf(f)), { force: true });
+  }
+  const ms = Date.now() - t0;
+  log(`升级完成（${(ms / 1e3).toFixed(1)} 秒）。升级前的库在 ${backup}`);
+  return { from: have, to: target, backup, ms };
+}
+__name(upgradeVault, "upgradeVault");
+function tooNewMessage(vault, have, target) {
+  let app = "";
+  try {
+    const db = new DatabaseSync(dbPath(vault), { readOnly: true });
+    try {
+      app = appOf(db);
+    } finally {
+      db.close();
+    }
+  } catch {
+  }
+  return `数据是更新的版本${app ? `（${app}）` : ""}写的：数据库 v${have}，这个程序（${VERSION}）只认到 v${target}。请装${app ? ` ${app} 或更新的版本` : "新版本"}；要用这个旧版本，先运行 \`zhiro vault rollback\` 回到升级前`;
+}
+__name(tooNewMessage, "tooNewMessage");
+function stampApp(db) {
+  db.prepare("insert into meta(key, value) values ('app_version', ?) on conflict(key) do update set value = excluded.value").run(VERSION);
+}
+__name(stampApp, "stampApp");
+function verifyVault(vault, opts = {}) {
+  const live = dbPath(vault), problems = [];
+  if (!existsSync(vault)) throw new Error(`数据目录不存在：${vault}`);
+  if (!existsSync(live)) return { ok: false, schema: 0, program: SCHEMA_VERSION, problems: [`没有数据库：${live}`], counts: {} };
+  let schema = 0;
+  try {
+    schema = schemaOf(live);
+  } catch (e) {
+    return { ok: false, schema: 0, program: SCHEMA_VERSION, problems: [String(e?.message ?? e)], counts: {} };
+  }
+  if (schema > SCHEMA_VERSION) problems.push(`数据库 v${schema} 比这个程序（v${SCHEMA_VERSION}）新`);
+  if (schema < SCHEMA_VERSION) problems.push(`数据库 v${schema} 还没升级到 v${SCHEMA_VERSION}（启动一次就会升级）`);
+  const db = new DatabaseSync(live, { readOnly: true });
+  let counts2 = {};
+  try {
+    db.exec("pragma busy_timeout = 5000; begin");
+    const c = census(db);
+    counts2 = c.counts;
+    const check = db.prepare(opts.quick ? "pragma quick_check" : "pragma integrity_check").all().map((r) => Object.values(r)[0]);
+    if (check.join() !== "ok") problems.push(`完整性检查：${check.join("；").slice(0, 200)}`);
+    const fk = db.prepare("pragma foreign_key_check").all();
+    if (fk.length) problems.push(`${fk.length} 条外键指向不存在的行`);
+    if (schema === SCHEMA_VERSION) {
+      const want = expectedStructure(MIGRATIONS);
+      const missing = want.filter((s) => !c.structure.includes(s));
+      if (missing.length) problems.push(`缺少：${missing.join("、")}`);
+    }
+    db.exec("commit");
+  } finally {
+    db.close();
+  }
+  const cfg = join(vault, "config", "jobos.yaml");
+  if (existsSync(cfg)) {
+    try {
+      YAML.parse(readFileSync(cfg, "utf8"));
+    } catch (e) {
+      problems.push(`配置文件读不出来：${String(e?.message ?? e).slice(0, 120)}`);
+    }
+  }
+  return { ok: problems.length === 0, schema, program: SCHEMA_VERSION, problems, counts: counts2 };
+}
+__name(verifyVault, "verifyVault");
+function rollbackVault(vault, _lock, file) {
+  const name = file ?? preUpgradeBackups(vault)[0];
+  if (!name) throw new Error("没有升级前的备份（backups/pre-v*.db），无从回退");
+  const backup = name.includes("/") || name.includes("\\") ? name : join(vault, "backups", name);
+  if (!existsSync(backup)) throw new Error(`找不到备份：${backup}`);
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestOf(backup), "utf8"));
+  } catch {
+    throw new Error(`备份旁边没有清单（${manifestOf(backup)}），不能确认它是完整的，不回退`);
+  }
+  if (sha256(backup) !== manifest.sha256) throw new Error("备份文件和它的清单对不上（文件被改过或损坏），不回退");
+  const probe = new DatabaseSync(backup, { readOnly: true });
+  try {
+    const r = probe.prepare("pragma integrity_check").all();
+    if (r.map((x) => x.integrity_check).join() !== "ok") throw new Error("备份没通过完整性检查，不回退");
+  } finally {
+    probe.close();
+  }
+  const live = dbPath(vault);
+  const kept = join(vault, "backups", `jobos.db.before-rollback-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`);
+  if (existsSync(live)) {
+    const cur = new DatabaseSync(live);
+    try {
+      cur.exec("pragma wal_checkpoint(TRUNCATE)");
+    } finally {
+      cur.close();
+    }
+    for (const s of ["-wal", "-shm"]) rmSync(live + s, { force: true });
+    renameSync(live, kept);
+  }
+  copyFileSync(backup, live + ".rollback");
+  renameSync(live + ".rollback", live);
+  return { restored: backup, kept, manifest };
+}
+__name(rollbackVault, "rollbackVault");
+
+// apps/daemon/src/service/export.ts
+import { DatabaseSync as DatabaseSync2 } from "node:sqlite";
+import { existsSync as existsSync2, lstatSync as lstatSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, renameSync as renameSync2, rmSync as rmSync2, statSync as statSync2, writeFileSync, copyFileSync as copyFileSync2 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { isAbsolute, join as join2, relative as relative2, resolve } from "node:path";
+import YAML2 from "yaml";
+
+// apps/daemon/src/service/zip.ts
+import { deflateRawSync, inflateRawSync } from "node:zlib";
+var TABLE = (() => {
+  const t = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    t[n] = c >>> 0;
+  }
+  return t;
+})();
+function crc32(buf) {
+  let c = 4294967295;
+  for (let i = 0; i < buf.length; i++) c = TABLE[(c ^ buf[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+__name(crc32, "crc32");
+function dosTime(d) {
+  return { time: (d.getHours() & 31) << 11 | (d.getMinutes() & 63) << 5 | d.getSeconds() >> 1 & 31, date: (d.getFullYear() - 1980 & 127) << 9 | (d.getMonth() + 1 & 15) << 5 | d.getDate() & 31 };
+}
+__name(dosTime, "dosTime");
+function zipWrite(entries) {
+  if (entries.length > 65e3) throw new Error("ZIP_TOO_MANY: 文件超过 65,000 个");
+  const parts = [], central = [];
+  let offset = 0;
+  for (const e of entries) {
+    const name = Buffer.from(e.name.replace(/\\/g, "/"), "utf8");
+    const comp = deflateRawSync(e.data), store = comp.length >= e.data.length;
+    const body = store ? e.data : comp, method = store ? 0 : 8, crc = crc32(e.data), { time, date } = dosTime(e.mtime ?? /* @__PURE__ */ new Date());
+    const local = Buffer.alloc(30);
+    local.writeUInt32LE(67324752, 0);
+    local.writeUInt16LE(20, 4);
+    local.writeUInt16LE(2048, 6);
+    local.writeUInt16LE(method, 8);
+    local.writeUInt16LE(time, 10);
+    local.writeUInt16LE(date, 12);
+    local.writeUInt32LE(crc, 14);
+    local.writeUInt32LE(body.length, 18);
+    local.writeUInt32LE(e.data.length, 22);
+    local.writeUInt16LE(name.length, 26);
+    local.writeUInt16LE(0, 28);
+    const cd = Buffer.alloc(46);
+    cd.writeUInt32LE(33639248, 0);
+    cd.writeUInt16LE(20, 4);
+    cd.writeUInt16LE(20, 6);
+    cd.writeUInt16LE(2048, 8);
+    cd.writeUInt16LE(method, 10);
+    cd.writeUInt16LE(time, 12);
+    cd.writeUInt16LE(date, 14);
+    cd.writeUInt32LE(crc, 16);
+    cd.writeUInt32LE(body.length, 20);
+    cd.writeUInt32LE(e.data.length, 24);
+    cd.writeUInt16LE(name.length, 28);
+    cd.writeUInt16LE(0, 30);
+    cd.writeUInt16LE(0, 32);
+    cd.writeUInt16LE(0, 34);
+    cd.writeUInt16LE(0, 36);
+    cd.writeUInt32LE(0, 38);
+    cd.writeUInt32LE(offset, 42);
+    parts.push(local, name, body);
+    central.push(cd, name);
+    offset += local.length + name.length + body.length;
+  }
+  const cdSize = central.reduce((a, b) => a + b.length, 0);
+  const end = Buffer.alloc(22);
+  end.writeUInt32LE(101010256, 0);
+  end.writeUInt16LE(0, 4);
+  end.writeUInt16LE(0, 6);
+  end.writeUInt16LE(entries.length, 8);
+  end.writeUInt16LE(entries.length, 10);
+  end.writeUInt32LE(cdSize, 12);
+  end.writeUInt32LE(offset, 16);
+  end.writeUInt16LE(0, 20);
+  if (offset + cdSize + 22 > 4294967295) throw new Error("ZIP_TOO_BIG: 超过 4 GB");
+  return Buffer.concat([...parts, ...central, end]);
+}
+__name(zipWrite, "zipWrite");
+function zipRead(buf) {
+  let eocd = -1;
+  for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65557); i--) if (buf.readUInt32LE(i) === 101010256) {
+    eocd = i;
+    break;
+  }
+  if (eocd < 0) throw new Error("ZIP_BAD: 不是 zip 文件");
+  const count = buf.readUInt16LE(eocd + 10), cdOffset = buf.readUInt32LE(eocd + 16);
+  const out = [];
+  let p = cdOffset;
+  for (let i = 0; i < count; i++) {
+    if (buf.readUInt32LE(p) !== 33639248) throw new Error("ZIP_BAD: 目录损坏");
+    const method = buf.readUInt16LE(p + 10), crc = buf.readUInt32LE(p + 16), csize = buf.readUInt32LE(p + 20), usize = buf.readUInt32LE(p + 24);
+    const nlen = buf.readUInt16LE(p + 28), xlen = buf.readUInt16LE(p + 30), clen = buf.readUInt16LE(p + 32), local = buf.readUInt32LE(p + 42);
+    const name = buf.subarray(p + 46, p + 46 + nlen).toString("utf8");
+    p += 46 + nlen + xlen + clen;
+    if (buf.readUInt32LE(local) !== 67324752) throw new Error("ZIP_BAD: 条目损坏");
+    const dataStart = local + 30 + buf.readUInt16LE(local + 26) + buf.readUInt16LE(local + 28);
+    const body = buf.subarray(dataStart, dataStart + csize);
+    const data = method === 8 ? inflateRawSync(body) : method === 0 ? Buffer.from(body) : (() => {
+      throw new Error(`ZIP_BAD: 不支持的压缩方式 ${method}`);
+    })();
+    if (data.length !== usize || crc32(data) !== crc) throw new Error(`ZIP_BAD: ${name} 校验失败`);
+    out.push({ name, data });
+  }
+  return out;
+}
+__name(zipRead, "zipRead");
+
+// apps/daemon/src/service/export.ts
+var FORMAT = 1;
+var FILE_DIRS = ["research", "resume", "profile", "captures", "snapshots", "submissions"];
+var SECRET_KEY = /secret|password|token|webhook|cookie|apikey|api_key/i;
+var COUNTED = ["company", "campaign", "position", "application", "fact", "proposal", "agent_action"];
+function counts(db) {
+  const out = {};
+  for (const t of COUNTED) {
+    try {
+      out[t] = db.prepare(`select count(*) as n from ${t}`).get().n;
+    } catch {
+    }
+  }
+  return out;
+}
+__name(counts, "counts");
+function redact(v) {
+  if (Array.isArray(v)) return v.map(redact);
+  if (v && typeof v === "object") {
+    const o = {};
+    for (const [k, x] of Object.entries(v)) o[k] = SECRET_KEY.test(k) ? "" : redact(x);
+    return o;
+  }
+  return v;
+}
+__name(redact, "redact");
+function walk(vault) {
+  const out = [];
+  const visit = /* @__PURE__ */ __name((abs, rel) => {
+    const st = lstatSync2(abs);
+    if (st.isSymbolicLink()) return;
+    if (st.isDirectory()) {
+      for (const n of readdirSync2(abs)) visit(join2(abs, n), rel ? `${rel}/${n}` : n);
+    } else if (st.isFile()) out.push({ rel, abs });
+  }, "visit");
+  for (const d of FILE_DIRS) if (existsSync2(join2(vault, d))) visit(join2(vault, d), d);
+  return out;
+}
+__name(walk, "walk");
+var realOf = /* @__PURE__ */ __name((p) => {
+  try {
+    return realpathSync(p);
+  } catch {
+    const up = resolve(p, "..");
+    return up === resolve(p) ? up : join2(realOf(up), relative2(up, resolve(p)));
+  }
+}, "realOf");
+var inside = /* @__PURE__ */ __name((dir, p) => {
+  const r = relative2(realOf(dir), realOf(p));
+  return r === "" || !r.startsWith("..") && !isAbsolute(r);
+}, "inside");
+function snapshotDb(db, to) {
+  rmSync2(to, { force: true });
+  db.exec(`vacuum into '${to.replace(/'/g, "''")}'`);
+  const copy = new DatabaseSync2(to, { readOnly: true });
+  try {
+    const r = copy.prepare("pragma integrity_check").all();
+    if (r.length !== 1 || r[0].integrity_check !== "ok") throw new Error(`SNAPSHOT_BAD: ${r.map((x) => x.integrity_check).join("; ").slice(0, 200)}`);
+  } finally {
+    copy.close();
+  }
+}
+__name(snapshotDb, "snapshotDb");
+function exportVault(db, vault, to) {
+  if (!/\.zip$/i.test(to)) throw new Error("BAD_PATH: 导出文件名要以 .zip 结尾");
+  if (inside(vault, to)) throw new Error("BAD_PATH: 不能导出到数据目录里面");
+  if (existsSync2(to)) throw new Error("EXISTS: 已有同名文件，换个名字");
+  mkdirSync(join2(vault, "backups"), { recursive: true });
+  const snap = join2(vault, "backups", `export-${Date.now()}.db`);
+  snapshotDb(db, snap);
+  try {
+    const dbBuf = readFileSync2(snap);
+    const schemaVersion = db.prepare("select max(v) as v from schema_version").get().v ?? 0;
+    const files = walk(vault);
+    const entries = [{ name: "jobos.db", data: dbBuf }];
+    const cfg = join2(vault, "config", "jobos.yaml");
+    if (existsSync2(cfg)) entries.push({ name: "config/jobos.yaml", data: Buffer.from(YAML2.stringify(redact(YAML2.parse(readFileSync2(cfg, "utf8")) ?? {})), "utf8") });
+    for (const f of files) entries.push({ name: `files/${f.rel}`, data: readFileSync2(f.abs), mtime: statSync2(f.abs).mtime });
+    const manifest = { format: FORMAT, exportedAt: (/* @__PURE__ */ new Date()).toISOString(), schemaVersion, counts: counts(db), files: files.length, dbSha256: createHash2("sha256").update(dbBuf).digest("hex") };
+    entries.unshift({ name: "manifest.json", data: Buffer.from(JSON.stringify(manifest, null, 2), "utf8") });
+    const zip = zipWrite(entries);
+    mkdirSync(resolve(to, ".."), { recursive: true });
+    writeFileSync(to + ".part", zip);
+    renameSync2(to + ".part", to);
+    return { path: to, bytes: zip.length, manifest };
+  } finally {
+    rmSync2(snap, { force: true });
+  }
+}
+__name(exportVault, "exportVault");
+function importVault(vault, from, lock) {
+  const entries = zipRead(readFileSync2(from));
+  const byName = new Map(entries.map((e) => [e.name, e]));
+  const mf = byName.get("manifest.json"), dbe = byName.get("jobos.db");
+  if (!mf || !dbe) throw new Error("NOT_EXPORT: 这不是 Zhiro 导出的 zip（缺 manifest.json 或 jobos.db）");
+  const manifest = JSON.parse(mf.data.toString("utf8"));
+  if (manifest.format !== FORMAT) throw new Error(`FORMAT: 导出格式 ${manifest.format}，这个版本只认 ${FORMAT}`);
+  if (createHash2("sha256").update(dbe.data).digest("hex") !== manifest.dbSha256) throw new Error("CORRUPT: 数据库与清单的校验和不符");
+  for (const e of entries) if (/(^|\/)\.\.(\/|$)|^[A-Za-z]:|^\//.test(e.name)) throw new Error(`CORRUPT: 路径不对 ${e.name}`);
+  mkdirSync(join2(vault, "backups"), { recursive: true });
+  mkdirSync(join2(vault, "config"), { recursive: true });
+  const incoming = join2(vault, "backups", `import-${Date.now()}.db`);
+  writeFileSync(incoming, dbe.data);
+  const probe = new DatabaseSync2(incoming, { readOnly: true });
+  try {
+    const r = probe.prepare("pragma integrity_check").all();
+    if (r.length !== 1 || r[0].integrity_check !== "ok") throw new Error("CORRUPT: 导出里的数据库没通过完整性检查");
+  } finally {
+    probe.close();
+  }
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backup = join2(vault, "backups", `pre-import-${stamp}.db`);
+  const dbPath2 = join2(vault, "jobos.db");
+  let before = {};
+  if (existsSync2(dbPath2)) {
+    const cur = new DatabaseSync2(dbPath2, { readOnly: true });
+    try {
+      before = counts(cur);
+      snapshotDb(cur, backup);
+    } finally {
+      cur.close();
+    }
+  }
+  const cfg = join2(vault, "config", "jobos.yaml");
+  if (existsSync2(cfg)) copyFileSync2(cfg, join2(vault, "backups", `pre-import-${stamp}.yaml`));
+  for (const s of ["", "-wal", "-shm"]) rmSync2(dbPath2 + s, { force: true });
+  renameSync2(incoming, dbPath2);
+  let files = 0;
+  for (const e of entries) {
+    if (!e.name.startsWith("files/")) continue;
+    const p = join2(vault, e.name.slice(6));
+    mkdirSync(resolve(p, ".."), { recursive: true });
+    writeFileSync(p, e.data);
+    files++;
+  }
+  const cfge = byName.get("config/jobos.yaml");
+  if (cfge) {
+    const incomingCfg = YAML2.parse(cfge.data.toString("utf8")) ?? {};
+    const current = existsSync2(cfg) ? YAML2.parse(readFileSync2(cfg, "utf8")) ?? {} : {};
+    const keepSecrets = /* @__PURE__ */ __name((into, from2) => {
+      if (!from2 || typeof from2 !== "object") return;
+      for (const [k, v] of Object.entries(from2)) {
+        if (SECRET_KEY.test(k) && v && !into?.[k]) into[k] = v;
+        else if (v && typeof v === "object" && !Array.isArray(v) && into?.[k] && typeof into[k] === "object") keepSecrets(into[k], v);
+      }
+    }, "keepSecrets");
+    keepSecrets(incomingCfg, current);
+    replaceConfig(vault, incomingCfg);
+  }
+  upgradeVault(vault, lock);
+  const db = openDb(dbPath2);
+  try {
+    const after = counts(db);
+    const schemaVersion = db.prepare("select max(v) as v from schema_version").get().v ?? 0;
+    return { backup, before, after, files, schemaVersion };
+  } finally {
+    db.close();
+  }
+}
+__name(importVault, "importVault");
+var defaultExportPath = /* @__PURE__ */ __name(() => {
+  const d = /* @__PURE__ */ new Date();
+  return join2(process.env.USERPROFILE ?? process.env.HOME ?? ".", "Downloads", `Zhiro-${d.toISOString().slice(0, 10)}-${String(d.getHours()).padStart(2, "0")}${String(d.getMinutes()).padStart(2, "0")}.zip`);
+}, "defaultExportPath");
+
+// apps/daemon/src/service/backup.ts
+import { DatabaseSync as DatabaseSync3 } from "node:sqlite";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync3, statSync as statSync3, readdirSync as readdirSync3, rmSync as rmSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+import YAML3 from "yaml";
+var OWN = /^jobos-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z\.db$/;
+var takenAt = /* @__PURE__ */ __name((f) => Date.parse(f.slice(6, 16) + "T" + f.slice(17, 25).replace(/-/g, ":") + "." + f.slice(26, 29) + "Z"), "takenAt");
+function staleBackups(names, now = Date.now(), keep = 5) {
+  const rest = names.filter((f) => OWN.test(f)).sort().reverse().slice(keep);
+  const older = rest.find((f) => now - takenAt(f) >= 7 * 864e5);
+  return rest.filter((f) => f !== older);
+}
+__name(staleBackups, "staleBackups");
+var pairOf = /* @__PURE__ */ __name((db) => db.replace(/\.db$/, ".yaml"), "pairOf");
+function runBackup(db, vault) {
+  const dir = join3(vault, "backups");
+  mkdirSync2(dir, { recursive: true });
+  const path = join3(dir, `jobos-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}.db`);
+  const cfg = configFile(vault);
+  const config = existsSync3(cfg) ? pairOf(path) : "";
+  try {
+    snapshotDb(db, path);
+    const copy = new DatabaseSync3(path, { readOnly: true });
+    let same;
+    try {
+      same = JSON.stringify(counts(copy)) === JSON.stringify(counts(db));
+    } finally {
+      copy.close();
+    }
+    if (!same) throw new Error("BACKUP_BAD: 备份里的条数和库里对不上（备份期间库被写入了？），再跑一次");
+    if (config) writeFileSync2(config, YAML3.stringify(redact(YAML3.parse(readFileSync3(cfg, "utf8")) ?? {})), "utf8");
+  } catch (e) {
+    rmSync3(path, { force: true });
+    if (config) rmSync3(config, { force: true });
+    throw e;
+  }
+  for (const f of staleBackups(readdirSync3(dir))) {
+    rmSync3(join3(dir, f), { force: true });
+    rmSync3(join3(dir, pairOf(f)), { force: true });
+  }
+  return { path, bytes: statSync3(path).size, verified: true, config };
+}
+__name(runBackup, "runBackup");
+
+export {
+  UpgradeFailed,
+  preUpgradeBackups,
+  upgradeVault,
+  stampApp,
+  verifyVault,
+  rollbackVault,
+  zipRead,
+  exportVault,
+  importVault,
+  defaultExportPath,
+  runBackup
+};