@ceon-oy/monitor-sdk 1.0.1

package/dist/index.js

@@ -0,0 +1,605 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MonitorClient: () => MonitorClient
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/MonitorClient.ts
+var MonitorClient = class {
+  constructor(config) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.isClosed = false;
+    this.retryCount = /* @__PURE__ */ new Map();
+    this.isFlushInProgress = false;
+    if (!config.apiKey || config.apiKey.trim().length === 0) {
+      throw new Error("[MonitorClient] API key is required");
+    }
+    if (!/^cm_[a-zA-Z0-9_-]+$/.test(config.apiKey)) {
+      throw new Error("[MonitorClient] Invalid API key format. Expected format: cm_xxx");
+    }
+    if (!config.endpoint || config.endpoint.trim().length === 0) {
+      throw new Error("[MonitorClient] Endpoint URL is required");
+    }
+    try {
+      const url = new URL(config.endpoint);
+      if (!["https:", "http:"].includes(url.protocol)) {
+        throw new Error("[MonitorClient] Endpoint must use HTTP or HTTPS protocol");
+      }
+      if (url.protocol === "http:" && config.environment !== "development" && config.environment !== "test") {
+        console.warn("[MonitorClient] Warning: Using HTTP in non-development environment is not recommended");
+      }
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("[MonitorClient]")) {
+        throw err;
+      }
+      throw new Error("[MonitorClient] Invalid endpoint URL");
+    }
+    this.apiKey = config.apiKey;
+    this.endpoint = config.endpoint.replace(/\/$/, "");
+    this.environment = config.environment || "production";
+    this.batchSize = Math.max(1, config.batchSize || 10);
+    this.flushIntervalMs = Math.max(1e3, config.flushIntervalMs || 5e3);
+    this.trackDependencies = config.trackDependencies || false;
+    this.packageJsonPath = config.packageJsonPath;
+    this.dependencySources = config.dependencySources;
+    this.maxQueueSize = config.maxQueueSize || 1e3;
+    this.maxRetries = config.maxRetries || 3;
+    this.requestTimeoutMs = config.requestTimeoutMs || 1e4;
+    const defaultExcludePatterns = [
+      "@types/*",
+      "eslint*",
+      "prettier*",
+      "*-loader",
+      "*-plugin",
+      "@eslint/*",
+      "@typescript-eslint/*"
+    ];
+    this.excludePatterns = config.excludePatterns || defaultExcludePatterns;
+    this.startFlushTimer();
+    if (this.trackDependencies) {
+      this.syncDependencies().catch((err) => {
+        console.error("[MonitorClient] Failed to sync dependencies:", err instanceof Error ? err.message : String(err));
+      });
+    }
+  }
+  async captureError(error, context) {
+    if (this.isClosed) return;
+    const payload = {
+      severity: context?.severity || "ERROR",
+      message: error.message,
+      stack: error.stack,
+      environment: this.environment,
+      route: context?.route,
+      method: context?.method,
+      statusCode: context?.statusCode,
+      userAgent: context?.userAgent,
+      ip: context?.ip,
+      requestId: context?.requestId,
+      metadata: context?.metadata
+    };
+    this.enqueue(payload);
+  }
+  async captureMessage(message, severity = "INFO", context) {
+    if (this.isClosed) return;
+    const payload = {
+      severity,
+      message,
+      environment: this.environment,
+      route: context?.route,
+      method: context?.method,
+      statusCode: context?.statusCode,
+      userAgent: context?.userAgent,
+      ip: context?.ip,
+      requestId: context?.requestId,
+      metadata: context?.metadata
+    };
+    this.enqueue(payload);
+  }
+  async flush() {
+    if (this.isFlushInProgress || this.queue.length === 0) return;
+    this.isFlushInProgress = true;
+    const errors = [...this.queue];
+    this.queue = [];
+    try {
+      if (errors.length === 1) {
+        await this.sendSingle(errors[0]);
+      } else {
+        await this.sendBatch(errors);
+      }
+      for (const error of errors) {
+        this.retryCount.delete(this.getErrorKey(error));
+      }
+    } catch (err) {
+      console.error("[MonitorClient] Failed to send errors:", err instanceof Error ? err.message : String(err));
+      for (const error of errors) {
+        const key = this.getErrorKey(error);
+        const retries = this.retryCount.get(key) || 0;
+        if (retries < this.maxRetries) {
+          this.retryCount.set(key, retries + 1);
+          if (this.queue.length < this.maxQueueSize) {
+            this.queue.push(error);
+          } else {
+            console.warn("[MonitorClient] Queue full, dropping error");
+            this.retryCount.delete(key);
+          }
+        } else {
+          console.warn("[MonitorClient] Max retries exceeded, dropping error");
+          this.retryCount.delete(key);
+        }
+      }
+    } finally {
+      this.isFlushInProgress = false;
+    }
+  }
+  getErrorKey(error) {
+    return `${error.message}-${error.stack?.substring(0, 100) || ""}-${error.route || ""}`;
+  }
+  async close() {
+    this.isClosed = true;
+    this.stopFlushTimer();
+    await this.flush();
+  }
+  enqueue(payload) {
+    if (this.queue.length >= this.maxQueueSize) {
+      console.warn("[MonitorClient] Queue full, dropping oldest error");
+      this.queue.shift();
+    }
+    this.queue.push(payload);
+    if (this.queue.length >= this.batchSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Fetch with timeout to prevent hanging requests
+   */
+  async fetchWithTimeout(url, options, timeoutMs = this.requestTimeoutMs) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        signal: controller.signal
+      });
+      return response;
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeoutMs}ms`);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async sendSingle(error) {
+    const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/errors`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(error)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+    }
+  }
+  async sendBatch(errors) {
+    const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/errors/batch`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({ errors })
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+    }
+  }
+  startFlushTimer() {
+    this.flushTimer = setInterval(() => {
+      this.flush();
+    }, this.flushIntervalMs);
+  }
+  stopFlushTimer() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  async syncDependencies() {
+    try {
+      if (this.dependencySources && this.dependencySources.length > 0) {
+        for (const source of this.dependencySources) {
+          const technologies = await this.readPackageJsonFromPath(source.path);
+          if (technologies.length === 0) continue;
+          await this.sendTechnologiesWithEnvironment(technologies, source.environment);
+        }
+      } else {
+        const technologies = await this.readPackageJson();
+        if (technologies.length === 0) return;
+        await this.sendTechnologies(technologies);
+      }
+    } catch (err) {
+      console.error("[MonitorClient] Failed to sync dependencies:", err);
+    }
+  }
+  async syncTechnologies(technologies) {
+    await this.sendTechnologies(technologies);
+  }
+  async readPackageJson() {
+    const packagePath = this.packageJsonPath || "package.json";
+    return this.readPackageJsonFromPath(packagePath);
+  }
+  async readPackageJsonFromPath(packagePath) {
+    if (typeof process === "undefined" || typeof process.cwd !== "function") {
+      return [];
+    }
+    try {
+      const fsModule = await import("fs");
+      const pathModule = await import("path");
+      const fs = fsModule.default || fsModule;
+      const path = pathModule.default || pathModule;
+      const baseDir = process.cwd();
+      const resolvedPath = path.isAbsolute(packagePath) ? packagePath : path.join(baseDir, packagePath);
+      const normalizedPath = path.normalize(resolvedPath);
+      const normalizedBase = path.normalize(baseDir);
+      if (!path.isAbsolute(packagePath)) {
+        if (!normalizedPath.startsWith(normalizedBase)) {
+          console.warn("[MonitorClient] Path traversal attempt blocked:", packagePath);
+          return [];
+        }
+      }
+      if (packagePath.includes("\0") || /\.\.[\\/]/.test(packagePath)) {
+        console.warn("[MonitorClient] Suspicious path blocked:", packagePath);
+        return [];
+      }
+      if (!normalizedPath.endsWith("package.json")) {
+        console.warn("[MonitorClient] Path must point to package.json");
+        return [];
+      }
+      if (!fs.existsSync(normalizedPath)) {
+        return [];
+      }
+      const packageJson = JSON.parse(fs.readFileSync(normalizedPath, "utf-8"));
+      const technologies = [];
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      for (const [name, version] of Object.entries(deps)) {
+        if (typeof version === "string") {
+          if (this.shouldExclude(name)) {
+            continue;
+          }
+          technologies.push({
+            name,
+            version: version.replace(/^[\^~]/, "")
+          });
+        }
+      }
+      return technologies;
+    } catch {
+      return [];
+    }
+  }
+  shouldExclude(packageName) {
+    for (const pattern of this.excludePatterns) {
+      const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+      if (new RegExp(`^${regexPattern}$`).test(packageName)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async sendTechnologies(technologies) {
+    await this.sendTechnologiesWithEnvironment(technologies, this.environment);
+  }
+  async sendTechnologiesWithEnvironment(technologies, environment) {
+    const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/technologies/sync`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        environment,
+        technologies
+      })
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+    }
+  }
+  /**
+   * Capture a security event (auth failures, rate limits, suspicious activity, etc.)
+   * Returns brute force warning if pattern is detected
+   */
+  async captureSecurityEvent(input) {
+    if (this.isClosed) return {};
+    const payload = {
+      ...input,
+      environment: this.environment
+    };
+    const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/security`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+    }
+    const result = await response.json();
+    return { warning: result.warning };
+  }
+  /**
+   * Capture a login failure event (convenience method)
+   */
+  async captureLoginFailure(options) {
+    return this.captureSecurityEvent({
+      eventType: `login_failed_${options.authMethod || "other"}`,
+      category: "AUTHENTICATION",
+      severity: "MEDIUM",
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { reason: options.reason, authMethod: options.authMethod }
+    });
+  }
+  /**
+   * Capture a successful login event
+   */
+  async captureLoginSuccess(options) {
+    await this.captureSecurityEvent({
+      eventType: `login_success_${options.authMethod || "other"}`,
+      category: "AUTHENTICATION",
+      severity: "LOW",
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { authMethod: options.authMethod }
+    });
+  }
+  /**
+   * Capture a rate limit event
+   */
+  async captureRateLimit(options) {
+    await this.captureSecurityEvent({
+      eventType: "rate_limit_exceeded",
+      category: "RATE_LIMIT",
+      severity: "MEDIUM",
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { limit: options.limit, window: options.window }
+    });
+  }
+  /**
+   * Capture an authorization failure (user tried to access unauthorized resource)
+   */
+  async captureAuthorizationFailure(options) {
+    await this.captureSecurityEvent({
+      eventType: "authorization_denied",
+      category: "AUTHORIZATION",
+      severity: "MEDIUM",
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { resource: options.resource, action: options.action }
+    });
+  }
+  /**
+   * Check if an IP or identifier has triggered brute force detection
+   */
+  async checkBruteForce(options) {
+    const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/security/detect/brute-force`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(options)
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+    }
+    const result = await response.json();
+    return result.data;
+  }
+  /**
+   * Run npm audit and send results to the monitoring server.
+   * This scans the project for known vulnerabilities in dependencies.
+   *
+   * @param options.projectPath - Path to the project directory (defaults to cwd)
+   * @param options.environment - Environment label (defaults to client environment)
+   * @returns Audit summary with vulnerability counts
+   */
+  async auditDependencies(options = {}) {
+    if (typeof require === "undefined") {
+      console.warn("[MonitorClient] auditDependencies only works in Node.js environment");
+      return null;
+    }
+    const startTime = Date.now();
+    const environment = options.environment || this.environment;
+    try {
+      const { execSync } = require("child_process");
+      const path = require("path");
+      const fs = require("fs");
+      let projectPath = options.projectPath || process.cwd();
+      if (projectPath.includes("\0") || /[;&|`$(){}[\]<>]/.test(projectPath)) {
+        console.error("[MonitorClient] Invalid projectPath: contains forbidden characters");
+        return null;
+      }
+      projectPath = path.resolve(projectPath);
+      try {
+        const stats = fs.statSync(projectPath);
+        if (!stats.isDirectory()) {
+          console.error("[MonitorClient] projectPath is not a directory");
+          return null;
+        }
+      } catch {
+        console.error("[MonitorClient] projectPath does not exist");
+        return null;
+      }
+      const packageJsonPath = path.join(projectPath, "package.json");
+      if (!fs.existsSync(packageJsonPath)) {
+        console.error("[MonitorClient] No package.json found in projectPath");
+        return null;
+      }
+      let auditOutput;
+      try {
+        auditOutput = execSync("npm audit --json", {
+          cwd: projectPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "pipe"],
+          maxBuffer: 10 * 1024 * 1024,
+          // 10MB buffer for large outputs
+          timeout: 6e4
+          // 60 second timeout
+        });
+      } catch (err) {
+        const execError = err;
+        if (execError.killed) {
+          console.error("[MonitorClient] npm audit timed out");
+          return null;
+        }
+        if (execError.stdout) {
+          auditOutput = execError.stdout;
+        } else {
+          throw err;
+        }
+      }
+      const auditData = JSON.parse(auditOutput);
+      const vulnerabilities = this.parseNpmAuditOutput(auditData);
+      const totalDeps = auditData.metadata?.dependencies?.total || 0;
+      const scanDurationMs = Date.now() - startTime;
+      const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/vulnerabilities/audit`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          environment,
+          totalDeps,
+          vulnerabilities,
+          scanDurationMs
+        })
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status}${errorText ? `: ${errorText}` : ""}`);
+      }
+      const result = await response.json();
+      return result.data;
+    } catch (err) {
+      console.error("[MonitorClient] Failed to audit dependencies:", err instanceof Error ? err.message : String(err));
+      return null;
+    }
+  }
+  /**
+   * Parse npm audit JSON output into vulnerability items
+   */
+  parseNpmAuditOutput(auditData) {
+    const vulnerabilities = [];
+    if (!auditData.vulnerabilities) {
+      return vulnerabilities;
+    }
+    for (const [packageName, vuln] of Object.entries(auditData.vulnerabilities)) {
+      const viaDetails = vuln.via.find(
+        (v) => typeof v === "object" && "title" in v
+      );
+      if (viaDetails) {
+        vulnerabilities.push({
+          packageName,
+          severity: vuln.severity.toLowerCase(),
+          title: viaDetails.title,
+          url: viaDetails.url,
+          vulnerableRange: viaDetails.range,
+          installedVersion: vuln.nodes?.[0]?.split("@").pop(),
+          patchedVersions: this.getFixVersion(vuln.fixAvailable),
+          path: vuln.nodes?.join(" > "),
+          recommendation: this.getRecommendation(vuln.fixAvailable),
+          cwe: viaDetails.cwe,
+          cvss: viaDetails.cvss?.score,
+          isFixable: Boolean(vuln.fixAvailable),
+          isDirect: vuln.isDirect
+        });
+      } else {
+        const viaNames = vuln.via.filter((v) => typeof v === "string");
+        vulnerabilities.push({
+          packageName,
+          severity: vuln.severity.toLowerCase(),
+          title: `Depends on vulnerable ${viaNames.join(", ")}`,
+          vulnerableRange: vuln.range,
+          path: vuln.nodes?.join(" > "),
+          isFixable: Boolean(vuln.fixAvailable),
+          isDirect: vuln.isDirect
+        });
+      }
+    }
+    return vulnerabilities;
+  }
+  getFixVersion(fixAvailable) {
+    if (typeof fixAvailable === "object" && fixAvailable !== null) {
+      return fixAvailable.version;
+    }
+    return void 0;
+  }
+  getRecommendation(fixAvailable) {
+    if (typeof fixAvailable === "object" && fixAvailable !== null) {
+      const majorWarning = fixAvailable.isSemVerMajor ? " (breaking change)" : "";
+      return `Update ${fixAvailable.name} to ${fixAvailable.version}${majorWarning}`;
+    } else if (fixAvailable === true) {
+      return "Run npm audit fix";
+    }
+    return "No fix available";
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MonitorClient
+});