@zintrust/workers 0.1.28 → 0.1.30

package/dist/http/WorkerMonitoringService.js

@@ -0,0 +1,62 @@
+import { Logger, NodeSingletons, workersConfig } from '@zintrust/core';
+import { HealthMonitor } from '../HealthMonitor';
+import { getWorkers } from '../dashboard/workers-api';
+// Internal state
+const emitter = new NodeSingletons.EventEmitter();
+emitter.setMaxListeners(Infinity);
+let interval = null;
+let subscribers = 0;
+const INTERVAL_MS = workersConfig?.intervalMs || 5000;
+const broadcastSnapshot = async () => {
+    try {
+        if (subscribers <= 0)
+            return;
+        const monitoring = await HealthMonitor.getSummary();
+        // Fetch full workers listing optimized for dashboard
+        const workersPayload = await getWorkers({ page: 1, limit: 200 });
+        const payload = {
+            type: 'snapshot',
+            ts: new Date().toISOString(),
+            monitoring,
+            workers: workersPayload,
+        };
+        emitter.emit('snapshot', payload);
+    }
+    catch (err) {
+        Logger.error('WorkerMonitoringService.broadcastSnapshot failed', err);
+        emitter.emit('error', err);
+    }
+};
+const startPolling = () => {
+    if (interval)
+        return;
+    Logger.debug('Starting WorkerMonitoringService polling');
+    // Initial fetch
+    void broadcastSnapshot();
+    interval = setInterval(() => {
+        void broadcastSnapshot();
+    }, INTERVAL_MS);
+};
+const stopPolling = () => {
+    if (interval) {
+        Logger.debug('Stopping WorkerMonitoringService polling');
+        clearInterval(interval);
+        interval = null;
+    }
+};
+export const WorkerMonitoringService = Object.freeze({
+    subscribe(callback) {
+        emitter.on('snapshot', callback);
+        subscribers++;
+        if (subscribers === 1) {
+            startPolling();
+        }
+    },
+    unsubscribe(callback) {
+        emitter.off('snapshot', callback);
+        subscribers--;
+        if (subscribers <= 0) {
+            stopPolling();
+        }
+    },
+});

package/dist/http/middleware/CustomValidation.js

@@ -258,7 +258,7 @@ export const ValidationSchemas = {
         },
         driver: {
             type: 'string',
-            allowedValues: ['db', 'redis', 'memory', ''],
+            allowedValues: ['db', 'database', 'redis', 'memory', ''],
             optional: true,
         },
         search: {

package/dist/http/middleware/EditWorkerValidation.d.ts

@@ -2,6 +2,6 @@ import { type IRequest, type IResponse } from '@zintrust/core';
 export type RouteHandler = (req: IRequest, res: IResponse) => Promise<void> | void;
 /**
  * Composite middleware for worker edit validation
- * Maps processorPath to processor for validation and validates all editable fields
+ * Maps processorSpec to processor for validation and validates all editable fields
  */
 export declare const withEditWorkerValidation: (handler: RouteHandler) => RouteHandler;

package/dist/http/middleware/EditWorkerValidation.js

@@ -10,19 +10,19 @@ import { withVersionValidation } from './VersionSanitizer';
 import { withWorkerNameValidation } from './WorkerNameSanitizer';
 /**
  * Composite middleware for worker edit validation
- * Maps processorPath to processor for validation and validates all editable fields
+ * Maps processorSpec to processor for validation and validates all editable fields
  */
 export const withEditWorkerValidation = (handler) => {
     return async (req, res) => {
         try {
             const data = req.data();
             const currentBody = req.getBody();
-            // Map processorPath to processor for validation if processorPath exists
+            // Map processorSpec/processorSpec to processor for validation if provided
             let mappedBody = { ...currentBody };
-            if (data['processorPath'] && !data['processor']) {
+            if (data['processorSpec'] && !data['processor']) {
                 mappedBody = {
                     ...mappedBody,
-                    processor: data['processorPath'], // Map for validation
+                    processor: data['processorSpec'],
                 };
             }
             // Update the request body with mapped fields
@@ -31,8 +31,8 @@ export const withEditWorkerValidation = (handler) => {
             return withStrictPayloadKeys([
                 'name',
                 'queueName',
-                'processor', // Validated field (mapped from processorPath)
-                'processorPath', // Original field
+                'processor', // Validated field (mapped from processorSpec)
+                'processorSpec',
                 'version',
                 'options', // Skip strict validation for editing
                 'infrastructure',
@@ -41,6 +41,7 @@ export const withEditWorkerValidation = (handler) => {
                 'concurrency', // Original field
                 'region',
                 'autoStart',
+                'activeStatus',
                 'status',
             ], withProcessorPathValidation(withWorkerNameValidation(withQueueNameValidation(withVersionValidation(withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler))))))))(req, res);
         }

package/dist/http/middleware/ProcessorPathSanitizer.js

@@ -1,5 +1,17 @@
-import { Logger, NodeSingletons } from '@zintrust/core';
-const PROCESSOR_PATH_PATTERN = /^[a-zA-Z0-9/_.-]+\.(ts|js)$/;
+import { Logger, NodeSingletons, workersConfig, } from '@zintrust/core';
+const PROCESSOR_PATH_PATTERN = /^[a-zA-Z0-9/_.-]+\.(ts|js|mjs|cjs)$/;
+const isUrlSpec = (value) => {
+    if (value.startsWith('url:'))
+        return true;
+    return value.includes('://');
+};
+const normalizeUrlSpec = (value) => {
+    return value.startsWith('url:') ? value.slice(4) : value;
+};
+const isAllowedRemoteHost = (host) => {
+    const allowlist = workersConfig.processorSpec.remoteAllowlist;
+    return allowlist.map((value) => value.toLowerCase()).includes(host.toLowerCase());
+};
 const decodeProcessorPath = (processor) => {
     return processor
         .replaceAll('/', '/') // HTML hex entity for /
@@ -11,6 +23,70 @@ const decodeProcessorPath = (processor) => {
         .replaceAll('-', '-') // HTML hex entity for -
         .replaceAll('%2D', '-'); // URL encoding for -
 };
+const validateUrlSpec = (processor) => {
+    const normalized = normalizeUrlSpec(processor);
+    let parsed;
+    try {
+        parsed = new URL(normalized);
+    }
+    catch {
+        return {
+            isValid: false,
+            error: { error: 'Invalid processor url', code: 'INVALID_PROCESSOR_URL' },
+        };
+    }
+    if (parsed.protocol === 'file:') {
+        const path = NodeSingletons.path;
+        const baseDir = path.resolve(process.cwd());
+        const resolved = path.resolve(baseDir, decodeURIComponent(parsed.pathname));
+        if (!resolved.startsWith(baseDir)) {
+            return {
+                isValid: false,
+                error: { error: 'Invalid processor path', code: 'INVALID_PROCESSOR_PATH_TRAVERSAL' },
+            };
+        }
+    }
+    else {
+        if (parsed.protocol !== 'https:') {
+            return {
+                isValid: false,
+                error: { error: 'Invalid processor url', code: 'INVALID_PROCESSOR_URL' },
+            };
+        }
+        if (!isAllowedRemoteHost(parsed.host)) {
+            return {
+                isValid: false,
+                error: { error: 'Invalid processor url host', code: 'INVALID_PROCESSOR_URL_HOST' },
+            };
+        }
+    }
+    return { isValid: true };
+};
+const validateRelativePath = (processor) => {
+    if (processor.includes('..') || processor.startsWith('/')) {
+        return {
+            isValid: false,
+            error: { error: 'Invalid processor path', code: 'INVALID_PROCESSOR_PATH' },
+        };
+    }
+    if (!PROCESSOR_PATH_PATTERN.test(processor)) {
+        return {
+            isValid: false,
+            error: { error: 'Invalid processor path', code: 'INVALID_PROCESSOR_EXTENSION' },
+        };
+    }
+    return { isValid: true };
+};
+const sanitizeAndResolvePath = (processor) => {
+    const sanitizedProcessor = processor.replaceAll(/[^a-zA-Z0-9/_.-]/g, '');
+    const path = NodeSingletons.path;
+    const baseDir = path.resolve(process.cwd());
+    const resolved = path.resolve(baseDir, sanitizedProcessor);
+    if (!resolved.startsWith(baseDir)) {
+        return { isValid: false, sanitized: processor };
+    }
+    return { isValid: true, sanitized: sanitizedProcessor };
+};
 export const withProcessorPathValidation = (handler) => {
     return async (req, res) => {
         try {
@@ -18,49 +94,39 @@ export const withProcessorPathValidation = (handler) => {
             let processor = data['processor'];
             if (!processor) {
                 return res.setStatus(400).json({
-                    error: 'Processor path is required',
-                    code: 'MISSING_PROCESSOR_PATH',
+                    error: 'Processor spec is required',
+                    code: 'MISSING_PROCESSOR_SPEC',
                 });
             }
             // Decode URL-encoded characters
             processor = decodeProcessorPath(processor);
             // Trim whitespace
             processor = processor.trim();
-            // Prevent path traversal
-            if (processor.includes('..') || processor.startsWith('/')) {
-                return res.setStatus(400).json({
-                    error: 'Invalid processor path',
-                    message: 'Processor path must be relative and cannot contain path traversal',
-                    code: 'INVALID_PROCESSOR_PATH',
-                });
+            const isUrl = isUrlSpec(processor);
+            let validation;
+            if (isUrl) {
+                validation = validateUrlSpec(processor);
             }
-            if (!PROCESSOR_PATH_PATTERN.test(processor)) {
-                Logger.error('Processor path validation failed', {
-                    processor,
-                    pattern: PROCESSOR_PATH_PATTERN.toString(),
-                    testResult: PROCESSOR_PATH_PATTERN.test(processor),
-                });
-                return res.setStatus(400).json({
-                    error: 'Invalid processor path',
-                    message: `Processor must be a TypeScript or JavaScript file. Got: "${processor}"`,
-                    code: 'INVALID_PROCESSOR_EXTENSION',
-                });
+            else {
+                validation = validateRelativePath(processor);
+                if (validation.isValid) {
+                    const pathValidation = sanitizeAndResolvePath(processor);
+                    if (pathValidation.isValid) {
+                        processor = pathValidation.sanitized;
+                    }
+                    else {
+                        validation = {
+                            isValid: false,
+                            error: { error: 'Invalid processor path', code: 'INVALID_PROCESSOR_PATH_TRAVERSAL' },
+                        };
+                    }
+                }
             }
-            // Sanitize the processor path (remove any invalid characters just in case)
-            const sanitizedProcessor = processor.replaceAll(/[^a-zA-Z0-9/_.-]/g, '');
-            const path = NodeSingletons.path;
-            // Ensure resolved path stays within repository/app scope
-            const BASE_PROCESSOR_DIR = path.resolve(process.cwd());
-            const resolved = path.resolve(BASE_PROCESSOR_DIR, sanitizedProcessor);
-            if (!resolved.startsWith(BASE_PROCESSOR_DIR)) {
-                return res.setStatus(400).json({
-                    error: 'Invalid processor path',
-                    message: 'Processor path resolves outside of allowed base directory',
-                    code: 'INVALID_PROCESSOR_PATH_TRAVERSAL',
-                });
+            if (!validation.isValid) {
+                return res.setStatus(400).json(validation.error);
             }
             const currentBody = req.getBody();
-            req.setBody({ ...currentBody, processor: sanitizedProcessor });
+            req.setBody({ ...currentBody, processor });
             return handler(req, res);
         }
         catch (error) {

package/dist/http/middleware/WorkerValidationChain.js

@@ -23,6 +23,7 @@ export const withCreateWorkerValidation = (handler) => {
         'infrastructure',
         'features',
         'datacenter',
+        'activeStatus',
     ], withProcessorPathValidation(withWorkerNameValidation(withQueueNameValidation(withVersionValidation(withOptionsValidation(withInfrastructureValidation(withFeaturesValidation(withDatacenterValidation(handler)))))))));
 };
 /**

package/dist/index.d.ts

@@ -23,9 +23,10 @@ export { DatacenterOrchestrator } from './DatacenterOrchestrator';
 export { MultiQueueWorker } from './MultiQueueWorker';
 export { WorkerVersioning } from './WorkerVersioning';
 export { WorkerFactory } from './WorkerFactory';
-export type { WorkerPersistenceConfig } from './WorkerFactory';
+export type { ProcessorResolver, WorkerFactoryConfig, WorkerPersistenceConfig, } from './WorkerFactory';
 export { WorkerInit } from './WorkerInit';
 export { WorkerShutdown } from './WorkerShutdown';
+export { ZinTrustWorkerShutdownDurableObject } from './WorkerShutdownDurableObject';
 export { WorkerController } from './http/WorkerController';
 export { registerWorkerRoutes } from './routes/workers';
 export { BroadcastWorker } from './BroadcastWorker';

package/dist/index.js

@@ -33,6 +33,7 @@ export { WorkerVersioning } from './WorkerVersioning';
 export { WorkerFactory } from './WorkerFactory';
 export { WorkerInit } from './WorkerInit';
 export { WorkerShutdown } from './WorkerShutdown';
+export { ZinTrustWorkerShutdownDurableObject } from './WorkerShutdownDurableObject';
 // HTTP Controllers & Routes
 export { WorkerController } from './http/WorkerController';
 export { registerWorkerRoutes } from './routes/workers';

package/dist/routes/workers.js

@@ -3,20 +3,24 @@
  * HTTP API for managing workers with dashboard functionality
  */
 import { Logger, Router } from '@zintrust/core';
-import { WorkerApiController } from '../http/WorkerApiController';
-import { WorkerController } from '../http/WorkerController';
+import { HealthMonitor } from '../HealthMonitor';
 import { ValidationSchemas, withCustomValidation } from '../http/middleware/CustomValidation';
 import { withEditWorkerValidation } from '../http/middleware/EditWorkerValidation';
 import { withDriverValidation } from '../http/middleware/ValidateDriver';
 import { withCreateWorkerValidation, withWorkerOperationValidation, } from '../http/middleware/WorkerValidationChain';
+import { WorkerApiController } from '../http/WorkerApiController';
+import { WorkerController } from '../http/WorkerController';
+import { ResourceMonitor } from '../ResourceMonitor';
+import { TelemetryDashboard } from '../telemetry';
 import { registerStaticAssets } from '../ui/router/ui';
+import { WorkerFactory } from '../WorkerFactory';
 const controller = WorkerController.create();
 const apiController = WorkerApiController.create();
 function registerCoreWorkerRoutes(r) {
     // Core worker operations
     Router.post(r, '/create', withCreateWorkerValidation(controller.create));
     Router.put(r, '/:name', withCreateWorkerValidation(controller.update));
-    // Worker editing with custom validation that handles processorPath mapping
+    // Worker editing with custom validation that handles mapping
     Router.put(r, '/:name/edit', withEditWorkerValidation(controller.update));
     Router.post(r, '/:name/start', withDriverValidation(withWorkerOperationValidation(controller.start)));
     Router.post(r, '/:name/auto-start', withDriverValidation(withWorkerOperationValidation(controller.setAutoStart)));
@@ -40,6 +44,8 @@ function registerWorkerQueryRoutes(r) {
     Router.get(r, '/:name/driver-data', withDriverValidation(apiController.getWorkerDriverDataHandler));
 }
 function registerMonitoringRoutes(r) {
+    // SSE events stream for monitoring + workers snapshot
+    Router.get(r, '/events', controller.eventsStream);
     // Health monitoring
     Router.post(r, '/:name/monitoring/start', controller.startMonitoring);
     Router.post(r, '/:name/monitoring/stop', controller.stopMonitoring);
@@ -48,8 +54,6 @@ function registerMonitoringRoutes(r) {
     Router.put(r, '/:name/monitoring/config', controller.updateMonitoringConfig);
     // SLA monitoring
     Router.get(r, '/:name/sla/status', controller.getSlaStatus);
-    // SSE events stream for monitoring + workers snapshot
-    Router.get(r, '/events', controller.eventsStream);
 }
 function registerVersioningRoutes(r) {
     // Versioning
@@ -66,16 +70,54 @@ function registerUtilityRoutes(r) {
 function registerWorkerLifecycleRoutes(router, middleware) {
     Router.group(router, '/api/workers', (r) => {
         Logger.info('Registering Worker Management Routes');
+        registerMonitoringRoutes(r); // ← Move FIRST - has /events
         registerCoreWorkerRoutes(r);
         registerWorkerQueryRoutes(r);
-        registerMonitoringRoutes(r);
         registerVersioningRoutes(r);
         registerUtilityRoutes(r);
     }, { middleware: middleware });
 }
+function registerWorkerTelemetryRoutes(router, middleware) {
+    const options = middleware ? { middleware } : undefined;
+    Router.group(router, '/api', (r) => {
+        Router.get(r, '/workers/system/summary', async (_req, res) => {
+            const workers = WorkerFactory.list();
+            const monitoringSummary = await HealthMonitor.getSummary();
+            const resourceUsage = ResourceMonitor.getCurrentUsage('system');
+            res.json({
+                ok: true,
+                summary: {
+                    workers: workers.length,
+                    monitoring: monitoringSummary,
+                    resources: resourceUsage,
+                },
+            });
+        });
+        Router.get(r, '/workers/system/monitoring/summary', async (_req, res) => {
+            const summary = await HealthMonitor.getSummary();
+            res.json({ ok: true, summary });
+        });
+        Router.get(r, '/resources/current', async (_req, res) => {
+            const usage = ResourceMonitor.getCurrentUsage('system');
+            res.json({ ok: true, usage });
+        });
+        Router.get(r, '/resources/trends', async (req, res) => {
+            const period = (req.getParam('period') ?? 'day');
+            const trends = ResourceMonitor.getAllTrends('system', period);
+            res.json({ ok: true, trends });
+        });
+    }, options);
+}
 export function registerWorkerRoutes(router, _options, routeOptions) {
     registerStaticAssets(router, routeOptions?.middleware ?? []);
     registerWorkerLifecycleRoutes(router, routeOptions?.middleware);
+    registerWorkerTelemetryRoutes(router, routeOptions?.middleware);
+    // Register Telemetry Dashboard
+    const dashboard = TelemetryDashboard.create({
+        basePath: '/telemetry',
+    });
+    dashboard.registerRoutes(router);
     Logger.info('Worker routes registered at http://127.0.0.1:7777/workers');
+    Logger.info('Telemetry dashboard registered at http://127.0.0.1:7777/telemetry');
 }
 export default registerWorkerRoutes;

package/dist/storage/WorkerStore.d.ts

@@ -12,7 +12,8 @@ export type WorkerRecord = {
     autoStart: boolean;
     concurrency: number;
     region: string | null;
-    processorPath?: string | null;
+    processorSpec?: string | null;
+    activeStatus?: boolean;
     features?: Record<string, unknown> | null;
     infrastructure?: Record<string, unknown> | null;
     datacenter?: Record<string, unknown> | null;
@@ -28,10 +29,12 @@ export type WorkerStore = {
         offset?: number;
         limit?: number;
         search?: string;
+        includeInactive?: boolean;
     }): Promise<WorkerRecord[]>;
     get(name: string): Promise<WorkerRecord | null>;
     save(record: WorkerRecord): Promise<void>;
     update(name: string, patch: Partial<WorkerRecord>): Promise<void>;
+    updateMany?: (names: string[], patch: Partial<WorkerRecord>) => Promise<void>;
     remove(name: string): Promise<void>;
 };
 export declare const InMemoryWorkerStore: Readonly<{

package/dist/storage/WorkerStore.js

@@ -8,6 +8,12 @@ const mergeRecord = (current, patch) => ({
     ...patch,
     updatedAt: patch.updatedAt ?? now(),
 });
+const toSqlDateTime = (value) => {
+    if (!value)
+        return null;
+    // Use UTC and drop timezone for SQL DATETIME compatibility
+    return value.toISOString().slice(0, 19).replace('T', ' ');
+};
 const serializeDbWorker = (record) => ({
     name: record.name,
     queue_name: record.queueName,
@@ -16,13 +22,14 @@ const serializeDbWorker = (record) => ({
     auto_start: record.autoStart,
     concurrency: record.concurrency,
     region: record.region,
-    processor_path: record.processorPath ?? null,
+    processor_spec: record.processorSpec ?? null,
+    active_status: record.activeStatus ?? true,
     features: record.features ? JSON.stringify(record.features) : null,
     infrastructure: record.infrastructure ? JSON.stringify(record.infrastructure) : null,
     datacenter: record.datacenter ? JSON.stringify(record.datacenter) : null,
-    created_at: record.createdAt,
-    updated_at: record.updatedAt,
-    last_health_check: record.lastHealthCheck ?? null,
+    created_at: toSqlDateTime(record.createdAt),
+    updated_at: toSqlDateTime(record.updatedAt),
+    last_health_check: toSqlDateTime(record.lastHealthCheck ?? null),
     last_error: record.lastError ?? null,
     connection_state: record.connectionState ?? null,
 });
@@ -53,7 +60,8 @@ const deserializeDbWorker = (row) => {
         autoStart: Boolean(row['auto_start'] ?? false),
         concurrency: Number(row['concurrency'] ?? 0),
         region: row['region'] ? String(row['region']) : null,
-        processorPath: row['processor_path'] ? String(row['processor_path']) : null,
+        processorSpec: String(row['processor_spec']),
+        activeStatus: row['active_status'] === undefined ? true : Boolean(row['active_status']),
         features: parseJson(row['features']),
         infrastructure: parseJson(row['infrastructure']),
         datacenter: parseJson(row['datacenter']),
@@ -94,6 +102,14 @@ export const InMemoryWorkerStore = Object.freeze({
                     return;
                 store.set(name, mergeRecord(current, patch));
             },
+            async updateMany(names, patch) {
+                for (const name of names) {
+                    const current = store.get(name);
+                    if (!current)
+                        continue;
+                    store.set(name, mergeRecord(current, patch));
+                }
+            },
             async remove(name) {
                 store.delete(name);
             },
@@ -122,7 +138,7 @@ export const RedisWorkerStore = Object.freeze({
             },
             async list(options) {
                 const all = await client.hgetall(key);
-                let values = Object.values(all).map(deserialize);
+                let values = Object.values(all).map((element) => deserialize(element));
                 values.sort((a, b) => a.name.localeCompare(b.name));
                 if (options) {
                     const start = options.offset || 0;
@@ -144,6 +160,22 @@ export const RedisWorkerStore = Object.freeze({
                     return;
                 await client.hset(key, name, serialize(mergeRecord(current, patch)));
             },
+            async updateMany(names, patch) {
+                if (names.length === 0)
+                    return;
+                const entries = await client.hmget(key, ...names);
+                const updates = [];
+                entries.forEach((raw, index) => {
+                    if (!raw)
+                        return;
+                    const current = deserialize(raw);
+                    const updated = mergeRecord(current, patch);
+                    updates.push(names[index], serialize(updated));
+                });
+                if (updates.length === 0)
+                    return;
+                await client.hset(key, ...updates);
+            },
             async remove(name) {
                 await client.hdel(key, name);
             },
@@ -163,7 +195,7 @@ export const DbWorkerStore = Object.freeze({
                 if (options?.offset)
                     query.offset(options.offset);
                 const rows = await query.get();
-                return rows.map(deserializeDbWorker);
+                return rows.map((element) => deserializeDbWorker(element));
             },
             async get(name) {
                 const row = await db.table(table).where('name', '=', name).first();
@@ -187,6 +219,22 @@ export const DbWorkerStore = Object.freeze({
                 const updated = mergeRecord(current, patch);
                 await db.table(table).where('name', '=', name).update(serializeDbWorker(updated));
             },
+            async updateMany(names, patch) {
+                if (names.length === 0)
+                    return;
+                const update = {
+                    updated_at: toSqlDateTime(patch.updatedAt ?? now()),
+                };
+                if (patch.status !== undefined)
+                    update['status'] = patch.status;
+                if (patch.lastError !== undefined)
+                    update['last_error'] = patch.lastError ?? null;
+                if (patch.lastHealthCheck !== undefined)
+                    update['last_health_check'] = toSqlDateTime(patch.lastHealthCheck ?? null);
+                if (patch.connectionState !== undefined)
+                    update['connection_state'] = patch.connectionState ?? null;
+                await db.table(table).whereIn('name', names).update(update);
+            },
             async remove(name) {
                 await db.table(table).where('name', '=', name).delete();
             },

package/dist/telemetry/api/TelemetryAPI.d.ts

@@ -0,0 +1,46 @@
+export type TelemetrySettings = {
+    enabled: boolean;
+    basePath: string;
+    middleware: ReadonlyArray<string>;
+    autoRefresh: boolean;
+    refreshIntervalMs: number;
+};
+export type ResourceCurrentResponse = {
+    ok: boolean;
+    usage?: unknown;
+};
+export type SystemSummaryResponse = {
+    ok: boolean;
+    summary?: unknown;
+};
+export type ApiResponse<T> = {
+    ok: boolean;
+    error?: string;
+} & T;
+export type AlertRep = {
+    type: string;
+    severity: string;
+    message: string;
+    timestamp: string;
+    recommendation?: string;
+};
+export declare const TelemetryAPI: Readonly<{
+    getSystemSummary(): Promise<ApiResponse<{
+        summary: unknown;
+    }>>;
+    getMonitoringSummary(): Promise<ApiResponse<{
+        summary: unknown;
+    }>>;
+    getResourceCurrent(): Promise<ApiResponse<{
+        usage: unknown;
+    }>>;
+    getResourceTrends(): Promise<ApiResponse<{
+        trends: unknown;
+    }>>;
+}>;
+export declare function createSnapshotBuilder(): () => Promise<{
+    ok: boolean;
+    summary: unknown;
+    resources: unknown;
+    cost: unknown;
+}>;