@mazjq/zhiro 0.0.0-stage → 0.1.2

package/dist/chunk-2SSYR7VW.js

@@ -0,0 +1,558 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// apps/daemon/src/lock.ts
+import net from "node:net";
+import { createHash } from "node:crypto";
+import { realpathSync, rmSync } from "node:fs";
+import { join } from "node:path";
+var VaultBusy = class extends Error {
+  constructor(holder, vault) {
+    super(`数据目录已被${holder || "另一个 Zhiro 进程"}占用：${vault}`);
+    this.holder = holder;
+  }
+  holder;
+  static {
+    __name(this, "VaultBusy");
+  }
+  code = "VAULT_BUSY";
+};
+function endpoint(vault) {
+  let dir = vault;
+  try {
+    dir = realpathSync(vault);
+  } catch {
+  }
+  const key = createHash("sha256").update(process.platform === "win32" ? dir.toLowerCase() : dir).digest("hex").slice(0, 24);
+  return process.platform === "win32" ? `\\\\.\\pipe\\jobos-${key}` : join("/tmp", `jobos-${key}.sock`);
+}
+__name(endpoint, "endpoint");
+function holderOf(path) {
+  return new Promise((done) => {
+    const c = net.connect(path);
+    let said = "";
+    c.setEncoding("utf8");
+    c.on("data", (d) => said += d);
+    c.on("end", () => done(said.trim()));
+    c.on("error", () => done(null));
+    setTimeout(() => {
+      c.destroy();
+      done(said.trim() || null);
+    }, 1500).unref();
+  });
+}
+__name(holderOf, "holderOf");
+async function lockVault(vault, who) {
+  const path = endpoint(vault);
+  const label = `${who}（进程 ${process.pid}）`;
+  for (let attempt = 0; attempt < 2; attempt++) {
+    const server = net.createServer((c) => {
+      c.on("error", () => {
+      });
+      c.end(label);
+    });
+    const got = await new Promise((done) => {
+      server.once("error", done);
+      server.listen(path, () => done(null));
+    });
+    if (!got) {
+      server.unref();
+      return { release: /* @__PURE__ */ __name(() => new Promise((done) => server.close(() => done())), "release") };
+    }
+    if (got.code !== "EADDRINUSE") throw got;
+    const holder = await holderOf(path);
+    if (holder !== null) throw new VaultBusy(holder, vault);
+    if (process.platform === "win32") throw new VaultBusy("", vault);
+    rmSync(path, { force: true });
+  }
+  throw new VaultBusy("", vault);
+}
+__name(lockVault, "lockVault");
+
+// apps/daemon/src/move.ts
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import { execFile, execFileSync } from "node:child_process";
+import { DatabaseSync } from "node:sqlite";
+import { closeSync, copyFileSync, existsSync, lstatSync, utimesSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync as realpathSync2, renameSync, rmSync as rmSync2, rmdirSync, statSync, statfsSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { readdir, stat } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join as join2, relative, resolve } from "node:path";
+var VaultUnavailable = class extends Error {
+  static {
+    __name(this, "VaultUnavailable");
+  }
+  code = "VAULT_UNAVAILABLE";
+};
+var logPath = /* @__PURE__ */ __name((entry) => `${resolve(entry)}.move.json`, "logPath");
+var mark = /* @__PURE__ */ __name((log) => join2(log.to, `.jobos-move-${log.id}`), "mark");
+var probeName = /* @__PURE__ */ __name((log) => `${resolve(log.entry)}.moving-${log.id}`, "probeName");
+var norm = /* @__PURE__ */ __name((p) => process.platform === "win32" ? resolve(p).toLowerCase() : resolve(p), "norm");
+var same = /* @__PURE__ */ __name((a, b) => norm(a) === norm(b), "same");
+var within = /* @__PURE__ */ __name((dir, p) => {
+  const r = relative(norm(dir), norm(p));
+  return r === "" || !r.startsWith("..") && !isAbsolute(r);
+}, "within");
+var isLink = /* @__PURE__ */ __name((p) => {
+  try {
+    return lstatSync(p).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}, "isLink");
+var dropLink = /* @__PURE__ */ __name((p) => process.platform === "win32" ? rmSync2(p) : unlinkSync(p), "dropLink");
+var real = /* @__PURE__ */ __name((p) => {
+  try {
+    return realpathSync2(p);
+  } catch {
+    return resolve(p);
+  }
+}, "real");
+var gb = /* @__PURE__ */ __name((n) => `${(n / 1e9).toFixed(1)} GB`, "gb");
+var codeOf = /* @__PURE__ */ __name((e) => String(e?.code ?? e?.message ?? e).split("\n")[0].slice(0, 120), "codeOf");
+function readLog(entry) {
+  let text;
+  try {
+    text = readFileSync(logPath(entry), "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new VaultUnavailable(`搬数据的记录读不出来：${logPath(entry)}。它记着数据现在在哪，Zhiro 不会在读不出来的时候猜`);
+  }
+}
+__name(readLog, "readLog");
+function writeLog(entry, log) {
+  const p = logPath(entry), next = { ...log, at: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(p + ".tmp", JSON.stringify(next, null, 2), "utf8");
+  renameSync(p + ".tmp", p);
+  return next;
+}
+__name(writeLog, "writeLog");
+function files(root) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = /* @__PURE__ */ __name((dir, rel) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) walk(join2(dir, e.name), r);
+      else out.set(r, e.isFile() ? statSync(join2(dir, e.name)).size : -1);
+    }
+  }, "walk");
+  walk(root, "");
+  return out;
+}
+__name(files, "files");
+function copyTree(from, to) {
+  mkdirSync(to, { recursive: true });
+  for (const e of readdirSync(from, { withFileTypes: true })) {
+    const a = join2(from, e.name), b = join2(to, e.name);
+    if (e.isDirectory()) copyTree(a, b);
+    else if (e.isFile()) {
+      copyFileSync(a, b);
+      const st = statSync(a);
+      utimesSync(b, st.atime, st.mtime);
+    } else throw new Error(`数据文件夹里有一个不是普通文件的东西，没法照原样复制：${a}`);
+  }
+}
+__name(copyTree, "copyTree");
+function dirSize(root) {
+  let n = 0;
+  try {
+    for (const s of files(root).values()) if (s > 0) n += s;
+  } catch {
+  }
+  return n;
+}
+__name(dirSize, "dirSize");
+function sha(path) {
+  const h = createHash2("sha256"), buf = Buffer.allocUnsafe(1 << 22), fd = openSync(path, "r");
+  try {
+    for (let n; (n = readSync(fd, buf, 0, buf.length, null)) > 0; ) h.update(buf.subarray(0, n));
+  } finally {
+    closeSync(fd);
+  }
+  return h.digest("hex");
+}
+__name(sha, "sha");
+var DRIVES_PS = "Get-Partition | Where-Object DriveLetter | ForEach-Object { $v = Get-Volume -Partition $_; [pscustomobject]@{ letter = [string]$_.DriveLetter; bus = [string](Get-Disk -Number $_.DiskNumber).BusType; fs = [string]$v.FileSystemType; free = [double]$v.SizeRemaining; label = [string]$v.FileSystemLabel } } | ConvertTo-Json -Compress";
+var DRIVES_ARGS = ["-NoProfile", "-NonInteractive", "-Command", DRIVES_PS];
+var parseDrives = /* @__PURE__ */ __name((out) => [JSON.parse(out)].flat().filter((d) => d.fs === "NTFS" && d.bus !== "USB").map((d) => ({ root: `${d.letter}:\\`, label: d.label ?? "", freeBytes: Number(d.free) || 0 })).sort((x, y) => x.root.localeCompare(y.root)), "parseDrives");
+function drives() {
+  if (process.platform !== "win32") return [];
+  try {
+    return parseDrives(execFileSync("powershell", DRIVES_ARGS, { encoding: "utf8", timeout: 2e4, windowsHide: true }));
+  } catch {
+    return [];
+  }
+}
+__name(drives, "drives");
+var drivesLater = /* @__PURE__ */ __name(() => new Promise((done) => {
+  if (process.platform !== "win32") return done([]);
+  execFile("powershell", DRIVES_ARGS, { encoding: "utf8", timeout: 2e4, windowsHide: true }, (err, out) => {
+    try {
+      done(err ? [] : parseDrives(out));
+    } catch {
+      done([]);
+    }
+  });
+}), "drivesLater");
+async function sizeLater(root) {
+  let n = 0;
+  try {
+    const all = (await readdir(root, { recursive: true, withFileTypes: true })).filter((e) => e.isFile());
+    for (let i = 0; i < all.length; i += 256) for (const s of await Promise.all(all.slice(i, i + 256).map((e) => stat(join2(e.parentPath, e.name)).then((x) => x.size, () => 0)))) n += s;
+  } catch {
+  }
+  return n;
+}
+__name(sizeLater, "sizeLater");
+function checkTarget(entry, to, need, ok = drives()) {
+  if (!isAbsolute(to)) return "要写完整路径，例如 E:\\Zhiro数据";
+  const parent = dirname(resolve(to));
+  if (same(parent, to)) return "不能直接用整个盘，写一个文件夹，例如 E:\\Zhiro数据";
+  if (!existsSync(parent)) return `上一级文件夹不存在：${parent}`;
+  if (isLink(to)) return "目标要是一个普通的空文件夹，或者还不存在";
+  if (existsSync(to)) {
+    if (!lstatSync(to).isDirectory()) return "目标要是一个普通的空文件夹，或者还不存在";
+    if (readdirSync(to).length) return "目标文件夹里已经有东西了，换一个空的";
+  }
+  const target = join2(real(parent), basename(resolve(to)));
+  const log = readLog(entry);
+  for (const p of [real(entry), resolve(entry), ...log?.old ? [log.old] : []]) if (within(p, target) || within(target, p)) return "目标不能在现在的数据文件夹里面，也不能包住它";
+  if (log?.old && existsSync(log.old)) return `上次搬家留下的旧的一份还在：${log.old}。确认不要了，先把它删掉再搬`;
+  if (process.platform === "win32" && !ok.some((d) => norm(target).startsWith(norm(d.root)))) return "只能搬到机内硬盘（NTFS 格式，不是 USB 移动硬盘）";
+  let free = 0;
+  try {
+    const s = statfsSync(real(parent));
+    free = Number(s.bavail) * Number(s.bsize);
+  } catch (e) {
+    return `读不到那个盘的剩余空间：${codeOf(e)}`;
+  }
+  if (free < need * 1.1) return `那个盘剩余空间不够：要 ${gb(need * 1.1)}，只剩 ${gb(free)}`;
+  try {
+    const probe = join2(real(parent), `.jobos-probe-${randomBytes(4).toString("hex")}`);
+    mkdirSync(probe);
+    rmdirSync(probe);
+  } catch (e) {
+    return `那个位置写不进去：${codeOf(e)}`;
+  }
+  return null;
+}
+__name(checkTarget, "checkTarget");
+function requestMove(entry, to, ok) {
+  const from = real(entry);
+  const why = checkTarget(entry, to, dirSize(from), ok);
+  if (why) throw new Error(`BAD_TARGET: ${why}`);
+  return writeLog(entry, { id: randomBytes(6).toString("hex"), entry: resolve(entry), from, to: resolve(to), phase: "requested", at: "" });
+}
+__name(requestMove, "requestMove");
+function cancelMove(entry) {
+  const log = readLog(entry);
+  if (log?.phase === "requested") writeLog(entry, { ...log, phase: "failed", error: "" });
+}
+__name(cancelMove, "cancelMove");
+function dropTarget(log) {
+  if (existsSync(mark(log))) rmSync2(log.to, { recursive: true, force: true, maxRetries: 3, retryDelay: 200 });
+}
+__name(dropTarget, "dropTarget");
+function ensureEntry(entry) {
+  const log = readLog(entry);
+  if (!log) return;
+  if (log.phase === "switched") throw new VaultUnavailable("上次搬数据停在了切换那一步：启动一次 Zhiro，它会接着处理");
+  const home = log.phase === "done" ? log.to : log.from;
+  if (existsSync(entry) && same(real(entry), real(home))) return;
+  const reachable = existsSync(join2(home, "jobos.db"));
+  const gone = `数据应该在 ${home}，现在够不着（盘没连上，或者文件夹被移走了）。Zhiro 不会在它的位置新建一份空数据。确实要从头开始的话，删掉 ${logPath(entry)}`;
+  if (isLink(entry)) {
+    if (existsSync(join2(entry, "jobos.db"))) return;
+    throw new VaultUnavailable(gone);
+  }
+  if (!reachable) throw new VaultUnavailable(gone);
+  if (existsSync(entry)) {
+    try {
+      rmdirSync(entry);
+    } catch {
+      throw new VaultUnavailable(`数据在 ${home}，但 ${entry} 现在是一个有内容的普通文件夹。Zhiro 不会猜哪一份是对的：把其中一个挪走再启动`);
+    }
+  }
+  symlinkSync(home, entry, "junction");
+}
+__name(ensureEntry, "ensureEntry");
+async function resolveVault(entry, say = (m) => console.log(`[zhiro] ${m}`), ok) {
+  const log = readLog(entry);
+  if (!log) return;
+  if (!existsSync(entry) && !isLink(entry) && existsSync(probeName(log))) renameSync(probeName(log), entry);
+  if (log.phase === "requested") return runMove(entry, log, say, ok);
+  if (log.phase === "copying" || log.phase === "verified") {
+    dropTarget(log);
+    writeLog(entry, { ...log, phase: "failed", error: "上次搬到一半被打断了。数据还在原位置，没有丢" });
+    return;
+  }
+  if (log.phase === "switched") settle(entry, log, say);
+}
+__name(resolveVault, "resolveVault");
+function settle(entry, log, say) {
+  const done = /* @__PURE__ */ __name(() => {
+    rmSync2(mark(log), { force: true });
+    writeLog(entry, { ...log, phase: "done" });
+    say(`数据已在 ${log.to}`);
+  }, "done");
+  const failed = /* @__PURE__ */ __name(() => {
+    writeLog(entry, { ...log, phase: "failed", old: void 0, error: "上次搬到最后一步被打断了。数据还在原位置，没有丢" });
+  }, "failed");
+  if (existsSync(entry) && same(real(entry), real(log.to))) return done();
+  if (existsSync(entry) || isLink(entry)) {
+    dropTarget(log);
+    return failed();
+  }
+  if (existsSync(join2(log.to, "jobos.db")) && existsSync(mark(log))) {
+    symlinkSync(log.to, entry, "junction");
+    return done();
+  }
+  const firstMove = !!log.old && same(dirname(log.old), dirname(resolve(entry)));
+  if (firstMove && existsSync(log.old)) {
+    renameSync(log.old, entry);
+    return failed();
+  }
+  if (!firstMove && existsSync(join2(log.from, "jobos.db"))) {
+    symlinkSync(log.from, entry, "junction");
+    return failed();
+  }
+  throw new VaultUnavailable(`上次搬数据停在了切换那一步，两边都够不着：${log.from}、${log.to}`);
+}
+__name(settle, "settle");
+async function runMove(entry, start, say, ok) {
+  let log = start;
+  const fail = /* @__PURE__ */ __name((why) => {
+    writeLog(entry, { ...log, phase: "failed", old: void 0, error: why });
+    say(`数据没有搬：${why}`);
+  }, "fail");
+  let lock;
+  try {
+    lock = await lockVault(log.from, "搬数据");
+  } catch (e) {
+    return fail(e instanceof VaultBusy ? e.message : `拿不到数据目录的锁：${codeOf(e)}`);
+  }
+  try {
+    const need = dirSize(log.from);
+    const why = checkTarget(entry, log.to, need, ok);
+    if (why) return fail(why);
+    const dbFile = join2(log.from, "jobos.db");
+    if (existsSync(dbFile)) {
+      const db = new DatabaseSync(dbFile);
+      try {
+        if (db.prepare("pragma wal_checkpoint(truncate)").get()?.busy) return fail("数据库正被别的程序用着");
+        const r = db.prepare("pragma integrity_check").all();
+        if (r.length !== 1 || r[0].integrity_check !== "ok") return fail(`数据库自检没通过（和搬家无关，原位置的库本身有问题）：${r.map((x) => x.integrity_check).join("; ").slice(0, 200)}`);
+      } finally {
+        db.close();
+      }
+    }
+    if (!isLink(entry)) {
+      try {
+        renameSync(entry, probeName(log));
+      } catch (e) {
+        return fail(`数据文件夹正被别的程序开着（${codeOf(e)}）。关掉在里面打开的 Claude Code / Codex 窗口和 Zhiro 打开的网申浏览器，再试`);
+      }
+      try {
+        renameSync(probeName(log), entry);
+      } catch (e) {
+        throw new VaultUnavailable(`没能把数据文件夹改回原名（${codeOf(e)}）：手工把 ${probeName(log)} 改名为 ${entry} 再启动`);
+      }
+    }
+    mkdirSync(log.to, { recursive: true });
+    writeFileSync(mark(log), "", "utf8");
+    log = writeLog(entry, { ...log, phase: "copying" });
+    say(`正在把数据（${gb(need)}）复制到 ${log.to} …`);
+    try {
+      copyTree(log.from, log.to);
+    } catch (e) {
+      dropTarget(log);
+      return fail(`复制时出错：${codeOf(e)}`);
+    }
+    say("复制完了，正在逐个文件比对 …");
+    const a = files(log.from), b = files(log.to);
+    b.delete(basename(mark(log)));
+    let bad = a.size !== b.size ? `文件个数不一样（${a.size} / ${b.size}）` : "";
+    for (const [rel, size] of a) {
+      if (bad) break;
+      if (b.get(rel) !== size) bad = `大小不一样：${rel}`;
+      else if (size >= 0 && sha(join2(log.from, rel)) !== sha(join2(log.to, rel))) bad = `内容不一样：${rel}`;
+    }
+    if (bad) {
+      dropTarget(log);
+      return fail(`复制出来的和原来的不一致（${bad}）。可能有程序在复制期间改了文件`);
+    }
+    log = writeLog(entry, { ...log, phase: "verified" });
+    const linked = isLink(entry);
+    const old = linked ? log.from : `${resolve(entry)}.old-${log.id}`;
+    log = writeLog(entry, { ...log, phase: "switched", old });
+    try {
+      if (linked) dropLink(entry);
+      else renameSync(entry, old);
+      symlinkSync(log.to, entry, "junction");
+    } catch (e) {
+      try {
+        if (!existsSync(entry) && !isLink(entry)) {
+          if (linked) symlinkSync(log.from, entry, "junction");
+          else renameSync(old, entry);
+        }
+      } catch {
+        throw new VaultUnavailable(`切换到一半出错（${codeOf(e)}），也没能恢复原状。数据完好，在 ${linked ? log.from : old}：${linked ? `在 ${entry} 重建指向它的目录联接` : `手工把它改名为 ${entry}`} 再启动`);
+      }
+      dropTarget(log);
+      return fail(`切换时出错（${codeOf(e)}）。多半是数据文件夹刚被别的程序打开了：关掉再试`);
+    }
+    rmSync2(mark(log), { force: true });
+    writeLog(entry, { ...log, phase: "done" });
+    say(`数据已搬到 ${log.to}（${a.size} 个文件逐个核对一致）。旧的一份留在 ${old}，确认没问题后由你自己删`);
+  } finally {
+    await lock.release();
+  }
+}
+__name(runMove, "runMove");
+async function locationInfo(entry, ok) {
+  const log = readLog(entry), path = real(entry);
+  let freeBytes = 0;
+  try {
+    const s = statfsSync(path);
+    freeBytes = Number(s.bavail) * Number(s.bsize);
+  } catch {
+  }
+  const oldPath = log?.phase === "done" && log.old && existsSync(log.old) ? log.old : null;
+  const [bytes, backupsBytes, oldBytes, list] = await Promise.all([sizeLater(path), sizeLater(join2(path, "backups")), oldPath ? sizeLater(oldPath) : 0, ok ?? drivesLater()]);
+  return {
+    entry: resolve(entry),
+    path,
+    bytes,
+    backupsBytes,
+    freeBytes,
+    drives: list,
+    pending: log?.phase === "requested" ? log.to : null,
+    lastError: log?.phase === "failed" ? log.error ?? "" : "",
+    old: oldPath ? { path: oldPath, bytes: oldBytes } : null
+  };
+}
+__name(locationInfo, "locationInfo");
+
+// apps/daemon/src/datadir.ts
+import { closeSync as closeSync2, existsSync as existsSync2, fsyncSync, lstatSync as lstatSync2, mkdirSync as mkdirSync2, openSync as openSync2, readFileSync as readFileSync2, renameSync as renameSync2, writeSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3, resolve as resolve2 } from "node:path";
+var here = /* @__PURE__ */ __name(() => ({ argv: process.argv, env: process.env, platform: process.platform, home: homedir() }), "here");
+function configHome(w = here()) {
+  if (w.platform === "win32") return join3(w.env.APPDATA ?? join3(w.home, "AppData", "Roaming"), "Zhiro");
+  if (w.platform === "darwin") return join3(w.home, "Library", "Preferences", "Zhiro");
+  return join3(w.env.XDG_CONFIG_HOME || join3(w.home, ".config"), "zhiro");
+}
+__name(configHome, "configHome");
+var pointerFile = /* @__PURE__ */ __name((w = here()) => join3(configHome(w), "data-dir"), "pointerFile");
+function legacyDir(w = here()) {
+  if (w.platform === "win32") return join3(w.env.APPDATA ?? join3(w.home, "AppData", "Roaming"), "JobOS", "vault");
+  if (w.platform === "darwin") return join3(w.home, "Library", "Application Support", "JobOS", "vault");
+  return join3(w.home, ".local", "share", "jobos", "vault");
+}
+__name(legacyDir, "legacyDir");
+function defaultDir(w = here()) {
+  if (w.platform === "win32") return join3(w.env.APPDATA ?? join3(w.home, "AppData", "Roaming"), "Zhiro", "data");
+  if (w.platform === "darwin") return join3(w.home, "Library", "Application Support", "Zhiro");
+  return join3(w.env.XDG_DATA_HOME || join3(w.home, ".local", "share"), "zhiro");
+}
+__name(defaultDir, "defaultDir");
+function argOf(argv) {
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i] === "--data") return argv[i + 1];
+    if (argv[i].startsWith("--data=")) return argv[i].slice(7);
+  }
+  return void 0;
+}
+__name(argOf, "argOf");
+var present = /* @__PURE__ */ __name((p) => {
+  try {
+    lstatSync2(p);
+    return true;
+  } catch {
+    return false;
+  }
+}, "present");
+function findDataDir(w = here()) {
+  const arg = argOf(w.argv);
+  if (arg) return { dir: resolve2(arg), source: "arg" };
+  const env = w.env.ZHIRO_DATA || w.env.JOBOS_VAULT;
+  if (env) {
+    if (w.env.ZHIRO_DATA && w.env.JOBOS_VAULT && resolve2(w.env.ZHIRO_DATA) !== resolve2(w.env.JOBOS_VAULT)) console.warn(`[zhiro] ZHIRO_DATA 和 JOBOS_VAULT 都设了，用 ZHIRO_DATA（${w.env.ZHIRO_DATA}）`);
+    return { dir: resolve2(env), source: "env" };
+  }
+  const ptr = pointerFile(w);
+  if (existsSync2(ptr)) {
+    const dir = readFileSync2(ptr, "utf8").trim();
+    if (!dir) throw new VaultUnavailable(`记着数据位置的文件是空的：${ptr}。删掉它再启动会重新问数据放哪`);
+    if (!present(dir)) throw new VaultUnavailable(`数据应该在 ${dir}（记在 ${ptr}），现在找不到（盘没连上，或者文件夹被移走了）。不会在别处新建一份空数据；确实要从头开始的话，删掉 ${ptr}`);
+    return { dir, source: "pointer" };
+  }
+  const old = legacyDir(w);
+  if (present(old) || existsSync2(`${old}.move.json`)) return { dir: old, source: "legacy" };
+  return { dir: defaultDir(w), source: "default" };
+}
+__name(findDataDir, "findDataDir");
+var found = null;
+function dataDir() {
+  return found ??= findDataDir();
+}
+__name(dataDir, "dataDir");
+function setDataDir(d) {
+  found = d;
+}
+__name(setDataDir, "setDataDir");
+function writePointer(dir, w = here()) {
+  const p = pointerFile(w);
+  mkdirSync2(dirname2(p), { recursive: true });
+  const tmp = `${p}.tmp`;
+  const fd = openSync2(tmp, "w");
+  try {
+    writeSync(fd, resolve2(dir) + "\n", null, "utf8");
+    fsyncSync(fd);
+  } finally {
+    closeSync2(fd);
+  }
+  renameSync2(tmp, p);
+}
+__name(writePointer, "writePointer");
+async function firstRun(d, say = console.log) {
+  if (d.source !== "default" || existsSync2(d.dir)) return d;
+  if (!process.stdin.isTTY) {
+    say(`[zhiro] 数据放在 ${d.dir}（各平台的惯例位置）。要换：下次加 --data <文件夹> 启动，或在设置页「换个位置」`);
+    return d;
+  }
+  const { createInterface } = await import("node:readline/promises");
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    const answer = (await rl.question(`第一次启动：数据存在哪？（直接回车用 ${d.dir}）
+> `)).trim().replace(/^["']|["']$/g, "");
+    const dir = answer ? resolve2(answer) : d.dir;
+    writePointer(dir);
+    say(`[zhiro] 数据放在 ${dir}；以后在设置页「换个位置」可以搬`);
+    const chosen = { dir, source: "pointer" };
+    setDataDir(chosen);
+    return chosen;
+  } finally {
+    rl.close();
+  }
+}
+__name(firstRun, "firstRun");
+
+export {
+  __name,
+  VaultBusy,
+  lockVault,
+  VaultUnavailable,
+  requestMove,
+  cancelMove,
+  ensureEntry,
+  resolveVault,
+  locationInfo,
+  pointerFile,
+  dataDir,
+  writePointer,
+  firstRun
+};

package/dist/chunk-4JJEOOW2.js

@@ -0,0 +1,107 @@
+import {
+  __name,
+  dataDir,
+  ensureEntry
+} from "./chunk-2SSYR7VW.js";
+
+// apps/daemon/src/config.ts
+import { closeSync, existsSync, fsyncSync, mkdirSync, openSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync, writeSync } from "node:fs";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+import YAML from "yaml";
+var DEFAULTS = {
+  vault: "",
+  http: { host: "127.0.0.1", port: 8787 },
+  llm: { provider: "openai-codex", model: "gpt-6-astra" },
+  feishu: {},
+  reminders: { daysBefore: [7, 3, 1] },
+  agent: { mode: "default", maxWritesPerTurn: 10, harnessConfirm: "harness", backend: "builtin" },
+  sources: []
+};
+function defaultVaultDir() {
+  return dataDir().dir;
+}
+__name(defaultVaultDir, "defaultVaultDir");
+function loadConfig(vault = defaultVaultDir()) {
+  ensureEntry(vault);
+  for (const d of ["config", "captures", "snapshots", "submissions", "backups", "runs", "profile", "resume/templates", "resume/variants", "research"]) {
+    mkdirSync(join(vault, d), { recursive: true });
+  }
+  const file = configFile(vault);
+  let user = {};
+  if (existsSync(file)) user = YAML.parse(readFileSync(file, "utf8")) ?? {};
+  else replaceConfig(vault, { ...DEFAULTS, vault: void 0 });
+  return {
+    ...DEFAULTS,
+    ...user,
+    vault,
+    // ZHIRO_PORT: another port for this run (8787 taken, a second instance for a test) without touching the settings
+    http: { ...DEFAULTS.http, ...user.http ?? {}, ...process.env.ZHIRO_PORT ? { port: Number(process.env.ZHIRO_PORT) } : {} },
+    llm: { ...DEFAULTS.llm, ...user.llm ?? {} },
+    feishu: { ...user.feishu ?? {} },
+    reminders: { ...DEFAULTS.reminders, ...user.reminders ?? {} },
+    agent: { ...DEFAULTS.agent, ...user.agent ?? {} },
+    sources: Array.isArray(user.sources) ? user.sources : []
+  };
+}
+__name(loadConfig, "loadConfig");
+var configFile = /* @__PURE__ */ __name((vault) => join(vault, "config", "jobos.yaml"), "configFile");
+function writeWhole(vault, doc) {
+  const file = configFile(vault);
+  const tmp = `${file}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    const fd = openSync(tmp, "wx");
+    try {
+      writeSync(fd, YAML.stringify(doc), null, "utf8");
+      fsyncSync(fd);
+    } finally {
+      closeSync(fd);
+    }
+    renameSync(tmp, file);
+  } catch (e) {
+    rmSync(tmp, { force: true });
+    throw e;
+  }
+}
+__name(writeWhole, "writeWhole");
+function updateConfig(vault, change) {
+  const file = configFile(vault);
+  let doc = {};
+  try {
+    doc = YAML.parse(readFileSync(file, "utf8")) ?? {};
+  } catch (e) {
+    if (e?.code !== "ENOENT") throw e;
+  }
+  change(doc);
+  writeWhole(vault, doc);
+}
+__name(updateConfig, "updateConfig");
+function replaceConfig(vault, doc) {
+  writeWhole(vault, doc);
+}
+__name(replaceConfig, "replaceConfig");
+function clearConfigTemps(vault) {
+  const dir = join(vault, "config");
+  let names = [];
+  try {
+    names = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const f of names) if (/^jobos\.yaml\.(\d+\.[0-9a-f]+\.)?tmp$/.test(f)) rmSync(join(dir, f), { force: true });
+}
+__name(clearConfigTemps, "clearConfigTemps");
+function dbPath(vault) {
+  return join(vault, "jobos.db");
+}
+__name(dbPath, "dbPath");
+
+export {
+  defaultVaultDir,
+  loadConfig,
+  configFile,
+  updateConfig,
+  replaceConfig,
+  clearConfigTemps,
+  dbPath
+};