@covro/covro 0.1.1-dev.6 → 0.1.1-dev.8

package/dist/update-worker.cjs

@@ -101,10 +101,10 @@ var require_polyfills = __commonJS({
       if (platform === "win32") {
         fs.rename = typeof fs.rename !== "function" ? fs.rename : (function(fs$rename) {
           function rename4(from, to, cb) {
-            var start = Date.now();
+            var start2 = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
-              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
+              if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start2 < 6e4) {
                 setTimeout(function() {
                   fs.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
@@ -542,8 +542,8 @@ var require_graceful_fs = __commonJS({
         }
       }
       var fs$writeFile = fs2.writeFile;
-      fs2.writeFile = writeFile;
-      function writeFile(path, data, options, cb) {
+      fs2.writeFile = writeFile2;
+      function writeFile2(path, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
         return go$writeFile(path, data, options, cb);
@@ -1108,7 +1108,7 @@ var require_signal_exit = __commonJS({
           };
         }
         assert2.equal(typeof cb, "function", "a callback must be provided for exit handler");
-        if (loaded === false) {
+        if (loaded2 === false) {
           load();
         }
         var ev = "exit";
@@ -1125,10 +1125,10 @@ var require_signal_exit = __commonJS({
         return remove;
       };
       unload = function unload2() {
-        if (!loaded || !processOk(global.process)) {
+        if (!loaded2 || !processOk(global.process)) {
           return;
         }
-        loaded = false;
+        loaded2 = false;
         signals.forEach(function(sig) {
           try {
             process2.removeListener(sig, sigListeners[sig]);
@@ -1168,12 +1168,12 @@ var require_signal_exit = __commonJS({
       module2.exports.signals = function() {
         return signals;
       };
-      loaded = false;
+      loaded2 = false;
       load = function load2() {
-        if (loaded || !processOk(global.process)) {
+        if (loaded2 || !processOk(global.process)) {
           return;
         }
-        loaded = true;
+        loaded2 = true;
         emitter.count += 1;
         signals = signals.filter(function(sig) {
           try {
@@ -1221,7 +1221,7 @@ var require_signal_exit = __commonJS({
     var unload;
     var emit;
     var sigListeners;
-    var loaded;
+    var loaded2;
     var load;
     var originalProcessReallyExit;
     var processReallyExit;
@@ -1578,27 +1578,27 @@ var require_adapter = __commonJS({
 var require_proper_lockfile = __commonJS({
   "node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/index.js"(exports2, module2) {
     "use strict";
-    var lockfile3 = require_lockfile();
+    var lockfile4 = require_lockfile();
     var { toPromise, toSync, toSyncOptions } = require_adapter();
     async function lock(file2, options) {
-      const release = await toPromise(lockfile3.lock)(file2, options);
+      const release = await toPromise(lockfile4.lock)(file2, options);
       return toPromise(release);
     }
     function lockSync(file2, options) {
-      const release = toSync(lockfile3.lock)(file2, toSyncOptions(options));
+      const release = toSync(lockfile4.lock)(file2, toSyncOptions(options));
       return toSync(release);
     }
     function unlock(file2, options) {
-      return toPromise(lockfile3.unlock)(file2, options);
+      return toPromise(lockfile4.unlock)(file2, options);
     }
     function unlockSync(file2, options) {
-      return toSync(lockfile3.unlock)(file2, toSyncOptions(options));
+      return toSync(lockfile4.unlock)(file2, toSyncOptions(options));
     }
     function check2(file2, options) {
-      return toPromise(lockfile3.check)(file2, options);
+      return toPromise(lockfile4.check)(file2, options);
     }
     function checkSync(file2, options) {
-      return toSync(lockfile3.check)(file2, toSyncOptions(options));
+      return toSync(lockfile4.check)(file2, toSyncOptions(options));
     }
     module2.exports = lock;
     module2.exports.lock = lock;
@@ -2323,9 +2323,9 @@ function nullish(input2) {
   return input2 === null || input2 === void 0;
 }
 function cleanRegex(source) {
-  const start = source.startsWith("^") ? 1 : 0;
+  const start2 = source.startsWith("^") ? 1 : 0;
   const end = source.endsWith("$") ? source.length - 1 : source.length;
-  return source.slice(start, end);
+  return source.slice(start2, end);
 }
 function floatSafeRemainder(val, step) {
   const ratio = val / step;
@@ -2796,9 +2796,9 @@ function sizeCaps(defChecks) {
   }
   return caps;
 }
-function attachSchema(issues, start, inst) {
+function attachSchema(issues, start2, inst) {
   var _a3;
-  for (let i = start; i < issues.length; i++) {
+  for (let i = start2; i < issues.length; i++) {
     (_a3 = issues[i]).schema ?? (_a3.schema = inst);
   }
 }
@@ -4983,10 +4983,10 @@ function capSize(inst, size) {
     if (n > cap && !ctx?.skipChecks && ctx?.direction !== "backward") {
       for (const [max, ch] of sizeCaps(inst._zod.def.checks)) {
         if (n > max && ch._zod.def.when(payload)) {
-          const start = payload.issues.length;
+          const start2 = payload.issues.length;
           ch._zod.check(payload);
-          payload.issues[start].continue = false;
-          attachSchema(payload.issues, start, inst);
+          payload.issues[start2].continue = false;
+          attachSchema(payload.issues, start2, inst);
           return payload;
         }
       }
@@ -21390,17 +21390,15 @@ function requireCodexCompatibility(metadata, running, confirmed = false) {
 }
 
 // src/updates/worker.ts
-var import_node_child_process2 = require("node:child_process");
-var import_node_util2 = require("node:util");
+var import_node_child_process4 = require("node:child_process");
+var import_node_util4 = require("node:util");
 var import_node_module = require("node:module");
-var import_node_crypto2 = require("node:crypto");
-var import_promises5 = require("node:fs/promises");
+var import_node_crypto4 = require("node:crypto");
+var import_promises9 = require("node:fs/promises");
 var import_node_fs2 = require("node:fs");
-var import_node_path4 = require("node:path");
-var import_promises6 = require("node:timers/promises");
-var import_node_child_process3 = require("node:child_process");
-var import_node_os = require("node:os");
-var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+var import_node_path7 = require("node:path");
+var import_promises10 = require("node:timers/promises");
+var import_proper_lockfile3 = __toESM(require_proper_lockfile(), 1);
 
 // src/cli/control.ts
 var import_node_http = require("node:http");
@@ -21464,23 +21462,121 @@ async function stopAndWait(location) {
   throw new Error("Covro \u5C1A\u672A\u5B8C\u6210\u5173\u95ED\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
 }
 
-// src/updates/files.ts
+// src/cli/background.ts
+var import_node_child_process2 = require("node:child_process");
+var import_promises5 = require("node:fs/promises");
+var import_node_path4 = require("node:path");
+var import_node_util2 = require("node:util");
+var import_promises6 = require("node:timers/promises");
+var import_proper_lockfile2 = __toESM(require_proper_lockfile(), 1);
+
+// src/cli/launchd.ts
+var import_node_child_process = require("node:child_process");
+var import_node_util = require("node:util");
+var import_node_crypto3 = require("node:crypto");
+var import_node_os = require("node:os");
+var import_node_path3 = require("node:path");
+var import_promises4 = require("node:fs/promises");
+
+// src/cli/launch-environment.ts
+var import_node_net = require("node:net");
+var import_promises2 = require("node:fs/promises");
 var import_node_crypto = require("node:crypto");
 var import_node_path = require("node:path");
-var import_promises2 = require("node:fs/promises");
+async function environmentBridge(home) {
+  const path = (0, import_node_path.join)(home, `e-${(0, import_node_crypto.randomBytes)(6).toString("hex")}.sock`);
+  const clients = /* @__PURE__ */ new Set();
+  let accept;
+  const consumed = new Promise((resolve) => {
+    accept = resolve;
+  });
+  const payload = JSON.stringify({ env: { ...process.env, COVRO_HOME: home }, cwd: process.cwd() });
+  const server = (0, import_node_net.createServer)((socket) => {
+    clients.add(socket);
+    socket.setTimeout(5e3, () => socket.destroy());
+    socket.on("error", () => {
+    });
+    socket.on("close", () => clients.delete(socket));
+    socket.end(payload, () => accept?.());
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(path, resolve);
+    });
+    await (0, import_promises2.chmod)(path, 384);
+    return {
+      path,
+      async wait() {
+        let timer;
+        try {
+          await Promise.race([
+            consumed,
+            new Promise((_, reject) => {
+              timer = setTimeout(
+                () => reject(new Error("launchd \u542F\u52A8\u73AF\u5883\u4F20\u9012\u8D85\u65F6\uFF0C\u8BF7\u67E5\u770B Covro \u65E5\u5FD7")),
+                1e4
+              );
+            })
+          ]);
+        } finally {
+          clearTimeout(timer);
+        }
+      },
+      async close() {
+        for (const socket of clients) socket.destroy();
+        await new Promise(
+          (resolve, reject) => server.close((error62) => error62 ? reject(error62) : resolve())
+        );
+        await (0, import_promises2.rm)(path, { force: true });
+      }
+    };
+  } catch (error62) {
+    server.close();
+    await (0, import_promises2.rm)(path, { force: true });
+    throw error62;
+  }
+}
+var launchRunner = `import { connect } from 'node:net';
+const [socketPath, entry, config] = process.argv.slice(2);
+try {
+  const input = await new Promise((resolve, reject) => {
+    const socket = connect(socketPath);
+    let body = '';
+    socket.setTimeout(10000, () => socket.destroy(new Error('launch environment timed out')));
+    socket.setEncoding('utf8');
+    socket.on('data', chunk => {
+      body += chunk;
+      if (Buffer.byteLength(body) > 2 * 1024 * 1024) socket.destroy(new Error('launch environment too large'));
+    });
+    socket.on('error', reject);
+    socket.on('end', () => { try { resolve(JSON.parse(body)); } catch { reject(new Error('invalid launch environment')); } });
+  });
+  process.chdir(input.cwd);
+  process.execve(process.execPath, [process.execPath, entry, 'run', '--config', config], input.env);
+} catch {
+  console.error('Covro launch environment unavailable; restart with covro start.');
+  process.exitCode = 1;
+}
+`;
+
+// src/updates/files.ts
+var import_node_crypto2 = require("node:crypto");
+var import_node_path2 = require("node:path");
+var import_promises3 = require("node:fs/promises");
 async function readJson(filename) {
   try {
-    return JSON.parse(await (0, import_promises2.readFile)(filename, "utf8"));
+    return JSON.parse(await (0, import_promises3.readFile)(filename, "utf8"));
   } catch (error62) {
     if (error62.code === "ENOENT") return void 0;
     throw error62;
   }
 }
 async function saveJson(filename, value) {
-  await (0, import_promises2.mkdir)((0, import_node_path.dirname)(filename), { recursive: true, mode: 448 });
-  const temporary = `${filename}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  await (0, import_promises3.mkdir)((0, import_node_path2.dirname)(filename), { recursive: true, mode: 448 });
+  const temporary = `${filename}.${(0, import_node_crypto2.randomUUID)()}.tmp`;
   try {
-    const file2 = await (0, import_promises2.open)(temporary, "wx", 384);
+    const file2 = await (0, import_promises3.open)(temporary, "wx", 384);
     try {
       await file2.writeFile(`${JSON.stringify(value, null, 2)}
 `);
@@ -21488,15 +21584,15 @@ async function saveJson(filename, value) {
     } finally {
       await file2.close();
     }
-    await (0, import_promises2.rename)(temporary, filename);
-    await syncDirectory((0, import_node_path.dirname)(filename));
+    await (0, import_promises3.rename)(temporary, filename);
+    await syncDirectory((0, import_node_path2.dirname)(filename));
   } finally {
-    await (0, import_promises2.rm)(temporary, { force: true });
+    await (0, import_promises3.rm)(temporary, { force: true });
   }
 }
 async function syncDirectory(directory) {
   if (process.platform === "win32") return;
-  const handle = await (0, import_promises2.open)(directory, "r");
+  const handle = await (0, import_promises3.open)(directory, "r");
   try {
     await handle.sync();
   } finally {
@@ -21504,20 +21600,228 @@ async function syncDirectory(directory) {
   }
 }
 async function copyDurable(source, target) {
-  await (0, import_promises2.cp)(source, target);
-  const file2 = await (0, import_promises2.open)(target, "r");
+  await (0, import_promises3.cp)(source, target);
+  const file2 = await (0, import_promises3.open)(target, "r");
   try {
     await file2.sync();
   } finally {
     await file2.close();
   }
-  await syncDirectory((0, import_node_path.dirname)(target));
+  await syncDirectory((0, import_node_path2.dirname)(target));
 }
 
+// src/cli/launchd.ts
+var exec = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var launchctl = (args) => exec("/bin/launchctl", args, { timeout: 5e3, maxBuffer: 2 * 1024 * 1024 });
+var xml = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+function failureDetail(error62) {
+  const failure2 = error62;
+  if (failure2.killed) return "launchctl \u8BF7\u6C42\u8D85\u65F6";
+  return (failure2.stderr?.trim() || (error62 instanceof Error ? error62.message : "\u672A\u77E5\u9519\u8BEF")).slice(
+    0,
+    1024
+  );
+}
+function launchdPaths(location, label = `dev.covro.${location.key}.${(0, import_node_crypto3.createHash)("sha256").update(location.home).digest("hex").slice(0, 12)}`) {
+  const domain2 = `gui/${process.getuid()}`;
+  return {
+    label,
+    domain: domain2,
+    target: `${domain2}/${label}`,
+    temporary: (0, import_node_path3.join)(location.state, "launchd.plist"),
+    login: (0, import_node_path3.join)((0, import_node_os.homedir)(), "Library/LaunchAgents", `${label}.plist`)
+  };
+}
+async function loaded(target) {
+  try {
+    await launchctl(["print", target]);
+    return true;
+  } catch (error62) {
+    const stderr = error62.stderr ?? "";
+    if (/Could not find (?:domain|service|specified service)/i.test(stderr)) return false;
+    throw new Error(
+      `\u65E0\u6CD5\u67E5\u8BE2 launchd ${target}\uFF1A${failureDetail(error62)}\uFF1B\u8BF7\u68C0\u67E5\u5F53\u524D\u7528\u6237\u7684 launchd \u6743\u9650`,
+      { cause: error62 }
+    );
+  }
+}
+async function guiSessionAvailable(location) {
+  return loaded(launchdPaths(location).domain);
+}
+async function loginRegistration(location) {
+  const installed = await readJson(
+    (0, import_node_path3.join)(location.state, "service.json")
+  );
+  if (installed?.platform !== "darwin") return void 0;
+  if (installed.label !== launchdPaths(location).label && installed.label !== `dev.covro.${location.key}`)
+    throw new Error("\u767B\u5F55\u670D\u52A1\u8EAB\u4EFD\u4E0E\u5F53\u524D\u914D\u7F6E\u4E0D\u5339\u914D");
+  return installed;
+}
+function launchdPlist(location, args, login) {
+  const { label } = launchdPaths(location, login ? `dev.covro.${location.key}` : void 0);
+  const environment = {
+    PATH: process.env.PATH ?? "/usr/bin:/bin",
+    COVRO_HOME: location.home,
+    ...process.env.CODEX_HOME ? { CODEX_HOME: process.env.CODEX_HOME } : {}
+  };
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0"><dict>
+<key>Label</key><string>${label}</string>
+<key>ProgramArguments</key><array>${args.map((arg) => `<string>${xml(arg)}</string>`).join("")}</array>
+<key>LimitLoadToSessionType</key><string>Aqua</string>
+<key>RunAtLoad</key><true/>
+${login ? "<key>KeepAlive</key><dict><key>SuccessfulExit</key><false/></dict><key>ThrottleInterval</key><integer>30</integer>" : ""}
+<key>EnvironmentVariables</key><dict>${Object.entries(environment).map(([key, value]) => `<key>${key}</key><string>${xml(value)}</string>`).join("")}</dict>
+<key>StandardOutPath</key><string>${xml(location.log)}</string>
+<key>StandardErrorPath</key><string>${xml(location.log)}</string>
+</dict></plist>
+`;
+}
+async function unloadLaunchd(location) {
+  const { target, temporary } = launchdPaths(location);
+  const installed = await loginRegistration(location);
+  const targets = /* @__PURE__ */ new Set([
+    target,
+    ...installed ? [launchdPaths(location, installed.label).target] : []
+  ]);
+  for (const serviceTarget of targets) {
+    if (await loaded(serviceTarget)) {
+      try {
+        await launchctl(["bootout", serviceTarget]);
+      } catch (error62) {
+        if (await loaded(serviceTarget)) throw error62;
+      }
+    }
+  }
+  await (0, import_promises4.rm)(temporary, { force: true });
+}
+async function startLaunchd(location, entry) {
+  const installed = await loginRegistration(location);
+  const { domain: domain2, target, temporary, login } = launchdPaths(location, installed?.label);
+  if (!await guiSessionAvailable(location)) {
+    if (installed) throw new Error("\u5F53\u524D\u6CA1\u6709 macOS \u684C\u9762\u767B\u5F55\u4F1A\u8BDD\uFF0C\u65E0\u6CD5\u542F\u52A8 GUI \u767B\u5F55\u670D\u52A1");
+    return false;
+  }
+  await unloadLaunchd(location);
+  if (installed) {
+    await launchctl(["enable", target]);
+    await launchctl(["bootstrap", domain2, login]);
+    return true;
+  }
+  const bridge = await environmentBridge(location.home);
+  try {
+    const runner = (0, import_node_path3.join)(location.state, "launch-runner.mjs");
+    await (0, import_promises4.writeFile)(runner, launchRunner, { mode: 384 });
+    await (0, import_promises4.writeFile)(
+      temporary,
+      launchdPlist(
+        location,
+        [process.execPath, runner, bridge.path, entry, location.config],
+        false
+      ),
+      { mode: 384 }
+    );
+    await launchctl(["enable", target]);
+    await launchctl(["bootstrap", domain2, temporary]);
+    await bridge.wait();
+    return true;
+  } catch (error62) {
+    let cleanup = "";
+    try {
+      await unloadLaunchd(location);
+    } catch (cleanupError) {
+      cleanup = `\uFF1B\u6E05\u7406\u4EFB\u52A1\u5931\u8D25\uFF1A${failureDetail(cleanupError)}`;
+    }
+    throw new Error(
+      `Covro GUI \u540E\u53F0\u542F\u52A8\u5931\u8D25\uFF1A${failureDetail(error62)}${cleanup}\uFF1B\u8FDB\u7A0B\u65E5\u5FD7\u4F4D\u4E8E ${location.log}`,
+      { cause: error62 }
+    );
+  } finally {
+    await bridge.close();
+  }
+}
+
+// src/cli/background.ts
+var exec2 = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+async function lifecycle(location, action) {
+  await (0, import_promises5.mkdir)(location.state, { recursive: true, mode: 448 });
+  const release = await import_proper_lockfile2.default.lock(location.state, {
+    lockfilePath: (0, import_node_path4.join)(location.state, "lifecycle.lock"),
+    stale: 1e4,
+    update: 2e3,
+    retries: { retries: 280, minTimeout: 250, maxTimeout: 250 }
+  });
+  try {
+    return await action();
+  } finally {
+    await release();
+  }
+}
+async function start(location, entry) {
+  try {
+    return await control(location, "status");
+  } catch (error62) {
+    if (!isNotRunning(error62)) throw error62;
+  }
+  let child;
+  const installed = await readJson(
+    (0, import_node_path4.join)(location.state, "service.json")
+  );
+  if (process.platform === "darwin" && await startLaunchd(location, entry)) {
+  } else if (installed?.platform === "linux") {
+    await exec2("systemctl", ["--user", "start", `${installed.label}.service`]);
+  } else {
+    if (process.platform === "darwin")
+      console.warn(
+        "\u5F53\u524D\u6CA1\u6709 macOS \u684C\u9762\u767B\u5F55\u4F1A\u8BDD\uFF0C\u4F7F\u7528 headless \u540E\u53F0\u542F\u52A8\uFF1B\u7CFB\u7EDF\u94A5\u5319\u4E32\u51ED\u8BC1\u53EF\u80FD\u4E0D\u53EF\u7528\u3002"
+      );
+    const log = await (0, import_promises5.open)(location.log, "a", 384);
+    try {
+      child = (0, import_node_child_process2.spawn)(process.execPath, [entry, "run", "--config", location.config], {
+        detached: true,
+        stdio: ["ignore", log.fd, log.fd],
+        windowsHide: true,
+        env: { ...process.env, COVRO_HOME: location.home }
+      });
+      await new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+      });
+      child.unref();
+    } finally {
+      await log.close();
+    }
+  }
+  for (let attempt = 0; attempt < 240; attempt++) {
+    try {
+      return await control(location, "status");
+    } catch (error62) {
+      if (!isNotRunning(error62)) throw error62;
+    }
+    if (child && child.exitCode !== null) throw new Error(`Covro \u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u67E5\u770B ${location.log}`);
+    await (0, import_promises6.setTimeout)(250);
+  }
+  throw new Error(`Covro \u5C1A\u672A\u786E\u8BA4\u542F\u52A8\uFF0C\u8BF7\u8FD0\u884C covro status \u5E76\u67E5\u770B ${location.log}`);
+}
+async function stop(location) {
+  await stopAndWait(location);
+  if (process.platform === "darwin") await unloadLaunchd(location);
+  else {
+    const installed = await readJson(
+      (0, import_node_path4.join)(location.state, "service.json")
+    );
+    if (installed?.platform === "linux")
+      await exec2("systemctl", ["--user", "stop", `${installed.label}.service`]);
+  }
+}
+var startBackground = (location, entry) => lifecycle(location, () => start(location, entry));
+var stopBackground = (location) => lifecycle(location, () => stop(location));
+
 // src/updates/transaction.ts
-var import_promises3 = require("node:fs/promises");
-var import_node_path2 = require("node:path");
-var exists = async (path) => (0, import_promises3.stat)(path).then(
+var import_promises7 = require("node:fs/promises");
+var import_node_path5 = require("node:path");
+var exists = async (path) => (0, import_promises7.stat)(path).then(
   () => true,
   (error62) => {
     if (error62.code === "ENOENT") return false;
@@ -21535,17 +21839,17 @@ async function activateUpdate(paths, effects) {
     await effects.phase("stopping", "\u5DF2\u5173\u95ED\u65B0\u4EFB\u52A1\u5165\u53E3\uFF0C\u6B63\u5728\u505C\u6B62\u65E7\u670D\u52A1\u5E76\u5907\u4EFD\u6570\u636E");
     stopped = true;
     await effects.stop();
-    await (0, import_promises3.mkdir)(paths.backup, { recursive: true, mode: 448 });
+    await (0, import_promises7.mkdir)(paths.backup, { recursive: true, mode: 448 });
     for (const name of ["app.sqlite", "app.sqlite-wal", "app.sqlite-shm"]) {
-      if (await exists((0, import_node_path2.join)(paths.dataDir, name)))
-        await copyDurable((0, import_node_path2.join)(paths.dataDir, name), (0, import_node_path2.join)(paths.backup, name));
+      if (await exists((0, import_node_path5.join)(paths.dataDir, name)))
+        await copyDurable((0, import_node_path5.join)(paths.dataDir, name), (0, import_node_path5.join)(paths.backup, name));
     }
-    await copyDurable(paths.config, (0, import_node_path2.join)(paths.backup, "config.json"));
-    await saveJson((0, import_node_path2.join)(paths.backup, "snapshot.json"), { complete: true });
+    await copyDurable(paths.config, (0, import_node_path5.join)(paths.backup, "config.json"));
+    await saveJson((0, import_node_path5.join)(paths.backup, "snapshot.json"), { complete: true });
     backedUp = true;
-    await (0, import_promises3.rename)(paths.root, paths.previous);
+    await (0, import_promises7.rename)(paths.root, paths.previous);
     moved = true;
-    await (0, import_promises3.rename)(paths.candidate, paths.root);
+    await (0, import_promises7.rename)(paths.candidate, paths.root);
     await effects.phase("verifying", "\u6B63\u5728\u542F\u52A8\u65B0\u7248\u3001\u8FC1\u79FB\u6570\u636E\u5E93\u5E76\u9A8C\u8BC1\uFF1B\u4E1A\u52A1\u5199\u5165\u4FDD\u6301\u6682\u505C");
     await effects.start(true);
     await effects.verify();
@@ -21562,16 +21866,16 @@ async function activateUpdate(paths, effects) {
     try {
       await effects.stop();
       if (moved) {
-        await (0, import_promises3.rm)(paths.root, { recursive: true, force: true });
-        await (0, import_promises3.rename)(paths.previous, paths.root);
+        await (0, import_promises7.rm)(paths.root, { recursive: true, force: true });
+        await (0, import_promises7.rename)(paths.previous, paths.root);
       }
       if (backedUp) {
         for (const name of ["app.sqlite", "app.sqlite-wal", "app.sqlite-shm"]) {
-          await (0, import_promises3.rm)((0, import_node_path2.join)(paths.dataDir, name), { force: true });
-          if (await exists((0, import_node_path2.join)(paths.backup, name)))
-            await copyDurable((0, import_node_path2.join)(paths.backup, name), (0, import_node_path2.join)(paths.dataDir, name));
+          await (0, import_promises7.rm)((0, import_node_path5.join)(paths.dataDir, name), { force: true });
+          if (await exists((0, import_node_path5.join)(paths.backup, name)))
+            await copyDurable((0, import_node_path5.join)(paths.backup, name), (0, import_node_path5.join)(paths.dataDir, name));
         }
-        await copyDurable((0, import_node_path2.join)(paths.backup, "config.json"), paths.config);
+        await copyDurable((0, import_node_path5.join)(paths.backup, "config.json"), paths.config);
       }
       await effects.phase(
         "rolledBack",
@@ -21589,16 +21893,16 @@ async function activateUpdate(paths, effects) {
   }
 }
 function transactionPaths(root, id, dataDir, config2, backup) {
-  const prefix = (0, import_node_path2.join)((0, import_node_path2.dirname)(root), `.covro-stage-${id}`);
+  const prefix = (0, import_node_path5.join)((0, import_node_path5.dirname)(root), `.covro-stage-${id}`);
   return {
     root,
     prefix,
-    candidate: (0, import_node_path2.join)(
+    candidate: (0, import_node_path5.join)(
       prefix,
       process.platform === "win32" ? "node_modules" : "lib/node_modules",
       npmPackageName
     ),
-    previous: (0, import_node_path2.join)((0, import_node_path2.dirname)(root), `.covro-previous-${id}`),
+    previous: (0, import_node_path5.join)((0, import_node_path5.dirname)(root), `.covro-previous-${id}`),
     backup,
     dataDir,
     config: config2
@@ -21606,12 +21910,12 @@ function transactionPaths(root, id, dataDir, config2, backup) {
 }
 
 // src/updates/registry.ts
-var import_node_child_process = require("node:child_process");
-var import_node_util = require("node:util");
-var import_promises4 = require("node:fs/promises");
+var import_node_child_process3 = require("node:child_process");
+var import_node_util3 = require("node:util");
+var import_promises8 = require("node:fs/promises");
 var import_node_fs = require("node:fs");
-var import_node_path3 = require("node:path");
-var run = (0, import_node_util.promisify)(import_node_child_process.execFile);
+var import_node_path6 = require("node:path");
+var run = (0, import_node_util3.promisify)(import_node_child_process3.execFile);
 var registry2 = "https://registry.npmjs.org";
 var releaseSchema = external_exports.object({
   name: external_exports.literal(npmPackageName),
@@ -21628,80 +21932,27 @@ async function inspectInstallation(root) {
   }
 }
 async function inspectPackageDirectory(root, globalRoot) {
-  const expected = (0, import_node_path3.join)(await (0, import_promises4.realpath)(globalRoot), npmPackageName);
-  if ((await (0, import_promises4.lstat)(expected)).isSymbolicLink() || await (0, import_promises4.realpath)(root) !== expected)
+  const expected = (0, import_node_path6.join)(await (0, import_promises8.realpath)(globalRoot), npmPackageName);
+  if ((await (0, import_promises8.lstat)(expected)).isSymbolicLink() || await (0, import_promises8.realpath)(root) !== expected)
     return "\u5F53\u524D\u4E3A\u6E90\u7801\u3001\u94FE\u63A5\u6216\u975E npm \u5168\u5C40\u5B89\u88C5\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
   try {
-    await (0, import_promises4.lstat)((0, import_node_path3.join)(expected, ".git"));
+    await (0, import_promises8.lstat)((0, import_node_path6.join)(expected, ".git"));
     return "\u5F53\u524D\u5B89\u88C5\u5305\u542B Git \u5DE5\u4F5C\u533A\uFF1B\u8BF7\u4F7F\u7528\u539F\u90E8\u7F72\u65B9\u5F0F\u66F4\u65B0\u3002";
   } catch (error62) {
     if (error62.code !== "ENOENT") throw error62;
   }
-  await (0, import_promises4.access)(root, import_node_fs.constants.W_OK);
+  await (0, import_promises8.access)(root, import_node_fs.constants.W_OK);
   return void 0;
 }
 
 // src/updates/worker.ts
-var exec = (0, import_node_util2.promisify)(import_node_child_process2.execFile);
+var exec3 = (0, import_node_util4.promisify)(import_node_child_process4.execFile);
 var message = (error62) => error62 instanceof Error ? error62.message : String(error62);
-async function startService(context, activation) {
-  const installed = await readJson(
-    (0, import_node_path4.join)(context.location.state, "service.json")
-  );
-  if (installed) {
-    if (installed.platform === "darwin")
-      await exec("launchctl", [
-        "bootstrap",
-        `gui/${process.getuid()}`,
-        (0, import_node_path4.join)((0, import_node_os.homedir)(), "Library/LaunchAgents", `${installed.label}.plist`)
-      ]);
-    else await exec("systemctl", ["--user", "start", `${installed.label}.service`]);
-  } else {
-    const log = await (0, import_promises5.open)(context.location.log, "a", 384);
-    try {
-      const child = (0, import_node_child_process3.spawn)(
-        process.execPath,
-        [(0, import_node_path4.join)(context.root, "bin/covro.mjs"), "run", "--config", context.location.config],
-        {
-          detached: true,
-          stdio: ["ignore", log.fd, log.fd],
-          windowsHide: true,
-          env: {
-            ...process.env,
-            COVRO_HOME: context.location.home,
-            ...activation ? { COVRO_ACTIVATING: activation } : {}
-          }
-        }
-      );
-      await new Promise((done, reject) => {
-        child.once("spawn", done);
-        child.once("error", reject);
-      });
-      child.unref();
-    } finally {
-      await log.close();
-    }
-  }
+async function startService(context) {
+  await startBackground(context.location, (0, import_node_path7.join)(context.root, "bin/covro.mjs"));
 }
 async function stopService(context) {
-  await stopAndWait(context.location);
-  const installed = await readJson(
-    (0, import_node_path4.join)(context.location.state, "service.json")
-  );
-  if (installed?.platform === "linux")
-    await exec("systemctl", ["--user", "stop", `${installed.label}.service`]);
-  else if (installed?.platform === "darwin") {
-    const target = `gui/${process.getuid()}/${installed.label}`;
-    try {
-      await exec("launchctl", ["bootout", target]);
-    } catch (error62) {
-      const stillLoaded = await exec("launchctl", ["print", target]).then(
-        () => true,
-        () => false
-      );
-      if (stillLoaded) throw error62;
-    }
-  }
+  await stopBackground(context.location);
 }
 async function verifyRestoredService(context, version3) {
   for (let attempt = 0; attempt < 240; attempt++) {
@@ -21713,15 +21964,15 @@ async function verifyRestoredService(context, version3) {
     } catch (error62) {
       if (attempt === 239) throw error62;
     }
-    await (0, import_promises6.setTimeout)(250);
+    await (0, import_promises10.setTimeout)(250);
   }
 }
 async function verifyMigrations(context, candidate) {
-  const require2 = (0, import_node_module.createRequire)((0, import_node_path4.join)(context.root, "package.json"));
+  const require2 = (0, import_node_module.createRequire)((0, import_node_path7.join)(context.root, "package.json"));
   const Sqlite = require2("better-sqlite3");
-  const filename = (0, import_node_path4.join)(context.dataDir, "app.sqlite");
+  const filename = (0, import_node_path7.join)(context.dataDir, "app.sqlite");
   try {
-    await (0, import_promises5.access)(filename);
+    await (0, import_promises9.access)(filename);
   } catch (error62) {
     if (error62.code === "ENOENT") return;
     throw error62;
@@ -21732,12 +21983,12 @@ async function verifyMigrations(context, candidate) {
     if (!table) return;
     const applied = db.prepare("SELECT hash FROM __drizzle_migrations ORDER BY created_at").all();
     const journal = JSON.parse(
-      await (0, import_promises5.readFile)((0, import_node_path4.join)(candidate, "dist/drizzle/meta/_journal.json"), "utf8")
+      await (0, import_promises9.readFile)((0, import_node_path7.join)(candidate, "dist/drizzle/meta/_journal.json"), "utf8")
     );
     const hashes = await Promise.all(
       journal.entries.map(async (entry) => {
         if (!/^[a-zA-Z0-9_-]+$/.test(entry.tag)) throw new Error("\u5019\u9009\u5305\u5305\u542B\u65E0\u6548\u8FC1\u79FB\u8DEF\u5F84");
-        return (0, import_node_crypto2.createHash)("sha256").update(await (0, import_promises5.readFile)((0, import_node_path4.join)(candidate, "dist/drizzle", `${entry.tag}.sql`))).digest("hex");
+        return (0, import_node_crypto4.createHash)("sha256").update(await (0, import_promises9.readFile)((0, import_node_path7.join)(candidate, "dist/drizzle", `${entry.tag}.sql`))).digest("hex");
       })
     );
     if (applied.some((entry, i) => entry.hash !== hashes[i]))
@@ -21747,28 +21998,28 @@ async function verifyMigrations(context, candidate) {
   }
 }
 async function worker(directory) {
-  await (0, import_promises5.mkdir)(directory, { recursive: true, mode: 448 });
-  const release = await import_proper_lockfile2.default.lock(directory, {
+  await (0, import_promises9.mkdir)(directory, { recursive: true, mode: 448 });
+  const release = await import_proper_lockfile3.default.lock(directory, {
     stale: 1e4,
     update: 2e3,
     retries: { retries: 30, minTimeout: 100, maxTimeout: 500 }
   });
-  let record2 = await readJson((0, import_node_path4.join)(directory, "run.json"));
-  const context = await readJson((0, import_node_path4.join)(directory, "context.json"));
+  let record2 = await readJson((0, import_node_path7.join)(directory, "run.json"));
+  const context = await readJson((0, import_node_path7.join)(directory, "context.json"));
   if (!record2 || !context) {
     await release();
     throw new Error("\u7F3A\u5C11\u5347\u7EA7\u8BB0\u5F55");
   }
   const update = async (phase, detail) => {
     record2 = { ...record2, phase, message: detail, updatedAt: Date.now() };
-    await saveJson((0, import_node_path4.join)(directory, "run.json"), record2);
+    await saveJson((0, import_node_path7.join)(directory, "run.json"), record2);
   };
   const paths = transactionPaths(
     context.root,
     record2.id,
     context.dataDir,
     context.location.config,
-    (0, import_node_path4.join)(directory, `backup-${record2.id}`)
+    (0, import_node_path7.join)(directory, `backup-${record2.id}`)
   );
   try {
     if (process.argv[3] === "--repair") {
@@ -21782,18 +22033,18 @@ async function worker(directory) {
       if (active && !active.maintenance && active.version !== record2.from)
         throw new Error("\u5F53\u524D\u670D\u52A1\u53EF\u80FD\u5DF2\u63A5\u53D7\u65B0\u7248\u4E1A\u52A1\u6570\u636E\uFF1B\u62D2\u7EDD\u6062\u590D\u65E7\u5FEB\u7167\uFF0C\u8BF7\u4F7F\u7528\u517C\u5BB9\u7248\u672C\u68C0\u67E5\u3002");
       const previous = await readJson(
-        (0, import_node_path4.join)(paths.previous, "package.json")
+        (0, import_node_path7.join)(paths.previous, "package.json")
       );
       if (previous) {
         if (active && !active.maintenance)
           throw new Error("\u65E7\u670D\u52A1\u5DF2\u6062\u590D\u4E1A\u52A1\u5199\u5165\uFF1B\u62D2\u7EDD\u7528\u5347\u7EA7\u524D\u5FEB\u7167\u8986\u76D6\u73B0\u6709\u6570\u636E\uFF0C\u8BF7\u4FDD\u7559\u73B0\u573A\u68C0\u67E5\u3002");
         if (previous.name !== npmPackageName || previous.version !== record2.from)
           throw new Error("\u65E7\u7248\u5907\u4EFD\u8EAB\u4EFD\u4E0D\u5339\u914D");
-        const snapshot = await readJson((0, import_node_path4.join)(paths.backup, "snapshot.json"));
+        const snapshot = await readJson((0, import_node_path7.join)(paths.backup, "snapshot.json"));
         if (!snapshot?.complete) throw new Error("\u6570\u636E\u5E93\u5907\u4EFD\u4E0D\u5B8C\u6574\uFF0C\u4FDD\u7559\u5168\u90E8\u73B0\u573A\u4F9B\u68C0\u67E5");
       } else {
         const original = await readJson(
-          (0, import_node_path4.join)(paths.root, "package.json")
+          (0, import_node_path7.join)(paths.root, "package.json")
         );
         if (original?.name !== npmPackageName || original.version !== record2.from)
           throw new Error("\u672A\u627E\u5230\u5B8C\u6574\u7684\u4E0A\u4E00\u7248\u672C\u5B89\u88C5");
@@ -21804,20 +22055,20 @@ async function worker(directory) {
       }
       await stopService(context);
       if (previous) {
-        await (0, import_promises5.rm)(paths.root, { recursive: true, force: true });
-        await (0, import_promises5.rename)(paths.previous, paths.root);
+        await (0, import_promises9.rm)(paths.root, { recursive: true, force: true });
+        await (0, import_promises9.rename)(paths.previous, paths.root);
         for (const name of ["app.sqlite", "app.sqlite-wal", "app.sqlite-shm"]) {
-          await (0, import_promises5.rm)((0, import_node_path4.join)(paths.dataDir, name), { force: true });
+          await (0, import_promises9.rm)((0, import_node_path7.join)(paths.dataDir, name), { force: true });
           try {
-            await copyDurable((0, import_node_path4.join)(paths.backup, name), (0, import_node_path4.join)(paths.dataDir, name));
+            await copyDurable((0, import_node_path7.join)(paths.backup, name), (0, import_node_path7.join)(paths.dataDir, name));
           } catch (error62) {
             if (error62.code !== "ENOENT") throw error62;
           }
         }
-        await copyDurable((0, import_node_path4.join)(paths.backup, "config.json"), paths.config);
+        await copyDurable((0, import_node_path7.join)(paths.backup, "config.json"), paths.config);
       }
       const restored = await readJson(
-        (0, import_node_path4.join)(paths.root, "package.json")
+        (0, import_node_path7.join)(paths.root, "package.json")
       );
       if (restored?.name !== npmPackageName || restored.version !== record2.from)
         throw new Error("\u672A\u627E\u5230\u5B8C\u6574\u7684\u4E0A\u4E00\u7248\u672C\u5B89\u88C5");
@@ -21834,10 +22085,10 @@ async function worker(directory) {
     }
     const reason = await inspectInstallation(context.root);
     if (reason) throw new Error(reason);
-    for (const key of await (0, import_promises5.readdir)((0, import_node_path4.join)(context.location.home, "instances"))) {
+    for (const key of await (0, import_promises9.readdir)((0, import_node_path7.join)(context.location.home, "instances"))) {
       if (key === context.location.key) continue;
       const instance = await readJson(
-        (0, import_node_path4.join)(context.location.home, "instances", key, "instance.json")
+        (0, import_node_path7.join)(context.location.home, "instances", key, "instance.json")
       );
       if (instance?.root !== context.root) continue;
       try {
@@ -21847,8 +22098,8 @@ async function worker(directory) {
         if (!isNotRunning(error62)) throw error62;
       }
     }
-    await (0, import_promises5.access)((0, import_node_path4.dirname)(context.root), import_node_fs2.constants.W_OK);
-    await exec(
+    await (0, import_promises9.access)((0, import_node_path7.dirname)(context.root), import_node_fs2.constants.W_OK);
+    await exec3(
       "npm",
       [
         "install",
@@ -21865,7 +22116,7 @@ async function worker(directory) {
       { timeout: 10 * 6e4, maxBuffer: 2 * 1024 * 1024 }
     );
     const candidate = await readJson(
-      (0, import_node_path4.join)(paths.candidate, "package.json")
+      (0, import_node_path7.join)(paths.candidate, "package.json")
     );
     if (candidate?.name !== npmPackageName || candidate.version !== record2.target)
       throw new Error("\u5019\u9009\u5305\u8EAB\u4EFD\u6216\u7248\u672C\u4E0D\u5339\u914D");
@@ -21884,13 +22135,13 @@ async function worker(directory) {
       );
     };
     await checkCodex();
-    await exec(process.execPath, [(0, import_node_path4.join)(paths.candidate, "bin/covro.mjs"), "--version"], {
+    await exec3(process.execPath, [(0, import_node_path7.join)(paths.candidate, "bin/covro.mjs"), "--version"], {
       timeout: 3e4
     });
     const nativeProbe = 'const {createRequire}=await import("node:module"); const r=createRequire(process.argv[1]); const DB=r("better-sqlite3"); const db=new DB(":memory:"); db.close();';
-    await exec(
+    await exec3(
       process.execPath,
-      ["--input-type=module", "-e", nativeProbe, (0, import_node_path4.join)(paths.candidate, "package.json")],
+      ["--input-type=module", "-e", nativeProbe, (0, import_node_path7.join)(paths.candidate, "package.json")],
       { timeout: 3e4 }
     );
     await verifyMigrations(context, paths.candidate);
@@ -21908,12 +22159,12 @@ async function worker(directory) {
             return;
           }
           await update("waiting", result.reason ?? "\u7B49\u5F85\u6240\u6709\u4EFB\u52A1\u7ED3\u675F");
-          await (0, import_promises6.setTimeout)(2e3);
+          await (0, import_promises10.setTimeout)(2e3);
         }
       },
       stop: () => stopService(context),
       start: async (candidate2) => {
-        await startService(context, candidate2 ? record2.id : void 0);
+        await startService(context);
         if (!candidate2) await verifyRestoredService(context, record2.from);
       },
       verify: async () => {
@@ -21927,7 +22178,7 @@ async function worker(directory) {
             await checkCodex(current);
             if (current.codexReady) return;
           }
-          await (0, import_promises6.setTimeout)(250);
+          await (0, import_promises10.setTimeout)(250);
         }
         throw new Error("\u65B0\u7248\u670D\u52A1\u6216 Codex \u8FDE\u63A5\u672A\u5C31\u7EEA\uFF0C\u62D2\u7EDD\u6FC0\u6D3B");
       },
@@ -21936,18 +22187,18 @@ async function worker(directory) {
           id: record2.id,
           channel: record2.channel
         });
-        const final = await readJson((0, import_node_path4.join)(directory, "run.json"));
+        const final = await readJson((0, import_node_path7.join)(directory, "run.json"));
         if (!final?.committed) throw new Error("\u65B0\u7248\u5C1A\u672A\u786E\u8BA4\u5347\u7EA7\u63D0\u4EA4");
         record2 = final;
       },
-      hasCommitted: async () => Boolean((await readJson((0, import_node_path4.join)(directory, "run.json")))?.committed),
+      hasCommitted: async () => Boolean((await readJson((0, import_node_path7.join)(directory, "run.json")))?.committed),
       resume: async () => {
         await control(context.location, "cancel-update").catch(() => {
         });
       }
     });
   } catch (error62) {
-    const latest = await readJson((0, import_node_path4.join)(directory, "run.json"));
+    const latest = await readJson((0, import_node_path7.join)(directory, "run.json"));
     if (latest?.committed) {
       record2 = latest;
     } else if (!["rolledBack", "failed"].includes(record2.phase))
@@ -21957,7 +22208,7 @@ async function worker(directory) {
   } finally {
     await release();
     if (record2.phase === "succeeded" || record2.phase === "rolledBack") {
-      await (0, import_promises5.rm)(paths.prefix, { recursive: true, force: true });
+      await (0, import_promises9.rm)(paths.prefix, { recursive: true, force: true });
     }
   }
 }