@kodelyth/nostr 2026.5.39 → 2026.5.42

package/index.ts

@@ -0,0 +1,95 @@
+import {
+  defineBundledChannelEntry,
+  loadBundledEntryExportSync,
+} from "klaw/plugin-sdk/channel-entry-contract";
+import type { KlawConfig, PluginRuntime, ResolvedNostrAccount } from "./api.js";
+
+function createNostrProfileHttpHandler() {
+  return loadBundledEntryExportSync<
+    (params: Record<string, unknown>) => (ctx: unknown) => Promise<void> | void
+  >(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "createNostrProfileHttpHandler",
+  });
+}
+
+function getNostrRuntime() {
+  return loadBundledEntryExportSync<() => PluginRuntime>(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "getNostrRuntime",
+  })();
+}
+
+function resolveNostrAccount(params: { cfg: unknown; accountId: string }) {
+  return loadBundledEntryExportSync<
+    (params: { cfg: unknown; accountId: string }) => ResolvedNostrAccount
+  >(import.meta.url, {
+    specifier: "./api.js",
+    exportName: "resolveNostrAccount",
+  })(params);
+}
+
+export default defineBundledChannelEntry({
+  id: "nostr",
+  name: "Nostr",
+  description: "Nostr DM channel plugin via NIP-04",
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./channel-plugin-api.js",
+    exportName: "nostrPlugin",
+  },
+  runtime: {
+    specifier: "./api.js",
+    exportName: "setNostrRuntime",
+  },
+  registerFull(api) {
+    const httpHandler = createNostrProfileHttpHandler()({
+      getConfigProfile: (accountId: string) => {
+        const runtime = getNostrRuntime();
+        const cfg = runtime.config.current() as KlawConfig;
+        const account = resolveNostrAccount({ cfg, accountId });
+        return account.profile;
+      },
+      updateConfigProfile: async (_accountId: string, profile: unknown) => {
+        const runtime = getNostrRuntime();
+
+        await runtime.config.mutateConfigFile({
+          afterWrite: { mode: "auto" },
+          mutate: (draft) => {
+            const channels = (draft.channels ?? {}) as Record<string, unknown>;
+            const nostrConfig = (channels.nostr ?? {}) as Record<string, unknown>;
+
+            draft.channels = {
+              ...channels,
+              nostr: {
+                ...nostrConfig,
+                profile,
+              },
+            };
+          },
+        });
+      },
+      getAccountInfo: (accountId: string) => {
+        const runtime = getNostrRuntime();
+        const cfg = runtime.config.current() as KlawConfig;
+        const account = resolveNostrAccount({ cfg, accountId });
+        if (!account.configured || !account.publicKey) {
+          return null;
+        }
+        return {
+          pubkey: account.publicKey,
+          relays: account.relays,
+        };
+      },
+      log: api.logger,
+    });
+
+    api.registerHttpRoute({
+      path: "/api/channels/nostr",
+      auth: "gateway",
+      match: "prefix",
+      gatewayRuntimeScopeSurface: "trusted-operator",
+      handler: httpHandler,
+    });
+  },
+});

package/klaw.plugin.json

@@ -3,196 +3,13 @@
   "activation": {
     "onStartup": false
   },
-  "channels": [
-    "nostr"
-  ],
+  "channels": ["nostr"],
   "channelEnvVars": {
-    "nostr": [
-      "NOSTR_PRIVATE_KEY"
-    ]
+    "nostr": ["NOSTR_PRIVATE_KEY"]
   },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
     "properties": {}
-  },
-  "channelConfigs": {
-    "nostr": {
-      "schema": {
-        "$schema": "http://json-schema.org/draft-07/schema#",
-        "type": "object",
-        "properties": {
-          "name": {
-            "type": "string"
-          },
-          "defaultAccount": {
-            "type": "string"
-          },
-          "enabled": {
-            "type": "boolean"
-          },
-          "markdown": {
-            "type": "object",
-            "properties": {
-              "tables": {
-                "type": "string",
-                "enum": [
-                  "off",
-                  "bullets",
-                  "code",
-                  "block"
-                ]
-              }
-            },
-            "additionalProperties": false
-          },
-          "privateKey": {
-            "anyOf": [
-              {
-                "type": "string"
-              },
-              {
-                "oneOf": [
-                  {
-                    "type": "object",
-                    "properties": {
-                      "source": {
-                        "type": "string",
-                        "const": "env"
-                      },
-                      "provider": {
-                        "type": "string",
-                        "pattern": "^[a-z][a-z0-9_-]{0,63}$"
-                      },
-                      "id": {
-                        "type": "string",
-                        "pattern": "^[A-Z][A-Z0-9_]{0,127}$"
-                      }
-                    },
-                    "required": [
-                      "source",
-                      "provider",
-                      "id"
-                    ],
-                    "additionalProperties": false
-                  },
-                  {
-                    "type": "object",
-                    "properties": {
-                      "source": {
-                        "type": "string",
-                        "const": "file"
-                      },
-                      "provider": {
-                        "type": "string",
-                        "pattern": "^[a-z][a-z0-9_-]{0,63}$"
-                      },
-                      "id": {
-                        "type": "string"
-                      }
-                    },
-                    "required": [
-                      "source",
-                      "provider",
-                      "id"
-                    ],
-                    "additionalProperties": false
-                  },
-                  {
-                    "type": "object",
-                    "properties": {
-                      "source": {
-                        "type": "string",
-                        "const": "exec"
-                      },
-                      "provider": {
-                        "type": "string",
-                        "pattern": "^[a-z][a-z0-9_-]{0,63}$"
-                      },
-                      "id": {
-                        "type": "string"
-                      }
-                    },
-                    "required": [
-                      "source",
-                      "provider",
-                      "id"
-                    ],
-                    "additionalProperties": false
-                  }
-                ]
-              }
-            ]
-          },
-          "relays": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "dmPolicy": {
-            "type": "string",
-            "enum": [
-              "pairing",
-              "allowlist",
-              "open",
-              "disabled"
-            ]
-          },
-          "allowFrom": {
-            "type": "array",
-            "items": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "number"
-                }
-              ]
-            }
-          },
-          "profile": {
-            "type": "object",
-            "properties": {
-              "name": {
-                "type": "string",
-                "maxLength": 256
-              },
-              "displayName": {
-                "type": "string",
-                "maxLength": 256
-              },
-              "about": {
-                "type": "string",
-                "maxLength": 2000
-              },
-              "picture": {
-                "type": "string",
-                "format": "uri"
-              },
-              "banner": {
-                "type": "string",
-                "format": "uri"
-              },
-              "website": {
-                "type": "string",
-                "format": "uri"
-              },
-              "nip05": {
-                "type": "string"
-              },
-              "lud16": {
-                "type": "string"
-              }
-            },
-            "additionalProperties": false
-          }
-        },
-        "additionalProperties": false
-      },
-      "label": "Nostr",
-      "description": "Decentralized protocol; encrypted DMs via NIP-04."
-    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kodelyth/nostr",
-  "version": "2026.5.39",
+  "version": "2026.5.42",
   "description": "Klaw Nostr channel plugin for NIP-04 encrypted DMs",
   "repository": {
     "type": "git",
@@ -13,7 +13,7 @@
   },
   "devDependencies": {
     "@kodelyth/plugin-sdk": "1.0.1",
-    "@kodelyth/klaw": "2026.5.41"
+    "@kodelyth/klaw": "2026.5.42"
   },
   "peerDependencies": {
     "@kodelyth/klaw": ">=2026.5.19"
@@ -25,9 +25,9 @@
   },
   "klaw": {
     "extensions": [
-      "./index.js"
+      "./index.ts"
     ],
-    "setupEntry": "./setup-entry.js",
+    "setupEntry": "./setup-entry.ts",
     "channel": {
       "id": "nostr",
       "label": "Nostr",

package/runtime-api.ts

@@ -0,0 +1,6 @@
+// Private runtime barrel for the bundled Nostr extension.
+// Keep this barrel thin and aligned with the local extension surface.
+
+export type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+export { getPluginRuntimeGatewayRequestScope } from "klaw/plugin-sdk/plugin-runtime";
+export type { PluginRuntime } from "klaw/plugin-sdk/runtime-store";

package/setup-api.ts

@@ -0,0 +1 @@
+export { nostrSetupAdapter, nostrSetupWizard } from "./src/setup-surface.js";

package/setup-entry.ts

@@ -0,0 +1,9 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+
+export default defineBundledChannelSetupEntry({
+  importMetaUrl: import.meta.url,
+  plugin: {
+    specifier: "./setup-plugin-api.js",
+    exportName: "nostrSetupPlugin",
+  },
+});

package/setup-plugin-api.ts

@@ -0,0 +1,3 @@
+// Keep bundled setup entry imports narrow so setup loads do not pull the
+// broader Nostr runtime plugin surface.
+export { nostrSetupPlugin } from "./src/channel.setup.js";

package/src/channel-api.ts

@@ -0,0 +1,11 @@
+export {
+  buildChannelConfigSchema,
+  DEFAULT_ACCOUNT_ID,
+  formatPairingApproveHint,
+  type ChannelPlugin,
+} from "klaw/plugin-sdk/channel-plugin-common";
+export type { ChannelOutboundAdapter } from "klaw/plugin-sdk/channel-contract";
+export {
+  collectStatusIssuesFromLastError,
+  createDefaultChannelRuntimeState,
+} from "klaw/plugin-sdk/status-helpers";

package/src/channel.inbound.test.ts

@@ -0,0 +1,187 @@
+import { createStartAccountContext } from "klaw/plugin-sdk/channel-test-helpers";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { PluginRuntime } from "../runtime-api.js";
+import { startNostrGatewayAccount } from "./gateway.js";
+import { setNostrRuntime } from "./runtime.js";
+import { buildResolvedNostrAccount } from "./test-fixtures.js";
+
+const mocks = vi.hoisted(() => ({
+  normalizePubkey: vi.fn((value: string) =>
+    value
+      .trim()
+      .replace(/^nostr:/i, "")
+      .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(() => "bot-pubkey"),
+  normalizePubkey: mocks.normalizePubkey,
+}));
+
+function createMockBus() {
+  return {
+    sendDm: vi.fn(async () => {}),
+    close: vi.fn(),
+    getMetrics: vi.fn(() => ({ counters: {} })),
+    publishProfile: vi.fn(),
+    getProfileState: vi.fn(async () => null),
+  };
+}
+
+function createRuntimeHarness() {
+  const recordInboundSession = vi.fn(async () => {});
+  const dispatchReplyWithBufferedBlockDispatcher = vi.fn(async ({ dispatcherOptions }) => {
+    await dispatcherOptions.deliver({ text: "|a|b|" });
+  });
+  const runtime = {
+    channel: {
+      text: {
+        resolveMarkdownTableMode: vi.fn(() => "off"),
+        convertMarkdownTables: vi.fn((text: string) => `converted:${text}`),
+      },
+      commands: {
+        shouldComputeCommandAuthorized: vi.fn(() => true),
+        resolveCommandAuthorizedFromAuthorizers: vi.fn(() => true),
+      },
+      routing: {
+        resolveAgentRoute: vi.fn(({ accountId, peer }) => ({
+          agentId: "agent-nostr",
+          accountId,
+          sessionKey: `nostr:${peer.id}`,
+        })),
+      },
+      session: {
+        resolveStorePath: vi.fn(() => "/tmp/nostr-session-store"),
+        readSessionUpdatedAt: vi.fn(() => undefined),
+        recordInboundSession,
+      },
+      reply: {
+        formatAgentEnvelope: vi.fn(({ body }) => `envelope:${body}`),
+        resolveEnvelopeFormatOptions: vi.fn(() => ({ mode: "agent" })),
+        finalizeInboundContext: vi.fn((ctx) => ctx),
+        dispatchReplyWithBufferedBlockDispatcher,
+      },
+      pairing: {
+        readAllowFromStore: vi.fn(async () => []),
+        upsertPairingRequest: vi.fn(async () => ({ code: "PAIR1234", created: true })),
+      },
+    },
+  } as unknown as PluginRuntime;
+
+  return {
+    runtime,
+    recordInboundSession,
+    dispatchReplyWithBufferedBlockDispatcher,
+  };
+}
+
+async function startGatewayHarness(params: {
+  account: ReturnType<typeof buildResolvedNostrAccount>;
+  cfg?: Parameters<typeof createStartAccountContext>[0]["cfg"];
+}) {
+  const harness = createRuntimeHarness();
+  const bus = createMockBus();
+  setNostrRuntime(harness.runtime);
+  mocks.startNostrBus.mockResolvedValueOnce(bus as never);
+
+  const cleanup = (await startNostrGatewayAccount(
+    createStartAccountContext({
+      account: params.account,
+      cfg: params.cfg,
+    }),
+  )) as { stop: () => void };
+
+  return { harness, bus, cleanup };
+}
+
+function mockCallArg(mock: ReturnType<typeof vi.fn>, callIndex = 0, argIndex = 0): unknown {
+  const call = mock.mock.calls[callIndex];
+  if (!call) {
+    throw new Error(`Expected mock call ${callIndex}`);
+  }
+  return call[argIndex];
+}
+
+describe("nostr inbound gateway path", () => {
+  afterEach(() => {
+    mocks.normalizePubkey.mockClear();
+    mocks.startNostrBus.mockReset();
+  });
+
+  it("issues a pairing reply before decrypt for unknown senders", async () => {
+    const { cleanup } = await startGatewayHarness({
+      account: buildResolvedNostrAccount({
+        config: { dmPolicy: "pairing", allowFrom: [] },
+      }),
+    });
+
+    const options = mockCallArg(mocks.startNostrBus) as {
+      authorizeSender: (params: {
+        senderPubkey: string;
+        reply: (text: string) => Promise<void>;
+      }) => Promise<string>;
+    };
+    const sendPairingReply = vi.fn(async (_text: string) => {});
+
+    await expect(
+      options.authorizeSender({
+        senderPubkey: "nostr:UNKNOWN-SENDER",
+        reply: sendPairingReply,
+      }),
+    ).resolves.toBe("pairing");
+    expect(sendPairingReply).toHaveBeenCalledTimes(1);
+    expect(mockCallArg(sendPairingReply)).toContain("Pairing code:");
+
+    cleanup.stop();
+  });
+
+  it("routes allowed DMs through the standard reply pipeline", async () => {
+    const { harness, cleanup } = await startGatewayHarness({
+      account: buildResolvedNostrAccount({
+        publicKey: "bot-pubkey",
+        config: { dmPolicy: "allowlist", allowFrom: ["nostr:sender-pubkey"] },
+      }),
+      cfg: {
+        session: { store: { type: "jsonl" } },
+        commands: { useAccessGroups: true },
+      } as never,
+    });
+
+    const options = mockCallArg(mocks.startNostrBus) as {
+      onMessage: (
+        senderPubkey: string,
+        text: string,
+        reply: (text: string) => Promise<void>,
+        meta: { eventId: string; createdAt: number },
+      ) => Promise<void>;
+    };
+    const sendReply = vi.fn(async (_text: string) => {});
+
+    await options.onMessage("sender-pubkey", "hello from nostr", sendReply, {
+      eventId: "event-123",
+      createdAt: 1_710_000_000,
+    });
+
+    expect(harness.recordInboundSession).toHaveBeenCalledTimes(1);
+    expect(harness.dispatchReplyWithBufferedBlockDispatcher).toHaveBeenCalledTimes(1);
+    const ctx = (
+      mockCallArg(harness.dispatchReplyWithBufferedBlockDispatcher) as {
+        ctx?: Record<string, unknown>;
+      }
+    ).ctx;
+    expect(ctx?.BodyForAgent).toBe("hello from nostr");
+    expect(ctx?.SenderId).toBe("sender-pubkey");
+    expect(ctx?.MessageSid).toBe("event-123");
+    expect(ctx?.CommandAuthorized).toBe(true);
+    expect(sendReply).toHaveBeenCalledWith("converted:|a|b|");
+
+    cleanup.stop();
+  });
+});