@zintrust/core 0.1.42 → 0.1.44

package/packages/workers/src/storage/WorkerStore.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+import type { createRedisConnection } from '../../../../src/index.js';
+import { type IDatabase } from '../../../../src/index.js';
+type RedisConnection = ReturnType<typeof createRedisConnection>;
+export type WorkerRecord = {
+    name: string;
+    queueName: string;
+    version: string | null;
+    status: string;
+    autoStart: boolean;
+    concurrency: number;
+    region: string | null;
+    processorSpec?: string | null;
+    activeStatus?: boolean;
+    features?: Record<string, unknown> | null;
+    infrastructure?: Record<string, unknown> | null;
+    datacenter?: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+    lastHealthCheck?: Date;
+    lastError?: string;
+    connectionState?: 'disconnected' | 'connecting' | 'connected' | 'error';
+};
+export type WorkerStore = {
+    init(): Promise<void>;
+    list(options?: {
+        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>;
+    close?(): Promise<void>;
+};
+export declare const InMemoryWorkerStore: Readonly<{
+    create(): WorkerStore;
+}>;
+export declare const RedisWorkerStore: Readonly<{
+    create(client: RedisConnection, keyPrefix?: string): WorkerStore;
+}>;
+export declare const DbWorkerStore: Readonly<{
+    create(db: IDatabase, table?: string): WorkerStore;
+}>;
+export {};
+//# sourceMappingURL=WorkerStore.d.ts.map

package/packages/workers/src/storage/WorkerStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkerStore.d.ts","sourceRoot":"","sources":["../../../../../packages/workers/src/storage/WorkerStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,KAAK,eAAe,GAAG,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEhE,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC5C,SAAS,EAAE,IAAI,CAAC;IAChB,SAAS,EAAE,IAAI,CAAC;IAChB,eAAe,CAAC,EAAE,IAAI,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,OAAO,CAAC;CACzE,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,CAAC,OAAO,CAAC,EAAE;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,eAAe,CAAC,EAAE,OAAO,CAAC;KAC3B,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;IAC5B,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChD,IAAI,CAAC,MAAM,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1C,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClE,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,CAAC,YAAY,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9E,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACpC,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB,CAAC;AAgFF,eAAO,MAAM,mBAAmB;cACpB,WAAW;EA0CrB,CAAC;AAEH,eAAO,MAAM,gBAAgB;mBACZ,eAAe,uBAAmC,WAAW;EA2E5E,CAAC;AAEH,eAAO,MAAM,aAAa;eACb,SAAS,mBAA+B,WAAW;EA2D9D,CAAC"}

package/packages/workers/src/storage/WorkerStore.js

@@ -0,0 +1,259 @@
+/**
+ * Worker Store
+ * Persistence layer for workers (memory, redis, db)
+ */
+const now = () => new Date();
+const mergeRecord = (current, patch) => ({
+    ...current,
+    ...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,
+    version: record.version,
+    status: record.status,
+    auto_start: record.autoStart,
+    concurrency: record.concurrency,
+    region: record.region,
+    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: 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,
+});
+const getHealthCheck = (row) => {
+    if (!row['last_health_check']) {
+        return undefined;
+    }
+    return row['last_health_check'] instanceof Date
+        ? row['last_health_check']
+        : new Date(String(row['last_health_check']));
+};
+const deserializeDbWorker = (row) => {
+    const parseJson = (value) => {
+        if (typeof value !== 'string' || value.trim() === '')
+            return null;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        name: String(row['name'] ?? ''),
+        queueName: String(row['queue_name'] ?? ''),
+        version: row['version'] ? String(row['version']) : null,
+        status: String(row['status'] ?? 'unknown'),
+        autoStart: Boolean(row['auto_start'] ?? false),
+        concurrency: Number(row['concurrency'] ?? 0),
+        region: row['region'] ? String(row['region']) : 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']),
+        createdAt: row['created_at'] instanceof Date ? row['created_at'] : new Date(String(row['created_at'])),
+        updatedAt: row['updated_at'] instanceof Date ? row['updated_at'] : new Date(String(row['updated_at'])),
+        lastHealthCheck: getHealthCheck(row),
+        lastError: row['last_error'] ? String(row['last_error']) : undefined,
+        connectionState: row['connection_state']
+            ? String(row['connection_state'])
+            : undefined,
+    };
+};
+export const InMemoryWorkerStore = Object.freeze({
+    create() {
+        const store = new Map();
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                let values = Array.from(store.values());
+                if (options) {
+                    const start = options.offset || 0;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                return store.get(name) ?? null;
+            },
+            async save(record) {
+                store.set(record.name, record);
+            },
+            async update(name, patch) {
+                const current = store.get(name);
+                if (!current)
+                    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);
+            },
+            async close() {
+                // No-op for memory store
+            },
+        };
+    },
+});
+export const RedisWorkerStore = Object.freeze({
+    create(client, keyPrefix = 'workers:registry') {
+        const key = keyPrefix;
+        const serialize = (record) => JSON.stringify({
+            ...record,
+            createdAt: record.createdAt.toISOString(),
+            updatedAt: record.updatedAt.toISOString(),
+        });
+        const deserialize = (raw) => {
+            const parsed = JSON.parse(raw);
+            return {
+                ...parsed,
+                createdAt: new Date(parsed.createdAt),
+                updatedAt: new Date(parsed.updatedAt),
+            };
+        };
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const all = await client.hgetall(key);
+                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;
+                    const end = options.limit ? start + options.limit : undefined;
+                    values = values.slice(start, end);
+                }
+                return values;
+            },
+            async get(name) {
+                const raw = await client.hget(key, name);
+                return raw ? deserialize(raw) : null;
+            },
+            async save(record) {
+                await client.hset(key, record.name, serialize(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    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 close() {
+                try {
+                    // Force disconnect in Cloudflare env to avoid hanging on quit()
+                    client.disconnect();
+                }
+                catch {
+                    // Ignore connection errors during cleanup
+                }
+            },
+            async remove(name) {
+                await client.hdel(key, name);
+            },
+        };
+    },
+});
+export const DbWorkerStore = Object.freeze({
+    create(db, table = 'zintrust_workers') {
+        return {
+            async init() {
+                return undefined;
+            },
+            async list(options) {
+                const query = db.table(table);
+                if (options?.limit)
+                    query.limit(options.limit);
+                if (options?.offset)
+                    query.offset(options.offset);
+                const rows = await query.get();
+                return rows.map((element) => deserializeDbWorker(element));
+            },
+            async get(name) {
+                const row = await db.table(table).where('name', '=', name).first();
+                return row ? deserializeDbWorker(row) : null;
+            },
+            async save(record) {
+                const existing = await db
+                    .table(table)
+                    .where('name', '=', record.name)
+                    .first();
+                if (existing) {
+                    await db.table(table).where('name', '=', record.name).update(serializeDbWorker(record));
+                    return;
+                }
+                await db.table(table).insert(serializeDbWorker(record));
+            },
+            async update(name, patch) {
+                const current = await this.get(name);
+                if (!current)
+                    return;
+                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();
+            },
+            async close() {
+                // Database clients often managed by pool, but if needed:
+                // await db.destroy?.();
+            },
+        };
+    },
+});

package/packages/workers/src/telemetry/api/TelemetryAPI.d.ts

@@ -0,0 +1,47 @@
+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;
+}>;
+//# sourceMappingURL=TelemetryAPI.d.ts.map

package/packages/workers/src/telemetry/api/TelemetryAPI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryAPI.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/telemetry/api/TelemetryAPI.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;IAClC,WAAW,EAAE,OAAO,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AACvE,MAAM,MAAM,qBAAqB,GAAG;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAQvE,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,CAAC,CAAC;AACjE,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AA+IF,eAAO,MAAM,YAAY;wBACG,OAAO,CAAC,WAAW,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;4BAuCtC,OAAO,CAAC,WAAW,CAAC;QAAE,OAAO,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;0BAc5C,OAAO,CAAC,WAAW,CAAC;QAAE,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;yBAczC,OAAO,CAAC,WAAW,CAAC;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC,CAAC;EAapE,CAAC;AAEH,wBAAgB,qBAAqB,UAClB,OAAO,CAAC;IACvB,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC,CA4BH"}

package/packages/workers/src/telemetry/api/TelemetryAPI.js

@@ -0,0 +1,219 @@
+import { Logger } from '../../../../../src/index.js';
+import { getWorkers } from '../../dashboard/workers-api.js';
+import { HealthMonitor } from '../../HealthMonitor.js';
+import { ResourceMonitor } from '../../ResourceMonitor.js';
+const isOkWithUsage = (value) => value.ok === true && 'usage' in value;
+const isOkWithSummary = (value) => value.ok === true && 'summary' in value;
+// Helper function to create stopped worker alert
+const createStoppedWorkerAlert = (worker) => ({
+    type: 'worker-stopped',
+    severity: 'warning',
+    message: `Worker ${worker.name} is stopped`,
+    timestamp: worker.health?.lastCheck || new Date().toISOString(),
+});
+// Helper function to create health check alert
+const createHealthCheckAlert = (worker) => {
+    const check = worker.health?.checks?.[0];
+    if (!check)
+        return null;
+    return {
+        type: 'health-check-failed',
+        severity: check.status === 'fail' ? 'critical' : 'warning',
+        message: check.message || `Health check failed: ${check.name}`,
+        timestamp: worker.health?.lastCheck || new Date().toISOString(),
+    };
+};
+// Helper function to generate worker alerts
+const generateWorkerAlerts = (workers) => {
+    return workers
+        .filter((w) => {
+        return (w.status !== 'running' ||
+            w.health?.status !== 'healthy' ||
+            (w.health?.checks && w.health.checks.length > 0));
+    })
+        .map((w) => {
+        const workerData = {
+            workerName: w.name,
+            status: w.status,
+            healthStatus: w.health?.status || 'unknown',
+            lastCheck: w.health?.lastCheck || new Date().toISOString(),
+            checks: w.health?.checks || [],
+        };
+        let alert = null;
+        if (w.status === 'stopped') {
+            alert = createStoppedWorkerAlert(w);
+        }
+        else if (w.health?.checks && w.health.checks.length > 0) {
+            alert = createHealthCheckAlert(w);
+        }
+        return {
+            ...workerData,
+            alert,
+        };
+    })
+        .filter((w) => w.alert !== null);
+};
+// Helper function to generate resource alerts
+const generateResourceAlerts = (resourceUsage) => {
+    const resourceAlerts = [];
+    const cpuUsage = resourceUsage.resourceSnapshot?.cpu?.usage || 0;
+    const memoryUsage = resourceUsage.resourceSnapshot?.memory?.usage || 0;
+    if (cpuUsage > 90) {
+        resourceAlerts.push({
+            type: 'cpu-high',
+            severity: 'critical',
+            message: `Critical CPU usage: ${cpuUsage.toFixed(1)}%`,
+            timestamp: new Date().toISOString(),
+            recommendation: 'Consider scaling up or optimizing worker code',
+        });
+    }
+    else if (cpuUsage > 80) {
+        resourceAlerts.push({
+            type: 'cpu-high',
+            severity: 'warning',
+            message: `High CPU usage: ${cpuUsage.toFixed(1)}%`,
+            timestamp: new Date().toISOString(),
+            recommendation: 'Monitor closely and consider scaling',
+        });
+    }
+    if (memoryUsage > 95) {
+        resourceAlerts.push({
+            type: 'memory-high',
+            severity: 'critical',
+            message: `Critical memory usage: ${memoryUsage.toFixed(1)}%`,
+            timestamp: new Date().toISOString(),
+            recommendation: 'Increase memory allocation or optimize memory usage',
+        });
+    }
+    else if (memoryUsage > 85) {
+        resourceAlerts.push({
+            type: 'memory-high',
+            severity: 'warning',
+            message: `High memory usage: ${memoryUsage.toFixed(1)}%`,
+            timestamp: new Date().toISOString(),
+            recommendation: 'Monitor memory usage closely',
+        });
+    }
+    return resourceAlerts;
+};
+// Helper function to calculate monitoring summary
+const calculateMonitoringSummary = (runningWorkers) => {
+    const healthyCount = runningWorkers.filter((w) => w.health?.status === 'healthy').length;
+    const degradedCount = runningWorkers.filter((w) => w.health?.status === 'warning').length;
+    const criticalCount = runningWorkers.filter((w) => w.health?.status === 'unhealthy').length;
+    return {
+        total: runningWorkers.length,
+        healthy: healthyCount,
+        degraded: degradedCount,
+        critical: criticalCount,
+        details: runningWorkers.map((w) => ({
+            workerName: w.name,
+            status: w.health?.status || 'unknown',
+            lastCheck: w.health?.lastCheck || new Date().toISOString(),
+            checks: w.health?.checks || [],
+        })),
+    };
+};
+export const TelemetryAPI = Object.freeze({
+    async getSystemSummary() {
+        try {
+            // Get all workers (both running and stopped) for complete alert visibility
+            const workersResult = await getWorkers({});
+            const runningWorkers = workersResult.workers.filter((w) => w.status === 'running');
+            // Calculate monitoring summary from running workers only
+            const monitoringSummary = calculateMonitoringSummary(runningWorkers);
+            // Generate alerts from workers and resources
+            const workerAlerts = generateWorkerAlerts(workersResult.workers);
+            const resourceUsage = ResourceMonitor.getCurrentUsage('system');
+            const resourceAlerts = generateResourceAlerts(resourceUsage);
+            // Combine all alerts
+            const allAlerts = [...workerAlerts, ...resourceAlerts];
+            return {
+                ok: true,
+                summary: {
+                    workers: runningWorkers.length,
+                    monitoring: {
+                        ...monitoringSummary,
+                        alerts: allAlerts, // Include all alerts (workers + resources)
+                    },
+                    resources: resourceUsage,
+                    alerts: allAlerts, // Top-level alerts for easy access
+                },
+            };
+        }
+        catch (error) {
+            Logger.error('Failed to get system summary', error);
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                summary: {},
+            };
+        }
+    },
+    async getMonitoringSummary() {
+        try {
+            const summary = await HealthMonitor.getSummary();
+            return { ok: true, summary };
+        }
+        catch (error) {
+            Logger.error('Failed to get monitoring summary', error);
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                summary: {},
+            };
+        }
+    },
+    async getResourceCurrent() {
+        try {
+            const usage = ResourceMonitor.getCurrentUsage('system');
+            return { ok: true, usage };
+        }
+        catch (error) {
+            Logger.error('Failed to get resource usage', error);
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                usage: null,
+            };
+        }
+    },
+    async getResourceTrends() {
+        try {
+            const trends = ResourceMonitor.getAllTrends('system', 'day');
+            return { ok: true, trends };
+        }
+        catch (error) {
+            Logger.error('Failed to get resource trends', error);
+            return {
+                ok: false,
+                error: error instanceof Error ? error.message : 'Unknown error',
+                trends: null,
+            };
+        }
+    },
+});
+export function createSnapshotBuilder() {
+    return async () => {
+        const [systemSummaryResult, resourceCurrentResult] = await Promise.allSettled([
+            TelemetryAPI.getSystemSummary(),
+            TelemetryAPI.getResourceCurrent(),
+        ]);
+        if (systemSummaryResult.status === 'rejected') {
+            Logger.error('Telemetry dashboard summary failed', systemSummaryResult.reason);
+        }
+        if (resourceCurrentResult.status === 'rejected') {
+            Logger.error('Telemetry resource summary failed', resourceCurrentResult.reason);
+        }
+        const systemSummary = systemSummaryResult.status === 'fulfilled' ? systemSummaryResult.value : { ok: false };
+        const resourceCurrent = resourceCurrentResult.status === 'fulfilled'
+            ? resourceCurrentResult.value
+            : { ok: false };
+        return {
+            ok: systemSummary.ok ?? false,
+            summary: isOkWithSummary(systemSummary) ? systemSummary.summary : {},
+            resources: isOkWithUsage(resourceCurrent) ? resourceCurrent.usage : null,
+            cost: null,
+        };
+    };
+}

package/packages/workers/src/telemetry/api/TelemetryMonitoringService.d.ts

@@ -0,0 +1,18 @@
+import type { IResponse } from '../../../../../src/index.js';
+import type { createSnapshotBuilder, TelemetrySettings } from './TelemetryAPI';
+export type TelemetrySnapshotData = {
+    type: string;
+    ts: string;
+    ok: boolean;
+    summary: unknown;
+    resources: unknown;
+    cost: unknown;
+};
+export declare const TelemetryMonitoringService: Readonly<{
+    subscribe(callback: (data: TelemetrySnapshotData) => void): void;
+    unsubscribe(callback: (data: TelemetrySnapshotData) => void): void;
+    startMonitoring(settings: TelemetrySettings, buildSnapshot: ReturnType<typeof createSnapshotBuilder>): void;
+    stopMonitoring(): void;
+}>;
+export declare const teleStream: (res: IResponse, settings: TelemetrySettings, buildSnapshot: ReturnType<typeof createSnapshotBuilder>) => Promise<void>;
+//# sourceMappingURL=TelemetryMonitoringService.d.ts.map

package/packages/workers/src/telemetry/api/TelemetryMonitoringService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryMonitoringService.d.ts","sourceRoot":"","sources":["../../../../../../packages/workers/src/telemetry/api/TelemetryMonitoringService.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEhD,OAAO,KAAK,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAE/E,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAkFF,eAAO,MAAM,0BAA0B;wBACjB,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAAG,IAAI;0BAQ1C,CAAC,IAAI,EAAE,qBAAqB,KAAK,IAAI,GAAG,IAAI;8BAWtD,iBAAiB,iBACZ,UAAU,CAAC,OAAO,qBAAqB,CAAC,GACtD,IAAI;sBAOW,IAAI;EAOtB,CAAC;AAEH,eAAO,MAAM,UAAU,GACrB,KAAK,SAAS,EACd,UAAU,iBAAiB,EAC3B,eAAe,UAAU,CAAC,OAAO,qBAAqB,CAAC,KACtD,OAAO,CAAC,IAAI,CA8Cd,CAAC"}