Feature: Single Sandbox Resource Metrics

src/__test__/integration/auth.test.ts

@@ -95,12 +95,14 @@ describe('Auth Actions - Integration Tests', () => {
       ok: true,
       json: () => Promise.resolve({ version: 'v2.60.7', name: 'GoTrue' }),
     })
+    global.fetch = fetchMock as unknown as typeof fetch
     verifyTurnstileToken.mockResolvedValue(true)
   })
 
   afterEach(() => {
     // Restore original console.error after each test
     console.error = originalConsoleError
+    global.fetch = originalFetch
   })
 
   describe('Sign In Flow', () => {

src/__test__/unit/sandbox-monitoring-chart-model.test.ts

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest'
+import { buildMonitoringChartModel } from '@/features/dashboard/sandbox/monitoring/utils/chart-model'
+import type { SandboxMetric } from '@/server/api/models/sandboxes.models'
+
+const baseMetric = {
+  timestamp: '1970-01-01T00:00:00.000Z',
+  cpuCount: 2,
+  memTotal: 1_000,
+  diskTotal: 2_000,
+} satisfies Omit<
+  SandboxMetric,
+  'timestampUnix' | 'cpuUsedPct' | 'memUsed' | 'diskUsed'
+>
+
+describe('buildMonitoringChartModel', () => {
+  it('builds deterministic time-series data sorted by timestamp', () => {
+    const metrics: SandboxMetric[] = [
+      {
+        ...baseMetric,
+        timestampUnix: 10,
+        cpuUsedPct: 30,
+        memUsed: 300,
+        diskUsed: 600,
+      },
+      {
+        ...baseMetric,
+        timestampUnix: 0,
+        cpuUsedPct: 10,
+        memUsed: 100,
+        diskUsed: 200,
+      },
+      {
+        ...baseMetric,
+        timestampUnix: 5,
+        cpuUsedPct: 20,
+        memUsed: 200,
+        diskUsed: 400,
+      },
+    ]
+
+    const result = buildMonitoringChartModel({
+      metrics,
+      startMs: 0,
+      endMs: 10_000,
+      hoveredTimestampMs: 6_000,
+    })
+
+    expect(result.latestMetric?.timestampUnix).toBe(10)
+    expect(result.resourceSeries).toHaveLength(2)
+    expect(result.diskSeries).toHaveLength(1)
+    expect(result.resourceSeries[0]?.data).toEqual([
+      [0, 10, null],
+      [5_000, 20, null],
+      [10_000, 30, null],
+    ])
+    expect(result.resourceSeries[1]?.data).toEqual([
+      [0, 10, 0],
+      [5_000, 20, 0],
+      [10_000, 30, 0],
+    ])
+    expect(result.diskSeries[0]?.data).toEqual([
+      [0, 10, 0],
+      [5_000, 20, 0],
+      [10_000, 30, 0],
+    ])
+    expect(result.resourceHoveredContext).toEqual({
+      cpuPercent: 20,
+      ramPercent: 20,
+      timestampMs: 5_000,
+    })
+    expect(result.diskHoveredContext).toEqual({
+      diskPercent: 20,
+      timestampMs: 5_000,
+    })
+  })
+
+  it('returns null hovered contexts when no data is available', () => {
+    const result = buildMonitoringChartModel({
+      metrics: [],
+      startMs: 0,
+      endMs: 10_000,
+      hoveredTimestampMs: 1_000,
+    })
+
+    expect(result.resourceHoveredContext).toBeNull()
+    expect(result.diskHoveredContext).toBeNull()
+  })
+
+  it('filters out metrics outside range and invalid timestamps', () => {
+    const metrics: SandboxMetric[] = [
+      {
+        ...baseMetric,
+        timestampUnix: 1,
+        cpuUsedPct: 5,
+        memUsed: 50,
+        diskUsed: 100,
+      },
+      {
+        ...baseMetric,
+        timestampUnix: Number.NaN,
+        cpuUsedPct: 55,
+        memUsed: 550,
+        diskUsed: 1_100,
+      },
+      {
+        ...baseMetric,
+        timestampUnix: 20,
+        cpuUsedPct: 80,
+        memUsed: 800,
+        diskUsed: 1_600,
+      },
+    ]
+
+    const result = buildMonitoringChartModel({
+      metrics,
+      startMs: 0,
+      endMs: 10_000,
+      hoveredTimestampMs: null,
+    })
+
+    expect(result.latestMetric?.timestampUnix).toBe(1)
+    expect(result.resourceSeries[0]?.data).toEqual([[1_000, 5, null]])
+    expect(result.diskSeries[0]?.data).toEqual([[1_000, 5, 0]])
+  })
+})

src/__test__/unit/sandbox-monitoring-timeframe.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, it } from 'vitest'
+import {
+  SANDBOX_MONITORING_DEFAULT_RANGE_MS,
+  SANDBOX_MONITORING_MAX_RANGE_MS,
+  SANDBOX_MONITORING_MIN_RANGE_MS,
+} from '@/features/dashboard/sandbox/monitoring/utils/constants'
+import {
+  getSandboxLifecycleBounds,
+  normalizeMonitoringTimeframe,
+  parseMonitoringQueryState,
+} from '@/features/dashboard/sandbox/monitoring/utils/timeframe'
+import type { SandboxDetailsDTO } from '@/server/api/models/sandboxes.models'
+
+describe('sandbox-monitoring-timeframe', () => {
+  describe('normalizeMonitoringTimeframe', () => {
+    it('should fallback to default range when inputs are invalid', () => {
+      const now = 1_700_000_000_000
+
+      const result = normalizeMonitoringTimeframe({
+        start: Number.NaN,
+        end: Number.POSITIVE_INFINITY,
+        now,
+      })
+
+      expect(result.end).toBe(now)
+      expect(result.start).toBe(now - SANDBOX_MONITORING_DEFAULT_RANGE_MS)
+    })
+
+    it('should enforce minimum range', () => {
+      const now = 1_700_000_000_000
+
+      const result = normalizeMonitoringTimeframe({
+        start: now - 1_000,
+        end: now,
+        now,
+      })
+
+      expect(result.end - result.start).toBe(SANDBOX_MONITORING_MIN_RANGE_MS)
+    })
+
+    it('should cap maximum range', () => {
+      const now = 1_700_000_000_000
+
+      const result = normalizeMonitoringTimeframe({
+        start: now - 365 * 24 * 60 * 60 * 1_000,
+        end: now,
+        now,
+      })
+
+      expect(result.end - result.start).toBe(SANDBOX_MONITORING_MAX_RANGE_MS)
+    })
+
+    it('should clamp future timestamps to now', () => {
+      const now = 1_700_000_000_000
+
+      const result = normalizeMonitoringTimeframe({
+        start: now + 5_000,
+        end: now + 10_000,
+        now,
+      })
+
+      expect(result.end).toBe(now)
+      expect(result.start).toBe(now - SANDBOX_MONITORING_MIN_RANGE_MS)
+    })
+  })
+
+  describe('parseMonitoringQueryState', () => {
+    it('should parse canonical query params', () => {
+      const result = parseMonitoringQueryState({
+        start: '1000',
+        end: '2000',
+        live: '1',
+      })
+
+      expect(result).toEqual({
+        start: 1000,
+        end: 2000,
+        live: true,
+      })
+    })
+
+    it('should reject non-canonical live values and invalid timestamps', () => {
+      const result = parseMonitoringQueryState({
+        start: '123abc',
+        end: String(Number.MAX_SAFE_INTEGER),
+        live: 'true',
+      })
+
+      expect(result).toEqual({
+        start: null,
+        end: null,
+        live: null,
+      })
+    })
+  })
+
+  describe('getSandboxLifecycleBounds', () => {
+    it('should clamp lifecycle anchor end to now for paused sandbox', () => {
+      const now = 1_700_000_000_000
+      const sandboxInfo: SandboxDetailsDTO = {
+        templateID: 'template-id',
+        sandboxID: 'sandbox-id',
+        startedAt: new Date(now - 60_000).toISOString(),
+        endAt: new Date(now + 60_000).toISOString(),
+        envdVersion: '1.0.0',
+        cpuCount: 2,
+        memoryMB: 512,
+        diskSizeMB: 1_024,
+        state: 'paused',
+      }
+
+      const bounds = getSandboxLifecycleBounds(sandboxInfo, now)
+
+      expect(bounds?.startMs).toBe(now - 60_000)
+      expect(bounds?.anchorEndMs).toBe(now)
+      expect(bounds?.isRunning).toBe(false)
+    })
+
+    it('should fall back to now for running sandbox without endAt', () => {
+      const now = 1_700_000_000_000
+      const sandboxInfo = {
+        startedAt: new Date(now - 60_000).toISOString(),
+        endAt: null,
+        state: 'running' as const,
+      }
+
+      const bounds = getSandboxLifecycleBounds(sandboxInfo, now)
+
+      expect(bounds?.startMs).toBe(now - 60_000)
+      expect(bounds?.anchorEndMs).toBe(now)
+      expect(bounds?.isRunning).toBe(true)
+    })
+
+    it('should use stoppedAt when endAt is null for killed sandbox', () => {
+      const now = 1_700_000_000_000
+      const stoppedAt = now - 30_000
+      const sandboxInfo: SandboxDetailsDTO = {
+        templateID: 'template-id',
+        sandboxID: 'sandbox-id',
+        startedAt: new Date(now - 60_000).toISOString(),
+        endAt: null,
+        stoppedAt: new Date(stoppedAt).toISOString(),
+        cpuCount: 2,
+        memoryMB: 512,
+        diskSizeMB: 1_024,
+        state: 'killed',
+      }
+
+      const bounds = getSandboxLifecycleBounds(sandboxInfo, now)
+
+      expect(bounds?.startMs).toBe(now - 60_000)
+      expect(bounds?.anchorEndMs).toBe(stoppedAt)
+      expect(bounds?.isRunning).toBe(false)
+    })
+
+    it('should fall back to now for killed sandbox without end timestamp', () => {
+      const now = 1_700_000_000_000
+      const sandboxInfo: SandboxDetailsDTO = {
+        templateID: 'template-id',
+        sandboxID: 'sandbox-id',
+        startedAt: new Date(now - 60_000).toISOString(),
+        endAt: null,
+        stoppedAt: null,
+        cpuCount: 2,
+        memoryMB: 512,
+        diskSizeMB: 1_024,
+        state: 'killed',
+      }
+
+      const bounds = getSandboxLifecycleBounds(sandboxInfo, now)
+
+      expect(bounds?.startMs).toBe(now - 60_000)
+      expect(bounds?.anchorEndMs).toBe(now)
+      expect(bounds?.isRunning).toBe(false)
+    })
+  })
+})