@solongate/proxy 0.81.50 → 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}
 `);

package/dist/tui/index.js

@@ -5,9 +5,9 @@ var __export = (target, all) => {
 };
 
 // src/tui/index.tsx
-import { appendFileSync, mkdirSync as mkdirSync5 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join7 } from "path";
+import { appendFileSync, mkdirSync as mkdirSync6 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join8 } from "path";
 import { render } from "ink";
 
 // src/tui/App.tsx
@@ -3091,6 +3091,83 @@ function Detail({ label, value, color }) {
 import { Box as Box7, Text as Text7, useInput as useInput6 } from "ink";
 import TextInput5 from "ink-text-input";
 import { useEffect as useEffect6, useRef as useRef3, useState as useState7 } from "react";
+
+// src/logs-server-daemon.ts
+import { spawn as spawn3 } from "child_process";
+import { mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { dirname, join as join6 } from "path";
+import { fileURLToPath } from "url";
+var DIR = join6(homedir6(), ".solongate");
+var STATE_FILE = join6(DIR, ".logs-server.json");
+var LOG_FILE = join6(DIR, "logs-server.log");
+var LOGS_SERVER_PORT = 8788;
+function readState() {
+  try {
+    const s = JSON.parse(readFileSync4(STATE_FILE, "utf-8"));
+    return s && typeof s === "object" ? s : {};
+  } catch {
+    return {};
+  }
+}
+function writeState(s) {
+  try {
+    mkdirSync4(DIR, { recursive: true });
+    writeFileSync5(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 startLogsServerDaemon() {
+  const cur = logsServerStatus();
+  if (cur.running) {
+    writeState({ ...readState(), desired: "on" });
+    return { ...cur, desired: "on" };
+  }
+  try {
+    mkdirSync4(DIR, { recursive: true });
+    const log = openSync2(LOG_FILE, "a");
+    const cli = join6(dirname(fileURLToPath(import.meta.url)), "index.js");
+    const p = spawn3(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 };
+}
+
+// src/tui/panels/Settings.tsx
 import { Fragment as Fragment5, jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
 var EVENTS = ["denials", "allowed", "all"];
 var SPIN2 = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
@@ -3122,6 +3199,11 @@ function SettingsPanel({
   const abort = useRef3(false);
   const refreshAccounts = () => setAccounts(listAccounts());
   const locked = accounts.length === 0;
+  const [srv, setSrv] = useState7(() => logsServerStatus());
+  useEffect6(() => {
+    const t = setInterval(() => setSrv(logsServerStatus()), 3e3);
+    return () => clearInterval(t);
+  }, []);
   useEffect6(() => {
     if (!login || login.phase === "done" || login.phase === "error") return;
     const t = setInterval(() => setTick((n) => n + 1), 120);
@@ -3139,6 +3221,7 @@ function SettingsPanel({
     ...locked ? [] : [
       { kind: "ll-enabled" },
       { kind: "ll-path" },
+      { kind: "ll-server" },
       ...webhooks.map((wh) => ({ kind: "wh", wh })),
       { kind: "wh-add" },
       ...alerts.map((rule) => ({ kind: "alert", rule })),
@@ -3214,6 +3297,12 @@ function SettingsPanel({
     } else if (r.kind === "ll-path") {
       setInput(local?.path ?? "");
       setEditing("path");
+    } else if (r.kind === "ll-server") {
+      const next = srv.running ? stopLogsServerDaemon() : startLogsServerDaemon();
+      setSrv(next);
+      setMsg(
+        next.running ? { text: `\u2713 dashboard link running on 127.0.0.1:${next.port} \u2014 keeps running after you close the dataroom`, level: "ok" } : { text: "\u2713 dashboard link stopped (disabled until you start it again)", level: "ok" }
+      );
     } else if (r.kind === "wh") {
       run(r.wh.enabled ? "webhook disabled" : "webhook enabled", () => api.settings.updateWebhook(r.wh.id, { enabled: !r.wh.enabled }), whQ.reload);
     } else if (r.kind === "wh-add") {
@@ -3357,7 +3446,7 @@ function SettingsPanel({
       ] }) : null
     ] }),
     locked ? null : /* @__PURE__ */ jsxs7(Fragment5, { children: [
-      inWindow({ kind: "ll-enabled" }) || inWindow({ kind: "ll-path" }) ? /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      inWindow({ kind: "ll-enabled" }) || inWindow({ kind: "ll-path" }) || inWindow({ kind: "ll-server" }) ? /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
         /* @__PURE__ */ jsxs7(Text7, { bold: true, color: theme.accentBright, children: [
           "LOCAL LOGS ",
           /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "\u2014 hooks mirror every decision to a file on the agent machine" })
@@ -3372,6 +3461,12 @@ function SettingsPanel({
           /* @__PURE__ */ jsx7(Text7, { color: keyOf(cur) === "ll-path" && focused ? theme.accentBright : theme.dim, children: mark({ kind: "ll-path" }) }),
           /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "path ".padEnd(10) }),
           local?.path ? /* @__PURE__ */ jsx7(Text7, { color: theme.accent, children: truncate(local.path, cols - 14) }) : /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "not set \u2014 enter to edit" })
+        ] }),
+        /* @__PURE__ */ jsxs7(Text7, { wrap: "truncate", children: [
+          /* @__PURE__ */ jsx7(Text7, { color: keyOf(cur) === "ll-server" && focused ? theme.accentBright : theme.dim, children: mark({ kind: "ll-server" }) }),
+          /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "dashboard".padEnd(10) }),
+          srv.running ? /* @__PURE__ */ jsx7(Text7, { color: theme.ok, children: `running 127.0.0.1:${srv.port}` }) : /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: "stopped" }),
+          /* @__PURE__ */ jsx7(Text7, { color: theme.dim, children: srv.running ? "   serves local logs to the dashboard \xB7 survives closing the dataroom \xB7 enter stops" : "   enter starts the local-logs link for the dashboard" })
         ] })
       ] }) : null,
       /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
@@ -3420,34 +3515,34 @@ function SettingsPanel({
 }
 
 // src/self-update.ts
-import { execFile, spawn as spawn3 } from "child_process";
-import { mkdirSync as mkdirSync4, openSync as openSync2, readFileSync as readFileSync4, realpathSync, writeFileSync as writeFileSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { dirname, join as join6 } from "path";
-import { fileURLToPath } from "url";
+import { execFile, spawn as spawn4 } from "child_process";
+import { mkdirSync as mkdirSync5, openSync as openSync3, readFileSync as readFileSync5, realpathSync, writeFileSync as writeFileSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { dirname as dirname2, join as join7 } from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 var PKG = "@solongate/proxy";
 var CHECK_EVERY_MS = 30 * 60 * 1e3;
 var ATTEMPT_EVERY_MS = 6 * 60 * 60 * 1e3;
-var STATE_FILE = join6(homedir6(), ".solongate", ".self-update.json");
-var LOG_FILE = join6(homedir6(), ".solongate", "self-update.log");
-function readState() {
+var STATE_FILE2 = join7(homedir7(), ".solongate", ".self-update.json");
+var LOG_FILE2 = join7(homedir7(), ".solongate", "self-update.log");
+function readState2() {
   try {
-    const s = JSON.parse(readFileSync4(STATE_FILE, "utf-8"));
+    const s = JSON.parse(readFileSync5(STATE_FILE2, "utf-8"));
     return s && typeof s === "object" ? s : {};
   } catch {
     return {};
   }
 }
-function writeState(s) {
+function writeState2(s) {
   try {
-    mkdirSync4(join6(homedir6(), ".solongate"), { recursive: true });
-    writeFileSync5(STATE_FILE, JSON.stringify(s));
+    mkdirSync5(join7(homedir7(), ".solongate"), { recursive: true });
+    writeFileSync6(STATE_FILE2, JSON.stringify(s));
   } catch {
   }
 }
 function currentVersion() {
   try {
-    const pkg = JSON.parse(readFileSync4(join6(dirname(fileURLToPath(import.meta.url)), "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync5(join7(dirname2(fileURLToPath2(import.meta.url)), "..", "package.json"), "utf-8"));
     return pkg.version ?? "0.0.0";
   } catch {
     return "0.0.0";
@@ -3497,14 +3592,14 @@ async function isGlobalInstall() {
 function runGlobalInstall(version) {
   return new Promise((resolve2) => {
     try {
-      mkdirSync4(join6(homedir6(), ".solongate"), { recursive: true });
+      mkdirSync5(join7(homedir7(), ".solongate"), { recursive: true });
       execFile(
         "npm",
         ["install", "-g", `${PKG}@${version}`],
         { timeout: 3e5, windowsHide: true, shell: process.platform === "win32" },
         (err, stdout, stderr) => {
           try {
-            writeFileSync5(LOG_FILE, `${(/* @__PURE__ */ new Date()).toISOString()} install ${version}: ${err ? "FAILED" : "ok"}
+            writeFileSync6(LOG_FILE2, `${(/* @__PURE__ */ new Date()).toISOString()} install ${version}: ${err ? "FAILED" : "ok"}
 ${stdout}
 ${stderr}
 `, { flag: "a" });
@@ -3522,13 +3617,13 @@ async function tuiUpdateFlow(onStatus) {
   try {
     const current = currentVersion();
     const latest = await fetchLatest();
-    const state = readState();
-    if (latest) writeState({ ...state, lastCheckAt: Date.now(), latestSeen: latest });
+    const state = readState2();
+    if (latest) writeState2({ ...state, lastCheckAt: Date.now(), latestSeen: latest });
     if (!latest || !newerThan(latest, current)) return;
-    const attempts = readState().attempts ?? {};
+    const attempts = readState2().attempts ?? {};
     const canRetry = Date.now() - (attempts[latest] ?? 0) >= ATTEMPT_EVERY_MS;
     if (await isGlobalInstall() && canRetry) {
-      writeState({ ...readState(), attempts: { [latest]: Date.now() } });
+      writeState2({ ...readState2(), attempts: { [latest]: Date.now() } });
       onStatus({ kind: "updating", version: latest });
       if (await runGlobalInstall(latest)) {
         onStatus({ kind: "updated", version: latest });
@@ -3713,11 +3808,11 @@ async function launchTui() {
     return;
   }
   process.stdout.write("\x1B[?1049h\x1B[H");
-  const debugLog = join7(homedir7(), ".solongate", "dataroom-debug.log");
+  const debugLog = join8(homedir8(), ".solongate", "dataroom-debug.log");
   const saved = { log: console.log, warn: console.warn, error: console.error, info: console.info, debug: console.debug };
   const toFile = (level) => (...args) => {
     try {
-      mkdirSync5(join7(homedir7(), ".solongate"), { recursive: true });
+      mkdirSync6(join8(homedir8(), ".solongate"), { recursive: true });
       appendFileSync(debugLog, `${(/* @__PURE__ */ new Date()).toISOString()} [${level}] ${args.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ")}
 `);
     } catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solongate/proxy",
-  "version": "0.81.50",
+  "version": "0.81.51",
   "description": "AI tool security proxy: protect any AI tool server with customizable policies, path/command constraints, rate limiting, and audit logging. No code changes required.",
   "type": "module",
   "bin": {