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.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Verify Patrol setup through a real local model and first run
pulse-triage[bot]a10fcd81a2e0
diff --git a/frontend-modern/browser-tests/patrol-setup-provider.cjs b/frontend-modern/browser-tests/patrol-setup-provider.cjsnew file mode 100644index 0000000000..46ae5afe76--- /dev/null+++ b/frontend-modern/browser-tests/patrol-setup-provider.cjs@@ -0,0 +1,132 @@+// A credential-free local Ollama protocol double, not a readiness/result stub.+// Pulse must parse streaming typed calls, execute its own tools and evaluate+// their exact nonce/context/continuation before it can issue a verdict.+const assert = require('node:assert/strict');+const http = require('node:http');++function readinessArguments(prompt) {+ const actionable = prompt.split('\n').find((line) => line.startsWith('ACTIONABLE '));+ const input = {};+ for (const match of (actionable || prompt).matchAll(+ /(resource_id|category|severity|evidence_token|nonce)=([^,\s.]+)/g,+ ))+ input[match[1]] = match[2];+ const nonce = /Evaluation nonce: ([a-f0-9]+)/.exec(prompt);+ if (nonce) input.nonce = nonce[1];+ return input;+}++async function startProvider(port, records) {+ let mode = 'pass';+ let sequence = 0;+ const server = http.createServer(async (request, response) => {+ try {+ assert.equal(request.headers.authorization, undefined, 'no provider credential');+ const chunks = [];+ for await (const chunk of request) chunks.push(chunk);+ const raw = Buffer.concat(chunks).toString();+ const body = raw ? JSON.parse(raw) : {};+ const record = { path: request.url, method: request.method, mode, body };+ records.push(record);+ response.setHeader('Content-Type', 'application/json');+ if (request.url === '/api/version')+ return response.end(JSON.stringify({ version: 'synthetic-ollama' }));+ if (request.url === '/api/tags')+ return response.end(+ JSON.stringify({+ models: [+ { name: 'qwen3:8b', size: 5_000_000_000, modified_at: '2026-10-13T00:00:00Z' },+ ],+ }),+ );+ if (request.url === '/api/show')+ return response.end(+ JSON.stringify({+ capabilities: ['completion', 'tools'],+ details: { family: 'qwen3', parameter_size: '8B', quantization_level: 'Q4_K_M' },+ model_info: { 'qwen3.context_length': 32768 },+ }),+ );+ assert.equal(request.url, '/api/chat', 'only supported local provider paths');+ const tools = (body.tools || []).map((tool) => tool.function.name);+ const messages = body.messages || [];+ const last = messages.at(-1);+ let call;+ let purpose;+ if (tools.includes('readiness_confirm_result')) {+ const result = JSON.parse(last.content);+ call = {+ name: 'readiness_confirm_result',+ arguments: { accepted: true, finding_id: result.finding_id, nonce: result.nonce },+ };+ purpose = 'readiness-continuation';+ } else if (tools.includes('readiness_record_observation')) {+ const prompt = messages.find((message) => message.role === 'user').content;+ const args = readinessArguments(prompt);+ if (mode === 'wrong-context') args.resource_id = 'healthy-decoy-001';+ call = { name: 'readiness_record_observation', arguments: args };+ purpose = 'readiness-scenario';+ } else if (tools.includes('pulse_query')) {+ purpose = 'patrol';+ if (last.role !== 'tool')+ call = { name: 'pulse_query', arguments: { action: 'list', type: 'agents' } };+ } else if (tools.length === 1) {+ purpose = 'startup-preflight';+ call = { name: tools[0], arguments: {} };+ } else {+ purpose = 'provider-chat';+ }+ record.purpose = purpose;+ const content =+ purpose === 'patrol'+ ? '### Infrastructure Status\nSynthetic fixture: reviewed the supplied host.\n### Key Observations\nNo warning or critical condition in this supplied fixture.\n### Actions Taken\nNo changes requested.'+ : 'Synthetic provider response.';+ if (mode === 'no-tools' && purpose.startsWith('readiness')) call = undefined;+ record.emittedTool = call?.name || null;+ const message = { role: 'assistant', content: call ? '' : content };+ if (call)+ message.tool_calls = [+ { id: `synthetic-call-${++sequence}`, function: { index: 0, ...call } },+ ];+ const end = {+ model: body.model,+ created_at: '2026-10-13T00:00:00Z',+ message,+ done: true,+ done_reason: call ? 'tool_use' : 'stop',+ prompt_eval_count: 100,+ eval_count: 20,+ };+ if (body.stream) {+ response.setHeader('Content-Type', 'application/x-ndjson');+ // Deliver the tool independently of the done event to exercise the+ // actual Ollama streaming parser rather than the non-streaming path.+ response.write(JSON.stringify({ ...end, done: false }) + '\n');+ response.end(+ JSON.stringify({ ...end, message: { role: 'assistant', content: '' } }) + '\n',+ );+ } else response.end(JSON.stringify(end));+ } catch (error) {+ records.push({ error: error.message });+ response.writeHead(500);+ response.end(JSON.stringify({ error: 'Synthetic fixture protocol refused' }));+ }+ });+ await new Promise((resolve, reject) => {+ server.once('error', reject);+ server.listen(port, '127.0.0.1', resolve);+ });+ return {+ port: server.address().port,+ setMode(next) {+ assert(['pass', 'no-tools', 'wrong-context'].includes(next));+ mode = next;+ },+ async close() {+ server.closeAllConnections();+ await new Promise((resolve) => server.close(resolve));+ },+ };+}++module.exports = { startProvider, readinessArguments };diff --git a/frontend-modern/browser-tests/patrol-setup-provider.test.cjs b/frontend-modern/browser-tests/patrol-setup-provider.test.cjsnew file mode 100644index 0000000000..f0bfcf07b3--- /dev/null+++ b/frontend-modern/browser-tests/patrol-setup-provider.test.cjs@@ -0,0 +1,96 @@+const assert = require('node:assert/strict');+const { test } = require('node:test');+const { startProvider, readinessArguments } = require('./patrol-setup-provider.cjs');++test('copies the typed observation and nonce without punctuation', () => {+ assert.deepEqual(+ readinessArguments(+ 'resource_id=node-protocol, category=reliability, severity=warning, evidence_token=token, nonce=abc123.',+ ),+ {+ resource_id: 'node-protocol',+ category: 'reliability',+ severity: 'warning',+ evidence_token: 'token',+ nonce: 'abc123',+ },+ );+});++test('takes the actionable context row, not healthy decoys or earlier fields', () => {+ const prompt =+ 'Evaluation nonce: abcd1234\nhealthy resource_id=decoy severity=warning\nACTIONABLE resource_id=pbs-lab-a category=backup severity=critical evidence_token=failed-job\nhealthy-decoy-049 cpu=20%';+ assert.deepEqual(readinessArguments(prompt), {+ resource_id: 'pbs-lab-a',+ category: 'backup',+ severity: 'critical',+ evidence_token: 'failed-job',+ nonce: 'abcd1234',+ });+});++test('the protocol double emits calls, not a fabricated Pulse verdict', async (t) => {+ const records = [];+ const provider = await startProvider(0, records);+ t.after(() => provider.close());+ const origin = `http://127.0.0.1:${provider.port}`;+ const request = (name, content, role = 'user') =>+ fetch(origin + '/api/chat', {+ method: 'POST',+ body: JSON.stringify({+ model: 'qwen3:8b',+ stream: true,+ tools: [{ function: { name } }],+ messages: [{ role, content }],+ }),+ });+ const read = async (response) =>+ (await response.text())+ .trim()+ .split('\n')+ .map((line) => JSON.parse(line));+ const prompt =+ 'resource_id=node-protocol, category=reliability, severity=warning, evidence_token=token, nonce=abc123.';+ const pass = await read(await request('readiness_record_observation', prompt));+ assert.equal(pass[0].done, false);+ assert.equal(pass[1].done, true);+ assert.equal(pass[0].message.tool_calls[0].function.name, 'readiness_record_observation');+ assert.equal(pass[0].message.tool_calls[0].function.arguments.nonce, 'abc123');+ assert.equal(pass[0].max_verified_mode, undefined);+ assert.equal(pass[0].status, undefined);++ provider.setMode('wrong-context');+ const wrong = await read(await request('readiness_record_observation', prompt));+ assert.equal(wrong[0].message.tool_calls[0].function.arguments.resource_id, 'healthy-decoy-001');+ provider.setMode('no-tools');+ const noTools = await read(await request('readiness_record_observation', prompt));+ assert.equal(noTools[0].message.tool_calls, undefined);++ provider.setMode('pass');+ const continued = await read(+ await request(+ 'readiness_confirm_result',+ JSON.stringify({ finding_id: 'backend-issued-finding', nonce: 'fresh-backend-nonce' }),+ 'tool',+ ),+ );+ assert.deepEqual(continued[0].message.tool_calls[0].function.arguments, {+ accepted: true,+ finding_id: 'backend-issued-finding',+ nonce: 'fresh-backend-nonce',+ });+ const firstRun = await read(await request('pulse_query', 'Synthetic host estate'));+ assert.deepEqual(firstRun[0].message.tool_calls[0].function.arguments, {+ action: 'list',+ type: 'agents',+ });+ const toolResult = await read(+ await request('pulse_query', JSON.stringify({ success: true }), 'tool'),+ );+ assert.equal(toolResult[0].message.tool_calls, undefined);+ assert.match(toolResult[0].message.content, /No changes requested/);+ assert.equal(+ records.some((record) => record.error),+ false,+ );+});diff --git a/frontend-modern/browser-tests/patrol-setup-real-backend.cjs b/frontend-modern/browser-tests/patrol-setup-real-backend.cjsnew file mode 100644index 0000000000..0f27485617--- /dev/null+++ b/frontend-modern/browser-tests/patrol-setup-real-backend.cjs@@ -0,0 +1,315 @@+const assert = require('node:assert/strict');+const fs = require('node:fs');+const path = require('node:path');+const crypto = require('node:crypto');+const cp = require('node:child_process');+const { chromium, webkit } = require('playwright');+const {+ startProvider,+} = require('/workspace/frontend-modern/browser-tests/patrol-setup-provider.cjs');++const root = '/workspace';+const output = path.join(root, 'tmp/patrol-setup-proof/browser');+const binary = path.join(root, 'tmp/patrol-setup-proof/patrol-setup-preview');+const sha256 = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');+const result = {+ playwright: require('playwright/package.json').version,+ scope:+ 'Production /patrol app, public router/auth/settings, Ollama streaming readiness evaluator, Watch-only tool executor and persisted run history. Only host inventory and provider protocol replies are synthetic. No page API routes or backend verdicts are stubbed.',+ source: JSON.parse(fs.readFileSync(path.join(root, 'tmp/patrol-setup-proof/binding.json'))),+ binary_sha256: sha256(fs.readFileSync(binary)),+ checks: [],+ requests: [],+ captures: [],+ provider: [],+ browsers: [],+ errors: [],+ cleanup: [],+};+assert.equal(+ result.playwright,+ JSON.parse(fs.readFileSync(path.join(root, 'tests/integration/package-lock.json'))).packages[+ 'node_modules/@playwright/test'+ ].version,+);+for (const [file, digest] of Object.entries(result.source.paths)) {+ assert.equal(sha256(fs.readFileSync(path.join(root, file))), digest, file);+}+const record = (name, detail) => result.checks.push({ name, detail });+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));++async function waitUntil(callback, label, timeout = 20000) {+ const end = Date.now() + timeout;+ while (Date.now() < end) {+ if (await callback()) return;+ await pause(150);+ }+ throw new Error(`Timed out: ${label}`);+}++async function stopOwned(child, log) {+ if (child.exitCode !== null) return { exit: child.exitCode, signal: child.signalCode };+ const exited = new Promise((resolve) =>+ child.once('exit', (exit, signal) => resolve({ exit, signal })),+ );+ child.kill('SIGTERM');+ const observed = await Promise.race([exited, pause(8000).then(() => null)]);+ if (observed) {+ const data = /patrol-setup-fixture-data (\/tmp\/pulse-patrol-setup-[a-zA-Z0-9]+)/.exec(log());+ assert(data, 'owned temporary data identity recorded');+ assert.equal(fs.existsSync(data[1]), false, 'owned data removed after shutdown');+ assert.match(log(), /patrol-setup-fixture-clean-shutdown/);+ return observed;+ }+ child.kill('SIGKILL');+ const forced = await exited;+ throw new Error(`Owned preview needed forced cleanup: ${JSON.stringify(forced)}`);+}++async function capture(page, name, target) {+ if (target) await target.scrollIntoViewIfNeeded();+ await page.evaluate(() => document.fonts.ready);+ await pause(250);+ const filename = `${name}.png`;+ await page.screenshot({ path: path.join(output, filename), fullPage: false });+ result.captures.push({+ file: filename,+ sha256: sha256(fs.readFileSync(path.join(output, filename))),+ });+}++(async () => {+ fs.mkdirSync(output, { recursive: true });+ let vite;+ try {+ process.env.PULSE_DEV_API_PORT = '5301';+ const { createServer } = await import(+ path.join(root, 'frontend-modern/node_modules/vite/dist/node/index.js')+ );+ vite = await createServer({+ root: path.join(root, 'frontend-modern'),+ configFile: path.join(root, 'frontend-modern/vite.config.ts'),+ server: { host: '127.0.0.1', port: 5300, strictPort: true },+ });+ await vite.listen();+ for (const spec of [+ {+ name: 'desktop',+ width: 1280,+ height: 900,+ engine: chromium,+ options: { headless: true, channel: 'chromium', args: ['--no-sandbox'] },+ },+ { name: 'phone', width: 375, height: 812, engine: webkit, options: { headless: true } },+ ]) {+ const providerRecords = [];+ const provider = await startProvider(5302, providerRecords);+ let backendLog = '';+ const backend = cp.spawn(binary, ['-port', '5301'], {+ cwd: path.join(root, 'tmp/patrol-setup-proof'),+ env: {+ ...process.env,+ PULSE_MOCK_MODE: 'false',+ PULSE_TELEMETRY: 'false',+ FRONTEND_DEV_SERVER: 'true',+ },+ });+ backend.stdout.on('data', (chunk) => {+ backendLog += chunk;+ });+ backend.stderr.on('data', (chunk) => {+ backendLog += chunk;+ });+ let browser;+ let page;+ try {+ await waitUntil(+ () => backendLog.includes('patrol-setup-fixture-ready'),+ 'real backend ready',+ );+ browser = await spec.engine.launch(spec.options);+ result.browsers.push({+ name: spec.name,+ version: browser.version(),+ viewport: { width: spec.width, height: spec.height },+ });+ const context = await browser.newContext({+ viewport: { width: spec.width, height: spec.height },+ colorScheme: 'light',+ ...(spec.name === 'phone'+ ? { hasTouch: true, isMobile: true, deviceScaleFactor: 2 }+ : {}),+ });+ page = await context.newPage();+ page.setDefaultTimeout(18000);+ const activate = async (locator) => {+ if (spec.name === 'phone') await locator.tap();+ else {+ await locator.focus();+ await locator.press('Enter');+ }+ };+ page.on('pageerror', (error) =>+ result.errors.push({ browser: spec.name, error: error.message }),+ );+ page.on('response', async (response) => {+ const url = new URL(response.url());+ if (!url.pathname.startsWith('/api/')) return;+ const entry = {+ browser: spec.name,+ method: response.request().method(),+ path: url.pathname,+ status: response.status(),+ };+ if (/\/api\/(settings\/ai|ai\/patrol\/(readiness|run|runs|status))/.test(url.pathname)) {+ try {+ entry.body = await response.json();+ } catch {+ /* whitespace streaming is parsed on completion */+ }+ }+ result.requests.push(entry);+ });+ await page.goto('http://127.0.0.1:5300/patrol');+ await page.locator('input[name="username"]').fill('synthetic-browser-admin');+ await page.locator('input[name="password"]').fill('synthetic-browser-password');+ await page.getByRole('button', { name: /sign in/i }).click();+ await page.getByTestId('patrol-setup-panel').waitFor();+ await capture(page, `${spec.name}-initial`);+ await activate(page.getByRole('button', { name: /Ollama/ }));+ await page.getByLabel('Ollama server URL').fill('http://127.0.0.1:5302');+ provider.setMode('wrong-context');+ await activate(page.getByRole('button', { name: 'Connect and check', exact: true }));+ await page.getByTestId('patrol-setup-error').waitFor();+ record(+ `${spec.name}: actual evaluator rejects wrong context`,+ await page.getByTestId('patrol-setup-error').innerText(),+ );+ assert.equal(+ await page.getByRole('button', { name: 'Run Patrol now', exact: true }).count(),+ 0,+ );+ await capture(page, `${spec.name}-refused-context`);+ provider.setMode('pass');+ await activate(page.getByRole('button', { name: 'Check qwen3:8b again', exact: true }));+ await page.getByTestId('patrol-setup-ready').waitFor();+ const ready = await page.getByTestId('patrol-setup-ready').innerText();+ assert.match(ready, /Patrol is ready/);+ record(`${spec.name}: actual streaming evaluator passes`, ready);+ await capture(page, `${spec.name}-ready`, page.getByTestId('patrol-setup-ready'));+ const settingsResponse = await context.request.get('http://127.0.0.1:5300/api/settings/ai');+ const saved = await settingsResponse.json();+ assert.equal(saved.model, 'ollama:qwen3:8b');+ assert.equal(saved.patrol_model, 'ollama:qwen3:8b');+ assert.equal(saved.patrol_interval_minutes, 360);+ record(`${spec.name}: real persisted models and original schedule`, {+ model: saved.model,+ patrol_model: saved.patrol_model,+ interval_minutes: saved.patrol_interval_minutes,+ });+ const runResponse = page.waitForResponse(+ (response) =>+ new URL(response.url()).pathname === '/api/ai/patrol/run' &&+ response.request().method() === 'POST',+ );+ await activate(page.getByRole('button', { name: 'Run Patrol now', exact: true }));+ const accepted = await runResponse;+ assert.equal(accepted.status(), 200);+ const acceptance = await accepted.json();+ assert.equal(acceptance.accepted, true);+ assert(acceptance.run_id);+ record(`${spec.name}: real manual first run accepted`, acceptance);+ await waitUntil(async () => {+ const response = await context.request.get('http://127.0.0.1:5300/api/ai/patrol/runs');+ const body = await response.json();+ const runs = body.runs || body;+ const run = runs.find((run) => run.id === acceptance.run_id);+ if (run?.completed_at) {+ result.completedRun = { ...result.completedRun, [spec.name]: run };+ return true;+ }+ return false;+ }, 'actual completed first-run record');+ const run = result.completedRun[spec.name];+ assert.equal(run.error_count, 0);+ assert.equal(run.resources_checked, 1);+ assert(run.tool_call_count > 0);+ assert.equal(run.trigger_reason, 'manual');+ record(`${spec.name}: first run executed tools and persisted`, run);+ // Read it through the actual workbench History journey, not only HTTP.+ await activate(page.getByRole('tab', { name: 'Activity', exact: true }));+ await activate(page.getByRole('button', { name: /Finding options and history/ }));+ await activate(page.getByRole('button', { name: 'History', exact: true }));+ await page.getByText('Patrol history', { exact: true }).waitFor();+ const historyEntry = page.getByRole('button').filter({ hasText: 'All clear' }).first();+ await historyEntry.waitFor();+ await capture(page, `${spec.name}-first-run-history`, historyEntry);+ await activate(historyEntry);+ await page.getByText('Check record', { exact: true }).waitFor();+ await capture(+ page,+ `${spec.name}-first-run-record`,+ page.getByText('Check record', { exact: true }),+ );+ record(`${spec.name}: actual History entry opens the completed run`, {+ run_id: acceptance.run_id,+ });+ const overflow = await page.evaluate(() => ({+ width: innerWidth,+ scrollWidth: document.documentElement.scrollWidth,+ }));+ assert(overflow.scrollWidth <= overflow.width + 1, JSON.stringify(overflow));+ record(`${spec.name}: viewport has no horizontal overflow`, overflow);+ assert(+ providerRecords.some(+ (entry) =>+ entry.purpose === 'readiness-continuation' &&+ entry.emittedTool === 'readiness_confirm_result',+ ),+ );+ assert(+ providerRecords.some(+ (entry) => entry.purpose === 'patrol' && entry.emittedTool === 'pulse_query',+ ),+ );+ } catch (error) {+ if (page) {+ await capture(page, `${spec.name}-failure`).catch(() => {});+ result.failureBody = await page+ .locator('body')+ .innerText()+ .catch(() => 'unavailable');+ }+ throw error;+ } finally {+ if (browser) await browser.close();+ const backendExit = await stopOwned(backend, () => backendLog);+ await provider.close();+ result.provider.push({ browser: spec.name, records: providerRecords });+ result.cleanup.push({+ browser: spec.name,+ backend: backendExit,+ browserClosed: true,+ providerClosed: true,+ });+ fs.writeFileSync(path.join(output, `${spec.name}-backend.log`), backendLog);+ }+ }+ } catch (error) {+ result.failure = error.stack;+ process.exitCode = 1;+ } finally {+ if (vite) await vite.close();+ result.viteClosed = true;+ fs.writeFileSync(path.join(output, 'result.json'), JSON.stringify(result, null, 2) + '\n');+ console.log(+ JSON.stringify({+ passed: !result.failure,+ checks: result.checks.length,+ failure: result.failure,+ captures: result.captures,+ cleanup: result.cleanup,+ }),+ );+ }+})();diff --git a/tests/qualification/patrol-setup/main.go b/tests/qualification/patrol-setup/main.gonew file mode 100644index 0000000000..7b1ee1ed2c--- /dev/null+++ b/tests/qualification/patrol-setup/main.go@@ -0,0 +1,119 @@+// This browser fixture runs the production public router, settings persistence,+// provider transport and Watch-only Patrol loop. Only the inventory is synthetic.+// It has no configured collectors, agent executor, licence, notification channel+// or external provider. The browser harness owns its loopback provider and data.+package main++import (+ "context"+ "flag"+ "fmt"+ "net"+ "net/http"+ "os"+ "os/signal"+ "path/filepath"+ "syscall"+ "time"++ "github.com/rcourtman/pulse-go-rewrite/internal/api"+ "github.com/rcourtman/pulse-go-rewrite/internal/config"+ "github.com/rcourtman/pulse-go-rewrite/internal/monitoring"+ "github.com/rcourtman/pulse-go-rewrite/internal/websocket"+ agentshost "github.com/rcourtman/pulse-go-rewrite/pkg/agents/host"+ "github.com/rs/zerolog"+ "golang.org/x/crypto/bcrypt"+)++func run() error {+ port := flag.Int("port", 5301, "loopback preview port")+ flag.Parse()+ if *port < 1024 || *port > 65535 {+ return fmt.Errorf("preview port must be unprivileged")+ }+ zerolog.SetGlobalLevel(zerolog.WarnLevel)+ data, err := os.MkdirTemp("", "pulse-patrol-setup-")+ if err != nil {+ return err+ }+ defer os.RemoveAll(data)+ fmt.Println("patrol-setup-fixture-data " + data)+ password, err := bcrypt.GenerateFromPassword([]byte("synthetic-browser-password"), bcrypt.MinCost)+ if err != nil {+ return err+ }+ cfg := &config.Config{+ DataPath: data, ConfigPath: data, AppRoot: filepath.Dir(data),+ BindAddress: "127.0.0.1", FrontendPort: *port,+ AuthUser: "synthetic-browser-admin", AuthPass: string(password),+ PublicURL: "http://127.0.0.1:5300", TelemetryEnabled: false,+ ConnectionTimeout: time.Second, PVEPollingInterval: time.Hour,+ AdaptivePollingBaseInterval: time.Hour, AdaptivePollingMaxInterval: time.Hour,+ Discovery: config.DefaultDiscoveryConfig(),+ }+ persistence := config.NewConfigPersistence(data)+ aiCfg := config.NewDefaultAIConfig()+ aiCfg.Enabled = false+ aiCfg.Model = ""+ aiCfg.PatrolModel = ""+ if err := persistence.SaveAIConfig(*aiCfg); err != nil {+ return err+ }+ monitor, err := monitoring.New(cfg)+ if err != nil {+ return err+ }+ defer monitor.Stop()+ // There is deliberately no Monitor.Start: no guest, SSH, disk, backup or+ // network collector can run. An ordinary admitted host report supplies the+ // real Resources projection and the Patrol prompt, without mock/demo mode.+ _, err = monitor.ApplyHostReport(agentshost.Report{+ Agent: agentshost.AgentInfo{ID: "setup-fixture-agent", IntervalSeconds: 3600},+ Host: agentshost.HostInfo{ID: "setup-fixture-machine", Hostname: "setup-fixture-host", Platform: "linux", OSName: "debian"},+ Metrics: agentshost.Metrics{CPUUsagePercent: 12, Memory: agentshost.MemoryMetric{TotalBytes: 8 << 30, UsedBytes: 2 << 30, FreeBytes: 6 << 30, Usage: 25}},+ Timestamp: time.Now().UTC(),+ }, nil)+ if err != nil {+ return err+ }+ hub := websocket.NewHub(func(string) interface{} { return monitor.GetState() })+ go hub.Run()+ defer hub.Stop()+ router := api.NewRouter(cfg, monitor, nil, hub, nil, "dev-patrol-setup-proof")+ defer router.ShutdownRBAC()+ defer router.ShutdownResourceStores()+ defer router.ShutdownAIIntelligence()+ defer router.StopAIChat(context.Background())+ ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGTERM, syscall.SIGINT)+ defer stop()+ router.StartPatrol(ctx)+ router.StartAIChat(ctx)+ listener, err := net.Listen("tcp4", fmt.Sprintf("127.0.0.1:%d", *port))+ if err != nil {+ return err+ }+ server := &http.Server{Handler: router.Handler(), ReadHeaderTimeout: 5 * time.Second}+ done := make(chan error, 1)+ go func() { done <- server.Serve(listener) }()+ fmt.Println("patrol-setup-fixture-ready")+ select {+ case err := <-done:+ return err+ case <-ctx.Done():+ shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)+ defer cancel()+ if err := server.Shutdown(shutdownCtx); err != nil {+ return err+ }+ }+ fmt.Println("patrol-setup-fixture-http-closed")+ return nil+}++func main() {+ if err := run(); err != nil {+ fmt.Fprintln(os.Stderr, err)+ os.Exit(1)+ }+ fmt.Println("patrol-setup-fixture-clean-shutdown")+}