agl 1.0.17 → 21.0.2

package/dist_ts/classes.resourcecoordinator.js

@@ -0,0 +1,294 @@
+import { controllerRuntimeIdKey, } from '../dist_ts_interfaces/index.js';
+import {} from './interfaces.flexipc.js';
+export class ControllerResourceUnavailableError extends Error {
+    code = 'resource_unavailable';
+    constructor(messageArg) {
+        super(messageArg);
+        this.name = 'ControllerResourceUnavailableError';
+    }
+}
+export class ControllerProjectHasResourcesError extends Error {
+    resourceIds;
+    code = 'project_has_resources';
+    constructor(resourceIds) {
+        super('Retire every project resource before removing the project.');
+        this.resourceIds = resourceIds;
+        this.name = 'ControllerProjectHasResourcesError';
+    }
+}
+const sessionIdsEqual = (leftArg, rightArg) => leftArg === null
+    ? rightArg === null
+    : rightArg !== null && controllerRuntimeIdKey(leftArg) === controllerRuntimeIdKey(rightArg);
+export class ControllerResourceCoordinator {
+    options;
+    projectStates = new Map();
+    deletingSessions = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    async listResources(projectIdArg) {
+        const resources = await this.options.store.listResources(projectIdArg);
+        return resources.map((resource) => this.toPublicResource(resource));
+    }
+    async requireResourceKind(projectIdArg, resourceIdArg, kindArg) {
+        return this.runProjectMutation(projectIdArg, async () => {
+            const resource = (await this.options.store.listResources(projectIdArg))
+                .find((entry) => entry.id === resourceIdArg);
+            if (!resource)
+                return false;
+            if (resource.kind !== kindArg) {
+                throw new ControllerResourceUnavailableError(`The requested ${kindArg} resource is unavailable.`);
+            }
+            return true;
+        });
+    }
+    async createResource(inputArg, signalArg) {
+        return this.runProjectMutation(inputArg.projectId, async () => {
+            const resource = await this.options.store.createResource(inputArg);
+            await this.hostFor(resource).startResource(resource, signalArg);
+            const current = (await this.options.store.listResources(inputArg.projectId))
+                .find((entry) => entry.id === resource.id) ?? resource;
+            return this.toPublicResource(current);
+        });
+    }
+    async renameResource(projectIdArg, resourceIdArg, titleArg) {
+        return this.runProjectMutation(projectIdArg, async () => {
+            const resource = await this.options.store.renameResource(projectIdArg, resourceIdArg, titleArg);
+            await this.hostFor(resource).renameResource?.(resource);
+            return this.toPublicResource(resource);
+        });
+    }
+    async changeAttachment(inputArg) {
+        return this.runProjectMutation(inputArg.projectId, async () => {
+            if (inputArg.sessionId
+                && this.deletingSessions.has(this.sessionKey(inputArg.projectId, inputArg.sessionId))) {
+                throw new ControllerResourceUnavailableError('The target session is being deleted.');
+            }
+            const pending = await this.options.store.beginResourceAttachmentTransition(inputArg.projectId, inputArg.resourceId, inputArg.sessionId, inputArg.expectedAttachmentRevision);
+            return this.toPublicResource(await this.reconcilePendingAttachment(pending, inputArg.signal));
+        });
+    }
+    async retireResource(projectIdArg, resourceIdArg, signalArg) {
+        await this.runProjectMutation(projectIdArg, async () => {
+            const retiring = await this.options.store.beginResourceRetirement(projectIdArg, resourceIdArg);
+            if (retiring.lifecycle === 'retired')
+                return;
+            await this.hostFor(retiring).retireResource(retiring, signalArg);
+            await this.options.store.completeResourceRetirement(projectIdArg, resourceIdArg);
+        });
+    }
+    async startResource(projectIdArg, resourceIdArg, signalArg) {
+        return this.runProjectMutation(projectIdArg, async () => {
+            const resource = (await this.options.store.listResources(projectIdArg))
+                .find((entry) => entry.id === resourceIdArg);
+            if (!resource || resource.lifecycle !== 'active' || resource.pendingAttachment) {
+                throw new ControllerResourceUnavailableError('The resource cannot be started now.');
+            }
+            await this.hostFor(resource).startResource(resource, signalArg);
+            const current = (await this.options.store.listResources(projectIdArg))
+                .find((entry) => entry.id === resourceIdArg) ?? resource;
+            return this.toPublicResource(current);
+        });
+    }
+    async stopResource(projectIdArg, resourceIdArg, signalArg) {
+        return this.runProjectMutation(projectIdArg, async () => {
+            const resource = (await this.options.store.listResources(projectIdArg))
+                .find((entry) => entry.id === resourceIdArg);
+            if (!resource || resource.lifecycle !== 'active') {
+                throw new ControllerResourceUnavailableError('The resource cannot be stopped now.');
+            }
+            await this.hostFor(resource).stopResource(resource, signalArg);
+            const current = (await this.options.store.listResources(projectIdArg))
+                .find((entry) => entry.id === resourceIdArg) ?? resource;
+            return this.toPublicResource(current);
+        });
+    }
+    async recover(signalArg) {
+        for (const resource of await this.options.store.listRecoverableResources()) {
+            signalArg.throwIfAborted();
+            await this.runProjectMutation(resource.projectId, async () => {
+                if (resource.lifecycle === 'retiring') {
+                    await this.hostFor(resource).retireResource(resource, signalArg);
+                    await this.options.store.completeResourceRetirement(resource.projectId, resource.id);
+                    return;
+                }
+                if (resource.pendingAttachment) {
+                    await this.reconcilePendingAttachment(resource, signalArg);
+                    return;
+                }
+                await this.hostFor(resource).reconcileAttachment(resource, signalArg);
+            });
+        }
+    }
+    async withSessionDeletion(projectIdArg, sessionIdArg, signalArg, deleteArg) {
+        const sessionKey = this.sessionKey(projectIdArg, sessionIdArg);
+        if (this.deletingSessions.has(sessionKey)) {
+            throw new ControllerResourceUnavailableError('The session is already being deleted.');
+        }
+        this.deletingSessions.add(sessionKey);
+        try {
+            await this.runProjectMutation(projectIdArg, async () => {
+                const resources = await this.options.store.listResources(projectIdArg);
+                for (let resource of resources) {
+                    if (resource.pendingAttachment) {
+                        resource = await this.reconcilePendingAttachment(resource, signalArg);
+                    }
+                    if (!sessionIdsEqual(resource.sessionId, sessionIdArg))
+                        continue;
+                    const pending = await this.options.store.beginResourceAttachmentTransition(projectIdArg, resource.id, null, resource.attachmentRevision);
+                    await this.reconcilePendingAttachment(pending, signalArg);
+                }
+            });
+            return await deleteArg();
+        }
+        finally {
+            this.deletingSessions.delete(sessionKey);
+        }
+    }
+    async withProjectRemovalGuard(projectIdArg, removeArg) {
+        const state = this.projectState(projectIdArg);
+        if (!state.admissionOpen || state.removed) {
+            throw new ControllerResourceUnavailableError('The project is not accepting resource operations.');
+        }
+        state.admissionOpen = false;
+        await state.tail;
+        const resources = await this.options.store.listResources(projectIdArg);
+        if (resources.length > 0) {
+            state.admissionOpen = true;
+            throw new ControllerProjectHasResourcesError(resources.map((resource) => resource.id));
+        }
+        try {
+            const result = await removeArg();
+            state.removed = true;
+            this.projectStates.delete(projectIdArg);
+            return result;
+        }
+        catch (errorArg) {
+            state.admissionOpen = true;
+            throw errorArg;
+        }
+    }
+    async resolveFlexBrowserResources(projectIdArg, sessionIdArg) {
+        return this.runProjectMutation(projectIdArg, async () => ((await this.options.store.listResources(projectIdArg))
+            .filter((resource) => (resource.kind === 'browser'
+            && resource.lifecycle === 'active'
+            && resource.pendingAttachment === undefined
+            && resource.sessionId?.harnessId === 'flex'
+            && resource.sessionId.nativeId === sessionIdArg))
+            .sort((left, right) => left.id.localeCompare(right.id))
+            .map((resource) => ({
+            resourceId: resource.id,
+            attachmentRevision: resource.attachmentRevision,
+        }))));
+    }
+    async requireFlexBrowserResource(inputArg) {
+        return this.runProjectMutation(inputArg.projectId, async () => {
+            const resource = (await this.options.store.listResources(inputArg.projectId))
+                .find((entry) => entry.id === inputArg.resourceId);
+            if (!resource
+                || resource.kind !== 'browser'
+                || resource.lifecycle !== 'active'
+                || resource.pendingAttachment !== undefined
+                || resource.attachmentRevision !== inputArg.attachmentRevision
+                || resource.sessionId?.harnessId !== 'flex'
+                || resource.sessionId.nativeId !== inputArg.sessionId)
+                throw new ControllerResourceUnavailableError('The browser attachment is no longer current.');
+            return resource;
+        });
+    }
+    async reconcilePendingAttachment(resourceArg, signalArg) {
+        const pending = resourceArg.pendingAttachment;
+        if (!pending)
+            return resourceArg;
+        const target = {
+            ...resourceArg,
+            attachmentRevision: pending.attachmentRevision,
+            sessionId: pending.sessionId === null ? null : { ...pending.sessionId },
+        };
+        delete target.pendingAttachment;
+        await this.hostFor(resourceArg).reconcileAttachment(target, signalArg);
+        return this.options.store.commitResourceAttachmentTransition(resourceArg.projectId, resourceArg.id, pending.operationId);
+    }
+    toPublicResource(resourceArg) {
+        const attachment = {
+            authorityId: resourceArg.attachmentAuthorityId,
+            revision: resourceArg.attachmentRevision,
+            sessionId: resourceArg.sessionId === null ? null : { ...resourceArg.sessionId },
+        };
+        const agentAvailability = resourceArg.pendingAttachment
+            ? 'transitioning'
+            : resourceArg.sessionId === null
+                ? 'detached'
+                : resourceArg.kind === 'browser'
+                    ? resourceArg.sessionId?.harnessId === 'flex'
+                        && this.options.browserHost.isAvailable()
+                        && this.options.isFlexHarnessAvailable()
+                        ? 'available'
+                        : 'dependencyUnavailable'
+                    : 'available';
+        const base = {
+            id: resourceArg.id,
+            projectId: resourceArg.projectId,
+            kind: resourceArg.kind,
+            title: resourceArg.title,
+            lifecycle: resourceArg.lifecycle,
+            attachment,
+            agentAvailability,
+            createdAt: resourceArg.createdAt.getTime(),
+            updatedAt: resourceArg.updatedAt.getTime(),
+        };
+        if (resourceArg.kind === 'browser') {
+            return {
+                ...base,
+                kind: 'browser',
+                browserRuntimeState: this.options.browserHost.isAvailable() ? 'available' : 'unavailable',
+            };
+        }
+        const terminal = resourceArg.terminal;
+        return {
+            ...base,
+            kind: 'terminal',
+            command: terminal.command,
+            cwd: terminal.cwd,
+            processState: this.options.terminalHost.isRunning(resourceArg) ? 'running' : 'stopped',
+            ...(terminal.stoppedAt === undefined ? {} : { stoppedAt: terminal.stoppedAt.getTime() }),
+            ...(terminal.lastExitCode === undefined ? {} : { lastExitCode: terminal.lastExitCode }),
+        };
+    }
+    hostFor(resourceArg) {
+        return resourceArg.kind === 'terminal' ? this.options.terminalHost : this.options.browserHost;
+    }
+    projectState(projectIdArg) {
+        let state = this.projectStates.get(projectIdArg);
+        if (!state) {
+            state = { tail: Promise.resolve(), admissionOpen: true, removed: false };
+            this.projectStates.set(projectIdArg, state);
+        }
+        return state;
+    }
+    runProjectMutation(projectIdArg, operationArg) {
+        const state = this.projectState(projectIdArg);
+        if (!state.admissionOpen || state.removed) {
+            return Promise.reject(new ControllerResourceUnavailableError('The project is not accepting resource operations.'));
+        }
+        const operation = state.tail.then(async () => {
+            if (!state.admissionOpen || state.removed) {
+                throw new ControllerResourceUnavailableError('The project stopped accepting resource operations.');
+            }
+            return operationArg();
+        });
+        const tail = operation.then(() => undefined, () => undefined);
+        state.tail = tail;
+        void tail.finally(() => {
+            if (state.admissionOpen
+                && !state.removed
+                && state.tail === tail)
+                this.projectStates.delete(projectIdArg);
+        });
+        return operation;
+    }
+    sessionKey(projectIdArg, sessionIdArg) {
+        return `${projectIdArg}:${controllerRuntimeIdKey(sessionIdArg)}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.resourcecoordinator.js","sourceRoot":"","sources":["../../ts/classes.resourcecoordinator.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.sessionintelligencereader.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from './plugins.js';
+import type { IOpenCodeConnectionConfig } from './interfaces.opencode.js';
+export declare class SessionIntelligenceReader {
+    private readonly config;
+    private readonly registry;
+    private connectionId?;
+    constructor(config: IOpenCodeConnectionConfig);
+    init(signalArg?: AbortSignal): Promise<void>;
+    listChats(limitArg: number): Promise<plugins.crossharness.IChatSummary[]>;
+    readChat(chatIdArg: string, limitArg: number, maxCharsArg: number): Promise<plugins.crossharness.IChatTranscript>;
+    close(): Promise<void>;
+    private connection;
+}

package/dist_ts/classes.sessionintelligencereader.js

@@ -0,0 +1,40 @@
+import * as plugins from './plugins.js';
+export class SessionIntelligenceReader {
+    config;
+    registry;
+    connectionId;
+    constructor(config) {
+        this.config = config;
+        this.registry = new plugins.crossharness.ConnectionRegistry({
+            allowedServerUrls: [config.baseUrl],
+            maxConnections: 1,
+            openCodeCredentials: {
+                serverUrl: config.baseUrl,
+                username: config.username,
+                password: config.password,
+            },
+        });
+    }
+    async init(signalArg) {
+        if (this.connectionId)
+            throw new Error('The Session Intelligence reader is already initialized.');
+        const connection = await this.registry.connect('opencode', this.config.baseUrl, this.config.directory, signalArg);
+        this.connectionId = connection.connectionId;
+    }
+    listChats(limitArg) {
+        return this.connection().listChats(limitArg);
+    }
+    readChat(chatIdArg, limitArg, maxCharsArg) {
+        return this.connection().readChat(chatIdArg, limitArg, maxCharsArg);
+    }
+    async close() {
+        await this.registry.closeAll();
+        this.connectionId = undefined;
+    }
+    connection() {
+        if (!this.connectionId)
+            throw new Error('The Session Intelligence reader is not initialized.');
+        return this.registry.get(this.connectionId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zZXNzaW9uaW50ZWxsaWdlbmNlcmVhZGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY2xhc3Nlcy5zZXNzaW9uaW50ZWxsaWdlbmNlcmVhZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBR3hDLE1BQU0sT0FBTyx5QkFBeUI7SUFJUDtJQUhaLFFBQVEsQ0FBMEM7SUFDM0QsWUFBWSxDQUFVO0lBRTlCLFlBQTZCLE1BQWlDO1FBQWpDLFdBQU0sR0FBTixNQUFNLENBQTJCO1FBQzVELElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxPQUFPLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDO1lBQzFELGlCQUFpQixFQUFFLENBQUMsTUFBTSxDQUFDLE9BQU8sQ0FBQztZQUNuQyxjQUFjLEVBQUUsQ0FBQztZQUNqQixtQkFBbUIsRUFBRTtnQkFDbkIsU0FBUyxFQUFFLE1BQU0sQ0FBQyxPQUFPO2dCQUN6QixRQUFRLEVBQUUsTUFBTSxDQUFDLFFBQVE7Z0JBQ3pCLFFBQVEsRUFBRSxNQUFNLENBQUMsUUFBUTthQUMxQjtTQUNGLENBQUMsQ0FBQztJQUNMLENBQUM7SUFFTSxLQUFLLENBQUMsSUFBSSxDQUFDLFNBQXVCO1FBQ3ZDLElBQUksSUFBSSxDQUFDLFlBQVk7WUFBRSxNQUFNLElBQUksS0FBSyxDQUFDLHlEQUF5RCxDQUFDLENBQUM7UUFDbEcsTUFBTSxVQUFVLEdBQUcsTUFBTSxJQUFJLENBQUMsUUFBUSxDQUFDLE9BQU8sQ0FDNUMsVUFBVSxFQUNWLElBQUksQ0FBQyxNQUFNLENBQUMsT0FBTyxFQUNuQixJQUFJLENBQUMsTUFBTSxDQUFDLFNBQVMsRUFDckIsU0FBUyxDQUNWLENBQUM7UUFDRixJQUFJLENBQUMsWUFBWSxHQUFHLFVBQVUsQ0FBQyxZQUFZLENBQUM7SUFDOUMsQ0FBQztJQUVNLFNBQVMsQ0FBQyxRQUFnQjtRQUMvQixPQUFPLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxTQUFTLENBQUMsUUFBUSxDQUFDLENBQUM7SUFDL0MsQ0FBQztJQUVNLFFBQVEsQ0FDYixTQUFpQixFQUNqQixRQUFnQixFQUNoQixXQUFtQjtRQUVuQixPQUFPLElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQyxRQUFRLENBQUMsU0FBUyxFQUFFLFFBQVEsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUN0RSxDQUFDO0lBRU0sS0FBSyxDQUFDLEtBQUs7UUFDaEIsTUFBTSxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQy9CLElBQUksQ0FBQyxZQUFZLEdBQUcsU0FBUyxDQUFDO0lBQ2hDLENBQUM7SUFFTyxVQUFVO1FBQ2hCLElBQUksQ0FBQyxJQUFJLENBQUMsWUFBWTtZQUFFLE1BQU0sSUFBSSxLQUFLLENBQUMscURBQXFELENBQUMsQ0FBQztRQUMvRixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM5QyxDQUFDO0NBQ0YifQ==

package/dist_ts/classes.systemmetricssampler.d.ts

@@ -0,0 +1,53 @@
+import type { IControllerSystemMetrics } from '../dist_ts_interfaces/index.js';
+interface ISystemMetricsSource {
+    currentLoad: () => Promise<{
+        currentLoad: number;
+    }>;
+    mem: () => Promise<{
+        active: number;
+        total: number;
+    }>;
+    networkInterfaces: () => Promise<Array<{
+        iface: string;
+        virtual: boolean;
+    }>>;
+    networkStats: (interfaces: string) => Promise<Array<{
+        rx_sec: number;
+        tx_sec: number;
+    }>>;
+}
+interface IRawSystemMetrics {
+    cpuUsagePercent?: unknown;
+    memoryUsedBytes?: unknown;
+    memoryTotalBytes?: unknown;
+    networkStats?: Array<{
+        rx_sec?: unknown;
+        tx_sec?: unknown;
+    }>;
+}
+interface ISystemMetricsSamplerOptions {
+    source?: ISystemMetricsSource;
+    now?: () => number;
+    sampleTimeoutMs?: number;
+}
+export declare const normalizeSystemMetrics: (sampledAtArg: number, rawArg: IRawSystemMetrics) => IControllerSystemMetrics;
+export declare class SystemMetricsSampler {
+    private readonly source;
+    private readonly now;
+    private readonly sampleTimeoutMs;
+    private cachedSample;
+    private inFlightSample;
+    private inFlightCpuRead;
+    private inFlightMemoryRead;
+    private inFlightNetworkRead;
+    constructor(optionsArg?: ISystemMetricsSamplerOptions);
+    sample(): Promise<IControllerSystemMetrics>;
+    private readFreshSample;
+    private readSourceMetrics;
+    private readCpu;
+    private readMemory;
+    private readNetwork;
+    private withTimeout;
+    private readNetworkStats;
+}
+export {};

package/dist_ts/classes.systemmetricssampler.js

@@ -0,0 +1,168 @@
+import * as plugins from './plugins.js';
+const cacheTtlMs = 1_000;
+const defaultSampleTimeoutMs = 2_000;
+const asNonNegativeNumber = (valueArg) => (typeof valueArg === 'number' && Number.isFinite(valueArg) && valueArg >= 0
+    ? valueArg
+    : null);
+const asPercentage = (valueArg) => {
+    const value = asNonNegativeNumber(valueArg);
+    return value !== null && value <= 100 ? value : null;
+};
+const aggregateNetworkRate = (statsArg, keyArg) => {
+    if (!statsArg || statsArg.length === 0)
+        return null;
+    let total = 0;
+    for (const stats of statsArg) {
+        const value = asNonNegativeNumber(stats[keyArg]);
+        if (value === null)
+            return null;
+        total += value;
+    }
+    return Number.isFinite(total) ? total : null;
+};
+export const normalizeSystemMetrics = (sampledAtArg, rawArg) => {
+    const memoryTotalBytes = asNonNegativeNumber(rawArg.memoryTotalBytes);
+    const memoryUsedCandidate = asNonNegativeNumber(rawArg.memoryUsedBytes);
+    const memoryUsedBytes = (memoryUsedCandidate !== null
+        && memoryTotalBytes !== null
+        && memoryTotalBytes > 0
+        && memoryUsedCandidate <= memoryTotalBytes) ? memoryUsedCandidate : null;
+    return {
+        sampledAt: sampledAtArg,
+        cpuUsagePercent: asPercentage(rawArg.cpuUsagePercent),
+        memoryUsedBytes,
+        memoryTotalBytes: memoryTotalBytes !== null && memoryTotalBytes > 0
+            ? memoryTotalBytes
+            : null,
+        networkReceiveBytesPerSecond: aggregateNetworkRate(rawArg.networkStats, 'rx_sec'),
+        networkTransmitBytesPerSecond: aggregateNetworkRate(rawArg.networkStats, 'tx_sec'),
+    };
+};
+export class SystemMetricsSampler {
+    source;
+    now;
+    sampleTimeoutMs;
+    cachedSample;
+    inFlightSample;
+    inFlightCpuRead;
+    inFlightMemoryRead;
+    inFlightNetworkRead;
+    constructor(optionsArg = {}) {
+        this.source = optionsArg.source ?? plugins.systeminformation;
+        this.now = optionsArg.now ?? Date.now;
+        this.sampleTimeoutMs = optionsArg.sampleTimeoutMs ?? defaultSampleTimeoutMs;
+    }
+    async sample() {
+        const now = this.now();
+        if (this.cachedSample && now - this.cachedSample.sampledAt < cacheTtlMs) {
+            return this.cachedSample;
+        }
+        if (this.inFlightSample)
+            return this.inFlightSample;
+        const samplePromise = this.readFreshSample();
+        this.inFlightSample = samplePromise;
+        try {
+            const sample = await samplePromise;
+            this.cachedSample = sample;
+            return sample;
+        }
+        finally {
+            if (this.inFlightSample === samplePromise) {
+                this.inFlightSample = undefined;
+            }
+        }
+    }
+    async readFreshSample() {
+        return normalizeSystemMetrics(this.now(), await this.readSourceMetrics());
+    }
+    async readSourceMetrics() {
+        const [cpuResult, memoryResult, networkResult] = await Promise.all([
+            this.readCpu(),
+            this.readMemory(),
+            this.readNetwork(),
+        ]);
+        return {
+            ...(cpuResult
+                ? { cpuUsagePercent: cpuResult.currentLoad }
+                : {}),
+            ...(memoryResult
+                ? {
+                    memoryUsedBytes: memoryResult.active,
+                    memoryTotalBytes: memoryResult.total,
+                }
+                : {}),
+            ...(networkResult
+                ? { networkStats: networkResult }
+                : {}),
+        };
+    }
+    async readCpu() {
+        let sourceRead = this.inFlightCpuRead;
+        if (!sourceRead) {
+            sourceRead = Promise.resolve().then(() => this.source.currentLoad());
+            this.inFlightCpuRead = sourceRead;
+            const clear = () => {
+                if (this.inFlightCpuRead === sourceRead)
+                    this.inFlightCpuRead = undefined;
+            };
+            void sourceRead.then(clear, clear);
+        }
+        return this.withTimeout(sourceRead);
+    }
+    async readMemory() {
+        let sourceRead = this.inFlightMemoryRead;
+        if (!sourceRead) {
+            sourceRead = Promise.resolve().then(() => this.source.mem());
+            this.inFlightMemoryRead = sourceRead;
+            const clear = () => {
+                if (this.inFlightMemoryRead === sourceRead)
+                    this.inFlightMemoryRead = undefined;
+            };
+            void sourceRead.then(clear, clear);
+        }
+        return this.withTimeout(sourceRead);
+    }
+    async readNetwork() {
+        let sourceRead = this.inFlightNetworkRead;
+        if (!sourceRead) {
+            sourceRead = Promise.resolve().then(() => this.readNetworkStats());
+            this.inFlightNetworkRead = sourceRead;
+            const clear = () => {
+                if (this.inFlightNetworkRead === sourceRead)
+                    this.inFlightNetworkRead = undefined;
+            };
+            void sourceRead.then(clear, clear);
+        }
+        return this.withTimeout(sourceRead);
+    }
+    async withTimeout(sourceReadArg) {
+        let timeout;
+        const timedOut = Symbol('systemMetricsTimeout');
+        try {
+            const result = await Promise.race([
+                sourceReadArg,
+                new Promise((resolve) => {
+                    timeout = setTimeout(() => resolve(timedOut), this.sampleTimeoutMs);
+                }),
+            ]);
+            return result === timedOut ? undefined : result;
+        }
+        catch {
+            return undefined;
+        }
+        finally {
+            if (timeout)
+                clearTimeout(timeout);
+        }
+    }
+    async readNetworkStats() {
+        const interfaces = await this.source.networkInterfaces();
+        const interfaceNames = [...new Set(interfaces
+                .filter((networkInterface) => !networkInterface.virtual && networkInterface.iface.length > 0)
+                .map((networkInterface) => networkInterface.iface))].slice(0, 128);
+        if (interfaceNames.length === 0)
+            return [];
+        return this.source.networkStats(interfaceNames.join(','));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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