Skip to content

armgit / Pulse

Public Imported from GitHub
0

Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.

Withdraw stopped VM filesystem readings from canonical History

pulse-triage[bot]ea05ef0f0978
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index 3760627ba8..e3ef7fe993 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -20,6 +20,30 @@
## Purpose
+### Canonical VM History respects native filesystem power state (12 October 2026)
+
+The canonical resource drawer uses `getWorkloadGuestDiskRead`, the same VM
+filesystem admission as Workloads and Alerts. Proxmox `runtimeStatus` takes
+precedence over canonical status from a linked source; absent native state
+falls back to canonical status, with `offline` treated as stopped. A stopped
+VM exposes neither a current disk/usage fallback nor a last-known disk carrier,
+even with a `prev-` reason or refreshed Last seen. The stopped explanation is
+visible beside History. Running retained/unavailable reads keep their existing
+distinction; an accepted zero is still current.
+
+Stored history remains inspectable, and independent CPU/memory/network metrics,
+LXC platform storage and non-Proxmox resources do not inherit VM filesystem
+rules. Power/read snapshot changes do not initiate a History refresh or a guest
+operation. This does not establish thaw, writes, restart recovery or release
+availability.
+
+`resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts` covers native
+and fallback state, platform scopes, zero, reason precedence and independent
+resource types. `ResourceDetailDrawer.history.test.tsx` connects reactive
+same-ID snapshots to the production drawer and History client. The production
+desktop Chromium/phone WebKit fixture `browser-tests/resource-stopped-filesystem.cjs`
+also preserves stored observations and trusted keyboard inspection.
+
### Existing alert History distinguishes failed reads from empty results
The History tab renders fixed non-provider error copy in a `role="alert"`
diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.cjs b/frontend-modern/browser-tests/resource-stopped-filesystem.cjs
new file mode 100644
index 0000000000..281f415b12
--- /dev/null
+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.cjs
@@ -0,0 +1,379 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { chromium, webkit } = require('playwright');
+const root = '/workspace/frontend-modern';
+const origin = 'http://127.0.0.1:5343';
+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const runtime = [
+ 'frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts',
+ 'frontend-modern/src/components/Infrastructure/useResourceDetailDrawerDerivedState.ts',
+ 'frontend-modern/src/components/Infrastructure/ResourceDetailDrawer.tsx',
+ 'frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx',
+ 'frontend-modern/src/utils/workloadGuestPresentation.ts',
+];
+const settle = (page) =>
+ page.evaluate(async () => {
+ await document.fonts.ready;
+ await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
+ });
+
+async function verify(original = false) {
+ const output = `/workspace/tmp/resource-stopped-filesystem/browser-${original ? 'original' : 'final'}`;
+ fs.mkdirSync(output, { recursive: true });
+ const result = {
+ result: 'incomplete',
+ phase: original ? 'original-adverse-observation' : 'candidate-verification',
+ playwright: require('playwright/package.json').version,
+ runtime_hashes: Object.fromEntries(runtime.map((file) => [file, hash('/workspace/' + file)])),
+ cases: [],
+ screenshots: [],
+ cleanup: { browsers: false, server: false },
+ limits:
+ 'Production ResourceDetailDrawer, History/client and CSS; synthetic snapshots and local endpoints. No native guest command, QGA, thaw, writes, restart, reporter, installed or release acceptance.',
+ };
+ assert.equal(
+ result.playwright,
+ JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[
+ 'node_modules/@playwright/test'
+ ].version,
+ );
+ process.chdir(root);
+ const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));
+ const server = await createServer({
+ root,
+ configFile: path.join(root, 'vite.config.ts'),
+ cacheDir: output + '/cache',
+ optimizeDeps: { entries: ['browser-tests/resource-stopped-filesystem.html'] },
+ server: { host: '127.0.0.1', port: 5343, strictPort: true },
+ });
+ let browser;
+ try {
+ await server.listen();
+ for (const [name, engine, width, height, dark] of [
+ ['chromium-desktop-light', chromium, 1280, 900, false],
+ ['webkit-phone-dark', webkit, 390, 844, true],
+ ]) {
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const page = await browser.newPage({
+ viewport: { width, height },
+ isMobile: width < 768,
+ hasTouch: width < 768,
+ locale: 'en-GB',
+ timezoneId: 'UTC',
+ });
+ page.setDefaultTimeout(12000);
+ const record = {
+ name,
+ width,
+ height,
+ dark,
+ browser: browser.version(),
+ errors: [],
+ requests: [],
+ checks: [],
+ states: [],
+ };
+ result.cases.push(record);
+ let mode = 'empty';
+ page.on('pageerror', (error) => record.errors.push(error.message));
+ await page.route('**/*', (route) => {
+ const request = route.request(),
+ url = new URL(request.url());
+ if (url.origin !== origin) {
+ record.requests.push({ path: url.pathname, method: request.method(), blocked: true });
+ return route.abort();
+ }
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ assert.equal(request.method(), 'GET');
+ record.requests.push({ path: url.pathname, method: request.method(), mode });
+ if (url.pathname === '/api/metrics-store/history') {
+ assert.equal(url.searchParams.get('resourceId'), 'fixture:pve:101');
+ const end = Date.now() - 60000,
+ start = end - 3600000;
+ const point = (timestamp, value) => ({ timestamp, value, min: value, max: value });
+ return route.fulfill({
+ json: {
+ resourceType: url.searchParams.get('resourceType'),
+ resourceId: 'fixture:pve:101',
+ range: url.searchParams.get('range'),
+ start,
+ end,
+ source: 'store',
+ metrics: mode === 'stored' ? { disk: [point(start, 25), point(end, 50)] } : {},
+ },
+ });
+ }
+ return route.fulfill({
+ json:
+ url.pathname === '/api/license/runtime-capabilities'
+ ? {
+ capabilities: [],
+ limits: [],
+ max_history_days: 90,
+ hosted_mode: false,
+ runtime: { build: 'community' },
+ blocked_capabilities: [],
+ }
+ : {
+ success: true,
+ data: [],
+ alerts: [],
+ anomalies: [],
+ config: null,
+ capabilities: [],
+ relationships: [],
+ recentChanges: [],
+ available: false,
+ audits: [],
+ count: 0,
+ },
+ });
+ });
+ await page.addInitScript((isDark) => {
+ document.addEventListener('DOMContentLoaded', () =>
+ document.documentElement.classList.toggle('dark', isDark),
+ );
+ window.__trustedInputs = [];
+ for (const type of ['click', 'keydown'])
+ document.addEventListener(
+ type,
+ (event) => window.__trustedInputs.push({ type, trusted: event.isTrusted }),
+ true,
+ );
+ }, dark);
+ await page.goto(origin + '/browser-tests/resource-stopped-filesystem.html', {
+ waitUntil: 'domcontentloaded',
+ timeout: 60000,
+ });
+ await page.waitForFunction(() => window.__resourceStoppedFilesystem, null, {
+ timeout: 45000,
+ });
+ const tab = page.getByRole('tab', { name: 'History', exact: true });
+ if (width < 768) await tab.tap();
+ else {
+ await tab.focus();
+ await page.keyboard.press('Enter');
+ }
+ const chart = page.locator('[data-history-group="utilization"]');
+ await chart.waitFor();
+ await settle(page);
+ const apply = async (value) => {
+ await page.evaluate((value) => window.__resourceStoppedFilesystem.apply(value), value);
+ await settle(page);
+ };
+ const reads = () =>
+ record.requests.filter((request) => request.path === '/api/metrics-store/history').length;
+ const firstReads = reads();
+ const capture = async (state) => {
+ await chart.scrollIntoViewIfNeeded();
+ await settle(page);
+ const file = `${name}-${state}.png`;
+ await chart.screenshot({ path: path.join(output, file) });
+ result.screenshots.push({ file, sha256: hash(path.join(output, file)), state, name });
+ };
+ const unavailable = async () => {
+ assert.equal(
+ await chart
+ .locator('[data-history-current="disk"], [data-history-last-known="disk"]')
+ .count(),
+ 0,
+ );
+ assert.match(
+ await chart.locator('[data-history-deferred="disk"]').innerText(),
+ /while the VM is stopped/,
+ );
+ assert.doesNotMatch(await chart.innerText(), /90\.0%/);
+ };
+ if (original) {
+ assert.match(
+ await chart.locator('[data-history-current="disk"]').innerText(),
+ /90\.0%\s*current/,
+ );
+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);
+ record.states.push({ state: 'native-stopped-no-reason', text: await chart.innerText() });
+ await capture('stopped-current-carrier');
+ await apply({ reason: 'prev-agent-busy' });
+ assert.match(
+ await chart.locator('[data-history-last-known="disk"]').innerText(),
+ /90\.0%\s*last known/,
+ );
+ assert.doesNotMatch(
+ await chart.locator('[data-history-deferred="disk"]').innerText(),
+ /VM is stopped/,
+ );
+ record.states.push({
+ state: 'native-stopped-retained-reason',
+ text: await chart.innerText(),
+ });
+ await capture('stopped-retained-carrier');
+ record.checks.push(
+ 'Native stopped state is ignored with both an empty reason and a retained reason in the original canonical History.',
+ );
+ } else {
+ await unavailable();
+ assert.match(
+ await chart.locator('[data-history-current="cpu"]').innerText(),
+ /10\.0%\s*current/,
+ );
+ assert.match(
+ await chart.locator('[data-history-current="memory"]').innerText(),
+ /0\.0%\s*current/,
+ );
+ assert.equal(await chart.locator('path, [data-history-observation]').count(), 0);
+ await capture('stopped');
+ record.checks.push(
+ 'Native stopped VM withdraws current and retained disk carriers, even when a linked source holds canonical status online; independent CPU/memory are unchanged.',
+ );
+ await apply({ reason: 'prev-agent-busy' });
+ await unavailable();
+ await apply({ power: ' STOPPED ', reason: '', seen: Date.now() + 3600000 });
+ await unavailable();
+ await apply({ power: undefined, status: 'offline' });
+ await unavailable();
+ record.checks.push(
+ 'Stopped native state overrides a prev reason; case/space normalization and legacy offline fallback stay unavailable without a new History read.',
+ );
+ await apply({ power: ' RUNNING ', status: 'offline', reason: '', usage: 0 });
+ assert.match(
+ await chart.locator('[data-history-current="disk"]').innerText(),
+ /0\.0%\s*current/,
+ );
+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);
+ await capture('current-zero');
+ record.checks.push(
+ "Explicit native running state wins over another source's offline status, and an accepted zero renders in the existing mounted chart.",
+ );
+ await apply({
+ power: 'running',
+ status: 'online',
+ reason: 'prev-agent-capacity',
+ usage: 90,
+ });
+ assert.match(
+ await chart.locator('[data-history-last-known="disk"]').innerText(),
+ /90\.0%\s*last known/,
+ );
+ assert.match(
+ await chart.locator('[data-history-deferred="disk"]').innerText(),
+ /guest-read capacity/,
+ );
+ await capture('retained');
+ await apply({ reason: 'agent-capacity' });
+ assert.equal(
+ await chart
+ .locator('[data-history-last-known="disk"], [data-history-current="disk"]')
+ .count(),
+ 0,
+ );
+ assert.match(
+ await chart.locator('[data-history-deferred="disk"]').innerText(),
+ /guest-read capacity/,
+ );
+ record.checks.push(
+ 'Running retained/unavailable read reasons keep their distinct existing semantics, not inferred recovery.',
+ );
+ await apply({ power: 'stopped', reason: '', platform: 'agent', scopes: ['proxmox-pve'] });
+ await unavailable();
+ await apply({
+ platform: 'vmware-vsphere',
+ scopes: undefined,
+ reason: 'prev-agent-capacity',
+ usage: 30,
+ });
+ assert.match(
+ await chart.locator('[data-history-current="disk"]').innerText(),
+ /30\.0%\s*current/,
+ );
+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);
+ assert.equal(reads(), firstReads);
+ record.checks.push(
+ 'Proxmox-scoped hybrid VM honours native power; a vSphere-only VM does not inherit Proxmox reasons, and snapshot changes send no additional History reads.',
+ );
+ await apply({
+ type: 'system-container',
+ platform: 'proxmox-pve',
+ power: 'stopped',
+ status: 'offline',
+ });
+ assert.match(
+ await chart.locator('[data-history-current="disk"]').innerText(),
+ /30\.0%\s*current/,
+ );
+ assert.equal(await chart.locator('[data-history-deferred="disk"]').count(), 0);
+ record.checks.push(
+ 'Independent LXC platform storage remains current despite stopped guest runtime and a VM-only read reason.',
+ );
+ await apply({ type: 'vm', power: 'stopped', status: 'online', reason: '', usage: 90 });
+ await unavailable();
+ mode = 'stored';
+ const refresh = page.getByRole('button', { name: 'Refresh history', exact: true });
+ if (width < 768) await refresh.tap();
+ else await refresh.click();
+ const slider = chart.getByRole('slider', { name: 'Inspect Utilization history' });
+ await slider.waitFor();
+ assert.equal(await chart.locator('path').count(), 1);
+ await unavailable();
+ await slider.focus();
+ await page.keyboard.press('Home');
+ assert.match(await slider.getAttribute('aria-valuetext'), /Disk 25\.0%/);
+ await page.keyboard.press('End');
+ assert.match(await slider.getAttribute('aria-valuetext'), /Disk 50\.0%/);
+ await capture('stored-stopped');
+ record.checks.push(
+ 'Stopping withdraws only live carriers, not genuine stored history; trusted keyboard Home/End inspection preserves both disk observations.',
+ );
+ }
+ record.layout = await page.evaluate(() => ({
+ width: document.documentElement.clientWidth,
+ scrollWidth: document.documentElement.scrollWidth,
+ }));
+ assert.ok(
+ record.layout.scrollWidth <= record.layout.width + 1,
+ JSON.stringify(record.layout),
+ );
+ assert.ok((await page.evaluate(() => window.__trustedInputs)).some((event) => event.trusted));
+ assert.deepEqual(record.errors, []);
+ assert.equal(
+ record.requests.filter((request) => request.blocked || request.method !== 'GET').length,
+ 0,
+ );
+ await browser.close();
+ browser = null;
+ }
+ result.cleanup.browsers = true;
+ result.result = 'passed';
+ } catch (error) {
+ result.result = 'failed';
+ result.error = String(error);
+ throw error;
+ } finally {
+ if (browser) {
+ await browser.close();
+ result.cleanup.browsers = true;
+ }
+ await server.close();
+ result.cleanup.server = true;
+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');
+ process.stdout.write(
+ JSON.stringify({
+ result: result.result,
+ cases: result.cases.length,
+ checks: result.cases.reduce((n, c) => n + c.checks.length, 0),
+ cleanup: result.cleanup,
+ }) + '\n',
+ );
+ }
+}
+
+module.exports = { verify };
+if (require.main === module)
+ verify().catch((error) => {
+ process.stderr.write(String(error) + '\n');
+ process.exitCode = 1;
+ });
diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.html b/frontend-modern/browser-tests/resource-stopped-filesystem.html
new file mode 100644
index 0000000000..c253f29419
--- /dev/null
+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.html
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+ <head>
+ <meta charset="UTF-8" />
+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+ <title>Canonical resource filesystem History verification</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="/browser-tests/resource-stopped-filesystem.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/resource-stopped-filesystem.tsx b/frontend-modern/browser-tests/resource-stopped-filesystem.tsx
new file mode 100644
index 0000000000..dc7c35b3b4
--- /dev/null
+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.tsx
@@ -0,0 +1,107 @@
+// Synthetic source snapshots only; the drawer, History client and CSS are production.
+import { createMemo, createSignal } from 'solid-js';
+import { render } from 'solid-js/web';
+import { Route, Router } from '@solidjs/router';
+import { ResourceDetailDrawer } from '../src/components/Infrastructure/ResourceDetailDrawer';
+import { DarkModeContext, WebSocketContext, type WebSocketStore } from '../src/contexts/appRuntime';
+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';
+import type { Resource } from '../src/types/resource';
+import '../src/index.css';
+
+syncAIRuntimeSettings({ discovery_enabled: false });
+// Only the empty alert producer is synthetic; no WebSocket connection is opened.
+const websocket = {
+ activeAlerts: {},
+ state: { resources: [] },
+ connected: () => true,
+} as unknown as WebSocketStore;
+
+type Snapshot = {
+ power?: string;
+ status: Resource['status'];
+ reason: string;
+ usage: number;
+ type: Resource['type'];
+ platform: Resource['platformType'];
+ scopes?: Resource['platformScopes'];
+ seen: number;
+};
+
+function Fixture() {
+ const [snapshot, setSnapshot] = createSignal<Snapshot>({
+ power: 'stopped',
+ status: 'online',
+ reason: '',
+ usage: 90,
+ type: 'vm',
+ platform: 'proxmox-pve',
+ seen: Date.now(),
+ });
+ const resource = createMemo<Resource>(() => ({
+ id: 'fixture-vm',
+ type: snapshot().type,
+ name: 'backup-guest',
+ displayName: 'Backup guest',
+ platformId: 'fixture',
+ platformType: snapshot().platform,
+ platformScopes: snapshot().scopes,
+ sourceType: 'hybrid',
+ status: snapshot().status,
+ lastSeen: snapshot().seen,
+ metricsTarget: {
+ resourceType: snapshot().type === 'system-container' ? 'lxc' : 'vm',
+ resourceId: 'fixture:pve:101',
+ },
+ cpu: { current: 10 },
+ memory: {
+ current: 0,
+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-10T00:00:00Z' },
+ },
+ disk: { current: snapshot().usage },
+ network: { rxBytes: 0, txBytes: 200 },
+ proxmox: {
+ vmid: 101,
+ node: 'pve',
+ instance: 'fixture',
+ runtimeStatus: snapshot().power,
+ diskStatusReason: snapshot().reason,
+ },
+ }));
+ Object.assign(window, {
+ __resourceStoppedFilesystem: {
+ apply: (next: Partial<Snapshot>) => setSnapshot((previous) => ({ ...previous, ...next })),
+ resource,
+ },
+ });
+ return (
+ <main class="min-h-screen bg-surface p-3 text-base-content">
+ <h1 class="text-base font-semibold">Canonical filesystem History</h1>
+ <p class="my-2 text-xs text-muted">
+ Synthetic power and filesystem observations. No guest operation is sent.
+ </p>
+ <section class="mx-auto max-w-5xl" aria-label="Production drawer">
+ <ResourceDetailDrawer resource={resource()} presentation="table-row" />
+ </section>
+ </main>
+ );
+}
+
+render(
+ () => (
+ <Router>
+ <Route
+ path="*"
+ component={() => (
+ <DarkModeContext.Provider
+ value={() => document.documentElement.classList.contains('dark')}
+ >
+ <WebSocketContext.Provider value={websocket}>
+ <Fixture />
+ </WebSocketContext.Provider>
+ </DarkModeContext.Provider>
+ )}
+ />
+ </Router>
+ ),
+ document.getElementById('root')!,
+);
diff --git a/frontend-modern/browser-verification/ec3ba02b1d517813.json b/frontend-modern/browser-verification/ec3ba02b1d517813.json
new file mode 100644
index 0000000000..530c0a9d87
--- /dev/null
+++ b/frontend-modern/browser-verification/ec3ba02b1d517813.json
@@ -0,0 +1,60 @@
+{
+ "version": 1,
+ "base_sha": "7df7f3563f9e30dfd0aa678d8be6b2f7e9a4cca4",
+ "verified_at": "2026-10-12T04:20:43Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts": "d496cdf324afac269828ef7ccc7d6fe18855fb49806dca0716a2869a7838a44d"
+ },
+ "routes": [
+ "/browser-tests/resource-stopped-filesystem.html (production canonical ResourceDetailDrawer History and CSS; synthetic sources/local API)"
+ ],
+ "viewports": [
+ {
+ "width": 1280,
+ "height": 900,
+ "browser": "chromium-desktop-light"
+ },
+ {
+ "width": 390,
+ "height": 844,
+ "browser": "webkit-phone-dark"
+ }
+ ],
+ "states": [
+ "Native stopped VM with canonical online and no read reason: no current or last-known disk carrier.",
+ "Stopped VM with previous-busy reason, normalized native power and refreshed Last seen remains unavailable.",
+ "Missing native state falls back to canonical offline; explicit native running takes precedence and displays accepted zero.",
+ "Running retained capacity is last known; running unavailable capacity has no live number.",
+ "Hybrid Proxmox-scoped VM retains native power admission; vSphere-only VM and LXC platform storage remain independent.",
+ "Genuine stored disk observations remain inspectable for stopped VM."
+ ],
+ "interactions": [
+ "Desktop trusted keyboard Enter opens History; phone trusted tap opens History.",
+ "Reactive same-ID synthetic source snapshots exercise native power/read/status transitions without extra History reads before target-type change.",
+ "Trusted refresh loads stored disk25% and50%; trusted Home/End slider keys inspect both samples.",
+ "Eight chart captures viewed; stopped explanation wraps, no horizontal overflow or page errors on either browser."
+ ],
+ "proof": {
+ "script": "frontend-modern/browser-tests/resource-stopped-filesystem.cjs",
+ "playwright": "1.56.1",
+ "checks": 14,
+ "captures": 8,
+ "runtime_hashes": {
+ "frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts": "d496cdf324afac269828ef7ccc7d6fe18855fb49806dca0716a2869a7838a44d",
+ "frontend-modern/src/components/Infrastructure/useResourceDetailDrawerDerivedState.ts": "94e4b364c744f204ff52e2d28cde6b80a5a66ac414c7ba702113e960a6a67e17",
+ "frontend-modern/src/components/Infrastructure/ResourceDetailDrawer.tsx": "9e7ee3e3cbb5f8da38cf43e0aaecd105f43333d16df7338e849d3ccaf6804d8f",
+ "frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx": "8b94c3d9409f46bedf812b00ff9f3156da9ace6885ec04456ea5fed59d842127",
+ "frontend-modern/src/utils/workloadGuestPresentation.ts": "71a2d2e62411c70c0eb609e68cd4963dac483be59a5be6afcf96c1ce2191436f"
+ },
+ "result_json_sha256": "bcab014213c55e7f17ddca9e513eee1ab3a3516571d4dfccc2c0862871446375",
+ "cleanup": {
+ "browsers": true,
+ "server": true
+ },
+ "limits": "Production ResourceDetailDrawer, History/client and CSS; synthetic snapshots and local endpoints. No native guest command, QGA, thaw, writes, restart, reporter, installed or release acceptance."
+ }
+}
diff --git a/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx b/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx
index f5e53ea7de..30ea9130be 100644
--- a/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx
+++ b/frontend-modern/src/components/Infrastructure/__tests__/ResourceDetailDrawer.history.test.tsx
@@ -255,6 +255,73 @@ describe('ResourceDetailDrawer change history section', () => {
}
});
+ it('reactively withdraws stopped VM disk carriers without discarding History or independent readings', async () => {
+ resetCreateNonSuspendingQueryCacheForTest();
+ const source = baseResource({
+ id: 'native-power-vm',
+ type: 'vm',
+ platformType: 'proxmox-pve',
+ metricsTarget: { resourceType: 'vm', resourceId: 'power:pve:101' },
+ cpu: { current: 10 },
+ memory: {
+ current: 0,
+ observation: { state: 'current', source: 'agent', observedAt: '2026-10-10T00:00:00Z' },
+ },
+ disk: { current: 90 },
+ proxmox: { runtimeStatus: 'running' },
+ });
+ const read = vi.spyOn(ChartsAPI, 'getMetricsHistory').mockResolvedValue({
+ resourceType: 'vm',
+ resourceId: 'power:pve:101',
+ range: '24h',
+ start: Date.parse('2026-10-10T00:00:00Z'),
+ end: Date.parse('2026-10-10T01:00:00Z'),
+ source: 'store',
+ metrics: {},
+ });
+ const [resource, setResource] = createSignal(source);
+ const view = render(() => (
+ <ResourceDetailDrawer resource={resource()} presentation="table-row" />
+ ));
+ try {
+ fireEvent.click(screen.getByRole('tab', { name: 'History' }));
+ await waitFor(() => expect(read).toHaveBeenCalledTimes(1));
+ const chart = view.container.querySelector('[data-history-group="utilization"]')!;
+ expect(chart.querySelector('[data-history-current="disk"]')).toHaveTextContent(
+ '90.0%current',
+ );
+ for (const diskStatusReason of ['', 'prev-agent-busy']) {
+ setResource({
+ ...source,
+ lastSeen: source.lastSeen + 3600000,
+ proxmox: { runtimeStatus: 'stopped', diskStatusReason },
+ });
+ expect(chart.querySelector('[data-history-current="disk"]')).toBeNull();
+ expect(chart.querySelector('[data-history-last-known="disk"]')).toBeNull();
+ expect(chart.querySelector('[data-history-deferred="disk"]')).toHaveTextContent(
+ 'Guest filesystem stats unavailable while the VM is stopped.',
+ );
+ expect(chart.querySelector('[data-history-current="memory"]')).toHaveTextContent(
+ '0.0%current',
+ );
+ expect(chart.querySelector('[data-history-current="cpu"]')).toHaveTextContent(
+ '10.0%current',
+ );
+ }
+ setResource({ ...source, status: 'offline', disk: { current: 0 } });
+ expect(chart.querySelector('[data-history-current="disk"]')).toHaveTextContent('0.0%current');
+ expect(chart.querySelector('[data-history-deferred="disk"]')).toBeNull();
+ expect(view.container.querySelector('[data-history-group="utilization"]')).toBe(chart);
+ expect(chart.querySelector('path')).toBeNull();
+ expect(read).toHaveBeenCalledTimes(1);
+ expect(screen.getByRole('tab', { name: 'History' })).toHaveAttribute('aria-selected', 'true');
+ } finally {
+ view.unmount();
+ read.mockRestore();
+ resetCreateNonSuspendingQueryCacheForTest();
+ }
+ });
+
it('keeps current readings separate from stored history samples', () => {
expect(guestDrawerHistorySource).toContain('currentMetrics');
expect(guestDrawerHistorySource).toContain('No stored history in this range');
diff --git a/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts b/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts
index 9fe9a0ac3b..1cb61e1fb1 100644
--- a/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts
+++ b/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts
@@ -165,6 +165,85 @@ describe('canonical drawer History honours selected guest observation provenance
expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBe(50);
},
);
+
+ it.each(['stopped', ' STOPPED ', 'offline'])(
+ 'withdraws native %s VM disk carriers before considering a retained read reason',
+ (runtimeStatus) => {
+ for (const diskStatusReason of ['', 'prev-agent-busy']) {
+ const value = resource('current', 0);
+ value.proxmox = { runtimeStatus, diskStatusReason };
+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({
+ disk: undefined,
+ usage: undefined,
+ memory: 0,
+ cpu: 10,
+ netin: 0,
+ });
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toEqual({
+ lastKnownValue: undefined,
+ message: 'Guest filesystem stats unavailable while the VM is stopped.',
+ });
+ value.lastSeen += 3600000;
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();
+ }
+ },
+ );
+
+ it('uses native running state over canonical offline, keeping accepted zero current', () => {
+ const value = resource('current');
+ value.status = 'offline';
+ value.proxmox = { runtimeStatus: ' RUNNING ', diskStatusReason: '' };
+ value.disk = { current: 0 };
+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 0, usage: 0 });
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();
+ value.proxmox.diskStatusReason = 'vm-stopped';
+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();
+ });
+
+ it.each([undefined, '', ' '])(
+ 'uses canonical offline only when native state is absent (%s)',
+ (runtimeStatus) => {
+ const value = resource('current');
+ value.status = 'offline';
+ value.proxmox = { runtimeStatus };
+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.message).toContain(
+ 'VM is stopped',
+ );
+ },
+ );
+
+ it('honours native power for a VM with Proxmox among its platform scopes', () => {
+ const value = resource('current');
+ value.platformType = 'agent';
+ value.platformScopes = ['agent', 'proxmox-pve'];
+ value.proxmox = { runtimeStatus: 'stopped' };
+ expect(getResourceMetricsHistoryCurrentMetrics(value).disk).toBeUndefined();
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk.lastKnownValue).toBeUndefined();
+ });
+
+ it.each(['system-container', 'storage', 'disk', 'agent'] as const)(
+ 'does not apply VM filesystem power/read rules to independent %s metrics',
+ (type) => {
+ const value = resource('current');
+ value.type = type;
+ value.status = 'offline';
+ value.proxmox = { runtimeStatus: 'stopped', diskStatusReason: 'prev-agent-busy' };
+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 50, usage: 50 });
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();
+ },
+ );
+
+ it('leaves a vSphere-only VM independent of Proxmox power/read metadata', () => {
+ const value = resource('current');
+ value.platformType = 'vmware-vsphere';
+ value.platformScopes = ['vmware-vsphere'];
+ value.status = 'offline';
+ value.proxmox = { runtimeStatus: 'stopped', diskStatusReason: 'prev-agent-busy' };
+ expect(getResourceMetricsHistoryCurrentMetrics(value)).toMatchObject({ disk: 50, usage: 50 });
+ expect(getResourceMetricsHistoryDeferredMetrics(value).disk).toBeUndefined();
+ });
});
describe('getResourceMetricsHistoryTarget branch coverage', () => {
diff --git a/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts b/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts
index 8d4ee55a4b..d0c8a50c8a 100644
--- a/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts
+++ b/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts
@@ -20,7 +20,7 @@ import {
} from '@/features/storageBackups/diskTemperaturePresentation';
import { asTrimmedString } from '@/utils/stringUtils';
import { getMemoryObservationPresentation } from '@/utils/memoryObservation';
-import { getWorkloadGuestDiskStatusMessage } from '@/utils/workloadGuestPresentation';
+import { getWorkloadGuestDiskRead } from '@/utils/workloadGuestPresentation';
const finiteMetric = (value: number | undefined): number | undefined =>
typeof value === 'number' && Number.isFinite(value) ? value : undefined;
@@ -173,10 +173,22 @@ const memoryReading = (resource: Resource) =>
isProxmoxGuest(resource),
);
-const diskReadReason = (resource: Resource): string | undefined =>
- resource.type === 'vm' && isProxmoxGuest(resource)
- ? resource.proxmox?.diskStatusReason || undefined
- : undefined;
+const guestDiskReading = (resource: Resource) => {
+ if (resource.type !== 'vm' || !isProxmoxGuest(resource)) return null;
+ // A linked source can keep the canonical resource online while Proxmox
+ // reports the VM stopped. Judge filesystem carriers by the native state,
+ // using the same read admission as Workloads and Alerts, not Last seen.
+ const status = (asTrimmedString(resource.proxmox?.runtimeStatus) || resource.status)
+ .trim()
+ .toLowerCase();
+ return getWorkloadGuestDiskRead(
+ {
+ status: status === 'offline' ? 'stopped' : status,
+ diskStatusReason: resource.proxmox?.diskStatusReason,
+ },
+ true,
+ );
+};
// A physical disk's reading and its collection state both live on
// physicalDisk, so read them only together: websocket rows carry no top-level
@@ -203,14 +215,14 @@ export const getResourceMetricsHistoryDeferredMetrics = (
message: memory.message,
};
}
- const reason = diskReadReason(resource);
- if (reason) {
+ const disk = guestDiskReading(resource);
+ if (disk && disk.state !== 'current') {
metrics.disk = {
lastKnownValue:
- reason.startsWith('prev-') && resource.disk
+ disk.state === 'last-known' && resource.disk
? finiteMetric(getDiskPercent(resource))
: undefined,
- message: getWorkloadGuestDiskStatusMessage(reason),
+ message: disk.message,
};
}
if (!isResourceTemperatureCurrent(resource)) {
@@ -232,7 +244,11 @@ export const getResourceMetricsHistoryDeferredMetrics = (
export const getResourceMetricsHistoryCurrentMetrics = (
resource: Resource,
): Record<string, number | undefined> => {
- const diskPercent = resource.disk ? finiteMetric(getDiskPercent(resource)) : undefined;
+ const disk = guestDiskReading(resource);
+ const diskPercent =
+ resource.disk && (!disk || disk.state === 'current')
+ ? finiteMetric(getDiskPercent(resource))
+ : undefined;
const temperature = isResourceTemperatureCurrent(resource)
? finiteMetric(resourceTemperature(resource))
: undefined;
@@ -243,7 +259,7 @@ export const getResourceMetricsHistoryCurrentMetrics = (
resource.memory && (!memory || memory.state === 'current')
? finiteMetric(getMemoryPercent(resource))
: undefined,
- disk: diskReadReason(resource) ? undefined : diskPercent,
+ disk: diskPercent,
usage: diskPercent,
netin: finiteMetric(resource.network?.rxBytes),
netout: finiteMetric(resource.network?.txBytes),