@solongate/proxy 0.81.49 → 0.81.51

package/dist/logs-server-daemon.d.ts

@@ -0,0 +1,19 @@
+export declare const LOGS_SERVER_PORT = 8788;
+export interface LogsServerStatus {
+    desired: 'on' | 'off';
+    running: boolean;
+    pid?: number;
+    port: number;
+}
+export declare function logsServerStatus(): LogsServerStatus;
+/** Called from runLogsServer when a (foreground or daemon) server starts. */
+export declare function recordLogsServerStarted(port: number): void;
+/** Spawn the detached daemon (idempotent — no-op when already running). */
+export declare function startLogsServerDaemon(): LogsServerStatus;
+/** Explicit disable — the ONLY thing that flips desired to 'off'. */
+export declare function stopLogsServerDaemon(): LogsServerStatus;
+/**
+ * Resurrect the daemon when it SHOULD be running but isn't (machine reboot,
+ * Ctrl+C on a foreground run, crash). Called from every human CLI startup.
+ */
+export declare function ensureLogsServerDaemon(): void;

package/dist/logs-server.js

@@ -1,8 +1,118 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/logs-server-daemon.ts
+var logs_server_daemon_exports = {};
+__export(logs_server_daemon_exports, {
+  LOGS_SERVER_PORT: () => LOGS_SERVER_PORT,
+  ensureLogsServerDaemon: () => ensureLogsServerDaemon,
+  logsServerStatus: () => logsServerStatus,
+  recordLogsServerStarted: () => recordLogsServerStarted,
+  startLogsServerDaemon: () => startLogsServerDaemon,
+  stopLogsServerDaemon: () => stopLogsServerDaemon
+});
+import { spawn } from "child_process";
+import { mkdirSync, openSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+function readState() {
+  try {
+    const s = JSON.parse(readFileSync(STATE_FILE, "utf-8"));
+    return s && typeof s === "object" ? s : {};
+  } catch {
+    return {};
+  }
+}
+function writeState(s) {
+  try {
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(STATE_FILE, JSON.stringify(s));
+  } catch {
+  }
+}
+function pidAlive(pid) {
+  if (!pid || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function logsServerStatus() {
+  const s = readState();
+  const running = pidAlive(s.pid);
+  return { desired: s.desired === "on" ? "on" : "off", running, pid: running ? s.pid : void 0, port: s.port || LOGS_SERVER_PORT };
+}
+function recordLogsServerStarted(port) {
+  writeState({ desired: "on", pid: process.pid, port, startedAt: Date.now() });
+}
+function startLogsServerDaemon() {
+  const cur = logsServerStatus();
+  if (cur.running) {
+    writeState({ ...readState(), desired: "on" });
+    return { ...cur, desired: "on" };
+  }
+  try {
+    mkdirSync(DIR, { recursive: true });
+    const log = openSync(LOG_FILE, "a");
+    const cli = join(dirname(fileURLToPath(import.meta.url)), "index.js");
+    const p = spawn(process.execPath, [cli, "logs-server"], {
+      detached: true,
+      stdio: ["ignore", log, log],
+      windowsHide: true
+    });
+    p.on("error", () => {
+    });
+    p.unref();
+    writeState({ desired: "on", pid: p.pid, port: LOGS_SERVER_PORT, startedAt: Date.now() });
+    return { desired: "on", running: true, pid: p.pid, port: LOGS_SERVER_PORT };
+  } catch {
+    return { ...cur, desired: "on", running: false };
+  }
+}
+function stopLogsServerDaemon() {
+  const s = readState();
+  if (pidAlive(s.pid)) {
+    try {
+      process.kill(s.pid);
+    } catch {
+    }
+  }
+  writeState({ desired: "off", port: s.port });
+  return { desired: "off", running: false, port: s.port || LOGS_SERVER_PORT };
+}
+function ensureLogsServerDaemon() {
+  try {
+    const s = logsServerStatus();
+    if (s.desired === "on" && !s.running) startLogsServerDaemon();
+  } catch {
+  }
+}
+var DIR, STATE_FILE, LOG_FILE, LOGS_SERVER_PORT;
+var init_logs_server_daemon = __esm({
+  "src/logs-server-daemon.ts"() {
+    "use strict";
+    DIR = join(homedir(), ".solongate");
+    STATE_FILE = join(DIR, ".logs-server.json");
+    LOG_FILE = join(DIR, "logs-server.log");
+    LOGS_SERVER_PORT = 8788;
+  }
+});
+
 // src/logs-server.ts
 import { createServer } from "http";
-import { readFileSync, statSync } from "fs";
-import { resolve, join, isAbsolute } from "path";
-import { homedir } from "os";
+import { readFileSync as readFileSync2, statSync } from "fs";
+import { resolve, join as join2, isAbsolute } from "path";
+import { homedir as homedir2 } from "os";
 import { readdirSync } from "fs";
 var LOG_FILENAME = "solongate-audit.jsonl";
 var DEFAULT_PORT = 8788;
@@ -21,15 +131,15 @@ function resolveLocalLogDir(rawPath) {
   const dir = String(rawPath || "").trim().replace(/[\\/]+$/, "");
   if (!dir) return null;
   if (isAbsolute(dir)) return dir;
-  return resolve(homedir(), ".solongate", "local-logs");
+  return resolve(homedir2(), ".solongate", "local-logs");
 }
 async function findLogDir() {
-  const base = resolve(homedir(), ".solongate");
+  const base = resolve(homedir2(), ".solongate");
   try {
     const files = readdirSync(base).filter((f) => f.startsWith(".policy-cache-") && f.endsWith(".json"));
     for (const f of files) {
       try {
-        const c = JSON.parse(readFileSync(join(base, f), "utf-8"));
+        const c = JSON.parse(readFileSync2(join2(base, f), "utf-8"));
         const p = c?.security?.localLogs?.path;
         if (typeof p === "string" && p.trim()) return { dir: resolveLocalLogDir(p), configured: p };
       } catch {
@@ -38,7 +148,7 @@ async function findLogDir() {
   } catch {
   }
   try {
-    const cfgRaw = readFileSync(join(base, "cloud-guard.json"), "utf-8");
+    const cfgRaw = readFileSync2(join2(base, "cloud-guard.json"), "utf-8");
     const { apiKey, apiUrl } = JSON.parse(cfgRaw);
     if (apiKey) {
       const url = `${apiUrl || "https://api.solongate.com"}/api/v1/policies/active`;
@@ -67,7 +177,7 @@ function setCors(req, res) {
 }
 function fileInfo(dir) {
   if (!dir) return { file: null, exists: false, size: 0, mtimeMs: 0 };
-  const file = join(dir, LOG_FILENAME);
+  const file = join2(dir, LOG_FILENAME);
   try {
     const st = statSync(file);
     return { file, exists: true, size: st.size, mtimeMs: st.mtimeMs };
@@ -128,7 +238,7 @@ async function runLogsServer() {
         return;
       }
       try {
-        const text = readFileSync(info.file, "utf-8");
+        const text = readFileSync2(info.file, "utf-8");
         res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8", "Last-Modified": lastMod, "X-Solongate-Exists": "1" });
         res.end(text);
       } catch {
@@ -141,6 +251,8 @@ async function runLogsServer() {
     res.end("not found");
   });
   server.listen(port, "127.0.0.1", async () => {
+    const { recordLogsServerStarted: recordLogsServerStarted2 } = await Promise.resolve().then(() => (init_logs_server_daemon(), logs_server_daemon_exports));
+    recordLogsServerStarted2(port);
     const { dir, configured } = await findLogDir();
     process.stdout.write(`[SolonGate] Local logs agent listening on http://127.0.0.1:${port}
 `);