@nordbyte/nordrelay 0.5.2 → 0.7.0

package/dist/discord-channel-runtime.js

@@ -0,0 +1,133 @@
+import { ActionRowBuilder, AttachmentBuilder, ButtonBuilder, ButtonStyle, Client, } from "discord.js";
+import { DiscordChannelAdapter, } from "./channel-adapter.js";
+import { discordRateLimiter } from "./discord-rate-limit.js";
+import { redactText } from "./redaction.js";
+const DISCORD_MESSAGE_LIMIT = 2000;
+const DISCORD_SAFE_MESSAGE_LIMIT = 1900;
+export const DISCORD_ACTION_PREFIX = "nr:";
+export class DiscordBotChannelRuntime {
+    client;
+    id = "discord";
+    label = "Discord";
+    capabilities = new DiscordChannelAdapter().capabilities;
+    constructor(client) {
+        this.client = client;
+    }
+    describe() {
+        return new DiscordChannelAdapter().describe();
+    }
+    async sendMessage(context, message) {
+        const channel = await this.resolveChannel(context, message.threadId);
+        const content = discordMessageText(message);
+        const chunks = splitDiscordMessage(content);
+        let first = null;
+        for (const [index, chunk] of chunks.entries()) {
+            const sent = await discordRateLimiter.run(discordBucket(context), "sendMessage", () => channel.send({
+                content: chunk,
+                components: index === chunks.length - 1 ? discordActionRows(message.buttons) : [],
+                allowedMentions: { parse: [] },
+            }));
+            first ??= sent;
+        }
+        return { messageId: first?.id ?? "" };
+    }
+    async editMessage(context, messageId, message) {
+        const channel = await this.resolveChannel(context, message.threadId);
+        const existing = await channel.messages.fetch(messageId).catch(() => null);
+        if (!existing) {
+            await this.sendMessage(context, message);
+            return;
+        }
+        await discordRateLimiter.run(discordBucket(context), "editMessage", () => existing.edit({
+            content: trimDiscordMessage(discordMessageText(message)),
+            components: discordActionRows(message.buttons),
+            allowedMentions: { parse: [] },
+        }));
+    }
+    async sendTyping(context) {
+        const channel = await this.resolveChannel(context);
+        await discordRateLimiter.run(discordBucket(context), "typing", () => channel.sendTyping());
+    }
+    async sendFile(context, file) {
+        const channel = await this.resolveChannel(context, file.threadId);
+        const sent = await discordRateLimiter.run(discordBucket(context), "sendFile", () => channel.send({
+            content: file.caption ? trimDiscordMessage(redactText(file.caption)) : undefined,
+            files: [new AttachmentBuilder(file.localPath, { name: file.name })],
+            allowedMentions: { parse: [] },
+        }));
+        return { messageId: sent.id };
+    }
+    async resolveChannel(context, overrideThreadId) {
+        const id = overrideThreadId ?? context.topicId ?? context.chatId;
+        const channel = await this.client.channels.fetch(id);
+        if (!channel?.isTextBased() || !("send" in channel) || !("messages" in channel)) {
+            throw new Error(`Discord channel is not text-capable: ${id}`);
+        }
+        return channel;
+    }
+}
+function discordBucket(context) {
+    return context.topicId ?? context.chatId;
+}
+export function discordMessageText(message) {
+    return message.fallbackText?.trim() || stripTelegramHtml(message.text).trim() || ".";
+}
+export function discordActionRows(rows) {
+    if (!rows?.length) {
+        return [];
+    }
+    return rows.slice(0, 5).map((row) => new ActionRowBuilder()
+        .addComponents(row.slice(0, 5).map((button) => new ButtonBuilder()
+        .setCustomId(discordActionId(button.action))
+        .setLabel(trimButtonLabel(button.label))
+        .setStyle(ButtonStyle.Secondary)))
+        .toJSON());
+}
+export function discordActionId(action) {
+    const raw = `${DISCORD_ACTION_PREFIX}${action}`;
+    return raw.length <= 100 ? raw : `${DISCORD_ACTION_PREFIX}${action.slice(0, 97 - DISCORD_ACTION_PREFIX.length)}`;
+}
+export function actionFromDiscordCustomId(customId) {
+    return customId.startsWith(DISCORD_ACTION_PREFIX) ? customId.slice(DISCORD_ACTION_PREFIX.length) : null;
+}
+export function splitDiscordMessage(text) {
+    const normalized = text || ".";
+    if (normalized.length <= DISCORD_SAFE_MESSAGE_LIMIT) {
+        return [normalized];
+    }
+    const chunks = [];
+    let remaining = normalized;
+    while (remaining.length > 0) {
+        const slice = remaining.slice(0, DISCORD_SAFE_MESSAGE_LIMIT);
+        const breakAt = Math.max(slice.lastIndexOf("\n"), slice.lastIndexOf(" "));
+        const length = breakAt > 400 ? breakAt : DISCORD_SAFE_MESSAGE_LIMIT;
+        chunks.push(remaining.slice(0, length).trimEnd() || ".");
+        remaining = remaining.slice(length).trimStart();
+    }
+    return chunks;
+}
+export function trimDiscordMessage(text) {
+    return text.length <= DISCORD_MESSAGE_LIMIT ? text : `${text.slice(0, DISCORD_MESSAGE_LIMIT - 1)}…`;
+}
+export function discordMessageOptions(message) {
+    return {
+        content: trimDiscordMessage(discordMessageText(message)),
+        components: discordActionRows(message.buttons),
+        allowedMentions: { parse: [] },
+    };
+}
+function stripTelegramHtml(text) {
+    return text
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|pre)>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&amp;/g, "&")
+        .replace(/&quot;/g, "\"")
+        .replace(/&#39;/g, "'");
+}
+function trimButtonLabel(label) {
+    const trimmed = label.trim() || "Action";
+    return trimmed.length <= 80 ? trimmed : trimmed.slice(0, 80);
+}

package/dist/discord-command-surface.js

@@ -0,0 +1,57 @@
+import { permissionForCommand } from "./access-control.js";
+import { discordCommandCatalog } from "./channel-command-catalog.js";
+import { normalizeChannelCommandName, parseChannelCommand } from "./channel-runtime.js";
+export function parseDiscordMessageCommand(text) {
+    return parseChannelCommand(text, { allowBotMention: false });
+}
+export function argumentFromDiscordInteraction(interaction) {
+    if (interaction.commandName === "prompt") {
+        return interaction.options.getString("text") ?? "";
+    }
+    if (interaction.commandName === "queue") {
+        return [interaction.options.getString("action"), interaction.options.getString("id")].filter(Boolean).join(" ");
+    }
+    if (interaction.commandName === "update") {
+        return [interaction.options.getString("target"), interaction.options.getString("agent"), interaction.options.getString("input")].filter(Boolean).join(" ");
+    }
+    return interaction.options.getString("value") ?? interaction.options.getString("query") ?? interaction.options.getString("thread_id") ?? "";
+}
+export function requiredPermissionForDiscordCommand(command, argument) {
+    const normalized = normalizeChannelCommandName(command);
+    if (normalized === "prompt")
+        return "prompt.send";
+    if (normalized === "queue")
+        return argument.trim() ? "queue.write" : "queue.read";
+    return permissionForCommand(normalized);
+}
+export function isUnauthenticatedDiscordCommandAllowed(command) {
+    return normalizeChannelCommandName(command) === "link";
+}
+export function permissionForDiscordAction(action) {
+    if (action.startsWith("discord_queue_") || action.startsWith("discord_peer_queue_"))
+        return "queue.write";
+    if (action.startsWith("discord_abort:"))
+        return "prompt.abort";
+    if (action.startsWith("discord_pick:"))
+        return "sessions.write";
+    if (action.startsWith("discord_artifact_delete:"))
+        return "files.write";
+    if (action.startsWith("discord_artifact_"))
+        return "files.read";
+    if (action.startsWith("agent-update:"))
+        return "updates.run";
+    return null;
+}
+export function discordCommands() {
+    return discordCommandCatalog()
+        .map((entry) => command(entry.name, entry.description, entry.options));
+}
+function command(name, description, options = []) {
+    return {
+        name,
+        description,
+        type: 1,
+        dm_permission: true,
+        options,
+    };
+}

package/dist/discord-rate-limit.js

@@ -0,0 +1,141 @@
+const DEFAULT_OPTIONS = {
+    minIntervalMs: 250,
+    editMinIntervalMs: 1_500,
+    typingMinIntervalMs: 4_500,
+    maxRetries: 5,
+};
+export class DiscordRateLimiter {
+    options;
+    buckets = new Map();
+    queued = 0;
+    running = 0;
+    completed = 0;
+    failed = 0;
+    retries = 0;
+    rateLimitHits = 0;
+    lastRateLimitAt;
+    lastRetryAfterSeconds;
+    constructor(options = DEFAULT_OPTIONS) {
+        this.options = options;
+    }
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+    async run(bucket, method, operation) {
+        const normalizedBucket = `${method}:${bucket}`;
+        const state = this.getBucket(normalizedBucket);
+        this.queued += 1;
+        let releasePrevious;
+        const previous = state.chain;
+        state.chain = new Promise((resolve) => {
+            releasePrevious = resolve;
+        });
+        await previous.catch(() => { });
+        this.queued = Math.max(0, this.queued - 1);
+        this.running += 1;
+        try {
+            await this.waitForBucket(state, method);
+            const result = await this.runWithRetries(operation);
+            this.completed += 1;
+            state.lastRunAtMs = Date.now();
+            state.queuedUntilMs = Math.max(state.queuedUntilMs, state.lastRunAtMs + this.intervalForMethod(method));
+            return result;
+        }
+        catch (error) {
+            this.failed += 1;
+            throw error;
+        }
+        finally {
+            this.running = Math.max(0, this.running - 1);
+            releasePrevious();
+        }
+    }
+    getMetrics() {
+        return {
+            queued: this.queued,
+            running: this.running,
+            completed: this.completed,
+            failed: this.failed,
+            retries: this.retries,
+            rateLimitHits: this.rateLimitHits,
+            lastRateLimitAt: this.lastRateLimitAt,
+            lastRetryAfterSeconds: this.lastRetryAfterSeconds,
+            buckets: [...this.buckets.entries()]
+                .filter(([, state]) => state.queuedUntilMs > Date.now() || state.lastRunAtMs > 0)
+                .slice(0, 12)
+                .map(([bucket, state]) => ({
+                bucket,
+                queuedUntilMs: state.queuedUntilMs,
+                lastRunAtMs: state.lastRunAtMs,
+            })),
+        };
+    }
+    getBucket(bucket) {
+        let state = this.buckets.get(bucket);
+        if (!state) {
+            state = {
+                chain: Promise.resolve(),
+                queuedUntilMs: 0,
+                lastRunAtMs: 0,
+            };
+            this.buckets.set(bucket, state);
+        }
+        return state;
+    }
+    async waitForBucket(state, method) {
+        const interval = this.intervalForMethod(method);
+        const now = Date.now();
+        const earliest = Math.max(state.queuedUntilMs, state.lastRunAtMs + interval);
+        if (earliest > now) {
+            await delay(earliest - now);
+        }
+    }
+    async runWithRetries(operation) {
+        let attempt = 0;
+        while (true) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                const retryAfterSeconds = getRetryAfterSeconds(error);
+                if (retryAfterSeconds === undefined || attempt >= this.options.maxRetries) {
+                    throw error;
+                }
+                attempt += 1;
+                this.retries += 1;
+                this.rateLimitHits += 1;
+                this.lastRateLimitAt = new Date().toISOString();
+                this.lastRetryAfterSeconds = retryAfterSeconds;
+                await delay((retryAfterSeconds * 1000) + 250);
+            }
+        }
+    }
+    intervalForMethod(method) {
+        if (method.startsWith("edit"))
+            return this.options.editMinIntervalMs;
+        if (method.startsWith("typing"))
+            return this.options.typingMinIntervalMs;
+        return this.options.minIntervalMs;
+    }
+}
+export const discordRateLimiter = new DiscordRateLimiter();
+export function getDiscordRateLimitMetrics() {
+    return discordRateLimiter.getMetrics();
+}
+function getRetryAfterSeconds(error) {
+    const candidate = error;
+    const direct = candidate.retryAfter ?? candidate.rawError?.retry_after ?? candidate.data?.retry_after;
+    if (typeof direct === "number" && Number.isFinite(direct)) {
+        return Math.max(1, direct > 100 ? direct / 1000 : direct);
+    }
+    const text = typeof candidate.message === "string" ? candidate.message : "";
+    const match = text.match(/retry[_ -]?after["':\s]+(\d+(?:\.\d+)?)/i);
+    if (!match) {
+        return undefined;
+    }
+    const parsed = Number(match[1]);
+    return Number.isFinite(parsed) ? Math.max(1, parsed) : undefined;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+}

package/dist/index.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { webhookCallback } from "grammy";
 import { agentLabel } from "./agent.js";
 import { createBot, registerCommands } from "./bot.js";
+import { createDiscordBridge } from "./discord-bot.js";
 import { checkAuthStatus } from "./codex-auth.js";
 import { describeCodexCli, resolveCodexCli } from "./codex-cli.js";
 import { checkClaudeCodeAuthStatus } from "./claude-code-auth.js";
@@ -18,12 +19,17 @@ import { describeOpenClawCli, resolveOpenClawCli } from "./openclaw-cli.js";
 import { installConsoleLogger } from "./logger.js";
 import { checkPiAuthStatus } from "./pi-auth.js";
 import { describePiCli, resolvePiCli } from "./pi-cli.js";
+import { startPeerServer } from "./peer-server.js";
+import { RelayRuntime } from "./relay-runtime.js";
 import { configureRedaction } from "./redaction.js";
 import { SessionRegistry } from "./session-registry.js";
 import { UserStore } from "./user-management.js";
 let registry;
 let bot;
+let discordBridge;
 let webhookServer;
+let peerServer;
+let peerRuntime;
 let runtimeConfig;
 try {
     const config = loadConfig();
@@ -31,8 +37,16 @@ try {
     configureRedaction(config.telegramRedactPatterns);
     installConsoleLogger(config.logFormat);
     registry = new SessionRegistry(config);
-    bot = createBot(config, registry);
-    await registerCommands(bot);
+    if (config.telegramEnabled) {
+        bot = createBot(config, registry);
+        await registerCommands(bot);
+    }
+    discordBridge = createDiscordBridge(config, registry);
+    await discordBridge?.start();
+    if (config.peerEnabled) {
+        peerRuntime = new RelayRuntime(config);
+        peerServer = await startPeerServer({ config, runtime: peerRuntime });
+    }
     console.log("NordRelay running");
     const userStore = new UserStore();
     if (userStore.hasAdminUser()) {
@@ -46,6 +60,9 @@ try {
     if (!authStatus.authenticated) {
         console.warn(`Warning: ${agentLabel(config.defaultAgent)} is not authenticated. ${authStatus.detail}`);
     }
+    for (const warning of config.adapterWarnings ?? []) {
+        console.warn(`Warning: ${warning}`);
+    }
     console.log(`Workspace: ${config.workspace}`);
     console.log(`Enabled agents: ${enabledAgents(config).join(", ")} (default: ${config.defaultAgent})`);
     if (config.codexModel) {
@@ -74,14 +91,16 @@ try {
             console.warn("Warning: Default launch profile uses danger-full-access.");
         }
     }
-    console.log("Session mode: per Telegram context");
-    console.log(`Telegram transport: ${config.telegramTransport}`);
+    console.log("Session mode: per chat context");
+    console.log(`Telegram: ${config.telegramEnabled ? config.telegramTransport : "disabled"}`);
+    console.log(`Discord: ${config.discordEnabled ? "enabled" : "disabled"}`);
+    console.log(`Peers: ${peerServer ? peerServer.url : "disabled"}`);
     await writeConnectorState({
         status: "ready",
         pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,
         appPid: process.pid,
         workspace: config.workspace,
-        sessionMode: "per Telegram context",
+        sessionMode: "per chat context",
         authenticated: authStatus.authenticated,
         authMethod: authStatus.method,
         codexCli: describeCodexCli(codexCli),
@@ -91,6 +110,11 @@ try {
         claudeCodeCli: describeClaudeCodeCli(claudeCodeCli),
         openClawGateway: config.openClawGatewayUrl,
         telegramTransport: config.telegramTransport,
+        discordEnabled: config.discordEnabled,
+        peerEnabled: config.peerEnabled,
+        peerUrl: peerServer?.url,
+        peerTlsFingerprint: peerServer?.tlsFingerprint,
+        adapterWarnings: config.adapterWarnings ?? [],
     });
 }
 catch (error) {
@@ -137,9 +161,16 @@ const shutdown = (signal) => {
     console.log(`Received ${signal}, shutting down NordRelay...`);
     if (bot && runtimeConfig?.telegramTransport !== "webhook")
         bot.stop();
+    void discordBridge?.stop().catch((error) => {
+        console.warn("Failed to stop Discord bridge:", error instanceof Error ? error.message : String(error));
+    });
     webhookServer?.close();
+    void peerServer?.close().catch((error) => {
+        console.warn("Failed to stop peer server:", error instanceof Error ? error.message : String(error));
+    });
     setTimeout(() => {
         registry?.disposeAll();
+        peerRuntime?.dispose();
         void writeConnectorState({
             status: "stopped",
             pid: Number(process.env.NORDRELAY_WRAPPER_PID) || process.pid,

package/dist/job-store.js

@@ -0,0 +1,127 @@
+import { createDocumentStore } from "./state-backend.js";
+const DEFAULT_MAX_JOBS = 1000;
+export class UnifiedJobStore {
+    maxJobs;
+    store;
+    constructor(workspace, backend = "json", maxJobs = DEFAULT_MAX_JOBS) {
+        this.maxJobs = maxJobs;
+        this.store = createDocumentStore({
+            workspace,
+            backend,
+            fileName: "unified-jobs.json",
+            sqliteKey: "unified-jobs",
+        });
+    }
+    list(limit = 200) {
+        return this.readPayload().jobs
+            .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
+            .slice(0, Math.max(1, Math.min(this.maxJobs, limit)));
+    }
+    get(id) {
+        return this.readPayload().jobs.find((job) => job.id === id) ?? null;
+    }
+    upsert(job) {
+        const payload = this.readPayload();
+        const normalized = normalizeJob(job);
+        const index = payload.jobs.findIndex((candidate) => candidate.id === normalized.id);
+        if (index >= 0) {
+            payload.jobs[index] = {
+                ...payload.jobs[index],
+                ...normalized,
+            };
+        }
+        else {
+            payload.jobs.push(normalized);
+        }
+        payload.jobs = trimJobs(payload.jobs, this.maxJobs);
+        this.store.write(payload);
+        return normalized;
+    }
+    upsertMany(jobs) {
+        if (jobs.length === 0) {
+            return this.list();
+        }
+        const payload = this.readPayload();
+        const byId = new Map(payload.jobs.map((job) => [job.id, job]));
+        for (const job of jobs) {
+            const normalized = normalizeJob(job);
+            byId.set(normalized.id, {
+                ...byId.get(normalized.id),
+                ...normalized,
+            });
+        }
+        payload.jobs = trimJobs([...byId.values()], this.maxJobs);
+        this.store.write(payload);
+        return payload.jobs;
+    }
+    patch(id, patch) {
+        const payload = this.readPayload();
+        const index = payload.jobs.findIndex((job) => job.id === id);
+        if (index < 0) {
+            return null;
+        }
+        payload.jobs[index] = normalizeJob({
+            ...payload.jobs[index],
+            ...patch,
+            id,
+            updatedAt: patch.updatedAt ?? new Date().toISOString(),
+        });
+        this.store.write(payload);
+        return payload.jobs[index];
+    }
+    remove(id) {
+        const payload = this.readPayload();
+        const next = payload.jobs.filter((job) => job.id !== id);
+        if (next.length === payload.jobs.length) {
+            return false;
+        }
+        payload.jobs = next;
+        this.store.write(payload);
+        return true;
+    }
+    readPayload() {
+        const payload = this.store.read();
+        if (!payload || payload.version !== 1 || !Array.isArray(payload.jobs)) {
+            return { version: 1, jobs: [] };
+        }
+        return {
+            version: 1,
+            jobs: trimJobs(payload.jobs.filter(isUnifiedJobDto).map(normalizeJob), this.maxJobs),
+        };
+    }
+}
+function trimJobs(jobs, maxJobs) {
+    return jobs
+        .sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt))
+        .slice(0, maxJobs);
+}
+function normalizeJob(job) {
+    return {
+        ...job,
+        startedAt: validDateString(job.startedAt) ?? new Date().toISOString(),
+        updatedAt: validDateString(job.updatedAt) ?? new Date().toISOString(),
+        finishedAt: validDateString(job.finishedAt),
+        canCancel: Boolean(job.canCancel),
+        canRetry: Boolean(job.canRetry),
+        canReadLog: Boolean(job.canReadLog),
+    };
+}
+function validDateString(value) {
+    if (!value) {
+        return undefined;
+    }
+    return Number.isFinite(Date.parse(value)) ? value : undefined;
+}
+function isUnifiedJobDto(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const candidate = value;
+    return typeof candidate.id === "string" &&
+        typeof candidate.kind === "string" &&
+        typeof candidate.title === "string" &&
+        typeof candidate.status === "string" &&
+        typeof candidate.source === "string" &&
+        typeof candidate.startedAt === "string" &&
+        typeof candidate.updatedAt === "string";
+}

package/dist/metrics.js

@@ -0,0 +1,87 @@
+import { monitorEventLoopDelay } from "node:perf_hooks";
+import { getDiscordRateLimitMetrics } from "./discord-rate-limit.js";
+import { getTelegramRateLimitMetrics } from "./telegram-rate-limit.js";
+const startedAt = Date.now();
+const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
+eventLoopDelay.enable();
+export function buildRuntimeMetrics(input) {
+    const completedPromptDurations = input.activity
+        .filter((event) => event.category === "prompt" && event.status === "completed" && typeof event.durationMs === "number")
+        .map((event) => event.durationMs);
+    return {
+        generatedAt: new Date().toISOString(),
+        queue: {
+            length: input.queueLength,
+            paused: input.queuePaused,
+        },
+        turns: {
+            active: input.activeTurnCount,
+            completed: countActivity(input.activity, "completed"),
+            failed: countActivity(input.activity, "failed"),
+            aborted: countActivity(input.activity, "aborted"),
+            averageDurationMs: completedPromptDurations.length
+                ? Math.round(completedPromptDurations.reduce((sum, value) => sum + value, 0) / completedPromptDurations.length)
+                : null,
+        },
+        jobs: {
+            total: input.jobs.length,
+            queued: countJobs(input.jobs, "queued"),
+            running: countJobs(input.jobs, "running"),
+            completed: countJobs(input.jobs, "completed"),
+            failed: countJobs(input.jobs, "failed"),
+            aborted: countJobs(input.jobs, "aborted"),
+        },
+        process: processMetrics(),
+        adapters: {
+            telegram: getTelegramRateLimitMetrics(),
+            discord: getDiscordRateLimitMetrics(),
+        },
+    };
+}
+function processMetrics() {
+    const memory = process.memoryUsage();
+    const cpu = process.cpuUsage();
+    const uptimeMs = Math.max(0, Math.round(process.uptime() * 1000));
+    const totalMs = Math.round((cpu.user + cpu.system) / 1000);
+    return {
+        pid: process.pid,
+        nodeVersion: process.version,
+        platform: process.platform,
+        arch: process.arch,
+        uptimeMs,
+        startedAt: new Date(startedAt).toISOString(),
+        memory: {
+            rssBytes: memory.rss,
+            heapTotalBytes: memory.heapTotal,
+            heapUsedBytes: memory.heapUsed,
+            externalBytes: memory.external,
+            arrayBuffersBytes: memory.arrayBuffers,
+        },
+        cpu: {
+            userMs: Math.round(cpu.user / 1000),
+            systemMs: Math.round(cpu.system / 1000),
+            totalMs,
+            percentSinceStart: uptimeMs > 0 ? roundMetric((totalMs / uptimeMs) * 100) : null,
+        },
+        eventLoop: {
+            delayMeanMs: nanosecondsToMilliseconds(eventLoopDelay.mean),
+            delayMaxMs: nanosecondsToMilliseconds(eventLoopDelay.max),
+            delayP95Ms: nanosecondsToMilliseconds(eventLoopDelay.percentile(95)),
+        },
+    };
+}
+function nanosecondsToMilliseconds(value) {
+    if (!Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    return roundMetric(value / 1_000_000);
+}
+function roundMetric(value) {
+    return Math.round(value * 100) / 100;
+}
+function countJobs(jobs, status) {
+    return jobs.filter((job) => job.status === status).length;
+}
+function countActivity(events, status) {
+    return events.filter((event) => event.category === "prompt" && event.status === status).length;
+}