@askexenow/exe-os 0.8.32 → 0.8.36

package/dist/hooks/summary-worker.js

@@ -23,12 +23,68 @@ var init_memory = __esm({
   }
 });
 
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts) => retryOnBusy(() => target.batch(stmts), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
+
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config.dbPath}`
@@ -37,20 +93,27 @@ async function initDatabase(config) {
     opts.encryptionKey = config.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 function isInitialized() {
   return _client !== null;
 }
 function getClient() {
+  if (!_resilientClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _resilientClient;
+}
+function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
   return _client;
 }
 async function ensureSchema() {
-  const client = getClient();
+  const client = getRawClient();
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -839,11 +902,13 @@ async function ensureSchema() {
     }
   }
 }
-var _client, initTurso;
+var _client, _resilientClient, initTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
+    init_db_retry();
     _client = null;
+    _resilientClient = null;
     initTurso = initDatabase;
   }
 });
@@ -1290,12 +1355,12 @@ function shardExists(projectName) {
 }
 function listShards() {
   if (!existsSync3(SHARDS_DIR)) return [];
-  const { readdirSync: readdirSync2 } = __require("fs");
-  return readdirSync2(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  const { readdirSync: readdirSync3 } = __require("fs");
+  return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1481,7 +1546,7 @@ var init_shard_manager = __esm({
 
 // src/lib/employees.ts
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync3 } from "fs";
 import { execSync } from "child_process";
 import path5 from "path";
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
@@ -1495,6 +1560,45 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
     return [];
   }
 }
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  await mkdir3(path5.dirname(employeesPath), { recursive: true });
+  await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  let exeBinPath;
+  try {
+    exeBinPath = execSync("which exe", { encoding: "utf-8" }).trim();
+  } catch {
+    errors.push("Could not find 'exe' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path5.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path5.join(binDir, linkName);
+    if (existsSync5(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
 var EMPLOYEES_PATH;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
@@ -1505,7 +1609,7 @@ var init_employees = __esm({
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
 import { randomUUID } from "crypto";
 import path6 from "path";
 import { jwtVerify, importSPKI } from "jose";
@@ -1513,14 +1617,14 @@ function loadDeviceId() {
   const deviceJsonPath = path6.join(EXE_AI_DIR, "device.json");
   try {
     if (existsSync6(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync3(deviceJsonPath, "utf8"));
+      const data = JSON.parse(readFileSync4(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
     if (existsSync6(DEVICE_ID_PATH)) {
-      const id2 = readFileSync3(DEVICE_ID_PATH, "utf8").trim();
+      const id2 = readFileSync4(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
@@ -1533,7 +1637,7 @@ function loadDeviceId() {
 function loadLicense() {
   try {
     if (!existsSync6(LICENSE_PATH)) return null;
-    return readFileSync3(LICENSE_PATH, "utf8").trim();
+    return readFileSync4(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
@@ -1563,7 +1667,7 @@ async function verifyLicenseJwt(token) {
 async function getCachedLicense() {
   try {
     if (!existsSync6(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync3(CACHE_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync4(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -1679,12 +1783,12 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync4, existsSync as existsSync7 } from "fs";
+import { readFileSync as readFileSync5, existsSync as existsSync7 } from "fs";
 import path7 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync7(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync4(CACHE_PATH2, "utf8"));
+    const raw = JSON.parse(readFileSync5(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -1752,7 +1856,7 @@ function assertEmployeeLimitSync(rosterPath) {
   let count = 0;
   try {
     if (existsSync7(filePath)) {
-      const raw = readFileSync4(filePath, "utf8");
+      const raw = readFileSync5(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -1797,7 +1901,7 @@ var init_plan_limits = __esm({
 import net from "net";
 import { spawn } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync5, openSync, closeSync, statSync } from "fs";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
 import path8 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
@@ -1822,7 +1926,7 @@ function handleData(chunk) {
 function cleanupStaleFiles() {
   if (existsSync8(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1970,11 +2074,11 @@ async function connectEmbedDaemon() {
     }
   }
   const start = Date.now();
-  let delay = 100;
+  let delay2 = 100;
   while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
+    await new Promise((r) => setTimeout(r, delay2));
     if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
   return false;
 }
@@ -2030,7 +2134,7 @@ function killAndRespawnDaemon() {
   process.stderr.write("[exed-client] Killing daemon for restart...\n");
   if (existsSync8(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, "SIGKILL");
@@ -2066,11 +2170,11 @@ async function embedViaClient(text, priority = "high") {
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay = 200;
+      let delay2 = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
+        await new Promise((r) => setTimeout(r, delay2));
         if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
+        delay2 = Math.min(delay2 * 2, 3e3);
       }
       if (!_connected) return null;
     }
@@ -2082,11 +2186,11 @@ async function embedViaClient(text, priority = "high") {
 `);
     killAndRespawnDaemon();
     const start = Date.now();
-    let delay = 200;
+    let delay2 = 200;
     while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
+      await new Promise((r) => setTimeout(r, delay2));
       if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
+      delay2 = Math.min(delay2 * 2, 3e3);
     }
     if (!_connected) return null;
     const retry = await sendRequest([text], priority);
@@ -2166,10 +2270,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync10 } = await import("fs");
-  const path10 = await import("path");
-  const modelPath = path10.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync10(modelPath)) {
+  const { existsSync: existsSync11 } = await import("fs");
+  const path11 = await import("path");
+  const modelPath = path11.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync11(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -2279,10 +2383,25 @@ var init_compress = __esm({
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
+  buildRosterBlob: () => buildRosterBlob,
   cloudPull: () => cloudPull,
+  cloudPullRoster: () => cloudPullRoster,
   cloudPush: () => cloudPush,
-  cloudSync: () => cloudSync
+  cloudPushRoster: () => cloudPushRoster,
+  cloudSync: () => cloudSync,
+  mergeRosterFromRemote: () => mergeRosterFromRemote
 });
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync9, readdirSync as readdirSync2, mkdirSync as mkdirSync3, appendFileSync } from "fs";
+import path9 from "path";
+import { homedir } from "os";
+function logError(msg) {
+  try {
+    const logPath = path9.join(homedir(), ".exe-os", "workers.log");
+    appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+`);
+  } catch {
+  }
+}
 function assertSecureEndpoint(endpoint) {
   if (endpoint.startsWith("https://")) return;
   if (endpoint.startsWith("http://")) {
@@ -2315,8 +2434,7 @@ async function cloudPush(records, maxVersion, config) {
     });
     return resp.ok;
   } catch (err) {
-    process.stderr.write(`[cloud-sync] PUSH FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    logError(`[cloud-sync] PUSH FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
 }
@@ -2347,8 +2465,7 @@ async function cloudPull(sinceVersion, config) {
     }
     return { records: allRecords, maxVersion: data.max_version ?? sinceVersion };
   } catch (err) {
-    process.stderr.write(`[cloud-sync] PULL FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
+    logError(`[cloud-sync] PULL FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return { records: [], maxVersion: sinceVersion };
   }
 }
@@ -2437,8 +2554,137 @@ async function cloudSync(config) {
       pushed = records.length;
     }
   }
+  try {
+    await cloudPushRoster(config);
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] Roster push warning: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+  try {
+    await cloudPullRoster(config);
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] Roster pull warning: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
   return { pushed, pulled };
 }
+function buildRosterBlob(paths) {
+  const rosterPath = paths?.rosterPath ?? path9.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path9.join(EXE_AI_DIR, "identity");
+  let roster = [];
+  if (existsSync9(rosterPath)) {
+    try {
+      roster = JSON.parse(readFileSync7(rosterPath, "utf-8"));
+    } catch {
+    }
+  }
+  const identities = {};
+  if (existsSync9(identityDir)) {
+    for (const file of readdirSync2(identityDir).filter((f) => f.endsWith(".md"))) {
+      try {
+        identities[file] = readFileSync7(path9.join(identityDir, file), "utf-8");
+      } catch {
+      }
+    }
+  }
+  const content = JSON.stringify({ roster, identities });
+  const hash = Buffer.from(content).length;
+  return { roster, identities, version: hash };
+}
+async function cloudPushRoster(config) {
+  assertSecureEndpoint(config.endpoint);
+  const blob = buildRosterBlob();
+  if (blob.roster.length === 0) return true;
+  try {
+    const client = getClient();
+    const meta = await client.execute(
+      "SELECT value FROM sync_meta WHERE key = 'last_roster_push_version'"
+    );
+    const lastVersion = meta.rows.length > 0 ? Number(meta.rows[0].value) : 0;
+    if (blob.version === lastVersion) return true;
+  } catch {
+  }
+  try {
+    const json = JSON.stringify(blob);
+    const compressed = compress(Buffer.from(json, "utf8"));
+    const encrypted = encryptSyncBlob(compressed);
+    const resp = await fetch(`${config.endpoint}/sync/push-roster`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "Content-Type": "application/json",
+        "X-Device-Id": loadDeviceId()
+      },
+      body: JSON.stringify({ blob: encrypted })
+    });
+    if (resp.ok) {
+      try {
+        const client = getClient();
+        await client.execute({
+          sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_roster_push_version', ?)",
+          args: [String(blob.version)]
+        });
+      } catch {
+      }
+    }
+    return resp.ok;
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] ROSTER PUSH FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+    return false;
+  }
+}
+async function cloudPullRoster(config) {
+  assertSecureEndpoint(config.endpoint);
+  try {
+    const resp = await fetch(`${config.endpoint}/sync/pull-roster`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${config.apiKey}`,
+        "X-Device-Id": loadDeviceId()
+      }
+    });
+    if (!resp.ok) return { added: 0 };
+    const data = await resp.json();
+    if (!data.blob) return { added: 0 };
+    const compressed = decryptSyncBlob(data.blob);
+    const json = decompress(compressed).toString("utf8");
+    const remote = JSON.parse(json);
+    return mergeRosterFromRemote(remote);
+  } catch (err) {
+    process.stderr.write(`[cloud-sync] ROSTER PULL FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+    return { added: 0 };
+  }
+}
+async function mergeRosterFromRemote(remote, paths) {
+  const rosterPath = paths?.rosterPath ?? void 0;
+  const identityDir = paths?.identityDir ?? path9.join(EXE_AI_DIR, "identity");
+  const localEmployees = await loadEmployees(rosterPath);
+  const localNames = new Set(localEmployees.map((e) => e.name));
+  let added = 0;
+  for (const remoteEmp of remote.roster) {
+    if (localNames.has(remoteEmp.name)) continue;
+    localEmployees.push(remoteEmp);
+    localNames.add(remoteEmp.name);
+    added++;
+    if (remote.identities[`${remoteEmp.name}.md`]) {
+      if (!existsSync9(identityDir)) mkdirSync3(identityDir, { recursive: true });
+      const idPath = path9.join(identityDir, `${remoteEmp.name}.md`);
+      if (!existsSync9(idPath)) {
+        writeFileSync2(idPath, remote.identities[`${remoteEmp.name}.md`], "utf-8");
+      }
+    }
+    try {
+      registerBinSymlinks(remoteEmp.name);
+    } catch {
+    }
+  }
+  if (added > 0) {
+    await saveEmployees(localEmployees, rosterPath);
+  }
+  return { added };
+}
 var LOCALHOST_PATTERNS;
 var init_cloud_sync = __esm({
   "src/lib/cloud-sync.ts"() {
@@ -2448,6 +2694,8 @@ var init_cloud_sync = __esm({
     init_compress();
     init_plan_limits();
     init_license();
+    init_config();
+    init_employees();
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
   }
 });
@@ -2724,8 +2972,8 @@ async function writeNotification(notification) {
 
 // src/adapters/claude/hooks/summary-worker.ts
 import { execSync as execSync2 } from "child_process";
-import { existsSync as existsSync9, mkdirSync as mkdirSync3, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import path9 from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import path10 from "path";
 async function main() {
   const agentId = process.env.AGENT_ID ?? "default";
   const agentRole = process.env.AGENT_ROLE ?? "employee";
@@ -2832,28 +3080,33 @@ async function main() {
   try {
     const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
     const vector = await embed2(summaryText);
-    await client.execute({
-      sql: `UPDATE memories SET vector = vector32(?) WHERE rowid = (
-        SELECT rowid FROM memories WHERE agent_id = ? AND tool_name = 'auto-summary'
-        ORDER BY timestamp DESC LIMIT 1
-      )`,
-      args: [vectorToBlob(vector), agentId]
+    const rowResult = await client.execute({
+      sql: `SELECT rowid FROM memories WHERE agent_id = ? AND tool_name = 'auto-summary'
+            ORDER BY timestamp DESC LIMIT 1`,
+      args: [agentId]
     });
+    const targetRowid = rowResult.rows[0]?.rowid;
+    if (targetRowid != null) {
+      await client.execute({
+        sql: `UPDATE memories SET vector = vector32(?) WHERE rowid = ?`,
+        args: [vectorToBlob(vector), targetRowid]
+      });
+    }
   } catch (err) {
     process.stderr.write("[summary-worker] embed failed: " + (err instanceof Error ? err.message : String(err)) + "\n");
   }
   try {
     const { EXE_AI_DIR: EXE_AI_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-    const flagPath = path9.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
-    if (existsSync9(flagPath)) {
+    const flagPath = path10.join(EXE_AI_DIR2, "session-cache", "needs-backfill");
+    if (existsSync10(flagPath)) {
       const { spawn: spawn2 } = await import("child_process");
       const { fileURLToPath: fileURLToPath2 } = await import("url");
       const thisFile = fileURLToPath2(import.meta.url);
-      const backfillPath = path9.resolve(path9.dirname(thisFile), "backfill-vectors.js");
-      if (existsSync9(backfillPath)) {
+      const backfillPath = path10.resolve(path10.dirname(thisFile), "backfill-vectors.js");
+      if (existsSync10(backfillPath)) {
         const { EXE_AI_DIR: exeDir2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const bLogPath = path9.join(exeDir2, "workers.log");
-        mkdirSync3(path9.dirname(bLogPath), { recursive: true });
+        const bLogPath = path10.join(exeDir2, "workers.log");
+        mkdirSync4(path10.dirname(bLogPath), { recursive: true });
         const bLogFd = openSync2(bLogPath, "a");
         const child = spawn2(process.execPath, [backfillPath], {
           detached: true,