@ceon-oy/monitor-sdk 1.2.1 → 1.4.0

package/README.md

@@ -1,6 +1,6 @@
 # Ceon Monitor SDK
 
-Lightweight client SDK for integrating with the Ceon Monitor service. Provides error reporting, technology tracking, vulnerability auditing, and security event monitoring.
+Lightweight client SDK for integrating with the Ceon Monitor service. Provides error reporting, technology tracking, vulnerability auditing, system metrics collection (CPU, RAM, disk), and security event monitoring.
 
 ## Table of Contents
 
@@ -12,6 +12,7 @@ Lightweight client SDK for integrating with the Ceon Monitor service. Provides e
   - [Technology Tracking](#technology-tracking)
   - [Vulnerability Auditing](#vulnerability-auditing)
   - [SDK-Based Health Checks](#sdk-based-health-checks)
+  - [System Metrics](#system-metrics)
   - [Security Events](#security-events)
 - [Framework Examples](#framework-examples)
   - [Express.js](#expressjs)
@@ -490,6 +491,75 @@ const results = [
 await monitor.submitHealthResults(results);
 ```
 
+### System Metrics
+
+The SDK automatically collects and reports server resource usage — CPU, RAM, and disk — to Ceon Monitor. No SDK configuration flag is needed; the feature activates based on the project settings configured in the Ceon Monitor dashboard.
+
+#### How It Works
+
+When the `MonitorClient` is created, it fetches your project settings from the server. If the project has **Enable Metric Collection** turned on, the SDK:
+
+1. Reads `metricsIntervalSeconds` from project settings (configured in the dashboard)
+2. Reads `metricsDiskPaths` from project settings (e.g. `["/", "/data"]`)
+3. Starts collecting metrics at that interval automatically
+4. POSTs metrics to the server — no manual calls needed
+
+#### What Is Collected
+
+| Metric | Method | Notes |
+|--------|--------|-------|
+| CPU usage % | Dual `os.cpus()` sample with 500 ms gap | Accurate active-cycle average |
+| RAM total | `os.totalmem()` | Bytes |
+| RAM used | `os.totalmem() - os.freemem()` | Bytes |
+| RAM % | `usedMemory / totalMemory * 100` | |
+| Disk total / used / free per path | `fs.statfs(path)` | Node.js 18.15+ built-in, zero external deps |
+
+Hostname is automatically set via `os.hostname()` and included with every report.
+
+#### Enable in Dashboard
+
+1. Open the **Ceon Monitor** dashboard
+2. Go to **Projects** and click **Edit** on your project
+3. Enable the **System Metrics** widget
+4. Click **Enable Metric Collection**
+5. Set the collection interval (e.g. every 60 seconds)
+6. Add disk paths to monitor (e.g. `/` for root, `/data` for a data volume)
+7. Configure CPU / RAM / disk alert thresholds
+8. Save
+
+The SDK will pick up the new settings on its next startup.
+
+#### Notifications
+
+When a metric exceeds a configured threshold, Ceon Monitor sends a `SYSTEM_METRIC_CRITICAL` notification to any user who has subscribed to **System Metric Alerts** for that project. Subscribe in **Settings → Subscriptions**.
+
+#### Node.js Version Requirement
+
+`fs.statfs()` (used for disk monitoring) requires **Node.js 18.15 or later**. No external packages are needed.
+
+#### Manual Metric Submission
+
+You can also submit a metric reading manually:
+
+```typescript
+await monitor.submitSystemMetric({
+  hostname: os.hostname(),
+  cpuPercent: 72.5,
+  memoryTotal: 8 * 1024 ** 3,   // 8 GB in bytes
+  memoryUsed:  5 * 1024 ** 3,   // 5 GB in bytes
+  memoryPercent: 62.5,
+  disks: [
+    {
+      path: '/',
+      total: 100 * 1024 ** 3,   // 100 GB
+      used:   60 * 1024 ** 3,   // 60 GB
+      free:   40 * 1024 ** 3,   // 40 GB
+      usedPercent: 60,
+    },
+  ],
+});
+```
+
 ### Security Events
 
 #### Report Security Event
@@ -1092,6 +1162,10 @@ Runs npm audit and sends results to the server.
 
 Runs npm audit on all directories configured in `auditPaths` and returns a combined summary.
 
+#### `submitSystemMetric(metric: SystemMetric): Promise<void>`
+
+Manually submits a system metric reading. Under normal usage this is called automatically by the SDK's internal collection loop — use this only if you need custom collection logic.
+
 #### `flush(): Promise<void>`
 
 Immediately sends all queued errors.
@@ -1160,6 +1234,23 @@ interface AuditPath {
   environment: string; // Environment label (e.g., 'server', 'client')
 }
 
+interface DiskMetric {
+  path: string;        // Mount path (e.g. '/', '/data')
+  total: number;       // Total bytes
+  used: number;        // Used bytes
+  free: number;        // Free bytes
+  usedPercent: number; // 0–100
+}
+
+interface SystemMetric {
+  hostname: string;
+  cpuPercent: number;
+  memoryTotal: number;
+  memoryUsed: number;
+  memoryPercent: number;
+  disks: DiskMetric[];
+}
+
 interface MultiAuditSummary {
   results: Array<{
     environment: string;

package/dist/index.d.mts

@@ -53,7 +53,7 @@ interface MonitorClientConfig {
     allowInsecureHttp?: boolean;
     /** Custom npm registry URL for fetching latest versions (default: https://registry.npmjs.org) */
     npmRegistryUrl?: string;
-    /** Enable SDK-based health check polling (default: false) */
+    /** Enable SDK-based health check polling (default: true) */
     healthCheckEnabled?: boolean;
     /** Interval to fetch health endpoints from server in ms (default: 60000) */
     healthCheckFetchIntervalMs?: number;
@@ -166,6 +166,7 @@ interface SdkHealthEndpoint {
     intervalMs: number;
     timeoutMs: number;
     expectedStatus: number;
+    allowInsecureTls?: boolean;
 }
 interface SdkHealthResult {
     endpointId: string;
@@ -226,6 +227,12 @@ declare class MonitorClient {
     private healthCheckTimers;
     private healthCheckResultsQueue;
     private healthCheckFlushTimer;
+    private sdkErrorQueue;
+    private sdkErrorFlushTimer;
+    private sdkErrorsInCurrentWindow;
+    private sdkErrorWindowResetTimer;
+    private metricsCollectionTimer;
+    private metricsSettingsCheckTimer;
     constructor(config: MonitorClientConfig);
     /**
      * Security: Validate and sanitize metadata to prevent oversized payloads
@@ -253,6 +260,15 @@ declare class MonitorClient {
     flush(): Promise<void>;
     private getErrorKey;
     close(): Promise<void>;
+    /**
+     * Queue an SDK error to be reported to the server's system errors page.
+     * Fire-and-forget — never throws. If reporting itself fails, logs to console only.
+     * Throttled to max 20 errors per minute to prevent flooding.
+     */
+    private reportError;
+    private startSdkErrorFlushTimer;
+    private stopSdkErrorFlushTimer;
+    private flushSdkErrors;
     private stopAuditIntervalTimer;
     /**
      * Fetch project settings from the monitoring server.
@@ -263,6 +279,12 @@ declare class MonitorClient {
         vulnerabilityScanIntervalHours: number;
         scanRequestedAt: string | null;
         techScanRequestedAt: string | null;
+        metricsEnabled?: boolean;
+        metricsIntervalSeconds?: number;
+        metricsDiskPaths?: string[];
+        metricsCpuThreshold?: number;
+        metricsRamThreshold?: number;
+        metricsDiskThreshold?: number;
     } | null>;
     /**
      * Setup automatic vulnerability scanning based on server-configured interval.
@@ -465,6 +487,47 @@ declare class MonitorClient {
      * Stop all health check timers
      */
     private stopHealthCheckTimers;
+    /**
+     * Start system metrics collection based on server-configured settings.
+     * Only runs if metricsEnabled is true in project settings.
+     * Collects CPU, RAM, and disk usage using built-in Node.js modules.
+     */
+    setupSystemMetricsCollection(): Promise<void>;
+    private startMetricsCollection;
+    private stopMetricsCollection;
+    /**
+     * Collect system metrics (CPU, RAM, disk) using built-in Node.js modules
+     * and submit to the monitoring server.
+     *
+     * Uses: os.cpus(), os.totalmem(), os.freemem(), os.hostname(), fs.statfs()
+     * Zero dependencies — all built-in Node.js 18.15+
+     */
+    private collectAndSubmitMetrics;
+    /**
+     * Measure CPU utilization by sampling cpus() twice with a 500ms gap.
+     * Returns a percentage (0–100).
+     */
+    private measureCpuPercent;
+    /**
+     * Collect disk usage for each configured path using fs.statfs() (Node 18.15+).
+     */
+    private collectDiskMetrics;
+    /**
+     * Submit a system metric snapshot to the monitoring server.
+     */
+    submitSystemMetric(metric: {
+        hostname: string;
+        cpuPercent: number;
+        memoryTotal: number;
+        memoryUsed: number;
+        memoryPercent: number;
+        disks: Array<{
+            path: string;
+            total: number;
+            used: number;
+            percent: number;
+        }>;
+    }): Promise<void>;
 }
 
 export { type AuditPath, type AuditResult, type AuditSummary, type BruteForceDetectionResult, type DependencySource, type ErrorContext, type ErrorPayload, type HealthStatus, MonitorClient, type MonitorClientConfig, type MultiAuditSummary, type SdkHealthEndpoint, type SdkHealthEndpointsResponse, type SdkHealthResult, type SdkHealthResultsResponse, type SecurityCategory, type SecurityEventInput, type SecurityEventPayload, type SecuritySeverity, type Severity, type TechnologyItem, type TechnologyType, type VulnerabilityItem, type VulnerabilitySeverity };

package/dist/index.d.ts

@@ -53,7 +53,7 @@ interface MonitorClientConfig {
     allowInsecureHttp?: boolean;
     /** Custom npm registry URL for fetching latest versions (default: https://registry.npmjs.org) */
     npmRegistryUrl?: string;
-    /** Enable SDK-based health check polling (default: false) */
+    /** Enable SDK-based health check polling (default: true) */
     healthCheckEnabled?: boolean;
     /** Interval to fetch health endpoints from server in ms (default: 60000) */
     healthCheckFetchIntervalMs?: number;
@@ -166,6 +166,7 @@ interface SdkHealthEndpoint {
     intervalMs: number;
     timeoutMs: number;
     expectedStatus: number;
+    allowInsecureTls?: boolean;
 }
 interface SdkHealthResult {
     endpointId: string;
@@ -226,6 +227,12 @@ declare class MonitorClient {
     private healthCheckTimers;
     private healthCheckResultsQueue;
     private healthCheckFlushTimer;
+    private sdkErrorQueue;
+    private sdkErrorFlushTimer;
+    private sdkErrorsInCurrentWindow;
+    private sdkErrorWindowResetTimer;
+    private metricsCollectionTimer;
+    private metricsSettingsCheckTimer;
     constructor(config: MonitorClientConfig);
     /**
      * Security: Validate and sanitize metadata to prevent oversized payloads
@@ -253,6 +260,15 @@ declare class MonitorClient {
     flush(): Promise<void>;
     private getErrorKey;
     close(): Promise<void>;
+    /**
+     * Queue an SDK error to be reported to the server's system errors page.
+     * Fire-and-forget — never throws. If reporting itself fails, logs to console only.
+     * Throttled to max 20 errors per minute to prevent flooding.
+     */
+    private reportError;
+    private startSdkErrorFlushTimer;
+    private stopSdkErrorFlushTimer;
+    private flushSdkErrors;
     private stopAuditIntervalTimer;
     /**
      * Fetch project settings from the monitoring server.
@@ -263,6 +279,12 @@ declare class MonitorClient {
         vulnerabilityScanIntervalHours: number;
         scanRequestedAt: string | null;
         techScanRequestedAt: string | null;
+        metricsEnabled?: boolean;
+        metricsIntervalSeconds?: number;
+        metricsDiskPaths?: string[];
+        metricsCpuThreshold?: number;
+        metricsRamThreshold?: number;
+        metricsDiskThreshold?: number;
     } | null>;
     /**
      * Setup automatic vulnerability scanning based on server-configured interval.
@@ -465,6 +487,47 @@ declare class MonitorClient {
      * Stop all health check timers
      */
     private stopHealthCheckTimers;
+    /**
+     * Start system metrics collection based on server-configured settings.
+     * Only runs if metricsEnabled is true in project settings.
+     * Collects CPU, RAM, and disk usage using built-in Node.js modules.
+     */
+    setupSystemMetricsCollection(): Promise<void>;
+    private startMetricsCollection;
+    private stopMetricsCollection;
+    /**
+     * Collect system metrics (CPU, RAM, disk) using built-in Node.js modules
+     * and submit to the monitoring server.
+     *
+     * Uses: os.cpus(), os.totalmem(), os.freemem(), os.hostname(), fs.statfs()
+     * Zero dependencies — all built-in Node.js 18.15+
+     */
+    private collectAndSubmitMetrics;
+    /**
+     * Measure CPU utilization by sampling cpus() twice with a 500ms gap.
+     * Returns a percentage (0–100).
+     */
+    private measureCpuPercent;
+    /**
+     * Collect disk usage for each configured path using fs.statfs() (Node 18.15+).
+     */
+    private collectDiskMetrics;
+    /**
+     * Submit a system metric snapshot to the monitoring server.
+     */
+    submitSystemMetric(metric: {
+        hostname: string;
+        cpuPercent: number;
+        memoryTotal: number;
+        memoryUsed: number;
+        memoryPercent: number;
+        disks: Array<{
+            path: string;
+            total: number;
+            used: number;
+            percent: number;
+        }>;
+    }): Promise<void>;
 }
 
 export { type AuditPath, type AuditResult, type AuditSummary, type BruteForceDetectionResult, type DependencySource, type ErrorContext, type ErrorPayload, type HealthStatus, MonitorClient, type MonitorClientConfig, type MultiAuditSummary, type SdkHealthEndpoint, type SdkHealthEndpointsResponse, type SdkHealthResult, type SdkHealthResultsResponse, type SecurityCategory, type SecurityEventInput, type SecurityEventPayload, type SecuritySeverity, type Severity, type TechnologyItem, type TechnologyType, type VulnerabilityItem, type VulnerabilitySeverity };

package/dist/index.js

@@ -94,6 +94,14 @@ var MonitorClient = class {
     this.healthCheckTimers = /* @__PURE__ */ new Map();
     this.healthCheckResultsQueue = [];
     this.healthCheckFlushTimer = null;
+    // SDK error reporting queue (errors visible on admin system errors page)
+    this.sdkErrorQueue = [];
+    this.sdkErrorFlushTimer = null;
+    this.sdkErrorsInCurrentWindow = 0;
+    this.sdkErrorWindowResetTimer = null;
+    // System metrics collection (on-premise only, opt-in)
+    this.metricsCollectionTimer = null;
+    this.metricsSettingsCheckTimer = null;
     if (!config.apiKey || config.apiKey.trim().length === 0) {
       throw new Error("[MonitorClient] API key is required");
     }
@@ -153,24 +161,28 @@ var MonitorClient = class {
     this.auditTimeoutMs = Math.min(CONFIG_LIMITS.MAX_AUDIT_TIMEOUT_MS, Math.max(1e3, config.auditTimeoutMs || CONFIG_LIMITS.AUDIT_TIMEOUT_MS));
     this.registryTimeoutMs = Math.min(CONFIG_LIMITS.MAX_REGISTRY_TIMEOUT_MS, Math.max(1e3, config.registryTimeoutMs || CONFIG_LIMITS.REGISTRY_TIMEOUT_MS));
     this.npmRegistryUrl = (config.npmRegistryUrl || "https://registry.npmjs.org").replace(/\/$/, "");
-    this.healthCheckEnabled = config.healthCheckEnabled || false;
+    this.healthCheckEnabled = config.healthCheckEnabled ?? true;
     this.healthCheckFetchIntervalMs = config.healthCheckFetchIntervalMs || CONFIG_LIMITS.HEALTH_CHECK_FETCH_INTERVAL_MS;
     this.startFlushTimer();
     if (this.trackDependencies) {
       this.syncDependencies().catch((err) => {
-        console.error("[MonitorClient] Failed to sync dependencies:", err instanceof Error ? err.message : String(err));
+        this.reportError("DEPENDENCY_SYNC", "Failed to sync dependencies on startup", err);
       });
     }
     if (this.autoAudit) {
       this.setupAutoAudit().catch((err) => {
-        console.error("[MonitorClient] Failed to setup auto audit:", err instanceof Error ? err.message : String(err));
+        this.reportError("AUDIT_SETUP", "Failed to setup auto audit", err);
       });
     }
     if (this.healthCheckEnabled) {
       this.setupHealthCheckPolling().catch((err) => {
-        console.error("[MonitorClient] Failed to setup health check polling:", err instanceof Error ? err.message : String(err));
+        this.reportError("HEALTH_POLLING_SETUP", "Failed to setup health check polling", err);
       });
     }
+    this.startSdkErrorFlushTimer();
+    this.setupSystemMetricsCollection().catch((err) => {
+      this.reportError("SYSTEM_METRICS_SETUP", "Failed to setup system metrics collection", err);
+    });
   }
   /**
    * Security: Validate and sanitize metadata to prevent oversized payloads
@@ -320,8 +332,66 @@ var MonitorClient = class {
     this.stopFlushTimer();
     this.stopAuditIntervalTimer();
     this.stopHealthCheckTimers();
+    this.stopSdkErrorFlushTimer();
+    this.stopMetricsCollection();
     await this.flush();
     await this.flushHealthResults();
+    await this.flushSdkErrors();
+  }
+  /**
+   * Queue an SDK error to be reported to the server's system errors page.
+   * Fire-and-forget — never throws. If reporting itself fails, logs to console only.
+   * Throttled to max 20 errors per minute to prevent flooding.
+   */
+  reportError(category, message, err) {
+    if (this.sdkErrorsInCurrentWindow >= 20) return;
+    this.sdkErrorsInCurrentWindow++;
+    const errorMessage = err instanceof Error ? `${message}: ${err.message}` : message;
+    const stack = err instanceof Error ? err.stack : void 0;
+    this.sdkErrorQueue.push({ category, message: errorMessage, stack });
+    if (this.sdkErrorQueue.length >= 20) {
+      this.flushSdkErrors().catch(() => {
+      });
+    }
+  }
+  startSdkErrorFlushTimer() {
+    this.sdkErrorFlushTimer = setInterval(() => {
+      this.flushSdkErrors().catch(() => {
+      });
+    }, 3e4);
+    this.sdkErrorWindowResetTimer = setInterval(() => {
+      this.sdkErrorsInCurrentWindow = 0;
+    }, 6e4);
+  }
+  stopSdkErrorFlushTimer() {
+    if (this.sdkErrorFlushTimer) {
+      clearInterval(this.sdkErrorFlushTimer);
+      this.sdkErrorFlushTimer = null;
+    }
+    if (this.sdkErrorWindowResetTimer) {
+      clearInterval(this.sdkErrorWindowResetTimer);
+      this.sdkErrorWindowResetTimer = null;
+    }
+  }
+  async flushSdkErrors() {
+    if (this.sdkErrorQueue.length === 0) return;
+    const errors = [...this.sdkErrorQueue];
+    this.sdkErrorQueue = [];
+    try {
+      const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/sdk-errors`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ errors })
+      });
+      if (!response.ok) {
+        console.warn(`[MonitorClient] Failed to report SDK errors: HTTP ${response.status}`);
+      }
+    } catch (err) {
+      console.warn("[MonitorClient] Failed to flush SDK errors to server:", err instanceof Error ? err.message : String(err));
+    }
   }
   stopAuditIntervalTimer() {
     if (this.auditIntervalTimer) {
@@ -383,14 +453,14 @@ var MonitorClient = class {
       const intervalMs = intervalHours * 60 * 60 * 1e3;
       this.auditIntervalTimer = setInterval(() => {
         this.runScanAndTrackTime().catch((err) => {
-          console.error("[MonitorClient] Auto audit scan failed:", err);
+          this.reportError("AUDIT_SCAN", "Auto audit scan failed", err);
         });
       }, intervalMs);
     }
     console.log("[MonitorClient] Polling for scan requests enabled (every 5 minutes)");
     this.settingsPollingTimer = setInterval(() => {
       this.checkForScanRequest().catch((err) => {
-        console.error("[MonitorClient] Scan request check failed:", err);
+        this.reportError("SETTINGS_POLL", "Scan request check failed", err);
       });
     }, CONFIG_LIMITS.SETTINGS_POLL_INTERVAL_MS);
   }
@@ -411,7 +481,7 @@ var MonitorClient = class {
       const duration = Date.now() - startTime;
       console.log(`[MonitorClient] Vulnerability scan completed in ${duration}ms`);
     } catch (err) {
-      console.error("[MonitorClient] Vulnerability scan failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Vulnerability scan failed", err);
     }
   }
   /**
@@ -438,7 +508,7 @@ var MonitorClient = class {
         }
       }
     } catch (err) {
-      console.error("[MonitorClient] Failed to check for scan request:", err instanceof Error ? err.message : String(err));
+      this.reportError("SETTINGS_POLL", "Failed to check for scan request", err);
     }
   }
   enqueue(payload) {
@@ -525,7 +595,7 @@ var MonitorClient = class {
       );
       console.log("[MonitorClient] Technology sync completed successfully");
     } catch (err) {
-      console.error("[MonitorClient] Technology sync failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("DEPENDENCY_SYNC", "Technology sync failed", err);
     }
   }
   async performDependencySync(signal) {
@@ -1029,7 +1099,7 @@ var MonitorClient = class {
       const result = await response.json();
       return result.data;
     } catch (err) {
-      console.error("[MonitorClient] Failed to audit dependencies:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Failed to audit dependencies", err);
       return null;
     }
   }
@@ -1059,7 +1129,7 @@ var MonitorClient = class {
       }
       return result;
     } catch (err) {
-      console.error("[MonitorClient] Multi-path audit failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Multi-path audit failed", err);
       return null;
     }
   }
@@ -1278,6 +1348,19 @@ var MonitorClient = class {
           "Content-Type": "application/json"
         };
       }
+      if (endpoint.allowInsecureTls) {
+        try {
+          const undici = await import(
+            /* webpackIgnore: true */
+            "undici"
+          );
+          const Agent = undici.Agent;
+          requestOptions.dispatcher = new Agent({
+            connect: { rejectUnauthorized: false }
+          });
+        } catch {
+        }
+      }
       const response = await this.fetchWithTimeout(
         endpoint.url,
         requestOptions,
@@ -1321,12 +1404,12 @@ var MonitorClient = class {
     await this.fetchAndScheduleHealthChecks();
     this.healthCheckFetchTimer = setInterval(() => {
       this.fetchAndScheduleHealthChecks().catch((err) => {
-        console.error("[MonitorClient] Failed to fetch and schedule health checks:", err);
+        this.reportError("HEALTH_ENDPOINT_FETCH", "Failed to fetch and schedule health checks", err);
       });
     }, this.healthCheckFetchIntervalMs);
     this.healthCheckFlushTimer = setInterval(() => {
       this.flushHealthResults().catch((err) => {
-        console.error("[MonitorClient] Failed to flush health results:", err);
+        this.reportError("HEALTH_RESULTS_FLUSH", "Failed to flush health results", err);
       });
     }, CONFIG_LIMITS.HEALTH_CHECK_FLUSH_INTERVAL_MS);
   }
@@ -1347,7 +1430,7 @@ var MonitorClient = class {
         this.scheduleHealthCheck(endpoint);
       }
     } catch (err) {
-      console.error("[MonitorClient] Failed to fetch health endpoints:", err);
+      this.reportError("HEALTH_ENDPOINT_FETCH", "Failed to fetch health endpoints from server", err);
     }
   }
   /**
@@ -1356,11 +1439,11 @@ var MonitorClient = class {
   scheduleHealthCheck(endpoint) {
     const intervalMs = Math.max(CONFIG_LIMITS.HEALTH_CHECK_MIN_INTERVAL_MS, endpoint.intervalMs);
     this.runHealthCheck(endpoint).catch((err) => {
-      console.error(`[MonitorClient] Health check failed for ${endpoint.name}:`, err);
+      this.reportError("HEALTH_CHECK", `Health check failed for ${endpoint.name}`, err);
     });
     const timer = setInterval(() => {
       this.runHealthCheck(endpoint).catch((err) => {
-        console.error(`[MonitorClient] Health check failed for ${endpoint.name}:`, err);
+        this.reportError("HEALTH_CHECK", `Health check failed for ${endpoint.name}`, err);
       });
     }, intervalMs);
     this.healthCheckTimers.set(endpoint.id, timer);
@@ -1386,7 +1469,7 @@ var MonitorClient = class {
       const response = await this.submitHealthResults(results);
       console.log(`[MonitorClient] Submitted ${response.processed}/${response.total} health check results`);
     } catch (err) {
-      console.error("[MonitorClient] Failed to flush health results:", err);
+      this.reportError("HEALTH_RESULTS_FLUSH", "Failed to submit health check results to server", err);
       if (this.healthCheckResultsQueue.length + results.length <= CONFIG_LIMITS.HEALTH_CHECK_MAX_BATCH_SIZE) {
         this.healthCheckResultsQueue.unshift(...results);
       }
@@ -1409,6 +1492,171 @@ var MonitorClient = class {
       this.healthCheckTimers.delete(endpointId);
     }
   }
+  // ---- System Metrics (on-premise only) ----
+  /**
+   * Start system metrics collection based on server-configured settings.
+   * Only runs if metricsEnabled is true in project settings.
+   * Collects CPU, RAM, and disk usage using built-in Node.js modules.
+   */
+  async setupSystemMetricsCollection() {
+    const settings = await this.fetchProjectSettings();
+    if (!settings?.metricsEnabled) {
+      this.metricsSettingsCheckTimer = setInterval(() => {
+        this.fetchProjectSettings().then((latestSettings) => {
+          if (latestSettings?.metricsEnabled) {
+            clearInterval(this.metricsSettingsCheckTimer);
+            this.metricsSettingsCheckTimer = null;
+            this.startMetricsCollection(latestSettings);
+          }
+        }).catch(() => {
+        });
+      }, 3e5);
+      return;
+    }
+    this.startMetricsCollection(settings);
+  }
+  startMetricsCollection(settings) {
+    const intervalMs = Math.max(3e4, (settings.metricsIntervalSeconds ?? 3600) * 1e3);
+    console.log(`[MonitorClient] System metrics collection enabled (every ${intervalMs / 1e3}s)`);
+    const initialDiskPaths = settings.metricsDiskPaths ?? ["/"];
+    this.collectAndSubmitMetrics(initialDiskPaths).catch((err) => {
+      this.reportError("SYSTEM_METRICS", "Initial system metrics collection failed", err);
+    });
+    this.metricsCollectionTimer = setInterval(() => {
+      this.fetchProjectSettings().then((latestSettings) => {
+        if (!latestSettings?.metricsEnabled) return;
+        const diskPaths = latestSettings.metricsDiskPaths ?? ["/"];
+        return this.collectAndSubmitMetrics(diskPaths);
+      }).catch((err) => {
+        this.reportError("SYSTEM_METRICS", "Scheduled system metrics collection failed", err);
+      });
+    }, intervalMs);
+  }
+  stopMetricsCollection() {
+    if (this.metricsCollectionTimer) {
+      clearInterval(this.metricsCollectionTimer);
+      this.metricsCollectionTimer = null;
+    }
+    if (this.metricsSettingsCheckTimer) {
+      clearInterval(this.metricsSettingsCheckTimer);
+      this.metricsSettingsCheckTimer = null;
+    }
+  }
+  /**
+   * Collect system metrics (CPU, RAM, disk) using built-in Node.js modules
+   * and submit to the monitoring server.
+   *
+   * Uses: os.cpus(), os.totalmem(), os.freemem(), os.hostname(), fs.statfs()
+   * Zero dependencies — all built-in Node.js 18.15+
+   */
+  async collectAndSubmitMetrics(diskPaths) {
+    if (typeof window !== "undefined" || typeof document !== "undefined") {
+      return;
+    }
+    let os;
+    let fs;
+    try {
+      const osModule = await import(
+        /* webpackIgnore: true */
+        "os"
+      );
+      const fsModule = await import(
+        /* webpackIgnore: true */
+        "fs/promises"
+      );
+      os = osModule;
+      fs = fsModule;
+    } catch {
+      this.reportError("SYSTEM_METRICS", "System metrics require Node.js (not available in bundled/browser environments)");
+      return;
+    }
+    try {
+      const hostname = os.hostname();
+      const cpuPercent = await this.measureCpuPercent(os);
+      const memoryTotal = os.totalmem();
+      const memoryFree = os.freemem();
+      const memoryUsed = memoryTotal - memoryFree;
+      const memoryPercent = memoryTotal > 0 ? memoryUsed / memoryTotal * 100 : 0;
+      const disks = await this.collectDiskMetrics(diskPaths, fs);
+      await this.submitSystemMetric({
+        hostname,
+        cpuPercent,
+        memoryTotal,
+        memoryUsed,
+        memoryPercent,
+        disks
+      });
+    } catch (err) {
+      this.reportError("SYSTEM_METRICS", "Failed to collect system metrics", err);
+    }
+  }
+  /**
+   * Measure CPU utilization by sampling cpus() twice with a 500ms gap.
+   * Returns a percentage (0–100).
+   */
+  async measureCpuPercent(os) {
+    const sample1 = os.cpus();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const sample2 = os.cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+    for (let i = 0; i < sample2.length; i++) {
+      const prev = sample1[i];
+      const curr = sample2[i];
+      const prevTotal = Object.values(prev.times).reduce((a, b) => a + b, 0);
+      const currTotal = Object.values(curr.times).reduce((a, b) => a + b, 0);
+      totalTick += currTotal - prevTotal;
+      totalIdle += curr.times.idle - prev.times.idle;
+    }
+    const idlePercent = totalTick > 0 ? totalIdle / totalTick * 100 : 0;
+    return Math.max(0, Math.min(100, 100 - idlePercent));
+  }
+  /**
+   * Collect disk usage for each configured path using fs.statfs() (Node 18.15+).
+   */
+  async collectDiskMetrics(paths, fs) {
+    const results = [];
+    for (const diskPath of paths) {
+      try {
+        const stat = await fs.statfs(diskPath);
+        const total = stat.bsize * stat.blocks;
+        const free = stat.bsize * stat.bavail;
+        const used = total - free;
+        const percent = total > 0 ? used / total * 100 : 0;
+        results.push({
+          path: diskPath,
+          total: Math.round(total),
+          used: Math.round(used),
+          percent: Math.round(percent * 10) / 10
+          // 1 decimal place
+        });
+      } catch {
+        this.reportError("SYSTEM_METRICS", `Failed to get disk stats for path: ${diskPath}`);
+      }
+    }
+    return results;
+  }
+  /**
+   * Submit a system metric snapshot to the monitoring server.
+   */
+  async submitSystemMetric(metric) {
+    try {
+      const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/system-metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(metric)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status}${errorText ? `: ${this.sanitizeErrorResponse(errorText)}` : ""}`);
+      }
+    } catch (err) {
+      this.reportError("SYSTEM_METRICS", "Failed to submit system metric to server", err);
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/index.mjs

@@ -58,6 +58,14 @@ var MonitorClient = class {
     this.healthCheckTimers = /* @__PURE__ */ new Map();
     this.healthCheckResultsQueue = [];
     this.healthCheckFlushTimer = null;
+    // SDK error reporting queue (errors visible on admin system errors page)
+    this.sdkErrorQueue = [];
+    this.sdkErrorFlushTimer = null;
+    this.sdkErrorsInCurrentWindow = 0;
+    this.sdkErrorWindowResetTimer = null;
+    // System metrics collection (on-premise only, opt-in)
+    this.metricsCollectionTimer = null;
+    this.metricsSettingsCheckTimer = null;
     if (!config.apiKey || config.apiKey.trim().length === 0) {
       throw new Error("[MonitorClient] API key is required");
     }
@@ -117,24 +125,28 @@ var MonitorClient = class {
     this.auditTimeoutMs = Math.min(CONFIG_LIMITS.MAX_AUDIT_TIMEOUT_MS, Math.max(1e3, config.auditTimeoutMs || CONFIG_LIMITS.AUDIT_TIMEOUT_MS));
     this.registryTimeoutMs = Math.min(CONFIG_LIMITS.MAX_REGISTRY_TIMEOUT_MS, Math.max(1e3, config.registryTimeoutMs || CONFIG_LIMITS.REGISTRY_TIMEOUT_MS));
     this.npmRegistryUrl = (config.npmRegistryUrl || "https://registry.npmjs.org").replace(/\/$/, "");
-    this.healthCheckEnabled = config.healthCheckEnabled || false;
+    this.healthCheckEnabled = config.healthCheckEnabled ?? true;
     this.healthCheckFetchIntervalMs = config.healthCheckFetchIntervalMs || CONFIG_LIMITS.HEALTH_CHECK_FETCH_INTERVAL_MS;
     this.startFlushTimer();
     if (this.trackDependencies) {
       this.syncDependencies().catch((err) => {
-        console.error("[MonitorClient] Failed to sync dependencies:", err instanceof Error ? err.message : String(err));
+        this.reportError("DEPENDENCY_SYNC", "Failed to sync dependencies on startup", err);
       });
     }
     if (this.autoAudit) {
       this.setupAutoAudit().catch((err) => {
-        console.error("[MonitorClient] Failed to setup auto audit:", err instanceof Error ? err.message : String(err));
+        this.reportError("AUDIT_SETUP", "Failed to setup auto audit", err);
       });
     }
     if (this.healthCheckEnabled) {
       this.setupHealthCheckPolling().catch((err) => {
-        console.error("[MonitorClient] Failed to setup health check polling:", err instanceof Error ? err.message : String(err));
+        this.reportError("HEALTH_POLLING_SETUP", "Failed to setup health check polling", err);
       });
     }
+    this.startSdkErrorFlushTimer();
+    this.setupSystemMetricsCollection().catch((err) => {
+      this.reportError("SYSTEM_METRICS_SETUP", "Failed to setup system metrics collection", err);
+    });
   }
   /**
    * Security: Validate and sanitize metadata to prevent oversized payloads
@@ -284,8 +296,66 @@ var MonitorClient = class {
     this.stopFlushTimer();
     this.stopAuditIntervalTimer();
     this.stopHealthCheckTimers();
+    this.stopSdkErrorFlushTimer();
+    this.stopMetricsCollection();
     await this.flush();
     await this.flushHealthResults();
+    await this.flushSdkErrors();
+  }
+  /**
+   * Queue an SDK error to be reported to the server's system errors page.
+   * Fire-and-forget — never throws. If reporting itself fails, logs to console only.
+   * Throttled to max 20 errors per minute to prevent flooding.
+   */
+  reportError(category, message, err) {
+    if (this.sdkErrorsInCurrentWindow >= 20) return;
+    this.sdkErrorsInCurrentWindow++;
+    const errorMessage = err instanceof Error ? `${message}: ${err.message}` : message;
+    const stack = err instanceof Error ? err.stack : void 0;
+    this.sdkErrorQueue.push({ category, message: errorMessage, stack });
+    if (this.sdkErrorQueue.length >= 20) {
+      this.flushSdkErrors().catch(() => {
+      });
+    }
+  }
+  startSdkErrorFlushTimer() {
+    this.sdkErrorFlushTimer = setInterval(() => {
+      this.flushSdkErrors().catch(() => {
+      });
+    }, 3e4);
+    this.sdkErrorWindowResetTimer = setInterval(() => {
+      this.sdkErrorsInCurrentWindow = 0;
+    }, 6e4);
+  }
+  stopSdkErrorFlushTimer() {
+    if (this.sdkErrorFlushTimer) {
+      clearInterval(this.sdkErrorFlushTimer);
+      this.sdkErrorFlushTimer = null;
+    }
+    if (this.sdkErrorWindowResetTimer) {
+      clearInterval(this.sdkErrorWindowResetTimer);
+      this.sdkErrorWindowResetTimer = null;
+    }
+  }
+  async flushSdkErrors() {
+    if (this.sdkErrorQueue.length === 0) return;
+    const errors = [...this.sdkErrorQueue];
+    this.sdkErrorQueue = [];
+    try {
+      const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/sdk-errors`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({ errors })
+      });
+      if (!response.ok) {
+        console.warn(`[MonitorClient] Failed to report SDK errors: HTTP ${response.status}`);
+      }
+    } catch (err) {
+      console.warn("[MonitorClient] Failed to flush SDK errors to server:", err instanceof Error ? err.message : String(err));
+    }
   }
   stopAuditIntervalTimer() {
     if (this.auditIntervalTimer) {
@@ -347,14 +417,14 @@ var MonitorClient = class {
       const intervalMs = intervalHours * 60 * 60 * 1e3;
       this.auditIntervalTimer = setInterval(() => {
         this.runScanAndTrackTime().catch((err) => {
-          console.error("[MonitorClient] Auto audit scan failed:", err);
+          this.reportError("AUDIT_SCAN", "Auto audit scan failed", err);
         });
       }, intervalMs);
     }
     console.log("[MonitorClient] Polling for scan requests enabled (every 5 minutes)");
     this.settingsPollingTimer = setInterval(() => {
       this.checkForScanRequest().catch((err) => {
-        console.error("[MonitorClient] Scan request check failed:", err);
+        this.reportError("SETTINGS_POLL", "Scan request check failed", err);
       });
     }, CONFIG_LIMITS.SETTINGS_POLL_INTERVAL_MS);
   }
@@ -375,7 +445,7 @@ var MonitorClient = class {
       const duration = Date.now() - startTime;
       console.log(`[MonitorClient] Vulnerability scan completed in ${duration}ms`);
     } catch (err) {
-      console.error("[MonitorClient] Vulnerability scan failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Vulnerability scan failed", err);
     }
   }
   /**
@@ -402,7 +472,7 @@ var MonitorClient = class {
         }
       }
     } catch (err) {
-      console.error("[MonitorClient] Failed to check for scan request:", err instanceof Error ? err.message : String(err));
+      this.reportError("SETTINGS_POLL", "Failed to check for scan request", err);
     }
   }
   enqueue(payload) {
@@ -489,7 +559,7 @@ var MonitorClient = class {
       );
       console.log("[MonitorClient] Technology sync completed successfully");
     } catch (err) {
-      console.error("[MonitorClient] Technology sync failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("DEPENDENCY_SYNC", "Technology sync failed", err);
     }
   }
   async performDependencySync(signal) {
@@ -993,7 +1063,7 @@ var MonitorClient = class {
       const result = await response.json();
       return result.data;
     } catch (err) {
-      console.error("[MonitorClient] Failed to audit dependencies:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Failed to audit dependencies", err);
       return null;
     }
   }
@@ -1023,7 +1093,7 @@ var MonitorClient = class {
       }
       return result;
     } catch (err) {
-      console.error("[MonitorClient] Multi-path audit failed:", err instanceof Error ? err.message : String(err));
+      this.reportError("VULNERABILITY_SCAN", "Multi-path audit failed", err);
       return null;
     }
   }
@@ -1242,6 +1312,19 @@ var MonitorClient = class {
           "Content-Type": "application/json"
         };
       }
+      if (endpoint.allowInsecureTls) {
+        try {
+          const undici = await import(
+            /* webpackIgnore: true */
+            "undici"
+          );
+          const Agent = undici.Agent;
+          requestOptions.dispatcher = new Agent({
+            connect: { rejectUnauthorized: false }
+          });
+        } catch {
+        }
+      }
       const response = await this.fetchWithTimeout(
         endpoint.url,
         requestOptions,
@@ -1285,12 +1368,12 @@ var MonitorClient = class {
     await this.fetchAndScheduleHealthChecks();
     this.healthCheckFetchTimer = setInterval(() => {
       this.fetchAndScheduleHealthChecks().catch((err) => {
-        console.error("[MonitorClient] Failed to fetch and schedule health checks:", err);
+        this.reportError("HEALTH_ENDPOINT_FETCH", "Failed to fetch and schedule health checks", err);
       });
     }, this.healthCheckFetchIntervalMs);
     this.healthCheckFlushTimer = setInterval(() => {
       this.flushHealthResults().catch((err) => {
-        console.error("[MonitorClient] Failed to flush health results:", err);
+        this.reportError("HEALTH_RESULTS_FLUSH", "Failed to flush health results", err);
       });
     }, CONFIG_LIMITS.HEALTH_CHECK_FLUSH_INTERVAL_MS);
   }
@@ -1311,7 +1394,7 @@ var MonitorClient = class {
         this.scheduleHealthCheck(endpoint);
       }
     } catch (err) {
-      console.error("[MonitorClient] Failed to fetch health endpoints:", err);
+      this.reportError("HEALTH_ENDPOINT_FETCH", "Failed to fetch health endpoints from server", err);
     }
   }
   /**
@@ -1320,11 +1403,11 @@ var MonitorClient = class {
   scheduleHealthCheck(endpoint) {
     const intervalMs = Math.max(CONFIG_LIMITS.HEALTH_CHECK_MIN_INTERVAL_MS, endpoint.intervalMs);
     this.runHealthCheck(endpoint).catch((err) => {
-      console.error(`[MonitorClient] Health check failed for ${endpoint.name}:`, err);
+      this.reportError("HEALTH_CHECK", `Health check failed for ${endpoint.name}`, err);
     });
     const timer = setInterval(() => {
       this.runHealthCheck(endpoint).catch((err) => {
-        console.error(`[MonitorClient] Health check failed for ${endpoint.name}:`, err);
+        this.reportError("HEALTH_CHECK", `Health check failed for ${endpoint.name}`, err);
       });
     }, intervalMs);
     this.healthCheckTimers.set(endpoint.id, timer);
@@ -1350,7 +1433,7 @@ var MonitorClient = class {
       const response = await this.submitHealthResults(results);
       console.log(`[MonitorClient] Submitted ${response.processed}/${response.total} health check results`);
     } catch (err) {
-      console.error("[MonitorClient] Failed to flush health results:", err);
+      this.reportError("HEALTH_RESULTS_FLUSH", "Failed to submit health check results to server", err);
       if (this.healthCheckResultsQueue.length + results.length <= CONFIG_LIMITS.HEALTH_CHECK_MAX_BATCH_SIZE) {
         this.healthCheckResultsQueue.unshift(...results);
       }
@@ -1373,6 +1456,171 @@ var MonitorClient = class {
       this.healthCheckTimers.delete(endpointId);
     }
   }
+  // ---- System Metrics (on-premise only) ----
+  /**
+   * Start system metrics collection based on server-configured settings.
+   * Only runs if metricsEnabled is true in project settings.
+   * Collects CPU, RAM, and disk usage using built-in Node.js modules.
+   */
+  async setupSystemMetricsCollection() {
+    const settings = await this.fetchProjectSettings();
+    if (!settings?.metricsEnabled) {
+      this.metricsSettingsCheckTimer = setInterval(() => {
+        this.fetchProjectSettings().then((latestSettings) => {
+          if (latestSettings?.metricsEnabled) {
+            clearInterval(this.metricsSettingsCheckTimer);
+            this.metricsSettingsCheckTimer = null;
+            this.startMetricsCollection(latestSettings);
+          }
+        }).catch(() => {
+        });
+      }, 3e5);
+      return;
+    }
+    this.startMetricsCollection(settings);
+  }
+  startMetricsCollection(settings) {
+    const intervalMs = Math.max(3e4, (settings.metricsIntervalSeconds ?? 3600) * 1e3);
+    console.log(`[MonitorClient] System metrics collection enabled (every ${intervalMs / 1e3}s)`);
+    const initialDiskPaths = settings.metricsDiskPaths ?? ["/"];
+    this.collectAndSubmitMetrics(initialDiskPaths).catch((err) => {
+      this.reportError("SYSTEM_METRICS", "Initial system metrics collection failed", err);
+    });
+    this.metricsCollectionTimer = setInterval(() => {
+      this.fetchProjectSettings().then((latestSettings) => {
+        if (!latestSettings?.metricsEnabled) return;
+        const diskPaths = latestSettings.metricsDiskPaths ?? ["/"];
+        return this.collectAndSubmitMetrics(diskPaths);
+      }).catch((err) => {
+        this.reportError("SYSTEM_METRICS", "Scheduled system metrics collection failed", err);
+      });
+    }, intervalMs);
+  }
+  stopMetricsCollection() {
+    if (this.metricsCollectionTimer) {
+      clearInterval(this.metricsCollectionTimer);
+      this.metricsCollectionTimer = null;
+    }
+    if (this.metricsSettingsCheckTimer) {
+      clearInterval(this.metricsSettingsCheckTimer);
+      this.metricsSettingsCheckTimer = null;
+    }
+  }
+  /**
+   * Collect system metrics (CPU, RAM, disk) using built-in Node.js modules
+   * and submit to the monitoring server.
+   *
+   * Uses: os.cpus(), os.totalmem(), os.freemem(), os.hostname(), fs.statfs()
+   * Zero dependencies — all built-in Node.js 18.15+
+   */
+  async collectAndSubmitMetrics(diskPaths) {
+    if (typeof window !== "undefined" || typeof document !== "undefined") {
+      return;
+    }
+    let os;
+    let fs;
+    try {
+      const osModule = await import(
+        /* webpackIgnore: true */
+        "os"
+      );
+      const fsModule = await import(
+        /* webpackIgnore: true */
+        "fs/promises"
+      );
+      os = osModule;
+      fs = fsModule;
+    } catch {
+      this.reportError("SYSTEM_METRICS", "System metrics require Node.js (not available in bundled/browser environments)");
+      return;
+    }
+    try {
+      const hostname = os.hostname();
+      const cpuPercent = await this.measureCpuPercent(os);
+      const memoryTotal = os.totalmem();
+      const memoryFree = os.freemem();
+      const memoryUsed = memoryTotal - memoryFree;
+      const memoryPercent = memoryTotal > 0 ? memoryUsed / memoryTotal * 100 : 0;
+      const disks = await this.collectDiskMetrics(diskPaths, fs);
+      await this.submitSystemMetric({
+        hostname,
+        cpuPercent,
+        memoryTotal,
+        memoryUsed,
+        memoryPercent,
+        disks
+      });
+    } catch (err) {
+      this.reportError("SYSTEM_METRICS", "Failed to collect system metrics", err);
+    }
+  }
+  /**
+   * Measure CPU utilization by sampling cpus() twice with a 500ms gap.
+   * Returns a percentage (0–100).
+   */
+  async measureCpuPercent(os) {
+    const sample1 = os.cpus();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const sample2 = os.cpus();
+    let totalIdle = 0;
+    let totalTick = 0;
+    for (let i = 0; i < sample2.length; i++) {
+      const prev = sample1[i];
+      const curr = sample2[i];
+      const prevTotal = Object.values(prev.times).reduce((a, b) => a + b, 0);
+      const currTotal = Object.values(curr.times).reduce((a, b) => a + b, 0);
+      totalTick += currTotal - prevTotal;
+      totalIdle += curr.times.idle - prev.times.idle;
+    }
+    const idlePercent = totalTick > 0 ? totalIdle / totalTick * 100 : 0;
+    return Math.max(0, Math.min(100, 100 - idlePercent));
+  }
+  /**
+   * Collect disk usage for each configured path using fs.statfs() (Node 18.15+).
+   */
+  async collectDiskMetrics(paths, fs) {
+    const results = [];
+    for (const diskPath of paths) {
+      try {
+        const stat = await fs.statfs(diskPath);
+        const total = stat.bsize * stat.blocks;
+        const free = stat.bsize * stat.bavail;
+        const used = total - free;
+        const percent = total > 0 ? used / total * 100 : 0;
+        results.push({
+          path: diskPath,
+          total: Math.round(total),
+          used: Math.round(used),
+          percent: Math.round(percent * 10) / 10
+          // 1 decimal place
+        });
+      } catch {
+        this.reportError("SYSTEM_METRICS", `Failed to get disk stats for path: ${diskPath}`);
+      }
+    }
+    return results;
+  }
+  /**
+   * Submit a system metric snapshot to the monitoring server.
+   */
+  async submitSystemMetric(metric) {
+    try {
+      const response = await this.fetchWithTimeout(`${this.endpoint}/api/v1/system-metrics`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(metric)
+      });
+      if (!response.ok) {
+        const errorText = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status}${errorText ? `: ${this.sanitizeErrorResponse(errorText)}` : ""}`);
+      }
+    } catch (err) {
+      this.reportError("SYSTEM_METRICS", "Failed to submit system metric to server", err);
+    }
+  }
 };
 export {
   MonitorClient

package/package.json

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