@openclaw/nostr 2026.2.2 → 2026.2.9

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 2026.2.6-3
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.6-2
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.6
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
+## 2026.2.4
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.2.2
 
 ### Changes

package/package.json

@@ -1,11 +1,10 @@
 {
   "name": "@openclaw/nostr",
-  "version": "2026.2.2",
+  "version": "2026.2.9",
   "description": "OpenClaw Nostr channel plugin for NIP-04 encrypted DMs",
   "type": "module",
   "dependencies": {
     "nostr-tools": "^2.23.0",
-    "openclaw": "workspace:*",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/src/channel.ts

@@ -148,7 +148,11 @@ export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = {
       const message = core.channel.text.convertMarkdownTables(text ?? "", tableMode);
       const normalizedTo = normalizePubkey(to);
       await bus.sendDm(normalizedTo, message);
-      return { channel: "nostr", to: normalizedTo };
+      return {
+        channel: "nostr" as const,
+        to: normalizedTo,
+        messageId: `nostr-${Date.now()}`,
+      };
     },
   },
 
@@ -224,10 +228,15 @@ export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = {
         privateKey: account.privateKey,
         relays: account.relays,
         onMessage: async (senderPubkey, text, reply) => {
-          ctx.log?.debug(`[${account.accountId}] DM from ${senderPubkey}: ${text.slice(0, 50)}...`);
+          ctx.log?.debug?.(
+            `[${account.accountId}] DM from ${senderPubkey}: ${text.slice(0, 50)}...`,
+          );
 
           // Forward to OpenClaw's message pipeline
-          await runtime.channel.reply.handleInboundMessage({
+          // TODO: Replace with proper dispatchReplyWithBufferedBlockDispatcher call
+          await (
+            runtime.channel.reply as { handleInboundMessage?: (params: unknown) => Promise<void> }
+          ).handleInboundMessage?.({
             channel: "nostr",
             accountId: account.accountId,
             senderId: senderPubkey,
@@ -240,31 +249,33 @@ export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = {
           });
         },
         onError: (error, context) => {
-          ctx.log?.error(`[${account.accountId}] Nostr error (${context}): ${error.message}`);
+          ctx.log?.error?.(`[${account.accountId}] Nostr error (${context}): ${error.message}`);
         },
         onConnect: (relay) => {
-          ctx.log?.debug(`[${account.accountId}] Connected to relay: ${relay}`);
+          ctx.log?.debug?.(`[${account.accountId}] Connected to relay: ${relay}`);
         },
         onDisconnect: (relay) => {
-          ctx.log?.debug(`[${account.accountId}] Disconnected from relay: ${relay}`);
+          ctx.log?.debug?.(`[${account.accountId}] Disconnected from relay: ${relay}`);
         },
         onEose: (relays) => {
-          ctx.log?.debug(`[${account.accountId}] EOSE received from relays: ${relays}`);
+          ctx.log?.debug?.(`[${account.accountId}] EOSE received from relays: ${relays}`);
         },
         onMetric: (event: MetricEvent) => {
           // Log significant metrics at appropriate levels
           if (event.name.startsWith("event.rejected.")) {
-            ctx.log?.debug(`[${account.accountId}] Metric: ${event.name}`, event.labels);
+            ctx.log?.debug?.(
+              `[${account.accountId}] Metric: ${event.name} ${JSON.stringify(event.labels)}`,
+            );
           } else if (event.name === "relay.circuit_breaker.open") {
-            ctx.log?.warn(
+            ctx.log?.warn?.(
               `[${account.accountId}] Circuit breaker opened for relay: ${event.labels?.relay}`,
             );
           } else if (event.name === "relay.circuit_breaker.close") {
-            ctx.log?.info(
+            ctx.log?.info?.(
               `[${account.accountId}] Circuit breaker closed for relay: ${event.labels?.relay}`,
             );
           } else if (event.name === "relay.error") {
-            ctx.log?.debug(`[${account.accountId}] Relay error: ${event.labels?.relay}`);
+            ctx.log?.debug?.(`[${account.accountId}] Relay error: ${event.labels?.relay}`);
           }
           // Update cached metrics snapshot
           if (busHandle) {

package/src/nostr-bus.ts

@@ -488,24 +488,28 @@ export async function startNostrBus(options: NostrBusOptions): Promise<NostrBusH
     }
   }
 
-  const sub = pool.subscribeMany(relays, [{ kinds: [4], "#p": [pk], since }], {
-    onevent: handleEvent,
-    oneose: () => {
-      // EOSE handler - called when all stored events have been received
-      for (const relay of relays) {
-        metrics.emit("relay.message.eose", 1, { relay });
-      }
-      onEose?.(relays.join(", "));
-    },
-    onclose: (reason) => {
-      // Handle subscription close
-      for (const relay of relays) {
-        metrics.emit("relay.message.closed", 1, { relay });
-        options.onDisconnect?.(relay);
-      }
-      onError?.(new Error(`Subscription closed: ${reason.join(", ")}`), "subscription");
+  const sub = pool.subscribeMany(
+    relays,
+    [{ kinds: [4], "#p": [pk], since }] as unknown as Parameters<typeof pool.subscribeMany>[1],
+    {
+      onevent: handleEvent,
+      oneose: () => {
+        // EOSE handler - called when all stored events have been received
+        for (const relay of relays) {
+          metrics.emit("relay.message.eose", 1, { relay });
+        }
+        onEose?.(relays.join(", "));
+      },
+      onclose: (reason) => {
+        // Handle subscription close
+        for (const relay of relays) {
+          metrics.emit("relay.message.closed", 1, { relay });
+          options.onDisconnect?.(relay);
+        }
+        onError?.(new Error(`Subscription closed: ${reason.join(", ")}`), "subscription");
+      },
     },
-  });
+  );
 
   // Public sendDm function
   const sendDm = async (toPubkey: string, text: string): Promise<void> => {
@@ -693,7 +697,7 @@ export function normalizePubkey(input: string): string {
       throw new Error("Invalid npub key");
     }
     // Convert Uint8Array to hex string
-    return Array.from(decoded.data)
+    return Array.from(decoded.data as unknown as Uint8Array)
       .map((b) => b.toString(16).padStart(2, "0"))
       .join("");
   }

package/src/nostr-profile-http.ts

@@ -229,31 +229,58 @@ function sendJson(res: ServerResponse, status: number, body: unknown): void {
   res.end(JSON.stringify(body));
 }
 
-async function readJsonBody(req: IncomingMessage, maxBytes = 64 * 1024): Promise<unknown> {
+async function readJsonBody(
+  req: IncomingMessage,
+  maxBytes = 64 * 1024,
+  timeoutMs = 30_000,
+): Promise<unknown> {
   return new Promise((resolve, reject) => {
+    let done = false;
+    const finish = (fn: () => void) => {
+      if (done) {
+        return;
+      }
+      done = true;
+      clearTimeout(timer);
+      fn();
+    };
+
+    const timer = setTimeout(() => {
+      finish(() => {
+        const err = new Error("Request body timeout");
+        req.destroy(err);
+        reject(err);
+      });
+    }, timeoutMs);
+
     const chunks: Buffer[] = [];
     let totalBytes = 0;
 
     req.on("data", (chunk: Buffer) => {
       totalBytes += chunk.length;
       if (totalBytes > maxBytes) {
-        reject(new Error("Request body too large"));
-        req.destroy();
+        finish(() => {
+          reject(new Error("Request body too large"));
+          req.destroy();
+        });
         return;
       }
       chunks.push(chunk);
     });
 
     req.on("end", () => {
-      try {
-        const body = Buffer.concat(chunks).toString("utf-8");
-        resolve(body ? JSON.parse(body) : {});
-      } catch {
-        reject(new Error("Invalid JSON"));
-      }
+      finish(() => {
+        try {
+          const body = Buffer.concat(chunks).toString("utf-8");
+          resolve(body ? JSON.parse(body) : {});
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
     });
 
-    req.on("error", reject);
+    req.on("error", (err) => finish(() => reject(err)));
+    req.on("close", () => finish(() => reject(new Error("Connection closed"))));
   });
 }
 

package/src/nostr-profile-import.ts

@@ -130,7 +130,7 @@ export async function importProfileFromRelays(
               authors: [pubkey],
               limit: 1,
             },
-          ],
+          ] as unknown as Parameters<typeof pool.subscribeMany>[1],
           {
             onevent(event) {
               events.push({ event, relay });