ultravisor-beacon-capability 1.0.0

package/docs/examples/mysql-maintenance.md

@@ -0,0 +1,253 @@
+# Example: MySQL Maintenance
+
+A capability for recurring MySQL database maintenance tasks -- purging old records, optimizing tables, and exporting query results.
+
+## Full Source
+
+```javascript
+const libFable = require('fable');
+const libBeaconCapability = require('ultravisor-beacon-capability');
+const libMySQL = require('mysql2');
+
+class MySQLMaintenance extends libBeaconCapability
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'MySQLMaintenance';
+		this.capabilityName = 'MySQLMaintenance';
+
+		this._Pool = null;
+	}
+
+	onInitialize(fCallback)
+	{
+		this._Pool = libMySQL.createPool({
+			host: this.fable.settings.MySQL.Host || 'localhost',
+			port: this.fable.settings.MySQL.Port || 3306,
+			user: this.fable.settings.MySQL.User || 'root',
+			password: this.fable.settings.MySQL.Password || '',
+			database: this.fable.settings.MySQL.Database || 'myapp',
+			connectionLimit: 5
+		});
+
+		// Verify connectivity
+		this._Pool.query('SELECT 1 AS alive', (pError) =>
+		{
+			if (pError)
+			{
+				this.log.error(`MySQL connection failed: ${pError.message}`);
+				return fCallback(pError);
+			}
+			this.log.info('MySQL connection pool ready');
+			return fCallback(null);
+		});
+	}
+
+	onShutdown(fCallback)
+	{
+		if (this._Pool)
+		{
+			this._Pool.end((pError) =>
+			{
+				if (pError) this.log.warn(`Pool close error: ${pError.message}`);
+				this._Pool = null;
+				return fCallback(null);
+			});
+		}
+		else
+		{
+			return fCallback(null);
+		}
+	}
+
+	// --- Action: PurgeOldRecords ---
+
+	get actionPurgeOldRecords_Description()
+	{
+		return 'Delete records older than a specified number of days from a table';
+	}
+
+	get actionPurgeOldRecords_Schema()
+	{
+		return [
+			{ Name: 'TableName', DataType: 'String', Required: true },
+			{ Name: 'DateColumn', DataType: 'String', Required: true },
+			{ Name: 'MaxAgeDays', DataType: 'Integer', Required: true },
+			{ Name: 'BatchSize', DataType: 'Integer', Required: false, Default: 1000 },
+			{ Name: 'DryRun', DataType: 'Boolean', Required: false, Default: true }
+		];
+	}
+
+	actionPurgeOldRecords(pSettings, pWorkItem, fCallback, fReportProgress)
+	{
+		let tmpTable = this._Pool.escapeId(pSettings.TableName);
+		let tmpColumn = this._Pool.escapeId(pSettings.DateColumn);
+		let tmpDays = parseInt(pSettings.MaxAgeDays, 10);
+		let tmpBatch = parseInt(pSettings.BatchSize, 10) || 1000;
+
+		// Step 1: Count records to delete
+		let tmpCountSQL = `SELECT COUNT(*) AS cnt FROM ${tmpTable} WHERE ${tmpColumn} < DATE_SUB(NOW(), INTERVAL ? DAY)`;
+
+		this._Pool.query(tmpCountSQL, [tmpDays], (pCountError, pCountRows) =>
+		{
+			if (pCountError) return fCallback(pCountError);
+
+			let tmpCount = pCountRows[0].cnt;
+			fReportProgress({ Percent: 10, Message: `Found ${tmpCount} records to purge` });
+
+			if (pSettings.DryRun)
+			{
+				return fCallback(null, {
+					Outputs: { RecordsFound: tmpCount, DryRun: true, Deleted: 0 },
+					Log: [`DRY RUN: Would delete ${tmpCount} records from ${pSettings.TableName}`]
+				});
+			}
+
+			// Step 2: Delete in batches
+			let tmpDeleteSQL = `DELETE FROM ${tmpTable} WHERE ${tmpColumn} < DATE_SUB(NOW(), INTERVAL ? DAY) LIMIT ?`;
+			let tmpTotalDeleted = 0;
+
+			let fnDeleteBatch = () =>
+			{
+				this._Pool.query(tmpDeleteSQL, [tmpDays, tmpBatch], (pDelError, pDelResult) =>
+				{
+					if (pDelError) return fCallback(pDelError);
+
+					tmpTotalDeleted += pDelResult.affectedRows;
+					let tmpPercent = Math.min(90, Math.round((tmpTotalDeleted / tmpCount) * 80) + 10);
+					fReportProgress({ Percent: tmpPercent, Message: `Deleted ${tmpTotalDeleted} / ${tmpCount}` });
+
+					if (pDelResult.affectedRows < tmpBatch)
+					{
+						return fCallback(null, {
+							Outputs: { RecordsFound: tmpCount, Deleted: tmpTotalDeleted, DryRun: false },
+							Log: [`Purged ${tmpTotalDeleted} records from ${pSettings.TableName}`]
+						});
+					}
+
+					// Continue batching
+					setImmediate(fnDeleteBatch);
+				});
+			};
+
+			fnDeleteBatch();
+		});
+	}
+
+	// --- Action: OptimizeTable ---
+
+	get actionOptimizeTable_Description()
+	{
+		return 'Run OPTIMIZE TABLE to reclaim space and rebuild indexes';
+	}
+
+	get actionOptimizeTable_Schema()
+	{
+		return [
+			{ Name: 'TableName', DataType: 'String', Required: true }
+		];
+	}
+
+	actionOptimizeTable(pSettings, pWorkItem, fCallback)
+	{
+		let tmpTable = this._Pool.escapeId(pSettings.TableName);
+		let tmpSQL = `OPTIMIZE TABLE ${tmpTable}`;
+
+		this.log.info(`Optimizing table ${pSettings.TableName}...`);
+
+		this._Pool.query(tmpSQL, (pError, pResults) =>
+		{
+			if (pError) return fCallback(pError);
+			return fCallback(null, {
+				Outputs: { Result: pResults },
+				Log: [`Optimized table ${pSettings.TableName}`]
+			});
+		});
+	}
+
+	// --- Action: ExportQuery ---
+
+	get actionExportQuery_Description()
+	{
+		return 'Execute a SELECT query and return the results as JSON';
+	}
+
+	get actionExportQuery_Schema()
+	{
+		return [
+			{ Name: 'Query', DataType: 'String', Required: true },
+			{ Name: 'MaxRows', DataType: 'Integer', Required: false, Default: 10000 }
+		];
+	}
+
+	actionExportQuery(pSettings, pWorkItem, fCallback)
+	{
+		let tmpQuery = pSettings.Query;
+
+		// Safety: reject non-SELECT queries
+		if (!tmpQuery.trim().toUpperCase().startsWith('SELECT'))
+		{
+			return fCallback(new Error('ExportQuery only supports SELECT statements'));
+		}
+
+		let tmpMaxRows = parseInt(pSettings.MaxRows, 10) || 10000;
+		let tmpSQL = `${tmpQuery} LIMIT ${tmpMaxRows}`;
+
+		this._Pool.query(tmpSQL, (pError, pRows) =>
+		{
+			if (pError) return fCallback(pError);
+			return fCallback(null, {
+				Outputs: { Rows: pRows, RowCount: pRows.length, Truncated: pRows.length >= tmpMaxRows },
+				Log: [`Exported ${pRows.length} rows`]
+			});
+		});
+	}
+}
+
+// --- Startup ---
+
+let tmpFable = new libFable({
+	Product: 'MySQLMaintenance',
+	ProductVersion: '1.0.0',
+	MySQL:
+	{
+		Host: process.env.MYSQL_HOST || 'localhost',
+		Port: parseInt(process.env.MYSQL_PORT, 10) || 3306,
+		User: process.env.MYSQL_USER || 'root',
+		Password: process.env.MYSQL_PASSWORD || '',
+		Database: process.env.MYSQL_DATABASE || 'myapp'
+	}
+});
+
+tmpFable.addServiceType('MySQLMaintenance', MySQLMaintenance);
+let tmpCap = tmpFable.instantiateServiceProvider('MySQLMaintenance');
+
+tmpCap.connect(
+	{
+		ServerURL: process.env.ULTRAVISOR_URL || 'http://localhost:54321',
+		Name: 'mysql-maintenance'
+	},
+	(pError) =>
+	{
+		if (pError) throw pError;
+		console.log('MySQL maintenance beacon online');
+	});
+
+process.on('SIGTERM', () => { tmpCap.disconnect(() => process.exit(0)); });
+```
+
+## Registered Task Types
+
+- `beacon-mysqlmaintenance-purgeoldrecords`
+- `beacon-mysqlmaintenance-optimizetable`
+- `beacon-mysqlmaintenance-exportquery`
+
+## Key Points
+
+- **Connection pool** is created in `onInitialize` and closed in `onShutdown`
+- **Batch deletion** uses `LIMIT` and `setImmediate` to avoid locking the table for too long
+- **Progress reporting** gives visibility into long-running purge operations
+- **DryRun mode** counts affected records without deleting (defaults to `true` for safety)
+- **ExportQuery** rejects non-SELECT statements to prevent accidental mutations
+- Database credentials come from Fable settings, which can be sourced from environment variables

package/docs/examples/postgresql-aggregation.md

@@ -0,0 +1,247 @@
+# Example: PostgreSQL Aggregation
+
+A capability for running aggregation queries, refreshing materialized views, and collecting table statistics on a PostgreSQL database.
+
+## Full Source
+
+```javascript
+const libFable = require('fable');
+const libBeaconCapability = require('ultravisor-beacon-capability');
+const { Client } = require('pg');
+
+class PostgresAggregation extends libBeaconCapability
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'PostgresAggregation';
+		this.capabilityName = 'PostgresAggregation';
+
+		this._Client = null;
+	}
+
+	onInitialize(fCallback)
+	{
+		this._Client = new Client({
+			host: this.fable.settings.Postgres.Host || 'localhost',
+			port: this.fable.settings.Postgres.Port || 5432,
+			user: this.fable.settings.Postgres.User || 'postgres',
+			password: this.fable.settings.Postgres.Password || '',
+			database: this.fable.settings.Postgres.Database || 'analytics'
+		});
+
+		this._Client.connect((pError) =>
+		{
+			if (pError)
+			{
+				this.log.error(`PostgreSQL connection failed: ${pError.message}`);
+				return fCallback(pError);
+			}
+			this.log.info('PostgreSQL client connected');
+			return fCallback(null);
+		});
+	}
+
+	onShutdown(fCallback)
+	{
+		if (this._Client)
+		{
+			this._Client.end()
+				.then(() =>
+				{
+					this._Client = null;
+					return fCallback(null);
+				})
+				.catch((pError) =>
+				{
+					this.log.warn(`PG disconnect error: ${pError.message}`);
+					this._Client = null;
+					return fCallback(null);
+				});
+		}
+		else
+		{
+			return fCallback(null);
+		}
+	}
+
+	// --- Action: RefreshMaterializedView ---
+
+	get actionRefreshMaterializedView_Description()
+	{
+		return 'Refresh a materialized view, optionally concurrently';
+	}
+
+	get actionRefreshMaterializedView_Schema()
+	{
+		return [
+			{ Name: 'ViewName', DataType: 'String', Required: true },
+			{ Name: 'Concurrently', DataType: 'Boolean', Required: false, Default: true }
+		];
+	}
+
+	actionRefreshMaterializedView(pSettings, pWorkItem, fCallback)
+	{
+		let tmpConcurrently = (pSettings.Concurrently !== false) ? 'CONCURRENTLY' : '';
+		let tmpSQL = `REFRESH MATERIALIZED VIEW ${tmpConcurrently} ${pSettings.ViewName}`;
+
+		this.log.info(`Refreshing view: ${pSettings.ViewName}`);
+		let tmpStart = Date.now();
+
+		this._Client.query(tmpSQL, (pError) =>
+		{
+			if (pError) return fCallback(pError);
+			let tmpDuration = Date.now() - tmpStart;
+			return fCallback(null, {
+				Outputs: { ViewName: pSettings.ViewName, DurationMs: tmpDuration },
+				Log: [`Refreshed ${pSettings.ViewName} in ${tmpDuration}ms`]
+			});
+		});
+	}
+
+	// --- Action: RunAggregation ---
+
+	get actionRunAggregation_Description()
+	{
+		return 'Execute an aggregation query and return the results';
+	}
+
+	get actionRunAggregation_Schema()
+	{
+		return [
+			{ Name: 'Query', DataType: 'String', Required: true },
+			{ Name: 'Parameters', DataType: 'Array', Required: false }
+		];
+	}
+
+	actionRunAggregation(pSettings, pWorkItem, fCallback)
+	{
+		let tmpQuery = pSettings.Query;
+
+		// Safety: only allow read-only queries
+		let tmpUpper = tmpQuery.trim().toUpperCase();
+		if (!tmpUpper.startsWith('SELECT') && !tmpUpper.startsWith('WITH'))
+		{
+			return fCallback(new Error('RunAggregation only supports SELECT and CTE queries'));
+		}
+
+		let tmpParams = pSettings.Parameters || [];
+		let tmpStart = Date.now();
+
+		this._Client.query(tmpQuery, tmpParams, (pError, pResult) =>
+		{
+			if (pError) return fCallback(pError);
+			let tmpDuration = Date.now() - tmpStart;
+			return fCallback(null, {
+				Outputs: {
+					Rows: pResult.rows,
+					RowCount: pResult.rowCount,
+					DurationMs: tmpDuration,
+					Fields: pResult.fields.map((pField) => pField.name)
+				},
+				Log: [`Aggregation returned ${pResult.rowCount} rows in ${tmpDuration}ms`]
+			});
+		});
+	}
+
+	// --- Action: TableStatistics ---
+
+	get actionTableStatistics_Description()
+	{
+		return 'Collect size, row count, and index statistics for specified tables';
+	}
+
+	get actionTableStatistics_Schema()
+	{
+		return [
+			{ Name: 'SchemaName', DataType: 'String', Required: false, Default: 'public' },
+			{ Name: 'Tables', DataType: 'Array', Required: false }
+		];
+	}
+
+	actionTableStatistics(pSettings, pWorkItem, fCallback)
+	{
+		let tmpSchema = pSettings.SchemaName || 'public';
+
+		let tmpSQL = `
+			SELECT
+				relname AS table_name,
+				pg_size_pretty(pg_total_relation_size(c.oid)) AS total_size,
+				pg_size_pretty(pg_relation_size(c.oid)) AS data_size,
+				pg_size_pretty(pg_indexes_size(c.oid)) AS index_size,
+				n_live_tup AS estimated_rows,
+				last_vacuum,
+				last_autovacuum,
+				last_analyze
+			FROM pg_class c
+			JOIN pg_stat_user_tables s ON c.relname = s.relname
+			WHERE c.relkind = 'r'
+			AND s.schemaname = $1
+			ORDER BY pg_total_relation_size(c.oid) DESC
+		`;
+
+		this._Client.query(tmpSQL, [tmpSchema], (pError, pResult) =>
+		{
+			if (pError) return fCallback(pError);
+
+			let tmpRows = pResult.rows;
+
+			// Filter to specific tables if requested
+			if (pSettings.Tables && pSettings.Tables.length > 0)
+			{
+				let tmpTableSet = new Set(pSettings.Tables);
+				tmpRows = tmpRows.filter((pRow) => tmpTableSet.has(pRow.table_name));
+			}
+
+			return fCallback(null, {
+				Outputs: { Tables: tmpRows, Schema: tmpSchema },
+				Log: [`Collected statistics for ${tmpRows.length} tables in ${tmpSchema}`]
+			});
+		});
+	}
+}
+
+// --- Startup ---
+
+let tmpFable = new libFable({
+	Product: 'PostgresAggregation',
+	ProductVersion: '1.0.0',
+	Postgres:
+	{
+		Host: process.env.PGHOST || 'localhost',
+		Port: parseInt(process.env.PGPORT, 10) || 5432,
+		User: process.env.PGUSER || 'postgres',
+		Password: process.env.PGPASSWORD || '',
+		Database: process.env.PGDATABASE || 'analytics'
+	}
+});
+
+tmpFable.addServiceType('PostgresAggregation', PostgresAggregation);
+let tmpCap = tmpFable.instantiateServiceProvider('PostgresAggregation');
+
+tmpCap.connect(
+	{
+		ServerURL: process.env.ULTRAVISOR_URL || 'http://localhost:54321',
+		Name: 'postgres-aggregation'
+	},
+	(pError) =>
+	{
+		if (pError) throw pError;
+		console.log('PostgreSQL aggregation beacon online');
+	});
+
+process.on('SIGTERM', () => { tmpCap.disconnect(() => process.exit(0)); });
+```
+
+## Registered Task Types
+
+- `beacon-postgresaggregation-refreshmaterializedview`
+- `beacon-postgresaggregation-runaggregation`
+- `beacon-postgresaggregation-tablestatistics`
+
+## Key Points
+
+- **Materialized view refresh** supports `CONCURRENTLY` for zero-downtime refreshes
+- **RunAggregation** accepts parameterized queries via `Parameters` array to prevent SQL injection
+- **TableStatistics** uses PostgreSQL system catalogs for accurate size and vacuum information
+- Query duration is measured and included in outputs for performance monitoring

package/docs/examples/rest-api-health-check.md

@@ -0,0 +1,213 @@
+# Example: REST API Health Check
+
+A capability that monitors multiple REST endpoints and reports their health status. Useful for synthetic monitoring when you want results captured in Ultravisor rather than a separate monitoring tool.
+
+## Full Source
+
+```javascript
+const libFable = require('fable');
+const libBeaconCapability = require('ultravisor-beacon-capability');
+const libHTTPS = require('https');
+const libHTTP = require('http');
+const libURL = require('url');
+
+class RESTHealthCheck extends libBeaconCapability
+{
+	constructor(pFable, pOptions, pServiceHash)
+	{
+		super(pFable, pOptions, pServiceHash);
+		this.serviceType = 'RESTHealthCheck';
+		this.capabilityName = 'RESTHealthCheck';
+	}
+
+	// --- Action: CheckEndpoint ---
+
+	get actionCheckEndpoint_Description()
+	{
+		return 'Check a single REST endpoint and report status, latency, and response';
+	}
+
+	get actionCheckEndpoint_Schema()
+	{
+		return [
+			{ Name: 'URL', DataType: 'String', Required: true },
+			{ Name: 'Method', DataType: 'String', Required: false, Default: 'GET' },
+			{ Name: 'ExpectedStatus', DataType: 'Integer', Required: false, Default: 200 },
+			{ Name: 'TimeoutMs', DataType: 'Integer', Required: false, Default: 10000 },
+			{ Name: 'Headers', DataType: 'Object', Required: false }
+		];
+	}
+
+	actionCheckEndpoint(pSettings, pWorkItem, fCallback)
+	{
+		let tmpParsed = libURL.parse(pSettings.URL);
+		let tmpLib = (tmpParsed.protocol === 'https:') ? libHTTPS : libHTTP;
+		let tmpStart = Date.now();
+
+		let tmpOptions = {
+			hostname: tmpParsed.hostname,
+			port: tmpParsed.port,
+			path: tmpParsed.path,
+			method: pSettings.Method || 'GET',
+			timeout: pSettings.TimeoutMs || 10000,
+			headers: pSettings.Headers || {}
+		};
+
+		let tmpReq = tmpLib.request(tmpOptions, (pRes) =>
+		{
+			let tmpBody = '';
+			pRes.on('data', (pChunk) => { tmpBody += pChunk; });
+			pRes.on('end', () =>
+			{
+				let tmpLatency = Date.now() - tmpStart;
+				let tmpExpected = pSettings.ExpectedStatus || 200;
+				let tmpHealthy = (pRes.statusCode === tmpExpected);
+
+				return fCallback(null, {
+					Outputs: {
+						URL: pSettings.URL,
+						StatusCode: pRes.statusCode,
+						ExpectedStatus: tmpExpected,
+						Healthy: tmpHealthy,
+						LatencyMs: tmpLatency,
+						ResponseBody: tmpBody.substring(0, 2048),
+						Headers: pRes.headers
+					},
+					Log: [
+						`${pSettings.URL} -> ${pRes.statusCode} (${tmpLatency}ms) ${tmpHealthy ? 'HEALTHY' : 'UNHEALTHY'}`
+					]
+				});
+			});
+		});
+
+		tmpReq.on('timeout', () =>
+		{
+			tmpReq.destroy();
+			return fCallback(null, {
+				Outputs: {
+					URL: pSettings.URL,
+					Healthy: false,
+					LatencyMs: Date.now() - tmpStart,
+					Error: 'Request timed out'
+				},
+				Log: [`${pSettings.URL} -> TIMEOUT`]
+			});
+		});
+
+		tmpReq.on('error', (pError) =>
+		{
+			return fCallback(null, {
+				Outputs: {
+					URL: pSettings.URL,
+					Healthy: false,
+					LatencyMs: Date.now() - tmpStart,
+					Error: pError.message
+				},
+				Log: [`${pSettings.URL} -> ERROR: ${pError.message}`]
+			});
+		});
+
+		tmpReq.end();
+	}
+
+	// --- Action: CheckMultiple ---
+
+	get actionCheckMultiple_Description()
+	{
+		return 'Check multiple endpoints in parallel and return a consolidated health report';
+	}
+
+	get actionCheckMultiple_Schema()
+	{
+		return [
+			{ Name: 'Endpoints', DataType: 'Array', Required: true, Description: 'Array of { URL, Method, ExpectedStatus }' },
+			{ Name: 'TimeoutMs', DataType: 'Integer', Required: false, Default: 10000 }
+		];
+	}
+
+	actionCheckMultiple(pSettings, pWorkItem, fCallback, fReportProgress)
+	{
+		let tmpEndpoints = pSettings.Endpoints || [];
+		let tmpResults = [];
+		let tmpCompleted = 0;
+		let tmpTotal = tmpEndpoints.length;
+
+		if (tmpTotal === 0)
+		{
+			return fCallback(null, {
+				Outputs: { Results: [], AllHealthy: true, HealthyCount: 0, TotalCount: 0 },
+				Log: ['No endpoints to check']
+			});
+		}
+
+		tmpEndpoints.forEach((pEndpoint, pIndex) =>
+		{
+			let tmpCheckSettings = {
+				URL: pEndpoint.URL || pEndpoint,
+				Method: pEndpoint.Method || 'GET',
+				ExpectedStatus: pEndpoint.ExpectedStatus || 200,
+				TimeoutMs: pSettings.TimeoutMs || 10000,
+				Headers: pEndpoint.Headers || {}
+			};
+
+			this.actionCheckEndpoint(tmpCheckSettings, pWorkItem, (pError, pResult) =>
+			{
+				tmpCompleted++;
+				tmpResults.push(pResult ? pResult.Outputs : { URL: tmpCheckSettings.URL, Healthy: false, Error: 'Check failed' });
+
+				fReportProgress({
+					Percent: Math.round((tmpCompleted / tmpTotal) * 100),
+					Message: `Checked ${tmpCompleted} / ${tmpTotal} endpoints`
+				});
+
+				if (tmpCompleted === tmpTotal)
+				{
+					let tmpHealthyCount = tmpResults.filter((pR) => pR.Healthy).length;
+					return fCallback(null, {
+						Outputs: {
+							Results: tmpResults,
+							AllHealthy: tmpHealthyCount === tmpTotal,
+							HealthyCount: tmpHealthyCount,
+							UnhealthyCount: tmpTotal - tmpHealthyCount,
+							TotalCount: tmpTotal
+						},
+						Log: [`Health check complete: ${tmpHealthyCount}/${tmpTotal} healthy`]
+					});
+				}
+			});
+		});
+	}
+}
+
+// --- Startup ---
+
+let tmpFable = new libFable({ Product: 'RESTHealthCheck', ProductVersion: '1.0.0' });
+tmpFable.addServiceType('RESTHealthCheck', RESTHealthCheck);
+let tmpCap = tmpFable.instantiateServiceProvider('RESTHealthCheck');
+
+tmpCap.connect(
+	{
+		ServerURL: process.env.ULTRAVISOR_URL || 'http://localhost:54321',
+		Name: 'rest-health-checker'
+	},
+	(pError) =>
+	{
+		if (pError) throw pError;
+		console.log('REST health check beacon online');
+	});
+
+process.on('SIGTERM', () => { tmpCap.disconnect(() => process.exit(0)); });
+```
+
+## Registered Task Types
+
+- `beacon-resthealthcheck-checkendpoint`
+- `beacon-resthealthcheck-checkmultiple`
+
+## Key Points
+
+- **No external HTTP library** -- uses Node.js built-in `http`/`https` modules
+- **Timeout handling** returns results (not errors) so the work item always completes
+- **CheckMultiple** runs all checks in parallel for speed, with progress reporting
+- **Response body** is truncated to 2KB to avoid excessive output
+- Schedule `CheckMultiple` on a cron in Ultravisor to get continuous monitoring with history