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.

Keep Discovery outcomes attached to their guest and run

pulse-triage[bot]817834440b3d
diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.cjs b/frontend-modern/browser-tests/discovery-outcome-ownership.cjs
new file mode 100644
index 0000000000..3d7238fbab
--- /dev/null
+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.cjs
@@ -0,0 +1,301 @@
+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 output = '/workspace/tmp/discovery-ownership-proof/browser';
+const origin = 'http://127.0.0.1:5333';
+const runtime = [
+ 'frontend-modern/src/components/Discovery/DiscoveryTab.tsx',
+ 'frontend-modern/src/components/Discovery/useDiscoveryTabState.ts',
+ 'frontend-modern/src/components/Workloads/GuestDrawer.tsx',
+];
+const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
+const saved = (id, service = `Saved Home Assistant ${id}`) => ({
+ id: `vm:fixture-node-agent:${id}`,
+ resource_type: 'vm',
+ resource_id: id,
+ target_id: 'fixture-node-agent',
+ hostname: `guest-${id}`,
+ service_type: 'home-assistant',
+ service_name: service,
+ service_version: 'test',
+ category: 'home_automation',
+ cli_access: '',
+ facts: [],
+ config_paths: [],
+ data_paths: [],
+ log_paths: [],
+ ports: [],
+ user_notes: '',
+ user_secrets: {},
+ confidence: 0.9,
+ ai_reasoning: 'Synthetic saved evidence',
+ discovered_at: '2026-10-03T12:00:00Z',
+ updated_at: '2026-10-03T12:00:00Z',
+ discovery_engine_version: 1,
+});
+(async () => {
+ fs.mkdirSync(output, { recursive: true });
+ const report = {
+ result: 'incomplete',
+ playwright: require('playwright/package.json').version,
+ runtime_sha256: Object.fromEntries(runtime.map((p) => [p, hash('/workspace/' + p)])),
+ groups: [],
+ screenshots: [],
+ cleanup: {},
+ limits:
+ 'Production DiscoveryTab/state/CSS, synthetic API and production event-bus progress. No native QGA, automatic collector, original freeze cause, thaw, covered filesystem writes, installed, physical-phone or release acceptance.',
+ };
+ assert.equal(
+ report.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',
+ server: { host: '127.0.0.1', port: 5333, strictPort: true, watch: null },
+ });
+ let browser,
+ phase = 'server';
+ try {
+ await server.listen();
+ for (const [name, engine, width, dark] of [
+ ['desktop-light', chromium, 1365, false],
+ ['desktop-dark', chromium, 1365, true],
+ ['phone-dark', webkit, 390, true],
+ ['narrow-light', webkit, 320, false],
+ ]) {
+ phase = name;
+ browser = await engine.launch(
+ engine === chromium
+ ? { headless: true, channel: 'chromium', args: ['--no-sandbox'] }
+ : { headless: true },
+ );
+ const page = await browser.newPage({
+ viewport: { width, height: width < 500 ? 844 : 900 },
+ isMobile: width < 500,
+ hasTouch: width < 500,
+ locale: 'en-GB',
+ timezoneId: 'UTC',
+ });
+ page.setDefaultTimeout(10000);
+ page.setDefaultNavigationTimeout(60000);
+ const group = {
+ name,
+ width,
+ dark,
+ browser: browser.version(),
+ checks: [],
+ requests: [],
+ errors: [],
+ offOrigin: [],
+ };
+ report.groups.push(group);
+ page.on('pageerror', (error) => group.errors.push(error.message));
+ await page.routeWebSocket('**/ws*', () => {});
+ await page.addInitScript((dark) => {
+ const apply = () => document.documentElement.classList.toggle('dark', dark);
+ if (document.documentElement) apply();
+ else document.addEventListener('DOMContentLoaded', apply, { once: true });
+ }, dark);
+ let fail = false;
+ const releases = new Map();
+ const arrivals = new Map();
+ const stored = new Map();
+ await page.route('**/*', async (route) => {
+ const request = route.request(),
+ url = new URL(request.url());
+ if (url.origin !== origin) {
+ group.offOrigin.push(url.origin);
+ return route.abort();
+ }
+ if (!url.pathname.startsWith('/api/')) return route.continue();
+ group.requests.push({
+ path: url.pathname,
+ method: request.method(),
+ body: request.postData(),
+ });
+ const target = url.pathname.match(/^\/api\/discovery\/vm\/fixture-node-agent\/(101|102)$/);
+ if (target) {
+ const id = target[1];
+ if (request.method() === 'GET')
+ return route.fulfill({ json: stored.get(id) || saved(id) });
+ assert.equal(request.method(), 'POST');
+ if (fail)
+ return route.fulfill({
+ status: 409,
+ json: { error: 'Guest execution paused: backup lock observed' },
+ });
+ await new Promise((resolve) => {
+ releases.set(id, resolve);
+ arrivals.get(id)?.();
+ });
+ const result = saved(id, id === '101' ? 'Old guest result' : 'Current guest result');
+ stored.set(id, result);
+ return route.fulfill({ json: result });
+ }
+ assert.equal(request.method(), 'GET');
+ const responses = {
+ '/api/discovery/info/vm': {
+ ai_provider: { provider: 'test', model: 'test', is_local: true, label: 'Local' },
+ commands: [],
+ command_categories: [],
+ },
+ '/api/ai/agents': {
+ count: 1,
+ agents: [{ agent_id: 'fixture-node-agent', hostname: 'pve1' }],
+ },
+ '/api/ai/settings': { discovery_enabled: true, enabled: false },
+ '/api/license/runtime-capabilities': {
+ capabilities: [],
+ limits: [],
+ hosted_mode: false,
+ runtime: { build: 'community' },
+ blocked_capabilities: [],
+ },
+ };
+ return route.fulfill({ json: responses[url.pathname] || {} });
+ });
+ const capture = async (suffix) => {
+ await page.screenshot({ path: `${output}/${name}-${suffix}.png`, fullPage: true });
+ report.screenshots.push(`${name}-${suffix}.png`);
+ assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1));
+ };
+ const emit = (progress) =>
+ page.evaluate((progress) => window.discoveryOwnership.progress(progress), progress);
+ const run = page.getByRole('button', { name: 'Run Discovery', exact: true });
+ const pressRun = async () => {
+ if (width >= 500) {
+ await run.focus();
+ await page.keyboard.press('Enter');
+ } else await run.tap();
+ };
+ await page.goto(origin + '/browser-tests/discovery-outcome-ownership.html');
+ await page.getByText('Saved Home Assistant 101', { exact: true }).waitFor();
+ await run.waitFor();
+ await page.waitForFunction(
+ () =>
+ !Array.from(document.querySelectorAll('button')).find(
+ (b) => b.textContent.trim() === 'Run Discovery',
+ ).disabled,
+ );
+ const before = group.requests.length;
+ await emit({
+ resource_id: 'vm:fixture-node-agent:101',
+ status: 'running',
+ current_step: 'Collecting guest evidence',
+ percent_complete: 20,
+ });
+ await page.getByText('Collecting guest evidence', { exact: true }).waitFor();
+ await emit({
+ resource_id: 'vm:fixture-node-agent:101',
+ status: 'completed',
+ error: 'Guest execution paused: backup lock observed',
+ current_step: 'Guest execution paused',
+ percent_complete: 20,
+ });
+ const alert = page.getByRole('alert');
+ await alert.waitFor();
+ await page.waitForTimeout(650);
+ assert((await alert.innerText()).includes('Guest execution paused: backup lock observed'));
+ assert.equal(group.requests.length, before);
+ assert(await page.getByText('Saved Home Assistant 101', { exact: true }).isVisible());
+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);
+ await capture('retained-background-pause');
+ group.checks.push(
+ 'Background completed-with-error remains an accessible failure with saved evidence and no retry or refresh',
+ );
+ const dismiss = page.getByRole('button', { name: 'Dismiss Discovery error' });
+ await dismiss.focus();
+ await page.keyboard.press('Enter');
+ assert.equal(await alert.count(), 0);
+ group.checks.push('The error dismiss action has a keyboard-accessible name');
+ const firstPost = new Promise((resolve) => arrivals.set('101', resolve));
+ await pressRun();
+ await firstPost;
+ await page.waitForFunction(() => document.body.textContent.includes('Scanning...'));
+ await page.evaluate(() => window.discoveryOwnership.target('102'));
+ await page.getByText('Saved Home Assistant 102', { exact: true }).waitFor();
+ const secondPost = new Promise((resolve) => arrivals.set('102', resolve));
+ await pressRun();
+ await secondPost;
+ await page.waitForFunction(() => document.body.textContent.includes('Scanning...'));
+ assert(releases.has('101'));
+ assert(releases.has('102'));
+ releases.get('101')();
+ await page.waitForTimeout(150);
+ assert.equal(await page.getByText('Old guest result', { exact: true }).count(), 0);
+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);
+ assert(await page.getByRole('button', { name: 'Scanning...', exact: true }).isDisabled());
+ await emit({
+ resource_id: 'vm:fixture-node-agent:102',
+ status: 'completed',
+ percent_complete: 100,
+ });
+ assert(await page.getByRole('button', { name: 'Scanning...', exact: true }).isDisabled());
+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);
+ releases.get('102')();
+ await page.getByText('Current guest result', { exact: true }).waitFor();
+ await page.getByText('Discovery complete!', { exact: true }).waitFor();
+ group.checks.push(
+ 'Late old-target HTTP and scanner completion cannot replace the current guest or finish its active HTTP request',
+ );
+ const posts = group.requests.filter((r) => r.method === 'POST');
+ assert.equal(posts.length, 2);
+ assert.deepEqual(
+ posts.map((p) => JSON.parse(p.body)),
+ [
+ { force: true, hostname: 'guest-101' },
+ { force: true, hostname: 'guest-102' },
+ ],
+ );
+ await capture('current-guest-result');
+ await emit({ resource_id: 'vm:fixture-node-agent:102', status: 'completed' });
+ await page.waitForTimeout(650);
+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);
+ assert(await page.getByText('Current guest result', { exact: true }).isVisible());
+ assert.equal(group.requests.filter((r) => r.method === 'POST').length, 2);
+ group.checks.push(
+ 'Later completion cannot strand the old HTTP success banner or issue an automatic scan',
+ );
+ fail = true;
+ await pressRun();
+ await alert.waitFor();
+ assert((await alert.innerText()).includes('Guest execution paused: backup lock observed'));
+ assert(await page.getByText('Current guest result', { exact: true }).isVisible());
+ assert.equal(await page.getByText('Discovery complete!', { exact: true }).count(), 0);
+ await page.waitForTimeout(650);
+ assert.equal(group.requests.filter((r) => r.method === 'POST').length, 3);
+ group.checks.push(
+ 'A failed explicit run retains prior saved evidence, visible failure and no automatic retry',
+ );
+ assert.deepEqual(group.errors, []);
+ assert.deepEqual(group.offOrigin, []);
+ await browser.close();
+ browser = null;
+ }
+ report.result = 'passed';
+ report.verified_at = new Date().toISOString();
+ } catch (error) {
+ report.result = 'failed';
+ report.phase = phase;
+ report.error = String(error.stack || error);
+ throw error;
+ } finally {
+ if (browser) await browser.close();
+ report.cleanup.browser_closed = true;
+ await server.close();
+ report.cleanup.server_closed = true;
+ fs.writeFileSync(output + '/result.json', JSON.stringify(report, null, 2) + '\n');
+ }
+})().catch((error) => {
+ console.error(error.stack || String(error));
+ process.exitCode = 1;
+});
diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.html b/frontend-modern/browser-tests/discovery-outcome-ownership.html
new file mode 100644
index 0000000000..7b3a737737
--- /dev/null
+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.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>Discovery outcome ownership evidence</title>
+ </head>
+ <body>
+ <div id="root"></div>
+ <script type="module" src="./discovery-outcome-ownership.tsx"></script>
+ </body>
+</html>
diff --git a/frontend-modern/browser-tests/discovery-outcome-ownership.tsx b/frontend-modern/browser-tests/discovery-outcome-ownership.tsx
new file mode 100644
index 0000000000..c9fe99348c
--- /dev/null
+++ b/frontend-modern/browser-tests/discovery-outcome-ownership.tsx
@@ -0,0 +1,54 @@
+import { createSignal } from 'solid-js';
+import { render } from 'solid-js/web';
+import { Router, Route } from '@solidjs/router';
+import { DiscoveryTab } from '../src/components/Discovery/DiscoveryTab';
+import { eventBus } from '../src/stores/events';
+import { syncAIRuntimeSettings } from '../src/stores/aiRuntimeState';
+import type { DiscoveryProgress } from '../src/types/discovery';
+import '../src/index.css';
+
+declare global {
+ interface Window {
+ discoveryOwnership: {
+ target: (id: string) => void;
+ progress: (progress: DiscoveryProgress) => void;
+ enabled: (enabled: boolean) => void;
+ };
+ }
+}
+
+function Fixture() {
+ const [id, setId] = createSignal('101');
+ const enabled = (discovery_enabled: boolean) =>
+ syncAIRuntimeSettings({ discovery_enabled } as Parameters<typeof syncAIRuntimeSettings>[0]);
+ enabled(true);
+ window.discoveryOwnership = {
+ target: setId,
+ progress: (progress) => eventBus.emit('ai_discovery_progress', progress),
+ enabled,
+ };
+ return (
+ <main class="mx-auto min-h-screen max-w-4xl space-y-3 bg-surface p-3 text-base-content">
+ <h1 class="text-base font-semibold">Discovery outcome ownership evidence</h1>
+ <p class="text-xs text-muted">Synthetic guest responses. No guest command is sent.</p>
+ <h2 class="text-sm font-medium">Guest {id()}</h2>
+ <DiscoveryTab
+ resourceType="vm"
+ agentId="fixture-node-agent"
+ resourceId={id()}
+ canonicalResourceId={`fixture-pve1-${id()}`}
+ hostname={`guest-${id()}`}
+ showManualRunAction
+ />
+ </main>
+ );
+}
+
+render(
+ () => (
+ <Router>
+ <Route path="/*" component={Fixture} />
+ </Router>
+ ),
+ document.getElementById('root')!,
+);
diff --git a/frontend-modern/browser-tests/guest-discovery-completion.cjs b/frontend-modern/browser-tests/guest-discovery-completion.cjs
new file mode 100644
index 0000000000..25bb445ee3
--- /dev/null
+++ b/frontend-modern/browser-tests/guest-discovery-completion.cjs
@@ -0,0 +1,19 @@
+const { spawnSync } = require('node:child_process');
+for (const script of ['guest-discovery-safety.cjs', 'discovery-outcome-ownership.cjs']) {
+ const result = spawnSync(
+ process.execPath,
+ ['/workspace/frontend-modern/browser-tests/' + script],
+ { stdio: 'inherit' },
+ );
+ if (result.status !== 0) {
+ console.error(
+ script,
+ 'did not complete successfully',
+ result.status,
+ result.signal,
+ result.error?.message,
+ );
+ process.exit(result.status || 1);
+ }
+}
+console.log('Combined guest Discovery pause and outcome ownership browser proof passed.');
diff --git a/frontend-modern/browser-verification/c45de66a92dcfc91.json b/frontend-modern/browser-verification/c45de66a92dcfc91.json
new file mode 100644
index 0000000000..88b556048b
--- /dev/null
+++ b/frontend-modern/browser-verification/c45de66a92dcfc91.json
@@ -0,0 +1,79 @@
+{
+ "version": 1,
+ "base_sha": "bc3f4d81d14873caae6f769dfa670d16fa13d518",
+ "verified_at": "2026-10-04T20:32:45.762Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/components/Discovery/DiscoveryTab.tsx",
+ "frontend-modern/src/components/Discovery/useDiscoveryTabState.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/components/Discovery/DiscoveryTab.tsx": "2e93209a2b3830f77a0ad94d02bd59ea01509932f8d51e594d60f55d1f5895d0",
+ "frontend-modern/src/components/Discovery/useDiscoveryTabState.ts": "e600bb993b80e85b6df48a9e070f1bc2db51d7bb8e5ffd6216e3861d610def14"
+ },
+ "routes": [
+ "/browser-tests/guest-discovery-safety.html: production Workloads row, GuestDrawer and DiscoveryTab with synthetic canonical snapshots",
+ "/browser-tests/discovery-outcome-ownership.html: reused production DiscoveryTab/state, synthetic per-guest APIs and production event-bus progress"
+ ],
+ "viewports": [
+ {
+ "width": 1365,
+ "height": 900
+ },
+ {
+ "width": 390,
+ "height": 844
+ },
+ {
+ "width": 320,
+ "height": 844
+ }
+ ],
+ "states": [
+ "Guest operation lock and all current guest-read deferrals with/without retained data; healthy explicit action",
+ "Original HTTP result retained after a same-target precaution without cancellation or another scan",
+ "Background completed-with-error retains an accessible failed outcome and saved evidence",
+ "Late old-target HTTP result cannot overwrite the current guest or stop its manual request",
+ "Scanner completion during HTTP does not claim saved success; later terminal event cannot strand earlier success",
+ "Current explicit failure remains visible without an automatic retry"
+ ],
+ "interactions": [
+ "Keyboard and touch drawer expansion, Discovery tabs, explicit enabled runs and associated disabled reasons",
+ "No POST on blocked/unlock/tab/snapshot change and exactly one target/body POST per explicit healthy action",
+ "Keyboard-labelled error dismissal with saved content preserved",
+ "Change target during an in-flight request, deliver the old and current responses independently and inspect original ownership",
+ "Render desktop light/dark and WebKit 390px/320px, inspect wrapping and all 24 captures"
+ ],
+ "script": "frontend-modern/browser-tests/guest-discovery-completion.cjs",
+ "browsers": [
+ {
+ "name": "desktop-light",
+ "browser": "141.0.7390.37",
+ "width": 1365,
+ "dark": false
+ },
+ {
+ "name": "desktop-dark",
+ "browser": "141.0.7390.37",
+ "width": 1365,
+ "dark": true
+ },
+ {
+ "name": "phone-dark",
+ "browser": "26.0",
+ "width": 390,
+ "dark": true
+ },
+ {
+ "name": "narrow-light",
+ "browser": "26.0",
+ "width": 320,
+ "dark": false
+ }
+ ],
+ "limitations": [
+ "Synthetic inputs and API responses, not native QGA, backup or automatic poller acceptance.",
+ "Vite-transformed production components. Exact production build is checked separately in the source-proof VM.",
+ "No original freeze cause, independent thaw, covered-filesystem writes, installed use, physical phone or containing release is established."
+ ]
+}
diff --git a/frontend-modern/src/components/Discovery/DiscoveryTab.tsx b/frontend-modern/src/components/Discovery/DiscoveryTab.tsx
index 169fd12981..a95395eed0 100644
--- a/frontend-modern/src/components/Discovery/DiscoveryTab.tsx
+++ b/frontend-modern/src/components/Discovery/DiscoveryTab.tsx
@@ -474,7 +474,10 @@ export const DiscoveryTab: Component<DiscoveryTabProps> = (props) => {
{/* Scan Error */}
<Show when={scanError()}>
- <div class="mb-4 rounded-md border border-red-200 bg-red-50 p-4 dark:border-red-800 dark:bg-red-900/25">
+ <div
+ role="alert"
+ class="mb-4 rounded-md border border-red-200 bg-red-50 p-4 dark:border-red-800 dark:bg-red-900/25"
+ >
<div class="flex items-start gap-3">
<svg
class="w-5 h-5 text-red-500 dark:text-red-400 shrink-0 mt-0.5"
@@ -490,10 +493,14 @@ export const DiscoveryTab: Component<DiscoveryTabProps> = (props) => {
/>
</svg>
<div>
- <p class="text-sm font-medium text-red-800 dark:text-red-200">Discovery Failed</p>
+ <p class="text-sm font-medium text-red-800 dark:text-red-200">
+ Discovery did not complete
+ </p>
<p class="text-sm text-red-700 dark:text-red-300 mt-1">{scanError()}</p>
</div>
<button
+ type="button"
+ aria-label="Dismiss Discovery error"
onClick={() => setScanError(null)}
class="ml-auto text-red-500 hover:text-red-700 dark:text-red-400 dark:hover:text-red-300"
>
diff --git a/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx
index ab6a4c1014..e2cdd43843 100644
--- a/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx
+++ b/frontend-modern/src/components/Discovery/__tests__/DiscoveryRun.lifecycle.test.tsx
@@ -144,9 +144,13 @@ describe('Discovery outcome ownership', () => {
vi.mocked(api.triggerDiscovery).mockReturnValueOnce(old.promise);
const { state } = await mount();
const first = state.handleTriggerDiscovery(true);
- syncAIRuntimeSettings({ discovery_enabled: false } as Parameters<typeof syncAIRuntimeSettings>[0]);
+ syncAIRuntimeSettings({ discovery_enabled: false } as Parameters<
+ typeof syncAIRuntimeSettings
+ >[0]);
await waitFor(() => expect(state.canTriggerDiscovery()).toBe(false));
- syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<typeof syncAIRuntimeSettings>[0]);
+ syncAIRuntimeSettings({ discovery_enabled: true } as Parameters<
+ typeof syncAIRuntimeSettings
+ >[0]);
await waitFor(() => expect(state.canTriggerDiscovery()).toBe(true));
old.resolve({ ...saved(), service_name: 'Disabled run result' });
await first;
@@ -188,6 +192,19 @@ describe('Discovery outcome ownership', () => {
expect(state.scanSuccess()).toBe(false);
});
+ it('does not leave the previous HTTP success visible forever after a later completion event', async () => {
+ const { state } = await mount();
+ vi.useFakeTimers();
+ await state.handleTriggerDiscovery(true);
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
+ await vi.advanceTimersByTimeAsync(2500);
+ expect(state.scanSuccess()).toBe(false);
+ expect(state.discovery()?.resource_id).toBe('100');
+ });
+
it.each(['failed', 'completed'] as const)(
'retains a background %s-with-error outcome and the saved evidence, not silent success',
async (status) => {
@@ -219,10 +236,16 @@ describe('Discovery outcome ownership', () => {
current_step: 'Collecting guest evidence',
});
expect(state.isScanning()).toBe(true);
- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
expect(state.isScanning()).toBe(false);
const first = state.handleTriggerDiscovery(true);
- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
expect(state.isScanning()).toBe(true);
expect(state.scanSuccess()).toBe(false);
http.resolve(saved());
@@ -233,7 +256,10 @@ describe('Discovery outcome ownership', () => {
it('drops a delayed background refresh when its target changed before dispatch', async () => {
const { state, setId } = await mount();
vi.useFakeTimers();
- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
setId('101');
await Promise.resolve();
const before = vi.mocked(api.getDiscovery).mock.calls.length;
@@ -248,9 +274,15 @@ describe('Discovery outcome ownership', () => {
const { state } = await mount();
vi.mocked(api.getDiscovery).mockReturnValueOnce(refresh.promise);
vi.useFakeTimers();
- eventBus.emit('ai_discovery_progress', { resource_id: 'vm:node-agent:100', status: 'completed' });
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
await vi.advanceTimersByTimeAsync(500);
- vi.mocked(api.triggerDiscovery).mockResolvedValueOnce({ ...saved(), service_name: 'New manual result' });
+ vi.mocked(api.triggerDiscovery).mockResolvedValueOnce({
+ ...saved(),
+ service_name: 'New manual result',
+ });
await state.handleTriggerDiscovery(true);
refresh.resolve({ ...saved(), service_name: 'Old background result' });
await Promise.resolve();
@@ -258,6 +290,35 @@ describe('Discovery outcome ownership', () => {
expect(state.scanSuccess()).toBe(true);
});
+ it.each([401, 403])(
+ 'withdraws saved evidence when a completion refresh is denied with %s',
+ async (status) => {
+ const { state } = await mount();
+ vi.mocked(api.getDiscovery).mockRejectedValueOnce(
+ Object.assign(new Error('Discovery details unavailable.'), { status }),
+ );
+ vi.useFakeTimers();
+ eventBus.emit('ai_discovery_progress', {
+ resource_id: 'vm:node-agent:100',
+ status: 'completed',
+ });
+ await vi.advanceTimersByTimeAsync(500);
+ expect(state.discovery()).toBeNull();
+ expect(state.scanSuccess()).toBe(false);
+ expect(api.triggerDiscovery).not.toHaveBeenCalled();
+ },
+ );
+
+ it('keeps saved evidence without success when HTTP supplies no result', async () => {
+ vi.mocked(api.triggerDiscovery).mockResolvedValueOnce(null as unknown as ResourceDiscovery);
+ const { state } = await mount();
+ await state.handleTriggerDiscovery(true);
+ expect(state.scanError()).toBe('Discovery returned no saved result.');
+ expect(state.scanSuccess()).toBe(false);
+ expect(state.discovery()?.service_name).toBe('Saved service 100');
+ expect(state.isScanning()).toBe(false);
+ });
+
it('does not close another guest’s notes editor when an old save finishes', async () => {
const save = deferred<void>();
vi.mocked(api.updateDiscoveryNotes).mockReturnValueOnce(save.promise);
diff --git a/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts b/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts
index b362dc984f..f45c6ae457 100644
--- a/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts
+++ b/frontend-modern/src/components/Discovery/useDiscoveryTabState.ts
@@ -47,6 +47,18 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
const [httpScanInProgress, setHttpScanInProgress] = createSignal(false);
const [copiedDiscoveryValue, setCopiedDiscoveryValue] = createSignal('');
let copyFeedbackTimer: ReturnType<typeof setTimeout> | undefined;
+ let successTimer: ReturnType<typeof setTimeout> | undefined;
+ let completionTimer: ReturnType<typeof setTimeout> | undefined;
+ let contextVersion = 0;
+ let runVersion = 0;
+ let disposed = false;
+
+ const clearScanTimers = () => {
+ clearTimeout(successTimer);
+ clearTimeout(completionTimer);
+ successTimer = undefined;
+ completionTimer = undefined;
+ };
const targetAgentId = createMemo(() => props.agentId || '');
const discoverySourceKey = createMemo(
@@ -59,6 +71,23 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
const { discoveryFeatureEnabled, discoveryFeatureKnownDisabled } =
useDiscoveryFeatureAvailability();
+ // A target key alone is insufficient: leaving and returning to the same
+ // guest must not admit a response from the previous visit. A precaution on
+ // the same target does not change this ownership or cancel dispatched work.
+ const captureContext = () => ({
+ version: contextVersion,
+ key: discoverySourceKey(),
+ type: props.resourceType,
+ agentId: targetAgentId(),
+ resourceId: props.resourceId,
+ hostname: props.hostname,
+ });
+ const isCurrentContext = (context: ReturnType<typeof captureContext>) =>
+ !disposed &&
+ context.version === contextVersion &&
+ context.key === discoverySourceKey() &&
+ discoveryFeatureEnabled();
+
const [discoveryInfo] = createResource(
() => (discoveryFeatureEnabled() ? props.resourceType : null),
async (type) => {
@@ -150,6 +179,9 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
createEffect(() => {
void discoveryFeatureEnabled();
void discoverySourceKey();
+ contextVersion++;
+ runVersion++;
+ clearScanTimers();
setIsScanning(false);
setHttpScanInProgress(false);
setScanProgress(null);
@@ -193,14 +225,22 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
const handleTriggerDiscovery = async (force = false) => {
// Check the current snapshot at the dispatch boundary as well as disabling
- // buttons. A retained handler must not use an earlier enabled verdict.
- // Do not cancel an already dispatched scan or hide its eventual outcome.
- if (runBlockReason() || isScanning()) return;
+ // buttons. Do not cancel a dispatched scan when a precaution appears.
+ if (disposed || runBlockReason() || isScanning()) return;
if (!discoveryFeatureEnabled()) {
setScanError('Service context is disabled in Settings -> Pulse Intelligence -> Assistant.');
return;
}
+ const context = captureContext();
+ if (!context.agentId) {
+ setScanError('Agent identifier unavailable for discovery');
+ return;
+ }
+ if (!aiProviderConfigured()) return;
+ clearScanTimers();
+ const version = ++runVersion;
+ const ownsRun = () => isCurrentContext(context) && version === runVersion;
setIsScanning(true);
setHttpScanInProgress(true);
setScanProgress(null);
@@ -210,59 +250,58 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
setLiveElapsedSeconds(0);
try {
- const agentId = targetAgentId();
- if (!agentId) {
- setScanError('Agent identifier unavailable for discovery');
- return;
- }
-
- const result = await triggerDiscovery(props.resourceType, agentId, props.resourceId, {
+ const result = await triggerDiscovery(context.type, context.agentId, context.resourceId, {
force,
- hostname: props.hostname,
+ hostname: context.hostname,
});
- if (result) {
- mutate(result);
- }
-
- setHttpScanInProgress(false);
- setIsScanning(false);
- setScanProgress(null);
- setScanStartTime(null);
+ if (!ownsRun()) return;
+ if (!result) throw new Error('Discovery returned no saved result.');
+ mutate(result);
+ setScanError(null);
setScanSuccess(true);
- setTimeout(() => setScanSuccess(false), 2000);
+ successTimer = setTimeout(() => {
+ successTimer = undefined;
+ if (ownsRun()) setScanSuccess(false);
+ }, 2000);
} catch (err) {
+ if (!ownsRun()) return;
console.error('Discovery failed:', err);
const message = err instanceof Error ? err.message : 'Discovery scan failed';
-
- if (message.includes('no connected agent')) {
- setScanError(getDiscoveryNoConnectedAgentMessage(props.commandsEnabled));
- } else {
- setScanError(message);
+ setScanError(
+ message.includes('no connected agent')
+ ? getDiscoveryNoConnectedAgentMessage(props.commandsEnabled)
+ : message,
+ );
+ } finally {
+ if (ownsRun()) {
+ setHttpScanInProgress(false);
+ setIsScanning(false);
+ setScanProgress(null);
+ setScanStartTime(null);
}
-
- setHttpScanInProgress(false);
- setIsScanning(false);
- setScanProgress(null);
- setScanStartTime(null);
}
};
const handleSaveNotes = async () => {
+ if (disposed || !discoveryFeatureEnabled()) return;
setSaveError(null);
- const agentId = targetAgentId();
- if (!agentId) {
+ const context = captureContext();
+ if (!context.agentId) {
setSaveError('Agent identifier unavailable for discovery');
return;
}
try {
- await updateDiscoveryNotes(props.resourceType, agentId, props.resourceId, {
+ await updateDiscoveryNotes(context.type, context.agentId, context.resourceId, {
user_notes: notesText(),
});
+ if (!isCurrentContext(context)) return;
setEditingNotes(false);
await refetch();
} catch (err) {
- setSaveError(err instanceof Error ? err.message : 'Failed to save notes');
+ if (isCurrentContext(context)) {
+ setSaveError(err instanceof Error ? err.message : 'Failed to save notes');
+ }
}
};
@@ -278,14 +317,19 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
};
onCleanup(() => {
+ disposed = true;
+ contextVersion++;
+ runVersion++;
+ clearScanTimers();
clearCopyFeedbackTimer();
});
const handleCopyDiscoveryValue = async (value?: string | null) => {
const text = (value || '').trim();
if (!text) return;
+ const context = captureContext();
const copied = await copyToClipboard(text);
- if (!copied) return;
+ if (!copied || !isCurrentContext(context)) return;
clearCopyFeedbackTimer();
setCopiedDiscoveryValue(text);
@@ -302,28 +346,56 @@ export function useDiscoveryTabState(props: DiscoveryTabStateProps) {
if (!progress || progress.resource_id !== resourceId()) return;
setScanProgress(progress);
-
- if (
- (progress.status === 'completed' || progress.status === 'failed') &&
- !httpScanInProgress()
- ) {
- setIsScanning(false);
- setTimeout(async () => {
- const agentId = targetAgentId();
- if (!agentId) return;
-
- try {
- const result = await getDiscovery(props.resourceType, agentId, props.resourceId);
- if (result) {
- mutate(result);
- }
- } catch (err) {
- console.error('Failed to fetch discovery after completion:', err);
- }
-
- setScanProgress(null);
- }, 500);
+ if (progress.status === 'running' || progress.status === 'pending') {
+ if (!httpScanInProgress() && !isScanning()) {
+ clearScanTimers();
+ runVersion++;
+ setScanError(null);
+ setScanSuccess(false);
+ const startedAt = Date.parse(progress.started_at || '');
+ setScanStartTime(Number.isFinite(startedAt) ? startedAt : Date.now());
+ }
+ setIsScanning(true);
+ return;
}
+ if (progress.status !== 'completed' && progress.status !== 'failed') return;
+
+ // The scanner can emit completed-with-error when QGA is paused or no
+ // command evidence was collected. It is not successful saved Discovery.
+ // Keep that reason visible even when this tab did not initiate the scan.
+ const error =
+ progress.error?.trim() || (progress.status === 'failed' ? 'Discovery scan failed.' : null);
+ if (error) {
+ setScanError(error);
+ setScanSuccess(false);
+ }
+ // Scanner completion can precede analysis/persistence. A manual request
+ // owns its final result until HTTP settles, not an intermediate event.
+ if (httpScanInProgress()) return;
+
+ clearScanTimers();
+ const version = ++runVersion;
+ setScanSuccess(false);
+ setIsScanning(false);
+ setScanStartTime(null);
+ setScanProgress(null);
+ if (error) return;
+
+ const context = captureContext();
+ const ownsRefresh = () => isCurrentContext(context) && version === runVersion;
+ completionTimer = setTimeout(async () => {
+ completionTimer = undefined;
+ if (!context.agentId || !ownsRefresh()) return;
+ try {
+ const result = await getDiscovery(context.type, context.agentId, context.resourceId);
+ if (ownsRefresh()) mutate(result);
+ } catch (err) {
+ if (!ownsRefresh()) return;
+ const status = (err as { status?: number } | null)?.status;
+ if (status === 401 || status === 403) mutate(null);
+ console.error('Failed to fetch discovery after completion:', err);
+ }
+ }, 500);
});
onCleanup(() => {