@runeya/runeya 2.0.121 → 2.0.123

package/chunk-HK5QNU6P.js

@@ -0,0 +1,117 @@
+import {
+  machineRoot
+} from "./chunk-ZFELQG4B.js";
+
+// ../server/src/services/disk-freshness.ts
+import { stat } from "fs/promises";
+var seen = /* @__PURE__ */ new Map();
+async function rememberFile(path) {
+  try {
+    const s = await stat(path);
+    seen.set(path, { mtimeMs: s.mtimeMs, size: s.size, ino: s.ino });
+  } catch {
+    seen.delete(path);
+  }
+}
+async function hasChangedSinceRead(path) {
+  const known = seen.get(path);
+  if (!known) return true;
+  try {
+    const s = await stat(path);
+    return s.mtimeMs !== known.mtimeMs || s.size !== known.size || s.ino !== known.ino;
+  } catch {
+    return true;
+  }
+}
+function wasRead(path) {
+  return seen.has(path);
+}
+async function fingerprintFiles(paths) {
+  const stamps = await Promise.all(paths.map(async (path) => {
+    try {
+      const s = await stat(path);
+      return `${path}:${s.mtimeMs}:${s.size}:${s.ino}`;
+    } catch {
+      return `${path}:-`;
+    }
+  }));
+  return stamps.sort().join("|");
+}
+
+// ../server/src/services/run-store-utils.ts
+import { randomUUID } from "crypto";
+import { chmod, mkdir, readdir, rename, rm, stat as stat2, writeFile, readFile } from "fs/promises";
+import { dirname, join, resolve, sep } from "path";
+var SAFE_PATH_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;
+function resolveConversationRunDir(rootDirName, conversationId) {
+  if (!SAFE_PATH_SEGMENT_RE.test(conversationId)) {
+    throw new Error("Invalid conversationId");
+  }
+  const base = resolve(machineRoot(), rootDirName);
+  const dir = resolve(base, conversationId);
+  if (!dir.startsWith(base + sep)) {
+    throw new Error("Invalid conversationId");
+  }
+  return dir;
+}
+async function atomicWriteSecure(filePath, content) {
+  await mkdir(dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(tmpPath, content, typeof content === "string" ? "utf-8" : void 0);
+    await rename(tmpPath, filePath);
+  } catch (err) {
+    await rm(tmpPath, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+  await chmod(filePath, 384);
+}
+var OWN_TEMP_RE = /\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.tmp$/;
+var STALE_TEMP_MS = 36e5;
+async function sweepStaleTempFiles(dirs) {
+  let removed = 0;
+  const limit = Date.now() - STALE_TEMP_MS;
+  for (const dir of dirs) {
+    let names;
+    try {
+      names = await readdir(dir);
+    } catch {
+      continue;
+    }
+    for (const name of names.filter((n) => OWN_TEMP_RE.test(n))) {
+      const path = join(dir, name);
+      try {
+        if ((await stat2(path)).mtimeMs > limit) continue;
+        await rm(path, { force: true });
+        removed += 1;
+      } catch {
+      }
+    }
+  }
+  return removed;
+}
+async function atomicWriteJsonSecure(filePath, data, pretty = false) {
+  await atomicWriteSecure(filePath, JSON.stringify(data, null, pretty ? 2 : 0));
+}
+async function readJsonFileSafe(filePath) {
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  rememberFile,
+  hasChangedSinceRead,
+  wasRead,
+  fingerprintFiles,
+  resolveConversationRunDir,
+  atomicWriteSecure,
+  sweepStaleTempFiles,
+  atomicWriteJsonSecure,
+  readJsonFileSafe
+};
+//# sourceMappingURL=chunk-HK5QNU6P.js.map

package/chunk-HK5QNU6P.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../server/src/services/disk-freshness.ts","../../server/src/services/run-store-utils.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\n\n/**\n * Le fichier a-t-il changé depuis qu'on l'a lu ?\n *\n * Les stores gardent de côté ce qu'ils n'ont pas su déchiffrer, pour le\n * réécrire tel quel plutôt que de l'effacer. Cette copie est la bonne réponse\n * tant que personne d'autre ne touche au fichier — et la mauvaise dès que\n * quelqu'un le répare par-dessous : la copie, elle, ne se périme jamais, et la\n * sauvegarde suivante réinstalle l'état d'avant la réparation.\n *\n * C'est arrivé deux fois de suite sur le même coffre : une conversion de clé\n * menée sur le disque, défaite quelques minutes plus tard par un store qui\n * tenait encore l'ancien chiffré en mémoire.\n *\n * D'où ce repère : l'empreinte du fichier au moment de la lecture. Si elle a\n * bougé, la copie mémoire ne fait plus foi et doit être abandonnée.\n */\n\ninterface Fingerprint {\n  mtimeMs: number;\n  size: number;\n  /**\n   * L'inode du chemin, qui change à chaque `rename` par-dessus.\n   *\n   * La date et la taille laissent passer le motif d'écriture de tout le dépôt :\n   * les stores réécrivent le fichier entier, donc une modification rend souvent\n   * le même nombre d'octets, et deux instances qui réagissent au même événement\n   * écrivent dans la même milliseconde. Le fichier temporaire renommé\n   * par-dessus, lui, installe toujours un autre inode.\n   *\n   * Là où le système n'en expose pas (il rend alors 0), le repère retombe sur\n   * la date et la taille — ce qu'il valait avant.\n   */\n  ino: number;\n}\n\nconst seen = new Map<string, Fingerprint>();\n\n/** Retenir l'état d'un fichier au moment où on vient de le lire. */\nexport async function rememberFile(path: string): Promise<void> {\n  try {\n    const s = await stat(path);\n    seen.set(path, { mtimeMs: s.mtimeMs, size: s.size, ino: s.ino });\n  } catch {\n    // Pas encore de fichier : rien à retenir, et rien à réémettre non plus.\n    seen.delete(path);\n  }\n}\n\n/**\n * Vrai si le fichier a changé — ou si l'on ne sait pas.\n *\n * L'ignorance compte comme un changement : réécrire une copie dont on ne peut\n * plus prouver qu'elle correspond au disque est précisément le geste à éviter.\n */\nexport async function hasChangedSinceRead(path: string): Promise<boolean> {\n  const known = seen.get(path);\n  if (!known) return true;\n  try {\n    const s = await stat(path);\n    return s.mtimeMs !== known.mtimeMs || s.size !== known.size || s.ino !== known.ino;\n  } catch {\n    return true;\n  }\n}\n\n/**\n * A-t-on lu ce fichier ?\n *\n * `hasChangedSinceRead` tient l'ignorance pour un changement : c'est juste\n * quand il s'agit de décider si une copie mémoire fait encore foi. Ça ne l'est\n * pas pour décider d'écrire — un fichier jamais lu est le cas d'un coffre neuf,\n * et le traiter comme « modifié sous nos pieds » revenait à ne jamais écrire la\n * première fois. Les appelants qui protègent une écriture demandent donc les\n * deux : connu, et inchangé.\n */\nexport function wasRead(path: string): boolean {\n  return seen.has(path);\n}\n\n/** Oublier un fichier — après un rechargement complet, par exemple. */\nexport function forgetFile(path: string): void {\n  seen.delete(path);\n}\n\n/**\n * L'empreinte d'un ensemble de fichiers : lesquels, et dans quel état.\n *\n * Le repère ci-dessus répond pour un fichier qu'on a lu soi-même ; celui-ci\n * répond pour un store dont le contenu vient de plusieurs fichiers à la fois —\n * un par coffre — et dont la question est « le disque a-t-il bougé depuis mon\n * dernier chargement ? ». Comparer deux empreintes coûte quelques `stat` ;\n * recharger coûte autant de lectures, d'analyses et de déchiffrements.\n *\n * L'absence d'un fichier en fait partie : un coffre disparu change l'empreinte\n * autant qu'un coffre modifié.\n */\nexport async function fingerprintFiles(paths: string[]): Promise<string> {\n  const stamps = await Promise.all(paths.map(async (path) => {\n    try {\n      const s = await stat(path);\n      // L'inode en fait partie pour la raison décrite sur `Fingerprint` : un\n      // fichier renommé par-dessus la cible peut n'avoir bougé ni en taille ni\n      // en date, et reste pourtant un autre contenu.\n      return `${path}:${s.mtimeMs}:${s.size}:${s.ino}`;\n    } catch {\n      return `${path}:-`;\n    }\n  }));\n  return stamps.sort().join('|');\n}\n","import { randomUUID } from 'node:crypto';\nimport { chmod, mkdir, readdir, rename, rm, stat, writeFile, readFile } from 'node:fs/promises';\nimport { dirname, join, resolve, sep } from 'node:path';\nimport { machineRoot } from './vault-resolver.js';\n\nconst SAFE_PATH_SEGMENT_RE = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/;\n\nexport function resolveConversationRunDir(rootDirName: string, conversationId: string): string {\n  if (!SAFE_PATH_SEGMENT_RE.test(conversationId)) {\n    throw new Error('Invalid conversationId');\n  }\n  // Machine-wide, like the conversations these runs belong to: using the launch\n  // directory would put a `.runeya` in a repository just for asking the AI a\n  // question about a cloud project.\n  const base = resolve(machineRoot(), rootDirName);\n  const dir = resolve(base, conversationId);\n  if (!dir.startsWith(base + sep)) {\n    throw new Error('Invalid conversationId');\n  }\n  return dir;\n}\n\nexport async function atomicWriteSecure(filePath: string, content: string | Uint8Array): Promise<void> {\n  await mkdir(dirname(filePath), { recursive: true });\n  // Un nom par écriture : deux Runeya d'un même poste écrivent les mêmes\n  // fichiers, et un `.tmp` commun se fait renommer sous le nez de l'autre.\n  const tmpPath = `${filePath}.${process.pid}.${randomUUID()}.tmp`;\n  try {\n    await writeFile(tmpPath, content, typeof content === 'string' ? 'utf-8' : undefined);\n    await rename(tmpPath, filePath);\n  } catch (err) {\n    // Un nom unique ne se réécrit jamais : laissé là, chaque échec en ajouterait un.\n    await rm(tmpPath, { force: true }).catch(() => {});\n    throw err;\n  }\n  await chmod(filePath, 0o600);\n}\n\n/** Le nom qu'`atomicWriteSecure` donne à ses fichiers temporaires : `<fichier>.<pid>.<uuid>.tmp`. */\nconst OWN_TEMP_RE = /\\.\\d+\\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\\.tmp$/;\nconst STALE_TEMP_MS = 3600_000;\n\n/**\n * Retirer les fichiers temporaires qu'un arrêt brutal a laissés.\n *\n * Un nom par écriture ne se réécrit jamais : chaque arrêt en pleine écriture en\n * laissait un pour toujours. Seuls les nôtres sont concernés, et seulement\n * passé une heure — un plus récent peut appartenir à une écriture en cours,\n * celle d'une autre Runeya du même poste.\n */\nexport async function sweepStaleTempFiles(dirs: string[]): Promise<number> {\n  let removed = 0;\n  const limit = Date.now() - STALE_TEMP_MS;\n  for (const dir of dirs) {\n    let names: string[];\n    try {\n      names = await readdir(dir);\n    } catch {\n      continue;\n    }\n    for (const name of names.filter((n) => OWN_TEMP_RE.test(n))) {\n      const path = join(dir, name);\n      try {\n        if ((await stat(path)).mtimeMs > limit) continue;\n        await rm(path, { force: true });\n        removed += 1;\n      } catch {\n        // Disparu entre-temps : rien à retirer.\n      }\n    }\n  }\n  return removed;\n}\n\nexport async function atomicWriteJsonSecure(filePath: string, data: unknown, pretty = false): Promise<void> {\n  await atomicWriteSecure(filePath, JSON.stringify(data, null, pretty ? 2 : 0));\n}\n\nexport async function readJsonFileSafe<T>(filePath: string): Promise<T | null> {\n  try {\n    const raw = await readFile(filePath, 'utf-8');\n    return JSON.parse(raw) as T;\n  } catch {\n    return null;\n  }\n}\n"],"mappings":"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","names":["stat","stat"]}

package/{chunk-CNTL6NVU.js → chunk-MSLFR2EN.js}

@@ -1,9 +1,10 @@
 import {
+  atomicWriteSecure,
   fingerprintFiles,
   hasChangedSinceRead,
   rememberFile,
   wasRead
-} from "./chunk-YZU5FNXR.js";
+} from "./chunk-HK5QNU6P.js";
 import {
   AGENT_FETCH_TIMEOUT,
   AGENT_HEALTH_POLL_INTERVAL,
@@ -390,7 +391,7 @@ var agentStore = new AgentStore();
 
 // ../server/src/services/service-store.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { readFile as readFile3, writeFile as writeFile3, rename as rename3, mkdir as mkdir3, chmod as chmod3, rm as rm2 } from "fs/promises";
+import { readFile as readFile3, rm as rm2 } from "fs/promises";
 import { join as join3 } from "path";
 
 // ../server/src/services/project-key.ts
@@ -501,9 +502,49 @@ function isVaultConflicted(root) {
   return conflicted.has(root);
 }
 
+// ../server/src/services/store-disk-coordinator.ts
+import { AsyncLocalStorage } from "async_hooks";
+var insideReload = new AsyncLocalStorage();
+var StoreDiskCoordinator = class {
+  reloading = null;
+  saves = 0;
+  queue = Promise.resolve();
+  /**
+   * `read` rend de quoi substituer le nouvel état, ou `null` s'il n'y a rien à
+   * relire. La substitution doit être synchrone : c'est ce qui la rend atomique.
+   */
+  load(read) {
+    const inside = insideReload.getStore();
+    if (inside && (inside.has(this) || this.reloading)) return Promise.resolve();
+    this.reloading ??= this.reload(read).finally(() => {
+      this.reloading = null;
+    });
+    return this.reloading;
+  }
+  async reload(read) {
+    for (; ; ) {
+      await this.queue;
+      const savesBefore = this.saves;
+      const outer = insideReload.getStore() ?? /* @__PURE__ */ new Set();
+      const commit = await insideReload.run(/* @__PURE__ */ new Set([...outer, this]), read);
+      if (!commit) return;
+      if (this.saves !== savesBefore) continue;
+      commit();
+      return;
+    }
+  }
+  save(write) {
+    this.saves += 1;
+    const run = this.queue.then(write);
+    this.queue = run.catch(() => {
+    });
+    return run;
+  }
+};
+
 // ../server/src/services/environment-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile2, writeFile as writeFile2, rename as rename2, mkdir as mkdir2, chmod as chmod2, rm } from "fs/promises";
+import { readFile as readFile2, rm } from "fs/promises";
 import { join as join2 } from "path";
 
 // ../server/src/services/crypto-helpers.ts
@@ -647,6 +688,7 @@ var EnvironmentStore = class {
    * refusée l'est pour toujours et la modification de l'utilisateur se perd.
    */
   fingerprint = "";
+  disk = new StoreDiskCoordinator();
   listeners = /* @__PURE__ */ new Set();
   /** Notified after every persisted mutation, for the cloud sync bridge. */
   onChange(fn) {
@@ -810,7 +852,7 @@ var EnvironmentStore = class {
     }
     return result;
   }
-  decryptEnvironment(environment, vault) {
+  decryptEnvironment(environment, vault, unreadable = this.unreadableSecrets) {
     let decryptedVars = environment.variables;
     if (environment.variables && Object.keys(environment.variables).length > 0) {
       const failed = /* @__PURE__ */ new Set();
@@ -820,8 +862,8 @@ var EnvironmentStore = class {
         (variableId) => failed.add(variableId),
         vault ?? this.vaultOf(environment)
       );
-      if (failed.size > 0) this.unreadableSecrets.set(environment.id, failed);
-      else this.unreadableSecrets.delete(environment.id);
+      if (failed.size > 0) unreadable.set(environment.id, failed);
+      else unreadable.delete(environment.id);
     }
     return { ...environment, variables: decryptedVars };
   }
@@ -837,39 +879,47 @@ var EnvironmentStore = class {
    * store reads environments while absorbing a project, which would deadlock).
    */
   async load() {
-    const fingerprint = await this.diskFingerprint();
-    if (this.loaded && fingerprint === this.fingerprint) return;
-    this.loaded = true;
-    this.fingerprint = fingerprint;
-    await ensureProjectsLoaded();
-    if (!getEncryptionKey()) {
-      this.loaded = false;
-      return;
-    }
-    const roots = await allVaultRoots();
-    this.environments.clear();
-    this.diskEncryptedSlots.clear();
-    this.roots.clear();
-    this.unreadableSecrets.clear();
-    for (const root of roots) {
+    await this.disk.load(async () => {
+      const fingerprint = await this.diskFingerprint();
+      if (this.loaded && fingerprint === this.fingerprint) return null;
+      await ensureProjectsLoaded();
+      if (!getEncryptionKey()) return null;
+      const next = await this.readVaults();
+      return () => {
+        this.environments = next.environments;
+        this.diskEncryptedSlots = next.diskEncryptedSlots;
+        this.roots = next.roots;
+        this.unreadableSecrets = next.unreadableSecrets;
+        this.fingerprint = fingerprint;
+        this.loaded = true;
+      };
+    });
+  }
+  /** Lire tous les coffres dans des tables neuves, que `load` substitue d'un coup. */
+  async readVaults() {
+    const environments = /* @__PURE__ */ new Map();
+    const diskEncryptedSlots = /* @__PURE__ */ new Map();
+    const roots = /* @__PURE__ */ new Map();
+    const unreadableSecrets = /* @__PURE__ */ new Map();
+    for (const root of await allVaultRoots()) {
       try {
         const raw = await readFile2(this.getFilePath(root), "utf-8");
         await rememberFile(this.getFilePath(root));
         const data = JSON.parse(raw);
-        const clash = data.find((e) => this.environments.has(e.id) && this.roots.get(e.id) !== root);
+        const clash = data.find((e) => environments.has(e.id) && roots.get(e.id) !== root);
         if (clash) {
           markVaultConflict(root, `environnement ${clash.id}`);
           continue;
         }
         for (const e of data) {
-          this.diskEncryptedSlots.set(e.id, this.extractEncryptedCache(e));
-          this.roots.set(e.id, root);
-          const decrypted = this.decryptEnvironment(e, vaultIdOfRoot(root));
-          this.environments.set(e.id, decrypted);
+          diskEncryptedSlots.set(e.id, this.extractEncryptedCache(e));
+          roots.set(e.id, root);
+          environments.set(e.id, this.decryptEnvironment(e, vaultIdOfRoot(root), unreadableSecrets));
         }
       } catch {
       }
     }
+    return { environments, diskEncryptedSlots, roots, unreadableSecrets };
   }
   /**
    * Write each vault that holds — or held — an environment.
@@ -891,7 +941,10 @@ var EnvironmentStore = class {
       if (wasRead(path) && await hasChangedSinceRead(path)) this.staleRoots.add(root);
     }
   }
-  async save() {
+  save() {
+    return this.disk.save(() => this.writeVaults());
+  }
+  async writeVaults() {
     await this.markStaleRoots();
     const byRoot = /* @__PURE__ */ new Map();
     for (const root of this.roots.values()) {
@@ -921,11 +974,7 @@ var EnvironmentStore = class {
         });
         continue;
       }
-      await mkdir2(root, { recursive: true });
-      const tmpPath = filePath + ".tmp";
-      await writeFile2(tmpPath, JSON.stringify(environments, null, 2), "utf-8");
-      await rename2(tmpPath, filePath);
-      await chmod2(filePath, 384);
+      await atomicWriteSecure(filePath, JSON.stringify(environments, null, 2));
       await rememberFile(filePath);
     }
     this.fingerprint = await this.diskFingerprint();
@@ -1273,6 +1322,7 @@ var ServiceStore = class {
    * pour toutes ne verrait jamais les services créés par l'autre.
    */
   fingerprint = "";
+  disk = new StoreDiskCoordinator();
   listeners = /* @__PURE__ */ new Set();
   /**
    * Last on-disk (encrypted) form per service id, so `prepareForDisk` can reuse
@@ -1344,20 +1394,30 @@ var ServiceStore = class {
    */
   async load() {
     if (!getEncryptionKey()) return;
-    const fingerprint = await this.diskFingerprint();
-    if (this.loaded && fingerprint === this.fingerprint) return;
-    this.loaded = true;
-    this.fingerprint = fingerprint;
-    await ensureProjectsLoaded();
-    const roots = await allVaultRoots();
-    this.services.clear();
-    this.diskForm.clear();
-    this.roots.clear();
-    for (const root of roots) {
+    await this.disk.load(async () => {
+      const fingerprint = await this.diskFingerprint();
+      if (this.loaded && fingerprint === this.fingerprint) return null;
+      await ensureProjectsLoaded();
+      const next = await this.readVaults();
+      return () => {
+        this.services = next.services;
+        this.diskForm = next.diskForm;
+        this.roots = next.roots;
+        this.fingerprint = fingerprint;
+        this.loaded = true;
+        if (this.services.size > 0) this.notify();
+      };
+    });
+  }
+  async readVaults() {
+    const services = /* @__PURE__ */ new Map();
+    const diskForm = /* @__PURE__ */ new Map();
+    const roots = /* @__PURE__ */ new Map();
+    for (const root of await allVaultRoots()) {
       try {
         const raw = await readFile3(this.getFilePath(root), "utf-8");
         const data = JSON.parse(raw);
-        const clash = data.find((s) => this.services.has(s.id) && this.roots.get(s.id) !== root);
+        const clash = data.find((s) => services.has(s.id) && roots.get(s.id) !== root);
         if (clash) {
           markVaultConflict(root, `service ${clash.id}`);
           continue;
@@ -1368,17 +1428,17 @@ var ServiceStore = class {
               if (cmd.shell === void 0) cmd.shell = true;
             }
           }
-          this.diskForm.set(s.id, s);
-          this.services.set(s.id, {
+          diskForm.set(s.id, s);
+          services.set(s.id, {
             ...s,
             logSources: decryptLogSources(s.logSources ?? [], vaultIdOfRoot(root))
           });
-          this.roots.set(s.id, root);
+          roots.set(s.id, root);
         }
       } catch {
       }
     }
-    if (this.services.size > 0) this.notify();
+    return { services, diskForm, roots };
   }
   /**
    * Write each vault that holds — or held — a service.
@@ -1387,7 +1447,10 @@ var ServiceStore = class {
    * another vault must not survive in the one it left, and a `[]` left behind
    * would keep (or recreate) a `.runeya` in a directory that holds nothing.
    */
-  async save() {
+  save() {
+    return this.disk.save(() => this.writeVaults());
+  }
+  async writeVaults() {
     const byRoot = /* @__PURE__ */ new Map();
     for (const root of this.roots.values()) {
       if (!isVaultConflicted(root)) byRoot.set(root, []);
@@ -1410,11 +1473,7 @@ var ServiceStore = class {
         });
         continue;
       }
-      await mkdir3(root, { recursive: true });
-      const tmpPath = filePath + ".tmp";
-      await writeFile3(tmpPath, JSON.stringify(services, null, 2), "utf-8");
-      await rename3(tmpPath, filePath);
-      await chmod3(filePath, 384);
+      await atomicWriteSecure(filePath, JSON.stringify(services, null, 2));
     }
     this.fingerprint = await this.diskFingerprint();
   }
@@ -1627,7 +1686,7 @@ import { dirname as dirname2, join as join5 } from "path";
 import { fileURLToPath } from "url";
 
 // ../server/src/services/instance-registry.ts
-import { mkdir as mkdir4, readdir, readFile as readFile4, writeFile as writeFile4, rm as rm3 } from "fs/promises";
+import { mkdir as mkdir2, readdir, readFile as readFile4, writeFile as writeFile2, rm as rm3 } from "fs/promises";
 import { readFileSync } from "fs";
 import dotenv from "dotenv";
 import { spawn } from "child_process";
@@ -1724,9 +1783,9 @@ function selfRecord() {
 }
 async function registerInstance() {
   try {
-    await mkdir4(registryDir(), { recursive: true });
+    await mkdir2(registryDir(), { recursive: true });
     published = selfRecord();
-    await writeFile4(fileFor(process.pid), JSON.stringify(published, null, 2));
+    await writeFile2(fileFor(process.pid), JSON.stringify(published, null, 2));
   } catch (err) {
     console.log("[instances] Could not register this instance:", err.message);
   }
@@ -1739,7 +1798,7 @@ async function setInstanceAgentPid(agentPid) {
   if (!published) return;
   published = { ...published, agentPid: agentPid ?? void 0 };
   try {
-    await writeFile4(fileFor(process.pid), JSON.stringify(published, null, 2));
+    await writeFile2(fileFor(process.pid), JSON.stringify(published, null, 2));
   } catch {
   }
 }
@@ -3011,6 +3070,7 @@ export {
   decryptVariableSlots,
   extractEncryptedVariableSlots,
   isEncryptedValue,
+  StoreDiskCoordinator,
   projectKey,
   AmbiguousProjectError,
   registerProjectLoader,
@@ -3035,4 +3095,4 @@ export {
   traefikManager,
   agentManager
 };
-//# sourceMappingURL=chunk-CNTL6NVU.js.map
+//# sourceMappingURL=chunk-MSLFR2EN.js.map