@openclaw/nostr 2026.3.13 → 2026.5.2-beta.1

package/src/channel.ts

@@ -1,22 +1,34 @@
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import {
+  createScopedDmSecurityResolver,
+  createTopLevelChannelConfigAdapter,
+} from "openclaw/plugin-sdk/channel-config-helpers";
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
+import {
+  buildPassiveChannelStatusSummary,
+  buildTrafficStatusSummary,
+} from "openclaw/plugin-sdk/extension-shared";
+import { createComputedAccountStatusAdapter } from "openclaw/plugin-sdk/status-helpers";
 import {
   buildChannelConfigSchema,
   collectStatusIssuesFromLastError,
   createDefaultChannelRuntimeState,
   DEFAULT_ACCOUNT_ID,
   formatPairingApproveHint,
-  mapAllowFromEntries,
   type ChannelPlugin,
-} from "openclaw/plugin-sdk/nostr";
-import {
-  buildPassiveChannelStatusSummary,
-  buildTrafficStatusSummary,
-} from "../../shared/channel-status-summary.js";
+} from "./channel-api.js";
 import type { NostrProfile } from "./config-schema.js";
 import { NostrConfigSchema } from "./config-schema.js";
-import type { MetricEvent, MetricsSnapshot } from "./metrics.js";
-import { normalizePubkey, startNostrBus, type NostrBusHandle } from "./nostr-bus.js";
+import {
+  getActiveNostrBuses,
+  nostrOutboundAdapter,
+  nostrPairingTextAdapter,
+  startNostrGatewayAccount,
+} from "./gateway.js";
+import { normalizePubkey } from "./nostr-key-utils.js";
 import type { ProfilePublishResult } from "./nostr-profile.js";
-import { getNostrRuntime } from "./runtime.js";
+import { resolveNostrOutboundSessionRoute } from "./session-route.js";
+import { nostrSetupAdapter, nostrSetupWizard } from "./setup-surface.js";
 import {
   listNostrAccountIds,
   resolveDefaultNostrAccountId,
@@ -24,288 +36,140 @@ import {
   type ResolvedNostrAccount,
 } from "./types.js";
 
-// Store active bus handles per account
-const activeBuses = new Map<string, NostrBusHandle>();
-
-// Store metrics snapshots per account (for status reporting)
-const metricsSnapshots = new Map<string, MetricsSnapshot>();
-
-export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = {
-  id: "nostr",
-  meta: {
-    id: "nostr",
-    label: "Nostr",
-    selectionLabel: "Nostr",
-    docsPath: "/channels/nostr",
-    docsLabel: "nostr",
-    blurb: "Decentralized DMs via Nostr relays (NIP-04)",
-    order: 100,
-  },
-  capabilities: {
-    chatTypes: ["direct"], // DMs only for MVP
-    media: false, // No media for MVP
+const resolveNostrDmPolicy = createScopedDmSecurityResolver<ResolvedNostrAccount>({
+  channelKey: "nostr",
+  resolvePolicy: (account) => account.config.dmPolicy,
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  policyPathSuffix: "dmPolicy",
+  defaultPolicy: "pairing",
+  approveHint: formatPairingApproveHint("nostr"),
+  normalizeEntry: (raw) => {
+    try {
+      return normalizePubkey(raw.trim().replace(/^nostr:/i, ""));
+    } catch {
+      return raw.trim();
+    }
   },
-  reload: { configPrefixes: ["channels.nostr"] },
-  configSchema: buildChannelConfigSchema(NostrConfigSchema),
-
-  config: {
-    listAccountIds: (cfg) => listNostrAccountIds(cfg),
-    resolveAccount: (cfg, accountId) => resolveNostrAccount({ cfg, accountId }),
-    defaultAccountId: (cfg) => resolveDefaultNostrAccountId(cfg),
-    isConfigured: (account) => account.configured,
-    describeAccount: (account) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      publicKey: account.publicKey,
-    }),
-    resolveAllowFrom: ({ cfg, accountId }) =>
-      mapAllowFromEntries(resolveNostrAccount({ cfg, accountId }).config.allowFrom),
-    formatAllowFrom: ({ allowFrom }) =>
-      allowFrom
-        .map((entry) => String(entry).trim())
-        .filter(Boolean)
-        .map((entry) => {
-          if (entry === "*") {
-            return "*";
-          }
-          try {
-            return normalizePubkey(entry);
-          } catch {
-            return entry; // Keep as-is if normalization fails
-          }
-        })
-        .filter(Boolean),
-  },
-
-  pairing: {
-    idLabel: "nostrPubkey",
-    normalizeAllowEntry: (entry) => {
-      try {
-        return normalizePubkey(entry.replace(/^nostr:/i, ""));
-      } catch {
-        return entry;
-      }
-    },
-    notifyApproval: async ({ id }) => {
-      // Get the default account's bus and send approval message
-      const bus = activeBuses.get(DEFAULT_ACCOUNT_ID);
-      if (bus) {
-        await bus.sendDm(id, "Your pairing request has been approved!");
-      }
+});
+
+const nostrConfigAdapter = createTopLevelChannelConfigAdapter<ResolvedNostrAccount>({
+  sectionKey: "nostr",
+  resolveAccount: (cfg) => resolveNostrAccount({ cfg }),
+  listAccountIds: listNostrAccountIds,
+  defaultAccountId: resolveDefaultNostrAccountId,
+  deleteMode: "clear-fields",
+  clearBaseFields: [
+    "name",
+    "defaultAccount",
+    "privateKey",
+    "relays",
+    "dmPolicy",
+    "allowFrom",
+    "profile",
+  ],
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  formatAllowFrom: (allowFrom) =>
+    allowFrom
+      .map((entry) => String(entry).trim())
+      .filter(Boolean)
+      .map((entry) => {
+        if (entry === "*") {
+          return "*";
+        }
+        try {
+          return normalizePubkey(entry);
+        } catch {
+          return entry;
+        }
+      })
+      .filter(Boolean),
+});
+
+export const nostrPlugin: ChannelPlugin<ResolvedNostrAccount> = createChatChannelPlugin({
+  base: {
+    id: "nostr",
+    meta: {
+      id: "nostr",
+      label: "Nostr",
+      selectionLabel: "Nostr",
+      docsPath: "/channels/nostr",
+      docsLabel: "nostr",
+      blurb: "Decentralized DMs via Nostr relays (NIP-04)",
+      order: 100,
     },
-  },
-
-  security: {
-    resolveDmPolicy: ({ account }) => {
-      return {
-        policy: account.config.dmPolicy ?? "pairing",
-        allowFrom: account.config.allowFrom ?? [],
-        policyPath: "channels.nostr.dmPolicy",
-        allowFromPath: "channels.nostr.allowFrom",
-        approveHint: formatPairingApproveHint("nostr"),
-        normalizeEntry: (raw) => {
-          try {
-            return normalizePubkey(raw.replace(/^nostr:/i, "").trim());
-          } catch {
-            return raw.trim();
-          }
-        },
-      };
+    capabilities: {
+      chatTypes: ["direct"], // DMs only for MVP
+      media: false, // No media for MVP
     },
-  },
-
-  messaging: {
-    normalizeTarget: (target) => {
-      // Strip nostr: prefix if present
-      const cleaned = target.replace(/^nostr:/i, "").trim();
-      try {
-        return normalizePubkey(cleaned);
-      } catch {
-        return cleaned;
-      }
+    reload: { configPrefixes: ["channels.nostr"] },
+    configSchema: buildChannelConfigSchema(NostrConfigSchema),
+    setup: nostrSetupAdapter,
+    setupWizard: nostrSetupWizard,
+    config: {
+      ...nostrConfigAdapter,
+      isConfigured: (account) => account.configured,
+      describeAccount: (account) =>
+        describeAccountSnapshot({
+          account,
+          configured: account.configured,
+          extra: {
+            publicKey: account.publicKey,
+          },
+        }),
     },
-    targetResolver: {
-      looksLikeId: (input) => {
-        const trimmed = input.trim();
-        return trimmed.startsWith("npub1") || /^[0-9a-fA-F]{64}$/.test(trimmed);
+    messaging: {
+      targetPrefixes: ["nostr"],
+      normalizeTarget: (target) => {
+        // Strip nostr: prefix if present
+        const cleaned = target.trim().replace(/^nostr:/i, "");
+        try {
+          return normalizePubkey(cleaned);
+        } catch {
+          return cleaned;
+        }
       },
-      hint: "<npub|hex pubkey|nostr:npub...>",
+      targetResolver: {
+        looksLikeId: (input) => {
+          const trimmed = input.trim();
+          return trimmed.startsWith("npub1") || /^[0-9a-fA-F]{64}$/.test(trimmed);
+        },
+        hint: "<npub|hex pubkey|nostr:npub...>",
+      },
+      resolveOutboundSessionRoute: (params) => resolveNostrOutboundSessionRoute(params),
     },
-  },
-
-  outbound: {
-    deliveryMode: "direct",
-    textChunkLimit: 4000,
-    sendText: async ({ cfg, to, text, accountId }) => {
-      const core = getNostrRuntime();
-      const aid = accountId ?? DEFAULT_ACCOUNT_ID;
-      const bus = activeBuses.get(aid);
-      if (!bus) {
-        throw new Error(`Nostr bus not running for account ${aid}`);
-      }
-      const tableMode = core.channel.text.resolveMarkdownTableMode({
-        cfg,
-        channel: "nostr",
-        accountId: aid,
-      });
-      const message = core.channel.text.convertMarkdownTables(text ?? "", tableMode);
-      const normalizedTo = normalizePubkey(to);
-      await bus.sendDm(normalizedTo, message);
-      return {
-        channel: "nostr" as const,
-        to: normalizedTo,
-        messageId: `nostr-${Date.now()}`,
-      };
+    status: {
+      ...createComputedAccountStatusAdapter<ResolvedNostrAccount>({
+        defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+        collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("nostr", accounts),
+        buildChannelSummary: ({ snapshot }) =>
+          buildPassiveChannelStatusSummary(snapshot, {
+            publicKey: snapshot.publicKey ?? null,
+          }),
+        resolveAccountSnapshot: ({ account, runtime }) => ({
+          accountId: account.accountId,
+          name: account.name,
+          enabled: account.enabled,
+          configured: account.configured,
+          extra: {
+            publicKey: account.publicKey,
+            profile: account.profile,
+            ...buildTrafficStatusSummary(runtime),
+          },
+        }),
+      }),
+    },
+    gateway: {
+      startAccount: startNostrGatewayAccount,
     },
   },
-
-  status: {
-    defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
-    collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("nostr", accounts),
-    buildChannelSummary: ({ snapshot }) =>
-      buildPassiveChannelStatusSummary(snapshot, {
-        publicKey: snapshot.publicKey ?? null,
-      }),
-    buildAccountSnapshot: ({ account, runtime }) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      publicKey: account.publicKey,
-      profile: account.profile,
-      running: runtime?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? null,
-      ...buildTrafficStatusSummary(runtime),
-    }),
+  pairing: {
+    text: nostrPairingTextAdapter,
   },
-
-  gateway: {
-    startAccount: async (ctx) => {
-      const account = ctx.account;
-      ctx.setStatus({
-        accountId: account.accountId,
-        publicKey: account.publicKey,
-      });
-      ctx.log?.info(
-        `[${account.accountId}] starting Nostr provider (pubkey: ${account.publicKey})`,
-      );
-
-      if (!account.configured) {
-        throw new Error("Nostr private key not configured");
-      }
-
-      const runtime = getNostrRuntime();
-
-      // Track bus handle for metrics callback
-      let busHandle: NostrBusHandle | null = null;
-
-      const bus = await startNostrBus({
-        accountId: account.accountId,
-        privateKey: account.privateKey,
-        relays: account.relays,
-        onMessage: async (senderPubkey, text, reply) => {
-          ctx.log?.debug?.(
-            `[${account.accountId}] DM from ${senderPubkey}: ${text.slice(0, 50)}...`,
-          );
-
-          // Forward to OpenClaw's message pipeline
-          await (
-            runtime.channel.reply as { handleInboundMessage?: (params: unknown) => Promise<void> }
-          ).handleInboundMessage?.({
-            channel: "nostr",
-            accountId: account.accountId,
-            senderId: senderPubkey,
-            chatType: "direct",
-            chatId: senderPubkey, // For DMs, chatId is the sender's pubkey
-            text,
-            reply: async (responseText: string) => {
-              await reply(responseText);
-            },
-          });
-        },
-        onError: (error, context) => {
-          ctx.log?.error?.(`[${account.accountId}] Nostr error (${context}): ${error.message}`);
-        },
-        onConnect: (relay) => {
-          ctx.log?.debug?.(`[${account.accountId}] Connected to relay: ${relay}`);
-        },
-        onDisconnect: (relay) => {
-          ctx.log?.debug?.(`[${account.accountId}] Disconnected from relay: ${relay}`);
-        },
-        onEose: (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} ${JSON.stringify(event.labels)}`,
-            );
-          } else if (event.name === "relay.circuit_breaker.open") {
-            ctx.log?.warn?.(
-              `[${account.accountId}] Circuit breaker opened for relay: ${event.labels?.relay}`,
-            );
-          } else if (event.name === "relay.circuit_breaker.close") {
-            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}`);
-          }
-          // Update cached metrics snapshot
-          if (busHandle) {
-            metricsSnapshots.set(account.accountId, busHandle.getMetrics());
-          }
-        },
-      });
-
-      busHandle = bus;
-
-      // Store the bus handle
-      activeBuses.set(account.accountId, bus);
-
-      ctx.log?.info(
-        `[${account.accountId}] Nostr provider started, connected to ${account.relays.length} relay(s)`,
-      );
-
-      // Return cleanup function
-      return {
-        stop: () => {
-          bus.close();
-          activeBuses.delete(account.accountId);
-          metricsSnapshots.delete(account.accountId);
-          ctx.log?.info(`[${account.accountId}] Nostr provider stopped`);
-        },
-      };
-    },
+  security: {
+    resolveDmPolicy: resolveNostrDmPolicy,
   },
-};
-
-/**
- * Get metrics snapshot for a Nostr account.
- * Returns undefined if account is not running.
- */
-export function getNostrMetrics(
-  accountId: string = DEFAULT_ACCOUNT_ID,
-): MetricsSnapshot | undefined {
-  const bus = activeBuses.get(accountId);
-  if (bus) {
-    return bus.getMetrics();
-  }
-  return metricsSnapshots.get(accountId);
-}
-
-/**
- * Get all active Nostr bus handles.
- * Useful for debugging and status reporting.
- */
-export function getActiveNostrBuses(): Map<string, NostrBusHandle> {
-  return new Map(activeBuses);
-}
+  outbound: nostrOutboundAdapter,
+});
 
 /**
  * Publish a profile (kind:0) for a Nostr account.
@@ -318,7 +182,7 @@ export async function publishNostrProfile(
   accountId: string = DEFAULT_ACCOUNT_ID,
   profile: NostrProfile,
 ): Promise<ProfilePublishResult> {
-  const bus = activeBuses.get(accountId);
+  const bus = getActiveNostrBuses().get(accountId);
   if (!bus) {
     throw new Error(`Nostr bus not running for account ${accountId}`);
   }
@@ -335,7 +199,7 @@ export async function getNostrProfileState(accountId: string = DEFAULT_ACCOUNT_I
   lastPublishedEventId: string | null;
   lastPublishResults: Record<string, "ok" | "failed" | "timeout"> | null;
 } | null> {
-  const bus = activeBuses.get(accountId);
+  const bus = getActiveNostrBuses().get(accountId);
   if (!bus) {
     return null;
   }

package/src/config-schema.ts

@@ -1,6 +1,10 @@
-import { AllowFromListSchema, DmPolicySchema } from "openclaw/plugin-sdk/compat";
-import { MarkdownConfigSchema, buildChannelConfigSchema } from "openclaw/plugin-sdk/nostr";
-import { z } from "zod";
+import {
+  AllowFromListSchema,
+  DmPolicySchema,
+  MarkdownConfigSchema,
+} from "openclaw/plugin-sdk/channel-config-primitives";
+import { buildSecretInputSchema } from "openclaw/plugin-sdk/secret-input";
+import { z } from "openclaw/plugin-sdk/zod";
 
 /**
  * Validates https:// URLs only (no javascript:, data:, file:, etc.)
@@ -50,7 +54,16 @@ export const NostrProfileSchema = z.object({
   lud16: z.string().optional(),
 });
 
-export type NostrProfile = z.infer<typeof NostrProfileSchema>;
+export interface NostrProfile {
+  name?: string;
+  displayName?: string;
+  about?: string;
+  picture?: string;
+  banner?: string;
+  website?: string;
+  nip05?: string;
+  lud16?: string;
+}
 
 /**
  * Zod schema for channels.nostr.* configuration
@@ -69,7 +82,7 @@ export const NostrConfigSchema = z.object({
   markdown: MarkdownConfigSchema,
 
   /** Private key in hex or nsec bech32 format */
-  privateKey: z.string().optional(),
+  privateKey: buildSecretInputSchema().optional(),
 
   /** WebSocket relay URLs to connect to */
   relays: z.array(z.string()).optional(),
@@ -83,10 +96,3 @@ export const NostrConfigSchema = z.object({
   /** Profile metadata (NIP-01 kind:0 content) */
   profile: NostrProfileSchema.optional(),
 });
-
-export type NostrConfig = z.infer<typeof NostrConfigSchema>;
-
-/**
- * JSON Schema for Control UI (converted from Zod)
- */
-export const nostrChannelConfigSchema = buildChannelConfigSchema(NostrConfigSchema);

package/src/default-relays.ts

@@ -0,0 +1 @@
+export const DEFAULT_RELAYS = ["wss://relay.damus.io", "wss://nos.lol"];