@elizaos/plugin-nostr 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/service.js

@@ -0,0 +1,980 @@
+/**
+ * Nostr service implementation for ElizaOS.
+ */
+import { ChannelType, createUniqueUuid, logger, Service, } from "@elizaos/core";
+import { finalizeEvent, getPublicKey, SimplePool, verifyEvent, } from "nostr-tools";
+import { decrypt, encrypt } from "nostr-tools/nip04";
+import { listNostrAccountIds, normalizeNostrAccountId, readNostrAccountId, resolveDefaultNostrAccountId, resolveNostrAccountSettings, } from "./accounts.js";
+import { NOSTR_SERVICE_NAME, NostrConfigurationError, NostrEventTypes, normalizePubkey, pubkeyToNpub, splitMessageForNostr, validatePrivateKey, } from "./types.js";
+const NOSTR_CONNECTOR_CONTEXTS = ["social", "connectors"];
+const NOSTR_CONNECTOR_CAPABILITIES = [
+    "send_message",
+    "fetch_messages",
+    "resolve_targets",
+    "user_context",
+];
+function getNostrTargetMetadata(target) {
+    const metadata = target.metadata;
+    return metadata && typeof metadata === "object"
+        ? metadata
+        : undefined;
+}
+/**
+ * Append agent-generated attachment URLs to Nostr text (#8876). Nostr has no
+ * separate attachment field — kind:1 notes and DMs carry media as URLs in the
+ * content, which clients render inline. So a generated/sent attachment becomes a
+ * URL appended to the text rather than being dropped. http(s) URLs only.
+ */
+function appendNostrAttachmentUrls(text, content) {
+    const urls = Array.isArray(content.attachments)
+        ? content.attachments
+            .map((media) => (typeof media?.url === "string" ? media.url.trim() : ""))
+            .filter((url) => /^https?:\/\//i.test(url))
+        : [];
+    if (urls.length === 0)
+        return text;
+    return [text, ...urls].filter(Boolean).join("\n");
+}
+function clampLimit(value, defaultValue, max) {
+    if (!Number.isFinite(value)) {
+        return defaultValue;
+    }
+    return Math.min(Math.max(1, Math.floor(value)), max);
+}
+function isSafeRelayUrl(relay) {
+    try {
+        const parsed = new URL(relay);
+        return ((parsed.protocol === "wss:" || parsed.protocol === "ws:") &&
+            !parsed.username &&
+            !parsed.password);
+    }
+    catch {
+        return false;
+    }
+}
+function isEventShape(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const event = value;
+    return (typeof event.id === "string" &&
+        typeof event.pubkey === "string" &&
+        typeof event.content === "string" &&
+        typeof event.kind === "number" &&
+        Number.isFinite(event.kind) &&
+        typeof event.created_at === "number" &&
+        Number.isFinite(event.created_at) &&
+        Array.isArray(event.tags) &&
+        typeof event.sig === "string");
+}
+function normalizeEventTags(tags) {
+    if (!Array.isArray(tags))
+        return [];
+    return tags
+        .filter(Array.isArray)
+        .map((tag) => tag.filter((value) => typeof value === "string"))
+        .filter((tag) => tag.length > 0);
+}
+function createdAtMs(event) {
+    return Number.isFinite(event.created_at) && event.created_at > 0
+        ? event.created_at * 1000
+        : Date.now();
+}
+export class NostrService extends Service {
+    static serviceType = NOSTR_SERVICE_NAME;
+    capabilityDescription = "Provides Nostr protocol integration for encrypted direct messages";
+    settings = null;
+    pool = null;
+    privateKey = null;
+    connected = false;
+    seenEventIds = new Set();
+    accountServices = new Map();
+    /**
+     * Start the Nostr service.
+     */
+    static async start(runtime) {
+        logger.info("Starting Nostr service...");
+        const service = new NostrService(runtime);
+        await service.initialize();
+        return service;
+    }
+    static registerSendHandlers(runtime, serviceInstance) {
+        if (!serviceInstance) {
+            return;
+        }
+        for (const accountService of serviceInstance.getAccountServiceList()) {
+            const accountId = accountService.getAccountId(runtime);
+            accountService.registerPostConnector(runtime);
+            const sendHandler = accountService.handleSendMessage.bind(accountService);
+            if (typeof runtime.registerMessageConnector === "function") {
+                const registration = {
+                    source: "nostr",
+                    accountId,
+                    label: "Nostr",
+                    description: "Nostr encrypted DM connector using NIP-04.",
+                    capabilities: [...NOSTR_CONNECTOR_CAPABILITIES],
+                    supportedTargetKinds: ["user", "contact"],
+                    contexts: [...NOSTR_CONNECTOR_CONTEXTS],
+                    metadata: {
+                        accountId,
+                        service: NOSTR_SERVICE_NAME,
+                    },
+                    resolveTargets: accountService.resolveConnectorTargets.bind(accountService),
+                    listRecentTargets: accountService.listRecentConnectorTargets.bind(accountService),
+                    getUserContext: accountService.getConnectorUserContext.bind(accountService),
+                    fetchMessages: accountService.fetchConnectorMessages.bind(accountService),
+                    contentShaping: {
+                        systemPromptFragment: "For Nostr encrypted DMs, keep messages concise. Long messages may be split by the connector for relay delivery.",
+                        constraints: {
+                            supportsMarkdown: false,
+                            channelType: ChannelType.DM,
+                        },
+                    },
+                    sendHandler,
+                };
+                runtime.registerMessageConnector(registration);
+                runtime.logger.info({ src: "plugin:nostr", agentId: runtime.agentId }, "Registered Nostr DM connector");
+            }
+        }
+    }
+    registerPostConnector(runtime) {
+        const withPostConnector = runtime;
+        if (typeof withPostConnector.registerPostConnector !== "function") {
+            return;
+        }
+        const accountId = this.getAccountId(runtime);
+        withPostConnector.registerPostConnector({
+            source: "nostr",
+            accountId,
+            label: "Nostr",
+            description: "Nostr public note connector for publishing kind:1 notes, reading relay feeds, and NIP-50 relay search where supported.",
+            capabilities: ["post", "fetch_feed", "search_posts"],
+            contexts: ["social", "social_posting", "connectors"],
+            metadata: {
+                accountId,
+                service: NOSTR_SERVICE_NAME,
+            },
+            postHandler: this.handleSendPost.bind(this),
+            fetchFeed: this.fetchConnectorFeed.bind(this),
+            searchPosts: this.searchConnectorPosts.bind(this),
+            contentShaping: {
+                systemPromptFragment: "For Nostr notes, write plain public text. Hashtags and nostr: references are acceptable when useful; avoid Markdown-specific formatting.",
+                constraints: {
+                    supportsMarkdown: false,
+                    channelType: ChannelType.FEED,
+                },
+            },
+        });
+        runtime.logger.info({ src: "plugin:nostr", agentId: runtime.agentId }, "Registered Nostr post connector");
+    }
+    /**
+     * Initialize the service.
+     */
+    async initialize() {
+        const startedAccounts = [];
+        for (const accountId of listNostrAccountIds(this.runtime)) {
+            const settings = resolveNostrAccountSettings(this.runtime, accountId);
+            if (settings.enabled === false) {
+                continue;
+            }
+            const accountService = new NostrService(this.runtime);
+            await accountService.initializeAccount(accountId);
+            this.accountServices.set(accountService.getAccountId(), accountService);
+            startedAccounts.push(accountService.getAccountId());
+        }
+        if (startedAccounts.length === 0) {
+            logger.warn("No enabled Nostr accounts configured");
+            return;
+        }
+        logger.info(`Nostr service started ${startedAccounts.length} account(s): ${startedAccounts.join(", ")}`);
+    }
+    async initializeAccount(accountId) {
+        this.settings = this.loadSettings(accountId);
+        this.validateSettings();
+        // Initialize private key
+        this.privateKey = validatePrivateKey(this.settings.privateKey);
+        // Initialize SimplePool
+        this.pool = new SimplePool();
+        // Start subscription
+        await this.startSubscription();
+        this.connected = true;
+        logger.info(`Nostr service started (pubkey: ${this.settings.publicKey.slice(0, 16)}...)`);
+        this.runtime.emitEvent(NostrEventTypes.CONNECTION_READY, {
+            runtime: this.runtime,
+            service: this,
+            accountId: this.getAccountId(),
+        });
+    }
+    /**
+     * Stop the Nostr service.
+     */
+    async stop() {
+        logger.info("Stopping Nostr service...");
+        if (this.accountServices.size > 0) {
+            await Promise.all(Array.from(this.accountServices.values()).map((service) => service.stop()));
+            this.accountServices.clear();
+            logger.info("Nostr service stopped");
+            return;
+        }
+        this.connected = false;
+        if (this.pool) {
+            this.pool.close(this.settings?.relays || []);
+            this.pool = null;
+        }
+        this.privateKey = null;
+        this.seenEventIds.clear();
+        logger.info("Nostr service stopped");
+    }
+    getAccountServiceList() {
+        return this.accountServices.size > 0 ? Array.from(this.accountServices.values()) : [this];
+    }
+    getDefaultAccountService() {
+        if (!this.accountServices || this.accountServices.size === 0) {
+            return this;
+        }
+        const defaultAccountId = normalizeNostrAccountId(resolveDefaultNostrAccountId(this.runtime));
+        return (this.accountServices.get(defaultAccountId) ?? Array.from(this.accountServices.values())[0]);
+    }
+    getAccountService(accountId) {
+        if (!this.accountServices || this.accountServices.size === 0) {
+            const ownAccountId = this.getAccountId();
+            if (normalizeNostrAccountId(accountId) !== ownAccountId) {
+                throw new Error(`Nostr account '${accountId}' is not available in this service instance`);
+            }
+            return this;
+        }
+        const normalized = normalizeNostrAccountId(accountId);
+        const service = this.accountServices.get(normalized);
+        if (!service) {
+            throw new Error(`Nostr account '${normalized}' is not available`);
+        }
+        return service;
+    }
+    /**
+     * Load settings from runtime configuration.
+     */
+    loadSettings(accountId) {
+        const runtime = this.runtime;
+        if (!runtime) {
+            throw new NostrConfigurationError("Runtime not initialized");
+        }
+        const resolved = resolveNostrAccountSettings(runtime, accountId);
+        const allowFrom = resolved.allowFrom.map((p) => {
+            try {
+                return normalizePubkey(p.trim());
+            }
+            catch {
+                return p.trim();
+            }
+        });
+        // Derive public key
+        let publicKey = "";
+        if (resolved.privateKey) {
+            try {
+                const sk = validatePrivateKey(resolved.privateKey);
+                publicKey = getPublicKey(sk);
+            }
+            catch {
+                // Will be caught in validation
+            }
+        }
+        return {
+            ...resolved,
+            publicKey,
+            allowFrom,
+        };
+    }
+    /**
+     * Validate the settings.
+     */
+    validateSettings() {
+        const settings = this.settings;
+        if (!settings) {
+            throw new NostrConfigurationError("Settings not loaded");
+        }
+        if (!settings.privateKey) {
+            throw new NostrConfigurationError("NOSTR_PRIVATE_KEY is required", "NOSTR_PRIVATE_KEY");
+        }
+        if (!settings.publicKey) {
+            throw new NostrConfigurationError("Invalid private key - could not derive public key", "NOSTR_PRIVATE_KEY");
+        }
+        if (settings.relays.length === 0) {
+            throw new NostrConfigurationError("At least one relay is required", "NOSTR_RELAYS");
+        }
+        // Validate relay URLs
+        for (const relay of settings.relays) {
+            if (!isSafeRelayUrl(relay)) {
+                throw new NostrConfigurationError(`Invalid relay URL: ${relay}`, "NOSTR_RELAYS");
+            }
+        }
+    }
+    /**
+     * Start the DM subscription.
+     */
+    async startSubscription() {
+        const settings = this.settings;
+        const pool = this.pool;
+        const privateKey = this.privateKey;
+        if (!settings || !pool || !privateKey) {
+            throw new NostrConfigurationError("Service not properly initialized");
+        }
+        const pk = settings.publicKey;
+        const since = Math.floor(Date.now() / 1000) - 120; // Last 2 minutes
+        // Subscribe to DMs (kind:4)
+        const filter = { kinds: [4], "#p": [pk], since };
+        pool.subscribeMany(settings.relays, filter, {
+            onevent: async (event) => {
+                await this.handleEvent(event);
+            },
+            oneose: () => {
+                logger.debug("Nostr EOSE received - initial sync complete");
+            },
+        });
+        logger.info(`Subscribed to ${settings.relays.length} relay(s)`);
+    }
+    /**
+     * Handle an incoming event.
+     */
+    async handleEvent(event) {
+        if (!isEventShape(event)) {
+            logger.warn("Ignoring malformed Nostr event payload");
+            return;
+        }
+        const settings = this.settings;
+        const privateKey = this.privateKey;
+        if (!settings || !privateKey) {
+            return;
+        }
+        // Dedupe
+        if (this.seenEventIds.has(event.id)) {
+            return;
+        }
+        this.seenEventIds.add(event.id);
+        // Limit seen set size
+        if (this.seenEventIds.size > 10000) {
+            const toDelete = Array.from(this.seenEventIds).slice(0, 5000);
+            for (const id of toDelete) {
+                this.seenEventIds.delete(id);
+            }
+        }
+        // Skip self-messages
+        if (event.pubkey === settings.publicKey) {
+            return;
+        }
+        // Verify signature
+        if (!verifyEvent(event)) {
+            logger.warn(`Invalid signature on event ${event.id}`);
+            return;
+        }
+        // Check if this is addressed to us
+        const isToUs = event.tags.some((t) => t[0] === "p" && t[1] === settings.publicKey);
+        if (!isToUs) {
+            return;
+        }
+        // Check DM policy
+        if (settings.dmPolicy === "disabled") {
+            logger.debug(`DM from ${event.pubkey} blocked - DMs disabled`);
+            return;
+        }
+        if (settings.dmPolicy === "allowlist") {
+            const allowed = settings.allowFrom.includes(event.pubkey);
+            if (!allowed) {
+                logger.debug(`DM from ${event.pubkey} blocked - not in allowlist`);
+                return;
+            }
+        }
+        // Decrypt the message (NIP-04)
+        let plaintext;
+        try {
+            logger.debug({ src: "plugin:nostr", op: "nip04:decrypt", from: event.pubkey }, "Decrypting Nostr DM");
+            plaintext = decrypt(privateKey, event.pubkey, event.content);
+        }
+        catch (err) {
+            logger.warn({ src: "plugin:nostr", op: "nip04:decrypt", from: event.pubkey, err: String(err) }, "Failed to decrypt Nostr DM");
+            return;
+        }
+        logger.debug(`Received DM from ${event.pubkey.slice(0, 8)}...: ${plaintext.slice(0, 50)}...`);
+        // Emit event
+        if (this.runtime) {
+            this.runtime.emitEvent(NostrEventTypes.MESSAGE_RECEIVED, {
+                runtime: this.runtime,
+                accountId: this.getAccountId(),
+                from: event.pubkey,
+                text: plaintext,
+                eventId: event.id,
+                createdAt: event.created_at,
+            });
+        }
+    }
+    /**
+     * Check if the service is connected.
+     */
+    isConnected() {
+        if (this.accountServices.size > 0) {
+            return Array.from(this.accountServices.values()).some((service) => service.isConnected());
+        }
+        return this.connected;
+    }
+    /**
+     * Get the bot's public key in hex format.
+     */
+    getPublicKey() {
+        if (this.accountServices.size > 0) {
+            return this.getDefaultAccountService().getPublicKey();
+        }
+        return this.settings?.publicKey || "";
+    }
+    getAccountId(runtime) {
+        if (this.accountServices?.size > 0) {
+            return this.getDefaultAccountService().getAccountId(runtime);
+        }
+        return normalizeNostrAccountId(this.settings?.accountId ?? (runtime ? resolveDefaultNostrAccountId(runtime) : undefined));
+    }
+    /**
+     * Get the bot's public key in npub format.
+     */
+    getNpub() {
+        const pk = this.getPublicKey();
+        return pk ? pubkeyToNpub(pk) : "";
+    }
+    /**
+     * Get connected relays.
+     */
+    getRelays() {
+        if (this.accountServices.size > 0) {
+            return this.getDefaultAccountService().getRelays();
+        }
+        return this.settings?.relays || [];
+    }
+    async handleSendMessage(_runtime, target, content) {
+        const requestedAccountId = normalizeNostrAccountId(target.accountId ?? readNostrAccountId(content, target) ?? this.getAccountId());
+        if (this.accountServices.size > 0) {
+            await this.getAccountService(requestedAccountId).handleSendMessage(_runtime, target, content);
+            return;
+        }
+        if (requestedAccountId !== this.getAccountId()) {
+            throw new Error(`Nostr account '${requestedAccountId}' is not available in this service instance`);
+        }
+        const text = appendNostrAttachmentUrls(typeof content.text === "string" ? content.text.trim() : "", content);
+        if (!text) {
+            throw new Error("Nostr DM connector requires non-empty text content or an attachment.");
+        }
+        const metadata = getNostrTargetMetadata(target);
+        const targetPubkey = (typeof metadata?.nostrPubkey === "string" ? metadata.nostrPubkey : undefined) ??
+            (typeof target.entityId === "string" ? target.entityId : undefined) ??
+            target.channelId ??
+            target.threadId;
+        if (!targetPubkey) {
+            throw new Error("Nostr DM connector requires a pubkey target.");
+        }
+        const chunks = splitMessageForNostr(text);
+        for (const chunk of chunks) {
+            const result = await this.sendDm({ toPubkey: targetPubkey, text: chunk });
+            if (!result.success) {
+                throw new Error(result.error ?? "Failed to send Nostr DM");
+            }
+        }
+    }
+    async handleSendPost(runtime, content) {
+        const requestedAccountId = normalizeNostrAccountId(readNostrAccountId(content) ?? this.getAccountId());
+        if (this.accountServices.size > 0) {
+            return this.getAccountService(requestedAccountId).handleSendPost(runtime, content);
+        }
+        if (requestedAccountId !== this.getAccountId()) {
+            throw new Error(`Nostr account '${requestedAccountId}' is not available in this service instance`);
+        }
+        const text = appendNostrAttachmentUrls(typeof content.text === "string" ? content.text.trim() : "", content);
+        if (!text) {
+            throw new Error("Nostr post connector requires non-empty text content or an attachment.");
+        }
+        const result = await this.publishNote(text);
+        if (!result.success || !result.eventId) {
+            throw new Error(result.error ?? "Failed to publish Nostr note");
+        }
+        const event = {
+            id: result.eventId,
+            pubkey: this.getPublicKey(),
+            kind: 1,
+            content: text,
+            created_at: Math.floor(Date.now() / 1000),
+            tags: [],
+            sig: "",
+        };
+        return this.nostrEventToPostMemory(runtime, event);
+    }
+    async fetchConnectorFeed(context, params = {}) {
+        const settings = this.settings;
+        const pool = this.pool;
+        if (!settings || !pool) {
+            return [];
+        }
+        const target = params.target ?? context.target;
+        const metadata = target ? getNostrTargetMetadata(target) : undefined;
+        const author = (typeof metadata?.nostrPubkey === "string" ? metadata.nostrPubkey : undefined) ??
+            (typeof target?.entityId === "string" ? target.entityId : undefined);
+        const normalizedAuthor = author ? normalizePubkey(author) : undefined;
+        const filter = {
+            kinds: [1],
+            limit: clampLimit(params.limit, 25, 100),
+            ...(normalizedAuthor ? { authors: [normalizedAuthor] } : {}),
+            ...(params.cursor && Number.isFinite(Number(params.cursor))
+                ? { until: Number(params.cursor) }
+                : {}),
+        };
+        const events = await pool.querySync(settings.relays, filter, { maxWait: 3000 });
+        return events
+            .sort((a, b) => b.created_at - a.created_at)
+            .map((event) => this.nostrEventToPostMemory(context.runtime, event));
+    }
+    async searchConnectorPosts(context, params) {
+        const query = params.query.trim();
+        if (!query) {
+            throw new Error("Nostr searchPosts connector requires a query.");
+        }
+        const settings = this.settings;
+        const pool = this.pool;
+        if (!settings || !pool) {
+            return [];
+        }
+        const filter = {
+            kinds: [1],
+            search: query,
+            limit: clampLimit(params.limit, 25, 100),
+            ...(params.cursor && Number.isFinite(Number(params.cursor))
+                ? { until: Number(params.cursor) }
+                : {}),
+        };
+        const events = await pool.querySync(settings.relays, filter, { maxWait: 3000 });
+        return events
+            .sort((a, b) => b.created_at - a.created_at)
+            .map((event) => this.nostrEventToPostMemory(context.runtime, event));
+    }
+    async fetchConnectorMessages(context, params = {}) {
+        const settings = this.settings;
+        const pool = this.pool;
+        const privateKey = this.privateKey;
+        if (!settings || !pool || !privateKey) {
+            return [];
+        }
+        const target = params.target ?? context.target;
+        const metadata = target ? getNostrTargetMetadata(target) : undefined;
+        const targetPubkeyRaw = (typeof metadata?.nostrPubkey === "string" ? metadata.nostrPubkey : undefined) ??
+            (typeof target?.entityId === "string" ? target.entityId : undefined);
+        const targetPubkey = targetPubkeyRaw ? normalizePubkey(targetPubkeyRaw) : undefined;
+        const limit = clampLimit(params.limit, 25, 100);
+        const filters = [
+            {
+                kinds: [4],
+                "#p": [settings.publicKey],
+                ...(targetPubkey ? { authors: [targetPubkey] } : {}),
+                limit,
+            },
+            ...(targetPubkey
+                ? [
+                    {
+                        kinds: [4],
+                        authors: [settings.publicKey],
+                        "#p": [targetPubkey],
+                        limit,
+                    },
+                ]
+                : []),
+        ];
+        const byId = new Map();
+        for (const filter of filters) {
+            const events = await pool.querySync(settings.relays, filter, { maxWait: 3000 });
+            for (const event of events) {
+                byId.set(event.id, event);
+            }
+        }
+        const memories = [];
+        for (const event of Array.from(byId.values()).sort((a, b) => b.created_at - a.created_at)) {
+            const isOwn = event.pubkey === settings.publicKey;
+            const peerPubkey = isOwn ? event.tags.find((tag) => tag[0] === "p")?.[1] : event.pubkey;
+            if (!peerPubkey) {
+                continue;
+            }
+            try {
+                const plaintext = decrypt(privateKey, peerPubkey, event.content);
+                memories.push(this.nostrEventToDmMemory(context.runtime, event, plaintext, peerPubkey));
+            }
+            catch (error) {
+                logger.debug({
+                    src: "plugin:nostr",
+                    op: "fetchConnectorMessages",
+                    eventId: event.id,
+                    error: error instanceof Error ? error.message : String(error),
+                }, "Skipping Nostr DM that could not be decrypted");
+            }
+            if (memories.length >= limit) {
+                break;
+            }
+        }
+        return memories;
+    }
+    async resolveConnectorTargets(query, _context) {
+        const trimmed = query.trim();
+        if (!trimmed) {
+            return this.listRecentConnectorTargets(_context);
+        }
+        let pubkey;
+        try {
+            pubkey = normalizePubkey(trimmed);
+        }
+        catch {
+            return [];
+        }
+        return [this.buildPubkeyTarget(pubkey, 1)];
+    }
+    async listRecentConnectorTargets(_context) {
+        const allowFrom = this.settings?.allowFrom ?? [];
+        return allowFrom.map((pubkey, index) => this.buildPubkeyTarget(pubkey, 0.8 - index * 0.01));
+    }
+    async getConnectorUserContext(entityId, _context) {
+        let pubkey;
+        try {
+            pubkey = normalizePubkey(entityId);
+        }
+        catch {
+            return null;
+        }
+        return {
+            entityId,
+            label: pubkeyToNpub(pubkey),
+            aliases: [pubkey, pubkeyToNpub(pubkey)],
+            handles: {
+                nostr: pubkeyToNpub(pubkey),
+            },
+            metadata: {
+                accountId: this.getAccountId(),
+                nostrPubkey: pubkey,
+                relays: this.getRelays(),
+            },
+        };
+    }
+    nostrEventToPostMemory(runtime, event) {
+        const createdAt = createdAtMs(event);
+        const entityId = event.pubkey === runtime.agentId
+            ? runtime.agentId
+            : createUniqueUuid(runtime, `nostr:user:${event.pubkey}`);
+        const roomId = createUniqueUuid(runtime, `nostr:feed:${event.pubkey}`);
+        return {
+            id: createUniqueUuid(runtime, `nostr:note:${event.id}`),
+            agentId: runtime.agentId,
+            entityId,
+            roomId,
+            createdAt,
+            content: {
+                text: event.content,
+                source: "nostr",
+                url: `nostr:${event.id}`,
+                channelType: ChannelType.FEED,
+            },
+            metadata: {
+                type: "message",
+                source: "nostr",
+                accountId: this.getAccountId(runtime),
+                provider: "nostr",
+                timestamp: createdAt,
+                fromBot: event.pubkey === this.getPublicKey(),
+                messageIdFull: event.id,
+                chatType: ChannelType.FEED,
+                sender: {
+                    id: event.pubkey,
+                    username: pubkeyToNpub(event.pubkey),
+                },
+                nostr: {
+                    accountId: this.getAccountId(runtime),
+                    eventId: event.id,
+                    pubkey: event.pubkey,
+                    npub: pubkeyToNpub(event.pubkey),
+                    kind: event.kind,
+                    tags: normalizeEventTags(event.tags),
+                },
+            },
+        };
+    }
+    nostrEventToDmMemory(runtime, event, plaintext, peerPubkey) {
+        const createdAt = createdAtMs(event);
+        const senderId = event.pubkey;
+        const entityId = senderId === runtime.agentId
+            ? runtime.agentId
+            : createUniqueUuid(runtime, `nostr:user:${senderId}`);
+        const roomId = createUniqueUuid(runtime, `nostr:dm:${peerPubkey}`);
+        return {
+            id: createUniqueUuid(runtime, `nostr:dm:${event.id}`),
+            agentId: runtime.agentId,
+            entityId,
+            roomId,
+            createdAt,
+            content: {
+                text: plaintext,
+                source: "nostr",
+                channelType: ChannelType.DM,
+            },
+            metadata: {
+                type: "message",
+                source: "nostr",
+                accountId: this.getAccountId(runtime),
+                provider: "nostr",
+                timestamp: createdAt,
+                fromBot: senderId === this.getPublicKey(),
+                messageIdFull: event.id,
+                chatType: ChannelType.DM,
+                sender: {
+                    id: senderId,
+                    username: pubkeyToNpub(senderId),
+                },
+                nostr: {
+                    accountId: this.getAccountId(runtime),
+                    eventId: event.id,
+                    pubkey: senderId,
+                    npub: pubkeyToNpub(senderId),
+                    peerPubkey,
+                    peerNpub: pubkeyToNpub(peerPubkey),
+                    kind: event.kind,
+                    tags: normalizeEventTags(event.tags),
+                },
+            },
+        };
+    }
+    buildPubkeyTarget(pubkey, score) {
+        return {
+            target: {
+                source: "nostr",
+                accountId: this.getAccountId(),
+                entityId: pubkey,
+            },
+            label: pubkeyToNpub(pubkey),
+            kind: "user",
+            description: "Nostr encrypted DM recipient",
+            score,
+            contexts: [...NOSTR_CONNECTOR_CONTEXTS],
+            metadata: {
+                accountId: this.getAccountId(),
+                nostrPubkey: pubkey,
+            },
+        };
+    }
+    /**
+     * Send a DM to a pubkey.
+     */
+    async sendDm(options) {
+        if (this.accountServices.size > 0) {
+            const accountId = normalizeNostrAccountId(options.accountId ?? this.getAccountId());
+            return this.getAccountService(accountId).sendDm(options);
+        }
+        const settings = this.settings;
+        const pool = this.pool;
+        const privateKey = this.privateKey;
+        if (!settings || !pool || !privateKey) {
+            return {
+                success: false,
+                error: "Service not initialized",
+            };
+        }
+        const text = typeof options.text === "string" ? options.text.trim() : "";
+        if (!text) {
+            return {
+                success: false,
+                error: "DM content cannot be empty",
+            };
+        }
+        // Normalize the target pubkey
+        let toPubkey;
+        try {
+            toPubkey = normalizePubkey(options.toPubkey);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Invalid target pubkey: ${err}`,
+            };
+        }
+        // Encrypt the message (NIP-04)
+        let ciphertext;
+        try {
+            logger.debug({ src: "plugin:nostr", op: "nip04:encrypt", to: toPubkey }, "Encrypting Nostr DM");
+            ciphertext = encrypt(privateKey, toPubkey, text);
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `Encryption failed: ${err}`,
+            };
+        }
+        // Create the event
+        const event = finalizeEvent({
+            kind: 4,
+            content: ciphertext,
+            tags: [["p", toPubkey]],
+            created_at: Math.floor(Date.now() / 1000),
+        }, privateKey);
+        // Publish to relays
+        const successRelays = [];
+        const errors = [];
+        for (const relay of settings.relays) {
+            try {
+                logger.debug({ src: "plugin:nostr", op: "pool.publish", kind: 4, relay, eventId: event.id }, "Publishing Nostr DM event to relay");
+                await pool.publish([relay], event);
+                successRelays.push(relay);
+            }
+            catch (err) {
+                errors.push(`${relay}: ${err}`);
+            }
+        }
+        if (successRelays.length === 0) {
+            return {
+                success: false,
+                error: `Failed to publish to any relay: ${errors.join("; ")}`,
+            };
+        }
+        logger.debug(`DM sent to ${toPubkey.slice(0, 8)}... via ${successRelays.length} relay(s)`);
+        if (this.runtime) {
+            this.runtime.emitEvent(NostrEventTypes.MESSAGE_SENT, {
+                runtime: this.runtime,
+                accountId: this.getAccountId(),
+                to: toPubkey,
+                eventId: event.id,
+                relays: successRelays,
+            });
+        }
+        return {
+            success: true,
+            eventId: event.id,
+            relays: successRelays,
+        };
+    }
+    /**
+     * Publish profile (kind:0).
+     */
+    async publishProfile(profile) {
+        if (this.accountServices.size > 0) {
+            const accountId = normalizeNostrAccountId(profile.accountId ?? this.getAccountId());
+            return this.getAccountService(accountId).publishProfile(profile);
+        }
+        const settings = this.settings;
+        const pool = this.pool;
+        const privateKey = this.privateKey;
+        if (!settings || !pool || !privateKey) {
+            return {
+                success: false,
+                error: "Service not initialized",
+            };
+        }
+        // Build profile content
+        const content = JSON.stringify({
+            name: profile.name,
+            display_name: profile.displayName,
+            about: profile.about,
+            picture: profile.picture,
+            banner: profile.banner,
+            nip05: profile.nip05,
+            lud16: profile.lud16,
+            website: profile.website,
+        });
+        // Create the event
+        const event = finalizeEvent({
+            kind: 0,
+            content,
+            tags: [],
+            created_at: Math.floor(Date.now() / 1000),
+        }, privateKey);
+        // Publish to relays
+        const successRelays = [];
+        const errors = [];
+        for (const relay of settings.relays) {
+            try {
+                logger.debug({ src: "plugin:nostr", op: "pool.publish", kind: 0, relay, eventId: event.id }, "Publishing Nostr profile event to relay");
+                await pool.publish([relay], event);
+                successRelays.push(relay);
+            }
+            catch (err) {
+                errors.push(`${relay}: ${err}`);
+            }
+        }
+        if (successRelays.length === 0) {
+            return {
+                success: false,
+                error: `Failed to publish profile to any relay: ${errors.join("; ")}`,
+            };
+        }
+        logger.info(`Profile published via ${successRelays.length} relay(s)`);
+        if (this.runtime) {
+            this.runtime.emitEvent(NostrEventTypes.PROFILE_PUBLISHED, {
+                runtime: this.runtime,
+                accountId: this.getAccountId(),
+                eventId: event.id,
+                relays: successRelays,
+            });
+        }
+        return {
+            success: true,
+            eventId: event.id,
+            relays: successRelays,
+        };
+    }
+    /**
+     * Publish a text note (kind:1).
+     */
+    async publishNote(text, tags = []) {
+        if (this.accountServices.size > 0) {
+            return this.getDefaultAccountService().publishNote(text, tags);
+        }
+        const settings = this.settings;
+        const pool = this.pool;
+        const privateKey = this.privateKey;
+        if (!settings || !pool || !privateKey) {
+            return {
+                success: false,
+                error: "Service not initialized",
+            };
+        }
+        const trimmed = text.trim();
+        if (!trimmed) {
+            return {
+                success: false,
+                error: "Note content cannot be empty",
+            };
+        }
+        const event = finalizeEvent({
+            kind: 1,
+            content: trimmed,
+            tags: normalizeEventTags(tags),
+            created_at: Math.floor(Date.now() / 1000),
+        }, privateKey);
+        const successRelays = [];
+        const errors = [];
+        for (const relay of settings.relays) {
+            try {
+                logger.debug({ src: "plugin:nostr", op: "pool.publish", kind: 1, relay, eventId: event.id }, "Publishing Nostr note to relay");
+                await pool.publish([relay], event);
+                successRelays.push(relay);
+            }
+            catch (err) {
+                errors.push(`${relay}: ${err}`);
+            }
+        }
+        if (successRelays.length === 0) {
+            return {
+                success: false,
+                error: `Failed to publish note to any relay: ${errors.join("; ")}`,
+            };
+        }
+        logger.info({ src: "plugin:nostr", op: "publishNote", eventId: event.id, relays: successRelays.length }, "Nostr note published");
+        return {
+            success: true,
+            eventId: event.id,
+            relays: successRelays,
+        };
+    }
+    /**
+     * Get the settings.
+     */
+    getSettings() {
+        if (this.accountServices.size > 0) {
+            return this.getDefaultAccountService().getSettings();
+        }
+        return this.settings;
+    }
+}
+//# sourceMappingURL=service.js.map