nostr-bray 2.1.0 → 2.2.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

@@ -203,7 +203,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

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/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.2.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",