@runeya/runeya 2.0.56 → 2.0.58

package/agent-manager-EDFP4VXP.js

@@ -0,0 +1,7 @@
+import {
+  agentManager
+} from "./chunk-NLVDO4EC.js";
+export {
+  agentManager
+};
+//# sourceMappingURL=agent-manager-EDFP4VXP.js.map

package/assets/icon.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 28 28">
+  <rect width="28" height="28" rx="8" fill="#6366f1"/>
+  <path d="M7 20 L14 8 L21 20" stroke="white" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round"/>
+  <path d="M10 16 L18 16" stroke="white" stroke-width="2.5" stroke-linecap="round"/>
+</svg>

package/{chunk-Q2WY6PYX.js → chunk-NLVDO4EC.js}

@@ -36,6 +36,10 @@ var EnvSchema = z.object({
   RUNEYA_MODE: z.enum(["local-simple", "cloud"]).default("local-simple"),
   RUNEYA_CORS_ORIGIN: z.string().nullable().default(null),
   RUNEYA_LAN_PROXY: z.preprocess((v) => v === "true" || v === "1", z.boolean()).default(false),
+  // Set by the CLI when it was started from a desktop launcher rather than a
+  // terminal. The web app surfaces it so the user knows which Runeya they are
+  // looking at when several are running.
+  RUNEYA_FROM_DESKTOP: z.preprocess((v) => v === "true" || v === "1", z.boolean()).default(false),
   // Label shown for this machine in the cloud's "linked machines" screen.
   // Defaults to the hostname (see `getDeviceName`); set it explicitly when a
   // single host runs several instances and you want to tell them apart.
@@ -63,7 +67,8 @@ var EnvSchema = z.object({
   CLOUD_APP_URL: data.RUNEYA_CLOUD_APP_URL,
   CORS_ORIGIN: data.RUNEYA_CORS_ORIGIN,
   AGENT_BINARY_PATH: data.RUNEYA_AGENT_BINARY_PATH,
-  DEVICE_NAME: data.RUNEYA_DEVICE_NAME
+  DEVICE_NAME: data.RUNEYA_DEVICE_NAME,
+  FROM_DESKTOP: data.RUNEYA_FROM_DESKTOP
 }));
 var env = EnvSchema.parse(process.env);
 
@@ -103,10 +108,35 @@ function vaultFor(target) {
   return { root: projectVaultRoot(target.orgId, target.id) };
 }
 var ORG_CLOUD_FILE = "cloud.json";
-async function stampOrgCloud(orgId, cloudUrl) {
+async function stampOrgCloud(orgId, cloudUrl, name) {
   const root = orgVaultRoot(orgId);
   await mkdir(root, { recursive: true });
-  await writeFile(join(root, ORG_CLOUD_FILE), JSON.stringify({ cloudUrl }, null, 2), "utf-8");
+  const known = name ?? (await readOrgNames())[orgId];
+  const stamp = known ? { cloudUrl, name: known } : { cloudUrl };
+  await writeFile(join(root, ORG_CLOUD_FILE), JSON.stringify(stamp, null, 2), "utf-8");
+}
+async function rememberOrgName(orgId, name) {
+  const file = join(orgVaultRoot(orgId), ORG_CLOUD_FILE);
+  let stamp;
+  try {
+    stamp = JSON.parse(await readFile(file, "utf-8"));
+  } catch {
+    return;
+  }
+  if (stamp["name"] === name) return;
+  await writeFile(file, JSON.stringify({ ...stamp, name }, null, 2), "utf-8");
+}
+async function readOrgNames() {
+  const out = {};
+  for (const orgId of await listOrgVaults()) {
+    try {
+      const raw = await readFile(join(orgVaultRoot(orgId), ORG_CLOUD_FILE), "utf-8");
+      const name = JSON.parse(raw).name;
+      if (typeof name === "string" && name) out[orgId] = name;
+    } catch {
+    }
+  }
+  return out;
 }
 async function readOrgClouds() {
   const orgsDir = join(machineRoot(), "orgs");
@@ -264,6 +294,9 @@ function markVaultLocked(vault) {
   lockedVaults.add(vault);
   keyring.delete(vault);
 }
+function isVaultLocked(vault) {
+  return lockedVaults.has(vault);
+}
 function clearVaultLock(vault) {
   lockedVaults.delete(vault);
 }
@@ -650,6 +683,28 @@ import { randomUUID as randomUUID2 } from "crypto";
 import { readFile as readFile3, writeFile as writeFile3, rename as rename2, mkdir as mkdir3, chmod as chmod2, rm } from "fs/promises";
 import { join as join3 } from "path";
 
+// ../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 });
+  } 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;
+  } catch {
+    return true;
+  }
+}
+
 // ../server/src/services/crypto-helpers.ts
 import { randomBytes as randomBytes2, createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2 } from "crypto";
 var ALGORITHM2 = "aes-256-gcm";
@@ -1204,7 +1259,17 @@ var ProcessStatusSchema = z9.object({
   startedAt: z9.coerce.date().nullable().optional(),
   restartCount: z9.number().int().nonnegative().default(0),
   uptime: z9.number().nonnegative().default(0),
-  healthStatus: HealthStatusSchema.default("unknown")
+  healthStatus: HealthStatusSchema.default("unknown"),
+  /**
+   * Le répertoire où le processus s'exécute VRAIMENT, absolutisé par l'agent.
+   *
+   * Rapporté par l'agent plutôt que déduit de la config : entre le `cwd` de la
+   * commande, celui du service, l'ancrage sur le projet et les variables que
+   * l'agent étend lui-même, la valeur affichée n'aurait rien prouvé. Ce qui
+   * intéresse quand un service tourne contre le mauvais dépôt, c'est le chemin
+   * final — y compris quand il retombe sur le répertoire de l'agent.
+   */
+  cwd: z9.string().max(4096).nullable().optional()
 });
 
 // ../../packages/shared/src/schemas/log.schema.ts
@@ -1566,6 +1631,22 @@ var KanbanCardSchema = z20.object({
   /** Files attached to the card — stored out of band, referenced here. */
   attachments: z20.array(KanbanAttachmentSchema).max(50).default([]),
   order: z20.number().int(),
+  /**
+   * La priorité de la carte, de 1 à 10 — 10 étant le plus urgent.
+   *
+   * Facultative, et absente veut dire « pas de priorité », pas « la plus
+   * basse » : une carte qu'on n'a pas encore arbitrée ne doit pas se ranger
+   * d'office au fond de la pile.
+   */
+  priority: z20.number().int().min(1).max(10).optional(),
+  /**
+   * Les groupes de la carte — des étiquettes libres, posées par l'équipe.
+   *
+   * Rien ne les déclare ailleurs : un groupe existe parce qu'une carte le
+   * porte, et disparaît avec la dernière qui le portait. C'est ce qui permet
+   * d'en créer un en le tapant, sans passer par un écran d'administration.
+   */
+  groups: z20.array(z20.string().min(1).max(60)).max(30).optional(),
   /**
    * La couleur de la carte, en hexadécimal (`#RRGGBB`) — un liseré en haut de
    * la carte, et rien d'autre : ce qu'elle veut dire appartient à l'équipe.
@@ -1993,12 +2074,12 @@ function applyToArray(arr, next) {
   const wanted = next.map(identityOf);
   const wantedCount = /* @__PURE__ */ new Map();
   for (const k of wanted) wantedCount.set(k, (wantedCount.get(k) ?? 0) + 1);
-  const seen = /* @__PURE__ */ new Map();
+  const seen2 = /* @__PURE__ */ new Map();
   for (let i = arr.length - 1; i >= 0; i--) {
     const key = identityOfY(arr.get(i));
-    const used = seen.get(key) ?? 0;
+    const used = seen2.get(key) ?? 0;
     if (used >= (wantedCount.get(key) ?? 0)) arr.delete(i, 1);
-    else seen.set(key, used + 1);
+    else seen2.set(key, used + 1);
   }
   for (let j = 0; j < next.length; j++) {
     const key = wanted[j];
@@ -2059,6 +2140,15 @@ var EnvironmentStore = class {
    * chiffrée : c'est ce que retient cette liste. Voir `keepUnreadableSecrets`.
    */
   unreadableSecrets = /* @__PURE__ */ new Map();
+  /**
+   * Coffres dont le fichier a bougé depuis la lecture.
+   *
+   * On ne les réécrit pas. Ni avec notre copie — elle décrirait l'état d'avant
+   * la réparation — ni sans elle, ce qui effacerait les secrets qu'elle
+   * protège. Entre les deux, la seule issue sûre est de ne pas toucher au
+   * fichier et de laisser le prochain chargement faire foi.
+   */
+  staleRoots = /* @__PURE__ */ new Set();
   listeners = /* @__PURE__ */ new Set();
   /** Notified after every persisted mutation, for the cloud sync bridge. */
   onChange(fn) {
@@ -2075,6 +2165,43 @@ var EnvironmentStore = class {
   roots = /* @__PURE__ */ new Map();
   /** L'organisation d'où vient un environnement reçu du cloud — voir `vaultOf`. */
   remoteOrgs = /* @__PURE__ */ new Map();
+  /**
+   * Oublier ce qui a été lu, pour tout relire sous la clé courante.
+   *
+   * Appelé après l'adoption d'une clé d'organisation : le disque vient d'être
+   * re-chiffré sous les pieds du store, si bien que sa mémoire décrit un état
+   * qui n'existe plus. La laisser en place n'affichait pas seulement des
+   * comptes périmés — la sauvegarde suivante réécrivait l'ancien chiffré
+   * par-dessus le nouveau, et défaisait l'adoption.
+   */
+  resetCache() {
+    this.environments.clear();
+    this.diskEncryptedSlots.clear();
+    this.unreadableSecrets.clear();
+    this.roots.clear();
+    this.remoteOrgs.clear();
+    this.loaded = false;
+    this.notify();
+  }
+  /**
+   * Combien de secrets ce coffre garde chiffrés sans savoir les ouvrir, par
+   * organisation (`null` pour la machine).
+   *
+   * Ils sont déjà préservés à l'écriture (`keepUnreadableSecrets`) ; ce qui
+   * manquait, c'est de le dire. Un secret qui s'affiche vide et se sauvegarde
+   * intact est rassurant sur le disque et déroutant à l'écran.
+   */
+  async unreadableByVault() {
+    await this.load();
+    const out = /* @__PURE__ */ new Map();
+    for (const [environmentId, failed] of this.unreadableSecrets) {
+      if (!failed.size) continue;
+      const environment = this.environments.get(environmentId);
+      const vault = (environment ? this.vaultOf(environment) : void 0) ?? null;
+      out.set(vault, (out.get(vault) ?? 0) + failed.size);
+    }
+    return out;
+  }
   getFilePath(root) {
     return join3(root, FILENAME2);
   }
@@ -2218,6 +2345,7 @@ var EnvironmentStore = class {
     for (const root of await allVaultRoots()) {
       try {
         const raw = await readFile3(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);
         if (clash) {
@@ -2226,9 +2354,9 @@ var EnvironmentStore = class {
         }
         for (const e of data) {
           this.diskEncryptedSlots.set(e.id, this.extractEncryptedCache(e));
-          const decrypted = this.decryptEnvironment(e);
-          this.environments.set(e.id, decrypted);
           this.roots.set(e.id, root);
+          const decrypted = this.decryptEnvironment(e, vaultIdOfRoot(root));
+          this.environments.set(e.id, decrypted);
         }
       } catch {
       }
@@ -2241,7 +2369,20 @@ var EnvironmentStore = class {
    * another vault must not survive in the old one, and a `[]` left behind would
    * keep (or recreate) a `.runeya` in a directory that holds nothing.
    */
+  /**
+   * Repérer les coffres réparés sous nos pieds, avant d'écrire.
+   *
+   * Le test est fait ici, une fois par sauvegarde, plutôt que par
+   * environnement : c'est le fichier du coffre qui change, pas la variable.
+   */
+  async markStaleRoots() {
+    this.staleRoots.clear();
+    for (const root of new Set(this.roots.values())) {
+      if (await hasChangedSinceRead(this.getFilePath(root))) this.staleRoots.add(root);
+    }
+  }
   async save() {
+    await this.markStaleRoots();
     const byRoot = /* @__PURE__ */ new Map();
     for (const root of this.roots.values()) {
       if (!isVaultConflicted(root)) byRoot.set(root, []);
@@ -2258,6 +2399,12 @@ var EnvironmentStore = class {
       else byRoot.set(root, [prepared]);
     }
     for (const [root, environments] of byRoot) {
+      if (this.staleRoots.has(root)) {
+        console.warn(
+          `[environment-store] ${this.getFilePath(root)} a chang\xE9 depuis sa lecture \u2014 \xE9criture ignor\xE9e pour ne pas \xE9craser une r\xE9paration faite en dehors du serveur.`
+        );
+        continue;
+      }
       const filePath = this.getFilePath(root);
       if (environments.length === 0) {
         await rm(filePath, { force: true }).catch(() => {
@@ -2269,6 +2416,7 @@ var EnvironmentStore = class {
       await writeFile3(tmpPath, JSON.stringify(environments, null, 2), "utf-8");
       await rename2(tmpPath, filePath);
       await chmod2(filePath, 384);
+      await rememberFile(filePath);
     }
     this.notify();
   }
@@ -2628,6 +2776,23 @@ var ServiceStore = class {
    * dit la même chose que le coffre.
    */
   remoteOrgs = /* @__PURE__ */ new Map();
+  /**
+   * Oublier ce qui a été lu, pour tout relire sous la clé courante.
+   *
+   * Appelé après l'adoption d'une clé d'organisation : le disque vient d'être
+   * re-chiffré sous les pieds du store, si bien que sa mémoire décrit un état
+   * qui n'existe plus. La laisser en place n'affichait pas seulement des
+   * comptes périmés — la sauvegarde suivante réécrivait l'ancien chiffré
+   * par-dessus le nouveau, et défaisait l'adoption.
+   */
+  resetCache() {
+    this.services.clear();
+    this.diskForm.clear();
+    this.roots.clear();
+    this.remoteOrgs.clear();
+    this.loaded = false;
+    this.notify();
+  }
   getFilePath(root) {
     return join4(root, FILENAME3);
   }
@@ -3918,6 +4083,7 @@ export {
   hasEncryptionKey,
   getEncryptionKey,
   markVaultLocked,
+  isVaultLocked,
   clearVaultLock,
   ensureEncryptionKey,
   setEncryptionKey,
@@ -3928,6 +4094,8 @@ export {
   vaultIdOfRoot,
   vaultFor,
   stampOrgCloud,
+  rememberOrgName,
+  readOrgNames,
   readOrgClouds,
   listOrgVaults,
   listCloudVaults,
@@ -3980,6 +4148,8 @@ export {
   decryptVariableSlots,
   extractEncryptedVariableSlots,
   isEncryptedValue,
+  rememberFile,
+  hasChangedSinceRead,
   projectKey,
   AmbiguousProjectError,
   registerProjectLoader,
@@ -3998,4 +4168,4 @@ export {
   traefikManager,
   agentManager
 };
-//# sourceMappingURL=chunk-Q2WY6PYX.js.map
+//# sourceMappingURL=chunk-NLVDO4EC.js.map