fifony 0.1.47 → 0.1.48

package/dist/chunk-AFOV3ZAF.js

@@ -0,0 +1,722 @@
+import {
+  computeMetrics
+} from "./chunk-VOYLU3MI.js";
+import {
+  serviceLogPath
+} from "./chunk-UR7T7IA6.js";
+import {
+  init_helpers,
+  now
+} from "./chunk-DLSPRIQL.js";
+import {
+  STATE_ROOT,
+  init_constants
+} from "./chunk-X37RNTWU.js";
+import {
+  logger
+} from "./chunk-PXTIWKLQ.js";
+
+// src/persistence/plugins/service-log-broadcaster.ts
+import { existsSync, statSync } from "fs";
+import TailFile from "@logdna/tail-file";
+
+// src/routes/websocket.ts
+init_helpers();
+init_constants();
+var meshSnapshotProvider = null;
+var servicesSnapshotProvider = null;
+var reverseProxySnapshotProvider = null;
+var meshSnapshotSeq = 0;
+var reverseProxySnapshotSeq = 0;
+var wsClientHandlers = /* @__PURE__ */ new Map();
+var wsClientTypeGuards = {
+  ping: () => true,
+  "service:log:subscribe": (msg) => typeof msg?.id === "string",
+  "service:log:unsubscribe": (msg) => typeof msg?.id === "string",
+  "services:subscribe": () => true,
+  "services:unsubscribe": () => true,
+  "analytics:subscribe": (msg) => typeof msg?.topic === "string",
+  "analytics:unsubscribe": (msg) => typeof msg?.topic === "string",
+  "issue:log:subscribe": (msg) => typeof msg?.id === "string",
+  "issue:log:unsubscribe": (msg) => typeof msg?.id === "string",
+  "mesh:subscribe": () => true,
+  "mesh:unsubscribe": () => true,
+  "proxy:reverse:subscribe": () => true,
+  "proxy:reverse:unsubscribe": () => true
+};
+var wsTelemetry = {
+  startedAt: now(),
+  connectionAttempts: 0,
+  successfulConnections: 0,
+  disconnections: 0,
+  connectionErrors: 0,
+  inboundMessages: 0,
+  outboundMessages: 0,
+  inboundByType: /* @__PURE__ */ Object.create(null),
+  outboundByType: /* @__PURE__ */ Object.create(null),
+  invalidMessages: 0,
+  unknownCommands: 0,
+  invalidCommandPayloads: 0,
+  commandErrors: 0,
+  lastInboundAt: null,
+  lastOutboundAt: null,
+  lastConnectedAt: null,
+  lastDisconnectedAt: null
+};
+function wsNow() {
+  return now();
+}
+function normalizeWsMessageType(value) {
+  return typeof value === "string" && value.length > 0 ? value : "__unknown__";
+}
+function incrementRecord(target, key) {
+  target[key] = (target[key] ?? 0) + 1;
+}
+function resolvePayloadType(payload) {
+  if (typeof payload === "string") {
+    try {
+      const parsed = JSON.parse(payload);
+      if (parsed && typeof parsed === "object" && typeof parsed.type === "string") {
+        return normalizeWsMessageType(parsed.type);
+      }
+    } catch {
+      return "__invalid-json__";
+    }
+  } else if (payload.type !== void 0) {
+    return normalizeWsMessageType(payload.type);
+  }
+  return "__unknown__";
+}
+function trackOutboundMessage(payload) {
+  const type = resolvePayloadType(payload);
+  wsTelemetry.outboundMessages += 1;
+  wsTelemetry.lastOutboundAt = wsNow();
+  incrementRecord(wsTelemetry.outboundByType, type);
+}
+function trackInboundMessage(message) {
+  const type = normalizeWsMessageType(message?.type);
+  wsTelemetry.inboundMessages += 1;
+  wsTelemetry.lastInboundAt = wsNow();
+  incrementRecord(wsTelemetry.inboundByType, type);
+}
+function cleanupStaleSocket(socketId) {
+  unsubscribeFromAllRooms(socketId);
+  wsClients.delete(socketId);
+}
+function sendToSocket(socketId, payload) {
+  const send = wsClients.get(socketId);
+  if (!send) return false;
+  const encoded = typeof payload === "string" ? payload : JSON.stringify(payload);
+  try {
+    send(encoded);
+    trackOutboundMessage(encoded);
+    return true;
+  } catch {
+    wsTelemetry.connectionErrors += 1;
+    cleanupStaleSocket(socketId);
+    return false;
+  }
+}
+function sendToSocketList(socketIds, payload) {
+  const safePayload = typeof payload === "string" ? payload : JSON.stringify(payload);
+  for (const socketId of [...socketIds]) {
+    const send = wsClients.get(socketId);
+    if (!send) {
+      socketIds.delete(socketId);
+      continue;
+    }
+    try {
+      send(safePayload);
+      trackOutboundMessage(safePayload);
+    } catch {
+      wsTelemetry.connectionErrors += 1;
+      cleanupStaleSocket(socketId);
+      socketIds.delete(socketId);
+    }
+  }
+}
+var wsClients = /* @__PURE__ */ new Map();
+var broadcastSeq = 0;
+var servicesSnapshotSeq = 0;
+var lastBroadcastIssueSnapshot = /* @__PURE__ */ new Map();
+function setMeshSnapshotProvider(fn) {
+  meshSnapshotProvider = fn;
+}
+function setServicesSnapshotProvider(fn) {
+  servicesSnapshotProvider = fn;
+}
+function notifyServicesSnapshot() {
+  const payload = servicesSnapshotProvider?.();
+  if (!payload || wsClients.size === 0) return;
+  servicesSnapshotSeq += 1;
+  sendToServicesRoom({
+    type: "services:snapshot",
+    ...payload,
+    seq: servicesSnapshotSeq,
+    timestamp: now()
+  });
+}
+function notifyMeshSnapshot() {
+  const payload = meshSnapshotProvider?.();
+  if (!payload || !meshRoomHasSubscribers()) return;
+  meshSnapshotSeq += 1;
+  sendToMeshRoom({
+    type: "mesh:snapshot",
+    ...payload,
+    seq: meshSnapshotSeq,
+    timestamp: now()
+  });
+}
+var serviceLogRooms = /* @__PURE__ */ new Map();
+function subscribeServiceLogRoom(socketId, serviceId) {
+  if (!serviceLogRooms.has(serviceId)) serviceLogRooms.set(serviceId, /* @__PURE__ */ new Set());
+  serviceLogRooms.get(serviceId).add(socketId);
+}
+function unsubscribeServiceLogRoom(socketId, serviceId) {
+  serviceLogRooms.get(serviceId)?.delete(socketId);
+}
+var analyticsRooms = /* @__PURE__ */ new Map();
+var analyticsOnSubscribeFn = null;
+function setAnalyticsOnSubscribeFn(fn) {
+  analyticsOnSubscribeFn = fn;
+}
+function subscribeAnalyticsRoom(socketId, topic) {
+  if (!analyticsRooms.has(topic)) analyticsRooms.set(topic, /* @__PURE__ */ new Set());
+  analyticsRooms.get(topic).add(socketId);
+  analyticsOnSubscribeFn?.(socketId, topic);
+}
+function unsubscribeAnalyticsRoom(socketId, topic) {
+  analyticsRooms.get(topic)?.delete(socketId);
+}
+function analyticsRoomHasSubscribers(topic) {
+  return (analyticsRooms.get(topic)?.size ?? 0) > 0;
+}
+function sendToAnalyticsRoom(topic, data) {
+  const room = analyticsRooms.get(topic);
+  if (!room || room.size === 0) return;
+  const msg = JSON.stringify({ type: "analytics:update", topic, data });
+  sendToSocketList(room, msg);
+}
+var issueLogRooms = /* @__PURE__ */ new Map();
+function subscribeIssueLogRoom(socketId, issueId) {
+  if (!issueLogRooms.has(issueId)) issueLogRooms.set(issueId, /* @__PURE__ */ new Set());
+  issueLogRooms.get(issueId).add(socketId);
+}
+function unsubscribeIssueLogRoom(socketId, issueId) {
+  issueLogRooms.get(issueId)?.delete(socketId);
+}
+function issueLogRoomSize(issueId) {
+  return issueLogRooms.get(issueId)?.size ?? 0;
+}
+function sendToIssueLogRoom(issueId, data) {
+  const room = issueLogRooms.get(issueId);
+  if (!room || room.size === 0) return;
+  sendToSocketList(room, data);
+}
+var servicesRoom = /* @__PURE__ */ new Set();
+function subscribeServicesRoom(socketId) {
+  servicesRoom.add(socketId);
+}
+function unsubscribeServicesRoom(socketId) {
+  servicesRoom.delete(socketId);
+}
+function servicesRoomHasSubscribers() {
+  return servicesRoom.size > 0;
+}
+function sendToServicesRoom(data) {
+  if (servicesRoom.size === 0) return;
+  const msg = JSON.stringify(data);
+  sendToSocketList(servicesRoom, msg);
+}
+var meshRoom = /* @__PURE__ */ new Set();
+function subscribeMeshRoom(socketId) {
+  meshRoom.add(socketId);
+}
+function unsubscribeMeshRoom(socketId) {
+  meshRoom.delete(socketId);
+}
+function sendToMeshRoom(data) {
+  if (meshRoom.size === 0) return;
+  const msg = JSON.stringify(data);
+  sendToSocketList(meshRoom, msg);
+}
+function meshRoomHasSubscribers() {
+  return meshRoom.size > 0;
+}
+var reverseProxyRoom = /* @__PURE__ */ new Set();
+function setReverseProxySnapshotProvider(fn) {
+  reverseProxySnapshotProvider = fn;
+}
+function subscribeReverseProxyRoom(socketId) {
+  reverseProxyRoom.add(socketId);
+}
+function unsubscribeReverseProxyRoom(socketId) {
+  reverseProxyRoom.delete(socketId);
+}
+function reverseProxyRoomHasSubscribers() {
+  return reverseProxyRoom.size > 0;
+}
+function sendToReverseProxyRoom(data) {
+  if (reverseProxyRoom.size === 0) return;
+  sendToSocketList(reverseProxyRoom, JSON.stringify(data));
+}
+function notifyReverseProxySnapshot() {
+  const payload = reverseProxySnapshotProvider?.();
+  if (!payload || reverseProxyRoom.size === 0) return;
+  reverseProxySnapshotSeq += 1;
+  sendToReverseProxyRoom({
+    type: "proxy:reverse:snapshot",
+    ...payload,
+    seq: reverseProxySnapshotSeq,
+    timestamp: now()
+  });
+}
+function unsubscribeFromAllRooms(socketId) {
+  for (const room of serviceLogRooms.values()) room.delete(socketId);
+  for (const room of analyticsRooms.values()) room.delete(socketId);
+  for (const room of issueLogRooms.values()) room.delete(socketId);
+  servicesRoom.delete(socketId);
+  meshRoom.delete(socketId);
+  reverseProxyRoom.delete(socketId);
+}
+function serviceLogRoomSize(serviceId) {
+  return serviceLogRooms.get(serviceId)?.size ?? 0;
+}
+function sendToServiceLogRoom(serviceId, data) {
+  const room = serviceLogRooms.get(serviceId);
+  if (!room || room.size === 0) return;
+  sendToSocketList(room, data);
+}
+function sendToAllClients(data) {
+  for (const socketId of [...wsClients.keys()]) {
+    if (!sendToSocket(socketId, data)) {
+      logger.debug(`WebSocket send failed for ${socketId}, removing (remaining: ${wsClients.size - 1})`);
+    }
+  }
+}
+function parseWsClientMessage(raw) {
+  if (typeof raw !== "string" && !Buffer.isBuffer(raw)) return null;
+  const payload = typeof raw === "string" ? raw : raw.toString("utf8");
+  try {
+    const msg = JSON.parse(payload);
+    return msg && typeof msg === "object" ? msg : null;
+  } catch {
+    return null;
+  }
+}
+function registerWsCommandHandlers() {
+  if (wsClientHandlers.size > 0) return;
+  wsClientHandlers.set("ping", (_socketId, _payload) => {
+    const payload = _payload;
+    const seq = typeof payload.seq === "number" ? payload.seq : void 0;
+    const clientTs = typeof payload.clientTs === "number" || typeof payload.clientTs === "string" ? payload.clientTs : void 0;
+    sendToSocket(_socketId, {
+      type: "pong",
+      seq,
+      clientTs,
+      timestamp: now()
+    });
+  });
+  wsClientHandlers.set("service:log:subscribe", (socketId, payload) => {
+    const serviceId = payload.id;
+    if (typeof serviceId !== "string") return;
+    subscribeServiceLogRoom(socketId, serviceId);
+    startServiceLogBroadcasting(serviceId, STATE_ROOT);
+    logger.debug({ socketId, serviceId }, "[WebSocket] Subscribed to service log room");
+  });
+  wsClientHandlers.set("service:log:unsubscribe", (socketId, payload) => {
+    const serviceId = payload.id;
+    if (typeof serviceId !== "string") return;
+    unsubscribeServiceLogRoom(socketId, serviceId);
+    logger.debug({ socketId, serviceId }, "[WebSocket] Unsubscribed from service log room");
+  });
+  wsClientHandlers.set("services:subscribe", (socketId) => {
+    subscribeServicesRoom(socketId);
+    const snapshot = servicesSnapshotProvider?.();
+    if (snapshot) {
+      sendToSocket(socketId, {
+        type: "services:snapshot",
+        ...snapshot,
+        seq: servicesSnapshotSeq,
+        timestamp: now()
+      });
+    }
+    logger.debug({ socketId }, "[WebSocket] Subscribed to services room");
+  });
+  wsClientHandlers.set("services:unsubscribe", (socketId) => {
+    unsubscribeServicesRoom(socketId);
+    logger.debug({ socketId }, "[WebSocket] Unsubscribed from services room");
+  });
+  wsClientHandlers.set("analytics:subscribe", (socketId, payload) => {
+    const topic = payload.topic;
+    if (typeof topic !== "string") return;
+    subscribeAnalyticsRoom(socketId, topic);
+    logger.debug({ socketId, topic }, "[WebSocket] Subscribed to analytics room");
+  });
+  wsClientHandlers.set("analytics:unsubscribe", (socketId, payload) => {
+    const topic = payload.topic;
+    if (typeof topic !== "string") return;
+    unsubscribeAnalyticsRoom(socketId, topic);
+    logger.debug({ socketId, topic }, "[WebSocket] Unsubscribed from analytics room");
+  });
+  wsClientHandlers.set("issue:log:subscribe", (socketId, payload) => {
+    const issueId = payload.id;
+    if (typeof issueId !== "string") return;
+    subscribeIssueLogRoom(socketId, issueId);
+    logger.debug({ socketId, issueId }, "[WebSocket] Subscribed to issue log room");
+  });
+  wsClientHandlers.set("issue:log:unsubscribe", (socketId, payload) => {
+    const issueId = payload.id;
+    if (typeof issueId !== "string") return;
+    unsubscribeIssueLogRoom(socketId, issueId);
+    logger.debug({ socketId, issueId }, "[WebSocket] Unsubscribed from issue log room");
+  });
+  wsClientHandlers.set("mesh:subscribe", (socketId) => {
+    subscribeMeshRoom(socketId);
+    const snapshot = meshSnapshotProvider?.();
+    if (snapshot) {
+      sendToSocket(socketId, {
+        type: "mesh:snapshot",
+        ...snapshot,
+        seq: meshSnapshotSeq,
+        timestamp: now()
+      });
+    }
+    logger.debug({ socketId }, "[WebSocket] Subscribed to mesh traffic room");
+  });
+  wsClientHandlers.set("mesh:unsubscribe", (socketId) => {
+    unsubscribeMeshRoom(socketId);
+    logger.debug({ socketId }, "[WebSocket] Unsubscribed from mesh traffic room");
+  });
+  wsClientHandlers.set("proxy:reverse:subscribe", (socketId) => {
+    subscribeReverseProxyRoom(socketId);
+    const snapshot = reverseProxySnapshotProvider?.();
+    if (snapshot) {
+      reverseProxySnapshotSeq += 1;
+      sendToSocket(socketId, {
+        type: "proxy:reverse:snapshot",
+        ...snapshot,
+        seq: reverseProxySnapshotSeq,
+        timestamp: now()
+      });
+    }
+    logger.debug({ socketId }, "[WebSocket] Subscribed to reverse proxy room");
+  });
+  wsClientHandlers.set("proxy:reverse:unsubscribe", (socketId) => {
+    unsubscribeReverseProxyRoom(socketId);
+    logger.debug({ socketId }, "[WebSocket] Unsubscribed from reverse proxy room");
+  });
+}
+function handleWsClientMessage(socketId, rawMessage, send) {
+  const msg = parseWsClientMessage(rawMessage);
+  if (!msg) {
+    wsTelemetry.invalidMessages += 1;
+    return;
+  }
+  trackInboundMessage(msg);
+  const type = msg.type;
+  if (typeof type !== "string") {
+    wsTelemetry.invalidMessages += 1;
+    return;
+  }
+  const handler = wsClientHandlers.get(type);
+  if (!handler) {
+    wsTelemetry.unknownCommands += 1;
+    return;
+  }
+  const guard = wsClientTypeGuards[type];
+  if (guard && !guard(msg)) {
+    wsTelemetry.invalidCommandPayloads += 1;
+    return;
+  }
+  try {
+    handler(socketId, msg, send);
+  } catch (error) {
+    wsTelemetry.commandErrors += 1;
+    logger.debug({ err: String(error), type, socketId }, "[WebSocket] Command handler failed");
+  }
+}
+function broadcastIssueProgress(progress) {
+  if (wsClients.size === 0) return;
+  const data = JSON.stringify({ type: "issue:progress", ...progress });
+  sendToAllClients(data);
+}
+function broadcastIssueTransition(issue) {
+  if (wsClients.size === 0) return;
+  const data = JSON.stringify({
+    type: "issue:transition",
+    id: issue.id,
+    state: issue.state,
+    issue
+  });
+  sendToAllClients(data);
+}
+function broadcastToWebSocketClients(message) {
+  if (wsClients.size === 0) return;
+  broadcastSeq++;
+  logger.debug({ seq: broadcastSeq, type: message.type, clientCount: wsClients.size }, "[WebSocket] Broadcasting state update");
+  const issues = message.issues;
+  if (issues && lastBroadcastIssueSnapshot.size > 0) {
+    const currentIds = /* @__PURE__ */ new Set();
+    const changedIssues = [];
+    for (const issue of issues) {
+      const id = issue.id;
+      currentIds.add(id);
+      const serialized = JSON.stringify(issue);
+      if (lastBroadcastIssueSnapshot.get(id) !== serialized) {
+        changedIssues.push(issue);
+      }
+    }
+    const removedIds = [];
+    for (const prevId of lastBroadcastIssueSnapshot.keys()) {
+      if (!currentIds.has(prevId)) {
+        removedIds.push(prevId);
+      }
+    }
+    lastBroadcastIssueSnapshot = new Map(
+      issues.map((issue) => [issue.id, JSON.stringify(issue)])
+    );
+    if (changedIssues.length < issues.length / 2 || changedIssues.length <= 3) {
+      const delta = {
+        type: "state:delta",
+        seq: broadcastSeq,
+        metrics: message.metrics,
+        milestones: message.milestones,
+        updatedAt: message.updatedAt,
+        issuesDelta: changedIssues,
+        issuesRemoved: removedIds,
+        events: message.events
+      };
+      sendToAllClients(JSON.stringify(delta));
+      return;
+    }
+  }
+  if (issues) {
+    lastBroadcastIssueSnapshot = new Map(
+      issues.map((issue) => [issue.id, JSON.stringify(issue)])
+    );
+  }
+  sendToAllClients(JSON.stringify({
+    ...message,
+    seq: broadcastSeq
+  }));
+}
+function makeWebSocketConfig(state) {
+  registerWsCommandHandlers();
+  return {
+    enabled: true,
+    path: "/ws",
+    maxPayloadBytes: 512e3,
+    onConnection: (socketId, send) => {
+      wsClients.set(socketId, send);
+      wsTelemetry.connectionAttempts += 1;
+      wsTelemetry.successfulConnections += 1;
+      wsTelemetry.lastConnectedAt = wsNow();
+      logger.debug(`WebSocket client connected: ${socketId} (total: ${wsClients.size})`);
+      try {
+        subscribeServicesRoom(socketId);
+        sendToSocket(socketId, JSON.stringify({
+          type: "connected",
+          seq: broadcastSeq,
+          timestamp: now(),
+          metrics: computeMetrics(state.issues),
+          milestones: state.milestones,
+          issues: state.issues,
+          events: state.events.slice(0, 50)
+        }));
+        const servicesSnapshot = servicesSnapshotProvider?.();
+        if (servicesSnapshot) {
+          sendToSocket(socketId, {
+            type: "services:snapshot",
+            ...servicesSnapshot,
+            seq: servicesSnapshotSeq,
+            timestamp: now()
+          });
+        }
+        const meshSnapshot = meshSnapshotProvider?.();
+        if (meshSnapshot) {
+          sendToSocket(socketId, {
+            type: "mesh:snapshot",
+            ...meshSnapshot,
+            seq: meshSnapshotSeq,
+            timestamp: now()
+          });
+        }
+        const reverseProxySnapshot = reverseProxySnapshotProvider?.();
+        if (reverseProxySnapshot) {
+          sendToSocket(socketId, {
+            type: "proxy:reverse:snapshot",
+            ...reverseProxySnapshot,
+            seq: reverseProxySnapshotSeq,
+            timestamp: now()
+          });
+        }
+      } catch (error) {
+        logger.debug(`WebSocket initial send failed for ${socketId}: ${String(error)}`);
+      }
+    },
+    onMessage: (socketId, message, send) => {
+      handleWsClientMessage(socketId, message, send);
+    },
+    onClose: (socketId) => {
+      wsClients.delete(socketId);
+      wsTelemetry.disconnections += 1;
+      wsTelemetry.lastDisconnectedAt = wsNow();
+      unsubscribeFromAllRooms(socketId);
+      logger.debug(`WebSocket client disconnected: ${socketId} (total: ${wsClients.size})`);
+    }
+  };
+}
+function getWsTelemetry() {
+  return {
+    ...wsTelemetry,
+    activeConnections: wsClients.size,
+    inboundByType: { ...wsTelemetry.inboundByType },
+    outboundByType: { ...wsTelemetry.outboundByType },
+    startedAt: wsTelemetry.startedAt,
+    lastInboundAt: wsTelemetry.lastInboundAt,
+    lastOutboundAt: wsTelemetry.lastOutboundAt,
+    lastConnectedAt: wsTelemetry.lastConnectedAt,
+    lastDisconnectedAt: wsTelemetry.lastDisconnectedAt
+  };
+}
+function resetWsTelemetry() {
+  wsTelemetry.startedAt = now();
+  wsTelemetry.connectionAttempts = 0;
+  wsTelemetry.successfulConnections = 0;
+  wsTelemetry.disconnections = 0;
+  wsTelemetry.connectionErrors = 0;
+  wsTelemetry.inboundMessages = 0;
+  wsTelemetry.outboundMessages = 0;
+  wsTelemetry.inboundByType = /* @__PURE__ */ Object.create(null);
+  wsTelemetry.outboundByType = /* @__PURE__ */ Object.create(null);
+  wsTelemetry.invalidMessages = 0;
+  wsTelemetry.unknownCommands = 0;
+  wsTelemetry.invalidCommandPayloads = 0;
+  wsTelemetry.commandErrors = 0;
+  wsTelemetry.lastInboundAt = null;
+  wsTelemetry.lastOutboundAt = null;
+  wsTelemetry.lastConnectedAt = null;
+  wsTelemetry.lastDisconnectedAt = null;
+  return getWsTelemetry();
+}
+
+// src/persistence/plugins/service-log-broadcaster.ts
+var MAX_CHUNK_BYTES = 16384;
+var active = /* @__PURE__ */ new Map();
+function startServiceLogBroadcasting(id, fifonyDir) {
+  if (active.has(id)) return;
+  const logPath = serviceLogPath(fifonyDir, id);
+  if (!existsSync(logPath)) return;
+  const tail = new TailFile(logPath, {
+    startPos: null,
+    // null = start from EOF
+    pollFileIntervalMs: 250,
+    // 250ms poll — fast enough for real-time feel
+    maxPollFailures: 30,
+    // tolerate temporary file absence (rotation)
+    encoding: "utf8"
+  });
+  const entry = { tail, buffer: "", position: 0 };
+  try {
+    entry.position = statSync(logPath).size;
+  } catch {
+  }
+  tail.on("data", (chunk) => {
+    const text = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    if (!text) return;
+    entry.position += Buffer.byteLength(text, "utf8");
+    if (serviceLogRoomSize(id) === 0) {
+      entry.buffer += text;
+      if (entry.buffer.length > MAX_CHUNK_BYTES) {
+        entry.buffer = entry.buffer.slice(-MAX_CHUNK_BYTES);
+      }
+      return;
+    }
+    let payload = entry.buffer + text;
+    entry.buffer = "";
+    if (payload.length > MAX_CHUNK_BYTES) {
+      payload = payload.slice(-MAX_CHUNK_BYTES);
+    }
+    sendToServiceLogRoom(id, JSON.stringify({ type: "service:log", id, chunk: payload }));
+  });
+  tail.on("truncated", (info) => {
+    logger.debug({ id, info }, "[ServiceLogBroadcaster] File truncated (rotation/restart)");
+    entry.position = 0;
+    entry.buffer = "";
+  });
+  tail.on("renamed", (info) => {
+    logger.debug({ id, info }, "[ServiceLogBroadcaster] File renamed (log rotation)");
+  });
+  tail.on("tail_error", (err) => {
+    logger.warn({ id, err }, "[ServiceLogBroadcaster] Tail error");
+  });
+  active.set(id, entry);
+  tail.start().then(() => {
+    logger.debug({ id, logPath }, "[ServiceLogBroadcaster] Started tailing");
+  }).catch((err) => {
+    logger.warn({ id, err }, "[ServiceLogBroadcaster] Failed to start tail");
+    active.delete(id);
+  });
+}
+function stopServiceLogBroadcasting(id) {
+  const entry = active.get(id);
+  if (!entry) return;
+  active.delete(id);
+  entry.tail.quit().catch(() => {
+  });
+}
+function stopAllServiceLogBroadcasting() {
+  for (const id of [...active.keys()]) stopServiceLogBroadcasting(id);
+}
+
+export {
+  startServiceLogBroadcasting,
+  stopServiceLogBroadcasting,
+  stopAllServiceLogBroadcasting,
+  wsClients,
+  broadcastSeq,
+  lastBroadcastIssueSnapshot,
+  setMeshSnapshotProvider,
+  setServicesSnapshotProvider,
+  notifyServicesSnapshot,
+  notifyMeshSnapshot,
+  subscribeServiceLogRoom,
+  unsubscribeServiceLogRoom,
+  setAnalyticsOnSubscribeFn,
+  subscribeAnalyticsRoom,
+  unsubscribeAnalyticsRoom,
+  analyticsRoomHasSubscribers,
+  sendToAnalyticsRoom,
+  subscribeIssueLogRoom,
+  unsubscribeIssueLogRoom,
+  issueLogRoomSize,
+  sendToIssueLogRoom,
+  subscribeServicesRoom,
+  unsubscribeServicesRoom,
+  servicesRoomHasSubscribers,
+  sendToServicesRoom,
+  subscribeMeshRoom,
+  unsubscribeMeshRoom,
+  sendToMeshRoom,
+  meshRoomHasSubscribers,
+  setReverseProxySnapshotProvider,
+  subscribeReverseProxyRoom,
+  unsubscribeReverseProxyRoom,
+  reverseProxyRoomHasSubscribers,
+  sendToReverseProxyRoom,
+  notifyReverseProxySnapshot,
+  unsubscribeFromAllRooms,
+  serviceLogRoomSize,
+  sendToServiceLogRoom,
+  sendToAllClients,
+  parseWsClientMessage,
+  handleWsClientMessage,
+  broadcastIssueProgress,
+  broadcastIssueTransition,
+  broadcastToWebSocketClients,
+  makeWebSocketConfig,
+  getWsTelemetry,
+  resetWsTelemetry
+};
+//# sourceMappingURL=chunk-AFOV3ZAF.js.map