@promptbook/cli 0.113.0-1 → 0.113.0-11

package/apps/agents-server/src/utils/resolveInheritedAgentSource.ts

@@ -231,8 +231,42 @@ type ResolveInheritedAgentSourceOptions = ImportAgentOptions & {
      * Retry configuration used for federated imported-agent loading.
      */
     readonly federatedAgentImportConfiguration?: FederatedAgentImportConfiguration;
+    /**
+     * Optional same-instance source importer used before falling back to HTTP import.
+     */
+    readonly agentSourceImporter?: AgentSourceImporter;
 };
 
+/**
+ * Context passed to a custom agent source importer.
+ */
+export type AgentSourceImporterContext = {
+    /**
+     * Commitment that requested the imported source.
+     */
+    readonly commitmentType: 'FROM' | 'IMPORT';
+
+    /**
+     * Import options propagated from the current resolution pass.
+     */
+    readonly importAgentOptions: ImportAgentOptions;
+
+    /**
+     * Retry configuration used by the default HTTP importer.
+     */
+    readonly federatedAgentImportConfiguration: FederatedAgentImportConfiguration;
+};
+
+/**
+ * Imports one agent source before the resolver falls back to the default HTTP importer.
+ *
+ * Return `null` when the importer does not own the given URL.
+ */
+export type AgentSourceImporter = (
+    agentUrl: string_agent_url,
+    context: AgentSourceImporterContext,
+) => Promise<string_book | null>;
+
 /**
  * Parent inheritance state derived before rewriting the source body.
  */
@@ -277,6 +311,11 @@ type AgentImportContext = {
      */
     readonly importAgentOptions: ImportAgentOptions;
 
+    /**
+     * Optional importer for same-instance agent sources.
+     */
+    readonly agentSourceImporter?: AgentSourceImporter;
+
     /**
      * Original resolution options used for cycle detection.
      */
@@ -364,6 +403,7 @@ function createAgentImportContext(options?: ResolveInheritedAgentSourceOptions):
             recursionLevel: options?.recursionLevel || 0,
             inheritancePath: createResolutionLineage(options),
         },
+        agentSourceImporter: options?.agentSourceImporter,
         resolutionOptions: options,
     };
 }
@@ -427,11 +467,20 @@ async function importAgentCorpus(
 ): Promise<string> {
     assertNoResolutionCycle(agentUrl, commitmentType, context.resolutionOptions);
 
-    const importedAgentSource = await importAgentWithFallback(
-        agentUrl,
-        context.importAgentOptions,
-        context.federatedAgentImportConfiguration,
-    );
+    const locallyImportedAgentSource = context.agentSourceImporter
+        ? await context.agentSourceImporter(agentUrl, {
+              commitmentType,
+              importAgentOptions: context.importAgentOptions,
+              federatedAgentImportConfiguration: context.federatedAgentImportConfiguration,
+          })
+        : null;
+    const importedAgentSource =
+        locallyImportedAgentSource ??
+        (await importAgentWithFallback(
+            agentUrl,
+            context.importAgentOptions,
+            context.federatedAgentImportConfiguration,
+        ));
 
     return getAgentSourceCorpus(importedAgentSource as string_book);
 }

package/apps/agents-server/src/utils/resolveServerAgentContext.ts

@@ -1,6 +1,7 @@
 import type { AgentReferenceResolver } from '../../../../src/book-2.0/agent-source/AgentReferenceResolver';
 import type { AgentCollection } from '../../../../src/collection/agent-collection/AgentCollection';
 import { resolveBookScopedAgentContext, type ResolvedBookScopedAgentContext } from './agentReferenceResolver/bookScopedAgentReferences';
+import { createLocalAgentSourceImporter } from './createLocalAgentSourceImporter';
 import { loadFederatedAgentImportConfiguration } from './federatedAgentImportConfiguration';
 import { getWellKnownAgentUrl } from './getWellKnownAgentUrl';
 import { resolveAgentStateFromSource, type ResolvedAgentState } from './resolveAgentStateFromSource';
@@ -46,12 +47,22 @@ export async function resolveServerAgentContext(
 ): Promise<ResolvedServerAgentContext> {
     const bookScopedAgentContext = await resolveBookScopedAgentContext(options);
     const federatedAgentImportConfiguration = await loadFederatedAgentImportConfiguration();
+    const adamAgentUrl = await getWellKnownAgentUrl('ADAM');
+    const agentSourceImporter = createLocalAgentSourceImporter({
+        collection: options.collection,
+        localServerUrls: [options.localServerUrl],
+        localAgentUrls: [adamAgentUrl],
+        adamAgentUrl,
+        fallbackResolver: options.fallbackResolver,
+        federatedAgentImportConfiguration,
+    });
     const resolvedAgentState = await resolveAgentStateFromSource(bookScopedAgentContext.unresolvedAgentSource, {
-        adamAgentUrl: await getWellKnownAgentUrl('ADAM'),
+        adamAgentUrl,
         canonicalAgentUrl: bookScopedAgentContext.canonicalAgentUrl,
         currentAgentAliases: bookScopedAgentContext.currentAgentAliases,
         agentReferenceResolver: bookScopedAgentContext.scopedAgentReferenceResolver,
         federatedAgentImportConfiguration,
+        agentSourceImporter,
     });
 
     return {

package/apps/agents-server/src/utils/resolveStoredAgentState.ts

@@ -30,7 +30,7 @@ export type ResolvedStoredAgentState<TAgent extends StoredAgentSourceRecord> = T
  */
 export type ResolveStoredAgentStateOptions = Pick<
     ResolveAgentStateFromSourceOptions,
-    'adamAgentUrl' | 'agentReferenceResolver' | 'federatedAgentImportConfiguration'
+    'adamAgentUrl' | 'agentReferenceResolver' | 'federatedAgentImportConfiguration' | 'agentSourceImporter'
 > & {
     /**
      * Public/current server origin used to build canonical local agent URLs.
@@ -91,6 +91,7 @@ export async function resolveStoredAgentState<TAgent extends StoredAgentSourceRe
         currentAgentAliases: createCanonicalLocalAgentAliases(agent, options.localServerUrl),
         agentReferenceResolver: options.agentReferenceResolver,
         federatedAgentImportConfiguration,
+        agentSourceImporter: options.agentSourceImporter,
     });
 
     return {

package/apps/agents-server/src/utils/resourceMonitor/formatResourceMonitorValue.ts

@@ -0,0 +1,50 @@
+/**
+ * Byte units used for compact resource values.
+ */
+const BYTE_UNITS = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'] as const;
+
+/**
+ * Converts a nullable byte count into a compact display value.
+ *
+ * @param bytes - Byte count.
+ * @returns Human-readable byte value.
+ */
+export function formatResourceBytes(bytes: number | null | undefined): string {
+    if (bytes === null || bytes === undefined || !Number.isFinite(bytes) || bytes <= 0) {
+        return '0 B';
+    }
+
+    const exponent = Math.min(BYTE_UNITS.length - 1, Math.floor(Math.log(bytes) / Math.log(1024)));
+    const value = bytes / Math.pow(1024, exponent);
+    const precision = value >= 10 || exponent === 0 ? 0 : 1;
+
+    return `${value.toFixed(precision)} ${BYTE_UNITS[exponent]}`;
+}
+
+/**
+ * Converts a nullable ratio into a display percentage.
+ *
+ * @param ratio - Ratio from `0` to `1`.
+ * @returns Human-readable percentage or fallback.
+ */
+export function formatResourcePercentage(ratio: number | null | undefined): string {
+    if (ratio === null || ratio === undefined || !Number.isFinite(ratio)) {
+        return 'Not available';
+    }
+
+    return `${(ratio * 100).toFixed(0)}%`;
+}
+
+/**
+ * Converts a nullable byte-per-second count into a compact display value.
+ *
+ * @param bytesPerSecond - Byte count per second.
+ * @returns Human-readable rate or fallback.
+ */
+export function formatResourceRate(bytesPerSecond: number | null | undefined): string {
+    if (bytesPerSecond === null || bytesPerSecond === undefined || !Number.isFinite(bytesPerSecond)) {
+        return 'Not available';
+    }
+
+    return `${formatResourceBytes(bytesPerSecond)}/s`;
+}

package/apps/agents-server/src/utils/resourceMonitor/readCpuResourceUsage.ts

@@ -0,0 +1,75 @@
+import os from 'node:os';
+
+import { DEFAULT_PROCESS_CPU_SAMPLE_DURATION_MS } from './resourceMonitorConstants';
+import { waitForResourceMonitorSample } from './waitForResourceMonitorSample';
+import type { CpuResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Options for reading CPU usage.
+ */
+type ReadCpuResourceUsageOptions = {
+    /**
+     * Whether the current Node.js process CPU usage should be sampled.
+     */
+    readonly isProcessUsageSampled: boolean;
+
+    /**
+     * Optional process CPU sampling duration.
+     */
+    readonly sampleDurationMs?: number;
+};
+
+/**
+ * Reads platform load average and optionally samples current process CPU usage.
+ *
+ * @param options - CPU reader options.
+ * @returns CPU usage snapshot.
+ */
+export async function readCpuResourceUsage({
+    isProcessUsageSampled,
+    sampleDurationMs = DEFAULT_PROCESS_CPU_SAMPLE_DURATION_MS,
+}: ReadCpuResourceUsageOptions): Promise<CpuResourceUsage> {
+    const coreCount = Math.max(os.cpus().length, 1);
+    const isLoadAverageAvailable = process.platform !== 'win32';
+    const [averageLoadOneMinute, averageLoadFiveMinutes, averageLoadFifteenMinutes] = isLoadAverageAvailable
+        ? os.loadavg()
+        : [null, null, null];
+    const loadRatio = averageLoadOneMinute === null ? null : averageLoadOneMinute / coreCount;
+    const processUsageRatio = isProcessUsageSampled
+        ? await sampleProcessCpuUsageRatio(coreCount, sampleDurationMs)
+        : null;
+
+    return {
+        coreCount,
+        averageLoadOneMinute,
+        averageLoadFiveMinutes,
+        averageLoadFifteenMinutes,
+        loadRatio,
+        processUsageRatio,
+    };
+}
+
+/**
+ * Samples current Node.js process CPU usage over a short interval.
+ *
+ * @param coreCount - Logical CPU core count.
+ * @param sampleDurationMs - Sampling duration in milliseconds.
+ * @returns Process CPU ratio across all logical cores.
+ */
+async function sampleProcessCpuUsageRatio(coreCount: number, sampleDurationMs: number): Promise<number | null> {
+    const startedUsage = process.cpuUsage();
+    const startedAtNanoseconds = process.hrtime.bigint();
+
+    await waitForResourceMonitorSample(sampleDurationMs);
+
+    const elapsedMicroseconds = Number(process.hrtime.bigint() - startedAtNanoseconds) / 1000;
+    if (!Number.isFinite(elapsedMicroseconds) || elapsedMicroseconds <= 0) {
+        return null;
+    }
+
+    const usage = process.cpuUsage(startedUsage);
+    const usedMicroseconds = usage.user + usage.system;
+    const processUsageRatio = usedMicroseconds / elapsedMicroseconds / Math.max(coreCount, 1);
+
+    return Number.isFinite(processUsageRatio) ? Math.max(processUsageRatio, 0) : null;
+}

package/apps/agents-server/src/utils/resourceMonitor/readDiskResourceUsage.ts

@@ -0,0 +1,42 @@
+import { statfs } from 'node:fs/promises';
+
+import type { DiskResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Reads disk usage for the filesystem that hosts the server process.
+ *
+ * @param inspectedPath - Filesystem path to inspect.
+ * @returns Disk usage snapshot.
+ */
+export async function readDiskResourceUsage(inspectedPath: string = process.cwd()): Promise<DiskResourceUsage> {
+    try {
+        const fileSystemStats = await statfs(inspectedPath);
+        const blockSize = fileSystemStats.bsize;
+        const totalBytes = fileSystemStats.blocks * blockSize;
+        const freeBytes = fileSystemStats.bfree * blockSize;
+        const availableBytes = fileSystemStats.bavail * blockSize;
+        const usedBytes = Math.max(totalBytes - freeBytes, 0);
+
+        return {
+            inspectedPath,
+            totalBytes,
+            freeBytes,
+            availableBytes,
+            usedBytes,
+            usedRatio: totalBytes > 0 ? usedBytes / totalBytes : null,
+            availableRatio: totalBytes > 0 ? availableBytes / totalBytes : null,
+            errorMessage: null,
+        };
+    } catch (error) {
+        return {
+            inspectedPath,
+            totalBytes: null,
+            freeBytes: null,
+            availableBytes: null,
+            usedBytes: null,
+            usedRatio: null,
+            availableRatio: null,
+            errorMessage: error instanceof Error ? error.message : 'Disk usage is not available.',
+        };
+    }
+}

package/apps/agents-server/src/utils/resourceMonitor/readMemoryResourceUsage.ts

@@ -0,0 +1,28 @@
+import os from 'node:os';
+
+import type { MemoryResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Reads current host and process memory usage.
+ *
+ * @returns Memory usage snapshot.
+ */
+export function readMemoryResourceUsage(): MemoryResourceUsage {
+    const totalBytes = os.totalmem();
+    const freeBytes = os.freemem();
+    const usedBytes = Math.max(totalBytes - freeBytes, 0);
+    const memoryUsage = process.memoryUsage();
+
+    return {
+        totalBytes,
+        freeBytes,
+        usedBytes,
+        usedRatio: totalBytes > 0 ? usedBytes / totalBytes : 0,
+        availableRatio: totalBytes > 0 ? freeBytes / totalBytes : 0,
+        processRssBytes: memoryUsage.rss,
+        processHeapUsedBytes: memoryUsage.heapUsed,
+        processHeapTotalBytes: memoryUsage.heapTotal,
+        processExternalBytes: memoryUsage.external,
+        processArrayBuffersBytes: memoryUsage.arrayBuffers ?? 0,
+    };
+}

package/apps/agents-server/src/utils/resourceMonitor/readNetworkResourceUsage.ts

@@ -0,0 +1,271 @@
+import { readFile } from 'node:fs/promises';
+import os from 'node:os';
+
+import { DEFAULT_NETWORK_SAMPLE_DURATION_MS } from './resourceMonitorConstants';
+import { waitForResourceMonitorSample } from './waitForResourceMonitorSample';
+import type { NetworkInterfaceResourceUsage, NetworkResourceUsage } from './resourceMonitorTypes';
+
+/**
+ * Linux network counter source.
+ */
+const LINUX_NETWORK_COUNTERS_PATH = '/proc/net/dev';
+
+/**
+ * Loopback interface omitted from host traffic totals.
+ */
+const LOOPBACK_NETWORK_INTERFACE_NAME = 'lo';
+
+/**
+ * Field index containing transmitted bytes in `/proc/net/dev`.
+ */
+const TRANSMITTED_BYTES_FIELD_INDEX = 8;
+
+/**
+ * Raw traffic counters read from the operating system.
+ */
+type NetworkTrafficCounter = {
+    readonly name: string;
+    readonly receivedBytes: number;
+    readonly transmittedBytes: number;
+};
+
+/**
+ * Result of reading traffic counters from the host.
+ */
+type NetworkTrafficCounterReadResult = {
+    readonly counters: ReadonlyArray<NetworkTrafficCounter> | null;
+    readonly errorMessage: string | null;
+};
+
+/**
+ * Reads network usage with current traffic rates when host counters are available.
+ *
+ * @param sampleDurationMs - Sampling duration used for byte-per-second rates.
+ * @returns Network usage snapshot.
+ */
+export async function readNetworkResourceUsage(
+    sampleDurationMs: number = DEFAULT_NETWORK_SAMPLE_DURATION_MS,
+): Promise<NetworkResourceUsage> {
+    const interfaceSummary = readNetworkInterfaceSummary();
+    const firstRead = await readLinuxNetworkTrafficCounters();
+
+    if (!firstRead.counters) {
+        return createUnavailableNetworkResourceUsage(interfaceSummary, firstRead.errorMessage);
+    }
+
+    const isRateSampled = sampleDurationMs > 0;
+    if (!isRateSampled) {
+        return createAvailableNetworkResourceUsage({
+            interfaceSummary,
+            counters: firstRead.counters,
+            previousCounters: null,
+            elapsedSeconds: null,
+            errorMessage: null,
+        });
+    }
+
+    const startedAtNanoseconds = process.hrtime.bigint();
+    await waitForResourceMonitorSample(sampleDurationMs);
+    const secondRead = await readLinuxNetworkTrafficCounters();
+    const elapsedSeconds = Number(process.hrtime.bigint() - startedAtNanoseconds) / 1_000_000_000;
+
+    if (!secondRead.counters) {
+        return createAvailableNetworkResourceUsage({
+            interfaceSummary,
+            counters: firstRead.counters,
+            previousCounters: null,
+            elapsedSeconds: null,
+            errorMessage: secondRead.errorMessage,
+        });
+    }
+
+    return createAvailableNetworkResourceUsage({
+        interfaceSummary,
+        counters: secondRead.counters,
+        previousCounters: firstRead.counters,
+        elapsedSeconds: Number.isFinite(elapsedSeconds) && elapsedSeconds > 0 ? elapsedSeconds : null,
+        errorMessage: null,
+    });
+}
+
+/**
+ * Reads interface and address counts from Node.js network metadata.
+ *
+ * @returns Network interface summary.
+ */
+function readNetworkInterfaceSummary(): Pick<NetworkResourceUsage, 'networkInterfaceCount' | 'networkAddressCount'> {
+    const networkInterfaces = os.networkInterfaces();
+    const interfaceNames = Object.keys(networkInterfaces);
+    const networkAddressCount = Object.values(networkInterfaces).reduce(
+        (count, addresses) => count + (addresses?.length ?? 0),
+        0,
+    );
+
+    return {
+        networkInterfaceCount: interfaceNames.length,
+        networkAddressCount,
+    };
+}
+
+/**
+ * Reads Linux traffic counters.
+ *
+ * @returns Traffic counters or an unavailable result.
+ */
+async function readLinuxNetworkTrafficCounters(): Promise<NetworkTrafficCounterReadResult> {
+    if (process.platform !== 'linux') {
+        return {
+            counters: null,
+            errorMessage: 'Traffic counters are available only on Linux hosts.',
+        };
+    }
+
+    try {
+        const content = await readFile(LINUX_NETWORK_COUNTERS_PATH, 'utf8');
+        return {
+            counters: parseLinuxNetworkTrafficCounters(content),
+            errorMessage: null,
+        };
+    } catch (error) {
+        return {
+            counters: null,
+            errorMessage: error instanceof Error ? error.message : 'Traffic counters are not available.',
+        };
+    }
+}
+
+/**
+ * Parses `/proc/net/dev` content into traffic counters.
+ *
+ * @param content - Raw `/proc/net/dev` file content.
+ * @returns Parsed non-loopback traffic counters.
+ */
+function parseLinuxNetworkTrafficCounters(content: string): ReadonlyArray<NetworkTrafficCounter> {
+    return content
+        .split('\n')
+        .slice(2)
+        .map(parseLinuxNetworkTrafficCounterLine)
+        .filter((counter): counter is NetworkTrafficCounter => counter !== null);
+}
+
+/**
+ * Parses one `/proc/net/dev` interface line.
+ *
+ * @param line - Raw interface line.
+ * @returns Traffic counter or `null` for unsupported lines.
+ */
+function parseLinuxNetworkTrafficCounterLine(line: string): NetworkTrafficCounter | null {
+    const separatorIndex = line.indexOf(':');
+    if (separatorIndex === -1) {
+        return null;
+    }
+
+    const name = line.slice(0, separatorIndex).trim();
+    if (!name || name === LOOPBACK_NETWORK_INTERFACE_NAME) {
+        return null;
+    }
+
+    const fields = line
+        .slice(separatorIndex + 1)
+        .trim()
+        .split(/\s+/);
+    const receivedBytes = Number(fields[0]);
+    const transmittedBytes = Number(fields[TRANSMITTED_BYTES_FIELD_INDEX]);
+    const isCounterValid = Number.isFinite(receivedBytes) && Number.isFinite(transmittedBytes);
+
+    if (!isCounterValid) {
+        return null;
+    }
+
+    return {
+        name,
+        receivedBytes,
+        transmittedBytes,
+    };
+}
+
+/**
+ * Creates an unavailable network usage snapshot.
+ *
+ * @param interfaceSummary - Interface/address counts.
+ * @param errorMessage - Reason traffic counters are unavailable.
+ * @returns Network usage snapshot.
+ */
+function createUnavailableNetworkResourceUsage(
+    interfaceSummary: Pick<NetworkResourceUsage, 'networkInterfaceCount' | 'networkAddressCount'>,
+    errorMessage: string | null,
+): NetworkResourceUsage {
+    return {
+        isTrafficAvailable: false,
+        interfaces: [],
+        totalReceivedBytes: null,
+        totalTransmittedBytes: null,
+        totalReceivedBytesPerSecond: null,
+        totalTransmittedBytesPerSecond: null,
+        networkInterfaceCount: interfaceSummary.networkInterfaceCount,
+        networkAddressCount: interfaceSummary.networkAddressCount,
+        errorMessage,
+    };
+}
+
+/**
+ * Creates an available network usage snapshot.
+ *
+ * @param options - Counter and sampling options.
+ * @returns Network usage snapshot.
+ */
+function createAvailableNetworkResourceUsage(options: {
+    readonly interfaceSummary: Pick<NetworkResourceUsage, 'networkInterfaceCount' | 'networkAddressCount'>;
+    readonly counters: ReadonlyArray<NetworkTrafficCounter>;
+    readonly previousCounters: ReadonlyArray<NetworkTrafficCounter> | null;
+    readonly elapsedSeconds: number | null;
+    readonly errorMessage: string | null;
+}): NetworkResourceUsage {
+    const previousCounterByName = new Map(options.previousCounters?.map((counter) => [counter.name, counter]) ?? []);
+    const interfaces = options.counters.map((counter): NetworkInterfaceResourceUsage => {
+        const previousCounter = previousCounterByName.get(counter.name);
+        const receivedBytesPerSecond =
+            previousCounter && options.elapsedSeconds
+                ? Math.max(counter.receivedBytes - previousCounter.receivedBytes, 0) / options.elapsedSeconds
+                : null;
+        const transmittedBytesPerSecond =
+            previousCounter && options.elapsedSeconds
+                ? Math.max(counter.transmittedBytes - previousCounter.transmittedBytes, 0) / options.elapsedSeconds
+                : null;
+
+        return {
+            name: counter.name,
+            receivedBytes: counter.receivedBytes,
+            transmittedBytes: counter.transmittedBytes,
+            receivedBytesPerSecond,
+            transmittedBytesPerSecond,
+        };
+    });
+
+    return {
+        isTrafficAvailable: true,
+        interfaces,
+        totalReceivedBytes: interfaces.reduce((sum, item) => sum + item.receivedBytes, 0),
+        totalTransmittedBytes: interfaces.reduce((sum, item) => sum + item.transmittedBytes, 0),
+        totalReceivedBytesPerSecond: sumNullableRates(interfaces.map((item) => item.receivedBytesPerSecond)),
+        totalTransmittedBytesPerSecond: sumNullableRates(interfaces.map((item) => item.transmittedBytesPerSecond)),
+        networkInterfaceCount: options.interfaceSummary.networkInterfaceCount,
+        networkAddressCount: options.interfaceSummary.networkAddressCount,
+        errorMessage: options.errorMessage,
+    };
+}
+
+/**
+ * Sums rates while preserving `null` when no rate was available.
+ *
+ * @param rates - Nullable rates.
+ * @returns Sum or `null`.
+ */
+function sumNullableRates(rates: ReadonlyArray<number | null>): number | null {
+    const availableRates = rates.filter((rate): rate is number => rate !== null);
+    if (availableRates.length === 0) {
+        return null;
+    }
+
+    return availableRates.reduce((sum, rate) => sum + rate, 0);
+}

package/apps/agents-server/src/utils/resourceMonitor/readServerResourceMonitorSnapshot.ts

@@ -0,0 +1,47 @@
+import { cache } from 'react';
+
+import { readCpuResourceUsage } from './readCpuResourceUsage';
+import { readDiskResourceUsage } from './readDiskResourceUsage';
+import { readMemoryResourceUsage } from './readMemoryResourceUsage';
+import { readNetworkResourceUsage } from './readNetworkResourceUsage';
+import { resolveServerResourceWarningStatus } from './resolveServerResourceWarningStatus';
+import type { ServerResourceMonitorSnapshot, ServerResourceWarningStatus } from './resourceMonitorTypes';
+
+/**
+ * Reads a full resource monitor snapshot for the admin page.
+ *
+ * @returns Full resource monitor snapshot.
+ */
+export const readServerResourceMonitorSnapshot = cache(async (): Promise<ServerResourceMonitorSnapshot> => {
+    const [cpu, disk, network] = await Promise.all([
+        readCpuResourceUsage({ isProcessUsageSampled: true }),
+        readDiskResourceUsage(),
+        readNetworkResourceUsage(),
+    ]);
+    const memory = readMemoryResourceUsage();
+    const warningStatus = resolveServerResourceWarningStatus({ cpu, memory, disk });
+
+    return {
+        measuredAt: new Date().toISOString(),
+        cpu,
+        memory,
+        disk,
+        network,
+        warningStatus,
+    };
+});
+
+/**
+ * Reads the lightweight warning status used by the header menu.
+ *
+ * @returns Current resource warning status.
+ */
+export const readServerResourceWarningStatus = cache(async (): Promise<ServerResourceWarningStatus> => {
+    const [cpu, disk] = await Promise.all([
+        readCpuResourceUsage({ isProcessUsageSampled: false }),
+        readDiskResourceUsage(),
+    ]);
+    const memory = readMemoryResourceUsage();
+
+    return resolveServerResourceWarningStatus({ cpu, memory, disk });
+});