@openclaw/nostr 2026.3.12 → 2026.5.1-beta.2

package/src/channel.outbound.test.ts

@@ -1,8 +1,10 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk/nostr";
+import { createStartAccountContext } from "openclaw/plugin-sdk/channel-test-helpers";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { createStartAccountContext } from "../../test-utils/start-account-context.js";
-import { nostrPlugin } from "./channel.js";
+import type { PluginRuntime } from "../runtime-api.js";
+import { nostrOutboundAdapter, startNostrGatewayAccount } from "./gateway.js";
 import { setNostrRuntime } from "./runtime.js";
+import { TEST_RESOLVED_PRIVATE_KEY, buildResolvedNostrAccount } from "./test-fixtures.js";
 
 const mocks = vi.hoisted(() => ({
   normalizePubkey: vi.fn((value: string) => `normalized-${value.toLowerCase()}`),
@@ -11,11 +13,58 @@ const mocks = vi.hoisted(() => ({
 
 vi.mock("./nostr-bus.js", () => ({
   DEFAULT_RELAYS: ["wss://relay.example.com"],
+  startNostrBus: mocks.startNostrBus,
+}));
+
+vi.mock("./nostr-key-utils.js", () => ({
   getPublicKeyFromPrivate: vi.fn(() => "pubkey"),
   normalizePubkey: mocks.normalizePubkey,
-  startNostrBus: mocks.startNostrBus,
 }));
 
+function createCfg() {
+  return {
+    channels: {
+      nostr: {
+        privateKey: TEST_RESOLVED_PRIVATE_KEY, // pragma: allowlist secret
+      },
+    },
+  };
+}
+
+function installOutboundRuntime(convertMarkdownTables = vi.fn((text: string) => text)) {
+  const resolveMarkdownTableMode = vi.fn(() => "off");
+  setNostrRuntime({
+    channel: {
+      text: {
+        resolveMarkdownTableMode,
+        convertMarkdownTables,
+      },
+    },
+    reply: {},
+  } as unknown as PluginRuntime);
+  return { resolveMarkdownTableMode, convertMarkdownTables };
+}
+
+async function startOutboundAccount(accountId?: string) {
+  const sendDm = vi.fn(async () => {});
+  const bus = {
+    sendDm,
+    close: vi.fn(),
+    getMetrics: vi.fn(() => ({ counters: {} })),
+    publishProfile: vi.fn(),
+    getProfileState: vi.fn(async () => null),
+  };
+  mocks.startNostrBus.mockResolvedValueOnce(bus as unknown);
+
+  const cleanup = (await startNostrGatewayAccount(
+    createStartAccountContext({
+      account: buildResolvedNostrAccount(accountId ? { accountId } : undefined),
+    }),
+  )) as { stop: () => void };
+
+  return { cleanup, sendDm };
+}
+
 describe("nostr outbound cfg threading", () => {
   afterEach(() => {
     mocks.normalizePubkey.mockClear();
@@ -23,52 +72,14 @@ describe("nostr outbound cfg threading", () => {
   });
 
   it("uses resolved cfg when converting markdown tables before send", async () => {
-    const resolveMarkdownTableMode = vi.fn(() => "off");
-    const convertMarkdownTables = vi.fn((text: string) => `converted:${text}`);
-    setNostrRuntime({
-      channel: {
-        text: {
-          resolveMarkdownTableMode,
-          convertMarkdownTables,
-        },
-      },
-      reply: {},
-    } as unknown as PluginRuntime);
-
-    const sendDm = vi.fn(async () => {});
-    const bus = {
-      sendDm,
-      close: vi.fn(),
-      getMetrics: vi.fn(() => ({ counters: {} })),
-      publishProfile: vi.fn(),
-      getProfileState: vi.fn(async () => null),
-    };
-    mocks.startNostrBus.mockResolvedValueOnce(bus as any);
-
-    const cleanup = (await nostrPlugin.gateway!.startAccount!(
-      createStartAccountContext({
-        account: {
-          accountId: "default",
-          enabled: true,
-          configured: true,
-          privateKey: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef", // pragma: allowlist secret
-          publicKey: "abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789", // pragma: allowlist secret
-          relays: ["wss://relay.example.com"],
-          config: {},
-        },
-        abortSignal: new AbortController().signal,
-      }),
-    )) as { stop: () => void };
+    const { resolveMarkdownTableMode, convertMarkdownTables } = installOutboundRuntime(
+      vi.fn((text: string) => `converted:${text}`),
+    );
+    const { cleanup, sendDm } = await startOutboundAccount();
 
-    const cfg = {
-      channels: {
-        nostr: {
-          privateKey: "resolved-nostr-private-key", // pragma: allowlist secret
-        },
-      },
-    };
-    await nostrPlugin.outbound!.sendText!({
-      cfg: cfg as any,
+    const cfg = createCfg();
+    await nostrOutboundAdapter.sendText({
+      cfg: cfg as OpenClawConfig,
       to: "NPUB123",
       text: "|a|b|",
       accountId: "default",
@@ -85,4 +96,33 @@ describe("nostr outbound cfg threading", () => {
 
     cleanup.stop();
   });
+
+  it("uses the configured defaultAccount when accountId is omitted", async () => {
+    const { resolveMarkdownTableMode } = installOutboundRuntime();
+    const { cleanup, sendDm } = await startOutboundAccount("work");
+
+    const cfg = {
+      channels: {
+        nostr: {
+          privateKey: TEST_RESOLVED_PRIVATE_KEY, // pragma: allowlist secret
+          defaultAccount: "work",
+        },
+      },
+    };
+
+    await nostrOutboundAdapter.sendText({
+      cfg: cfg as OpenClawConfig,
+      to: "NPUB123",
+      text: "hello",
+    });
+
+    expect(resolveMarkdownTableMode).toHaveBeenCalledWith({
+      cfg,
+      channel: "nostr",
+      accountId: "work",
+    });
+    expect(sendDm).toHaveBeenCalledWith("normalized-npub123", "hello");
+
+    cleanup.stop();
+  });
 });

package/src/channel.setup.ts

@@ -0,0 +1,231 @@
+import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+import { patchTopLevelChannelConfigSection } from "openclaw/plugin-sdk/setup";
+import {
+  createDelegatedSetupWizardProxy,
+  createStandardChannelSetupStatus,
+  DEFAULT_ACCOUNT_ID,
+  type ChannelSetupAdapter,
+} from "openclaw/plugin-sdk/setup-runtime";
+import { buildChannelConfigSchema, type ChannelPlugin } from "./channel-api.js";
+import { NostrConfigSchema } from "./config-schema.js";
+import { DEFAULT_RELAYS } from "./default-relays.js";
+
+const channel = "nostr" as const;
+
+type NostrAccountConfig = {
+  enabled?: boolean;
+  name?: string;
+  defaultAccount?: string;
+  privateKey?: unknown;
+  relays?: string[];
+  dmPolicy?: "pairing" | "allowlist" | "open" | "disabled";
+  allowFrom?: Array<string | number>;
+  profile?: unknown;
+};
+
+type ResolvedNostrSetupAccount = {
+  accountId: string;
+  name?: string;
+  enabled: boolean;
+  configured: boolean;
+  privateKey: string;
+  publicKey: string;
+  relays: string[];
+  profile?: unknown;
+  config: NostrAccountConfig;
+};
+
+function getNostrConfig(cfg: OpenClawConfig): NostrAccountConfig | undefined {
+  return (cfg.channels as Record<string, unknown> | undefined)?.nostr as
+    | NostrAccountConfig
+    | undefined;
+}
+
+function listSetupNostrAccountIds(cfg: OpenClawConfig): string[] {
+  const nostrCfg = getNostrConfig(cfg);
+  const privateKey = typeof nostrCfg?.privateKey === "string" ? nostrCfg.privateKey.trim() : "";
+  if (!privateKey) {
+    return [];
+  }
+  return [resolveDefaultSetupNostrAccountId(cfg)];
+}
+
+function resolveDefaultSetupNostrAccountId(cfg: OpenClawConfig): string {
+  const configured = getNostrConfig(cfg)?.defaultAccount;
+  return typeof configured === "string" && configured.trim()
+    ? configured.trim()
+    : DEFAULT_ACCOUNT_ID;
+}
+
+function resolveSetupNostrAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedNostrSetupAccount {
+  const nostrCfg = getNostrConfig(params.cfg);
+  const accountId = params.accountId?.trim() || resolveDefaultSetupNostrAccountId(params.cfg);
+  const privateKey = typeof nostrCfg?.privateKey === "string" ? nostrCfg.privateKey.trim() : "";
+  const configured = Boolean(privateKey);
+  return {
+    accountId,
+    name: typeof nostrCfg?.name === "string" ? nostrCfg.name : undefined,
+    enabled: nostrCfg?.enabled !== false,
+    configured,
+    privateKey,
+    publicKey: "",
+    relays: nostrCfg?.relays ?? DEFAULT_RELAYS,
+    profile: nostrCfg?.profile,
+    config: {
+      enabled: nostrCfg?.enabled,
+      name: nostrCfg?.name,
+      privateKey: nostrCfg?.privateKey,
+      relays: nostrCfg?.relays,
+      dmPolicy: nostrCfg?.dmPolicy,
+      allowFrom: nostrCfg?.allowFrom,
+      profile: nostrCfg?.profile,
+    },
+  };
+}
+
+function buildNostrSetupPatch(accountId: string, patch: Record<string, unknown>) {
+  return {
+    ...(accountId !== DEFAULT_ACCOUNT_ID ? { defaultAccount: accountId } : {}),
+    ...patch,
+  };
+}
+
+function parseRelayUrls(raw: string): { relays: string[]; error?: string } {
+  const entries = raw
+    .split(/[,\n]/)
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  const relays: string[] = [];
+  for (const entry of entries) {
+    try {
+      const parsed = new URL(entry);
+      if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+        return { relays: [], error: `Relay must use ws:// or wss:// (${entry})` };
+      }
+    } catch {
+      return { relays: [], error: `Invalid relay URL: ${entry}` };
+    }
+    relays.push(entry);
+  }
+  return { relays: [...new Set(relays)] };
+}
+
+function looksLikeNostrPrivateKey(privateKey: string): boolean {
+  return privateKey.startsWith("nsec1") || /^[0-9a-fA-F]{64}$/.test(privateKey);
+}
+
+const nostrSetupAdapter: ChannelSetupAdapter = {
+  resolveAccountId: ({ cfg, accountId }) =>
+    accountId?.trim() || resolveDefaultSetupNostrAccountId(cfg),
+  applyAccountName: ({ cfg, accountId, name }) =>
+    patchTopLevelChannelConfigSection({
+      cfg,
+      channel,
+      patch: buildNostrSetupPatch(accountId, name?.trim() ? { name: name.trim() } : {}),
+    }),
+  validateInput: ({ input }) => {
+    const typedInput = input as {
+      useEnv?: boolean;
+      privateKey?: string;
+      relayUrls?: string;
+    };
+    if (!typedInput.useEnv) {
+      const privateKey = typedInput.privateKey?.trim();
+      if (!privateKey) {
+        return "Nostr requires --private-key or --use-env.";
+      }
+      if (!looksLikeNostrPrivateKey(privateKey)) {
+        return "Nostr private key must be valid nsec or 64-character hex.";
+      }
+    }
+    if (typedInput.relayUrls?.trim()) {
+      return parseRelayUrls(typedInput.relayUrls).error ?? null;
+    }
+    return null;
+  },
+  applyAccountConfig: ({ cfg, accountId, input }) => {
+    const typedInput = input as {
+      useEnv?: boolean;
+      privateKey?: string;
+      relayUrls?: string;
+    };
+    const relayResult = typedInput.relayUrls?.trim()
+      ? parseRelayUrls(typedInput.relayUrls)
+      : { relays: [] };
+    return patchTopLevelChannelConfigSection({
+      cfg,
+      channel,
+      enabled: true,
+      clearFields: typedInput.useEnv ? ["privateKey"] : undefined,
+      patch: buildNostrSetupPatch(accountId, {
+        ...(typedInput.useEnv ? {} : { privateKey: typedInput.privateKey?.trim() }),
+        ...(relayResult.relays.length > 0 ? { relays: relayResult.relays } : {}),
+      }),
+    });
+  },
+};
+
+const nostrSetupWizard = createDelegatedSetupWizardProxy({
+  channel,
+  loadWizard: async () => (await import("./setup-surface.js")).nostrSetupWizard,
+  status: {
+    ...createStandardChannelSetupStatus({
+      channelLabel: "Nostr",
+      configuredLabel: "configured",
+      unconfiguredLabel: "needs private key",
+      configuredHint: "configured",
+      unconfiguredHint: "needs private key",
+      configuredScore: 1,
+      unconfiguredScore: 0,
+      includeStatusLine: true,
+      resolveConfigured: ({ cfg, accountId }) =>
+        resolveSetupNostrAccount({ cfg, accountId }).configured,
+      resolveExtraStatusLines: ({ cfg }) => {
+        const account = resolveSetupNostrAccount({ cfg });
+        return [`Relays: ${account.relays.length || DEFAULT_RELAYS.length}`];
+      },
+    }),
+  },
+  resolveShouldPromptAccountIds: () => false,
+  delegatePrepare: true,
+  delegateFinalize: true,
+});
+
+export const nostrSetupPlugin: ChannelPlugin<ResolvedNostrSetupAccount> = {
+  id: channel,
+  meta: {
+    id: channel,
+    label: "Nostr",
+    selectionLabel: "Nostr",
+    docsPath: "/channels/nostr",
+    docsLabel: "nostr",
+    blurb: "Decentralized DMs via Nostr relays (NIP-04)",
+    order: 100,
+  },
+  capabilities: {
+    chatTypes: ["direct"],
+    media: false,
+  },
+  reload: { configPrefixes: ["channels.nostr"] },
+  configSchema: buildChannelConfigSchema(NostrConfigSchema),
+  setup: nostrSetupAdapter,
+  setupWizard: nostrSetupWizard,
+  config: {
+    listAccountIds: listSetupNostrAccountIds,
+    resolveAccount: (cfg, accountId) => resolveSetupNostrAccount({ cfg, accountId }),
+    defaultAccountId: resolveDefaultSetupNostrAccountId,
+    isConfigured: (account) => account.configured,
+    describeAccount: (account) =>
+      describeAccountSnapshot({
+        account,
+        configured: account.configured,
+        extra: {
+          publicKey: account.publicKey,
+        },
+      }),
+  },
+};