@solongate/proxy 0.58.0 → 0.59.1

package/dist/global-install.js

@@ -232,7 +232,7 @@ async function runGlobalInstall(opts = {}) {
   writeFileSync(join(p.hooksDir, "stop.mjs"), readHook("stop.mjs"));
   writeFileSync(join(p.hooksDir, "shield.mjs"), readHook("shield.mjs"));
   console.log(`  Installed hooks \u2192 ${p.hooksDir}`);
-  installClaudeShim(join(p.hooksDir, "shield.mjs"));
+  removeClaudeShim();
   writeFileSync(p.configPath, JSON.stringify({ apiKey, apiUrl }, null, 2) + "\n");
   console.log(`  Wrote ${p.configPath}`);
   let existing = {};

package/dist/index.js

@@ -3412,12 +3412,12 @@ ${ctx.indent}`;
       for (const {
         format,
         test,
-        resolve: resolve8
+        resolve: resolve9
       } of tags) {
         if (test) {
           const match = str.match(test);
           if (match) {
-            let res = resolve8.apply(null, match);
+            let res = resolve9.apply(null, match);
             if (!(res instanceof Scalar)) res = new Scalar(res);
             if (format) res.format = format;
             return res;
@@ -6809,7 +6809,7 @@ async function runGlobalInstall(opts = {}) {
   writeFileSync3(join4(p.hooksDir, "stop.mjs"), readHook("stop.mjs"));
   writeFileSync3(join4(p.hooksDir, "shield.mjs"), readHook("shield.mjs"));
   console.log(`  Installed hooks \u2192 ${p.hooksDir}`);
-  installClaudeShim(join4(p.hooksDir, "shield.mjs"));
+  removeClaudeShim();
   writeFileSync3(p.configPath, JSON.stringify({ apiKey, apiUrl }, null, 2) + "\n");
   console.log(`  Wrote ${p.configPath}`);
   let existing = {};
@@ -7049,11 +7049,104 @@ function loadCfg() {
     if (f && existsSync5(f)) {
       const c3 = JSON.parse(readFileSync6(f, "utf-8"));
       const d = c3?.security?.dlpRedact;
-      if (d && Array.isArray(d.patterns)) return { patterns: d.patterns, custom: Array.isArray(d.custom) ? d.custom : [] };
+      const g = c3?.security?.ghost;
+      const ghost = g && Array.isArray(g.patterns) ? g.patterns : [];
+      if (d && Array.isArray(d.patterns)) return { patterns: d.patterns, custom: Array.isArray(d.custom) ? d.custom : [], ghost };
+      return { patterns: DLP_PATTERNS.map((p) => p.name), custom: [], ghost };
     }
   } catch {
   }
-  return { patterns: DLP_PATTERNS.map((p) => p.name), custom: [] };
+  return { patterns: DLP_PATTERNS.map((p) => p.name), custom: [], ghost: [] };
+}
+function ghostGlobToRegExp(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const c3 = glob[i];
+    if (c3 === "*") {
+      if (glob[i + 1] === "*") {
+        re += ".*";
+        i++;
+      } else re += "[^/]*";
+    } else if (c3 === "?") re += "[^/]";
+    else if ("\\^$.|+()[]{}".indexOf(c3) !== -1) re += "\\" + c3;
+    else re += c3;
+  }
+  try {
+    return new RegExp("^" + re + "$");
+  } catch {
+    return null;
+  }
+}
+function ghostMatch(targetPath, patterns) {
+  if (!targetPath || !Array.isArray(patterns) || patterns.length === 0) return false;
+  const norm = String(targetPath).replace(/\\/g, "/").replace(/\/+$/, "");
+  if (!norm) return false;
+  const segments = norm.split("/").filter(Boolean);
+  const base = segments.length ? segments[segments.length - 1] : norm;
+  for (let pat of patterns) {
+    pat = String(pat || "").trim();
+    if (!pat) continue;
+    let dirOnly = false;
+    if (pat.endsWith("/")) {
+      dirOnly = true;
+      pat = pat.slice(0, -1);
+    }
+    if (!pat) continue;
+    const hasSlash = pat.indexOf("/") !== -1;
+    const hasWild = /[*?]/.test(pat);
+    const re = ghostGlobToRegExp(pat);
+    if (!re) continue;
+    if (dirOnly) {
+      if (!hasSlash && !hasWild) {
+        if (segments.indexOf(pat) !== -1) return true;
+        continue;
+      }
+      let acc = "";
+      for (const s of segments) {
+        acc = acc ? acc + "/" + s : s;
+        if (re.test(acc) || re.test(s)) return true;
+      }
+      continue;
+    }
+    if (!hasSlash) {
+      if (re.test(base)) return true;
+      if (segments.some((s) => re.test(s))) return true;
+      continue;
+    }
+    if (re.test(norm)) return true;
+  }
+  return false;
+}
+function ghostCleanToken(tok) {
+  let t = String(tok || "").trim();
+  t = t.replace(/^[<>|;&(]+/, "").replace(/[);&|]+$/, "");
+  t = t.replace(/^['"]+/, "").replace(/['"]+$/, "");
+  t = t.replace(/^\d*>>?/, "");
+  return t.trim();
+}
+function ghostStripLines(text, pats) {
+  if (!Array.isArray(pats) || pats.length === 0) return text;
+  const lines = String(text).split("\n");
+  const kept = [];
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      kept.push(line);
+      continue;
+    }
+    if (ghostMatch(trimmed, pats)) continue;
+    const toks = trimmed.split(/\s+/);
+    const anyHit = toks.some((t) => ghostMatch(ghostCleanToken(t), pats));
+    if (!anyHit) {
+      kept.push(line);
+      continue;
+    }
+    if (toks.length > 3) continue;
+    const remaining = toks.filter((t) => !ghostMatch(ghostCleanToken(t), pats));
+    if (remaining.length === 0) continue;
+    kept.push(remaining.join("  "));
+  }
+  return kept.join("\n");
 }
 function dlpGlobToRe(glob, flags) {
   let re = "";
@@ -7078,8 +7171,16 @@ function redactString(s, cfg) {
   return out;
 }
 function redactDeep(value, cfg) {
-  if (typeof value === "string") return redactString(value, cfg);
-  if (Array.isArray(value)) return value.map((v) => redactDeep(v, cfg));
+  const ghost = cfg && Array.isArray(cfg.ghost) ? cfg.ghost : null;
+  if (typeof value === "string") {
+    let out = redactString(value, cfg);
+    if (ghost && ghost.length) out = ghostStripLines(out, ghost);
+    return out;
+  }
+  if (Array.isArray(value)) {
+    const arr = ghost && ghost.length ? value.filter((v) => !(typeof v === "string" && ghostMatch(v.trim(), ghost))) : value;
+    return arr.map((v) => redactDeep(v, cfg));
+  }
   if (value && typeof value === "object") {
     const out = {};
     for (const [k, v] of Object.entries(value)) out[k] = redactDeep(v, cfg);
@@ -7206,22 +7307,202 @@ var init_shield = __esm({
       { name: "GitHub fine-grained PAT", re: /github_pat_[A-Za-z0-9_]{20,}/g },
       { name: "GitLab token", re: /glpat-[A-Za-z0-9_-]{20,}/g },
       { name: "Slack token", re: /xox[baprs]-[A-Za-z0-9-]{10,}/g },
-      { name: "Google API key", re: /AIza[0-9A-Za-z_-]{35}/g },
       { name: "Stripe key", re: /[sr]k_(live|test)_[A-Za-z0-9]{20,}/g },
       { name: "SendGrid key", re: /SG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}/g },
       { name: "Twilio key", re: /SK[0-9a-fA-F]{32}/g },
       { name: "npm token", re: /npm_[A-Za-z0-9]{36}/g },
       { name: "JWT", re: /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g },
-      { name: "Bearer token", re: /bearer\s+[A-Za-z0-9._-]{20,}/gi },
-      { name: "secret assignment", re: /(api[_-]?key|secret|token|password|passwd|access[_-]?key)["']?\s*[:=]\s*["']?[A-Za-z0-9/+_.-]{12,}/gi }
+      { name: "Bearer token", re: /bearer\s+[A-Za-z0-9._-]{20,}/gi }
     ];
   }
 });
 
+// src/logs-server.ts
+var logs_server_exports = {};
+__export(logs_server_exports, {
+  runLogsServer: () => runLogsServer
+});
+import { createServer as createServer2 } from "http";
+import { readFileSync as readFileSync7, statSync as statSync2 } from "fs";
+import { resolve as resolve5, join as join5, isAbsolute } from "path";
+import { homedir as homedir4 } from "os";
+import { readdirSync as readdirSync2 } from "fs";
+function allowedOrigins() {
+  const base = [
+    "https://dashboard.solongate.com",
+    "http://localhost:3000",
+    "http://localhost:3005",
+    "http://127.0.0.1:3000",
+    "http://127.0.0.1:3005"
+  ];
+  const extra = (process.env.SOLONGATE_DASHBOARD_ORIGIN || "").split(",").map((s) => s.trim()).filter(Boolean);
+  return /* @__PURE__ */ new Set([...base, ...extra]);
+}
+function resolveLocalLogDir(rawPath) {
+  const dir = String(rawPath || "").trim().replace(/[\\/]+$/, "");
+  if (!dir) return null;
+  if (isAbsolute(dir)) return dir;
+  return resolve5(homedir4(), ".solongate", "local-logs");
+}
+async function findLogDir() {
+  const base = resolve5(homedir4(), ".solongate");
+  try {
+    const files = readdirSync2(base).filter((f) => f.startsWith(".policy-cache-") && f.endsWith(".json"));
+    for (const f of files) {
+      try {
+        const c3 = JSON.parse(readFileSync7(join5(base, f), "utf-8"));
+        const p = c3?.security?.localLogs?.path;
+        if (typeof p === "string" && p.trim()) return { dir: resolveLocalLogDir(p), configured: p };
+      } catch {
+      }
+    }
+  } catch {
+  }
+  try {
+    const cfgRaw = readFileSync7(join5(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`;
+      const res = await fetch(url, { headers: { Authorization: `Bearer ${apiKey}` } });
+      if (res.ok) {
+        const body = await res.json();
+        const p = body?.security?.localLogs?.path;
+        if (typeof p === "string" && p.trim()) return { dir: resolveLocalLogDir(p), configured: p };
+      }
+    }
+  } catch {
+  }
+  return { dir: null, configured: null };
+}
+function setCors(req, res) {
+  const origin = req.headers.origin;
+  if (origin && allowedOrigins().has(origin)) {
+    res.setHeader("Access-Control-Allow-Origin", origin);
+    res.setHeader("Vary", "Origin");
+  }
+  if (req.headers["access-control-request-private-network"] === "true") {
+    res.setHeader("Access-Control-Allow-Private-Network", "true");
+  }
+  res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+  res.setHeader("Access-Control-Allow-Headers", "If-Modified-Since, Content-Type");
+}
+function fileInfo(dir) {
+  if (!dir) return { file: null, exists: false, size: 0, mtimeMs: 0 };
+  const file = join5(dir, LOG_FILENAME);
+  try {
+    const st = statSync2(file);
+    return { file, exists: true, size: st.size, mtimeMs: st.mtimeMs };
+  } catch {
+    return { file, exists: false, size: 0, mtimeMs: 0 };
+  }
+}
+async function runLogsServer() {
+  const argv = process.argv.slice(3);
+  const portArg = argv[argv.indexOf("--port") + 1];
+  const port = Number(process.env.SOLONGATE_LOGS_PORT || (argv.includes("--port") ? portArg : "") || DEFAULT_PORT) || DEFAULT_PORT;
+  const server = createServer2(async (req, res) => {
+    setCors(req, res);
+    if (req.method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    if (req.method !== "GET") {
+      res.writeHead(405);
+      res.end();
+      return;
+    }
+    const url = (req.url || "/").split("?")[0];
+    const { dir, configured } = await findLogDir();
+    if (url === "/health") {
+      const info = fileInfo(dir);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        ok: true,
+        agent: "solongate-logs-server",
+        configuredPath: configured,
+        resolvedDir: dir,
+        file: info.file,
+        exists: info.exists,
+        size: info.size,
+        mtime: info.mtimeMs ? new Date(info.mtimeMs).toISOString() : null
+      }));
+      return;
+    }
+    if (url === "/local-logs") {
+      const info = fileInfo(dir);
+      if (!dir) {
+        res.writeHead(200, { "Content-Type": "text/plain", "X-Solongate-Configured": "0" });
+        res.end("");
+        return;
+      }
+      if (!info.exists) {
+        res.writeHead(200, { "Content-Type": "text/plain", "X-Solongate-Exists": "0" });
+        res.end("");
+        return;
+      }
+      const lastMod = new Date(info.mtimeMs).toUTCString();
+      const since = req.headers["if-modified-since"];
+      if (since && new Date(since).getTime() >= Math.floor(info.mtimeMs / 1e3) * 1e3) {
+        res.writeHead(304, { "Last-Modified": lastMod });
+        res.end();
+        return;
+      }
+      try {
+        const text = readFileSync7(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 {
+        res.writeHead(500);
+        res.end("read error");
+      }
+      return;
+    }
+    res.writeHead(404);
+    res.end("not found");
+  });
+  server.listen(port, "127.0.0.1", async () => {
+    const { dir, configured } = await findLogDir();
+    process.stdout.write(`[SolonGate] Local logs agent listening on http://127.0.0.1:${port}
+`);
+    if (configured) {
+      process.stdout.write(`[SolonGate] Configured path: ${configured}
+`);
+      if (dir && dir !== configured.trim().replace(/[\\/]+$/, "")) {
+        process.stdout.write(`[SolonGate] That path isn't absolute on this machine \u2014 reading from: ${dir}
+`);
+      }
+    } else {
+      process.stdout.write(`[SolonGate] Local log storage not configured yet (set it in dashboard Settings).
+`);
+    }
+    process.stdout.write(`[SolonGate] Keep this running; the dashboard reads your logs live from here. Ctrl+C to stop.
+`);
+  });
+  server.on("error", (err) => {
+    if (err.code === "EADDRINUSE") {
+      process.stderr.write(`[SolonGate] Port ${port} is already in use. Pass --port <n> or set SOLONGATE_LOGS_PORT.
+`);
+    } else {
+      process.stderr.write(`[SolonGate] Local logs agent error: ${err.message}
+`);
+    }
+    process.exit(1);
+  });
+}
+var LOG_FILENAME, DEFAULT_PORT;
+var init_logs_server = __esm({
+  "src/logs-server.ts"() {
+    "use strict";
+    LOG_FILENAME = "solongate-audit.jsonl";
+    DEFAULT_PORT = 8788;
+  }
+});
+
 // src/inject.ts
 var inject_exports = {};
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync6, copyFileSync } from "fs";
-import { resolve as resolve5 } from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync4, existsSync as existsSync7, copyFileSync } from "fs";
+import { resolve as resolve6 } from "path";
 import { execSync } from "child_process";
 function parseInjectArgs(argv) {
   const args = argv.slice(2);
@@ -7278,9 +7559,9 @@ WHAT IT DOES
 `);
 }
 function detectProject() {
-  if (!existsSync6(resolve5("package.json"))) return false;
+  if (!existsSync7(resolve6("package.json"))) return false;
   try {
-    const pkg = JSON.parse(readFileSync7(resolve5("package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync8(resolve6("package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     return !!(allDeps["@modelcontextprotocol/sdk"] || allDeps["@modelcontextprotocol/server"]);
   } catch {
@@ -7289,18 +7570,18 @@ function detectProject() {
 }
 function findTsEntryFile() {
   try {
-    const pkg = JSON.parse(readFileSync7(resolve5("package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync8(resolve6("package.json"), "utf-8"));
     if (pkg.bin) {
       const binPath = typeof pkg.bin === "string" ? pkg.bin : Object.values(pkg.bin)[0];
       if (typeof binPath === "string") {
         const srcPath = binPath.replace(/^\.\/dist\//, "./src/").replace(/\.js$/, ".ts");
-        if (existsSync6(resolve5(srcPath))) return resolve5(srcPath);
-        if (existsSync6(resolve5(binPath))) return resolve5(binPath);
+        if (existsSync7(resolve6(srcPath))) return resolve6(srcPath);
+        if (existsSync7(resolve6(binPath))) return resolve6(binPath);
       }
     }
     if (pkg.main) {
       const srcPath = pkg.main.replace(/^\.\/dist\//, "./src/").replace(/\.js$/, ".ts");
-      if (existsSync6(resolve5(srcPath))) return resolve5(srcPath);
+      if (existsSync7(resolve6(srcPath))) return resolve6(srcPath);
     }
   } catch {
   }
@@ -7313,10 +7594,10 @@ function findTsEntryFile() {
     "main.ts"
   ];
   for (const c3 of candidates) {
-    const full = resolve5(c3);
-    if (existsSync6(full)) {
+    const full = resolve6(c3);
+    if (existsSync7(full)) {
       try {
-        const content = readFileSync7(full, "utf-8");
+        const content = readFileSync8(full, "utf-8");
         if (content.includes("McpServer") || content.includes("McpServer")) {
           return full;
         }
@@ -7325,18 +7606,18 @@ function findTsEntryFile() {
     }
   }
   for (const c3 of candidates) {
-    if (existsSync6(resolve5(c3))) return resolve5(c3);
+    if (existsSync7(resolve6(c3))) return resolve6(c3);
   }
   return null;
 }
 function detectPackageManager() {
-  if (existsSync6(resolve5("pnpm-lock.yaml"))) return "pnpm";
-  if (existsSync6(resolve5("yarn.lock"))) return "yarn";
+  if (existsSync7(resolve6("pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync7(resolve6("yarn.lock"))) return "yarn";
   return "npm";
 }
 function installSdk() {
   try {
-    const pkg = JSON.parse(readFileSync7(resolve5("package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync8(resolve6("package.json"), "utf-8"));
     const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
     if (allDeps["@solongate/proxy"]) {
       log3("  @solongate/proxy already installed");
@@ -7357,7 +7638,7 @@ function installSdk() {
   }
 }
 function injectTypeScript(filePath) {
-  const original = readFileSync7(filePath, "utf-8");
+  const original = readFileSync8(filePath, "utf-8");
   const changes = [];
   let modified = original;
   if (modified.includes("SecureMcpServer")) {
@@ -7473,8 +7754,8 @@ async function main2() {
     process.exit(1);
   }
   log3("  Language: TypeScript");
-  const entryFile = opts.file ? resolve5(opts.file) : findTsEntryFile();
-  if (!entryFile || !existsSync6(entryFile)) {
+  const entryFile = opts.file ? resolve6(opts.file) : findTsEntryFile();
+  if (!entryFile || !existsSync7(entryFile)) {
     log3(`  Could not find entry file.${opts.file ? ` File not found: ${opts.file}` : ""}`);
     log3("");
     log3("  Specify it manually: --file <path>");
@@ -7487,7 +7768,7 @@ async function main2() {
   log3("");
   const backupPath = entryFile + ".solongate-backup";
   if (opts.restore) {
-    if (!existsSync6(backupPath)) {
+    if (!existsSync7(backupPath)) {
       log3("  No backup found. Nothing to restore.");
       process.exit(1);
     }
@@ -7523,7 +7804,7 @@ async function main2() {
     log3("  To apply: npx @solongate/proxy inject");
     process.exit(0);
   }
-  if (!existsSync6(backupPath)) {
+  if (!existsSync7(backupPath)) {
     copyFileSync(entryFile, backupPath);
     log3("");
     log3(`  Backup: ${backupPath}`);
@@ -7557,8 +7838,8 @@ var init_inject = __esm({
 
 // src/create.ts
 var create_exports = {};
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync7 } from "fs";
-import { resolve as resolve6, join as join5 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync5, existsSync as existsSync8 } from "fs";
+import { resolve as resolve7, join as join6 } from "path";
 import { execSync as execSync2 } from "child_process";
 function withSpinner(message, fn) {
   const frames = ["\u28FE", "\u28FD", "\u28FB", "\u28BF", "\u287F", "\u28DF", "\u28EF", "\u28F7"];
@@ -7638,7 +7919,7 @@ EXAMPLES
 }
 function createProject(dir, name, _policy) {
   writeFileSync5(
-    join5(dir, "package.json"),
+    join6(dir, "package.json"),
     JSON.stringify(
       {
         name,
@@ -7668,7 +7949,7 @@ function createProject(dir, name, _policy) {
     ) + "\n"
   );
   writeFileSync5(
-    join5(dir, "tsconfig.json"),
+    join6(dir, "tsconfig.json"),
     JSON.stringify(
       {
         compilerOptions: {
@@ -7688,9 +7969,9 @@ function createProject(dir, name, _policy) {
       2
     ) + "\n"
   );
-  mkdirSync5(join5(dir, "src"), { recursive: true });
+  mkdirSync5(join6(dir, "src"), { recursive: true });
   writeFileSync5(
-    join5(dir, "src", "index.ts"),
+    join6(dir, "src", "index.ts"),
     `#!/usr/bin/env node
 
 console.log = (...args: unknown[]) => {
@@ -7732,7 +8013,7 @@ console.log('Press Ctrl+C to stop.');
 `
   );
   writeFileSync5(
-    join5(dir, ".mcp.json"),
+    join6(dir, ".mcp.json"),
     JSON.stringify(
       {
         mcpServers: {
@@ -7750,12 +8031,12 @@ console.log('Press Ctrl+C to stop.');
     ) + "\n"
   );
   writeFileSync5(
-    join5(dir, ".env"),
+    join6(dir, ".env"),
     `SOLONGATE_API_KEY=sg_live_YOUR_KEY_HERE
 `
   );
   writeFileSync5(
-    join5(dir, ".gitignore"),
+    join6(dir, ".gitignore"),
     `node_modules/
 dist/
 *.solongate-backup
@@ -7767,9 +8048,9 @@ dist/
 }
 async function main3() {
   const opts = parseCreateArgs(process.argv);
-  const dir = resolve6(opts.name);
+  const dir = resolve7(opts.name);
   printBanner("Create MCP Server");
-  if (existsSync7(dir)) {
+  if (existsSync8(dir)) {
     log3(`  ${c.red}Error:${c.reset} Directory "${opts.name}" already exists.`);
     process.exit(1);
   }
@@ -7848,14 +8129,14 @@ var init_create = __esm({
 
 // src/pull-push.ts
 var pull_push_exports = {};
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync8 } from "fs";
-import { resolve as resolve7 } from "path";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, existsSync as existsSync9 } from "fs";
+import { resolve as resolve8 } from "path";
 function loadEnv() {
   if (process.env.SOLONGATE_API_KEY) return;
-  const envPath = resolve7(".env");
-  if (!existsSync8(envPath)) return;
+  const envPath = resolve8(".env");
+  if (!existsSync9(envPath)) return;
   try {
-    const content = readFileSync8(envPath, "utf-8");
+    const content = readFileSync9(envPath, "utf-8");
     for (const line of content.split("\n")) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#")) continue;
@@ -7910,7 +8191,7 @@ function parseCliArgs() {
     log5(red("ERROR: Pull/push/list requires a live API key (sg_live_...)."));
     process.exit(1);
   }
-  return { command, apiKey, file: resolve7(file), policyId };
+  return { command, apiKey, file: resolve8(file), policyId };
 }
 async function listPolicies(apiKey) {
   const res = await fetch(`${API_URL}/api/v1/policies`, {
@@ -8055,7 +8336,7 @@ async function pull(apiKey, file, policyId) {
   log5("");
 }
 async function push(apiKey, file, policyId) {
-  if (!existsSync8(file)) {
+  if (!existsSync9(file)) {
     log5(red(`ERROR: File not found: ${file}`));
     process.exit(1);
   }
@@ -8072,7 +8353,7 @@ async function push(apiKey, file, policyId) {
     log5("  solongate-proxy list");
     process.exit(1);
   }
-  const content = readFileSync8(file, "utf-8");
+  const content = readFileSync9(file, "utf-8");
   let policy;
   try {
     policy = JSON.parse(content);
@@ -10589,7 +10870,7 @@ var Mutex = class {
       this.locked = true;
       return;
     }
-    return new Promise((resolve8, reject) => {
+    return new Promise((resolve9, reject) => {
       const timer = setTimeout(() => {
         const idx = this.queue.indexOf(onReady);
         if (idx !== -1) this.queue.splice(idx, 1);
@@ -10597,7 +10878,7 @@ var Mutex = class {
       }, timeoutMs);
       const onReady = () => {
         clearTimeout(timer);
-        resolve8();
+        resolve9();
       };
       this.queue.push(onReady);
     });
@@ -11217,7 +11498,7 @@ ${msg.content.text}`;
 
 // src/index.ts
 init_cli_utils();
-var CLI_SUBCOMMANDS = /* @__PURE__ */ new Set(["login", "logout", "shield", "create", "inject", "pull", "push", "list", "ls"]);
+var CLI_SUBCOMMANDS = /* @__PURE__ */ new Set(["login", "logout", "shield", "create", "inject", "pull", "push", "list", "ls", "logs-server", "local-logs"]);
 var IS_HUMAN_CLI = process.argv.length <= 2 || CLI_SUBCOMMANDS.has(process.argv[2] ?? "");
 if (!IS_HUMAN_CLI) {
   console.log = (...args) => {
@@ -11245,6 +11526,9 @@ function printWelcome() {
   console.log(`  ${c.dim}on this machine with your cloud policy. Manage it at${c.reset}`);
   console.log(`  ${c.cyan}https://dashboard.solongate.com${c.reset}`);
   console.log("");
+  console.log(`  ${c.dim}Using local log storage? Show it live in the dashboard with${c.reset}`);
+  console.log(`    ${c.cyan}npx -y @solongate/proxy@latest logs-server${c.reset}`);
+  console.log("");
 }
 async function main5() {
   const subcommand = process.argv[2];
@@ -11266,6 +11550,11 @@ async function main5() {
     await runShield2();
     return;
   }
+  if (subcommand === "logs-server" || subcommand === "local-logs") {
+    const { runLogsServer: runLogsServer2 } = await Promise.resolve().then(() => (init_logs_server(), logs_server_exports));
+    await runLogsServer2();
+    return;
+  }
   if (subcommand === "inject") {
     process.argv.splice(2, 1);
     await Promise.resolve().then(() => (init_inject(), inject_exports));