fifony 0.1.47 → 0.1.48

package/dist/{chunk-AAVROEQC.js → chunk-UR7T7IA6.js}

@@ -1,13 +1,21 @@
 import {
-  S3DB_SERVICES_RESOURCE,
+  buildProxyEnvVars,
+  getMeshRuntimePortSnapshot
+} from "./chunk-7R7XFXJM.js";
+import {
+  isProcessAlive
+} from "./chunk-3NE23NYW.js";
+import {
+  init_helpers,
   now
-} from "./chunk-VM5QAYP5.js";
+} from "./chunk-DLSPRIQL.js";
+import {
+  S3DB_SERVICES_RESOURCE,
+  init_constants
+} from "./chunk-X37RNTWU.js";
 import {
   logger
 } from "./chunk-PXTIWKLQ.js";
-import {
-  isProcessAlive
-} from "./chunk-3NE23NYW.js";
 
 // src/persistence/plugins/fsm-service.ts
 import {
@@ -16,12 +24,14 @@ import {
   openSync,
   readFileSync,
   readSync,
+  renameSync,
   rmSync,
   statSync,
   writeFileSync
 } from "fs";
 import { join, resolve } from "path";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
+init_helpers();
 
 // src/domains/service-env.ts
 var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -57,285 +67,54 @@ function mergeServiceEnvironment(globalEnv, serviceEnv) {
 function shellQuoteEnvValue(value) {
   return `'${value.replace(/'/g, `'"'"'`)}'`;
 }
-function buildServiceCommand(command, globalEnv, serviceEnv) {
+function buildServiceCommand(command, globalEnv, serviceEnv, enforcedEnv) {
   const baseCommand = command.trim();
   if (!baseCommand) return "";
-  const env = mergeServiceEnvironment(globalEnv, serviceEnv);
+  const env = {
+    ...mergeServiceEnvironment(globalEnv, serviceEnv),
+    ...enforcedEnv ?? {}
+  };
   const assignments = Object.entries(env).map(([key, value]) => `${key}=${shellQuoteEnvValue(value)}`);
   return assignments.length > 0 ? `${assignments.join(" ")} ${baseCommand}` : baseCommand;
 }
 
-// src/persistence/plugins/traffic-proxy-server.ts
-import { createServer } from "http";
-import {
-  createHttpForwardProxy
-} from "raffel";
-
-// src/domains/traffic-proxy.ts
-var TrafficRingBuffer = class {
-  constructor(capacity = 1e3) {
-    this.capacity = capacity;
-    this.buf = new Array(capacity);
-  }
-  buf;
-  head = 0;
-  count = 0;
-  push(entry) {
-    this.buf[this.head] = entry;
-    this.head = (this.head + 1) % this.capacity;
-    if (this.count < this.capacity) this.count++;
-  }
-  getAll() {
-    if (this.count === 0) return [];
-    if (this.count < this.capacity) return this.buf.slice(0, this.count);
-    return [...this.buf.slice(this.head), ...this.buf.slice(0, this.head)];
-  }
-  getRecent(n) {
-    const all = this.getAll();
-    return n >= all.length ? all : all.slice(-n);
-  }
-  clear() {
-    this.head = 0;
-    this.count = 0;
-  }
-  get size() {
-    return this.count;
-  }
-};
-function edgeKey(source, target) {
-  return `${source}\0${target}`;
+// src/persistence/plugins/fsm-service.ts
+init_constants();
+var STARTING_GRACE_MS = 3e3;
+var STOPPING_KILL_MS = 5e3;
+var SERVICE_WATCHER_INTERVAL_MS = 5e3;
+function pidPath(fifonyDir, id) {
+  return join(fifonyDir, `service-${id}.pid`);
 }
-var MAX_TOP_PATHS = 5;
-var MAX_P95_SAMPLES = 200;
-var ServiceGraphAccumulator = class {
-  edges = /* @__PURE__ */ new Map();
-  totalRequests = 0;
-  capturedSince = (/* @__PURE__ */ new Date()).toISOString();
-  record(entry) {
-    const src = entry.sourceServiceId ?? "unknown";
-    const tgt = entry.targetServiceId ?? "external";
-    const key = edgeKey(src, tgt);
-    this.totalRequests++;
-    let edge = this.edges.get(key);
-    if (!edge) {
-      edge = {
-        source: src,
-        target: tgt,
-        requestCount: 0,
-        errorCount: 0,
-        latency: { sum: 0, count: 0, values: [] },
-        lastSeenAt: entry.startedAt,
-        pathCounts: /* @__PURE__ */ new Map()
-      };
-      this.edges.set(key, edge);
-    }
-    edge.requestCount++;
-    if (entry.statusCode >= 400 || entry.error) edge.errorCount++;
-    edge.latency.sum += entry.durationMs;
-    edge.latency.count++;
-    if (edge.latency.values.length >= MAX_P95_SAMPLES) edge.latency.values.shift();
-    edge.latency.values.push(entry.durationMs);
-    edge.lastSeenAt = entry.startedAt;
-    edge.pathCounts.set(entry.path, (edge.pathCounts.get(entry.path) ?? 0) + 1);
-  }
-  getGraph(services) {
-    const nodes = services.map((s) => ({
-      id: s.id,
-      name: s.name,
-      state: s.state,
-      port: s.port
-    }));
-    const edges = [];
-    for (const e of this.edges.values()) {
-      const sorted = [...e.latency.values].sort((a, b) => a - b);
-      const pct = (p) => sorted.length > 0 ? sorted[Math.min(Math.floor(sorted.length * p), sorted.length - 1)] : 0;
-      const topPaths = [...e.pathCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, MAX_TOP_PATHS).map(([path, count]) => ({ path, count }));
-      edges.push({
-        source: e.source,
-        target: e.target,
-        requestCount: e.requestCount,
-        errorCount: e.errorCount,
-        avgLatencyMs: e.latency.count > 0 ? Math.round(e.latency.sum / e.latency.count) : 0,
-        p50LatencyMs: pct(0.5),
-        p90LatencyMs: pct(0.9),
-        p95LatencyMs: pct(0.95),
-        p99LatencyMs: pct(0.99),
-        lastSeenAt: e.lastSeenAt,
-        topPaths
-      });
-    }
-    return {
-      nodes,
-      edges,
-      capturedSince: this.capturedSince,
-      totalRequests: this.totalRequests
-    };
-  }
-  reset() {
-    this.edges.clear();
-    this.totalRequests = 0;
-    this.capturedSince = (/* @__PURE__ */ new Date()).toISOString();
-  }
-};
-function extractServiceIdFromProxyAuth(headers) {
-  const auth = headers["proxy-authorization"];
-  if (!auth) return null;
-  const match = auth.match(/^Basic\s+(.+)$/i);
-  if (!match) return null;
+function serviceLogPath(fifonyDir, id) {
+  return join(fifonyDir, `service-${id}.log`);
+}
+function serviceLogGenerationPath(fifonyDir, id, generation) {
+  const base = serviceLogPath(fifonyDir, id);
+  return generation === 0 ? base : `${base}.${generation}`;
+}
+function rotateServiceLogs(fifonyDir, id) {
+  const base = serviceLogPath(fifonyDir, id);
   try {
-    const decoded = Buffer.from(match[1], "base64").toString("utf8");
-    const colon = decoded.indexOf(":");
-    return colon > 0 ? decoded.slice(0, colon) : decoded;
+    if (!existsSync(base) || statSync(base).size === 0) return;
   } catch {
-    return null;
+    return;
   }
-}
-function resolveTargetService(url, services) {
   try {
-    const parsed = new URL(url);
-    const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
-    const match = services.find((s) => s.port === port);
-    return match?.id ?? null;
+    if (existsSync(`${base}.2`)) rmSync(`${base}.2`);
   } catch {
-    return null;
   }
-}
-function buildProxyEnvVars(proxyPort, serviceId, dashboardPort, extraNoPorts = []) {
-  const proxyUrl = `http://${encodeURIComponent(serviceId)}:fifony@localhost:${proxyPort}`;
-  const noProxyList = [`localhost:${dashboardPort}`, ...extraNoPorts.map((p) => `localhost:${p}`)].join(",");
-  return {
-    HTTP_PROXY: proxyUrl,
-    http_proxy: proxyUrl,
-    NO_PROXY: noProxyList,
-    no_proxy: noProxyList
-  };
-}
-var entrySeq = 0;
-function buildTrafficEntry(method, url, requestSize, statusCode, responseSize, sourceServiceId, targetServiceId, startTime, error) {
-  let path;
   try {
-    path = new URL(url).pathname;
+    if (existsSync(`${base}.1`)) renameSync(`${base}.1`, `${base}.2`);
   } catch {
-    path = url;
   }
-  return {
-    id: `tr_${Date.now()}_${++entrySeq}`,
-    sourceServiceId,
-    targetServiceId,
-    method,
-    url,
-    path,
-    statusCode,
-    requestSize,
-    responseSize,
-    startedAt: new Date(startTime).toISOString(),
-    durationMs: Date.now() - startTime,
-    error
-  };
-}
-
-// src/persistence/plugins/traffic-proxy-server.ts
-var server = null;
-var proxy = null;
-var buffer = null;
-var graph = null;
-var boundPort = null;
-var onEntryCallback = null;
-var servicesAccessor = null;
-function setServicesAccessor(fn) {
-  servicesAccessor = fn;
-}
-async function startTrafficProxy(options = {}) {
-  if (server) {
-    logger.warn("Traffic proxy already running, skipping start");
-    return boundPort;
+  try {
+    renameSync(base, `${base}.1`);
+  } catch {
   }
-  const port = options.port ?? 0;
-  const bufferSize = options.bufferSize ?? 1e3;
-  buffer = new TrafficRingBuffer(bufferSize);
-  graph = new ServiceGraphAccumulator();
-  onEntryCallback = options.onEntry ?? null;
-  proxy = createHttpForwardProxy({
-    timeout: 3e4,
-    maxBodySize: 10 * 1024 * 1024
-  });
-  server = createServer((req, res) => {
-    const startTime = Date.now();
-    const method = req.method ?? "GET";
-    const url = req.url ?? "";
-    const sourceId = extractServiceIdFromProxyAuth(
-      req.headers
-    );
-    const services = servicesAccessor?.() ?? [];
-    const targetId = resolveTargetService(url, services);
-    const requestSize = Number(req.headers["content-length"] ?? 0);
-    res.on("finish", () => {
-      const entry = buildTrafficEntry(
-        method,
-        url,
-        requestSize,
-        res.statusCode,
-        Number(res.getHeader("content-length") ?? 0),
-        sourceId,
-        targetId,
-        startTime
-      );
-      buffer?.push(entry);
-      graph?.record(entry);
-      onEntryCallback?.(entry);
-    });
-    proxy.requestHandler(req, res);
-  });
-  return new Promise((resolve2, reject) => {
-    server.listen(port, "127.0.0.1", () => {
-      const addr = server.address();
-      boundPort = typeof addr === "object" && addr ? addr.port : port;
-      logger.info({ port: boundPort }, "Mesh traffic proxy started");
-      resolve2(boundPort);
-    });
-    server.on("error", (err) => {
-      logger.error({ err }, "Mesh traffic proxy failed to start");
-      reject(err);
-    });
-  });
-}
-async function stopTrafficProxy() {
-  if (!server) return;
-  return new Promise((resolve2) => {
-    server.close(() => {
-      logger.info("Mesh traffic proxy stopped");
-      server = null;
-      proxy = null;
-      boundPort = null;
-      resolve2();
-    });
-  });
-}
-function getTrafficProxyPort() {
-  return boundPort;
-}
-function isTrafficProxyRunning() {
-  return server !== null;
-}
-function getTrafficBuffer() {
-  return buffer;
-}
-function getServiceGraph() {
-  return graph;
-}
-function getTrafficProxyStats() {
-  return proxy?.stats ?? null;
-}
-
-// src/persistence/plugins/fsm-service.ts
-var STARTING_GRACE_MS = 3e3;
-var STOPPING_KILL_MS = 5e3;
-var SERVICE_WATCHER_INTERVAL_MS = 5e3;
-function pidPath(fifonyDir, id) {
-  return join(fifonyDir, `service-${id}.pid`);
-}
-function serviceLogPath(fifonyDir, id) {
-  return join(fifonyDir, `service-${id}.log`);
+  errorCountCache.delete(base);
+  errorCountCache.delete(`${base}.1`);
+  errorCountCache.delete(`${base}.2`);
 }
 var ERROR_PATTERN = /\b(ERROR|Exception|FATAL|FAIL)\b/gi;
 var errorCountCache = /* @__PURE__ */ new Map();
@@ -397,12 +176,16 @@ function spawnProcess(entry, targetRoot, fifonyDir, globalEnv) {
   const cwd = entry.cwd ? resolve(targetRoot, entry.cwd) : targetRoot;
   const log = serviceLogPath(fifonyDir, entry.id);
   let mergedGlobalEnv = globalEnv;
-  const proxyPort = getTrafficProxyPort();
+  const proxyPort = getMeshRuntimePortSnapshot();
   if (proxyPort) {
     const dashPort = Number(process.env.FIFONY_PORT ?? 4e3);
     mergedGlobalEnv = { ...globalEnv ?? {}, ...buildProxyEnvVars(proxyPort, entry.id, dashPort) };
   }
-  const command = buildServiceCommand(entry.command, mergedGlobalEnv, entry.env);
+  const enforcedEnv = entry.port ? {
+    PORT: String(entry.port)
+  } : {};
+  const command = buildServiceCommand(entry.command, mergedGlobalEnv, entry.env, enforcedEnv);
+  rotateServiceLogs(fifonyDir, entry.id);
   try {
     writeFileSync(log, "");
   } catch {
@@ -424,6 +207,65 @@ function spawnProcess(entry, targetRoot, fifonyDir, globalEnv) {
   }
   return { pid: child.pid, command };
 }
+function killProcessTree(pid) {
+  try {
+    const children = execSync(`pgrep -P ${pid} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    if (children) {
+      for (const childStr of children.split("\n")) {
+        const childPid = parseInt(childStr.trim(), 10);
+        if (!isNaN(childPid) && childPid > 0) {
+          killProcessTree(childPid);
+        }
+      }
+    }
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  } catch {
+  }
+}
+function killProcessesOnPort(port) {
+  try {
+    const pids = execSync(`lsof -ti tcp:${port} 2>/dev/null || true`, { encoding: "utf8" }).trim();
+    if (!pids) return;
+    for (const pidStr of pids.split("\n")) {
+      const pid = parseInt(pidStr.trim(), 10);
+      if (!isNaN(pid) && pid > 0) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    }
+    logger.debug({ port, pids }, "[ServiceFSM] Killed orphaned processes on port");
+  } catch {
+  }
+}
+function cleanupServiceProcesses(pid, port) {
+  if (pid && pid > 0) {
+    let allPorts = [];
+    try {
+      const lsofOut = execSync(`lsof -aPi tcp -sTCP:LISTEN -p ${pid} -Fn 2>/dev/null || true`, { encoding: "utf8" });
+      for (const line of lsofOut.split("\n")) {
+        if (line.startsWith("n")) {
+          const match = line.match(/:(\d+)$/);
+          if (match) allPorts.push(parseInt(match[1], 10));
+        }
+      }
+    } catch {
+    }
+    try {
+      process.kill(-pid, "SIGKILL");
+    } catch {
+    }
+    killProcessTree(pid);
+    for (const p of allPorts) {
+      killProcessesOnPort(p);
+    }
+  }
+  if (port) killProcessesOnPort(port);
+}
 function autoRestartBackoffMs(crashCount) {
   return Math.min(Math.pow(2, crashCount) * 1e3, 6e4);
 }
@@ -475,13 +317,12 @@ function getServiceStatus(entry, fifonyDir) {
 function getAllServiceStatuses(entries, fifonyDir) {
   return entries.map((e) => getServiceStatus(e, fifonyDir));
 }
-function readServiceLogTail(id, fifonyDir, bytes = 8192) {
-  const log = serviceLogPath(fifonyDir, id);
-  if (!existsSync(log)) return "";
+function readLogFileTail(filePath, bytes) {
+  if (!existsSync(filePath)) return "";
   try {
-    const size = statSync(log).size;
+    const size = statSync(filePath).size;
     const readSize = Math.min(size, bytes);
-    const fd = openSync(log, "r");
+    const fd = openSync(filePath, "r");
     const buf = Buffer.alloc(readSize);
     readSync(fd, buf, 0, readSize, Math.max(0, size - readSize));
     closeSync(fd);
@@ -490,12 +331,27 @@ function readServiceLogTail(id, fifonyDir, bytes = 8192) {
     return "";
   }
 }
+function readServiceLogTail(id, fifonyDir, bytes = 8192) {
+  return readLogFileTail(serviceLogPath(fifonyDir, id), bytes);
+}
+function readServiceLogGenerationTail(id, fifonyDir, generation, bytes = 16384) {
+  return readLogFileTail(serviceLogGenerationPath(fifonyDir, id, generation), bytes);
+}
+function listServiceLogGenerations(fifonyDir, id) {
+  const base = serviceLogPath(fifonyDir, id);
+  const generations = [];
+  if (existsSync(base)) generations.push(0);
+  if (existsSync(`${base}.1`)) generations.push(1);
+  if (existsSync(`${base}.2`)) generations.push(2);
+  return generations;
+}
 function reconcileServiceStates(entries, fifonyDir) {
   for (const entry of entries) {
     const info = readPidInfo(fifonyDir, entry.id);
     if (!info) continue;
     if (info.state === "stopped") continue;
     if (!isProcessAlive(info.pid)) {
+      cleanupServiceProcesses(info.pid, entry.port);
       const crashCount = (info.crashCount ?? 0) + 1;
       writePidInfo(fifonyDir, entry.id, {
         ...info,
@@ -503,7 +359,7 @@ function reconcileServiceStates(entries, fifonyDir) {
         crashCount,
         lastCrashAt: now()
       });
-      logger.info({ id: entry.id, crashCount }, "[Service] Boot: process dead \u2192 crashed");
+      logger.info({ id: entry.id, crashCount }, "[Service] Boot: process dead \u2192 crashed (port cleaned)");
     }
   }
 }
@@ -521,19 +377,69 @@ function setServiceResourceStateApi(api) {
   serviceResourceStateApi = api;
 }
 async function sendServiceEvent(entityId, event, context = {}) {
-  if (!serviceResourceStateApi) {
-    throw new Error("Service state machine not initialized");
+  if (!serviceRuntime) throw new Error("Service runtime not initialized");
+  const { fifonyDir, targetRoot, getEntries, getGlobalEnv, onTransition } = serviceRuntime;
+  const entry = (getEntries() ?? []).find((e) => e.id === entityId);
+  if (event === "START") {
+    const existing = readPidInfo(fifonyDir, entityId);
+    cleanupServiceProcesses(existing?.pid ?? null, entry?.port);
+    if (!entry) throw new Error(`Service entry not found: ${entityId}`);
+    const globalEnv = getGlobalEnv() ?? {};
+    const serviceVaulterEnv = serviceRuntime.getServiceEnv?.(entityId) ?? {};
+    const effectiveEntry = Object.keys(serviceVaulterEnv).length > 0 ? { ...entry, env: { ...serviceVaulterEnv, ...entry.env ?? {} } } : entry;
+    const spawned = spawnProcess(effectiveEntry, targetRoot, fifonyDir, globalEnv);
+    writePidInfo(fifonyDir, entityId, {
+      pid: spawned.pid,
+      command: spawned.command,
+      startedAt: now(),
+      state: "starting",
+      crashCount: 0
+    });
+    const transition = {
+      id: entityId,
+      from: "stopped",
+      to: "starting",
+      reason: "manual start",
+      pid: spawned.pid
+    };
+    onTransition?.(transition);
+    logger.info({ id: entityId, pid: spawned.pid }, "[ServiceFSM] START \u2192 starting");
+    return { pid: spawned.pid, state: "starting" };
   }
-  try {
-    await serviceResourceStateApi.send(entityId, event, context);
-  } catch (err) {
-    if (String(err).includes("not found") || String(err).includes("not initialized")) {
-      await serviceResourceStateApi.initialize(entityId, { state: "stopped" });
-      await serviceResourceStateApi.send(entityId, event, context);
-    } else {
-      throw err;
+  if (event === "STOP") {
+    const info = readPidInfo(fifonyDir, entityId);
+    if (!info || info.state === "stopped") return { state: "stopped" };
+    if (entry?.stopCommand) {
+      try {
+        const cwd = entry.cwd ? join(targetRoot, entry.cwd) : targetRoot;
+        execSync(entry.stopCommand, { cwd, stdio: "pipe", timeout: 15e3 });
+        logger.info({ id: entityId, stopCommand: entry.stopCommand }, "[ServiceFSM] stopCommand executed");
+      } catch (err) {
+        logger.warn({ err, id: entityId }, "[ServiceFSM] stopCommand failed, falling back to SIGTERM");
+        if (isProcessAlive(info.pid)) {
+          try {
+            process.kill(-info.pid, "SIGTERM");
+          } catch {
+          }
+        }
+      }
+    } else if (isProcessAlive(info.pid)) {
+      try {
+        process.kill(-info.pid, "SIGTERM");
+      } catch {
+      }
+      try {
+        process.kill(info.pid, "SIGTERM");
+      } catch {
+      }
     }
+    writePidInfo(fifonyDir, entityId, { ...info, state: "stopping", stoppingAt: now() });
+    const transition = { id: entityId, from: info.state, to: "stopping", reason: "manual stop", pid: info.pid };
+    onTransition?.(transition);
+    logger.info({ id: entityId, pid: info.pid }, "[ServiceFSM] STOP \u2192 stopping");
+    return { state: "stopping" };
   }
+  throw new Error(`Unknown service event: ${event}`);
 }
 function resolveServiceEntry(entityId) {
   if (!serviceRuntime) return null;
@@ -552,10 +458,13 @@ var serviceStateMachineConfig = {
       stateField: "state",
       initialState: "stopped",
       autoCleanup: false,
+      hooks: {
+        afterTransition: "onServiceTransition"
+      },
       states: {
         stopped: {
           on: { START: "starting" },
-          entry: "onEnterStopped"
+          afterEnter: "onEnterStopped"
         },
         starting: {
           on: {
@@ -563,7 +472,7 @@ var serviceStateMachineConfig = {
             PROCESS_DIED: "crashed",
             STOP: "stopping"
           },
-          entry: "spawnService",
+          afterEnter: "spawnService",
           triggers: [{
             type: "function",
             interval: TRIGGER_INTERVAL_MS,
@@ -592,7 +501,7 @@ var serviceStateMachineConfig = {
             PROCESS_DIED: "crashed",
             STOP: "stopping"
           },
-          entry: "onEnterRunning",
+          afterEnter: "onEnterRunning",
           triggers: [{
             type: "function",
             interval: TRIGGER_INTERVAL_MS,
@@ -610,7 +519,7 @@ var serviceStateMachineConfig = {
             PROCESS_EXITED: "stopped",
             KILL_TIMEOUT: "stopped"
           },
-          entry: "sendSigterm",
+          afterEnter: "sendSigterm",
           triggers: [{
             type: "function",
             interval: TRIGGER_INTERVAL_MS,
@@ -640,7 +549,7 @@ var serviceStateMachineConfig = {
             START: "starting",
             STOP: "stopping"
           },
-          entry: "recordCrash",
+          afterEnter: "recordCrash",
           triggers: [{
             type: "function",
             interval: TRIGGER_INTERVAL_MS,
@@ -665,6 +574,30 @@ var serviceStateMachineConfig = {
   // ── Actions ────────────────────────────────────────────────────────────────
   // (context, event, machine) — context is the payload from send()
   actions: {
+    // ── Machine-level afterTransition hook — consolidates WS broadcast + log broadcaster ──
+    onServiceTransition: async (context, _event, machine) => {
+      if (!serviceRuntime) return;
+      const { fifonyDir } = serviceRuntime;
+      const info = readPidInfo(fifonyDir, machine.entityId);
+      const currentState = info?.state ?? "stopped";
+      const pid = info?.pid ?? null;
+      logger.info({ id: machine.entityId, event: _event, state: currentState }, "[ServiceFSM] Transition");
+      serviceRuntime.onTransition?.({
+        id: machine.entityId,
+        from: context.previousState ?? "none",
+        to: currentState,
+        pid,
+        reason: _event
+      });
+      if (currentState === "starting") {
+        const { startServiceLogBroadcasting, stopServiceLogBroadcasting } = await import("./service-log-broadcaster-JIUP2L3D.js");
+        stopServiceLogBroadcasting(machine.entityId);
+        startServiceLogBroadcasting(machine.entityId, fifonyDir);
+      } else if (currentState === "stopped" || currentState === "crashed") {
+        const { stopServiceLogBroadcasting } = await import("./service-log-broadcaster-JIUP2L3D.js");
+        stopServiceLogBroadcasting(machine.entityId);
+      }
+    },
     spawnService: async (context, _event, machine) => {
       if (!serviceRuntime) {
         logger.warn({ entityId: machine.entityId }, "[ServiceFSM] spawnService called but runtime not set");
@@ -677,18 +610,11 @@ var serviceStateMachineConfig = {
       }
       const { fifonyDir, targetRoot } = serviceRuntime;
       const globalEnv = serviceRuntime.getGlobalEnv();
+      const serviceVaulterEnv = serviceRuntime.getServiceEnv?.(entry.id) ?? {};
+      const effectiveEntry = Object.keys(serviceVaulterEnv).length > 0 ? { ...entry, env: { ...serviceVaulterEnv, ...entry.env ?? {} } } : entry;
       const existing = readPidInfo(fifonyDir, entry.id);
-      if (existing && isProcessAlive(existing.pid)) {
-        try {
-          process.kill(-existing.pid, "SIGKILL");
-        } catch {
-        }
-        try {
-          process.kill(existing.pid, "SIGKILL");
-        } catch {
-        }
-      }
-      const spawned = spawnProcess(entry, targetRoot, fifonyDir, globalEnv);
+      cleanupServiceProcesses(existing?.pid ?? null, entry.port);
+      const spawned = spawnProcess(effectiveEntry, targetRoot, fifonyDir, globalEnv);
       const isAutoRestart = _event === "AUTO_RESTART";
       const prevCrashCount = existing?.crashCount ?? 0;
       writePidInfo(fifonyDir, entry.id, {
@@ -702,20 +628,28 @@ var serviceStateMachineConfig = {
         { id: entry.id, pid: spawned.pid, event: _event },
         `[ServiceFSM] spawnService \u2192 starting (${isAutoRestart ? "auto-restart" : "manual"})`
       );
-      serviceRuntime.onTransition?.({
-        id: entry.id,
-        from: context.previousState ?? "none",
-        to: "starting",
-        pid: spawned.pid,
-        reason: isAutoRestart ? `auto-restart (crash #${prevCrashCount})` : "manual start"
-      });
     },
     sendSigterm: async (context, _event, machine) => {
       if (!serviceRuntime) return;
-      const { fifonyDir } = serviceRuntime;
+      const { fifonyDir, targetRoot } = serviceRuntime;
+      const entry = resolveServiceEntry(machine.entityId);
       const info = readPidInfo(fifonyDir, machine.entityId);
       if (!info) return;
-      if (isProcessAlive(info.pid)) {
+      if (entry?.stopCommand) {
+        try {
+          const cwd = entry.cwd ? join(targetRoot, entry.cwd) : targetRoot;
+          execSync(entry.stopCommand, { cwd, stdio: "pipe", timeout: 15e3 });
+          logger.info({ id: machine.entityId, stopCommand: entry.stopCommand }, "[ServiceFSM] stopCommand executed");
+        } catch (err) {
+          logger.warn({ err, id: machine.entityId }, "[ServiceFSM] stopCommand failed, falling back to SIGTERM");
+          if (isProcessAlive(info.pid)) {
+            try {
+              process.kill(-info.pid, "SIGTERM");
+            } catch {
+            }
+          }
+        }
+      } else if (isProcessAlive(info.pid)) {
         try {
           process.kill(-info.pid, "SIGTERM");
         } catch {
@@ -726,14 +660,7 @@ var serviceStateMachineConfig = {
         state: "stopping",
         stoppingAt: now()
       });
-      logger.info({ id: machine.entityId, pid: info.pid }, "[ServiceFSM] sendSigterm \u2192 stopping");
-      serviceRuntime.onTransition?.({
-        id: machine.entityId,
-        from: context.previousState ?? "running",
-        to: "stopping",
-        pid: info.pid,
-        reason: "manual stop"
-      });
+      logger.info({ id: machine.entityId, pid: info.pid, hasStopCommand: !!entry?.stopCommand }, "[ServiceFSM] sendSigterm \u2192 stopping");
     },
     recordCrash: async (context, _event, machine) => {
       if (!serviceRuntime) return;
@@ -756,13 +683,6 @@ var serviceStateMachineConfig = {
         { id: machine.entityId, crashCount, nextRetryAt },
         "[ServiceFSM] recordCrash \u2192 crashed"
       );
-      serviceRuntime.onTransition?.({
-        id: machine.entityId,
-        from: context.previousState ?? "running",
-        to: "crashed",
-        pid: null,
-        reason: `process died (crash #${crashCount})`
-      });
     },
     onEnterStopped: async (context, _event, machine) => {
       if (!serviceRuntime) return;
@@ -781,15 +701,11 @@ var serviceStateMachineConfig = {
         }
         logger.info({ id: machine.entityId }, "[ServiceFSM] onEnterStopped \u2014 SIGKILL after stop timeout");
       }
+      const entry = resolveServiceEntry(machine.entityId);
+      const info2 = readPidInfo(fifonyDir, machine.entityId);
+      cleanupServiceProcesses(info2?.pid ?? null, entry?.port);
       removePidInfo(fifonyDir, machine.entityId);
       logger.info({ id: machine.entityId, event: _event }, "[ServiceFSM] onEnterStopped \u2014 pid file removed");
-      serviceRuntime.onTransition?.({
-        id: machine.entityId,
-        from: context.previousState ?? "stopping",
-        to: "stopped",
-        pid: null,
-        reason: _event === "KILL_TIMEOUT" ? "SIGKILL after stop timeout" : "process exited"
-      });
     },
     onEnterRunning: async (context, _event, machine) => {
       if (!serviceRuntime) return;
@@ -799,13 +715,6 @@ var serviceStateMachineConfig = {
         writePidInfo(fifonyDir, machine.entityId, { ...info, state: "running" });
       }
       logger.info({ id: machine.entityId, pid: info?.pid }, "[ServiceFSM] onEnterRunning \u2014 grace period elapsed");
-      serviceRuntime.onTransition?.({
-        id: machine.entityId,
-        from: "starting",
-        to: "running",
-        pid: info?.pid ?? null,
-        reason: "startup grace period elapsed"
-      });
     }
   },
   // ── Guards ─────────────────────────────────────────────────────────────────
@@ -835,19 +744,14 @@ var serviceStateMachineConfig = {
 
 export {
   normalizeServiceEnvironment,
-  setServicesAccessor,
-  startTrafficProxy,
-  stopTrafficProxy,
-  getTrafficProxyPort,
-  isTrafficProxyRunning,
-  getTrafficBuffer,
-  getServiceGraph,
-  getTrafficProxyStats,
   SERVICE_WATCHER_INTERVAL_MS,
   serviceLogPath,
+  serviceLogGenerationPath,
   getServiceStatus,
   getAllServiceStatuses,
   readServiceLogTail,
+  readServiceLogGenerationTail,
+  listServiceLogGenerations,
   reconcileServiceStates,
   SERVICE_STATE_MACHINE_ID,
   setServiceRuntime,
@@ -856,4 +760,4 @@ export {
   sendServiceEvent,
   serviceStateMachineConfig
 };
-//# sourceMappingURL=chunk-AAVROEQC.js.map
+//# sourceMappingURL=chunk-UR7T7IA6.js.map