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.

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.cjs
new file mode 100644
index 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.cjs
new file mode 100644
index 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.cjs
new file mode 100644
index 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.go
new file mode 100644
index 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")
+}