pinggy 0.4.9 → 0.5.0

package/dist/{chunk-3RTRUYNW.js → chunk-7G6SJEEA.js}

@@ -3,6 +3,22 @@ import winston from "winston";
 import fs from "fs";
 import path from "path";
 import { pinggy, LogLevel } from "@pinggy/pinggy";
+var _currentLevel = process.env.PINGGY_LOG_LEVEL || "info";
+var _sdkLogFilePath = null;
+function getLogLevel() {
+  return _currentLevel;
+}
+function setLogLevel(level) {
+  _currentLevel = level;
+  getLogger().level = level;
+  if (_sdkLogFilePath) {
+    enableLoggingByLogLevelInSdk(level, _sdkLogFilePath);
+  }
+  import("./daemonConfig-G6S46GPJ.js").then(({ writeDaemonConfig }) => writeDaemonConfig({ logLevel: level })).catch(() => {
+  });
+  import("./TunnelManager-OPUMAZFX.js").then(({ TunnelManager }) => TunnelManager.getInstance().applyLogLevelToActiveTunnels(level)).catch(() => {
+  });
+}
 var _logger = null;
 function getLogger() {
   if (!_logger) {
@@ -22,6 +38,7 @@ function applyLoggingConfig(cfg) {
   } = cfg;
   if (enableSdkLog) {
     enableLoggingByLogLevelInSdk(level ?? "info", filePath);
+    _sdkLogFilePath = filePath ?? null;
   }
   if (filePath) {
     const dir = path.dirname(filePath);
@@ -34,22 +51,30 @@ function applyLoggingConfig(cfg) {
         format: winston.format.combine(
           winston.format.colorize(),
           winston.format.timestamp(),
-          winston.format.printf(({ level: level2, message, timestamp, ...meta }) => {
-            const srcLabel = source ? "[CLI] " : "";
-            return `${timestamp} ${srcLabel}[${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
+          winston.format.printf(({ level: level2, message, timestamp, tunnelId, source: src, ...meta }) => {
+            const srcLabel = source && src && src !== "libpinggy" && src !== "sdk-js" ? `[${src}] ` : "";
+            const tunnelLabel = tunnelId ? `[tunnel:${String(tunnelId).slice(0, 8)}] ` : "";
+            return `${timestamp} ${tunnelLabel}[${level2}] ${srcLabel}${message}${Object.keys(meta).length ? " " + JSON.stringify(meta) : ""}`;
           })
         )
       })
     );
   }
   if (filePath) {
+    const daemonFilter = winston.format((info) => {
+      if (info.source === "libpinggy" || info.source === "sdk-js") return false;
+      return info;
+    });
     transports.push(
       new winston.transports.File({
         filename: filePath,
         format: winston.format.combine(
+          daemonFilter(),
           winston.format.timestamp(),
-          winston.format.printf(({ level: level2, message, timestamp, ...meta }) => {
-            return `${timestamp} [${level2}] ${message} ${Object.keys(meta).length ? JSON.stringify(meta) : ""}`;
+          winston.format.printf(({ level: level2, message, timestamp, tunnelId, source: src, ...meta }) => {
+            const srcLabel = src ? `[${src}] ` : "";
+            const tunnelLabel = tunnelId ? `[tunnel:${String(tunnelId).slice(0, 8)}] ` : "";
+            return `${timestamp} ${tunnelLabel}[${level2}] ${srcLabel}${message}${Object.keys(meta).length ? " " + JSON.stringify(meta) : ""}`;
           })
         )
       })
@@ -61,6 +86,7 @@ function applyLoggingConfig(cfg) {
     log.add(t);
   }
   log.level = (level || process.env.PINGGY_LOG_LEVEL || "info").toLowerCase();
+  _currentLevel = log.level;
   log.silent = silent || transports.length === 0;
   return log;
 }
@@ -87,9 +113,9 @@ function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
     return;
   }
   const l = loglevel.toUpperCase();
-  if (loglevel === "DEBUG") {
+  if (l === "DEBUG") {
     pinggy.setDebugLogging(true, LogLevel.DEBUG, logFilePath);
-  } else if (loglevel === "ERROR") {
+  } else if (l === "ERROR") {
     pinggy.setDebugLogging(true, LogLevel.ERROR, logFilePath);
   } else {
     pinggy.setDebugLogging(true, LogLevel.INFO, logFilePath);
@@ -97,6 +123,8 @@ function enableLoggingByLogLevelInSdk(loglevel, logFilePath) {
 }
 
 export {
+  getLogLevel,
+  setLogLevel,
   logger,
   configureLogger,
   enablePackageLogging

package/dist/chunk-BFARGPGP.js

@@ -0,0 +1,164 @@
+// src/daemon/ipc/ipcClient.ts
+import http from "http";
+
+// src/daemon/ipc/ipcRoutes.ts
+var Route = {
+  Ping: "GET /ping",
+  ListTunnels: "GET /tunnels",
+  ListTunnelsV1: "GET /tunnels-v1",
+  StartTunnel: "POST /tunnels/start",
+  StartTunnelConfig: "POST /tunnels/start-config",
+  StartTunnelV1: "POST /tunnels/start-v1",
+  StopTunnel: "POST /tunnels/stop",
+  RestartTunnel: "POST /tunnels/restart",
+  UpdateConfig: "POST /tunnels/update-config",
+  UpdateConfigV2: "POST /tunnels/update-config-v2",
+  RemoveStopped: "POST /tunnels/remove-stopped",
+  Shutdown: "POST /shutdown",
+  GetLogLevel: "GET /loglevel",
+  SetLogLevel: "POST /loglevel",
+  GetTunnelLogging: "GET /config/tunnel-logging",
+  SetTunnelLogging: "POST /config/tunnel-logging",
+  GetLogPaths: "GET /logs/paths"
+};
+var SessionMode = {
+  Foreground: "foreground",
+  Detached: "detached"
+};
+
+// src/daemon/ipc/ipcClient.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+var IPCClient = class {
+  constructor(port, origin = "cli") {
+    this.port = port;
+    this.origin = origin;
+  }
+  async ping(timeoutMs) {
+    return this.call(Route.Ping, void 0, timeoutMs);
+  }
+  async listTunnels() {
+    return this.call(Route.ListTunnels, void 0);
+  }
+  async getTunnel(tunnelId) {
+    return this.request("GET", `/tunnels/${tunnelId}`);
+  }
+  async getTunnelStats(tunnelId) {
+    return this.request("GET", `/tunnels/${encodeURIComponent(tunnelId)}/stats`);
+  }
+  async startTunnel(name, mode) {
+    return this.call(Route.StartTunnel, { name, mode });
+  }
+  async startTunnelWithConfig(config, mode, noWait) {
+    return this.call(Route.StartTunnelConfig, { config, mode, noWait });
+  }
+  async stopTunnel(tunnelid) {
+    return this.call(Route.StopTunnel, { tunnelid });
+  }
+  async restartTunnel(tunnelid) {
+    return this.call(Route.RestartTunnel, { tunnelid });
+  }
+  // v1 operations (used by remote management via daemon)
+  async startTunnelV1(config, mode, noWait) {
+    return this.call(Route.StartTunnelV1, { config, mode, noWait });
+  }
+  async listTunnelsV1() {
+    return this.call(Route.ListTunnelsV1, void 0);
+  }
+  async updateConfig(config, noWait) {
+    return this.call(Route.UpdateConfig, { config, noWait });
+  }
+  async updateConfigV2(config, noWait) {
+    return this.call(Route.UpdateConfigV2, { config, noWait });
+  }
+  async removeStoppedTunnel(opts) {
+    return this.call(Route.RemoveStopped, opts);
+  }
+  async shutdown() {
+    return this.call(Route.Shutdown, {});
+  }
+  async getLogLevel() {
+    return this.call(Route.GetLogLevel, void 0);
+  }
+  async setLogLevel(level) {
+    return this.call(Route.SetLogLevel, { level });
+  }
+  async getTunnelLogging() {
+    return this.call(Route.GetTunnelLogging, void 0);
+  }
+  async setTunnelLogging(enabled) {
+    return this.call(Route.SetTunnelLogging, { enabled });
+  }
+  async getLogPaths() {
+    return this.call(Route.GetLogPaths, void 0);
+  }
+  async resolveLogPath(q) {
+    return this.request("GET", `/logs/resolve?q=${encodeURIComponent(q)}`);
+  }
+  /**
+   * Get the WebSocket URL for event streaming.
+   */
+  getWsUrl() {
+    return `ws://127.0.0.1:${this.port}/ws`;
+  }
+  getPort() {
+    return this.port;
+  }
+  call(key, body, timeoutMs) {
+    const spaceIdx = key.indexOf(" ");
+    const method = key.slice(0, spaceIdx);
+    const path = key.slice(spaceIdx + 1);
+    const payload = method === "GET" ? void 0 : JSON.stringify(body ?? {});
+    return this.request(method, path, payload, timeoutMs);
+  }
+  request(method, path, body, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const headers = {
+        "X-Pinggy-Origin": this.origin
+      };
+      if (body) {
+        headers["Content-Type"] = "application/json";
+        headers["Content-Length"] = Buffer.byteLength(body);
+      }
+      const req = http.request(
+        {
+          hostname: "127.0.0.1",
+          port: this.port,
+          path,
+          method,
+          headers,
+          timeout: timeoutMs ?? REQUEST_TIMEOUT_MS
+        },
+        (res) => {
+          const chunks = [];
+          res.on("data", (chunk) => chunks.push(chunk));
+          res.on("end", () => {
+            const text = Buffer.concat(chunks).toString("utf-8");
+            const statusCode = res.statusCode ?? 0;
+            if (statusCode < 200 || statusCode >= 300) {
+              reject(new Error(`Daemon returned HTTP ${statusCode}: ${text.slice(0, 200)}`));
+              return;
+            }
+            try {
+              resolve(JSON.parse(text));
+            } catch {
+              reject(new Error(`Invalid JSON from daemon: ${text.slice(0, 200)}`));
+            }
+          });
+        }
+      );
+      req.on("error", (err) => reject(new Error(`Cannot connect to daemon: ${err.message}`)));
+      req.on("timeout", () => {
+        req.destroy();
+        reject(new Error("Daemon request timed out"));
+      });
+      if (body) req.write(body);
+      req.end();
+    });
+  }
+};
+
+export {
+  Route,
+  SessionMode,
+  IPCClient
+};