nostr-bray 0.0.0-development

package/dist/index.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { loadConfig } from './config.js';
+import { IdentityContext } from './context.js';
+import { RelayPool } from './relay-pool.js';
+import { Nip65Manager } from './nip65.js';
+import { registerIdentityTools } from './identity/tools.js';
+import { registerSocialTools } from './social/tools.js';
+import { registerTrustTools } from './trust/tools.js';
+import { registerRelayTools } from './relay/tools.js';
+import { registerZapTools } from './zap/tools.js';
+import { registerSafetyTools } from './safety/tools.js';
+const config = loadConfig();
+const pool = new RelayPool({
+    torProxy: config.torProxy,
+    allowClearnet: config.allowClearnetWithTor || !config.torProxy,
+    defaultRelays: config.relays,
+});
+const nip65 = new Nip65Manager(pool, config.relays);
+const ctx = new IdentityContext(config.secretKey, config.secretFormat);
+export const deps = { ctx, pool, nip65, nwcUri: config.nwcUri };
+config.secretKey = '';
+config.nwcUri = undefined;
+// Load master identity relay list
+const masterRelays = await nip65.loadForIdentity(ctx.activeNpub);
+pool.reconfigure(ctx.activeNpub, masterRelays);
+const server = new McpServer({ name: 'nostr-bray', version: '0.1.0' });
+// Phase 2: Identity tools
+registerIdentityTools(server, deps);
+// Phase 3: Social tools
+registerSocialTools(server, deps);
+// Phase 4: Trust tools
+registerTrustTools(server, deps);
+// Phase 5: Relay, Zap & Safety tools
+registerRelayTools(server, deps);
+registerZapTools(server, deps);
+registerSafetyTools(server, deps);
+if (config.transport === 'stdio') {
+    const { StdioServerTransport } = await import('@modelcontextprotocol/sdk/server/stdio.js');
+    await server.connect(new StdioServerTransport());
+    console.error('nostr-bray started (stdio)');
+}
+else {
+    const { createServer } = await import('node:http');
+    const { StreamableHTTPServerTransport } = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
+    const { randomUUID } = await import('node:crypto');
+    const token = randomUUID();
+    console.error(`nostr-bray HTTP auth token: ${token}`);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await server.connect(transport);
+    const { timingSafeEqual } = await import('node:crypto');
+    const expectedAuth = Buffer.from(`Bearer ${token}`);
+    // Sliding window rate limiter (per-IP)
+    const rateLimits = new Map();
+    const RATE_WINDOW = 60_000; // 60 seconds
+    const RATE_LIMIT = 100; // 100 requests per window
+    function checkRateLimit(ip) {
+        const now = Date.now();
+        const entry = rateLimits.get(ip);
+        if (!entry || now > entry.resetAt) {
+            rateLimits.set(ip, { count: 1, resetAt: now + RATE_WINDOW });
+            return true;
+        }
+        entry.count++;
+        return entry.count <= RATE_LIMIT;
+    }
+    const httpServer = createServer(async (req, res) => {
+        const clientIp = req.socket.remoteAddress ?? 'unknown';
+        // Rate limiting
+        if (!checkRateLimit(clientIp)) {
+            res.writeHead(429, { 'Content-Type': 'application/json', 'Retry-After': '60' });
+            res.end(JSON.stringify({ error: 'Too many requests' }));
+            return;
+        }
+        // Bearer token auth (constant-time comparison)
+        const actual = Buffer.from(req.headers.authorization ?? '');
+        if (actual.length !== expectedAuth.length || !timingSafeEqual(actual, expectedAuth)) {
+            res.writeHead(401, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Unauthorised' }));
+            return;
+        }
+        // Security headers — no CORS headers = deny all cross-origin
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        if (req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok' }));
+            return;
+        }
+        // Parse body for POST requests (1MB limit)
+        if (req.method === 'POST') {
+            const MAX_BODY = 1_048_576;
+            const chunks = [];
+            let size = 0;
+            for await (const chunk of req) {
+                size += chunk.length;
+                if (size > MAX_BODY) {
+                    res.writeHead(413, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Request body too large' }));
+                    return;
+                }
+                chunks.push(chunk);
+            }
+            let body;
+            try {
+                body = JSON.parse(Buffer.concat(chunks).toString());
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON' }));
+                return;
+            }
+            await transport.handleRequest(req, res, body);
+        }
+        else {
+            await transport.handleRequest(req, res);
+        }
+    });
+    httpServer.listen(config.port, config.bindAddress, () => {
+        console.error(`nostr-bray HTTP on ${config.bindAddress}:${config.port}`);
+    });
+}
+const shutdown = () => { ctx.destroy(); pool.close(); process.exit(0); };
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);

package/dist/nip65.d.ts

@@ -0,0 +1,15 @@
+import type { RelayPool } from './relay-pool.js';
+import type { RelaySet } from './types.js';
+/** Parse NIP-65 r-tags into read/write relay sets, filtering invalid URLs */
+export declare function parseRelayTags(tags: string[][]): RelaySet;
+export declare class Nip65Manager {
+    private pool;
+    private defaults;
+    private cache;
+    private readonly TTL;
+    constructor(pool: RelayPool, defaultRelays: string[]);
+    /** Load relay list for an identity from kind 10002 events */
+    loadForIdentity(npub: string, pubkeyHex?: string): Promise<RelaySet>;
+    /** Get cached relay list for an identity */
+    getCached(npub: string): RelaySet | undefined;
+}

package/dist/nip65.js

@@ -0,0 +1,71 @@
+import { decode } from 'nostr-tools/nip19';
+import { verifyEvent } from 'nostr-tools/pure';
+/** Validate relay URL scheme — must be wss:// or ws:// */
+function isValidRelayUrl(url) {
+    return /^wss?:\/\//i.test(url);
+}
+/** Parse NIP-65 r-tags into read/write relay sets, filtering invalid URLs */
+export function parseRelayTags(tags) {
+    const read = [];
+    const write = [];
+    for (const tag of tags) {
+        if (tag[0] !== 'r' || !tag[1])
+            continue;
+        const url = tag[1];
+        if (!isValidRelayUrl(url))
+            continue; // reject non-wss/ws URLs
+        const marker = tag[2];
+        if (marker === 'read') {
+            read.push(url);
+        }
+        else if (marker === 'write') {
+            write.push(url);
+        }
+        else {
+            read.push(url);
+            write.push(url);
+        }
+    }
+    return { read, write };
+}
+export class Nip65Manager {
+    pool;
+    defaults;
+    cache = new Map();
+    TTL = 3600_000; // 1 hour
+    constructor(pool, defaultRelays) {
+        this.pool = pool;
+        this.defaults = defaultRelays;
+    }
+    /** Load relay list for an identity from kind 10002 events */
+    async loadForIdentity(npub, pubkeyHex) {
+        // Return cached if still fresh
+        const cached = this.cache.get(npub);
+        if (cached && Date.now() - cached.fetchedAt < this.TTL)
+            return cached.relays;
+        const hex = pubkeyHex ?? decode(npub).data;
+        const events = await this.pool.query(npub, {
+            kinds: [10002],
+            authors: [hex],
+        });
+        // Filter to verified events from the expected author
+        const verified = events.filter(e => e.pubkey === hex && verifyEvent(e));
+        if (verified.length === 0) {
+            const fallback = {
+                read: [...this.defaults],
+                write: [...this.defaults],
+            };
+            this.cache.set(npub, { relays: fallback, fetchedAt: Date.now() });
+            return fallback;
+        }
+        // Take highest created_at from verified events
+        const best = verified.reduce((a, b) => b.created_at > a.created_at ? b : a);
+        const relaySet = parseRelayTags(best.tags);
+        this.cache.set(npub, { relays: relaySet, fetchedAt: Date.now() });
+        return relaySet;
+    }
+    /** Get cached relay list for an identity */
+    getCached(npub) {
+        return this.cache.get(npub)?.relays;
+    }
+}

package/dist/relay/handlers.d.ts

@@ -0,0 +1,36 @@
+import type { Event as NostrEvent } from 'nostr-tools';
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+import type { PublishResult } from '../types.js';
+export interface RelayListResult {
+    read: string[];
+    write: string[];
+    sharedWarning?: string;
+}
+export interface RelayEntry {
+    url: string;
+    mode?: 'read' | 'write';
+}
+/** Get relay list for the active identity, optionally checking for shared relays with another identity */
+export declare function handleRelayList(ctx: IdentityContext, pool: RelayPool, compareWithNpub?: string): RelayListResult;
+/** Publish a kind 10002 relay list */
+export declare function handleRelaySet(ctx: IdentityContext, pool: RelayPool, args: {
+    relays: RelayEntry[];
+    confirm?: boolean;
+}): Promise<{
+    event: NostrEvent;
+    published: boolean;
+    publish?: PublishResult;
+    warning?: string;
+}>;
+/** Add a single relay to the active identity's relay set */
+export declare function handleRelayAdd(ctx: IdentityContext, pool: RelayPool, args: {
+    url: string;
+    mode?: 'read' | 'write';
+}): {
+    reconfigured: boolean;
+};
+/** Validate a relay URL — must be wss:// or ws://, no private networks */
+export declare function validateRelayUrl(url: string): void;
+/** Fetch NIP-11 relay information document */
+export declare function handleRelayInfo(url: string): Promise<Record<string, unknown>>;

package/dist/relay/handlers.js

@@ -0,0 +1,96 @@
+/** Get relay list for the active identity, optionally checking for shared relays with another identity */
+export function handleRelayList(ctx, pool, compareWithNpub) {
+    const relays = pool.getRelays(ctx.activeNpub);
+    const result = {
+        read: relays.read,
+        write: relays.write,
+    };
+    if (compareWithNpub) {
+        const shared = pool.checkSharedRelays(ctx.activeNpub, compareWithNpub);
+        if (shared.length > 0) {
+            result.sharedWarning = `Shared relays with ${compareWithNpub}: ${shared.join(', ')}. This may link identities.`;
+        }
+    }
+    return result;
+}
+/** Publish a kind 10002 relay list */
+export async function handleRelaySet(ctx, pool, args) {
+    // Check for existing relay list
+    const existing = await pool.query(ctx.activeNpub, {
+        kinds: [10002],
+        authors: [ctx.activeNpub],
+    });
+    // Build r-tags
+    const tags = args.relays.map(r => {
+        if (r.mode)
+            return ['r', r.url, r.mode];
+        return ['r', r.url];
+    });
+    const sign = ctx.getSigningFunction();
+    const event = await sign({
+        kind: 10002,
+        created_at: Math.floor(Date.now() / 1000),
+        tags,
+        content: '',
+    });
+    if (existing.length > 0 && !args.confirm) {
+        return {
+            event,
+            published: false,
+            warning: 'Relay list already exists. Set confirm: true to overwrite.',
+        };
+    }
+    const publish = await pool.publish(ctx.activeNpub, event);
+    // Reconfigure the pool with the new relay set
+    const read = args.relays.filter(r => !r.mode || r.mode === 'read').map(r => r.url);
+    const write = args.relays.filter(r => !r.mode || r.mode === 'write').map(r => r.url);
+    pool.reconfigure(ctx.activeNpub, { read, write });
+    return { event, published: true, publish };
+}
+/** Add a single relay to the active identity's relay set */
+export function handleRelayAdd(ctx, pool, args) {
+    const current = pool.getRelays(ctx.activeNpub);
+    const read = [...current.read];
+    const write = [...current.write];
+    if (!args.mode || args.mode === 'read') {
+        if (!read.includes(args.url))
+            read.push(args.url);
+    }
+    if (!args.mode || args.mode === 'write') {
+        if (!write.includes(args.url))
+            write.push(args.url);
+    }
+    pool.reconfigure(ctx.activeNpub, { read, write });
+    return { reconfigured: true };
+}
+/** Validate a relay URL — must be wss:// or ws://, no private networks */
+export function validateRelayUrl(url) {
+    if (!/^wss?:\/\//i.test(url)) {
+        throw new Error('Relay URL must use wss:// or ws:// scheme');
+    }
+    const parsed = new URL(url);
+    const host = parsed.hostname.toLowerCase();
+    if (host === 'localhost' || host === '[::1]' ||
+        host.startsWith('127.') || host.startsWith('10.') ||
+        host.startsWith('192.168.') || host === '169.254.169.254' ||
+        /^172\.(1[6-9]|2\d|3[01])\./.test(host)) {
+        throw new Error('Relay URL must not point to private network addresses');
+    }
+}
+/** Fetch NIP-11 relay information document */
+export async function handleRelayInfo(url) {
+    validateRelayUrl(url);
+    const httpUrl = url.replace(/^wss:\/\//, 'https://').replace(/^ws:\/\//, 'http://');
+    const response = await fetch(httpUrl, {
+        headers: { Accept: 'application/nostr+json' },
+        signal: AbortSignal.timeout(10_000),
+    });
+    if (!response.ok) {
+        throw new Error(`NIP-11 fetch failed: ${response.status} ${response.statusText}`);
+    }
+    const text = await response.text();
+    if (text.length > 1_048_576) {
+        throw new Error('Relay info document too large');
+    }
+    return JSON.parse(text);
+}

package/dist/relay/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolDeps } from '../identity/tools.js';
+export declare function registerRelayTools(server: McpServer, deps: ToolDeps): void;

package/dist/relay/tools.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { relayUrl } from '../validation.js';
+import { handleRelayList, handleRelaySet, handleRelayAdd, handleRelayInfo } from './handlers.js';
+export function registerRelayTools(server, deps) {
+    server.registerTool('relay_list', {
+        description: 'List the relay set (read/write) for the active identity. Optionally check for shared relays with another identity.',
+        inputSchema: {
+            compareWithNpub: z.string().optional().describe('Compare shared relays with this npub'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ compareWithNpub }) => {
+        const result = handleRelayList(deps.ctx, deps.pool, compareWithNpub);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool('relay_set', {
+        description: 'Publish a kind 10002 relay list for the active identity. Warns if a relay list already exists.',
+        inputSchema: {
+            relays: z.array(z.object({
+                url: relayUrl.describe('Relay WebSocket URL'),
+                mode: z.enum(['read', 'write']).optional().describe('Read, write, or both (default)'),
+            })).describe('Relay entries'),
+            confirm: z.boolean().default(false).describe('Set true to overwrite existing relay list'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ relays, confirm }) => {
+        const result = await handleRelaySet(deps.ctx, deps.pool, { relays, confirm });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result.warning
+                        ? { warning: result.warning }
+                        : { published: true, id: result.event.id }, null, 2) }],
+        };
+    });
+    server.registerTool('relay_add', {
+        description: 'Add a single relay to the active identity\'s relay set (in-memory only — does not publish kind 10002).',
+        inputSchema: {
+            url: relayUrl.describe('Relay WebSocket URL'),
+            mode: z.enum(['read', 'write']).optional().describe('Read, write, or both (default)'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ url, mode }) => {
+        const result = handleRelayAdd(deps.ctx, deps.pool, { url, mode });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    server.registerTool('relay_info', {
+        description: 'Fetch the NIP-11 relay information document for a relay URL.',
+        inputSchema: {
+            url: relayUrl.describe('Relay WebSocket URL (wss://...)'),
+        },
+        annotations: { readOnlyHint: true },
+    }, async ({ url }) => {
+        const info = await handleRelayInfo(url);
+        return {
+            content: [{ type: 'text', text: JSON.stringify(info, null, 2) }],
+        };
+    });
+}

package/dist/relay-pool.d.ts

@@ -0,0 +1,42 @@
+import type { Event as NostrEvent, Filter } from 'nostr-tools';
+import type { PublishResult, RelaySet } from './types.js';
+/** Minimal pool interface for dependency injection (testability) */
+export interface PoolLike {
+    publish(relays: string[], event: NostrEvent): Promise<string>[];
+    querySync(relays: string[], filter: Filter): Promise<NostrEvent[]>;
+    destroy(): void;
+}
+export interface RelayPoolConfig {
+    torProxy?: string;
+    allowClearnet: boolean;
+    defaultRelays: string[];
+}
+export declare class RelayPool {
+    private pool;
+    private poolReady;
+    private relaySets;
+    private writeQueue;
+    private defaults;
+    private torProxy?;
+    private allowClearnet;
+    constructor(config: RelayPoolConfig, injectedPool?: PoolLike);
+    /** Store relay set for an identity and flush any queued writes */
+    reconfigure(npub: string, relays: RelaySet): void;
+    /** Get relay set for an identity, falling back to defaults */
+    getRelays(npub: string): RelaySet;
+    /** Publish event to write relays for the given identity */
+    publish(npub: string, event: NostrEvent): Promise<PublishResult>;
+    /** One-shot query from read relays for the given identity */
+    query(npub: string, filter: Filter): Promise<NostrEvent[]>;
+    /** Queue an event for publishing once the identity's relay list is known */
+    queueWrite(npub: string, event: NostrEvent): void;
+    /** Number of queued events for an identity */
+    queueSize(npub: string): number;
+    /** Flush write queue for an identity, publishing all queued events */
+    flushQueue(npub: string): Promise<void>;
+    /** Find relay URLs shared between two identities */
+    checkSharedRelays(npubA: string, npubB: string): string[];
+    /** Close all connections */
+    close(): void;
+    private isOnion;
+}

package/dist/relay-pool.js

@@ -0,0 +1,150 @@
+/** Initialise WebSocket and create a real SimplePool — lazy-loaded to avoid side effects at import */
+async function createRealPool(torProxy) {
+    const { useWebSocketImplementation, SimplePool } = await import('nostr-tools/pool');
+    const WS = (await import('ws')).default;
+    if (torProxy) {
+        // Route all WebSocket connections through the SOCKS5h proxy for Tor
+        // hostname is passed unresolved (socks5h) so DNS happens at the proxy
+        const { SocksProxyAgent } = await import('socks-proxy-agent');
+        const agent = new SocksProxyAgent(torProxy);
+        const ProxiedWebSocket = class extends WS {
+            constructor(url, protocols, options) {
+                super(url, protocols, { ...options, agent });
+            }
+        };
+        useWebSocketImplementation(ProxiedWebSocket);
+    }
+    else {
+        useWebSocketImplementation(WS);
+    }
+    return new SimplePool();
+}
+export class RelayPool {
+    pool;
+    poolReady;
+    relaySets = new Map();
+    writeQueue = new Map();
+    defaults;
+    torProxy;
+    allowClearnet;
+    constructor(config, injectedPool) {
+        this.torProxy = config.torProxy;
+        this.allowClearnet = config.allowClearnet;
+        // Validate Tor/clearnet policy on default relays
+        if (config.torProxy && !config.allowClearnet) {
+            const clearnet = config.defaultRelays.filter(r => !this.isOnion(r));
+            if (clearnet.length > 0) {
+                throw new Error(`Clearnet relays not allowed with Tor proxy (set allowClearnet to override): ${clearnet.join(', ')}`);
+            }
+        }
+        this.defaults = {
+            read: [...config.defaultRelays],
+            write: [...config.defaultRelays],
+        };
+        if (injectedPool) {
+            this.pool = injectedPool;
+            this.poolReady = Promise.resolve(injectedPool);
+        }
+        else {
+            this.poolReady = createRealPool(config.torProxy).then(p => { this.pool = p; return p; });
+        }
+    }
+    /** Store relay set for an identity and flush any queued writes */
+    reconfigure(npub, relays) {
+        // Enforce Tor policy on runtime relay additions
+        if (this.torProxy && !this.allowClearnet) {
+            const allUrls = [...relays.read, ...relays.write];
+            const clearnet = allUrls.filter(r => !this.isOnion(r));
+            if (clearnet.length > 0) {
+                throw new Error(`Clearnet relays not allowed with Tor proxy: ${clearnet.join(', ')}`);
+            }
+        }
+        this.relaySets.set(npub, relays);
+        void this.flushQueue(npub);
+    }
+    /** Get relay set for an identity, falling back to defaults */
+    getRelays(npub) {
+        return this.relaySets.get(npub) ?? this.defaults;
+    }
+    /** Publish event to write relays for the given identity */
+    async publish(npub, event) {
+        const pool = await this.poolReady;
+        const relays = this.getRelays(npub);
+        const writeRelays = relays.write;
+        if (writeRelays.length === 0) {
+            return { success: false, accepted: [], rejected: [], errors: ['no write relays configured'] };
+        }
+        const promises = pool.publish(writeRelays, event);
+        const accepted = [];
+        const rejected = [];
+        const errors = [];
+        const results = await Promise.allSettled(promises);
+        for (let i = 0; i < results.length; i++) {
+            const result = results[i];
+            const url = writeRelays[i] ?? `relay-${i}`;
+            if (result.status === 'fulfilled') {
+                accepted.push(url);
+            }
+            else {
+                rejected.push(url);
+                errors.push(`${url}: ${result.reason}`);
+            }
+        }
+        return {
+            success: accepted.length === writeRelays.length,
+            accepted,
+            rejected,
+            errors,
+        };
+    }
+    /** One-shot query from read relays for the given identity */
+    async query(npub, filter) {
+        const pool = await this.poolReady;
+        const relays = this.getRelays(npub);
+        return pool.querySync(relays.read, filter);
+    }
+    /** Queue an event for publishing once the identity's relay list is known */
+    queueWrite(npub, event) {
+        const queue = this.writeQueue.get(npub) ?? [];
+        if (queue.length >= 100) {
+            throw new Error(`Write queue full for ${npub} (max 100 events). Resolve relay list first.`);
+        }
+        queue.push(event);
+        this.writeQueue.set(npub, queue);
+    }
+    /** Number of queued events for an identity */
+    queueSize(npub) {
+        return this.writeQueue.get(npub)?.length ?? 0;
+    }
+    /** Flush write queue for an identity, publishing all queued events */
+    async flushQueue(npub) {
+        const queue = this.writeQueue.get(npub);
+        if (!queue || queue.length === 0)
+            return;
+        this.writeQueue.delete(npub);
+        for (const event of queue) {
+            await this.publish(npub, event);
+        }
+    }
+    /** Find relay URLs shared between two identities */
+    checkSharedRelays(npubA, npubB) {
+        const relaysA = this.getRelays(npubA);
+        const relaysB = this.getRelays(npubB);
+        const allA = new Set([...relaysA.read, ...relaysA.write]);
+        const allB = new Set([...relaysB.read, ...relaysB.write]);
+        return [...allA].filter(url => allB.has(url));
+    }
+    /** Close all connections */
+    close() {
+        this.pool?.destroy();
+    }
+    isOnion(url) {
+        try {
+            const parsed = new URL(url);
+            return parsed.hostname.endsWith('.onion');
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/dist/safety/handlers.d.ts

@@ -0,0 +1,15 @@
+import type { IdentityContext } from '../context.js';
+import type { RelayPool } from '../relay-pool.js';
+/** Configure a duress persona — derives it and pre-warms relay connections */
+export declare function handleDuressConfigure(ctx: IdentityContext, pool: RelayPool, args: {
+    personaName?: string;
+}): {
+    npub: string;
+    configured: boolean;
+};
+/** Activate duress persona — switches identity. Response is identical to identity_switch. */
+export declare function handleDuressActivate(ctx: IdentityContext, args: {
+    personaName?: string;
+}): {
+    npub: string;
+};

package/dist/safety/handlers.js

@@ -0,0 +1,12 @@
+/** Configure a duress persona — derives it and pre-warms relay connections */
+export function handleDuressConfigure(ctx, pool, args) {
+    const name = args.personaName ?? 'anonymous';
+    const persona = ctx.derivePersona(name, 0);
+    return { npub: persona.npub, configured: true };
+}
+/** Activate duress persona — switches identity. Response is identical to identity_switch. */
+export function handleDuressActivate(ctx, args) {
+    const name = args.personaName ?? 'anonymous';
+    ctx.switch(name);
+    return { npub: ctx.activeNpub };
+}

package/dist/safety/tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { ToolDeps } from '../identity/tools.js';
+export declare function registerSafetyTools(server: McpServer, deps: ToolDeps): void;

package/dist/safety/tools.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { handleDuressConfigure, handleDuressActivate } from './handlers.js';
+export function registerSafetyTools(server, deps) {
+    server.registerTool('safety_configure', {
+        description: 'Configure an alternative identity persona and pre-warm relay connections.',
+        inputSchema: {
+            personaName: z.string().default('anonymous').describe('Persona name for the alternative identity'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ personaName }) => {
+        const result = handleDuressConfigure(deps.ctx, deps.pool, { personaName });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+    // Description intentionally does NOT mention duress — appears as normal identity switch
+    server.registerTool('safety_activate', {
+        description: 'Switch to an alternative identity configuration.',
+        inputSchema: {
+            personaName: z.string().default('anonymous').describe('Persona name to switch to'),
+        },
+        annotations: { readOnlyHint: false },
+    }, async ({ personaName }) => {
+        const result = handleDuressActivate(deps.ctx, { personaName });
+        return {
+            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}