@actagent/nostr 2026.6.2

package/src/channel.outbound.test.ts

@@ -0,0 +1,175 @@
+// Nostr tests cover channel.outbound plugin behavior.
+import { verifyChannelMessageAdapterCapabilityProofs } from "actagent/plugin-sdk/channel-outbound";
+import { createStartAccountContext } from "actagent/plugin-sdk/channel-test-helpers";
+import type { ACTAgentConfig } from "actagent/plugin-sdk/config-contracts";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { PluginRuntime } from "../runtime-api.js";
+import { nostrPlugin } from "./channel.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()}`),
+  startNostrBus: vi.fn(),
+}));
+
+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,
+}));
+
+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 abort = new AbortController();
+
+  const task = startNostrGatewayAccount(
+    createStartAccountContext({
+      account: buildResolvedNostrAccount(accountId ? { accountId } : undefined),
+      abortSignal: abort.signal,
+    }),
+  );
+  await vi.waitFor(() => {
+    expect(mocks.startNostrBus).toHaveBeenCalledTimes(1);
+  });
+  const cleanup = {
+    stop: async () => {
+      abort.abort();
+      await task;
+    },
+  };
+
+  return { cleanup, sendDm };
+}
+
+describe("nostr outbound cfg threading", () => {
+  afterEach(() => {
+    mocks.normalizePubkey.mockClear();
+    mocks.startNostrBus.mockReset();
+  });
+
+  it("uses resolved cfg when converting markdown tables before send", async () => {
+    const { resolveMarkdownTableMode, convertMarkdownTables } = installOutboundRuntime(
+      vi.fn((text: string) => `converted:${text}`),
+    );
+    const { cleanup, sendDm } = await startOutboundAccount();
+
+    const cfg = createCfg();
+    await nostrOutboundAdapter.sendText({
+      cfg: cfg as ACTAgentConfig,
+      to: "NPUB123",
+      text: "|a|b|",
+      accountId: "default",
+    });
+
+    expect(resolveMarkdownTableMode).toHaveBeenCalledWith({
+      cfg,
+      channel: "nostr",
+      accountId: "default",
+    });
+    expect(convertMarkdownTables).toHaveBeenCalledWith("|a|b|", "off");
+    expect(mocks.normalizePubkey).toHaveBeenCalledWith("NPUB123");
+    expect(sendDm).toHaveBeenCalledWith("normalized-npub123", "converted:|a|b|");
+
+    await 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 ACTAgentConfig,
+      to: "NPUB123",
+      text: "hello",
+    });
+
+    expect(resolveMarkdownTableMode).toHaveBeenCalledWith({
+      cfg,
+      channel: "nostr",
+      accountId: "work",
+    });
+    expect(sendDm).toHaveBeenCalledWith("normalized-npub123", "hello");
+
+    await cleanup.stop();
+  });
+
+  it("backs declared message adapter capabilities with outbound sends", async () => {
+    installOutboundRuntime();
+    const { cleanup, sendDm } = await startOutboundAccount();
+    const adapter = nostrPlugin.message;
+    if (!adapter?.send?.text) {
+      throw new Error("expected Nostr message adapter with text sender");
+    }
+    const sendText = adapter.send.text;
+    expect(adapter.send.media).toBeUndefined();
+
+    await verifyChannelMessageAdapterCapabilityProofs({
+      adapterName: "nostrMessageAdapter",
+      adapter,
+      proofs: {
+        text: async () => {
+          const result = await sendText({
+            cfg: createCfg() as ACTAgentConfig,
+            to: "NPUB123",
+            text: "hello",
+            accountId: "default",
+          });
+          expect(sendDm).toHaveBeenCalledWith("normalized-npub123", "hello");
+          expect(result.receipt.parts[0]?.kind).toBe("text");
+        },
+        messageSendingHooks: () => {
+          expect(sendText).toBeTypeOf("function");
+        },
+      },
+    });
+
+    await cleanup.stop();
+  });
+});

package/src/channel.setup.ts

@@ -0,0 +1,161 @@
+// Nostr plugin module implements channel.setup behavior.
+import { describeAccountSnapshot } from "actagent/plugin-sdk/account-helpers";
+import type { ACTAgentConfig } from "actagent/plugin-sdk/config-contracts";
+import {
+  createDelegatedSetupWizardProxy,
+  createStandardChannelSetupStatus,
+  DEFAULT_ACCOUNT_ID,
+  createSetupTranslator,
+} from "actagent/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";
+import { createNostrSetupAdapter } from "./setup-adapter.js";
+
+const t = createSetupTranslator();
+
+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: ACTAgentConfig): NostrAccountConfig | undefined {
+  return (cfg.channels as Record<string, unknown> | undefined)?.nostr as
+    | NostrAccountConfig
+    | undefined;
+}
+
+function listSetupNostrAccountIds(cfg: ACTAgentConfig): string[] {
+  const nostrCfg = getNostrConfig(cfg);
+  const privateKey = typeof nostrCfg?.privateKey === "string" ? nostrCfg.privateKey.trim() : "";
+  if (!privateKey) {
+    return [];
+  }
+  return [resolveDefaultSetupNostrAccountId(cfg)];
+}
+
+function resolveDefaultSetupNostrAccountId(cfg: ACTAgentConfig): string {
+  const configured = getNostrConfig(cfg)?.defaultAccount;
+  return typeof configured === "string" && configured.trim()
+    ? configured.trim()
+    : DEFAULT_ACCOUNT_ID;
+}
+
+function resolveSetupNostrAccount(params: {
+  cfg: ACTAgentConfig;
+  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 looksLikeNostrPrivateKey(privateKey: string): boolean {
+  return privateKey.startsWith("nsec1") || /^[0-9a-fA-F]{64}$/.test(privateKey);
+}
+
+const nostrSetupAdapter = createNostrSetupAdapter({
+  resolveAccountId: (cfg, accountId) => accountId?.trim() || resolveDefaultSetupNostrAccountId(cfg),
+  validatePrivateKey: looksLikeNostrPrivateKey,
+});
+
+const nostrSetupWizard = createDelegatedSetupWizardProxy({
+  channel,
+  loadWizard: async () => (await import("./setup-surface.js")).nostrSetupWizard,
+  status: {
+    ...createStandardChannelSetupStatus({
+      channelLabel: "Nostr",
+      configuredLabel: t("wizard.channels.statusConfigured"),
+      unconfiguredLabel: t("wizard.channels.statusNeedsPrivateKey"),
+      configuredHint: t("wizard.channels.statusConfigured"),
+      unconfiguredHint: t("wizard.channels.statusNeedsPrivateKey"),
+      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,
+        },
+      }),
+  },
+};