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.

Explain why the Container update risk switch is locked

rcourtman357b1a505e80
diff --git a/docs/release-control/v6/internal/subsystems/api-contracts.md b/docs/release-control/v6/internal/subsystems/api-contracts.md
index 12452c53b1..0fd38347b5 100644
--- a/docs/release-control/v6/internal/subsystems/api-contracts.md
+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md
@@ -3187,6 +3187,11 @@ a new API state machine, queue contract, or verification-accounting field.
proof. The default API-backed presentation must stay on the selected control
level and its plain summary; it must not render a separate Limits disclosure,
hard-limit matrix, or always-on explanatory matrix beside the mode picker.
+ and the Patrol container update risk lock, so `/api/settings/ai`
+ `alert_triggered_analysis` stays the licence-masked API value while the
+ runtime-capabilities `ai_alerts` grant or `paid_runtime_required` block
+ decides which lock explanation the Patrol settings card renders, without a
+ new API field
and the Patrol run-record copy, so `finding_ids` remains the API-owned
fail-closed scoping input while the frontend presents selected history as a
Patrol run record instead of a generic findings filter or snapshot workflow
diff --git a/docs/release-control/v6/internal/subsystems/frontend-primitives.md b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
index e077067776..b2eb84d4c2 100644
--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md
+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md
@@ -4738,6 +4738,11 @@ stable accessible label and route unconfigured installs into the canonical
provider setup modal instead of falling back to generic "first pressed toggle"
selectors, provider-model-load heuristics, legacy hosted-model enablement, or
in-app trial acquisition.
+A settings toggle disabled by a plan or runtime lock must explain the lock in
+the card that owns it, not through the shared `Toggle` `locked` and
+`lockedMessage` props, which the primitive does not render. `AISettings.tsx`
+renders the Container update risk lock from the canonical Patrol availability
+presentation and links that explanation to the switch with `ariaDescribedBy`.
That same route-owned presentation rule also governs Patrol findings empty
states: shared section shells under `frontend-modern/src/features/patrol/`
must not render a green healthy empty state from `0 active findings` alone
diff --git a/docs/release-control/v6/internal/subsystems/patrol-intelligence.md b/docs/release-control/v6/internal/subsystems/patrol-intelligence.md
index dfbf50ed95..e04084427b 100644
--- a/docs/release-control/v6/internal/subsystems/patrol-intelligence.md
+++ b/docs/release-control/v6/internal/subsystems/patrol-intelligence.md
@@ -725,6 +725,16 @@ attention`, `approval needed`, `outcome verified`, `no active work`) instead
sentence across the header and mode control, repeatedly restate
infrastructure-unchanged caveats in the default view, or imply Patrol's main
value is a manual review chore.
+ Plan-gated Patrol capabilities share that one availability presentation:
+ `patrolAutonomyAvailability.ts` owns the precedence (runtime lock, then
+ hidden commercial surfaces, then plan lock) and the only action labels
+ (`Open Pro downloads`, `Plans & Billing`), while each capability supplies
+ its lock state and copy. The Patrol settings Container update risk trigger
+ (`ai_alerts`) uses `getPatrolAlertAnalysisAvailabilityPresentation`, so a
+ locked install sees why the trigger is unavailable beside the disabled
+ switch: a higher license plan, a missing Pulse Pro runtime, or, when
+ commercial surfaces are hidden, a neutral not-available line with no plan
+ or Pro wording. Actions appear only when upgrade prompts are allowed.
5. Add or change Patrol header schedule and runtime presentation through `frontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsx`, `frontend-modern/src/utils/aiPatrolSchedulePresentation.ts`, and `frontend-modern/src/utils/patrolRuntimePresentation.ts`.
Patrol must not surface retired hosted-model credit badges or trial-like activation prompts in the normal self-hosted GA app, even when legacy transport fields are still present.
6. Keep Patrol and chat identifier-label presentation aligned through the shared `frontend-modern/src/utils/textPresentation.ts`
diff --git a/frontend-modern/browser-verification/b254486b940deb2e.json b/frontend-modern/browser-verification/b254486b940deb2e.json
new file mode 100644
index 0000000000..f4f8ebe47f
--- /dev/null
+++ b/frontend-modern/browser-verification/b254486b940deb2e.json
@@ -0,0 +1,42 @@
+{
+ "version": 1,
+ "base_sha": "1dcf9418aae87f9427dbfc6bcae67dbde114bf8a",
+ "verified_at": "2026-10-05T21:16:11Z",
+ "result": "passed",
+ "changed_paths": [
+ "frontend-modern/src/components/Settings/AISettings.tsx",
+ "frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts"
+ ],
+ "content_sha256": {
+ "frontend-modern/src/components/Settings/AISettings.tsx": "d3966224e497b9f8f3cd701bea1661212c5f32c9cc15ff795c4001f851fae6ca",
+ "frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts": "240fe0f1988d881da4344811aa3fdcc8e452182da24414ca6c941ea72e8e545f"
+ },
+ "routes": [
+ "/settings/pulse-intelligence/patrol",
+ "/settings/pulse-intelligence/billing/plan"
+ ],
+ "viewports": [
+ {
+ "width": 1280,
+ "height": 900
+ },
+ {
+ "width": 390,
+ "height": 844
+ }
+ ],
+ "states": [
+ "Private stacks built from this tree: community runtime (7782/5282), community DEMO_MODE runtime (7783/5283) and a Pro runtime built from pulse-enterprise against this tree (7784/5284), mock data, dev-signed Pro and Enterprise licences. Playwright Chromium at 1280x900 dark and 390x844 light, plus the in-app browser pane.",
+ "Free community install (no licence, hideUpgrade true, hideCommercial false, ai_alerts absent, /api/settings/ai alert_triggered_analysis false via a real persisted save): switch disabled and off, card reads 'Higher license plan required. This install's plan does not include container update risk.' with no link; the switch's aria-describedby points at that line.",
+ "Unlicensed Pro runtime (prompts allowed, ai_alerts not granted, backend licence checker masks the setting to false): same plan-lock line plus a Plans & Billing link to /settings/pulse-intelligence/billing/plan.",
+ "Pro licence on the community runtime (ai_alerts blocked as paid_runtime_required): 'Pulse Pro runtime required. This install is running Pulse Community runtime. Install the Pulse Pro runtime to use container update risk.' plus Open Pro downloads (https://pulserelay.pro/download.html, new tab, noopener).",
+ "Hidden commercial surfaces via DEMO_MODE (hideCommercial and hideUpgrade true; read-only demo, so GET /api/settings/ai intercepted to alert_triggered_analysis false): 'Not available. This install does not include container update risk.' with no plan or Pro wording and no link.",
+ "Enterprise licence on the community runtime (white-label, hideCommercial true, ai_alerts runtime-blocked): runtime lock copy without the download link, which is the canonical runtime-before-commercial precedence shared with Patrol mode.",
+ "Pro licence on the Pro runtime: switch enabled, no lock line, no aria-describedby. No horizontal overflow and no page errors in any state; the disabled track styling is the pre-#2535 shared Toggle and is unchanged here."
+ ],
+ "interactions": [
+ "Clicked the Plans & Billing link from the locked card in the browser pane; it routed in-app to /settings/pulse-intelligence/billing/plan.",
+ "On the licensed Pro runtime, turned the container update risk switch on and saved Patrol settings; GET /api/settings/ai then returned alert_triggered_analysis true.",
+ "Switched licence state live (activate Pro, activate Enterprise, clear) against the same backend and reloaded the page for each state."
+ ]
+}
diff --git a/frontend-modern/src/components/Settings/AISettings.tsx b/frontend-modern/src/components/Settings/AISettings.tsx
index 931653fdec..a6f5c75a1e 100644
--- a/frontend-modern/src/components/Settings/AISettings.tsx
+++ b/frontend-modern/src/components/Settings/AISettings.tsx
@@ -1,4 +1,4 @@
-import { Component, For, createMemo, Show } from 'solid-js';
+import { Component, For, createMemo, createUniqueId, Show } from 'solid-js';
import { useNavigate } from '@solidjs/router';
import { AIChatMaintenanceSection } from '@/components/Settings/AIChatMaintenanceSection';
import { AISettingsDialogs } from '@/components/Settings/AISettingsDialogs';
@@ -18,8 +18,13 @@ import { FormSelect } from '@/components/shared/FormSelect';
import { LoadingSpinner } from '@/components/shared/LoadingSpinner';
import SettingsPanel from '@/components/shared/SettingsPanel';
import { Toggle } from '@/components/shared/Toggle';
+import { UpgradeLink } from '@/components/shared/UpgradeLink';
import { PATROL_PATH } from '@/routing/resourceLinks';
-import { getPatrolAutonomyAvailabilityPresentation } from '@/features/patrol/patrolAutonomyAvailability';
+import {
+ PATROL_ALERT_ANALYSIS_FEATURE_KEY,
+ getPatrolAlertAnalysisAvailabilityPresentation,
+ getPatrolAutonomyAvailabilityPresentation,
+} from '@/features/patrol/patrolAutonomyAvailability';
import { getRuntimeCapabilityBlock, hasFeature, runtimeCapabilities } from '@/stores/license';
import { getUpgradeActionDestination } from '@/stores/licenseCommercial';
import {
@@ -115,6 +120,17 @@ const PatrolSettingsContent: Component<{ state: ReturnType<typeof useAISettingsS
}),
);
const isPlanLockedPatrol = createMemo(() => patrolModeAvailability().kind === 'plan_locked');
+ const alertAnalysisAvailability = createMemo(() =>
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: props.state.alertAnalysisLocked(),
+ commercialSurfacesHidden: presentationPolicyHidesCommercialSurfaces(),
+ upgradePromptsHidden: presentationPolicyHidesUpgradePrompts(),
+ runtimeCapabilityBlock: getRuntimeCapabilityBlock(PATROL_ALERT_ANALYSIS_FEATURE_KEY),
+ runtime: runtimeCapabilities()?.runtime,
+ planUpgradeDestination: getUpgradeActionDestination(PATROL_ALERT_ANALYSIS_FEATURE_KEY),
+ }),
+ );
+ const alertAnalysisLockId = createUniqueId();
const intervalOptions = [
{ value: 0, label: 'Manual only' },
{ value: 60, label: 'Every hour' },
@@ -270,14 +286,38 @@ const PatrolSettingsContent: Component<{ state: ReturnType<typeof useAISettingsS
<p class="mt-1 text-xs text-muted">
Assess risk when container-update alerts fire.
</p>
+ <Show when={alertAnalysisAvailability().locked}>
+ <p id={alertAnalysisLockId} class="mt-1 text-xs text-muted">
+ <span class="font-medium text-base-content">
+ {alertAnalysisAvailability().title}.
+ </span>{' '}
+ {alertAnalysisAvailability().body}
+ <Show when={alertAnalysisAvailability().destination}>
+ {(destination) => (
+ <>
+ {' '}
+ <UpgradeLink
+ class="font-medium text-blue-600 hover:underline dark:text-blue-400"
+ destination={destination()}
+ >
+ {alertAnalysisAvailability().actionLabel}
+ </UpgradeLink>
+ </>
+ )}
+ </Show>
+ </p>
+ </Show>
</div>
<Toggle
checked={props.state.form.alertTriggeredAnalysis}
onChange={(event) =>
props.state.setForm('alertTriggeredAnalysis', event.currentTarget.checked)
}
- disabled={props.state.saving() || props.state.alertAnalysisLocked()}
+ disabled={props.state.saving() || alertAnalysisAvailability().locked}
ariaLabel="Enable container update risk analysis"
+ ariaDescribedBy={
+ alertAnalysisAvailability().locked ? alertAnalysisLockId : undefined
+ }
/>
</div>
</div>
diff --git a/frontend-modern/src/components/Settings/__tests__/AISettings.test.tsx b/frontend-modern/src/components/Settings/__tests__/AISettings.test.tsx
index 9625418385..55ce073d9f 100644
--- a/frontend-modern/src/components/Settings/__tests__/AISettings.test.tsx
+++ b/frontend-modern/src/components/Settings/__tests__/AISettings.test.tsx
@@ -37,6 +37,8 @@ const loadCommercialPostureMock = vi.fn();
const commercialPostureMock = vi.fn();
const entitlementsMock = vi.fn();
const presentationPolicyHidesUpgradePromptsMock = vi.fn();
+const presentationPolicyHidesCommercialSurfacesMock = vi.fn();
+const getRuntimeCapabilityBlockMock = vi.fn();
vi.mock('@/api/ai', () => ({
AIAPI: {
@@ -95,7 +97,7 @@ vi.mock('@/utils/logger', () => ({
vi.mock('@/stores/license', () => ({
hasFeature: (...args: unknown[]) => hasFeatureMock(...args),
- getRuntimeCapabilityBlock: () => undefined,
+ getRuntimeCapabilityBlock: (...args: unknown[]) => getRuntimeCapabilityBlockMock(...args),
loadRuntimeCapabilities: (...args: unknown[]) => loadLicenseStatusMock(...args),
runtimeCapabilities: () => ({ capabilities: [], runtime: undefined }),
}));
@@ -110,7 +112,7 @@ vi.mock('@/stores/licenseCommercial', () => ({
}));
vi.mock('@/stores/sessionPresentationPolicy', () => ({
- presentationPolicyHidesCommercialSurfaces: () => false,
+ presentationPolicyHidesCommercialSurfaces: () => presentationPolicyHidesCommercialSurfacesMock(),
presentationPolicyHidesUpgradePrompts: () => presentationPolicyHidesUpgradePromptsMock(),
}));
@@ -181,6 +183,8 @@ const resetAllMocks = () => {
commercialPostureMock.mockReset();
entitlementsMock.mockReset();
presentationPolicyHidesUpgradePromptsMock.mockReset();
+ presentationPolicyHidesCommercialSurfacesMock.mockReset();
+ getRuntimeCapabilityBlockMock.mockReset();
};
const setupDefaultMocks = () => {
@@ -212,6 +216,8 @@ const setupDefaultMocks = () => {
listSessionsMock.mockResolvedValue([]);
summarizeSessionMock.mockResolvedValue(undefined);
presentationPolicyHidesUpgradePromptsMock.mockReturnValue(false);
+ presentationPolicyHidesCommercialSurfacesMock.mockReturnValue(false);
+ getRuntimeCapabilityBlockMock.mockReturnValue(undefined);
};
describe('AISettings model loading error states', () => {
@@ -350,6 +356,106 @@ describe('AISettings model loading error states', () => {
expect(screen.getByRole('button', { name: /Open Patrol/i })).toBeInTheDocument();
});
+ describe('container update risk lock', () => {
+ const lockedPatrolSettings = () => ({
+ ...baseSettings(),
+ enabled: true,
+ configured: true,
+ // The backend masks this to false when the install lacks ai_alerts.
+ alert_triggered_analysis: false,
+ });
+ const containerRiskToggle = () =>
+ screen.getByLabelText('Enable container update risk analysis');
+ const lockExplanation = () => {
+ const describedBy = containerRiskToggle().getAttribute('aria-describedby');
+ expect(describedBy).toBeTruthy();
+ return document.getElementById(describedBy!)!;
+ };
+
+ it('explains a plan lock without an upgrade link on a free install', async () => {
+ hasFeatureMock.mockImplementation((feature: string) => feature !== 'ai_alerts');
+ presentationPolicyHidesUpgradePromptsMock.mockReturnValue(true);
+ getSettingsMock.mockResolvedValue(lockedPatrolSettings());
+
+ renderComponent('patrol');
+
+ await screen.findByLabelText('Enable container update risk analysis');
+ expect(containerRiskToggle()).toBeDisabled();
+ expect(lockExplanation()).toHaveTextContent(
+ "Higher license plan required. This install's plan does not include container update risk.",
+ );
+ expect(within(lockExplanation()).queryByRole('link')).toBeNull();
+ expect(screen.queryByRole('link', { name: 'Plans & Billing' })).toBeNull();
+ });
+
+ it('links Plans & Billing when upgrade prompts are allowed', async () => {
+ hasFeatureMock.mockImplementation((feature: string) => feature !== 'ai_alerts');
+ getSettingsMock.mockResolvedValue(lockedPatrolSettings());
+
+ renderComponent('patrol');
+
+ await screen.findByLabelText('Enable container update risk analysis');
+ expect(containerRiskToggle()).toBeDisabled();
+ const link = within(lockExplanation()).getByRole('link', { name: 'Plans & Billing' });
+ expect(link).toHaveAttribute('href', 'https://example.com/upgrade');
+ });
+
+ it('drops plan and Pro wording when commercial surfaces are hidden', async () => {
+ hasFeatureMock.mockImplementation((feature: string) => feature !== 'ai_alerts');
+ presentationPolicyHidesCommercialSurfacesMock.mockReturnValue(true);
+ presentationPolicyHidesUpgradePromptsMock.mockReturnValue(true);
+ getSettingsMock.mockResolvedValue(lockedPatrolSettings());
+
+ renderComponent('patrol');
+
+ await screen.findByLabelText('Enable container update risk analysis');
+ expect(containerRiskToggle()).toBeDisabled();
+ expect(lockExplanation()).toHaveTextContent(
+ 'Not available. This install does not include container update risk.',
+ );
+ expect(lockExplanation().textContent).not.toMatch(/plan|Pro\b/i);
+ expect(within(lockExplanation()).queryByRole('link')).toBeNull();
+ });
+
+ it('points a licensed community runtime at the Pro runtime download', async () => {
+ hasFeatureMock.mockImplementation((feature: string) => feature !== 'ai_alerts');
+ getRuntimeCapabilityBlockMock.mockImplementation((feature: string) =>
+ feature === 'ai_alerts'
+ ? {
+ key: 'ai_alerts',
+ reason: 'paid_runtime_required',
+ action_url: 'https://pulserelay.pro/download.html',
+ }
+ : undefined,
+ );
+ getSettingsMock.mockResolvedValue(lockedPatrolSettings());
+
+ renderComponent('patrol');
+
+ await screen.findByLabelText('Enable container update risk analysis');
+ expect(lockExplanation()).toHaveTextContent(
+ 'Pulse Pro runtime required. This install is running this runtime. Install the Pulse Pro runtime to use container update risk.',
+ );
+ expect(
+ within(lockExplanation()).getByRole('link', { name: 'Open Pro downloads' }),
+ ).toHaveAttribute('href', 'https://pulserelay.pro/download.html');
+ });
+
+ it('shows no lock explanation when the install includes the feature', async () => {
+ getSettingsMock.mockResolvedValue({
+ ...lockedPatrolSettings(),
+ alert_triggered_analysis: true,
+ });
+
+ renderComponent('patrol');
+
+ await screen.findByLabelText('Enable container update risk analysis');
+ expect(containerRiskToggle()).toBeEnabled();
+ expect(containerRiskToggle()).not.toHaveAttribute('aria-describedby');
+ expect(screen.queryByText(/Higher license plan required/)).toBeNull();
+ });
+ });
+
it('saves Patrol trigger settings from Pulse Intelligence Patrol settings', async () => {
getSettingsMock.mockResolvedValue({
...baseSettings(),
diff --git a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
index 768cf83f60..226f053d19 100644
--- a/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
+++ b/frontend-modern/src/components/Settings/__tests__/settingsArchitecture.test.ts
@@ -1459,6 +1459,35 @@ describe('settings architecture guardrails', () => {
);
});
+ it('explains the container update risk lock through the canonical Patrol availability policy', () => {
+ expect(aiSettingsSource).toContain('getPatrolAlertAnalysisAvailabilityPresentation({');
+ expect(aiSettingsSource).toContain(
+ 'commercialSurfacesHidden: presentationPolicyHidesCommercialSurfaces(),',
+ );
+ expect(aiSettingsSource).toContain(
+ 'upgradePromptsHidden: presentationPolicyHidesUpgradePrompts(),',
+ );
+ expect(aiSettingsSource).toContain(
+ 'runtimeCapabilityBlock: getRuntimeCapabilityBlock(PATROL_ALERT_ANALYSIS_FEATURE_KEY),',
+ );
+ expect(aiSettingsSource).toContain(
+ 'planUpgradeDestination: getUpgradeActionDestination(PATROL_ALERT_ANALYSIS_FEATURE_KEY),',
+ );
+ expect(aiSettingsSource).toContain(
+ 'disabled={props.state.saving() || alertAnalysisAvailability().locked}',
+ );
+ expect(aiSettingsSource).toContain(
+ '<p id={alertAnalysisLockId} class="mt-1 text-xs text-muted">',
+ );
+ expect(aiSettingsSource).toContain(
+ 'alertAnalysisAvailability().locked ? alertAnalysisLockId : undefined',
+ );
+ // The shared Toggle declares locked/lockedMessage but never renders them,
+ // so the card must carry the explanation itself.
+ expect(aiSettingsSource).not.toContain('lockedMessage=');
+ expect(aiSettingsSource).not.toContain('Requires Pulse Pro');
+ });
+
it('keeps system AI save feedback tied to provider and Patrol readiness context', () => {
expect(aiSettingsSource).toContain('Choose a Patrol mode on the Patrol page.');
expect(aiSettingsSource).toContain('Open Patrol');
diff --git a/frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceHeader.test.ts b/frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceHeader.test.ts
index d3e17b1700..c46e349e8f 100644
--- a/frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceHeader.test.ts
+++ b/frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceHeader.test.ts
@@ -8,6 +8,7 @@ import {
getPatrolConfigurationFailureInlineDetails,
} from '../PatrolIntelligenceHeader';
import {
+ getPatrolAlertAnalysisAvailabilityPresentation,
getPatrolAutonomyAvailabilityPresentation,
PATROL_AUTONOMY_RUNTIME_REQUIRED_REASON,
} from '../patrolAutonomyAvailability';
@@ -312,6 +313,43 @@ describe('PatrolIntelligenceHeader', () => {
});
});
+ it('explains the container update risk lock through the same presentation policy', () => {
+ const planUpgradeDestination = {
+ href: '/settings/pulse-intelligence/billing/plan',
+ external: false,
+ };
+ expect(
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ planUpgradeDestination,
+ }),
+ ).toMatchObject({
+ kind: 'plan_locked',
+ title: 'Higher license plan required',
+ actionLabel: 'Plans & Billing',
+ destination: planUpgradeDestination,
+ });
+ expect(
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ upgradePromptsHidden: true,
+ planUpgradeDestination,
+ }),
+ ).not.toHaveProperty('actionLabel');
+ expect(
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ commercialSurfacesHidden: true,
+ planUpgradeDestination,
+ }),
+ ).toEqual({
+ kind: 'plan_locked',
+ locked: true,
+ title: 'Not available',
+ body: 'This install does not include container update risk.',
+ });
+ });
+
it('keeps trust counters out of the page header chrome', () => {
// Needs Attention and deliberate history review own trust
// state. The header should stay focused on title, recency, and controls.
diff --git a/frontend-modern/src/features/patrol/__tests__/patrolAutonomyAvailability.test.ts b/frontend-modern/src/features/patrol/__tests__/patrolAutonomyAvailability.test.ts
index 100d81e519..c8a6f090ed 100644
--- a/frontend-modern/src/features/patrol/__tests__/patrolAutonomyAvailability.test.ts
+++ b/frontend-modern/src/features/patrol/__tests__/patrolAutonomyAvailability.test.ts
@@ -3,8 +3,10 @@ import { describe, expect, it } from 'vitest';
import type { LicenseRuntimeCapabilityBlock, LicenseRuntimeIdentity } from '@/api/license';
import {
+ PATROL_ALERT_ANALYSIS_FEATURE_KEY,
PATROL_AUTONOMY_FEATURE_KEY,
PATROL_AUTONOMY_RUNTIME_REQUIRED_REASON,
+ getPatrolAlertAnalysisAvailabilityPresentation,
getPatrolAutonomyAvailabilityPresentation,
} from '../patrolAutonomyAvailability';
import type { UpgradeDestination } from '@/utils/upgradeNavigation';
@@ -53,6 +55,10 @@ describe('patrolAutonomyAvailability', () => {
expect(PATROL_AUTONOMY_FEATURE_KEY).toBe('ai_autofix');
});
+ it('exposes the ai_alerts feature key', () => {
+ expect(PATROL_ALERT_ANALYSIS_FEATURE_KEY).toBe('ai_alerts');
+ });
+
it('exposes the paid_runtime_required reason', () => {
expect(PATROL_AUTONOMY_RUNTIME_REQUIRED_REASON).toBe('paid_runtime_required');
});
@@ -319,4 +325,118 @@ describe('patrolAutonomyAvailability', () => {
});
});
});
+
+ describe('getPatrolAlertAnalysisAvailabilityPresentation', () => {
+ const alertRuntimeBlock = runtimeBlock({ key: PATROL_ALERT_ANALYSIS_FEATURE_KEY });
+
+ it('is available when alert analysis is not locked, ignoring every other field', () => {
+ expect(
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: false,
+ runtimeCapabilityBlock: alertRuntimeBlock,
+ commercialSurfacesHidden: true,
+ planUpgradeDestination: planDestination,
+ }),
+ ).toEqual({
+ kind: 'available',
+ locked: false,
+ title: 'Container update risk available',
+ body: 'Assess risk when container-update alerts fire.',
+ });
+ });
+
+ it('explains a plan lock and offers Plans & Billing when surfaces are visible', () => {
+ expect(
+ getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ planUpgradeDestination: planDestination,
+ }),
+ ).toEqual({
+ kind: 'plan_locked',
+ locked: true,
+ title: 'Higher license plan required',
+ body: "This install's plan does not include container update risk.",
+ actionLabel: 'Plans & Billing',
+ destination: planDestination,
+ });
+ });
+
+ it('keeps the plan explanation but drops the action when upgrade prompts are hidden', () => {
+ const result = getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ upgradePromptsHidden: true,
+ planUpgradeDestination: planDestination,
+ });
+
+ expect(result).toEqual({
+ kind: 'plan_locked',
+ locked: true,
+ title: 'Higher license plan required',
+ body: "This install's plan does not include container update risk.",
+ });
+ expect(result).not.toHaveProperty('actionLabel');
+ expect(result).not.toHaveProperty('destination');
+ });
+
+ it('uses neutral copy with no action when commercial surfaces are hidden', () => {
+ const result = getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ commercialSurfacesHidden: true,
+ planUpgradeDestination: planDestination,
+ });
+
+ expect(result).toEqual({
+ kind: 'plan_locked',
+ locked: true,
+ title: 'Not available',
+ body: 'This install does not include container update risk.',
+ });
+ expect(`${result.title} ${result.body}`).not.toMatch(/plan|Pro\b/i);
+ });
+
+ it('shares the canonical runtime lock with Patrol mode', () => {
+ const input = {
+ runtimeCapabilityBlock: runtimeBlock({
+ key: PATROL_ALERT_ANALYSIS_FEATURE_KEY,
+ action_url: 'https://pro.example/downloads',
+ }),
+ runtime: runtime({ label: 'Pulse Community runtime' }),
+ planUpgradeDestination: planDestination,
+ };
+ const alertAnalysis = getPatrolAlertAnalysisAvailabilityPresentation({
+ ...input,
+ alertAnalysisLocked: true,
+ });
+ const patrolMode = getPatrolAutonomyAvailabilityPresentation({
+ ...input,
+ autoFixLocked: true,
+ });
+
+ expect(alertAnalysis).toEqual({
+ kind: 'runtime_locked',
+ locked: true,
+ title: 'Pulse Pro runtime required',
+ body: 'This install is running Pulse Community runtime. Install the Pulse Pro runtime to use container update risk.',
+ actionLabel: 'Open Pro downloads',
+ destination: externalDestination('https://pro.example/downloads'),
+ });
+ expect(alertAnalysis.title).toBe(patrolMode.title);
+ expect(alertAnalysis.actionLabel).toBe(patrolMode.actionLabel);
+ expect(alertAnalysis.destination).toEqual(patrolMode.destination);
+ });
+
+ it('omits the runtime download action when upgrade prompts are hidden', () => {
+ const result = getPatrolAlertAnalysisAvailabilityPresentation({
+ alertAnalysisLocked: true,
+ upgradePromptsHidden: true,
+ runtimeCapabilityBlock: alertRuntimeBlock,
+ runtime: runtime(),
+ planUpgradeDestination: planDestination,
+ });
+
+ expect(result.kind).toBe('runtime_locked');
+ expect(result).not.toHaveProperty('actionLabel');
+ expect(result).not.toHaveProperty('destination');
+ });
+ });
});
diff --git a/frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts b/frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts
index f23791bd33..c683fc9720 100644
--- a/frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts
+++ b/frontend-modern/src/features/patrol/patrolAutonomyAvailability.ts
@@ -3,12 +3,16 @@ import type { UpgradeDestination } from '@/utils/upgradeNavigation';
import { resolveUpgradeDestination } from '@/utils/upgradeNavigation';
export const PATROL_AUTONOMY_FEATURE_KEY = 'ai_autofix';
+export const PATROL_ALERT_ANALYSIS_FEATURE_KEY = 'ai_alerts';
export const PATROL_AUTONOMY_RUNTIME_REQUIRED_REASON = 'paid_runtime_required';
-export type PatrolAutonomyAvailabilityKind = 'available' | 'plan_locked' | 'runtime_locked';
+export type PatrolFeatureAvailabilityKind = 'available' | 'plan_locked' | 'runtime_locked';
-export interface PatrolAutonomyAvailabilityInput {
- autoFixLocked: boolean;
+// Presentation policy shared by every plan-gated Patrol capability. Each
+// capability supplies only its lock state and its own copy; the precedence
+// (runtime lock, then hidden commercial surfaces, then plan lock) and the
+// action labels stay canonical here.
+interface PatrolFeatureAvailabilityPolicy {
upgradePromptsHidden?: boolean;
commercialSurfacesHidden?: boolean;
runtimeCapabilityBlock?: LicenseRuntimeCapabilityBlock;
@@ -16,8 +20,16 @@ export interface PatrolAutonomyAvailabilityInput {
planUpgradeDestination: UpgradeDestination;
}
-export interface PatrolAutonomyAvailabilityPresentation {
- kind: PatrolAutonomyAvailabilityKind;
+export interface PatrolAutonomyAvailabilityInput extends PatrolFeatureAvailabilityPolicy {
+ autoFixLocked: boolean;
+}
+
+export interface PatrolAlertAnalysisAvailabilityInput extends PatrolFeatureAvailabilityPolicy {
+ alertAnalysisLocked: boolean;
+}
+
+export interface PatrolFeatureAvailabilityPresentation {
+ kind: PatrolFeatureAvailabilityKind;
locked: boolean;
title: string;
body: string;
@@ -25,6 +37,44 @@ export interface PatrolAutonomyAvailabilityPresentation {
destination?: UpgradeDestination;
}
+interface PatrolFeatureAvailabilityCopy {
+ available: { title: string; body: string };
+ planLocked: { title: string; body: string };
+ // Plan-locked copy for sessions that hide commercial surfaces. Defaults to
+ // planLocked, so it is only needed when that copy mentions plans.
+ planLockedCommercialHidden?: { title: string; body: string };
+ // Completes "Install the Pulse Pro runtime to use ...".
+ runtimeFeatureLabel: string;
+}
+
+const PATROL_AUTONOMY_COPY: PatrolFeatureAvailabilityCopy = {
+ available: {
+ title: 'Patrol mode available',
+ body: 'Choose the mode for this install.',
+ },
+ planLocked: {
+ title: 'Watch only',
+ body: 'This install watches infrastructure and shows issues.',
+ },
+ runtimeFeatureLabel: 'Patrol modes',
+};
+
+const PATROL_ALERT_ANALYSIS_COPY: PatrolFeatureAvailabilityCopy = {
+ available: {
+ title: 'Container update risk available',
+ body: 'Assess risk when container-update alerts fire.',
+ },
+ planLocked: {
+ title: 'Higher license plan required',
+ body: "This install's plan does not include container update risk.",
+ },
+ planLockedCommercialHidden: {
+ title: 'Not available',
+ body: 'This install does not include container update risk.',
+ },
+ runtimeFeatureLabel: 'container update risk',
+};
+
function getRuntimeDownloadDestination(
block: LicenseRuntimeCapabilityBlock | undefined,
runtime: LicenseRuntimeIdentity | undefined,
@@ -37,15 +87,16 @@ function getRuntimeLabel(runtime: LicenseRuntimeIdentity | undefined): string {
return runtime?.label?.trim() || 'this runtime';
}
-export function getPatrolAutonomyAvailabilityPresentation(
- input: PatrolAutonomyAvailabilityInput,
-): PatrolAutonomyAvailabilityPresentation {
- if (!input.autoFixLocked) {
+function getPatrolFeatureAvailabilityPresentation(
+ locked: boolean,
+ input: PatrolFeatureAvailabilityPolicy,
+ copy: PatrolFeatureAvailabilityCopy,
+): PatrolFeatureAvailabilityPresentation {
+ if (!locked) {
return {
kind: 'available',
locked: false,
- title: 'Patrol mode available',
- body: 'Choose the mode for this install.',
+ ...copy.available,
};
}
@@ -54,7 +105,7 @@ export function getPatrolAutonomyAvailabilityPresentation(
kind: 'runtime_locked',
locked: true,
title: 'Pulse Pro runtime required',
- body: `This install is running ${getRuntimeLabel(input.runtime)}. Install the Pulse Pro runtime to use Patrol modes.`,
+ body: `This install is running ${getRuntimeLabel(input.runtime)}. Install the Pulse Pro runtime to use ${copy.runtimeFeatureLabel}.`,
...(input.upgradePromptsHidden
? {}
: {
@@ -70,16 +121,14 @@ export function getPatrolAutonomyAvailabilityPresentation(
return {
kind: 'plan_locked',
locked: true,
- title: 'Watch only',
- body: 'This install watches infrastructure and shows issues.',
+ ...(copy.planLockedCommercialHidden ?? copy.planLocked),
};
}
return {
kind: 'plan_locked',
locked: true,
- title: 'Watch only',
- body: 'This install watches infrastructure and shows issues.',
+ ...copy.planLocked,
...(input.upgradePromptsHidden
? {}
: {
@@ -88,3 +137,19 @@ export function getPatrolAutonomyAvailabilityPresentation(
}),
};
}
+
+export function getPatrolAutonomyAvailabilityPresentation(
+ input: PatrolAutonomyAvailabilityInput,
+): PatrolFeatureAvailabilityPresentation {
+ return getPatrolFeatureAvailabilityPresentation(input.autoFixLocked, input, PATROL_AUTONOMY_COPY);
+}
+
+export function getPatrolAlertAnalysisAvailabilityPresentation(
+ input: PatrolAlertAnalysisAvailabilityInput,
+): PatrolFeatureAvailabilityPresentation {
+ return getPatrolFeatureAvailabilityPresentation(
+ input.alertAnalysisLocked,
+ input,
+ PATROL_ALERT_ANALYSIS_COPY,
+ );
+}