@ceon-oy/monitor-sdk 1.0.6 → 1.0.7

package/dist/index.js

@@ -286,12 +286,12 @@ var MonitorClient = class {
   /**
    * Fetch with timeout to prevent hanging requests
    */
-  async fetchWithTimeout(url, options2, timeoutMs = this.requestTimeoutMs) {
+  async fetchWithTimeout(url, options, timeoutMs = this.requestTimeoutMs) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
       const response = await fetch(url, {
-        ...options2,
+        ...options,
         signal: controller.signal
       });
       return response;
@@ -374,13 +374,13 @@ var MonitorClient = class {
     try {
       const fsModule = await import("fs");
       const pathModule = await import("path");
-      const fs2 = fsModule.default || fsModule;
-      const path2 = pathModule.default || pathModule;
+      const fs = fsModule.default || fsModule;
+      const path = pathModule.default || pathModule;
       const baseDir = process.cwd();
-      const resolvedPath = path2.isAbsolute(packagePath) ? packagePath : path2.join(baseDir, packagePath);
-      const normalizedPath = path2.normalize(resolvedPath);
-      const normalizedBase = path2.normalize(baseDir);
-      if (!path2.isAbsolute(packagePath)) {
+      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 [];
@@ -394,10 +394,10 @@ var MonitorClient = class {
         console.warn("[MonitorClient] Path must point to package.json");
         return [];
       }
-      if (!fs2.existsSync(normalizedPath)) {
+      if (!fs.existsSync(normalizedPath)) {
         return [];
       }
-      const packageJson = JSON.parse(fs2.readFileSync(normalizedPath, "utf-8"));
+      const packageJson = JSON.parse(fs.readFileSync(normalizedPath, "utf-8"));
       const technologies = [];
       const deps = {
         ...packageJson.dependencies,
@@ -431,7 +431,7 @@ var MonitorClient = class {
   async sendTechnologies(technologies) {
     await this.sendTechnologiesWithEnvironment(technologies, this.environment);
   }
-  async sendTechnologiesWithEnvironment(technologies, environment2) {
+  async sendTechnologiesWithEnvironment(technologies, environment) {
     const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/technologies/sync`, {
       method: "POST",
       headers: {
@@ -439,7 +439,7 @@ var MonitorClient = class {
         Authorization: `Bearer ${this.apiKey}`
       },
       body: JSON.stringify({
-        environment: environment2,
+        environment,
         technologies
       })
     });
@@ -476,74 +476,74 @@ var MonitorClient = class {
   /**
    * Capture a login failure event (convenience method)
    */
-  async captureLoginFailure(options2) {
+  async captureLoginFailure(options) {
     return this.captureSecurityEvent({
-      eventType: `login_failed_${options2.authMethod || "other"}`,
+      eventType: `login_failed_${options.authMethod || "other"}`,
       category: "AUTHENTICATION",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { reason: options2.reason, authMethod: options2.authMethod }
+      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(options2) {
+  async captureLoginSuccess(options) {
     await this.captureSecurityEvent({
-      eventType: `login_success_${options2.authMethod || "other"}`,
+      eventType: `login_success_${options.authMethod || "other"}`,
       category: "AUTHENTICATION",
       severity: "LOW",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { authMethod: options2.authMethod }
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { authMethod: options.authMethod }
     });
   }
   /**
    * Capture a rate limit event
    */
-  async captureRateLimit(options2) {
+  async captureRateLimit(options) {
     await this.captureSecurityEvent({
       eventType: "rate_limit_exceeded",
       category: "RATE_LIMIT",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { limit: options2.limit, window: options2.window }
+      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(options2) {
+  async captureAuthorizationFailure(options) {
     await this.captureSecurityEvent({
       eventType: "authorization_denied",
       category: "AUTHORIZATION",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { resource: options2.resource, action: options2.action }
+      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(options2) {
+  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(options2)
+      body: JSON.stringify(options)
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => "");
@@ -569,10 +569,12 @@ var MonitorClient = class {
     let path;
     let fs;
     try {
-      const _require = eval("require");
-      execSync = _require("child_process").execSync;
-      path = _require("path");
-      fs = _require("fs");
+      const childProcess = await import("child_process");
+      const pathModule = await import("path");
+      const fsModule = await import("fs");
+      execSync = childProcess.execSync;
+      path = pathModule;
+      fs = fsModule;
     } catch {
       console.warn("[MonitorClient] auditDependencies requires Node.js (not available in bundled/browser environments)");
       return null;

package/dist/index.mjs

@@ -250,12 +250,12 @@ var MonitorClient = class {
   /**
    * Fetch with timeout to prevent hanging requests
    */
-  async fetchWithTimeout(url, options2, timeoutMs = this.requestTimeoutMs) {
+  async fetchWithTimeout(url, options, timeoutMs = this.requestTimeoutMs) {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
     try {
       const response = await fetch(url, {
-        ...options2,
+        ...options,
         signal: controller.signal
       });
       return response;
@@ -338,13 +338,13 @@ var MonitorClient = class {
     try {
       const fsModule = await import("fs");
       const pathModule = await import("path");
-      const fs2 = fsModule.default || fsModule;
-      const path2 = pathModule.default || pathModule;
+      const fs = fsModule.default || fsModule;
+      const path = pathModule.default || pathModule;
       const baseDir = process.cwd();
-      const resolvedPath = path2.isAbsolute(packagePath) ? packagePath : path2.join(baseDir, packagePath);
-      const normalizedPath = path2.normalize(resolvedPath);
-      const normalizedBase = path2.normalize(baseDir);
-      if (!path2.isAbsolute(packagePath)) {
+      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 [];
@@ -358,10 +358,10 @@ var MonitorClient = class {
         console.warn("[MonitorClient] Path must point to package.json");
         return [];
       }
-      if (!fs2.existsSync(normalizedPath)) {
+      if (!fs.existsSync(normalizedPath)) {
         return [];
       }
-      const packageJson = JSON.parse(fs2.readFileSync(normalizedPath, "utf-8"));
+      const packageJson = JSON.parse(fs.readFileSync(normalizedPath, "utf-8"));
       const technologies = [];
       const deps = {
         ...packageJson.dependencies,
@@ -395,7 +395,7 @@ var MonitorClient = class {
   async sendTechnologies(technologies) {
     await this.sendTechnologiesWithEnvironment(technologies, this.environment);
   }
-  async sendTechnologiesWithEnvironment(technologies, environment2) {
+  async sendTechnologiesWithEnvironment(technologies, environment) {
     const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/technologies/sync`, {
       method: "POST",
       headers: {
@@ -403,7 +403,7 @@ var MonitorClient = class {
         Authorization: `Bearer ${this.apiKey}`
       },
       body: JSON.stringify({
-        environment: environment2,
+        environment,
         technologies
       })
     });
@@ -440,74 +440,74 @@ var MonitorClient = class {
   /**
    * Capture a login failure event (convenience method)
    */
-  async captureLoginFailure(options2) {
+  async captureLoginFailure(options) {
     return this.captureSecurityEvent({
-      eventType: `login_failed_${options2.authMethod || "other"}`,
+      eventType: `login_failed_${options.authMethod || "other"}`,
       category: "AUTHENTICATION",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { reason: options2.reason, authMethod: options2.authMethod }
+      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(options2) {
+  async captureLoginSuccess(options) {
     await this.captureSecurityEvent({
-      eventType: `login_success_${options2.authMethod || "other"}`,
+      eventType: `login_success_${options.authMethod || "other"}`,
       category: "AUTHENTICATION",
       severity: "LOW",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { authMethod: options2.authMethod }
+      ip: options.ip,
+      identifier: options.identifier,
+      endpoint: options.endpoint,
+      userAgent: options.userAgent,
+      metadata: { authMethod: options.authMethod }
     });
   }
   /**
    * Capture a rate limit event
    */
-  async captureRateLimit(options2) {
+  async captureRateLimit(options) {
     await this.captureSecurityEvent({
       eventType: "rate_limit_exceeded",
       category: "RATE_LIMIT",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { limit: options2.limit, window: options2.window }
+      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(options2) {
+  async captureAuthorizationFailure(options) {
     await this.captureSecurityEvent({
       eventType: "authorization_denied",
       category: "AUTHORIZATION",
       severity: "MEDIUM",
-      ip: options2.ip,
-      identifier: options2.identifier,
-      endpoint: options2.endpoint,
-      userAgent: options2.userAgent,
-      metadata: { resource: options2.resource, action: options2.action }
+      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(options2) {
+  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(options2)
+      body: JSON.stringify(options)
     });
     if (!response.ok) {
       const errorText = await response.text().catch(() => "");
@@ -533,10 +533,12 @@ var MonitorClient = class {
     let path;
     let fs;
     try {
-      const _require = eval("require");
-      execSync = _require("child_process").execSync;
-      path = _require("path");
-      fs = _require("fs");
+      const childProcess = await import("child_process");
+      const pathModule = await import("path");
+      const fsModule = await import("fs");
+      execSync = childProcess.execSync;
+      path = pathModule;
+      fs = fsModule;
     } catch {
       console.warn("[MonitorClient] auditDependencies requires Node.js (not available in bundled/browser environments)");
       return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceon-oy/monitor-sdk",
-  "version": "1.0.6",
+  "version": "1.0.7",
   "description": "Client SDK for Ceon Monitor - Error tracking, health monitoring, security events, and vulnerability scanning",
   "author": "Ceon",
   "license": "MIT",