fifony 0.1.43 → 0.1.47

package/dist/chunk-AAVROEQC.js

@@ -0,0 +1,859 @@
+import {
+  S3DB_SERVICES_RESOURCE,
+  now
+} from "./chunk-VM5QAYP5.js";
+import {
+  logger
+} from "./chunk-PXTIWKLQ.js";
+import {
+  isProcessAlive
+} from "./chunk-3NE23NYW.js";
+
+// src/persistence/plugins/fsm-service.ts
+import {
+  closeSync,
+  existsSync,
+  openSync,
+  readFileSync,
+  readSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "fs";
+import { join, resolve } from "path";
+import { spawn } from "child_process";
+
+// src/domains/service-env.ts
+var ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function isValidServiceEnvKey(key) {
+  return ENV_KEY_PATTERN.test(key);
+}
+function normalizeServiceEnvironment(value) {
+  if (value === void 0 || value === null) {
+    return { env: {}, errors: [] };
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return { env: {}, errors: ["Environment must be an object map of KEY -> value."] };
+  }
+  const env = {};
+  const errors = [];
+  for (const [rawKey, rawValue] of Object.entries(value)) {
+    const key = rawKey.trim();
+    if (!key) continue;
+    if (!isValidServiceEnvKey(key)) {
+      errors.push(`Invalid environment variable name: ${rawKey}`);
+      continue;
+    }
+    env[key] = rawValue === void 0 || rawValue === null ? "" : String(rawValue);
+  }
+  return { env, errors };
+}
+function mergeServiceEnvironment(globalEnv, serviceEnv) {
+  return {
+    ...globalEnv ?? {},
+    ...serviceEnv ?? {}
+  };
+}
+function shellQuoteEnvValue(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function buildServiceCommand(command, globalEnv, serviceEnv) {
+  const baseCommand = command.trim();
+  if (!baseCommand) return "";
+  const env = mergeServiceEnvironment(globalEnv, serviceEnv);
+  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}`;
+}
+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;
+  try {
+    const decoded = Buffer.from(match[1], "base64").toString("utf8");
+    const colon = decoded.indexOf(":");
+    return colon > 0 ? decoded.slice(0, colon) : decoded;
+  } catch {
+    return null;
+  }
+}
+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;
+  } 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;
+  } 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;
+  }
+  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`);
+}
+var ERROR_PATTERN = /\b(ERROR|Exception|FATAL|FAIL)\b/gi;
+var errorCountCache = /* @__PURE__ */ new Map();
+function countLogErrors(logFile) {
+  if (!existsSync(logFile)) return 0;
+  try {
+    const size = statSync(logFile).size;
+    if (size === 0) {
+      errorCountCache.delete(logFile);
+      return 0;
+    }
+    const cached = errorCountCache.get(logFile);
+    if (cached && size < cached.size) {
+      errorCountCache.delete(logFile);
+      return countLogErrors(logFile);
+    }
+    if (cached && size === cached.size) return cached.count;
+    const readFrom = cached ? cached.size : Math.max(0, size - 8192);
+    const readSize = size - readFrom;
+    if (readSize <= 0) return cached?.count ?? 0;
+    const fd = openSync(logFile, "r");
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, readFrom);
+    closeSync(fd);
+    const matches = buf.toString("utf8").match(ERROR_PATTERN);
+    const delta = matches ? matches.length : 0;
+    const total = (cached?.count ?? 0) + delta;
+    errorCountCache.set(logFile, { size, count: total });
+    return total;
+  } catch {
+    return 0;
+  }
+}
+function readPidInfo(fifonyDir, id) {
+  const path = pidPath(fifonyDir, id);
+  if (!existsSync(path)) return null;
+  try {
+    const data = JSON.parse(readFileSync(path, "utf8"));
+    if (!data?.pid || typeof data.pid !== "number") return null;
+    if (!data.state) {
+      data.state = isProcessAlive(data.pid) ? "running" : "crashed";
+      data.crashCount ??= 0;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function writePidInfo(fifonyDir, id, info) {
+  writeFileSync(pidPath(fifonyDir, id), JSON.stringify(info));
+}
+function removePidInfo(fifonyDir, id) {
+  try {
+    rmSync(pidPath(fifonyDir, id), { force: true });
+  } catch {
+  }
+}
+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();
+  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);
+  try {
+    writeFileSync(log, "");
+  } catch {
+  }
+  const logFd = openSync(log, "a");
+  const child = spawn(command, [], {
+    shell: true,
+    cwd,
+    detached: true,
+    stdio: ["ignore", logFd, logFd]
+  });
+  try {
+    closeSync(logFd);
+  } catch {
+  }
+  child.unref();
+  if (child.pid === void 0) {
+    throw new Error(`Failed to spawn service process: ${command}`);
+  }
+  return { pid: child.pid, command };
+}
+function autoRestartBackoffMs(crashCount) {
+  return Math.min(Math.pow(2, crashCount) * 1e3, 6e4);
+}
+function getServiceStatus(entry, fifonyDir) {
+  const info = readPidInfo(fifonyDir, entry.id);
+  const alive = info !== null && isProcessAlive(info.pid);
+  let state;
+  if (!info) {
+    state = "stopped";
+  } else if (info.state === "stopping") {
+    state = alive ? "stopping" : "stopped";
+  } else if (info.state === "starting" || info.state === "running") {
+    state = alive ? info.state : "crashed";
+  } else {
+    state = info.state;
+  }
+  const logFile = serviceLogPath(fifonyDir, entry.id);
+  let logSize = 0;
+  if (existsSync(logFile)) {
+    try {
+      logSize = statSync(logFile).size;
+    } catch {
+    }
+  }
+  const startedAt = info?.startedAt ?? null;
+  const running = state === "starting" || state === "running";
+  const uptime = startedAt && running ? Date.now() - Date.parse(startedAt) : 0;
+  return {
+    id: entry.id,
+    name: entry.name,
+    command: entry.command,
+    cwd: entry.cwd,
+    env: entry.env,
+    autoStart: entry.autoStart,
+    autoRestart: entry.autoRestart,
+    maxCrashes: entry.maxCrashes,
+    port: entry.port,
+    state,
+    running,
+    pid: alive ? info?.pid ?? null : null,
+    startedAt,
+    uptime: Number.isFinite(uptime) ? uptime : 0,
+    logSize,
+    crashCount: info?.crashCount ?? 0,
+    errorCount: countLogErrors(logFile),
+    nextRetryAt: info?.nextRetryAt
+  };
+}
+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 "";
+  try {
+    const size = statSync(log).size;
+    const readSize = Math.min(size, bytes);
+    const fd = openSync(log, "r");
+    const buf = Buffer.alloc(readSize);
+    readSync(fd, buf, 0, readSize, Math.max(0, size - readSize));
+    closeSync(fd);
+    return buf.toString("utf8");
+  } catch {
+    return "";
+  }
+}
+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)) {
+      const crashCount = (info.crashCount ?? 0) + 1;
+      writePidInfo(fifonyDir, entry.id, {
+        ...info,
+        state: "crashed",
+        crashCount,
+        lastCrashAt: now()
+      });
+      logger.info({ id: entry.id, crashCount }, "[Service] Boot: process dead \u2192 crashed");
+    }
+  }
+}
+var SERVICE_STATE_MACHINE_ID = "service-lifecycle";
+var TRIGGER_INTERVAL_MS = SERVICE_WATCHER_INTERVAL_MS;
+var serviceRuntime = null;
+function setServiceRuntime(ctx) {
+  serviceRuntime = ctx;
+}
+function getServiceRuntime() {
+  return serviceRuntime;
+}
+var serviceResourceStateApi = null;
+function setServiceResourceStateApi(api) {
+  serviceResourceStateApi = api;
+}
+async function sendServiceEvent(entityId, event, context = {}) {
+  if (!serviceResourceStateApi) {
+    throw new Error("Service state machine not initialized");
+  }
+  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;
+    }
+  }
+}
+function resolveServiceEntry(entityId) {
+  if (!serviceRuntime) return null;
+  return (serviceRuntime.getEntries() ?? []).find((e) => e.id === entityId) ?? null;
+}
+var serviceStateMachineConfig = {
+  persistTransitions: true,
+  workerId: `fifony-svc-${process.pid}`,
+  lockTimeout: 5e3,
+  lockTTL: 30,
+  enableFunctionTriggers: true,
+  triggerCheckInterval: TRIGGER_INTERVAL_MS,
+  stateMachines: {
+    [SERVICE_STATE_MACHINE_ID]: {
+      resource: S3DB_SERVICES_RESOURCE,
+      stateField: "state",
+      initialState: "stopped",
+      autoCleanup: false,
+      states: {
+        stopped: {
+          on: { START: "starting" },
+          entry: "onEnterStopped"
+        },
+        starting: {
+          on: {
+            GRACE_ELAPSED: "running",
+            PROCESS_DIED: "crashed",
+            STOP: "stopping"
+          },
+          entry: "spawnService",
+          triggers: [{
+            type: "function",
+            interval: TRIGGER_INTERVAL_MS,
+            condition: async (context, entityId) => {
+              if (!serviceRuntime) return false;
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info) return false;
+              const alive = isProcessAlive(info.pid);
+              if (!alive) return true;
+              const ageMs = Date.now() - Date.parse(info.startedAt);
+              return ageMs >= STARTING_GRACE_MS;
+            },
+            sendEvent: "GRACE_ELAPSED",
+            // default event; overridden by eventName resolver below
+            eventName: (context) => {
+              const entityId = context.entityId ?? context.id ?? "";
+              if (!serviceRuntime || !entityId) return "PROCESS_DIED";
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info || !isProcessAlive(info.pid)) return "PROCESS_DIED";
+              return "GRACE_ELAPSED";
+            }
+          }]
+        },
+        running: {
+          on: {
+            PROCESS_DIED: "crashed",
+            STOP: "stopping"
+          },
+          entry: "onEnterRunning",
+          triggers: [{
+            type: "function",
+            interval: TRIGGER_INTERVAL_MS,
+            condition: async (context, entityId) => {
+              if (!serviceRuntime) return false;
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info) return true;
+              return !isProcessAlive(info.pid);
+            },
+            sendEvent: "PROCESS_DIED"
+          }]
+        },
+        stopping: {
+          on: {
+            PROCESS_EXITED: "stopped",
+            KILL_TIMEOUT: "stopped"
+          },
+          entry: "sendSigterm",
+          triggers: [{
+            type: "function",
+            interval: TRIGGER_INTERVAL_MS,
+            condition: async (context, entityId) => {
+              if (!serviceRuntime) return false;
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info) return true;
+              const alive = isProcessAlive(info.pid);
+              if (!alive) return true;
+              const stoppingAgeMs = info.stoppingAt ? Date.now() - Date.parse(info.stoppingAt) : STOPPING_KILL_MS + 1;
+              return stoppingAgeMs >= STOPPING_KILL_MS;
+            },
+            sendEvent: "PROCESS_EXITED",
+            // default
+            eventName: (context) => {
+              const entityId = context.entityId ?? context.id ?? "";
+              if (!serviceRuntime || !entityId) return "PROCESS_EXITED";
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info || !isProcessAlive(info.pid)) return "PROCESS_EXITED";
+              return "KILL_TIMEOUT";
+            }
+          }]
+        },
+        crashed: {
+          on: {
+            AUTO_RESTART: "starting",
+            START: "starting",
+            STOP: "stopping"
+          },
+          entry: "recordCrash",
+          triggers: [{
+            type: "function",
+            interval: TRIGGER_INTERVAL_MS,
+            condition: async (context, entityId) => {
+              if (!serviceRuntime) return false;
+              const entry = resolveServiceEntry(entityId);
+              if (!entry) return false;
+              const info = readPidInfo(serviceRuntime.fifonyDir, entityId);
+              if (!info) return false;
+              const autoRestart = entry.autoRestart ?? false;
+              const maxCrashes = entry.maxCrashes ?? 5;
+              if (!autoRestart || (info.crashCount ?? 0) >= maxCrashes) return false;
+              const nextRetryMs = info.nextRetryAt ? Date.parse(info.nextRetryAt) : 0;
+              return Date.now() >= nextRetryMs;
+            },
+            sendEvent: "AUTO_RESTART"
+          }]
+        }
+      }
+    }
+  },
+  // ── Actions ────────────────────────────────────────────────────────────────
+  // (context, event, machine) — context is the payload from send()
+  actions: {
+    spawnService: async (context, _event, machine) => {
+      if (!serviceRuntime) {
+        logger.warn({ entityId: machine.entityId }, "[ServiceFSM] spawnService called but runtime not set");
+        return;
+      }
+      const entry = resolveServiceEntry(machine.entityId);
+      if (!entry) {
+        logger.warn({ entityId: machine.entityId }, "[ServiceFSM] spawnService \u2014 entry not found");
+        return;
+      }
+      const { fifonyDir, targetRoot } = serviceRuntime;
+      const globalEnv = serviceRuntime.getGlobalEnv();
+      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);
+      const isAutoRestart = _event === "AUTO_RESTART";
+      const prevCrashCount = existing?.crashCount ?? 0;
+      writePidInfo(fifonyDir, entry.id, {
+        pid: spawned.pid,
+        command: spawned.command,
+        startedAt: now(),
+        state: "starting",
+        crashCount: isAutoRestart ? prevCrashCount : 0
+      });
+      logger.info(
+        { 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 info = readPidInfo(fifonyDir, machine.entityId);
+      if (!info) return;
+      if (isProcessAlive(info.pid)) {
+        try {
+          process.kill(-info.pid, "SIGTERM");
+        } catch {
+        }
+      }
+      writePidInfo(fifonyDir, machine.entityId, {
+        ...info,
+        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"
+      });
+    },
+    recordCrash: async (context, _event, machine) => {
+      if (!serviceRuntime) return;
+      const { fifonyDir } = serviceRuntime;
+      const entry = resolveServiceEntry(machine.entityId);
+      const info = readPidInfo(fifonyDir, machine.entityId);
+      if (!info) return;
+      const crashCount = (info.crashCount ?? 0) + 1;
+      const maxCrashes = entry?.maxCrashes ?? 5;
+      const autoRestart = entry?.autoRestart ?? false;
+      const nextRetryAt = autoRestart && crashCount < maxCrashes ? new Date(Date.now() + autoRestartBackoffMs(crashCount)).toISOString() : void 0;
+      writePidInfo(fifonyDir, machine.entityId, {
+        ...info,
+        state: "crashed",
+        crashCount,
+        lastCrashAt: now(),
+        nextRetryAt
+      });
+      logger.warn(
+        { 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;
+      const { fifonyDir } = serviceRuntime;
+      if (_event === "KILL_TIMEOUT") {
+        const info = readPidInfo(fifonyDir, machine.entityId);
+        if (info && isProcessAlive(info.pid)) {
+          try {
+            process.kill(-info.pid, "SIGKILL");
+          } catch {
+          }
+          try {
+            process.kill(info.pid, "SIGKILL");
+          } catch {
+          }
+        }
+        logger.info({ id: machine.entityId }, "[ServiceFSM] onEnterStopped \u2014 SIGKILL after stop timeout");
+      }
+      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;
+      const { fifonyDir } = serviceRuntime;
+      const info = readPidInfo(fifonyDir, machine.entityId);
+      if (info) {
+        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 ─────────────────────────────────────────────────────────────────
+  guards: {
+    graceElapsed: async (context, _event, machine) => {
+      if (!serviceRuntime) return false;
+      const info = readPidInfo(serviceRuntime.fifonyDir, machine.entityId);
+      if (!info) return false;
+      if (!isProcessAlive(info.pid)) return false;
+      const ageMs = Date.now() - Date.parse(info.startedAt);
+      return ageMs >= STARTING_GRACE_MS;
+    },
+    canAutoRestart: async (context, _event, machine) => {
+      if (!serviceRuntime) return false;
+      const entry = resolveServiceEntry(machine.entityId);
+      if (!entry) return false;
+      const info = readPidInfo(serviceRuntime.fifonyDir, machine.entityId);
+      if (!info) return false;
+      const autoRestart = entry.autoRestart ?? false;
+      const maxCrashes = entry.maxCrashes ?? 5;
+      if (!autoRestart || (info.crashCount ?? 0) >= maxCrashes) return false;
+      const nextRetryMs = info.nextRetryAt ? Date.parse(info.nextRetryAt) : 0;
+      return Date.now() >= nextRetryMs;
+    }
+  }
+};
+
+export {
+  normalizeServiceEnvironment,
+  setServicesAccessor,
+  startTrafficProxy,
+  stopTrafficProxy,
+  getTrafficProxyPort,
+  isTrafficProxyRunning,
+  getTrafficBuffer,
+  getServiceGraph,
+  getTrafficProxyStats,
+  SERVICE_WATCHER_INTERVAL_MS,
+  serviceLogPath,
+  getServiceStatus,
+  getAllServiceStatuses,
+  readServiceLogTail,
+  reconcileServiceStates,
+  SERVICE_STATE_MACHINE_ID,
+  setServiceRuntime,
+  getServiceRuntime,
+  setServiceResourceStateApi,
+  sendServiceEvent,
+  serviceStateMachineConfig
+};
+//# sourceMappingURL=chunk-AAVROEQC.js.map