@runeya/runeya 2.0.120 → 2.0.122

package/{chunk-NYKFDU76.js → chunk-VNLIA5PV.js}

@@ -6,6 +6,7 @@ import {
 } from "./chunk-MD3VW4HQ.js";
 import {
   AmbiguousProjectError,
+  StoreDiskCoordinator,
   agentManager,
   decryptValue,
   encryptValue,
@@ -13,24 +14,28 @@ import {
   environmentStore,
   forgetProject,
   getEncryptionKey,
-  hasChangedSinceRead,
   projectKey,
   refOfProjectAmong,
   registerProjectLoader,
-  rememberFile,
   rootOfProjectAmong,
   rootOfProjectRef,
   serviceStore,
   setProjectServices,
-  setProjectVault,
+  setProjectVault
+} from "./chunk-XTLQOYLT.js";
+import {
+  atomicWriteSecure,
+  fingerprintFiles,
+  hasChangedSinceRead,
+  rememberFile,
   wasRead
-} from "./chunk-2WXQIUVC.js";
+} from "./chunk-GL7WA5K3.js";
 import {
   COMPANION_RELAY_CLOSE,
   COMPANION_RELAY_OPEN,
   ProjectSchema,
   extractCompanionRelay
-} from "./chunk-H6VIS4OY.js";
+} from "./chunk-T2BV5WZE.js";
 import {
   allVaultRoots,
   ensureLocalVault,
@@ -50,14 +55,14 @@ import { EventEmitter as EventEmitter4 } from "events";
 
 // ../server/src/services/conversation-store.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { readFile as readFile3, writeFile as writeFile4, rename as rename3, mkdir as mkdir3, chmod as chmod3 } from "fs/promises";
+import { readFile as readFile3, mkdir as mkdir2 } from "fs/promises";
 import { dirname, join as join4 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
 
 // ../server/src/services/project-store.ts
 import { randomUUID } from "crypto";
 import { EventEmitter } from "events";
-import { readFile as readFile2, writeFile as writeFile3, rename as rename2, mkdir as mkdir2, chmod as chmod2, rm } from "fs/promises";
+import { readFile as readFile2, rename as rename2, rm } from "fs/promises";
 import { join as join3 } from "path";
 
 // ../server/src/utils/ensure-data-gitignore.ts
@@ -267,22 +272,27 @@ var ProjectStore = class {
    */
   projects = /* @__PURE__ */ new Map();
   loaded = false;
+  /**
+   * L'état du disque tel qu'il était au dernier chargement.
+   *
+   * Plusieurs Runeya partagent la racine machine — l'application installée et
+   * celle qu'on développe, couramment — et créent donc des projets dans les
+   * mêmes coffres. Un store chargé une fois pour toutes ne voit jamais le
+   * travail de l'autre : il faudrait le redémarrer pour qu'un projet créé à
+   * côté existe pour lui.
+   */
+  fingerprint = "";
+  disk = new StoreDiskCoordinator();
   /** Emits `'saved'` after every persisted mutation, for the cloud sync bridge. */
   events = new EventEmitter();
   getFilePath(root = localVaultRoot()) {
     return join3(root, FILENAME2);
   }
-  async writeAtomic(filePath, data) {
-    const tmpPath = filePath + ".tmp";
-    await writeFile3(tmpPath, data, "utf-8");
-    await rename2(tmpPath, filePath);
-    await chmod2(filePath, 384);
-  }
   /** Adopt a project read from disk, remembering which vault it came from. */
-  async absorb(p, root) {
+  async absorb(into, p, root) {
     const projectEnvs = await environmentStore.getByProjectId(p.id).catch(() => []);
     const defaultEnv = projectEnvs.find((e) => e.default);
-    this.projects.set(projectKey(p), {
+    into.set(projectKey(p), {
       ...p,
       environmentIds: p.environmentIds ?? [],
       groupOrder: p.groupOrder ?? [],
@@ -292,6 +302,21 @@ var ProjectStore = class {
     setProjectVault(p, root);
     setProjectServices(p, p.serviceIds ?? []);
   }
+  /**
+   * Ce que le disque porte : quels coffres, et quand leur fiche a changé.
+   *
+   * Les coffres sont demandés à `listCloudVaults`, qui les découvre déjà par
+   * balayage — en refaire un ici donnerait deux inventaires à tenir d'accord.
+   * Seules les dates sont relevées : lire et analyser les fiches, puis les
+   * absorber (ce qui va interroger les environnements), est justement ce que ce
+   * repère évite de refaire à chaque appel.
+   */
+  async diskFingerprint() {
+    return fingerprintFiles([
+      this.getFilePath(),
+      ...(await listCloudVaults()).map((v) => this.getFilePath(v.root))
+    ]);
+  }
   /**
    * Read every vault: the launch directory, then each organization's projects.
    *
@@ -299,28 +324,53 @@ var ProjectStore = class {
    * than from an index. An index is one more thing that can disagree with the
    * disk — and a project present on disk but missing from it is exactly the
    * "already here, still shown as downloadable" bug.
+   *
+   * Relu quand le disque a bougé, pas une fois pour toutes : une autre instance
+   * partageant cette racine machine y crée des projets, et ne jamais relire
+   * reviendrait à exiger un redémarrage pour les voir.
    */
   async load() {
-    if (this.loaded) return;
-    this.loaded = true;
+    let migrated = false;
+    await this.disk.load(async () => {
+      const fingerprint = await this.diskFingerprint();
+      if (this.loaded && fingerprint === this.fingerprint) return null;
+      const next = await this.readVaults();
+      return () => {
+        for (const [key, project] of next.projects) {
+          const before = this.projects.get(key)?.activeEnvironmentId;
+          if (before && project.environmentIds.includes(before)) {
+            project.activeEnvironmentId = before;
+          }
+        }
+        this.projects = next.projects;
+        this.fingerprint = fingerprint;
+        this.loaded = true;
+        migrated = next.migrated;
+      };
+    });
+    if (migrated) {
+      await this.save();
+      await serviceStore.relocateAll();
+      await environmentStore.relocateAll();
+    }
+  }
+  /** Le parcours proprement dit, dans une table neuve que `load` substitue. */
+  async readVaults() {
+    const projects = /* @__PURE__ */ new Map();
     const { local, strayCloud } = await readLocalProject();
-    if (local) await this.absorb(local, localVaultRoot());
+    if (local) await this.absorb(projects, local, localVaultRoot());
     let migrated = false;
     for (const project of strayCloud) {
       try {
-        await this.absorb(project, vaultFor(project).root);
+        await this.absorb(projects, project, vaultFor(project).root);
         migrated = true;
       } catch {
       }
     }
     for (const { project, root } of await readCloudProjects()) {
-      await this.absorb(project, root);
-    }
-    if (migrated) {
-      await this.save();
-      await serviceStore.relocateAll();
-      await environmentStore.relocateAll();
+      await this.absorb(projects, project, root);
     }
+    return { projects, migrated };
   }
   /**
    * Persist every vault this store knows about.
@@ -329,7 +379,10 @@ var ProjectStore = class {
    * that moved between vaults — a local project adopted by an org, a cloud
    * project pulled for the first time — from lingering in the vault it left.
    */
-  async save() {
+  save() {
+    return this.disk.save(() => this.writeVaults());
+  }
+  async writeVaults() {
     const locals = [];
     const cloud = [];
     for (const project of this.projects.values()) {
@@ -346,7 +399,7 @@ var ProjectStore = class {
     if (local) {
       await ensureLocalVault();
       await ensureDataGitignore(localVaultRoot());
-      await this.writeAtomic(this.getFilePath(), JSON.stringify(toDiskForm(local), null, 2));
+      await atomicWriteSecure(this.getFilePath(), JSON.stringify(toDiskForm(local), null, 2));
     } else {
       await rm(this.getFilePath(), { force: true }).catch(() => {
       });
@@ -354,10 +407,10 @@ var ProjectStore = class {
     await rename2(join3(localVaultRoot(), LEGACY_FILENAME), join3(localVaultRoot(), LEGACY_FILENAME + ".bak")).catch(() => {
     });
     for (const { project, root } of cloud) {
-      await mkdir2(root, { recursive: true });
-      await this.writeAtomic(this.getFilePath(root), JSON.stringify(toDiskForm(project), null, 2));
+      await atomicWriteSecure(this.getFilePath(root), JSON.stringify(toDiskForm(project), null, 2));
       setProjectVault(project, root);
     }
+    this.fingerprint = await this.diskFingerprint();
     this.events.emit("saved");
   }
   /**
@@ -678,8 +731,17 @@ var ConversationStore = class {
    */
   unreadable = /* @__PURE__ */ new Map();
   loaded = false;
+  /**
+   * L'état du disque au dernier chargement — voir `ProjectStore.fingerprint`.
+   *
+   * Les conversations ne passent pas par le cloud : elles restent sur ce poste.
+   * Le disque est donc le seul canal entre deux Runeya qui le partagent, et un
+   * cache jamais revu y est la seule chose qui puisse faire disparaître une
+   * conversation écrite dans l'autre fenêtre.
+   */
+  fingerprint = "";
   events = new EventEmitter2().setMaxListeners(0);
-  saveQueue = Promise.resolve();
+  disk = new StoreDiskCoordinator();
   snapshotConversation(conv) {
     return structuredClone(conv);
   }
@@ -708,7 +770,7 @@ var ConversationStore = class {
     }
   }
   async ensureDir() {
-    await mkdir3(dirname(await this.getFilePath()), { recursive: true });
+    await mkdir2(dirname(await this.getFilePath()), { recursive: true });
   }
   encryptMessages(messages, vault) {
     return encryptValue(JSON.stringify(messages), vault);
@@ -800,21 +862,42 @@ ${new Error("trace").stack}`
    * one project. With no local project to point at, it is left unattributed
    * rather than filed under a project picked at random.
    */
-  async load() {
-    if (this.loaded) return;
-    if (!getEncryptionKey()) {
-      return;
-    }
-    this.loaded = true;
-    this.unreadable.clear();
-    await ensureProjectsLoaded();
+  /** Les fichiers dont ce store tire son contenu : les coffres, et l'hérité. */
+  async sourcePaths() {
     const vaults = await allVaultRoots();
     const legacyPaths = [this.getLegacyFilePath(), await keyedFilePath(FILENAME3)];
-    const sources = [
+    return [
       ...legacyPaths.map((path) => ({ path, legacy: true })),
       ...vaults.map((root) => ({ path: join4(root, FILENAME3), legacy: false }))
     ];
-    for (const { path, legacy } of sources) {
+  }
+  async diskFingerprint() {
+    return fingerprintFiles((await this.sourcePaths()).map((s) => s.path));
+  }
+  async load() {
+    if (!getEncryptionKey()) {
+      return;
+    }
+    await this.disk.load(async () => {
+      const fingerprint = await this.diskFingerprint();
+      if (this.loaded && fingerprint === this.fingerprint) return null;
+      await ensureProjectsLoaded();
+      const next = await this.readSources();
+      return () => {
+        this.conversations = next.conversations;
+        this.roots = next.roots;
+        this.unreadable = next.unreadable;
+        this.fingerprint = fingerprint;
+        this.loaded = true;
+      };
+    });
+  }
+  /** Lire toutes les sources dans des tables neuves, que `load` substitue d'un coup. */
+  async readSources() {
+    const conversations = /* @__PURE__ */ new Map();
+    const roots = /* @__PURE__ */ new Map();
+    const unreadable = /* @__PURE__ */ new Map();
+    for (const { path, legacy } of await this.sourcePaths()) {
       let data;
       try {
         data = JSON.parse(await readFile3(path, "utf-8"));
@@ -828,15 +911,16 @@ ${new Error("trace").stack}`
         try {
           const conv = this.fromDisk(item, vaultIdOfRoot(root));
           if (!conv.projectId && inherited) conv.projectId = inherited;
-          this.conversations.set(item.id, conv);
-          this.roots.set(item.id, root);
+          conversations.set(item.id, conv);
+          roots.set(item.id, root);
         } catch {
-          const bucket = this.unreadable.get(root) ?? [];
+          const bucket = unreadable.get(root) ?? [];
           bucket.push(item);
-          this.unreadable.set(root, bucket);
+          unreadable.set(root, bucket);
         }
       }
     }
+    return { conversations, roots, unreadable };
   }
   /**
    * Oublier ce qui a été lu, pour tout relire sous la clé courante.
@@ -903,13 +987,10 @@ ${new Error("trace").stack}`
         );
         continue;
       }
-      await mkdir3(root, { recursive: true });
-      const tmpPath = `${filePath}.tmp`;
-      await writeFile4(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-      await rename3(tmpPath, filePath);
-      await chmod3(filePath, 384);
+      await atomicWriteSecure(filePath, JSON.stringify(data, null, 2));
       await rememberFile(filePath);
     }
+    this.fingerprint = await this.diskFingerprint();
   }
   /**
    * The vault a conversation is written to: its project's.
@@ -945,11 +1026,8 @@ ${new Error("trace").stack}`
     await this.load();
     await this.save();
   }
-  async save() {
-    const write = this.saveQueue.then(() => this.saveInternal());
-    this.saveQueue = write.catch(() => {
-    });
-    return write;
+  save() {
+    return this.disk.save(() => this.saveInternal());
   }
   async list() {
     await this.load();
@@ -1944,7 +2022,7 @@ async function runCompanionForTurn(conversationId) {
   if (!hasNew) {
     return skip(conversationId, "nothingNew", `rien de neuf \xE0 relire (${messageCount} messages)`);
   }
-  const { startCliSession } = await import("./chat-PXMMZIAY.js");
+  const { startCliSession } = await import("./chat-SE5GIT4B.js");
   const companionConv = await ensureCompanionConversation(conv);
   const isFirstTurn = (companionConv.messages?.length ?? 0) === 0;
   const exchange = formatExchange(conv.messages, from);
@@ -2058,7 +2136,7 @@ async function deliverToMainConversation(conv, message) {
 async function attemptDelivery(conv, message) {
   if (await writeToLivePty(conv.id, message)) return "pty";
   try {
-    const { startCliSession } = await import("./chat-PXMMZIAY.js");
+    const { startCliSession } = await import("./chat-SE5GIT4B.js");
     await startCliSession(conv.runner, conv.id, message, { jwt: await signJwt() });
     return "headless";
   } catch (err) {
@@ -2081,7 +2159,7 @@ async function writeToLivePty(conversationId, message) {
 }
 async function companionSettings() {
   try {
-    const { settingsManager } = await import("./settings-manager-2C7RY6ZC.js");
+    const { settingsManager } = await import("./settings-manager-4GAINSJO.js");
     const settings = await settingsManager.getSettings();
     return settings.companion ?? { enabledByDefault: false };
   } catch {
@@ -2210,4 +2288,4 @@ export {
   runCompanionNow,
   initCompanion
 };
-//# sourceMappingURL=chunk-NYKFDU76.js.map
+//# sourceMappingURL=chunk-VNLIA5PV.js.map