chainlesschain 0.47.7 → 0.47.9

package/src/commands/nostr.js

@@ -14,6 +14,10 @@ import {
   getEvents,
   generateKeypair,
   mapDid,
+  publishDirectMessage,
+  decryptDirectMessage,
+  publishDeletion,
+  publishReaction,
 } from "../lib/nostr-bridge.js";
 
 export function registerNostrCommand(program) {
@@ -80,9 +84,13 @@ export function registerNostrCommand(program) {
 
   nostr
     .command("publish <content>")
-    .description("Publish a text note event")
+    .description("Publish a text note event (signed if --privkey provided)")
     .option("-k, --kind <n>", "Event kind", "1")
-    .option("-p, --pubkey <key>", "Author public key")
+    .option("-p, --pubkey <key>", "Author public key (unsigned path)")
+    .option(
+      "--privkey <hex>",
+      "Sign event with this 32-byte private key (hex). Pubkey is derived.",
+    )
     .action(async (content, options) => {
       try {
         const ctx = await bootstrap({ verbose: program.opts().verbose });
@@ -98,12 +106,17 @@ export function registerNostrCommand(program) {
           parseInt(options.kind),
           content,
           options.pubkey,
+          [],
+          options.privkey,
         );
         logger.success("Event published");
         logger.log(
-          `  ${chalk.bold("ID:")}   ${chalk.cyan(result.event.id.slice(0, 16))}...`,
+          `  ${chalk.bold("ID:")}     ${chalk.cyan(result.event.id.slice(0, 16))}...`,
+        );
+        logger.log(
+          `  ${chalk.bold("Signed:")} ${result.event.sig ? chalk.green("yes (BIP-340)") : chalk.yellow("no — will be rejected by real relays")}`,
         );
-        logger.log(`  ${chalk.bold("Sent:")} ${result.sentCount} relay(s)`);
+        logger.log(`  ${chalk.bold("Sent:")}   ${result.sentCount} relay(s)`);
         await shutdown();
       } catch (err) {
         logger.error(`Failed: ${err.message}`);
@@ -158,11 +171,12 @@ export function registerNostrCommand(program) {
         if (options.json) {
           console.log(JSON.stringify(kp, null, 2));
         } else {
-          logger.success("Keypair generated");
-          logger.log(`  ${chalk.bold("Public:")}  ${chalk.cyan(kp.publicKey)}`);
+          logger.success("Keypair generated (BIP-340 schnorr / NIP-19)");
+          logger.log(`  ${chalk.bold("npub:")}    ${chalk.cyan(kp.npub)}`);
           logger.log(
-            `  ${chalk.bold("Private:")} ${kp.privateKey.slice(0, 16)}...`,
+            `  ${chalk.bold("nsec:")}    ${chalk.yellow(kp.nsec.slice(0, 20))}…  ${chalk.dim("(keep private!)")}`,
           );
+          logger.log(`  ${chalk.bold("pubHex:")}  ${kp.publicKey}`);
         }
       } catch (err) {
         logger.error(`Failed: ${err.message}`);
@@ -182,4 +196,179 @@ export function registerNostrCommand(program) {
         process.exit(1);
       }
     });
+
+  // ── NIP-04: Encrypted Direct Message ──────────────────────────────
+
+  nostr
+    .command("dm <recipientPubkey> <plaintext>")
+    .description("Send a NIP-04 encrypted direct message (kind=4)")
+    .requiredOption("--sender-priv <hex>", "Sender's 32-byte private key (hex)")
+    .requiredOption(
+      "--sender-pub <hex>",
+      "Sender's 32-byte x-only public key (hex)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (recipientPubkey, plaintext, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureNostrTables(db);
+
+        const result = publishDirectMessage(db, {
+          senderPrivkey: options.senderPriv,
+          senderPubkey: options.senderPub,
+          recipientPubkey,
+          plaintext,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success("Encrypted DM sent");
+          logger.log(
+            `  ${chalk.bold("ID:")}   ${chalk.cyan(result.event.id.slice(0, 16))}...`,
+          );
+          logger.log(`  ${chalk.bold("Sent:")} ${result.sentCount} relay(s)`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  nostr
+    .command("dm-decrypt <eventId>")
+    .description("Decrypt a stored NIP-04 direct message by event id")
+    .requiredOption(
+      "--recipient-priv <hex>",
+      "Recipient's 32-byte private key (hex)",
+    )
+    .option("--json", "Output as JSON")
+    .action(async (eventId, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureNostrTables(db);
+
+        const events = getEvents({ kinds: [4], limit: 1000 });
+        const event = events.find((e) => e.id === eventId);
+        if (!event) {
+          logger.error(`Event not found: ${eventId}`);
+          process.exit(1);
+        }
+
+        const plaintext = decryptDirectMessage({
+          event,
+          recipientPrivkey: options.recipientPriv,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify({ success: true, plaintext }, null, 2));
+        } else {
+          logger.success("Decrypted");
+          logger.log(
+            `  ${chalk.bold("From:")}     ${chalk.cyan(event.pubkey.slice(0, 16))}...`,
+          );
+          logger.log(`  ${chalk.bold("Message:")}  ${plaintext}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── NIP-09: Event Deletion Request ─────────────────────────────────
+
+  nostr
+    .command("delete <eventIds...>")
+    .description("Publish a NIP-09 deletion request (kind=5)")
+    .option("-r, --reason <text>", "Reason for deletion", "")
+    .option("-p, --pubkey <key>", "Author public key")
+    .option("--json", "Output as JSON")
+    .action(async (eventIds, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureNostrTables(db);
+
+        const result = publishDeletion(db, {
+          eventIds,
+          reason: options.reason,
+          pubkey: options.pubkey,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(
+            `Deletion request published for ${eventIds.length} event(s)`,
+          );
+          logger.log(
+            `  ${chalk.bold("ID:")}   ${chalk.cyan(result.event.id.slice(0, 16))}...`,
+          );
+          logger.log(`  ${chalk.bold("Sent:")} ${result.sentCount} relay(s)`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // ── NIP-25: Reactions ──────────────────────────────────────────────
+
+  nostr
+    .command("react <targetEventId> <targetPubkey>")
+    .description(
+      'Publish a NIP-25 reaction (kind=7). content "+" | "-" | emoji',
+    )
+    .option("-c, --content <symbol>", "Reaction symbol", "+")
+    .option("-p, --pubkey <key>", "Author public key")
+    .option("--json", "Output as JSON")
+    .action(async (targetEventId, targetPubkey, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureNostrTables(db);
+
+        const result = publishReaction(db, {
+          targetEventId,
+          targetPubkey,
+          content: options.content,
+          pubkey: options.pubkey,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          logger.success(`Reaction "${options.content}" published`);
+          logger.log(
+            `  ${chalk.bold("ID:")}   ${chalk.cyan(result.event.id.slice(0, 16))}...`,
+          );
+          logger.log(`  ${chalk.bold("Sent:")} ${result.sentCount} relay(s)`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/commands/social.js

@@ -24,6 +24,17 @@ import {
   getChatThreads,
   getSocialStats,
 } from "../lib/social-manager.js";
+import { classifyTopic, detectLanguage } from "../lib/topic-classifier.js";
+import {
+  ensureGraphTables,
+  addEdge as graphAddEdge,
+  removeEdge as graphRemoveEdge,
+  getNeighbors as graphGetNeighbors,
+  getGraphSnapshot,
+  loadFromDb as graphLoadFromDb,
+  subscribe as graphSubscribe,
+  EDGE_TYPES,
+} from "../lib/social-graph.js";
 
 export function registerSocialCommand(program) {
   const social = program
@@ -477,4 +488,258 @@ export function registerSocialCommand(program) {
         process.exit(1);
       }
     });
+
+  // ── Analyze (topic classification, language-aware) ──────────
+
+  social
+    .command("analyze <text>")
+    .description("Classify text into topics (language-aware, multilingual)")
+    .option("-k, --top-k <n>", "Top-K topics to return", "3")
+    .option("--lang <code>", "Override detected language (zh|ja|en|other)")
+    .option("--min-score <n>", "Drop topics with rawScore <= this", "0")
+    .option("--json", "Output as JSON")
+    .action((text, options) => {
+      try {
+        const topK = Math.max(1, parseInt(options.topK, 10) || 3);
+        const minScore = Number(options.minScore) || 0;
+        const result = classifyTopic(text, {
+          topK,
+          lang: options.lang,
+          minScore,
+        });
+
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+
+        logger.log(
+          `  ${chalk.bold("Language:")} ${chalk.cyan(result.language)}`,
+        );
+        logger.log(`  ${chalk.bold("Tokens:")}   ${result.tokens.length}`);
+        if (result.topics.length === 0) {
+          logger.log(`  ${chalk.dim("(no topic matched)")}`);
+          return;
+        }
+        logger.log(`  ${chalk.bold("Top topics:")}`);
+        for (const t of result.topics) {
+          const pct = (t.score * 100).toFixed(1);
+          logger.log(
+            `    ${chalk.cyan(t.topic.padEnd(16))} ${pct}%  ` +
+              `${chalk.dim(`(raw=${t.rawScore}, hits=${t.hits})`)}`,
+          );
+        }
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  // Language-only quick helper.
+  social
+    .command("detect-lang <text>")
+    .description("Detect dominant language of text (zh|ja|en|other)")
+    .option("--json", "Output as JSON")
+    .action((text, options) => {
+      const language = detectLanguage(text);
+      if (options.json) {
+        console.log(JSON.stringify({ language }));
+      } else {
+        logger.log(chalk.cyan(language));
+      }
+    });
+
+  // ── Social Graph (realtime) ─────────────────────────────────
+
+  const graph = social
+    .command("graph")
+    .description("Social graph — typed edges, neighbors, live event stream");
+
+  graph
+    .command("add-edge <source> <target>")
+    .description(`Add a directed edge (types: ${EDGE_TYPES.join("|")})`)
+    .option("-t, --type <type>", "Edge type", "follow")
+    .option("-w, --weight <n>", "Edge weight", "1.0")
+    .option("-m, --metadata <json>", "JSON-encoded metadata")
+    .option("--json", "Output as JSON")
+    .action(async (source, target, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureGraphTables(db);
+        graphLoadFromDb(db);
+
+        const metadata = options.metadata ? JSON.parse(options.metadata) : null;
+        const result = graphAddEdge(db, source, target, options.type, {
+          weight: Number(options.weight) || 1.0,
+          metadata,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          const verb = result.created ? "added" : "updated";
+          logger.success(
+            `Edge ${verb}: ${chalk.cyan(source)} --${options.type}→ ${chalk.cyan(target)}`,
+          );
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("remove-edge <source> <target>")
+    .description("Remove a directed edge")
+    .option("-t, --type <type>", "Edge type", "follow")
+    .option("--json", "Output as JSON")
+    .action(async (source, target, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureGraphTables(db);
+        graphLoadFromDb(db);
+
+        const result = graphRemoveEdge(db, source, target, options.type);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else if (result.removed) {
+          logger.success(
+            `Edge removed: ${chalk.cyan(source)} --${options.type}→ ${chalk.cyan(target)}`,
+          );
+        } else {
+          logger.warn("Edge not found");
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("neighbors <did>")
+    .description("List neighbors of a DID")
+    .option("-d, --direction <dir>", "Direction: out | in | both", "both")
+    .option("-t, --type <type>", "Filter by edge type")
+    .option("--json", "Output as JSON")
+    .action(async (did, options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureGraphTables(db);
+        graphLoadFromDb(db);
+
+        const neighbors = graphGetNeighbors(did, {
+          direction: options.direction,
+          edgeType: options.type,
+        });
+        if (options.json) {
+          console.log(JSON.stringify({ did, neighbors }, null, 2));
+        } else if (neighbors.length === 0) {
+          logger.log(chalk.dim("(no neighbors)"));
+        } else {
+          for (const n of neighbors) logger.log(`  ${chalk.cyan(n)}`);
+        }
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("snapshot")
+    .description("Dump the full graph (nodes + edges + stats)")
+    .option("-t, --type <type>", "Filter by edge type")
+    .option("--json", "Output as JSON (default: yes — snapshot is raw)")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureGraphTables(db);
+        graphLoadFromDb(db);
+
+        const snapshot = getGraphSnapshot({ edgeType: options.type });
+        console.log(JSON.stringify(snapshot, null, 2));
+        await shutdown();
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
+
+  graph
+    .command("watch")
+    .description("Stream graph change events as NDJSON on stdout")
+    .option("-e, --events <list>", "Comma-separated event types (default: all)")
+    .option("--once", "Emit the first event then exit")
+    .action(async (options) => {
+      try {
+        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        if (!ctx.db) {
+          logger.error("Database not available");
+          process.exit(1);
+        }
+        const db = ctx.db.getDatabase();
+        ensureGraphTables(db);
+        graphLoadFromDb(db);
+
+        const events = options.events
+          ? options.events
+              .split(",")
+              .map((s) => s.trim())
+              .filter(Boolean)
+          : null;
+
+        // Announce subscription on stdout so pipelines know the stream is live.
+        process.stdout.write(
+          JSON.stringify({
+            type: "watch.started",
+            events: events || "all",
+            at: new Date().toISOString(),
+          }) + "\n",
+        );
+
+        let unsubscribe = null;
+        const stop = async () => {
+          if (unsubscribe) unsubscribe();
+          await shutdown();
+          process.exit(0);
+        };
+
+        unsubscribe = graphSubscribe(
+          (evt) => {
+            process.stdout.write(
+              JSON.stringify({ ...evt, at: new Date().toISOString() }) + "\n",
+            );
+            if (options.once) void stop();
+          },
+          events ? { events } : undefined,
+        );
+
+        process.on("SIGINT", stop);
+        process.on("SIGTERM", stop);
+      } catch (err) {
+        logger.error(`Failed: ${err.message}`);
+        process.exit(1);
+      }
+    });
 }

package/src/index.js

@@ -67,6 +67,7 @@ import { registerPqcCommand } from "./commands/pqc.js";
 // Phase 8: Communication Bridges
 import { registerNostrCommand } from "./commands/nostr.js";
 import { registerMatrixCommand } from "./commands/matrix.js";
+import { registerActivityPubCommand } from "./commands/activitypub.js";
 import { registerScimCommand } from "./commands/scim.js";
 
 // Phase 8: Infrastructure & Hardening
@@ -193,6 +194,7 @@ export function createProgram() {
   // Phase 8: Communication Bridges
   registerNostrCommand(program);
   registerMatrixCommand(program);
+  registerActivityPubCommand(program);
   registerScimCommand(program);
 
   // Phase 8: Infrastructure & Hardening