nostr-bray 2.1.0 → 2.3.0

package/dist/cli/commands/event.js

@@ -1,30 +1,28 @@
-import { assertEventSemanticallyValid, handlePublishEvent, handlePublishRaw } from '../../exports.js';
+import { assertEventSemanticallyValid, handlePublishEvent, handlePublishRaw, resolveKind } from '../../exports.js';
+import { nip19 } from 'nostr-tools';
 export async function dispatch(cmd, _cmdArgs, h, ctx, pool) {
-    const { flag, flags, hasFlag, out } = h;
+    const { flag, flags, hasFlag, flagAny, flagsAny, out } = h;
     switch (cmd) {
         case 'event': {
-            const kind = parseInt(flag('kind') ?? '', 10);
-            if (!kind || isNaN(kind))
-                throw new Error('Usage: event --kind <N> [--tag k=v] [--content s] [--relay url] [--no-publish]');
-            const tagValues = flags('tag').map(t => {
-                const eq = t.indexOf('=');
-                if (eq === -1)
-                    return [t];
-                return [t.slice(0, eq), t.slice(eq + 1)];
+            const kindArg = flagAny('kind', 'k');
+            if (!kindArg) {
+                throw new Error('Usage: event -k <number|name> [-c content] [-t k=v] [-p pubkey] [-e id] [-d ident] [--relay url]');
+            }
+            // Accepts a number or a registry kind name, e.g. -k "short text note"
+            const kind = resolveKind(kindArg);
+            const tagValues = collectTags(flagsAny('tag', 't'), {
+                p: flagsAny('p'), e: flagsAny('e'), d: flagsAny('d'), h: flagsAny('h'),
             });
-            const content = flag('content') ?? '';
+            const content = flagAny('content', 'c') ?? '';
             const validationMode = parseValidationMode(flag('validation'));
-            const relayOverrides = flags('relay');
+            const relayOverrides = flagsAny('relay', 'r');
             const pow = flag('pow') ? parseInt(flag('pow'), 10) : undefined;
             const powTimeoutMs = flag('pow-timeout') ? parseInt(flag('pow-timeout'), 10) : undefined;
+            const createdAtArg = flagAny('created-at', 'ts', 'time');
+            const createdAt = createdAtArg ? parseTimestamp(createdAtArg) : Math.floor(Date.now() / 1000);
             if (hasFlag('no-publish')) {
                 const { minePow } = await import('../../event/pow.js');
-                let template = {
-                    kind,
-                    created_at: Math.floor(Date.now() / 1000),
-                    tags: tagValues,
-                    content,
-                };
+                let template = { kind, created_at: createdAt, tags: tagValues, content };
                 if (pow !== undefined) {
                     template = minePow(template, { difficulty: pow, pubkey: ctx.activePublicKeyHex, timeoutMs: powTimeoutMs }).template;
                 }
@@ -32,18 +30,27 @@ export async function dispatch(cmd, _cmdArgs, h, ctx, pool) {
                 reportWarnings(validation.issues);
                 const sign = ctx.getSigningFunction();
                 const event = await sign(template);
-                console.log(JSON.stringify(event, null, 2));
+                // --envelope emits the relay wire form, ready to paste into a socket
+                console.log(hasFlag('envelope')
+                    ? JSON.stringify(['EVENT', event])
+                    : JSON.stringify(event, null, 2));
+                if (hasFlag('nevent'))
+                    printNevent(event, relayOverrides);
                 break;
             }
-            out(await handlePublishEvent(ctx, pool, {
+            const result = await handlePublishEvent(ctx, pool, {
                 kind,
                 content,
                 tags: tagValues,
+                createdAt,
                 relays: relayOverrides.length ? relayOverrides : undefined,
                 validationMode,
                 pow,
                 powTimeoutMs,
-            }));
+            });
+            out(result);
+            if (hasFlag('nevent'))
+                printNevent(result.event, relayOverrides);
             break;
         }
         case 'publish-raw': {
@@ -102,3 +109,45 @@ function reportWarnings(issues) {
             console.error(`validation warning [${entry.code}]: ${entry.message}`);
     }
 }
+/**
+ * Merge `--tag k=v` entries with the single-letter shortcuts.
+ *
+ * Shortcuts come after the explicit tags so that `-t p=<x> -p <y>` yields both,
+ * in the order written, rather than one silently replacing the other.
+ */
+function collectTags(tagArgs, shortcuts) {
+    const tags = tagArgs.map(t => {
+        const eq = t.indexOf('=');
+        if (eq === -1)
+            return [t];
+        // A value may itself contain '=', so only split on the first one
+        return [t.slice(0, eq), t.slice(eq + 1)];
+    });
+    for (const [name, values] of Object.entries(shortcuts)) {
+        for (const v of values)
+            tags.push([name, v]);
+    }
+    return tags;
+}
+/** Parse a created_at: a unix timestamp, an ISO date, or `now`. */
+function parseTimestamp(value) {
+    if (value === 'now')
+        return Math.floor(Date.now() / 1000);
+    if (/^\d+$/.test(value))
+        return Number(value);
+    const parsed = Date.parse(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`Could not read "${value}" as a timestamp. Use a unix time, an ISO date, or "now".`);
+    }
+    return Math.floor(parsed / 1000);
+}
+/** Print the nevent code to stderr, so stdout stays parseable. */
+function printNevent(event, relays) {
+    const code = nip19.neventEncode({
+        id: event.id,
+        author: event.pubkey,
+        kind: event.kind,
+        ...(relays.length ? { relays } : {}),
+    });
+    console.error(code);
+}

package/dist/cli/commands/relay.js

@@ -29,12 +29,20 @@ export async function dispatch(cmd, cmdArgs, h, ctx, pool, _activeNpub) {
             out(await handleRelayInfo(req(1, 'relay-info <wss://url>')));
             break;
         case 'req': {
-            // Support JSON filter on stdin when stdin is a pipe
+            // Support a JSON filter on stdin when stdin is a pipe. Not being a TTY
+            // does not guarantee stdin is readable — under a test runner, or a
+            // service manager that hands over a closed descriptor, the read throws
+            // EAGAIN and there is no filter to find anyway.
             let stdinFilter;
-            const isTTY = process.stdin.isTTY;
-            if (!isTTY) {
+            if (!process.stdin.isTTY) {
                 const { readFileSync } = await import('node:fs');
-                const raw = readFileSync(0, 'utf-8').trim();
+                let raw = '';
+                try {
+                    raw = readFileSync(0, 'utf-8').trim();
+                }
+                catch {
+                    raw = '';
+                }
                 if (raw)
                     stdinFilter = JSON.parse(raw);
             }
@@ -60,6 +68,59 @@ export async function dispatch(cmd, cmdArgs, h, ctx, pool, _activeNpub) {
             const paginate = hasFlag('paginate');
             const paginateIntervalMs = flag('paginate-interval') ? parseInt(flag('paginate-interval'), 10) : undefined;
             const maxPages = flag('max-pages') ? parseInt(flag('max-pages'), 10) : undefined;
+            // NIP-77 paths run before the normal REQ: both reconcile IDs with one
+            // relay rather than transferring events, which is the whole point.
+            if (hasFlag('ids-only') || hasFlag('only-missing')) {
+                const target = relayOverrides[0] ?? pool.getRelays(ctx.activeNpub).read[0];
+                if (!target)
+                    throw new Error('--ids-only and --only-missing need a relay: pass --relay <url>');
+                const negFilter = {
+                    ...(kindsRaw ? { kinds: kindsRaw.split(',').map(Number) } : {}),
+                    ...(authorsRaw ? { authors: authorsRaw.split(',') } : {}),
+                    ...(since !== undefined ? { since } : {}),
+                    ...(until !== undefined ? { until } : {}),
+                };
+                // Reconcile against what we already hold: nothing for --ids-only, the
+                // supplied jsonl for --only-missing.
+                let local = [];
+                if (hasFlag('only-missing')) {
+                    const { readFileSync } = await import('node:fs');
+                    const { validateInputPath } = await import('../../validation.js');
+                    const path = flag('only-missing');
+                    if (!path)
+                        throw new Error('Usage: req --only-missing <events.jsonl> [--relay url]');
+                    local = readFileSync(validateInputPath(path), 'utf8')
+                        .split('\n')
+                        .filter(l => l.trim())
+                        .map(l => {
+                        const e = JSON.parse(l);
+                        return { id: e.id, createdAt: e.created_at };
+                    });
+                }
+                const recon = await pool.reconcileDirect(target, local, negFilter, {
+                    timeoutMs: flag('timeout') ? parseInt(flag('timeout'), 10) : undefined,
+                    maxIds: limit,
+                });
+                if (recon.truncated) {
+                    console.error(`note: result truncated at ${recon.remoteOnlyIds.length} ids; raise --limit to see more`);
+                }
+                if (hasFlag('ids-only')) {
+                    for (const id of recon.remoteOnlyIds)
+                        console.log(id);
+                    break;
+                }
+                // --only-missing: fetch just the events we do not already have
+                if (recon.remoteOnlyIds.length === 0)
+                    break;
+                const missing = await handleRelayQuery(pool, ctx.activeNpub, {
+                    ids: recon.remoteOnlyIds,
+                    relays: [target],
+                    limit: recon.remoteOnlyIds.length,
+                });
+                for (const ev of missing)
+                    console.log(JSON.stringify(ev));
+                break;
+            }
             const queryArgs = {
                 ...(stdinFilter ?? {
                     ...(kindsRaw ? { kinds: kindsRaw.split(',').map(Number) } : {}),

package/dist/cli/dispatch.d.ts

@@ -8,6 +8,10 @@ export interface Helpers {
     flag(name: string, fallback?: string): string | undefined;
     flags(name: string): string[];
     hasFlag(name: string): boolean;
+    /** First value of whichever alias is present. Single-character names take one dash. */
+    flagAny(...names: string[]): string | undefined;
+    /** Every value across all the given aliases, in command-line order. */
+    flagsAny(...names: string[]): string[];
     out(data: unknown, humanFormatter?: (d: any) => string): void;
 }
 export type OutputMode = 'json' | 'human' | 'jsonl' | 'csv' | 'tsv';

package/dist/cli/dispatch.js

@@ -123,6 +123,26 @@ export function makeHelpers(cmdArgs, outputMode) {
         }
         return result;
     }
+    // `-k` and `--kind` should behave identically, so aliases are resolved by
+    // dash count rather than requiring every callsite to spell out both forms.
+    const asSwitch = (name) => (name.length === 1 ? `-${name}` : `--${name}`);
+    function flagAny(...names) {
+        const wanted = names.map(asSwitch);
+        for (let i = 0; i < cmdArgs.length - 1; i++) {
+            if (wanted.includes(cmdArgs[i]))
+                return cmdArgs[i + 1];
+        }
+        return undefined;
+    }
+    function flagsAny(...names) {
+        const wanted = names.map(asSwitch);
+        const result = [];
+        for (let i = 0; i < cmdArgs.length - 1; i++) {
+            if (wanted.includes(cmdArgs[i]))
+                result.push(cmdArgs[i + 1]);
+        }
+        return result;
+    }
     function out(data, humanFormatter) {
         switch (outputMode) {
             case 'jsonl':
@@ -152,7 +172,7 @@ export function makeHelpers(cmdArgs, outputMode) {
                 }
         }
     }
-    return { req, flag, flags, hasFlag, out };
+    return { req, flag, flags, hasFlag, flagAny, flagsAny, out };
 }
 /** Parse a shell line into args, respecting quotes */
 export function parseShellLine(line) {

package/dist/cli/index.js

@@ -61,6 +61,7 @@ if (command === 'serve' && !args.includes('--help')) {
         quiet: args.includes('--quiet'),
         auth: args.includes('--auth') || args.includes('--eager-auth'),
         eagerAuth: args.includes('--eager-auth'),
+        blossom: args.includes('--blossom'),
     });
     console.error(`nostr-bray test relay running at ${relayServer.url}`);
     console.error('Press Ctrl+C to stop');
@@ -203,7 +204,16 @@ Safety:
 
 Utility:
   req [--kinds N,N] [--authors hex,hex] [--since ts] [--limit N] [--relay url] [--min-trust level]  Query events
-  event --kind N [--tag k=v] [--content s] [--relay url] [--validation strict-known|off]  Validate, sign and publish an arbitrary event
+      [--paginate]                    Walk 'until' backwards until --limit is met
+                                      (--max-pages N caps round-trips, default 20;
+                                       --paginate-interval ms waits between pages)
+      [--ids-only]                    Fetch only event IDs, via NIP-77 negentropy
+      [--only-missing <events.jsonl>] Fetch only events absent from that file (NIP-77)
+  event -k <number|name> [-c content] [-t k=v] [-p pk] [-e id] [-d ident] [-h group]
+        [--relay url] [--pow N] [--created-at ts|ISO|now] [--envelope] [--nevent]
+        [--validation strict-known|off] [--no-publish]
+                                      Validate, sign and publish an arbitrary event.
+                                      -k takes a kind number or a registry name, e.g. -k "short text note"
   validate-event [event-json|--file path] [--validation strict-known|off]  Semantic protocol validation (no signature check)
   publish-raw [--file path] [--report] [--timeout ms] [--quorum n] [--validation strict-known|off]  Validate, sign+broadcast event
   subscribe [--kinds N,N] [--authors hex] [--relay url]  Live-tail events to stdout (JSONL) until SIGINT
@@ -236,7 +246,7 @@ MuSig2 (BIP-327 multi-signature):
 
 Modes:
   (no command)                        Start MCP server (stdio)
-  serve [--port N] [--events file] [--auth] [--eager-auth]  Start in-memory test relay
+  serve [--port N] [--events file] [--auth] [--eager-auth] [--blossom]  Start in-memory test relay
                                       (--auth requires NIP-42; --eager-auth also challenges on connect)
   bunker connect <bunker://…>              Save remote bunker URI for future commands
   bunker authorize <hex-pubkey>           Pre-authorise an app pubkey on the local bunker

package/dist/event-validation/kind-lookup.d.ts

@@ -46,3 +46,14 @@ export declare function lookupKind(kind: number): KindInfo;
  * dozens of kinds whose descriptions merely contain "note".
  */
 export declare function searchKinds(query: string, limit?: number): KindInfo[];
+/**
+ * Resolve a kind given either a number or a description.
+ *
+ * `-k 1` and `-k "short text note"` should both work, which is what nak does
+ * and what makes the CLI usable without memorising kind numbers. An ambiguous
+ * name is an error rather than a guess: silently picking one of several
+ * matching kinds would publish the wrong thing.
+ *
+ * @throws if the name matches no kind, or more than one.
+ */
+export declare function resolveKind(input: string): number;

package/dist/event-validation/kind-lookup.js

@@ -84,3 +84,44 @@ export function searchKinds(query, limit = 20) {
     scored.sort((a, b) => a.score - b.score || a.kind - b.kind);
     return scored.slice(0, limit).map(s => lookupKind(s.kind));
 }
+/**
+ * Resolve a kind given either a number or a description.
+ *
+ * `-k 1` and `-k "short text note"` should both work, which is what nak does
+ * and what makes the CLI usable without memorising kind numbers. An ambiguous
+ * name is an error rather than a guess: silently picking one of several
+ * matching kinds would publish the wrong thing.
+ *
+ * @throws if the name matches no kind, or more than one.
+ */
+export function resolveKind(input) {
+    const trimmed = input.trim();
+    if (/^\d+$/.test(trimmed))
+        return Number(trimmed);
+    const q = trimmed.toLowerCase();
+    const exact = [];
+    const partial = [];
+    for (const [k, schema] of Object.entries(PINNED_KIND_REGISTRY.kinds)) {
+        const desc = (schema.description ?? '').toLowerCase();
+        if (!desc)
+            continue;
+        if (desc === q)
+            exact.push(Number(k));
+        else if (desc.includes(q))
+            partial.push(Number(k));
+    }
+    if (exact.length === 1)
+        return exact[0];
+    if (exact.length > 1) {
+        throw new Error(`Kind name "${input}" matches several kinds: ${exact.join(', ')}. Use the number.`);
+    }
+    if (partial.length === 1)
+        return partial[0];
+    if (partial.length > 1) {
+        const shown = partial.slice(0, 8)
+            .map(k => `${k} (${PINNED_KIND_REGISTRY.kinds[String(k)].description})`)
+            .join(', ');
+        throw new Error(`Kind name "${input}" is ambiguous — matches ${partial.length}: ${shown}${partial.length > 8 ? ', …' : ''}. Use the number.`);
+    }
+    throw new Error(`No kind matches "${input}". Try: nostr-bray kind "${input}"`);
+}

package/dist/serve.d.ts

@@ -19,6 +19,13 @@ export interface ServeOptions {
     auth?: boolean;
     /** Send the AUTH challenge on connect rather than waiting for a rejection. */
     eagerAuth?: boolean;
+    /**
+     * Serve Blossom blob endpoints (BUD-01/02) alongside the relay.
+     *
+     * bray has ten blossom tools but no way to exercise them without a real
+     * blossom server, the same gap `--auth` closed for NIP-42.
+     */
+    blossom?: boolean;
 }
 export declare function startRelay(opts?: ServeOptions): {
     url: string;

package/dist/serve.js

@@ -7,7 +7,7 @@
 import { WebSocketServer, WebSocket } from 'ws';
 import { createServer } from 'node:http';
 import { readFileSync } from 'node:fs';
-import { randomBytes } from 'node:crypto';
+import { randomBytes, createHash } from 'node:crypto';
 import { verifyEvent } from 'nostr-tools/pure';
 let subCounter = 0;
 /** Check if an event matches a single filter */
@@ -64,12 +64,137 @@ function checkAuthEvent(event, challenge) {
         return 'auth event timestamp too far from now';
     return undefined;
 }
+const SHA256_PATH = /^\/([0-9a-f]{64})(\.[a-z0-9]+)?$/i;
+const LIST_PATH = /^\/list\/([0-9a-f]{64})$/i;
+/** 10 MiB, matching what the client refuses to send. */
+const MAX_BLOB = 10 * 1024 * 1024;
+/** Does this URL belong to the Blossom surface rather than the relay? */
+function isBlossomRequest(url) {
+    const path = url.split('?')[0];
+    return path === '/upload' || SHA256_PATH.test(path) || LIST_PATH.test(path);
+}
+/**
+ * Check a BUD-01 `Authorization: Nostr <base64 kind 24242>` header.
+ *
+ * Returns the uploader pubkey, or a reason to reject. The `t` and `x` tags are
+ * both checked: without `x` an upload authorisation could be replayed to
+ * delete a different blob, which is the whole point of binding it to a hash.
+ */
+function checkBlossomAuth(header, action, sha256) {
+    if (!header?.startsWith('Nostr '))
+        return { error: 'missing Nostr authorization header' };
+    let event;
+    try {
+        event = JSON.parse(Buffer.from(header.slice(6), 'base64').toString('utf8'));
+    }
+    catch {
+        return { error: 'authorization header is not base64-encoded JSON' };
+    }
+    if (event.kind !== 24242)
+        return { error: `expected kind 24242, got ${event.kind}` };
+    if (!verifyEvent(event))
+        return { error: 'invalid signature' };
+    const t = event.tags?.find(tag => tag[0] === 't')?.[1];
+    if (t !== action)
+        return { error: `authorization is for "${t}", not "${action}"` };
+    const expiration = event.tags?.find(tag => tag[0] === 'expiration')?.[1];
+    if (expiration && Number(expiration) < Math.floor(Date.now() / 1000)) {
+        return { error: 'authorization expired' };
+    }
+    if (sha256) {
+        const x = event.tags?.filter(tag => tag[0] === 'x').map(tag => tag[1]) ?? [];
+        if (!x.includes(sha256))
+            return { error: 'authorization does not name this blob hash' };
+    }
+    return { pubkey: event.pubkey };
+}
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        req.on('data', (c) => {
+            size += c.length;
+            if (size > MAX_BLOB) {
+                reject(new Error(`blob exceeds ${MAX_BLOB} bytes`));
+                req.destroy();
+                return;
+            }
+            chunks.push(c);
+        });
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+/** Serve BUD-01/02: PUT /upload, GET|HEAD /<sha256>, GET /list/<pubkey>, DELETE /<sha256>. */
+async function serveBlossom(req, res, blobs, hostname, log) {
+    const path = (req.url ?? '/').split('?')[0];
+    const port = (req.socket.localPort ?? 0);
+    const base = `http://${hostname}:${port}`;
+    const json = (code, body) => {
+        res.writeHead(code, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    };
+    try {
+        if (path === '/upload' && req.method === 'PUT') {
+            const body = await readBody(req);
+            const sha256 = createHash('sha256').update(body).digest('hex');
+            const auth = checkBlossomAuth(req.headers.authorization, 'upload', sha256);
+            if ('error' in auth)
+                return json(401, { message: auth.error });
+            const type = req.headers['content-type'] ?? 'application/octet-stream';
+            const uploaded = Math.floor(Date.now() / 1000);
+            blobs.set(sha256, { data: body, type: String(type), uploader: auth.pubkey, uploaded });
+            log(`blossom: stored ${sha256.slice(0, 12)}… (${body.length} bytes)`);
+            return json(200, { url: `${base}/${sha256}`, sha256, size: body.length, type, uploaded });
+        }
+        const listMatch = LIST_PATH.exec(path);
+        if (listMatch && req.method === 'GET') {
+            const pubkey = listMatch[1].toLowerCase();
+            const owned = [...blobs.entries()]
+                .filter(([, b]) => b.uploader === pubkey)
+                .map(([sha256, b]) => ({ url: `${base}/${sha256}`, sha256, size: b.data.length, type: b.type, uploaded: b.uploaded }));
+            return json(200, owned);
+        }
+        const blobMatch = SHA256_PATH.exec(path);
+        if (blobMatch) {
+            const sha256 = blobMatch[1].toLowerCase();
+            const blob = blobs.get(sha256);
+            if (req.method === 'GET' || req.method === 'HEAD') {
+                if (!blob)
+                    return json(404, { message: 'blob not found' });
+                res.writeHead(200, { 'Content-Type': blob.type, 'Content-Length': String(blob.data.length) });
+                res.end(req.method === 'HEAD' ? undefined : blob.data);
+                return;
+            }
+            if (req.method === 'DELETE') {
+                const auth = checkBlossomAuth(req.headers.authorization, 'delete', sha256);
+                if ('error' in auth)
+                    return json(401, { message: auth.error });
+                if (!blob)
+                    return json(404, { message: 'blob not found' });
+                // Only the uploader may delete, otherwise anyone could clear the store
+                if (blob.uploader !== auth.pubkey)
+                    return json(403, { message: 'not the uploader of this blob' });
+                blobs.delete(sha256);
+                log(`blossom: deleted ${sha256.slice(0, 12)}…`);
+                return json(200, { message: 'deleted' });
+            }
+        }
+        json(405, { message: `method ${req.method} not allowed on ${path}` });
+    }
+    catch (e) {
+        json(400, { message: e.message });
+    }
+}
 export function startRelay(opts = {}) {
     const hostname = opts.hostname ?? 'localhost';
     const port = opts.port ?? 10547;
     const quiet = opts.quiet ?? false;
     const requireAuth = opts.auth ?? false;
     const eagerAuth = opts.eagerAuth ?? false;
+    const enableBlossom = opts.blossom ?? false;
+    /** sha256 -> blob. In memory, like the event store. */
+    const blobs = new Map();
     const log = quiet ? () => { } : (...args) => console.error('[relay]', ...args);
     // The bundled test relay has no auth and accepts arbitrary signed events.
     // Binding it to anything other than loopback exposes a writable Nostr endpoint
@@ -95,6 +220,10 @@ export function startRelay(opts = {}) {
         log(`Loaded ${events.size} events from ${opts.eventsFile}`);
     }
     const httpServer = createServer((req, res) => {
+        if (enableBlossom && isBlossomRequest(req.url ?? '/')) {
+            void serveBlossom(req, res, blobs, hostname, log);
+            return;
+        }
         // NIP-11 relay info document
         if (req.headers.accept?.includes('application/nostr+json')) {
             res.writeHead(200, { 'Content-Type': 'application/nostr+json' });

package/dist/social/handlers.d.ts

@@ -274,6 +274,8 @@ export declare function handlePublishEvent(ctx: SigningContext, pool: RelayPool,
     pow?: number;
     /** Wall-clock budget for mining, in milliseconds. */
     powTimeoutMs?: number;
+    /** Unix timestamp for created_at. Defaults to now. */
+    createdAt?: number;
 }): Promise<ValidatedPostResult & {
     pow?: Omit<MinePowResult, 'template'>;
 }>;

package/dist/social/handlers.js

@@ -480,7 +480,7 @@ export async function handleContactsUnfollow(ctx, pool, args) {
 export async function handlePublishEvent(ctx, pool, args) {
     let template = {
         kind: args.kind,
-        created_at: Math.floor(Date.now() / 1000),
+        created_at: args.createdAt ?? Math.floor(Date.now() / 1000),
         tags: args.tags ?? [],
         content: args.content,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nostr-bray",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "mcpName": "dev.forgesworn/bray",
   "description": "Trust-aware Nostr for AI and humans. Three dimensions of trust -- verification, proximity, and access -- woven into every interaction.",
   "type": "module",