@runeya/runeya 2.0.120 → 2.0.122

package/chunk-GL7WA5K3.js

@@ -0,0 +1,92 @@
+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, rename, rm, writeFile, readFile } from "fs/promises";
+import { dirname, 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);
+}
+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,
+  atomicWriteJsonSecure,
+  readJsonFileSafe
+};
+//# sourceMappingURL=chunk-GL7WA5K3.js.map

package/chunk-GL7WA5K3.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, rename, rm, writeFile, readFile } from 'node:fs/promises';\nimport { dirname, 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\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":";;;;;AAAA,SAAS,YAAY;AAqCrB,IAAM,OAAO,oBAAI,IAAyB;AAG1C,eAAsB,aAAa,MAA6B;AAC9D,MAAI;AACF,UAAM,IAAI,MAAM,KAAK,IAAI;AACzB,SAAK,IAAI,MAAM,EAAE,SAAS,EAAE,SAAS,MAAM,EAAE,MAAM,KAAK,EAAE,IAAI,CAAC;AAAA,EACjE,QAAQ;AAEN,SAAK,OAAO,IAAI;AAAA,EAClB;AACF;AAQA,eAAsB,oBAAoB,MAAgC;AACxE,QAAM,QAAQ,KAAK,IAAI,IAAI;AAC3B,MAAI,CAAC,MAAO,QAAO;AACnB,MAAI;AACF,UAAM,IAAI,MAAM,KAAK,IAAI;AACzB,WAAO,EAAE,YAAY,MAAM,WAAW,EAAE,SAAS,MAAM,QAAQ,EAAE,QAAQ,MAAM;AAAA,EACjF,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAYO,SAAS,QAAQ,MAAuB;AAC7C,SAAO,KAAK,IAAI,IAAI;AACtB;AAmBA,eAAsB,iBAAiB,OAAkC;AACvE,QAAM,SAAS,MAAM,QAAQ,IAAI,MAAM,IAAI,OAAO,SAAS;AACzD,QAAI;AACF,YAAM,IAAI,MAAM,KAAK,IAAI;AAIzB,aAAO,GAAG,IAAI,IAAI,EAAE,OAAO,IAAI,EAAE,IAAI,IAAI,EAAE,GAAG;AAAA,IAChD,QAAQ;AACN,aAAO,GAAG,IAAI;AAAA,IAChB;AAAA,EACF,CAAC,CAAC;AACF,SAAO,OAAO,KAAK,EAAE,KAAK,GAAG;AAC/B;;;AC/GA,SAAS,kBAAkB;AAC3B,SAAS,OAAO,OAAO,QAAQ,IAAI,WAAW,gBAAgB;AAC9D,SAAS,SAAS,SAAS,WAAW;AAGtC,IAAM,uBAAuB;AAEtB,SAAS,0BAA0B,aAAqB,gBAAgC;AAC7F,MAAI,CAAC,qBAAqB,KAAK,cAAc,GAAG;AAC9C,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AAIA,QAAM,OAAO,QAAQ,YAAY,GAAG,WAAW;AAC/C,QAAM,MAAM,QAAQ,MAAM,cAAc;AACxC,MAAI,CAAC,IAAI,WAAW,OAAO,GAAG,GAAG;AAC/B,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AACA,SAAO;AACT;AAEA,eAAsB,kBAAkB,UAAkB,SAA6C;AACrG,QAAM,MAAM,QAAQ,QAAQ,GAAG,EAAE,WAAW,KAAK,CAAC;AAGlD,QAAM,UAAU,GAAG,QAAQ,IAAI,QAAQ,GAAG,IAAI,WAAW,CAAC;AAC1D,MAAI;AACF,UAAM,UAAU,SAAS,SAAS,OAAO,YAAY,WAAW,UAAU,MAAS;AACnF,UAAM,OAAO,SAAS,QAAQ;AAAA,EAChC,SAAS,KAAK;AAEZ,UAAM,GAAG,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM;AAAA,IAAC,CAAC;AACjD,UAAM;AAAA,EACR;AACA,QAAM,MAAM,UAAU,GAAK;AAC7B;AAEA,eAAsB,sBAAsB,UAAkB,MAAe,SAAS,OAAsB;AAC1G,QAAM,kBAAkB,UAAU,KAAK,UAAU,MAAM,MAAM,SAAS,IAAI,CAAC,CAAC;AAC9E;AAEA,eAAsB,iBAAoB,UAAqC;AAC7E,MAAI;AACF,UAAM,MAAM,MAAM,SAAS,UAAU,OAAO;AAC5C,WAAO,KAAK,MAAM,GAAG;AAAA,EACvB,QAAQ;AACN,WAAO;AAAA,EACT;AACF;","names":[]}

package/{chunk-GIHR3BGT.js → chunk-NIU3CN5A.js}

@@ -1,8 +1,14 @@
+import {
+  atomicWriteSecure,
+  hasChangedSinceRead,
+  rememberFile,
+  wasRead
+} from "./chunk-GL7WA5K3.js";
 import {
   SchemaVersionSchema,
   SettingsPrivateSchema,
   SettingsSchema
-} from "./chunk-H6VIS4OY.js";
+} from "./chunk-T2BV5WZE.js";
 import {
   env,
   legacyMachineFilePath,
@@ -12,7 +18,7 @@ import {
 } from "./chunk-ZFELQG4B.js";
 
 // ../server/src/services/settings-manager.ts
-import { readFile, writeFile, rename, mkdir, chmod } from "fs/promises";
+import { readFile } from "fs/promises";
 import { join } from "path";
 var SETTINGS_FILE = "settings.json";
 var SETTINGS_PRIVATE_FILE = "settings.private.json";
@@ -37,13 +43,27 @@ var SettingsManager = class {
     return vault ?? "";
   }
   async atomicWrite(filename, data, vault) {
-    const root = this.rootOf(vault);
-    await mkdir(root, { recursive: true });
-    const filePath = join(root, filename);
-    const tmpPath = filePath + ".tmp";
-    await writeFile(tmpPath, JSON.stringify(data, null, 2), "utf-8");
-    await rename(tmpPath, filePath);
-    await chmod(filePath, 384);
+    const filePath = join(this.rootOf(vault), filename);
+    await atomicWriteSecure(filePath, JSON.stringify(data, null, 2));
+    await rememberFile(filePath);
+  }
+  /**
+   * Le cache de ce coffre fait-il encore foi ?
+   *
+   * Plusieurs Runeya partagent la racine machine — l'application installée et
+   * celle qu'on développe, couramment — et écrivent donc le même fichier. Un
+   * cache peuplé une fois et jamais revu rend l'état du démarrage pour
+   * toujours, et la sauvegarde suivante le réinstalle sur le disque : ce que
+   * l'autre instance avait écrit entre-temps disparaît. Les réglages sont
+   * l'endroit où cela coûte le plus cher, parce qu'un coffre n'a qu'un fichier
+   * pour toute l'organisation — un projet, lui, a le sien.
+   *
+   * Un fichier jamais lu n'est pas périmé : c'est un coffre neuf, dont les
+   * défauts viennent d'être écrits.
+   */
+  async isStale(filename, vault) {
+    const path = join(this.rootOf(vault), filename);
+    return wasRead(path) && await hasChangedSinceRead(path);
   }
   /**
    * Lire le fichier de CE coffre, et rien d'autre.
@@ -55,8 +75,11 @@ var SettingsManager = class {
    * `migrateSettingsIntoVaults`, pas relu indéfiniment.
    */
   async readJson(filename, vault) {
+    const path = join(this.rootOf(vault), filename);
     try {
-      return JSON.parse(await readFile(join(this.rootOf(vault), filename), "utf-8"));
+      const parsed = JSON.parse(await readFile(path, "utf-8"));
+      await rememberFile(path);
+      return parsed;
     } catch {
       return null;
     }
@@ -79,6 +102,7 @@ var SettingsManager = class {
   async getSettings(vault) {
     const key = this.cacheKey(vault);
     let current = this.settings.get(key);
+    if (current && await this.isStale(SETTINGS_FILE, vault)) current = void 0;
     if (!current) {
       const raw = await this.readJson(SETTINGS_FILE, vault);
       const parsed = raw ? SettingsSchema.safeParse(raw) : null;
@@ -99,6 +123,7 @@ var SettingsManager = class {
   async getPrivateSettings(vault) {
     const key = this.cacheKey(vault);
     let current = this.settingsPrivate.get(key);
+    if (current && await this.isStale(SETTINGS_PRIVATE_FILE, vault)) current = void 0;
     if (!current) {
       const raw = await this.readJson(SETTINGS_PRIVATE_FILE, vault);
       const parsed = raw ? SettingsPrivateSchema.safeParse(raw) : null;
@@ -135,12 +160,7 @@ var SettingsManager = class {
   }
   async saveSchemaVersion(sv) {
     this.schemaVersion = sv;
-    await mkdir(machineRoot(), { recursive: true });
-    const filePath = machineFilePath(SCHEMA_VERSION_FILE);
-    const tmpPath = filePath + ".tmp";
-    await writeFile(tmpPath, JSON.stringify(sv, null, 2), "utf-8");
-    await rename(tmpPath, filePath);
-    await chmod(filePath, 384);
+    await atomicWriteSecure(machineFilePath(SCHEMA_VERSION_FILE), JSON.stringify(sv, null, 2));
   }
   getCurrentSchemaVersion() {
     return CURRENT_SCHEMA_VERSION;
@@ -151,4 +171,4 @@ var settingsManager = new SettingsManager();
 export {
   settingsManager
 };
-//# sourceMappingURL=chunk-GIHR3BGT.js.map
+//# sourceMappingURL=chunk-NIU3CN5A.js.map

package/chunk-NIU3CN5A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../server/src/services/settings-manager.ts"],"sourcesContent":["import { readFile } from 'node:fs/promises';\nimport { env } from '../config/env.js';\nimport { join } from 'node:path';\nimport { machineFilePath, legacyMachineFilePath, machineRoot, orgVaultRoot } from './vault-resolver.js';\nimport { SettingsSchema, SchemaVersionSchema, SettingsPrivateSchema } from '@runeya/packages-shared';\nimport type { Settings, SchemaVersion, SettingsPrivate } from '@runeya/packages-shared';\nimport { rememberFile, hasChangedSinceRead, wasRead } from './disk-freshness.js';\nimport { atomicWriteSecure } from './run-store-utils.js';\n\nconst SETTINGS_FILE = 'settings.json';\nconst SETTINGS_PRIVATE_FILE = 'settings.private.json';\nconst SCHEMA_VERSION_FILE = 'schema-version.json';\nconst CURRENT_SCHEMA_VERSION = 4;\n\n/**\n * Les réglages vivent dans le coffre de ce qu'ils configurent.\n *\n * Ils étaient au niveau machine — un fichier pour tout le poste — alors qu'ils\n * décrivent des choses qui appartiennent à des organisations différentes : les\n * fournisseurs d'IA qui paient le travail d'une équipe, les scénarios qui\n * décrivent ses services. Un réglage global obligeait donc à partager la clé\n * machine pour partager un secret d'organisation.\n *\n * `vault` désigne le coffre : l'identifiant d'une organisation, ou l'absence\n * pour le répertoire de lancement — celui d'un projet local, qui n'appartient à\n * personne d'autre. Rien ne reste au niveau machine sinon la session cloud,\n * irréductible puisque c'est elle qui donne accès aux organisations.\n */\nclass SettingsManager {\n  private settings = new Map<string, Settings>();\n  private settingsPrivate = new Map<string, SettingsPrivate>();\n  private schemaVersion: SchemaVersion | null = null;\n\n  /**\n   * Le coffre visé, sous forme de racine sur le disque.\n   *\n   * Sans organisation, la racine machine — pas le répertoire de lancement. Ce\n   * n'est pas un reste de l'ancien monde : y écrire forcerait un `.runeya` à\n   * exister chez quelqu'un qui ne travaille que sur des projets cloud, ce que\n   * les coffres ont justement supprimé (et ce qu'un test garde).\n   */\n  private rootOf(vault?: string): string {\n    return vault ? orgVaultRoot(vault) : machineRoot();\n  }\n\n  private cacheKey(vault?: string): string {\n    return vault ?? '';\n  }\n\n  private async atomicWrite(filename: string, data: unknown, vault?: string): Promise<void> {\n    const filePath = join(this.rootOf(vault), filename);\n    await atomicWriteSecure(filePath, JSON.stringify(data, null, 2));\n    // Notre propre écriture devient la référence : sans elle, la lecture\n    // suivante prendrait ce fichier pour l'œuvre d'une autre instance et\n    // relirait pour rien.\n    await rememberFile(filePath);\n  }\n\n  /**\n   * Le cache de ce coffre fait-il encore foi ?\n   *\n   * Plusieurs Runeya partagent la racine machine — l'application installée et\n   * celle qu'on développe, couramment — et écrivent donc le même fichier. Un\n   * cache peuplé une fois et jamais revu rend l'état du démarrage pour\n   * toujours, et la sauvegarde suivante le réinstalle sur le disque : ce que\n   * l'autre instance avait écrit entre-temps disparaît. Les réglages sont\n   * l'endroit où cela coûte le plus cher, parce qu'un coffre n'a qu'un fichier\n   * pour toute l'organisation — un projet, lui, a le sien.\n   *\n   * Un fichier jamais lu n'est pas périmé : c'est un coffre neuf, dont les\n   * défauts viennent d'être écrits.\n   */\n  private async isStale(filename: string, vault?: string): Promise<boolean> {\n    const path = join(this.rootOf(vault), filename);\n    return wasRead(path) && await hasChangedSinceRead(path);\n  }\n\n  /**\n   * Lire le fichier de CE coffre, et rien d'autre.\n   *\n   * Pas de repli sur un autre emplacement : un réglage lu ailleurs que là où il\n   * est écrit fait deux vérités pour un même fait, et l'accord entre les deux\n   * devient une chose de plus à tenir. Ce que les versions précédentes ont\n   * écrit ailleurs est déplacé une fois pour toutes par\n   * `migrateSettingsIntoVaults`, pas relu indéfiniment.\n   */\n  private async readJson<T>(filename: string, vault?: string): Promise<T | null> {\n    const path = join(this.rootOf(vault), filename);\n    try {\n      const parsed = JSON.parse(await readFile(path, 'utf-8')) as T;\n      // Repère pris après coup : c'est cette lecture-là que le cache reflète.\n      await rememberFile(path);\n      return parsed;\n    } catch {\n      return null;\n    }\n  }\n\n  /** Vide les caches — après un déplacement de fichiers sous nos pieds. */\n  forget(): void {\n    this.settings.clear();\n    this.settingsPrivate.clear();\n  }\n\n  /** Un fichier qui appartient au poste, pas à un coffre. */\n  private async readMachineJson<T>(filename: string): Promise<T | null> {\n    for (const path of [machineFilePath(filename), legacyMachineFilePath(filename)]) {\n      try {\n        return JSON.parse(await readFile(path, 'utf-8')) as T;\n      } catch {\n        // Try the next location.\n      }\n    }\n    return null;\n  }\n\n  async getSettings(vault?: string): Promise<Settings> {\n    const key = this.cacheKey(vault);\n    let current = this.settings.get(key);\n    if (current && await this.isStale(SETTINGS_FILE, vault)) current = undefined;\n    if (!current) {\n      const raw = await this.readJson<unknown>(SETTINGS_FILE, vault);\n      const parsed = raw ? SettingsSchema.safeParse(raw) : null;\n      if (parsed?.success) {\n        current = parsed.data;\n        this.settings.set(key, current);\n      } else {\n        current = SettingsSchema.parse({ mode: env.MODE, cloudUrl: env.CLOUD_URL ?? null });\n        await this.saveSettings(current, vault);\n      }\n    }\n    return current;\n  }\n\n  async saveSettings(settings: Settings, vault?: string): Promise<void> {\n    this.settings.set(this.cacheKey(vault), settings);\n    await this.atomicWrite(SETTINGS_FILE, settings, vault);\n  }\n\n  async getPrivateSettings(vault?: string): Promise<SettingsPrivate> {\n    const key = this.cacheKey(vault);\n    let current = this.settingsPrivate.get(key);\n    if (current && await this.isStale(SETTINGS_PRIVATE_FILE, vault)) current = undefined;\n    if (!current) {\n      const raw = await this.readJson<unknown>(SETTINGS_PRIVATE_FILE, vault);\n      const parsed = raw ? SettingsPrivateSchema.safeParse(raw) : null;\n      if (parsed?.success) {\n        current = parsed.data;\n        this.settingsPrivate.set(key, current);\n      } else {\n        current = SettingsPrivateSchema.parse({});\n        await this.savePrivateSettings(current, vault);\n      }\n    }\n    return current;\n  }\n\n  async savePrivateSettings(settings: SettingsPrivate, vault?: string): Promise<void> {\n    this.settingsPrivate.set(this.cacheKey(vault), settings);\n    await this.atomicWrite(SETTINGS_PRIVATE_FILE, settings, vault);\n  }\n\n  /**\n   * La version de schéma reste au niveau machine, et ce n'est pas un oubli :\n   * elle ne configure rien, elle date les migrations des données de ce poste.\n   */\n  async getSchemaVersion(): Promise<SchemaVersion> {\n    if (!this.schemaVersion) {\n      const raw = await this.readMachineJson<unknown>(SCHEMA_VERSION_FILE);\n      const parsed = raw ? SchemaVersionSchema.safeParse(raw) : null;\n      if (parsed?.success) {\n        this.schemaVersion = parsed.data;\n      } else {\n        this.schemaVersion = { version: CURRENT_SCHEMA_VERSION, migratedAt: new Date() };\n        await this.saveSchemaVersion(this.schemaVersion);\n      }\n    }\n    return this.schemaVersion;\n  }\n\n  async saveSchemaVersion(sv: SchemaVersion): Promise<void> {\n    this.schemaVersion = sv;\n    await atomicWriteSecure(machineFilePath(SCHEMA_VERSION_FILE), JSON.stringify(sv, null, 2));\n  }\n\n  getCurrentSchemaVersion(): number {\n    return CURRENT_SCHEMA_VERSION;\n  }\n}\n\nexport const settingsManager = new SettingsManager();\n"],"mappings":"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","names":[]}

package/{chunk-H6VIS4OY.js → chunk-T2BV5WZE.js}

@@ -1097,6 +1097,19 @@ var KanbanBoardSchema = z19.object({
   columns: z19.array(KanbanColumnSchema).default([]),
   /** Les regroupements de colonnes — vide sur un tableau qui n'en a jamais eu. */
   columnGroups: z19.array(KanbanColumnGroupSchema).default([]),
+  /**
+   * Les projets auxquels le tableau est rattaché, par leur identifiant.
+   *
+   * Un rattachement, pas une possession : il ne sert qu'à filtrer la liste des
+   * tableaux, et un tableau sans projet (`[]`, le cas par défaut) reste visible
+   * partout. Plusieurs projets sont permis parce qu'une équipe partage souvent
+   * un même tableau entre deux projets — obliger à choisir l'un des deux
+   * ferait disparaître le tableau de la liste de l'autre.
+   *
+   * Les identifiants sont ceux des projets de l'organisation ; le serveur
+   * refuse ceux qu'il ne connaît pas plutôt que de garder un lien mort.
+   */
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).default([]),
   archived: z19.boolean().default(false),
   /** Supprimé, mais conservé avec ses cartes — voir `deletedAt` sur la carte. */
   deletedAt: z19.string().optional(),
@@ -1106,7 +1119,8 @@ var KanbanBoardSchema = z19.object({
 var CreateKanbanBoardInput = z19.object({
   name: z19.string().min(1).max(200),
   description: z19.string().max(1e4).optional(),
-  instructions: z19.string().max(2e4).optional()
+  instructions: z19.string().max(2e4).optional(),
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).optional()
 });
 var UpdateKanbanBoardInput = z19.object({
   id: z19.string(),
@@ -1114,7 +1128,8 @@ var UpdateKanbanBoardInput = z19.object({
   description: z19.string().max(1e4).optional(),
   instructions: z19.string().max(2e4).optional(),
   columns: z19.array(KanbanColumnSchema).optional(),
-  archived: z19.boolean().optional()
+  archived: z19.boolean().optional(),
+  projectIds: z19.array(z19.string().min(1).max(128)).max(20).optional()
 });
 var KanbanCardLinkSchema = z19.object({
   id: z19.string().max(128),
@@ -1790,4 +1805,4 @@ export {
   writeEntity,
   primaryServiceLink
 };
-//# sourceMappingURL=chunk-H6VIS4OY.js.map
+//# sourceMappingURL=chunk-T2BV5WZE.js.map