@runeya/runeya 2.0.75 → 2.0.77

package/{src-MEMRUBM6.js → src-WON4SLMI.js}

@@ -110,7 +110,7 @@ import {
   wasRead,
   withDeprecatedAliases,
   writeEntity
-} from "./chunk-E2SU5RSO.js";
+} from "./chunk-WDM637TW.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -2432,6 +2432,9 @@ var projectRouter = router({
 import { z as z4 } from "zod";
 import { TRPCError as TRPCError4 } from "@trpc/server";
 
+// ../server/src/services/log-parser-store.ts
+import { randomUUID as randomUUID3 } from "crypto";
+
 // ../server/src/services/settings-manager.ts
 import { readFile as readFile7, writeFile as writeFile7, rename as rename7, mkdir as mkdir7, chmod as chmod6 } from "fs/promises";
 import { join as join8 } from "path";
@@ -2569,6 +2572,170 @@ var SettingsManager = class {
 };
 var settingsManager = new SettingsManager();
 
+// ../server/src/services/log-parser-store.ts
+function isShareable(parser) {
+  return parser.builtin !== true && !parser.id.startsWith("native:");
+}
+var LogParserStore = class {
+  localListeners = /* @__PURE__ */ new Set();
+  changeListeners = /* @__PURE__ */ new Set();
+  /**
+   * S'abonner aux écritures *locales* — celles nées ici.
+   *
+   * C'est ce qu'écoute la synchronisation : réagir aussi à ce qui arrive du
+   * document la ferait repartir aussitôt vers ce document, en boucle.
+   */
+  onLocalChange(fn) {
+    this.localListeners.add(fn);
+    return () => this.localListeners.delete(fn);
+  }
+  /**
+   * S'abonner à toute écriture, d'où qu'elle vienne.
+   *
+   * C'est ce qu'écoute l'interface : un parseur écrit par un collègue arrive
+   * par le document, donc silencieusement pour la synchronisation — mais un
+   * écran qui ne l'apprend qu'au prochain montage montre une liste fausse
+   * pendant tout ce temps, alors même que les services, eux, se rafraîchissent.
+   */
+  onChanged(fn) {
+    this.changeListeners.add(fn);
+    return () => this.changeListeners.delete(fn);
+  }
+  notify(vault, local) {
+    if (local) {
+      for (const fn of this.localListeners) {
+        try {
+          fn();
+        } catch (err) {
+          console.error("[log-parser-store] listener failed:", err.message);
+        }
+      }
+    }
+    for (const fn of this.changeListeners) {
+      try {
+        fn(vault);
+      } catch (err) {
+        console.error("[log-parser-store] listener failed:", err.message);
+      }
+    }
+  }
+  /** Les parseurs d'un coffre — ceux de l'organisation, ou ceux du poste. */
+  async list(vault) {
+    const settings = await settingsManager.getSettings(vault);
+    return settings.logParsers ?? [];
+  }
+  async get(id, vault) {
+    return (await this.list(vault)).find((p) => p.id === id) ?? null;
+  }
+  async write(parsers, vault, silent = false) {
+    const settings = await settingsManager.getSettings(vault);
+    await settingsManager.saveSettings({ ...settings, logParsers: parsers }, vault);
+    this.notify(vault, !silent);
+  }
+  async create(input, vault) {
+    const now = /* @__PURE__ */ new Date();
+    if (input.builtin) {
+      throw new Error("A parser created here is never a built-in one");
+    }
+    const parser = JSLogParserSchema.parse({
+      ...input,
+      id: randomUUID3(),
+      createdAt: now,
+      updatedAt: now
+    });
+    await this.write([...await this.list(vault), parser], vault);
+    return parser;
+  }
+  async update(id, patch, vault) {
+    const parsers = await this.list(vault);
+    const index = parsers.findIndex((p) => p.id === id);
+    if (index === -1) return null;
+    const updated = JSLogParserSchema.parse({
+      ...parsers[index],
+      ...patch,
+      id,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    const next = [...parsers];
+    next[index] = updated;
+    await this.write(next, vault);
+    return updated;
+  }
+  async delete(id, vault) {
+    const parsers = await this.list(vault);
+    const next = parsers.filter((p) => p.id !== id);
+    if (next.length === parsers.length) return false;
+    await this.write(next, vault);
+    return true;
+  }
+  // ---- Synchronisation --------------------------------------------------
+  /**
+   * Écrire ce que le document de l'organisation porte.
+   *
+   * Silencieux et gardé par une comparaison : réveiller les écoutants ici
+   * relancerait la réconciliation qui vient de produire cette écriture, et un
+   * document identique au disque ne mérite pas un fichier réécrit.
+   */
+  async applyRemoteUpsert(id, fields, orgId) {
+    const parsed = JSLogParserSchema.safeParse({ ...fields, id });
+    if (!parsed.success) {
+      console.warn("[log-parser-store] rejected a remote parser %s: %s", id, parsed.error.message);
+      return;
+    }
+    if (!isShareable(parsed.data)) return;
+    const parsers = await this.list(orgId);
+    const index = parsers.findIndex((p) => p.id === id);
+    if (index !== -1 && sameParser(parsers[index], parsed.data)) return;
+    const next = [...parsers];
+    if (index === -1) next.push(parsed.data);
+    else next[index] = parsed.data;
+    await this.write(next, orgId, true);
+  }
+  async applyRemoteDelete(id, orgId) {
+    const parsers = await this.list(orgId);
+    const next = parsers.filter((p) => p.id !== id);
+    if (next.length === parsers.length) return;
+    await this.write(next, orgId, true);
+  }
+  /**
+   * Remonter les parseurs du poste dans les organisations de cette machine.
+   *
+   * Un déplacement, pas une copie : le même parseur des deux côtés ferait deux
+   * vérités qui divergent au premier changement, et la liste du poste
+   * ressusciterait à chaque connexion celui qu'un membre vient de supprimer
+   * pour toute l'équipe. Une fois la machine vidée, il n'y a plus rien à
+   * remonter — l'opération peut donc être rejouée sans dégât.
+   *
+   * Vers *toutes* les organisations liées, chacune recevant sa copie : les
+   * coffres ne communiquent pas, et rien ne dit laquelle des deux était visée.
+   */
+  async migrateMachineParsersInto(orgIds) {
+    if (orgIds.length === 0) return;
+    const all = await this.list();
+    if (all.length === 0) return;
+    const machineParsers = all.filter(isShareable);
+    for (const orgId of orgIds) {
+      const existing = await this.list(orgId);
+      const known = new Set(existing.map((p) => p.id));
+      const added = machineParsers.filter((p) => !known.has(p.id));
+      if (added.length === 0) continue;
+      await this.write([...existing, ...added], orgId, true);
+    }
+    await this.write(all.filter((p) => !isShareable(p)), void 0, true);
+    if (machineParsers.length > 0) {
+      console.log(
+        "[log-parser-store] moved %d machine parser(s) into organization(s): %s",
+        machineParsers.length,
+        orgIds.join(", ")
+      );
+    }
+  }
+};
+function sameParser(a, b) {
+  return a.name === b.name && a.code === b.code && a.enabled === b.enabled && (a.description ?? "") === (b.description ?? "") && a.updatedAt.getTime() === b.updatedAt.getTime();
+}
+var logParserStore = new LogParserStore();
+
 // ../server/src/services/service-builtins.ts
 function buildServerBuiltins(input) {
   const { service, siblings, projectName, environmentName, agentName, host } = input;
@@ -2609,7 +2776,7 @@ import { isAbsolute as isAbsolute3 } from "path";
 import { isAbsolute as isAbsolute2, join as join10, dirname as dirname5 } from "path";
 
 // ../server/src/services/conversation-store.ts
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 import { readFile as readFile8, writeFile as writeFile8, rename as rename8, mkdir as mkdir8, chmod as chmod7 } from "fs/promises";
 import { dirname as dirname4, join as join9 } from "path";
 import { EventEmitter as EventEmitter2 } from "events";
@@ -2942,7 +3109,7 @@ ${new Error("trace").stack}`
     await this.load();
     const now = Date.now();
     const conv = {
-      id: randomUUID3(),
+      id: randomUUID4(),
       projectId,
       title: title ?? "New conversation",
       messages: [],
@@ -3104,8 +3271,9 @@ async function resolveServiceVariables(service) {
   }
   try {
     if (service.parserIds && service.parserIds.length > 0) {
-      const settings = await settingsManager.getSettings();
-      const allParsers = [...nativeParsers, ...settings.logParsers || []];
+      const vault = project?.orgId ?? void 0;
+      const parsers = await logParserStore.list(vault);
+      const allParsers = [...nativeParsers, ...parsers];
       const resolvedParsers = service.parserIds.map((id) => allParsers.find((p) => p.id === id)).filter((p) => p !== void 0);
       resolvedService = { ...resolvedService, resolvedLogParsers: resolvedParsers };
     }
@@ -4556,6 +4724,12 @@ async function setLanMode(enabled) {
 
 // ../server/src/trpc/routers/settings.ts
 var NotificationPreferencesPatchSchema = NotificationPreferencesSchema.partial().strict();
+function listWithOrigin(parsers, vault) {
+  return [
+    ...nativeParsers.map((p) => ({ ...p, origin: "native" })),
+    ...parsers.map((p) => ({ ...p, origin: vault ? "org" : "machine" }))
+  ];
+}
 function maskApiKey2(plaintext) {
   if (plaintext.length <= 8) return "****";
   return plaintext.slice(0, 4) + "****" + plaintext.slice(-4);
@@ -4648,17 +4822,63 @@ var settingsRouter = router({
   }),
   /**
    * List all parsers
+   *
+   * Les natifs, puis ceux du coffre visé. L'origine accompagne chacun : un
+   * parseur d'organisation se modifie pour toute l'équipe, et l'interface doit
+   * pouvoir le dire avant que quelqu'un le change sans le savoir.
    */
-  listParsers: protectedProcedure.query(async () => {
-    const settings = await settingsManager.getSettings();
-    return [...nativeParsers, ...settings.logParsers || []];
+  listParsers: protectedProcedure.input(z11.object(ScopeShape).optional()).query(async ({ input }) => {
+    const vault = await scopeOf(input);
+    return listWithOrigin(await logParserStore.list(vault), vault);
+  }),
+  /**
+   * Les parseurs du coffre visé, à chaque fois qu'ils changent.
+   *
+   * Les services arrivent en temps réel, et un parseur écrit par un collègue
+   * atteint le disque tout aussi vite ; sans ce flux, seul l'écran resterait en
+   * retard — affichant une liste dans laquelle le parseur qu'un service vient
+   * de référencer n'existe pas encore.
+   */
+  onParsersChanged: protectedProcedure.input(z11.object(ScopeShape).optional()).subscription(async function* ({ input, signal }) {
+    const vault = await scopeOf(input);
+    let pending = true;
+    let wake = null;
+    const off = logParserStore.onChanged((touched) => {
+      if (touched !== vault) return;
+      pending = true;
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    });
+    const onAbort = () => {
+      if (wake) {
+        wake();
+        wake = null;
+      }
+    };
+    signal?.addEventListener("abort", onAbort);
+    try {
+      while (!signal?.aborted) {
+        if (pending) {
+          pending = false;
+          yield listWithOrigin(await logParserStore.list(vault), vault);
+        } else {
+          await new Promise((resolve7) => {
+            wake = resolve7;
+          });
+        }
+      }
+    } finally {
+      off();
+      signal?.removeEventListener("abort", onAbort);
+    }
   }),
   /**
    * Get single parser by ID
    */
-  getParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).query(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const parser = (settings.logParsers || []).find((p) => p.id === input.id);
+  getParser: protectedProcedure.input(z11.object({ id: z11.string().max(128), ...ScopeShape })).query(async ({ input }) => {
+    const parser = await logParserStore.get(input.id, await scopeOf(input));
     if (!parser) {
       throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
@@ -4672,25 +4892,13 @@ var settingsRouter = router({
       id: true,
       createdAt: true,
       updatedAt: true
-    })
+    }).extend(ScopeShape)
   ).mutation(async ({ input }) => {
-    if (!input.code.trim()) {
+    const { orgId, projectId, ...fields } = input;
+    if (!fields.code.trim()) {
       throw new TRPCError8({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
-    const id = `parser-${Date.now()}-${Math.random().toString(36).substring(7)}`;
-    const now = /* @__PURE__ */ new Date();
-    const parser = {
-      id,
-      ...input,
-      createdAt: now,
-      updatedAt: now
-    };
-    const settings = await settingsManager.getSettings();
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: [...settings.logParsers || [], parser]
-    });
-    return parser;
+    return logParserStore.create(fields, await scopeOf({ orgId, projectId }));
   }),
   /**
    * Update existing parser
@@ -4699,53 +4907,32 @@ var settingsRouter = router({
     JSLogParserSchema.omit({
       createdAt: true,
       updatedAt: true
-    }).partial().required({ id: true })
+    }).partial().required({ id: true }).extend(ScopeShape)
   ).mutation(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const parserIndex = (settings.logParsers || []).findIndex(
-      (p) => p.id === input.id
-    );
-    if (parserIndex === -1) {
-      throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
-    }
-    if (input.id.startsWith("native:")) {
+    const { id, orgId, projectId, ...patch } = input;
+    if (id.startsWith("native:")) {
       throw new TRPCError8({ code: "FORBIDDEN", message: "Cannot modify built-in parsers" });
     }
-    const existing = (settings.logParsers || [])[parserIndex];
-    if (input.code && !input.code.trim()) {
+    if (patch.code !== void 0 && !patch.code.trim()) {
       throw new TRPCError8({ code: "BAD_REQUEST", message: "Parser code cannot be empty" });
     }
-    const updated = {
-      ...existing,
-      ...input,
-      updatedAt: /* @__PURE__ */ new Date()
-    };
-    const newParsers = [...settings.logParsers || []];
-    newParsers[parserIndex] = updated;
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: newParsers
-    });
+    const updated = await logParserStore.update(id, patch, await scopeOf({ orgId, projectId }));
+    if (!updated) {
+      throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${id}` });
+    }
     return updated;
   }),
   /**
    * Delete parser by ID
    */
-  deleteParser: protectedProcedure.input(z11.object({ id: z11.string().max(128) })).mutation(async ({ input }) => {
-    const settings = await settingsManager.getSettings();
-    const newParsers = (settings.logParsers || []).filter(
-      (p) => p.id !== input.id
-    );
+  deleteParser: protectedProcedure.input(z11.object({ id: z11.string().max(128), ...ScopeShape })).mutation(async ({ input }) => {
     if (input.id.startsWith("native:")) {
       throw new TRPCError8({ code: "FORBIDDEN", message: "Cannot delete built-in parsers" });
     }
-    if (newParsers.length === (settings.logParsers || []).length) {
+    const deleted = await logParserStore.delete(input.id, await scopeOf(input));
+    if (!deleted) {
       throw new TRPCError8({ code: "NOT_FOUND", message: `Parser not found: ${input.id}` });
     }
-    await settingsManager.saveSettings({
-      ...settings,
-      logParsers: newParsers
-    });
     return { deleted: true };
   }),
   // ---------------------------------------------------------------------------
@@ -7223,7 +7410,7 @@ async function fetchProviderModels(provider, plaintextKey) {
 }
 
 // ../server/src/services/image-storage.service.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { mkdir as mkdir15, writeFile as writeFile14, readFile as readFile15, unlink as unlink3, readdir as readdir4 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { join as join18, extname, resolve as resolve4, sep as sep2 } from "path";
@@ -7260,7 +7447,7 @@ var ImageStorageService = class {
       throw new Error(`Unsupported extension: ${ext}`);
     }
     await this.ensureTmpDir();
-    const imageId = randomUUID4();
+    const imageId = randomUUID5();
     const safeExt = ext.replace(/[^a-z.]/g, "");
     const fileName = `${imageId}${safeExt}`;
     const filePath = join18(this.dir, fileName);
@@ -7408,7 +7595,7 @@ async function resolveImagesToBase64(images, contextId) {
 }
 
 // ../server/src/services/kanban-commands.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 // ../server/src/trpc/routers/cloud-auth.ts
 import { z as z16 } from "zod";
@@ -7808,7 +7995,7 @@ async function addCardOrFallback(board, columnTitle, cardTitle, cardContent) {
   if (!col) return;
   const now = (/* @__PURE__ */ new Date()).toISOString();
   col.cards.push({
-    id: randomUUID5(),
+    id: randomUUID6(),
     title: cardTitle,
     markdown: cardContent ?? "",
     images: [],
@@ -8045,7 +8232,7 @@ Ne jamais omettre ce tag. Il doit \xEAtre la toute derni\xE8re ligne de ta r\xE9
 `.trim();
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // ../server/src/services/ai-runners/claude-pty-tail.ts
 import { open } from "fs/promises";
@@ -8169,7 +8356,7 @@ function tailTranscript(opts) {
 
 // ../server/src/services/ai-runners/claude-pty-runner.ts
 async function getAgentManager() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-DM6C7BTF.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-JUVAVUIQ.js");
   return agentManager2;
 }
 function buildPtyArgs(params, sessionId, opts) {
@@ -8239,7 +8426,7 @@ function dispatchEntry(entry, state, cbs) {
 async function runClaudeViaPty(params) {
   const { agentId, signal, skipTokenInstructions } = params;
   if (!agentId) throw new Error("runClaudeViaPty requires an agentId");
-  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID6();
+  const sessionId = params.sessionId && params.sessionId.length > 0 ? params.sessionId : randomUUID7();
   const args = buildPtyArgs(params, sessionId, { excludeMcp: true });
   const agentMgr = await getAgentManager();
   const displayArgs = args.map((a) => {
@@ -8910,7 +9097,7 @@ async function shutdownCodexAppServer() {
   }
 }
 async function getAgentManager2() {
-  const { agentManager: agentManager2 } = await import("./agent-manager-DM6C7BTF.js");
+  const { agentManager: agentManager2 } = await import("./agent-manager-JUVAVUIQ.js");
   return agentManager2;
 }
 function parseRuneyaCurlCommand(command) {
@@ -11015,7 +11202,7 @@ Rules:
 });
 
 // ../server/src/trpc/routers/scenario.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { TRPCError as TRPCError16 } from "@trpc/server";
 import { z as z19 } from "zod";
 
@@ -11132,7 +11319,7 @@ async function* streamWithActiveProvider(opts) {
 
 // ../server/src/services/scenario-runner.ts
 import { mkdir as mkdir16 } from "fs/promises";
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 import { join as join19 } from "path";
 
 // ../server/src/services/scenario-presets.ts
@@ -11474,7 +11661,7 @@ function applyHireDirectivesFromOutput(manager, scenario, output) {
   }
   const hired = [];
   for (const payload of hireDirectives) {
-    const id = `hire-${randomUUID7().slice(0, 8)}`;
+    const id = `hire-${randomUUID8().slice(0, 8)}`;
     const position = computeHirePosition(manager, scenario.nodes);
     ensureGroupCanContainNode(scenario, manager.groupId ?? null, position);
     const node = {
@@ -12642,7 +12829,7 @@ var scenarioRouter = router({
   })).mutation(({ input }) => {
     const now = Date.now();
     return createOrBadRequest(async () => scenarioStore.create({
-      id: randomUUID8(),
+      id: randomUUID9(),
       name: input.name,
       icon: input.icon,
       description: input.description,
@@ -12794,7 +12981,7 @@ var scenarioRouter = router({
 });
 
 // ../server/src/trpc/routers/debug.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { TRPCError as TRPCError17 } from "@trpc/server";
 import { z as z20 } from "zod";
 var MAX_BUFFER3 = 300;
@@ -12857,7 +13044,7 @@ var debugRouter = router({
     intervalMs: z20.number().int().min(100).max(5e3).optional(),
     maxTicks: z20.number().int().min(1).max(1e4).optional()
   }).optional()).mutation(({ input }) => {
-    const jobId = randomUUID9();
+    const jobId = randomUUID10();
     const intervalMs = input?.intervalMs ?? 400;
     const maxTicks = input?.maxTicks ?? 500;
     const job = {
@@ -13077,7 +13264,7 @@ var diagnosticsRouter = router({
 import { z as z22 } from "zod";
 
 // ../server/src/services/kanban-queue.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import { EventEmitter as EventEmitter5 } from "events";
 var KanbanQueueService = class extends EventEmitter5 {
   items = [];
@@ -13105,7 +13292,7 @@ var KanbanQueueService = class extends EventEmitter5 {
       return { id: alreadyRunning.id, addedAt: alreadyRunning.startedAt, ...item };
     }
     const queueItem = {
-      id: randomUUID10(),
+      id: randomUUID11(),
       ...item,
       addedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
@@ -14107,7 +14294,7 @@ async function reconcileOrgCanary(orgId) {
 }
 
 // ../server/src/services/cloud-sync-bridge.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import { mkdir as mkdir20, rm as rm5 } from "fs/promises";
 import * as Y from "yjs";
 
@@ -14190,6 +14377,7 @@ var RECONNECT_DELAY_MS = 3e3;
 var UNAUTHENTICATED_RETRY_MS = 5 * 6e4;
 var OUTDATED_RETRY_MS = 30 * 6e4;
 var COLLECTIONS = ["projects", "services", "environments"];
+var PARSERS = "logParsers";
 var SyncAuthError = class extends Error {
   constructor(status) {
     super(`cloud rejected the session (HTTP ${status})`);
@@ -14221,7 +14409,8 @@ var OrgSyncConnection = class {
   projects = getCollection(this.doc, "projects");
   services = getCollection(this.doc, "services");
   environments = getCollection(this.doc, "environments");
-  conn = randomUUID11();
+  logParsers = getCollection(this.doc, PARSERS);
+  conn = randomUUID12();
   link;
   stopped = false;
   initializing = true;
@@ -14289,9 +14478,14 @@ var OrgSyncConnection = class {
         void this.applyDocEventsToStore(name, events, isInitial);
       });
     }
+    this.logParsers.observeDeep((events, txn) => {
+      if (txn.origin !== REMOTE_ORIGIN) return;
+      void this.applyParserEventsToStore(events);
+    });
     projectStore.events.on("saved", this.onSaved);
     this.unsubscribes.push(serviceStore.onChange(this.onSaved));
     this.unsubscribes.push(environmentStore.onChange(this.onSaved));
+    this.unsubscribes.push(logParserStore.onLocalChange(this.onSaved));
     await this.reconcileLocalToDoc();
     this.initializing = false;
     this.needsPush = true;
@@ -14639,6 +14833,54 @@ var OrgSyncConnection = class {
       await this.upsertLocally(name, id, fields);
     }
   }
+  /**
+   * Nombre d'applications distantes de parseurs en cours.
+   *
+   * La réconciliation lit le coffre et supprime du document ce qu'elle n'y
+   * trouve pas ; déclenchée par un service enregistré au même instant, elle
+   * lirait un coffre où le parseur qui arrive n'est pas encore écrit — et
+   * l'effacerait pour toute l'organisation. Un compteur plutôt qu'un booléen :
+   * plusieurs évènements peuvent se chevaucher, et le premier terminé ne doit
+   * pas rouvrir la porte pour les autres.
+   */
+  applyingParsers = 0;
+  /**
+   * Porter au disque les parseurs que le document vient de changer.
+   *
+   * Une suppression est appliquée telle quelle, sans l'équivalent du garde qui
+   * protège les contenus d'un projet non téléchargé : chaque membre tient le
+   * jeu complet de l'organisation, donc un parseur retiré du document l'a bien
+   * été pour tout le monde.
+   */
+  async applyParserEventsToStore(events) {
+    const deleted = /* @__PURE__ */ new Set();
+    const affected = /* @__PURE__ */ new Set();
+    for (const event of events) {
+      if (event.target === this.logParsers) {
+        for (const [key, change] of event.changes.keys) {
+          if (change.action === "delete") deleted.add(key);
+          else affected.add(key);
+        }
+      } else {
+        const topKey = event.path[0];
+        if (typeof topKey === "string") affected.add(topKey);
+      }
+    }
+    this.applyingParsers += 1;
+    try {
+      for (const id of deleted) {
+        await logParserStore.applyRemoteDelete(id, this.link.orgId);
+      }
+      for (const id of affected) {
+        if (deleted.has(id)) continue;
+        const fields = readEntity(this.logParsers, id);
+        if (!fields) continue;
+        await logParserStore.applyRemoteUpsert(id, fields, this.link.orgId);
+      }
+    } finally {
+      this.applyingParsers -= 1;
+    }
+  }
   async upsertLocally(name, id, fields) {
     if (name === "services") {
       await serviceStore.applyRemoteUpsert(id, fields, this.link.orgId);
@@ -14725,6 +14967,8 @@ var OrgSyncConnection = class {
       environmentStore.listEncryptedByProjectIds(projectIds)
     ]);
     if (this.stopped) return;
+    const parsers = (await logParserStore.list(this.link.orgId)).filter(isShareable);
+    if (this.stopped) return;
     const local = { projects, services, environments };
     const ownedProjectIds = new Set(projectIds);
     this.doc.transact(() => {
@@ -14739,6 +14983,13 @@ var OrgSyncConnection = class {
           if (this.belongsToOwnedProject(name, id, ownedProjectIds)) collection.delete(id);
         }
       }
+      const parserIds = new Set(parsers.map((p) => p.id));
+      for (const parser of parsers) writeEntity(this.logParsers, parser.id, parser);
+      if (this.applyingParsers === 0) {
+        for (const id of Array.from(this.logParsers.keys())) {
+          if (!parserIds.has(id)) this.logParsers.delete(id);
+        }
+      }
     }, LOCAL_ORIGIN);
   }
   /**
@@ -14792,6 +15043,7 @@ var CloudSyncBridge = class {
       console.error("[cloud-sync] could not read which organizations to sync:", err.message);
       return;
     }
+    await this.migrateMachineParsers(links);
     for (const link of links) await this.connect(link);
     const connected = this.connections.size;
     if (links.length > 0) {
@@ -14827,8 +15079,28 @@ var CloudSyncBridge = class {
       console.error("[cloud-sync] could not read which organizations to sync:", err.message);
       return;
     }
+    await this.migrateMachineParsers(links);
     for (const link of links) await this.connect(link);
   }
+  /**
+   * Déplacer les parseurs du poste dans les organisations de cette machine.
+   *
+   * Avant d'ouvrir les connexions, pour que la première réconciliation parte
+   * d'un coffre déjà complet — sinon les parseurs partiraient au document au
+   * coup d'après, ce qui marche mais laisse une fenêtre où l'équipe voit une
+   * liste vide.
+   *
+   * Fait ici plutôt que dans chaque connexion : la liste du poste est vidée à
+   * la fin, et deux connexions qui migreraient en parallèle se la
+   * disputeraient — la seconde trouverait une machine déjà vide.
+   */
+  async migrateMachineParsers(links) {
+    try {
+      await logParserStore.migrateMachineParsersInto(links.map((l) => l.orgId));
+    } catch (err) {
+      console.error("[cloud-sync] could not move machine parsers into organizations:", err.message);
+    }
+  }
   /** Per-org sync state, for the UI. */
   states() {
     const live = Array.from(this.connections.entries()).map(([orgId, conn]) => ({
@@ -15682,7 +15954,7 @@ async function migrateSettingsIntoVaults() {
 // ../server/src/migrations/migrate-from-legacy.ts
 import { createRequire as createRequire2 } from "module";
 import { randomBytes as randomBytes6, createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3 } from "crypto";
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 import {
   readFile as readFile21,
   writeFile as writeFile20,
@@ -15892,11 +16164,11 @@ async function runLegacyMigration(dataDir) {
     const data = await readEncrypted(join28(parsersDir, file));
     if (data?.id) legacyParsers.push(data);
   }
-  const projectMonoId = randomUUID12();
+  const projectMonoId = randomUUID13();
   const envIdMap = {};
   const labelToKey = {};
   for (const [name, legacyEnv] of Object.entries(legacyEnvs)) {
-    envIdMap[name] = randomUUID12();
+    envIdMap[name] = randomUUID13();
     if (legacyEnv?.label) labelToKey[legacyEnv.label] = name;
   }
   const runeEnvs = [];
@@ -15921,7 +16193,7 @@ async function runLegacyMigration(dataDir) {
         if (hasInvalidInterpolation(value)) continue;
         const cleaned = cleanVarKey(key);
         if (inheritedVars[cleaned] === value) continue;
-        const varId = randomUUID12();
+        const varId = randomUUID13();
         variables[varId] = makeVariable(cleaned, value);
         varIdLookup.set(`${envIdMap[name]}:${cleaned}`, varId);
       }
@@ -15942,7 +16214,7 @@ async function runLegacyMigration(dataDir) {
   const serviceIdMap = {};
   const runeServices = [];
   for (const [name, legacy] of Object.entries(legacyServices)) {
-    const id = randomUUID12();
+    const id = randomUUID13();
     serviceIdMap[name] = id;
     const rootPath = legacy.rootPath || "";
     const rootPathCwd = rootPath && rootPath !== "." ? rootPath : "";
@@ -15951,7 +16223,7 @@ async function runLegacyMigration(dataDir) {
       const parts = [cmd.spawnCmd, ...cmd.spawnArgs || []].filter(Boolean);
       if (!parts.length) continue;
       commands.push({
-        id: cmd.id || randomUUID12(),
+        id: cmd.id || randomUUID13(),
         label: "Launch",
         command: parts.join(" "),
         cwd: cmd.spawnOptions?.cwd || "",
@@ -16012,7 +16284,7 @@ async function runLegacyMigration(dataDir) {
       const legacyBootstrapCmds = container.bootstrap?.commands || [];
       if (legacyBootstrapCmds.length > 0) {
         dockerConfig.bootstrapCommands = legacyBootstrapCmds.filter((bs) => bs.cmd || bs.entrypoint).map((bs, idx) => ({
-          id: bs.id || randomUUID12(),
+          id: bs.id || randomUUID13(),
           label: bs.label || `Bootstrap ${idx + 1}`,
           command: bs.cmd || "",
           ...bs.entrypoint ? { entrypoint: bs.entrypoint } : {},
@@ -16060,7 +16332,7 @@ async function runLegacyMigration(dataDir) {
       cwd: serviceCwd,
       runner: dockerConfig ? "docker" : "native",
       shortcuts: (legacy.shortcuts || []).filter((s) => s.spawnCmd || s.label).map((s) => ({
-        id: s.id || randomUUID12(),
+        id: s.id || randomUUID13(),
         label: s.label || s.spawnCmd || "",
         command: [s.spawnCmd, ...s.spawnArgs || []].filter(Boolean).join(" "),
         ...s.spawnOptions?.cwd ? { cwd: s.spawnOptions.cwd } : {}
@@ -16100,7 +16372,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID13(),
           projectId: projectMonoId,
           name: `${service?.name || name} (${globalEnv.name})`,
           scope: "service",
@@ -16124,7 +16396,7 @@ async function runLegacyMigration(dataDir) {
         const varPost = typeof varData === "object" ? String(varData.suffix ?? "") : "";
         if (!varKey || existingKeys.has(cleanVarKey(varKey))) continue;
         const cleaned = cleanVarKey(varKey);
-        const varId = randomUUID12();
+        const varId = randomUUID13();
         svcScopedEnv.variables[varId] = makeVariable(cleaned, varValue, varPre, varPost);
         existingKeys.add(cleaned);
       }
@@ -16144,7 +16416,7 @@ async function runLegacyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID13(),
           projectId: projectMonoId,
           name: `${service?.name || serviceName} (${globalEnv.name})`,
           scope: "service",
@@ -16165,7 +16437,7 @@ async function runLegacyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv.variables).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID12();
+          varId = randomUUID13();
           svcScopedEnv.variables[varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -16195,13 +16467,13 @@ async function runLegacyMigration(dataDir) {
             flatOverrides[varId] = makeVariable(cleaned, value);
           }
         } else {
-          flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
+          flatOverrides[randomUUID13()] = makeVariable(cleaned, value);
         }
       } else {
         const cleaned = cleanVarKey(key);
         const existingVarId = Object.entries(env2.variables).find(([, v]) => v.key === cleaned)?.[0];
         if (!existingVarId) {
-          const varId = randomUUID12();
+          const varId = randomUUID13();
           env2.variables[varId] = makeVariable(cleaned, value);
           varIdLookup.set(`${envId}:${cleaned}`, varId);
         }
@@ -16385,7 +16657,7 @@ async function runOverrideOnlyMigration(dataDir) {
         if (isSameAsBase(value, baseVar)) continue;
         flatOverrides[varId] = makeVariable(cleaned, value);
       } else {
-        flatOverrides[randomUUID12()] = makeVariable(cleaned, value);
+        flatOverrides[randomUUID13()] = makeVariable(cleaned, value);
       }
     }
   }
@@ -16422,7 +16694,7 @@ async function runOverrideOnlyMigration(dataDir) {
       );
       if (!svcScopedEnv) {
         svcScopedEnv = {
-          id: randomUUID12(),
+          id: randomUUID13(),
           projectId: globalEnv["projectId"],
           name: `${service?.["name"] || serviceName} (${globalEnv["name"]})`,
           scope: "service",
@@ -16444,7 +16716,7 @@ async function runOverrideOnlyMigration(dataDir) {
         const baseEntry = Object.entries(svcScopedEnv["variables"]).find(([, v]) => v.key === cleaned);
         let varId = baseEntry?.[0];
         if (!varId) {
-          varId = randomUUID12();
+          varId = randomUUID13();
           svcScopedEnv["variables"][varId] = {
             key: cleaned,
             value: { value: "", pre: "", post: "", isSecret: false, injectIntoAi: false }
@@ -17761,4 +18033,4 @@ export {
   pullEnv,
   registerInstance
 };
-//# sourceMappingURL=src-MEMRUBM6.js.map
+//# sourceMappingURL=src-WON4SLMI.js.map