@runeya/runeya 2.0.103 → 2.0.104

package/{src-V7DPPFCF.js → src-TEL7L4K2.js}

@@ -37,6 +37,7 @@ import {
   logParserStore,
   maskApiKey,
   networkInfo,
+  orgCloudUrl,
   protectedProcedure,
   publicProcedure,
   registerHttpServer,
@@ -57,7 +58,7 @@ import {
   shutdownCodexAppServer,
   startCliSession,
   vaultOfProject
-} from "./chunk-UYOWIH4R.js";
+} from "./chunk-IOAGFK3P.js";
 import {
   resolveCliInvocation,
   whichCommand
@@ -80,7 +81,8 @@ import {
   stopClaudeTranscriptWatcher,
   stopCodexTranscriptWatcher,
   verifyJwt
-} from "./chunk-NZNIWJDT.js";
+} from "./chunk-AAK7ACHG.js";
+import "./chunk-MD3VW4HQ.js";
 import {
   agentManager,
   agentSpawner,
@@ -118,29 +120,10 @@ import {
   stableEncryptValue,
   traefikManager,
   unregisterInstance
-} from "./chunk-QIBUMYR6.js";
+} from "./chunk-NPORVPEO.js";
 import {
   settingsManager
-} from "./chunk-Z67WBWKD.js";
-import {
-  env,
-  forgetOrgLogo,
-  keyRoot,
-  legacyMachineFilePath,
-  legacyVaultRoot,
-  listCloudVaults,
-  listOrgVaults,
-  machineFilePath,
-  machineRoot,
-  orgVaultRoot,
-  projectVaultRoot,
-  readOrgClouds,
-  readOrgLogos,
-  readOrgNames,
-  rememberOrgLogo,
-  rememberOrgName,
-  stampOrgCloud
-} from "./chunk-KY6KYSOU.js";
+} from "./chunk-5GYBAMHV.js";
 import {
   AGENT_LONG_FETCH_TIMEOUT,
   AGENT_STOP_FETCH_TIMEOUT,
@@ -171,7 +154,26 @@ import {
   readEntity,
   writeEntity
 } from "./chunk-QRMG6GMX.js";
-import "./chunk-MD3VW4HQ.js";
+import {
+  env,
+  forgetOrgLogo,
+  keyRoot,
+  legacyMachineFilePath,
+  legacyVaultRoot,
+  listCloudVaults,
+  listOrgVaults,
+  machineFilePath,
+  machineRoot,
+  orgVaultRoot,
+  projectVaultRoot,
+  readOrgClouds,
+  readOrgLogo,
+  readOrgLogos,
+  readOrgNames,
+  rememberOrgLogo,
+  rememberOrgName,
+  stampOrgCloud
+} from "./chunk-LTLOVQJQ.js";
 
 // ../server/src/create-server.ts
 import express from "express";
@@ -3243,9 +3245,9 @@ async function* streamProviderText(input) {
       stream: true,
       max_tokens: maxTokens
     }, { signal: signal ?? void 0 });
-    for await (const chunk of stream) {
+    for await (const chunk2 of stream) {
       if (signal?.aborted) return;
-      const text = chunk.choices[0]?.delta?.content;
+      const text = chunk2.choices[0]?.delta?.content;
       if (text) yield text;
     }
     return;
@@ -5102,16 +5104,16 @@ function installLogCapture() {
     [process.stderr, "stderr"]
   ]) {
     const original = stream.write.bind(stream);
-    stream.write = ((chunk, encoding, callback) => {
+    stream.write = ((chunk2, encoding, callback) => {
       try {
-        const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+        const text = typeof chunk2 === "string" ? chunk2 : Buffer.from(chunk2).toString("utf8");
         for (const raw of text.split("\n")) {
           const line = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
           if (line.trim() !== "") push(line, name);
         }
       } catch {
       }
-      return original(chunk, encoding, callback);
+      return original(chunk2, encoding, callback);
     });
   }
 }
@@ -7681,12 +7683,11 @@ var cloudSyncRouter = router({
    * réseau muet laisse en place ce qui est déjà là : hors ligne, on garde.
    */
   cacheOrgLogos: protectedProcedure.input(z23.object({ orgIds: z23.array(z23.string().min(1).max(128)).max(200) })).mutation(async ({ input }) => {
-    const clouds = await readOrgClouds();
     let cached = 0;
     for (const orgId of input.orgIds) {
-      const base = (clouds[orgId] ?? getCloudApiUrl()).replace(/\/+$/, "");
+      const base = await orgCloudUrl(orgId);
       try {
-        const res = await fetch(`${base}/api/org-logo/${encodeURIComponent(orgId)}`, {
+        const res = await fetch(`${base}/api/org-logo/${encodeURIComponent(orgId)}?format=png`, {
           signal: AbortSignal.timeout(1e4)
         });
         if (res.status === 404) {
@@ -7876,10 +7877,46 @@ async function installLauncher(input) {
   return { name: input.name, output: [stdout, stderr].filter((s) => s.trim()).join("\n").trim() };
 }
 
+// ../server/src/services/tray-accent.ts
+var accent = null;
+var listeners2 = /* @__PURE__ */ new Set();
+function getTrayAccent() {
+  return accent;
+}
+function setTrayAccent(next) {
+  const normalized = next === null ? null : next.trim().toLowerCase();
+  if (normalized === accent) return;
+  accent = normalized;
+  for (const listener of listeners2) {
+    try {
+      listener();
+    } catch {
+    }
+  }
+}
+function onTrayAccentChanged(listener) {
+  listeners2.add(listener);
+  return () => listeners2.delete(listener);
+}
+
 // ../server/src/trpc/routers/desktop.ts
 var desktopRouter = router({
   /** Ce que le CLI demanderait, prérempli avec l'instance en cours. */
   suggestLauncher: protectedProcedure.query(() => suggestLauncher()),
+  /**
+   * La couleur du thème de cet onglet.
+   *
+   * Le thème vit dans le navigateur ; l'icône de barre système, elle, est
+   * dessinée par le serveur. Sans cette annonce elle garderait la teinte figée
+   * du fichier livré avec le CLI. Rien n'est persisté — voir `tray-accent.ts`.
+   */
+  setTrayAccent: protectedProcedure.input(z25.object({
+    // `#rgb` ou `#rrggbb` : la forme est vérifiée ici, pas rabotée plus loin.
+    color: z25.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/).nullable()
+  })).mutation(({ input }) => {
+    setTrayAccent(input.color);
+    return { ok: true };
+  }),
   installLauncher: protectedProcedure.input(z25.object({
     name: z25.string().trim().min(1).max(120),
     /**
@@ -10080,7 +10117,7 @@ async function createLocalServer() {
     ]);
     console.log("[server] Shutdown complete");
   };
-  const { initCompanion } = await import("./companion-6J6NK7H7.js");
+  const { initCompanion } = await import("./companion-MUFVXURV.js");
   initCompanion();
   return { app, server, wss, shutdown };
 }
@@ -10199,14 +10236,241 @@ function onTrayServicesChanged(listener) {
   const offServices = serviceStore.onChange(onStatus);
   const offUnlock = onVaultUnlocked(onStatus);
   const offProject = onCurrentProjectChanged(onStatus);
+  const offAccent = onTrayAccentChanged(onStatus);
   return () => {
     agentManager.off("process:status", onStatus);
     offServices();
     offUnlock();
+    offAccent();
     offProject();
   };
 }
 
+// ../server/src/services/tray-icon.ts
+import { mkdir as mkdir13, writeFile as writeFile10, rename as rename8 } from "fs/promises";
+import { join as join17 } from "path";
+
+// ../server/src/services/png-to-ico.ts
+function isPng(bytes) {
+  const signature = [137, 80, 78, 71, 13, 10, 26, 10];
+  return bytes.length > signature.length && signature.every((b, i) => bytes[i] === b);
+}
+function pngSize(bytes) {
+  if (bytes.length < 24 || !isPng(bytes)) return null;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (String.fromCharCode(...bytes.slice(12, 16)) !== "IHDR") return null;
+  const width = view.getUint32(16);
+  const height = view.getUint32(20);
+  if (width === 0 || height === 0) return null;
+  return { width, height };
+}
+function pngToIco(png) {
+  const size = pngSize(png);
+  if (!size) return null;
+  if (size.width > 256 || size.height > 256) return null;
+  const header = new Uint8Array(6 + 16);
+  const view = new DataView(header.buffer);
+  view.setUint16(0, 0, true);
+  view.setUint16(2, 1, true);
+  view.setUint16(4, 1, true);
+  header[6] = size.width === 256 ? 0 : size.width;
+  header[7] = size.height === 256 ? 0 : size.height;
+  header[8] = 0;
+  header[9] = 0;
+  view.setUint16(10, 1, true);
+  view.setUint16(12, 32, true);
+  view.setUint32(14, png.length, true);
+  view.setUint32(18, header.length, true);
+  const ico = new Uint8Array(header.length + png.length);
+  ico.set(header, 0);
+  ico.set(png, header.length);
+  return ico;
+}
+
+// ../server/src/services/runeya-icon.ts
+import { deflateSync } from "zlib";
+var VIEW = 28;
+var CORNER_RADIUS = 8;
+var STROKE_WIDTH = 2.5;
+var STROKES = [
+  [7, 20, 14, 8],
+  [14, 8, 21, 20],
+  [10, 16, 18, 16]
+];
+function parseHexColor(hex) {
+  const value = hex.trim().replace(/^#/, "");
+  const full = value.length === 3 ? value.replace(/./g, (c) => c + c) : value;
+  if (!/^[0-9a-fA-F]{6}$/.test(full)) return null;
+  return [
+    parseInt(full.slice(0, 2), 16),
+    parseInt(full.slice(2, 4), 16),
+    parseInt(full.slice(4, 6), 16)
+  ];
+}
+function distanceToRoundedRect(x, y, half, radius) {
+  const dx = Math.abs(x) - (half - radius);
+  const dy = Math.abs(y) - (half - radius);
+  const outside = Math.hypot(Math.max(dx, 0), Math.max(dy, 0));
+  return outside + Math.min(Math.max(dx, dy), 0) - radius;
+}
+function distanceToStroke(x, y, [ax, ay, bx, by], width) {
+  const px = x - ax;
+  const py = y - ay;
+  const vx = bx - ax;
+  const vy = by - ay;
+  const t = Math.min(1, Math.max(0, (px * vx + py * vy) / (vx * vx + vy * vy)));
+  return Math.hypot(px - vx * t, py - vy * t) - width / 2;
+}
+function coverage(distance, pixel) {
+  return Math.min(1, Math.max(0, 0.5 - distance / pixel));
+}
+function renderRuneyaIcon(color, size = 64) {
+  const rgb = parseHexColor(color);
+  if (!rgb || size < 8 || size > 1024) return null;
+  const scale = size / VIEW;
+  const pixel = 1 / scale;
+  const half = VIEW / 2;
+  const rgba = new Uint8Array(size * size * 4);
+  for (let py = 0; py < size; py += 1) {
+    for (let px = 0; px < size; px += 1) {
+      const x = (px + 0.5) / scale;
+      const y = (py + 0.5) / scale;
+      const background = coverage(distanceToRoundedRect(x - half, y - half, half, CORNER_RADIUS), pixel);
+      if (background <= 0) continue;
+      let stroke = 0;
+      for (const segment of STROKES) {
+        stroke = Math.max(stroke, coverage(distanceToStroke(x, y, segment, STROKE_WIDTH), pixel));
+      }
+      stroke = Math.min(stroke, background);
+      const offset = (py * size + px) * 4;
+      for (let channel = 0; channel < 3; channel += 1) {
+        rgba[offset + channel] = Math.round(rgb[channel] * (1 - stroke) + 255 * stroke);
+      }
+      rgba[offset + 3] = Math.round(background * 255);
+    }
+  }
+  return encodePng(rgba, size, size);
+}
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n += 1) {
+    let c = n;
+    for (let k = 0; k < 8; k += 1) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let crc = 4294967295;
+  for (const byte of bytes) crc = CRC_TABLE[(crc ^ byte) & 255] ^ crc >>> 8;
+  return (crc ^ 4294967295) >>> 0;
+}
+function chunk(type, data) {
+  const out = new Uint8Array(data.length + 12);
+  const view = new DataView(out.buffer);
+  view.setUint32(0, data.length);
+  for (let i = 0; i < 4; i += 1) out[4 + i] = type.charCodeAt(i);
+  out.set(data, 8);
+  view.setUint32(data.length + 8, crc32(out.subarray(4, data.length + 8)));
+  return out;
+}
+function encodePng(rgba, width, height) {
+  const header = new Uint8Array(13);
+  const view = new DataView(header.buffer);
+  view.setUint32(0, width);
+  view.setUint32(4, height);
+  header[8] = 8;
+  header[9] = 6;
+  const raw = new Uint8Array(height * (width * 4 + 1));
+  for (let y = 0; y < height; y += 1) {
+    raw[y * (width * 4 + 1)] = 0;
+    raw.set(rgba.subarray(y * width * 4, (y + 1) * width * 4), y * (width * 4 + 1) + 1);
+  }
+  const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+  const parts = [
+    signature,
+    chunk("IHDR", header),
+    chunk("IDAT", new Uint8Array(deflateSync(raw))),
+    chunk("IEND", new Uint8Array(0))
+  ];
+  const png = new Uint8Array(parts.reduce((total, part) => total + part.length, 0));
+  let at = 0;
+  for (const part of parts) {
+    png.set(part, at);
+    at += part.length;
+  }
+  return png;
+}
+
+// ../server/src/services/tray-icon.ts
+var MAX_LOGO_BYTES = 1024 * 1024;
+var FETCH_TIMEOUT_MS = 3e3;
+var CACHE_TTL_MS = 10 * 6e4;
+var cache2 = /* @__PURE__ */ new Map();
+function trayIconDir() {
+  return join17(machineRoot(), "tray-icons");
+}
+async function resolveTrayIcon(platform = process.platform) {
+  const orgId = getCurrentProject()?.orgId;
+  if (orgId) {
+    const cached = cache2.get(orgId);
+    const logo = cached && Date.now() - cached.at < CACHE_TTL_MS ? cached.path : await resolveOrgLogo(orgId, platform);
+    if (!cached || Date.now() - cached.at >= CACHE_TTL_MS) {
+      cache2.set(orgId, { path: logo, at: Date.now() });
+    }
+    if (logo) return logo;
+  }
+  return renderThemedIcon(platform);
+}
+async function renderThemedIcon(platform) {
+  const accent2 = getTrayAccent();
+  if (!accent2) return null;
+  try {
+    const png = renderRuneyaIcon(accent2, 64);
+    if (!png) return null;
+    return writeTrayIcon(`theme-${accent2.replace(/[^a-z0-9]/g, "")}`, png, platform);
+  } catch (err) {
+    console.log(`[tray] ic\xF4ne du th\xE8me non \xE9crite : ${err.message}`);
+    return null;
+  }
+}
+async function writeTrayIcon(stem, png, platform) {
+  const dir = trayIconDir();
+  await mkdir13(dir, { recursive: true });
+  const path = join17(dir, stem);
+  if (platform === "win32") {
+    const ico = pngToIco(png);
+    return ico ? writeAtomic(`${path}.ico`, ico) : null;
+  }
+  return writeAtomic(`${path}.png`, png);
+}
+async function writeAtomic(path, bytes) {
+  const tmp = `${path}.${process.pid}.tmp`;
+  await writeFile10(tmp, bytes);
+  await rename8(tmp, path);
+  return path;
+}
+async function resolveOrgLogo(orgId, platform) {
+  try {
+    const bytes = await orgLogoBytes(orgId);
+    if (!bytes) return null;
+    return writeTrayIcon(`org-${orgId.replace(/[^a-zA-Z0-9_-]/g, "")}`, bytes, platform);
+  } catch (err) {
+    console.log(`[tray] logo d'organisation indisponible : ${err.message}`);
+    return null;
+  }
+}
+async function orgLogoBytes(orgId) {
+  const stored = await readOrgLogo(orgId);
+  if (stored && isPng(stored.bytes)) return stored.bytes;
+  const url = `${await orgCloudUrl(orgId)}/api/org-logo/${encodeURIComponent(orgId)}?format=png`;
+  const response = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+  if (!response.ok) return null;
+  const bytes = new Uint8Array(await response.arrayBuffer());
+  if (bytes.length === 0 || bytes.length > MAX_LOGO_BYTES) return null;
+  return isPng(bytes) ? bytes : null;
+}
+
 // ../server/src/index.ts
 dotenv.config({ quiet: true });
 if (process.env["RUNEYA_DATA_DIR"]) {
@@ -10292,6 +10556,7 @@ export {
   pullEnv,
   registerCli as registerCliLocation,
   registerInstance,
+  resolveTrayIcon,
   restartInstance,
   restartProcess,
   scheduleSelfRestart,
@@ -10299,4 +10564,4 @@ export {
   startProcess,
   stopProcess
 };
-//# sourceMappingURL=src-V7DPPFCF.js.map
+//# sourceMappingURL=src-TEL7L4K2.js.map