@tenex-chat/backend 0.9.1

package/src/services/mcp/mcpInstaller.ts

@@ -0,0 +1,130 @@
+import type { NDKMCPTool } from "@/events/NDKMCPTool";
+import { config } from "@/services/ConfigService";
+import type { MCPServerConfig } from "@/services/config/types";
+import { logger } from "@/utils/logger";
+
+/**
+ * Installs an MCP server from an NDKMCPTool event into a project's configuration
+ * @param metadataPath The project metadata path (~/.tenex/projects/{dTag})
+ */
+export async function installMCPServerFromEvent(
+    metadataPath: string,
+    mcpTool: NDKMCPTool
+): Promise<void> {
+    const serverName = mcpTool.slug;
+    const command = mcpTool.command;
+
+    if (!command) {
+        throw new Error(`MCP tool event ${mcpTool.id} is missing command tag`);
+    }
+
+    // Parse command and args
+    const [cmd, ...args] = command.split(" ");
+
+    // Build server config with event ID
+    const serverConfig: MCPServerConfig = {
+        command: cmd || "",
+        args,
+        description: mcpTool.description,
+        eventId: mcpTool.id, // Track the event ID
+    };
+
+    // Load existing MCP config from the metadata path
+    const mcpConfig = await config.loadTenexMCP(metadataPath);
+
+    // Check if this event ID is already installed (only if we have an event ID)
+    if (mcpTool.id && (await isMCPToolInstalled(metadataPath, mcpTool.id))) {
+        logger.info(`MCP tool with event ID ${mcpTool.id} already installed`, { metadataPath });
+        return;
+    }
+
+    // Check if server with same name already exists
+    if (mcpConfig.servers[serverName]) {
+        // If it exists without an event ID and we're adding one with an event ID, update it
+        if (!mcpConfig.servers[serverName].eventId && mcpTool.id) {
+            logger.info(`Updating existing MCP server '${serverName}' with event ID`, {
+                metadataPath,
+                eventId: mcpTool.id,
+            });
+        } else {
+            logger.info(`MCP server '${serverName}' already exists`, { metadataPath });
+            return;
+        }
+    }
+
+    // Add new server
+    mcpConfig.servers[serverName] = serverConfig;
+
+    // Save config directly to metadata path
+    await config.saveTenexMCP(metadataPath, mcpConfig);
+
+    logger.info(`Auto-installed MCP server: ${serverName}`, {
+        metadataPath,
+        command: cmd,
+        args,
+        eventId: mcpTool.id,
+    });
+}
+
+/**
+ * Checks if an MCP tool with a given event ID is already installed
+ * @param metadataPath The project metadata path (~/.tenex/projects/{dTag})
+ */
+export async function isMCPToolInstalled(metadataPath: string, eventId: string): Promise<boolean> {
+    // Load from the metadata path directly
+    const mcpConfig = await config.loadTenexMCP(metadataPath);
+
+    // Check if any server has this event ID
+    for (const serverConfig of Object.values(mcpConfig.servers)) {
+        if (serverConfig.eventId === eventId) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Gets all installed MCP tool event IDs (only those that have event IDs)
+ * @param metadataPath The project metadata path (~/.tenex/projects/{dTag})
+ */
+export async function getInstalledMCPEventIds(metadataPath: string): Promise<Set<string>> {
+    // Load from the metadata path directly
+    const mcpConfig = await config.loadTenexMCP(metadataPath);
+    const eventIds = new Set<string>();
+
+    for (const serverConfig of Object.values(mcpConfig.servers)) {
+        // Only add if eventId exists (some MCP tools are manually installed without event IDs)
+        if (serverConfig.eventId) {
+            eventIds.add(serverConfig.eventId);
+        }
+    }
+
+    return eventIds;
+}
+
+/**
+ * Removes an MCP server by its event ID
+ * @param metadataPath The project metadata path (~/.tenex/projects/{dTag})
+ */
+export async function removeMCPServerByEventId(metadataPath: string, eventId: string): Promise<void> {
+    // Load from the metadata path directly
+    const mcpConfig = await config.loadTenexMCP(metadataPath);
+
+    // Find and remove servers with this event ID
+    let removed = false;
+    for (const [serverName, serverConfig] of Object.entries(mcpConfig.servers)) {
+        if (serverConfig.eventId === eventId) {
+            delete mcpConfig.servers[serverName];
+            removed = true;
+            logger.info(`Removed MCP server '${serverName}' with event ID ${eventId}`);
+        }
+    }
+
+    if (removed) {
+        // Save updated config directly to metadata path
+        await config.saveTenexMCP(metadataPath, mcpConfig);
+    } else {
+        logger.warn(`No MCP server found with event ID ${eventId}`);
+    }
+}

package/src/services/nip46/Nip46SigningLog.ts

@@ -0,0 +1,81 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { config } from "@/services/ConfigService";
+
+/**
+ * Operations logged by the NIP-46 signing system.
+ */
+export type Nip46LogOperation =
+    | "signer_connect"
+    | "sign_request"
+    | "sign_success"
+    | "sign_timeout"
+    | "sign_rejected"
+    | "sign_error"
+    | "event_published";
+
+/**
+ * A single log entry for NIP-46 signing activity.
+ */
+export interface Nip46LogEntry {
+    ts: string;
+    op: Nip46LogOperation;
+    requestId?: string;
+    ownerPubkey?: string;       // First 12 chars
+    eventKind?: number;
+    agentAction?: string;
+    agentPubkey?: string;       // First 12 chars
+    pTagCount?: number;
+    signerType?: "nip46";
+    durationMs?: number;
+    error?: string;
+    eventId?: string;
+    trigger?: string;           // What triggered this signing request
+    eventTags?: string[][];     // Full tags array of the event being signed
+    eventContent?: string;      // Content field of the event being signed
+}
+
+/**
+ * Dedicated JSONL log writer for NIP-46 signing operations.
+ * Writes to ~/.tenex/daemon/nip46-signing.log, independent from daemon.log.
+ */
+export class Nip46SigningLog {
+    private static instance: Nip46SigningLog | null = null;
+    private logPath: string;
+
+    private constructor() {
+        const daemonDir = config.getConfigPath("daemon");
+        fs.mkdirSync(daemonDir, { recursive: true });
+        this.logPath = path.join(daemonDir, "nip46-signing.log");
+    }
+
+    static getInstance(): Nip46SigningLog {
+        if (!Nip46SigningLog.instance) {
+            Nip46SigningLog.instance = new Nip46SigningLog();
+        }
+        return Nip46SigningLog.instance;
+    }
+
+    /**
+     * Append a log entry as a single JSONL line.
+     */
+    log(entry: Omit<Nip46LogEntry, "ts">): void {
+        const fullEntry: Nip46LogEntry = {
+            ts: new Date().toISOString(),
+            ...entry,
+        };
+
+        try {
+            fs.appendFileSync(this.logPath, JSON.stringify(fullEntry) + "\n");
+        } catch {
+            // Silent failure - logging should never crash the daemon
+        }
+    }
+
+    /**
+     * Convenience: truncate a pubkey to 12 chars for logging.
+     */
+    static truncatePubkey(pubkey: string): string {
+        return pubkey.substring(0, 12);
+    }
+}

package/src/services/nip46/Nip46SigningService.ts

@@ -0,0 +1,467 @@
+import * as crypto from "node:crypto";
+import { getNDK } from "@/nostr/ndkClient";
+import { getRelayUrls } from "@/nostr/relays";
+import { config } from "@/services/ConfigService";
+import { logger } from "@/utils/logger";
+import {
+    type NDKEvent,
+    NDKNip46Signer,
+    NDKPrivateKeySigner,
+} from "@nostr-dev-kit/ndk";
+import { Nip46SigningLog } from "./Nip46SigningLog";
+
+/**
+ * Default configuration values for NIP-46 signing.
+ */
+const DEFAULTS = {
+    SIGNING_TIMEOUT_MS: 30_000,
+    CONNECT_TIMEOUT_MS: 30_000,
+    MAX_RETRIES: 2,
+} as const;
+
+/**
+ * Result of a NIP-46 signing attempt.
+ *
+ * - `signed` — signing succeeded
+ * - `user_rejected` — user/bunker explicitly rejected
+ * - `failed` — timeout/network error; event will not be published
+ */
+export type SignResult =
+    | { outcome: "signed" }
+    | { outcome: "user_rejected"; reason: string }
+    | { outcome: "failed"; reason: string };
+
+/**
+ * Race a promise against a timeout, cleaning up the timer regardless of outcome.
+ * Prevents leaked timers that cause unhandled promise rejections.
+ */
+function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+    let timer: ReturnType<typeof setTimeout>;
+    return Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+            timer = setTimeout(() => reject(new Error(message)), ms);
+        }),
+    ]).finally(() => clearTimeout(timer));
+}
+
+/**
+ * Singleton service that manages NIP-46 remote signing for kind 14199 events.
+ *
+ * Responsibilities:
+ * - Lazy initialization of NDKNip46Signer per owner pubkey
+ * - Timeout-wrapped signing with configurable retries
+ * - Per-owner mutex to serialize signing requests
+ * - Clear failure logging when signing fails (no fallback to backend key)
+ */
+export class Nip46SigningService {
+    private static instance: Nip46SigningService | null = null;
+
+    /** One NIP-46 signer per owner pubkey */
+    private signers = new Map<string, NDKNip46Signer>();
+
+    /** Per-owner promise chain for serialized signing */
+    private ownerLocks = new Map<string, Promise<void>>();
+
+    /** Track connection state per owner */
+    private connectedOwners = new Set<string>();
+
+    private signingLog: Nip46SigningLog;
+
+    private constructor() {
+        this.signingLog = Nip46SigningLog.getInstance();
+    }
+
+    static getInstance(): Nip46SigningService {
+        if (!Nip46SigningService.instance) {
+            Nip46SigningService.instance = new Nip46SigningService();
+        }
+        return Nip46SigningService.instance;
+    }
+
+    // =====================================================================================
+    // CONFIGURATION HELPERS
+    // =====================================================================================
+
+    /**
+     * Check if NIP-46 signing is globally enabled.
+     */
+    isEnabled(): boolean {
+        try {
+            const cfg = config.getConfig();
+            return cfg.nip46?.enabled === true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Check if NIP-46 is enabled and configured for a specific owner.
+     */
+    isEnabledForOwner(_ownerPubkey: string): boolean {
+        if (!this.isEnabled()) return false;
+        // NIP-46 is enabled for all whitelisted owners;
+        // we auto-construct bunker URIs when not explicitly configured
+        return true;
+    }
+
+    /**
+     * Get the bunker URI for an owner. If not explicitly configured,
+     * auto-constructs: bunker://<ownerPubkey>?relay=<firstRelay>
+     */
+    getBunkerUri(ownerPubkey: string): string {
+        const cfg = config.getConfig();
+        const ownerConfig = cfg.nip46?.owners?.[ownerPubkey];
+
+        if (ownerConfig?.bunkerUri) {
+            return ownerConfig.bunkerUri;
+        }
+
+        // Auto-construct bunker URI
+        const relays = getRelayUrls();
+        const relay = relays[0] || "wss://tenex.chat";
+        return `bunker://${ownerPubkey}?relay=${encodeURIComponent(relay)}`;
+    }
+
+    private getSigningTimeout(): number {
+        try {
+            return config.getConfig().nip46?.signingTimeoutMs ?? DEFAULTS.SIGNING_TIMEOUT_MS;
+        } catch {
+            return DEFAULTS.SIGNING_TIMEOUT_MS;
+        }
+    }
+
+    private getMaxRetries(): number {
+        try {
+            return config.getConfig().nip46?.maxRetries ?? DEFAULTS.MAX_RETRIES;
+        } catch {
+            return DEFAULTS.MAX_RETRIES;
+        }
+    }
+
+    // =====================================================================================
+    // SIGNER MANAGEMENT
+    // =====================================================================================
+
+    /**
+     * Get or create an NDKNip46Signer for a specific owner.
+     * Lazy initialization — signer created on first request, not at daemon startup.
+     */
+    private async getOrCreateSigner(ownerPubkey: string): Promise<NDKNip46Signer> {
+        const existing = this.signers.get(ownerPubkey);
+        if (existing) return existing;
+
+        const ndk = getNDK();
+        const backendNsec = await config.ensureBackendPrivateKey();
+        const localSigner = new NDKPrivateKeySigner(backendNsec);
+        const bunkerUri = this.getBunkerUri(ownerPubkey);
+
+        logger.info("[NIP-46] Creating signer for owner", {
+            ownerPubkey: ownerPubkey.substring(0, 12),
+            bunkerUri: bunkerUri.substring(0, 60),
+        });
+
+        const signer = NDKNip46Signer.bunker(ndk, bunkerUri, localSigner);
+
+        // Handle auth URL — log it so operator can approve if needed
+        signer.on("authUrl", (url: string) => {
+            logger.info("[NIP-46] Auth URL required", {
+                ownerPubkey: ownerPubkey.substring(0, 12),
+                url,
+            });
+            this.signingLog.log({
+                op: "signer_connect",
+                ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                error: `auth_url_required: ${url}`,
+            });
+        });
+
+        this.signers.set(ownerPubkey, signer);
+        return signer;
+    }
+
+    /**
+     * Ensure the signer for an owner is connected (blockUntilReady).
+     * Wrapped with timeout to prevent hanging forever.
+     */
+    private async ensureConnected(ownerPubkey: string): Promise<NDKNip46Signer> {
+        const signer = await this.getOrCreateSigner(ownerPubkey);
+
+        if (this.connectedOwners.has(ownerPubkey)) {
+            return signer;
+        }
+
+        const startMs = Date.now();
+        const requestId = crypto.randomUUID().substring(0, 8);
+
+        this.signingLog.log({
+            op: "signer_connect",
+            requestId,
+            ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+        });
+
+        try {
+            await withTimeout(
+                signer.blockUntilReady(),
+                DEFAULTS.CONNECT_TIMEOUT_MS,
+                "NIP-46 connect timed out",
+            );
+
+            this.connectedOwners.add(ownerPubkey);
+            const durationMs = Date.now() - startMs;
+
+            logger.info("[NIP-46] Signer connected", {
+                ownerPubkey: ownerPubkey.substring(0, 12),
+                durationMs,
+            });
+
+            this.signingLog.log({
+                op: "signer_connect",
+                requestId,
+                ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                durationMs,
+            });
+
+            return signer;
+        } catch (error) {
+            const durationMs = Date.now() - startMs;
+            const errorMsg = error instanceof Error ? error.message : String(error);
+
+            logger.error("[NIP-46] Signer connection failed", {
+                ownerPubkey: ownerPubkey.substring(0, 12),
+                error: errorMsg,
+                durationMs,
+            });
+
+            this.signingLog.log({
+                op: "sign_error",
+                requestId,
+                ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                error: `connect_failed: ${errorMsg}`,
+                durationMs,
+            });
+
+            // Remove from cache so next attempt creates a fresh signer
+            this.signers.delete(ownerPubkey);
+            throw error;
+        }
+    }
+
+    // =====================================================================================
+    // PER-OWNER MUTEX
+    // =====================================================================================
+
+    /**
+     * Serialize operations per owner pubkey to avoid concurrent NIP-46 signing.
+     */
+    private async withOwnerLock<T>(ownerPubkey: string, fn: () => Promise<T>): Promise<T> {
+        const existing = this.ownerLocks.get(ownerPubkey) ?? Promise.resolve();
+        let resolve: () => void;
+        const next = new Promise<void>((r) => (resolve = r));
+        this.ownerLocks.set(ownerPubkey, next);
+
+        await existing;
+
+        try {
+            return await fn();
+        } finally {
+            resolve!();
+            if (this.ownerLocks.get(ownerPubkey) === next) {
+                this.ownerLocks.delete(ownerPubkey);
+            }
+        }
+    }
+
+    // =====================================================================================
+    // SIGNING
+    // =====================================================================================
+
+    /**
+     * Sign an NDKEvent using NIP-46 remote signing for the given owner.
+     *
+     * @param ownerPubkey - The owner's hex pubkey (the "user" in NIP-46 terms)
+     * @param event - The NDKEvent to sign (will be mutated: pubkey set to ownerPubkey)
+     * @returns SignResult indicating success, explicit rejection, or transient failure
+     */
+    async signEvent(ownerPubkey: string, event: NDKEvent, trigger?: string): Promise<SignResult> {
+        return this.withOwnerLock(ownerPubkey, () =>
+            this.signEventInternal(ownerPubkey, event, trigger)
+        );
+    }
+
+    private async signEventInternal(ownerPubkey: string, event: NDKEvent, trigger?: string): Promise<SignResult> {
+        const requestId = crypto.randomUUID().substring(0, 8);
+        const signingTimeout = this.getSigningTimeout();
+        const maxRetries = this.getMaxRetries();
+        const startMs = Date.now();
+
+        this.signingLog.log({
+            op: "sign_request",
+            requestId,
+            ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+            eventKind: event.kind,
+            pTagCount: event.tags.filter((t) => t[0] === "p").length,
+            trigger,
+            eventTags: event.tags,
+            eventContent: event.content,
+        });
+
+        let lastError: Error | null = null;
+
+        for (let attempt = 0; attempt <= maxRetries; attempt++) {
+            try {
+                const signer = await this.ensureConnected(ownerPubkey);
+
+                // Set the event pubkey to the owner before signing
+                event.pubkey = ownerPubkey;
+
+                logger.info("[NIP-46] Pre-sign payload", {
+                    requestId,
+                    attempt,
+                    kind: event.kind,
+                    pubkey: event.pubkey?.substring(0, 12),
+                    tags: JSON.stringify(event.tags),
+                    content: event.content,
+                });
+
+                await withTimeout(
+                    event.sign(signer),
+                    signingTimeout,
+                    "NIP-46 sign timed out",
+                );
+
+                const durationMs = Date.now() - startMs;
+
+                this.signingLog.log({
+                    op: "sign_success",
+                    requestId,
+                    ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                    eventKind: event.kind,
+                    signerType: "nip46",
+                    durationMs,
+                    eventId: event.id,
+                });
+
+                logger.info("[NIP-46] Event signed successfully", {
+                    ownerPubkey: ownerPubkey.substring(0, 12),
+                    eventKind: event.kind,
+                    eventId: event.id?.substring(0, 12),
+                    durationMs,
+                    attempt,
+                });
+
+                return { outcome: "signed" };
+            } catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                const errorMsg = lastError.message;
+
+                // User rejection — never retry
+                if (this.isUserRejection(errorMsg)) {
+                    const durationMs = Date.now() - startMs;
+
+                    this.signingLog.log({
+                        op: "sign_rejected",
+                        requestId,
+                        ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                        eventKind: event.kind,
+                        error: errorMsg,
+                        durationMs,
+                    });
+
+                    logger.warn("[NIP-46] Signing rejected by user", {
+                        ownerPubkey: ownerPubkey.substring(0, 12),
+                        eventKind: event.kind,
+                        error: errorMsg,
+                    });
+
+                    return { outcome: "user_rejected", reason: errorMsg };
+                }
+
+                // Timeout or relay error — retry if attempts remain
+                if (attempt < maxRetries) {
+                    logger.warn("[NIP-46] Signing failed, retrying", {
+                        ownerPubkey: ownerPubkey.substring(0, 12),
+                        eventKind: event.kind,
+                        attempt: attempt + 1,
+                        maxRetries,
+                        error: errorMsg,
+                    });
+
+                    // Reset signer on connection errors
+                    if (errorMsg.includes("connect") || errorMsg.includes("timed out")) {
+                        this.signers.delete(ownerPubkey);
+                        this.connectedOwners.delete(ownerPubkey);
+                    }
+
+                    continue;
+                }
+            }
+        }
+
+        // All retries exhausted
+        const durationMs = Date.now() - startMs;
+        const errorMsg = lastError?.message ?? "unknown error";
+
+        if (errorMsg.includes("timed out")) {
+            this.signingLog.log({
+                op: "sign_timeout",
+                requestId,
+                ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                eventKind: event.kind,
+                error: errorMsg,
+                durationMs,
+            });
+        } else {
+            this.signingLog.log({
+                op: "sign_error",
+                requestId,
+                ownerPubkey: Nip46SigningLog.truncatePubkey(ownerPubkey),
+                eventKind: event.kind,
+                error: errorMsg,
+                durationMs,
+            });
+        }
+
+        logger.error("[NIP-46] Signing failed after all retries", {
+            ownerPubkey: ownerPubkey.substring(0, 12),
+            eventKind: event.kind,
+            retries: maxRetries,
+            error: errorMsg,
+            durationMs,
+        });
+
+        return { outcome: "failed", reason: errorMsg };
+    }
+
+    /**
+     * Detect user rejection errors — these should never be retried.
+     */
+    private isUserRejection(errorMsg: string): boolean {
+        const rejectionPatterns = [
+            "rejected",
+            "denied",
+            "refused",
+            "not authorized",
+            "user declined",
+        ];
+        const lower = errorMsg.toLowerCase();
+        return rejectionPatterns.some((p) => lower.includes(p));
+    }
+
+    // =====================================================================================
+    // LIFECYCLE
+    // =====================================================================================
+
+    /**
+     * Clean up all NIP-46 signer connections.
+     */
+    async shutdown(): Promise<void> {
+        logger.info("[NIP-46] Shutting down signing service", {
+            activeSingers: this.signers.size,
+        });
+
+        this.signers.clear();
+        this.connectedOwners.clear();
+        this.ownerLocks.clear();
+    }
+}

package/src/services/nip46/index.ts

@@ -0,0 +1,4 @@
+export { Nip46SigningService } from "./Nip46SigningService";
+export type { SignResult } from "./Nip46SigningService";
+export { Nip46SigningLog } from "./Nip46SigningLog";
+export type { Nip46LogEntry, Nip46LogOperation } from "./Nip46SigningLog";