@nordbyte/nordrelay 0.8.1 → 0.8.3

package/dist/web/web-performance.js

@@ -0,0 +1,62 @@
+const recent = [];
+const routeMetrics = new Map();
+const MAX_RECENT = 200;
+export function recordWebApiMetric(sample) {
+    const next = {
+        ...sample,
+        durationMs: Math.max(0, Math.round(sample.durationMs)),
+        at: sample.at ?? new Date().toISOString(),
+    };
+    recent.push(next);
+    if (recent.length > MAX_RECENT) {
+        recent.splice(0, recent.length - MAX_RECENT);
+    }
+    const key = `${next.method} ${routeKey(next.path)}`;
+    const existing = routeMetrics.get(key);
+    if (!existing) {
+        routeMetrics.set(key, {
+            method: next.method,
+            path: routeKey(next.path),
+            count: 1,
+            averageMs: next.durationMs,
+            maxMs: next.durationMs,
+            lastMs: next.durationMs,
+            lastStatusCode: next.statusCode,
+            lastAt: next.at,
+            totalMs: next.durationMs,
+        });
+        return;
+    }
+    existing.count += 1;
+    existing.totalMs += next.durationMs;
+    existing.averageMs = Math.round(existing.totalMs / existing.count);
+    existing.maxMs = Math.max(existing.maxMs, next.durationMs);
+    existing.lastMs = next.durationMs;
+    existing.lastStatusCode = next.statusCode;
+    existing.lastAt = next.at;
+}
+export function getWebApiPerformanceMetrics() {
+    return {
+        recent: [...recent].reverse().slice(0, 25),
+        slowest: [...recent].sort((left, right) => right.durationMs - left.durationMs).slice(0, 10),
+        routes: [...routeMetrics.values()]
+            .map(({ totalMs: _totalMs, ...metric }) => ({ ...metric }))
+            .sort((left, right) => right.averageMs - left.averageMs)
+            .slice(0, 25),
+    };
+}
+function routeKey(path) {
+    return path
+        .replace(/\/api\/peers\/[^/]+\/proxy$/, "/api/peers/:id/proxy")
+        .replace(/\/api\/peers\/[^/]+\/events$/, "/api/peers/:id/events")
+        .replace(/\/api\/peers\/[^/]+\/health$/, "/api/peers/:id/health")
+        .replace(/\/api\/peers\/[^/]+\/repin$/, "/api/peers/:id/repin")
+        .replace(/\/api\/peers\/[^/]+\/rotate$/, "/api/peers/:id/rotate")
+        .replace(/\/api\/agent-update\/[^/]+\/(log|input|cancel)$/, "/api/agent-update/:id/$1")
+        .replace(/\/api\/jobs\/[^/]+\/(log|action)$/, "/api/jobs/:id/$1")
+        .replace(/\/api\/trace$/, "/api/trace")
+        .replace(/\/api\/users\/[^/]+\/sessions\/[^/]+$/, "/api/users/:id/sessions/:sessionId")
+        .replace(/\/api\/users\/[^/]+\/(password|telegram|discord|slack|sessions)$/, "/api/users/:id/$1")
+        .replace(/\/api\/peers\/discovery-jobs\/[^/]+\/(cancel|log)$/, "/api/peers/discovery-jobs/:id/$1")
+        .replace(/\/api\/peers\/discovery-jobs\/[^/]+$/, "/api/peers/discovery-jobs/:id");
+}

package/dist/web/web-rate-limit.js

@@ -0,0 +1,19 @@
+export function consumeRateLimit(buckets, key, maxAttempts, windowMs, blockMs, now = Date.now()) {
+    const existing = buckets.get(key);
+    if (existing?.blockedUntil && existing.blockedUntil > now) {
+        return { limited: true, retryAfterMs: existing.blockedUntil - now };
+    }
+    if (!existing || existing.resetAt <= now) {
+        buckets.set(key, { count: 1, resetAt: now + windowMs });
+        return { limited: false };
+    }
+    existing.count += 1;
+    if (existing.count > maxAttempts) {
+        existing.blockedUntil = now + blockMs;
+        return { limited: true, retryAfterMs: blockMs };
+    }
+    return { limited: false };
+}
+export function resetRateLimit(buckets, key) {
+    buckets.delete(key);
+}

package/dist/{web-state.js → web/web-state.js}

@@ -1,6 +1,7 @@
 import { randomUUID } from "node:crypto";
-import { activityActorLabel, activityCategoryForType, } from "./activity-events.js";
-import { createDocumentStore } from "./state-backend.js";
+import { activityActorLabel, activityCategoryForType, } from "../core/activity-events.js";
+import { cursorPage, normalizeCursorLimit } from "../core/pagination.js";
+import { createDocumentStore } from "../state/state-backend.js";
 const DEFAULT_CHAT_LIMIT = 300;
 const DEFAULT_ACTIVITY_LIMIT = 1000;
 export class WebChatStore {
@@ -16,9 +17,16 @@ export class WebChatStore {
         this.maxMessages = maxMessages;
     }
     append(input) {
+        return this.appendWithResult(input).message;
+    }
+    appendWithResult(input) {
         const payload = this.readPayload();
         const threadId = input.threadId || "pending";
         const messages = payload.messagesByThread[threadId] ?? [];
+        const duplicate = findDuplicateWebChatMessage(messages, { ...input, threadId });
+        if (duplicate) {
+            return { message: duplicate, inserted: false };
+        }
         const message = {
             id: randomId(),
             timestamp: input.timestamp ?? new Date().toISOString(),
@@ -31,12 +39,54 @@ export class WebChatStore {
         }
         payload.messagesByThread[threadId] = messages;
         this.store.write(payload);
-        return message;
+        return { message, inserted: true };
+    }
+    upsertByKey(input) {
+        const payload = this.readPayload();
+        const threadId = input.threadId || "pending";
+        const messages = payload.messagesByThread[threadId] ?? [];
+        const now = new Date().toISOString();
+        const existing = messages.find((message) => message.key === input.key);
+        if (existing) {
+            existing.role = input.role;
+            existing.text = input.text;
+            existing.source = input.source;
+            existing.correlationId = input.correlationId;
+            existing.turnId = input.turnId;
+            existing.timestamp = input.timestamp ?? now;
+            existing.key = input.key;
+            this.store.write(payload);
+            return { message: existing, inserted: false, updated: true };
+        }
+        const message = {
+            id: randomId(),
+            timestamp: input.timestamp ?? now,
+            ...input,
+            threadId,
+        };
+        messages.push(message);
+        if (messages.length > this.maxMessages) {
+            messages.splice(0, messages.length - this.maxMessages);
+        }
+        payload.messagesByThread[threadId] = messages;
+        this.store.write(payload);
+        return { message, inserted: true, updated: false };
     }
     list(threadId, limit = 200) {
         const messages = this.readPayload().messagesByThread[threadId || "pending"] ?? [];
         return messages.slice(-Math.max(1, Math.min(this.maxMessages, limit)));
     }
+    findByCorrelationId(correlationId, limit = 100) {
+        const needle = correlationId.trim();
+        if (!needle) {
+            return [];
+        }
+        return Object.values(this.readPayload().messagesByThread)
+            .flat()
+            .filter((message) => message.correlationId === needle)
+            .sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp))
+            .slice(-Math.max(1, Math.min(this.maxMessages, limit)));
+    }
     clear(threadId) {
         const payload = this.readPayload();
         const key = threadId || "pending";
@@ -53,7 +103,7 @@ export class WebChatStore {
         const messagesByThread = {};
         for (const [threadId, messages] of Object.entries(payload.messagesByThread)) {
             if (Array.isArray(messages)) {
-                messagesByThread[threadId] = messages.filter(isWebChatMessage).slice(-this.maxMessages);
+                messagesByThread[threadId] = dedupeWebChatMessages(messages.filter(isWebChatMessage)).slice(-this.maxMessages);
             }
         }
         return { version: 1, messagesByThread };
@@ -87,7 +137,25 @@ export class WebActivityStore {
         return event;
     }
     list(options = {}) {
-        const limit = Math.max(1, Math.min(500, options.limit ?? 100));
+        return this.listPage(options).items;
+    }
+    listPage(options = {}) {
+        const limit = normalizeCursorLimit(options.limit, 100, 500);
+        const events = this.filteredEvents(options)
+            .sort((left, right) => Date.parse(right.timestamp) - Date.parse(left.timestamp));
+        return cursorPage(events, options.cursor, limit, (event) => event.id);
+    }
+    findByCorrelationId(correlationId, limit = 100) {
+        const needle = correlationId.trim();
+        if (!needle) {
+            return [];
+        }
+        return this.readPayload().events
+            .filter((event) => event.correlationId === needle)
+            .sort((left, right) => Date.parse(left.timestamp) - Date.parse(right.timestamp))
+            .slice(-Math.max(1, Math.min(500, limit)));
+    }
+    filteredEvents(options) {
         const since = normalizeSince(options.since);
         return this.readPayload().events
             .filter((event) => !options.source || options.source === "all" || event.source === options.source)
@@ -98,9 +166,7 @@ export class WebActivityStore {
             .filter((event) => !options.workspace || event.workspace === options.workspace)
             .filter((event) => !options.type || event.type.toLowerCase().includes(options.type.toLowerCase()))
             .filter((event) => !options.actor || activityActorMatches(event.actor, options.actor))
-            .filter((event) => !since || Date.parse(event.timestamp) >= since)
-            .slice(-limit)
-            .reverse();
+            .filter((event) => !since || Date.parse(event.timestamp) >= since);
     }
     readPayload() {
         const payload = this.store.read();
@@ -122,6 +188,7 @@ function isWebChatMessage(value) {
         typeof candidate.threadId === "string" &&
         typeof candidate.text === "string" &&
         typeof candidate.timestamp === "string" &&
+        (candidate.key === undefined || typeof candidate.key === "string") &&
         ["user", "agent", "system", "tool"].includes(candidate.role) &&
         ["web", "telegram", "discord", "slack", "cli"].includes(candidate.source);
 }
@@ -159,4 +226,35 @@ function activityActorMatches(actor, query) {
 function randomId() {
     return randomUUID().replace(/-/g, "").slice(0, 12);
 }
-export { activityActorLabel, activityCategoryForType, auditCategoryForAction, } from "./activity-events.js";
+function dedupeWebChatMessages(messages) {
+    const seen = new Set();
+    return messages.filter((message) => {
+        const key = webChatDedupKey(message);
+        if (!key) {
+            return true;
+        }
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function findDuplicateWebChatMessage(messages, input) {
+    const key = webChatDedupKey(input);
+    return key ? messages.find((message) => webChatDedupKey(message) === key) : undefined;
+}
+function webChatDedupKey(message) {
+    const threadId = message.threadId || "pending";
+    if (message.key) {
+        return [threadId, message.key].join("\0");
+    }
+    if (message.turnId) {
+        return [threadId, message.role, message.source, message.turnId, message.text].join("\0");
+    }
+    if (message.timestamp) {
+        return [threadId, message.role, message.source, message.timestamp, message.text].join("\0");
+    }
+    return null;
+}
+export { activityActorLabel, activityCategoryForType, auditCategoryForAction, } from "../core/activity-events.js";