@silicaclaw/cli 2026.3.20-2 → 2026.3.20-21

package/node_modules/@silicaclaw/core/src/privateCrypto.ts

@@ -0,0 +1,57 @@
+import nacl from "tweetnacl";
+import { fromBase64, toBase64 } from "./crypto";
+import { PrivateEncryptionKeyPair } from "./types";
+
+export function createPrivateEncryptionKeyPair(now = Date.now()): PrivateEncryptionKeyPair {
+  const pair = nacl.box.keyPair();
+  return {
+    public_key: toBase64(pair.publicKey),
+    private_key: toBase64(pair.secretKey),
+    created_at: now,
+  };
+}
+
+export function encryptPrivatePayload(input: {
+  plaintext: string;
+  recipient_public_key: string;
+  sender_keypair?: PrivateEncryptionKeyPair | null;
+}): {
+  ciphertext: string;
+  nonce: string;
+  sender_encryption_public_key: string;
+} {
+  const sender = input.sender_keypair || createPrivateEncryptionKeyPair();
+  const nonce = nacl.randomBytes(nacl.box.nonceLength);
+  const message = Buffer.from(String(input.plaintext || ""), "utf8");
+  const ciphertext = nacl.box(
+    new Uint8Array(message),
+    nonce,
+    fromBase64(input.recipient_public_key),
+    fromBase64(sender.private_key),
+  );
+  return {
+    ciphertext: toBase64(ciphertext),
+    nonce: toBase64(nonce),
+    sender_encryption_public_key: sender.public_key,
+  };
+}
+
+export function decryptPrivatePayload(input: {
+  ciphertext: string;
+  nonce: string;
+  sender_encryption_public_key: string;
+  recipient_private_key: string;
+}): string | null {
+  try {
+    const opened = nacl.box.open(
+      fromBase64(input.ciphertext),
+      fromBase64(input.nonce),
+      fromBase64(input.sender_encryption_public_key),
+      fromBase64(input.recipient_private_key),
+    );
+    if (!opened) return null;
+    return Buffer.from(opened).toString("utf8");
+  } catch {
+    return null;
+  }
+}

package/node_modules/@silicaclaw/core/src/privateMessage.ts

@@ -0,0 +1,101 @@
+import {
+  AgentIdentity,
+  PrivateMessageReceiptRecord,
+  PrivateMessageRecord,
+} from "./types";
+import { fromBase64, hashPublicKey, signPayload, verifyPayload } from "./crypto";
+
+function unsignedPrivateMessage(
+  record: PrivateMessageRecord
+): Omit<PrivateMessageRecord, "signature"> {
+  const { signature: _signature, ...rest } = record;
+  return rest;
+}
+
+function unsignedPrivateMessageReceipt(
+  record: PrivateMessageReceiptRecord
+): Omit<PrivateMessageReceiptRecord, "signature"> {
+  const { signature: _signature, ...rest } = record;
+  return rest;
+}
+
+export function signPrivateMessage(input: {
+  identity: AgentIdentity;
+  message_id: string;
+  conversation_id: string;
+  to_agent_id: string;
+  sender_encryption_public_key: string;
+  recipient_encryption_public_key: string;
+  ciphertext: string;
+  nonce: string;
+  created_at?: number;
+}): PrivateMessageRecord {
+  const payload: Omit<PrivateMessageRecord, "signature"> = {
+    type: "private.message",
+    message_id: input.message_id,
+    conversation_id: input.conversation_id,
+    from_agent_id: input.identity.agent_id,
+    to_agent_id: input.to_agent_id,
+    sender_public_key: input.identity.public_key,
+    sender_encryption_public_key: input.sender_encryption_public_key,
+    recipient_encryption_public_key: input.recipient_encryption_public_key,
+    cipher_scheme: "nacl-box-v1",
+    ciphertext: input.ciphertext,
+    nonce: input.nonce,
+    created_at: input.created_at ?? Date.now(),
+  };
+
+  return {
+    ...payload,
+    signature: signPayload(payload, input.identity.private_key),
+  };
+}
+
+export function verifyPrivateMessage(record: PrivateMessageRecord): boolean {
+  try {
+    if (hashPublicKey(fromBase64(record.sender_public_key)) !== record.from_agent_id) {
+      return false;
+    }
+    return verifyPayload(unsignedPrivateMessage(record), record.signature, record.sender_public_key);
+  } catch {
+    return false;
+  }
+}
+
+export function signPrivateMessageReceipt(input: {
+  identity: AgentIdentity;
+  receipt_id: string;
+  message_id: string;
+  conversation_id: string;
+  to_agent_id: string;
+  status: "received" | "read";
+  created_at?: number;
+}): PrivateMessageReceiptRecord {
+  const payload: Omit<PrivateMessageReceiptRecord, "signature"> = {
+    type: "private.message.receipt",
+    receipt_id: input.receipt_id,
+    message_id: input.message_id,
+    conversation_id: input.conversation_id,
+    from_agent_id: input.identity.agent_id,
+    to_agent_id: input.to_agent_id,
+    sender_public_key: input.identity.public_key,
+    status: input.status,
+    created_at: input.created_at ?? Date.now(),
+  };
+
+  return {
+    ...payload,
+    signature: signPayload(payload, input.identity.private_key),
+  };
+}
+
+export function verifyPrivateMessageReceipt(record: PrivateMessageReceiptRecord): boolean {
+  try {
+    if (hashPublicKey(fromBase64(record.sender_public_key)) !== record.from_agent_id) {
+      return false;
+    }
+    return verifyPayload(unsignedPrivateMessageReceipt(record), record.signature, record.sender_public_key);
+  } catch {
+    return false;
+  }
+}

package/node_modules/@silicaclaw/core/src/profile.ts

@@ -13,6 +13,7 @@ export function signProfile(input: ProfileInput, identity: AgentIdentity): Publi
     bio: input.bio,
     tags: input.tags,
     avatar_url: input.avatar_url,
+    private_encryption_public_key: input.private_encryption_public_key,
     public_enabled: input.public_enabled,
     updated_at: Date.now(),
   };
@@ -34,6 +35,7 @@ export function createDefaultProfileInput(agentId: string): ProfileInput {
     bio: "",
     tags: [],
     avatar_url: "",
+    private_encryption_public_key: "",
     public_enabled: false,
   };
 }

package/node_modules/@silicaclaw/core/src/publicProfileSummary.ts

@@ -10,9 +10,11 @@ export type ProfileVisibility = {
 
 export type PublicProfileSummary = {
   agent_id: string;
+  is_self: boolean;
   display_name: string;
   bio: string;
   avatar_url?: string;
+  private_encryption_public_key?: string;
   public_enabled: boolean;
   updated_at: number;
   online: boolean;
@@ -33,6 +35,7 @@ export type PublicProfileSummary = {
     display_name: string;
     bio: string;
     avatar_url?: string;
+    private_encryption_public_key?: string;
     tags: string[];
     public_enabled: boolean;
     profile_version: string;
@@ -73,6 +76,7 @@ export function deriveCapabilitiesSummary(tags: string[]): string[] {
 
 export function buildPublicProfileSummary(args: {
   profile: PublicProfile;
+  is_self?: boolean;
   online: boolean;
   last_seen_at: number | null;
   network_mode?: string;
@@ -130,9 +134,11 @@ export function buildPublicProfileSummary(args: {
 
   return {
     agent_id: args.profile.agent_id,
+    is_self: Boolean(args.is_self),
     display_name: args.profile.display_name,
     bio: args.profile.bio,
     avatar_url: args.profile.avatar_url,
+    private_encryption_public_key: args.profile.private_encryption_public_key,
     public_enabled: args.profile.public_enabled,
     updated_at: args.profile.updated_at,
     online: args.online,
@@ -153,6 +159,7 @@ export function buildPublicProfileSummary(args: {
       display_name: args.profile.display_name,
       bio: args.profile.bio,
       avatar_url: args.profile.avatar_url,
+      private_encryption_public_key: args.profile.private_encryption_public_key,
       tags,
       public_enabled: args.profile.public_enabled,
       profile_version: args.profile_version ?? "v1",

package/node_modules/@silicaclaw/core/src/types.ts

@@ -5,12 +5,19 @@ export type AgentIdentity = {
   created_at: number;
 };
 
+export type PrivateEncryptionKeyPair = {
+  public_key: string;
+  private_key: string;
+  created_at: number;
+};
+
 export type PublicProfile = {
   agent_id: string;
   display_name: string;
   bio: string;
   tags: string[];
   avatar_url?: string;
+  private_encryption_public_key?: string;
   public_enabled: boolean;
   updated_at: number;
   signature: string;
@@ -58,6 +65,43 @@ export type SocialMessageObservationRecord = {
   signature: string;
 };
 
+export type PrivateMessageRecord = {
+  type: "private.message";
+  message_id: string;
+  conversation_id: string;
+  from_agent_id: string;
+  to_agent_id: string;
+  sender_public_key: string;
+  sender_encryption_public_key: string;
+  recipient_encryption_public_key: string;
+  cipher_scheme: "nacl-box-v1";
+  ciphertext: string;
+  nonce: string;
+  created_at: number;
+  signature: string;
+};
+
+export type PrivateMessageReceiptRecord = {
+  type: "private.message.receipt";
+  receipt_id: string;
+  message_id: string;
+  conversation_id: string;
+  from_agent_id: string;
+  to_agent_id: string;
+  sender_public_key: string;
+  status: "received" | "read";
+  created_at: number;
+  signature: string;
+};
+
+export type PrivateConversationSummary = {
+  conversation_id: string;
+  peer_agent_id: string;
+  last_message_at: number | null;
+  last_message_preview: string;
+  unread_count: number;
+};
+
 export type DirectoryState = {
   profiles: Record<string, PublicProfile>;
   presence: Record<string, number>;

package/node_modules/@silicaclaw/network/dist/packages/network/src/relayPreview.d.ts

@@ -22,6 +22,10 @@ type RelayPeer = {
     last_seen_at: number;
     messages_seen: number;
     reconnect_attempts: number;
+    meta?: {
+        signal_queue_size?: number;
+        relay_queue_size?: number;
+    };
 };
 type RelayDiagnostics = {
     adapter: "relay-preview";
@@ -126,6 +130,7 @@ export declare class RelayPreviewAdapter implements NetworkAdapter {
     private started;
     private poller;
     private handlers;
+    private directHandlers;
     private peers;
     private seenMessageIds;
     private activeEndpoint;
@@ -150,10 +155,16 @@ export declare class RelayPreviewAdapter implements NetworkAdapter {
     stop(): Promise<void>;
     publish(topic: string, data: any): Promise<void>;
     subscribe(topic: string, handler: (data: any) => void): void;
+    sendDirect(peerId: string, topic: string, data: any): Promise<void>;
+    subscribeDirect(topic: string, handler: (data: any, meta?: {
+        peerId?: string;
+    }) => void): void;
     getDiagnostics(): RelayDiagnostics;
     private pollOnce;
     private refreshPeers;
     private onEnvelope;
+    private onDirectEnvelope;
+    private dispatchEnvelope;
     private recordDiscovery;
     private joinRoom;
     private maybeRefreshJoin;
@@ -162,5 +173,6 @@ export declare class RelayPreviewAdapter implements NetworkAdapter {
     private requestJson;
     private updatePeersFromList;
     private scheduleNextPoll;
+    private ensurePollingAlive;
 }
 export {};

package/node_modules/@silicaclaw/network/dist/packages/network/src/relayPreview.js

@@ -31,6 +31,7 @@ class RelayPreviewAdapter {
     started = false;
     poller = null;
     handlers = new Map();
+    directHandlers = new Map();
     peers = new Map();
     seenMessageIds = new Set();
     activeEndpoint = "";
@@ -109,7 +110,6 @@ class RelayPreviewAdapter {
         try {
             await this.joinRoom("start");
             this.started = true;
-            await this.refreshPeers();
             await this.pollOnce();
             this.scheduleNextPoll(this.pollIntervalMs);
             this.recordDiscovery("signaling_connected", { endpoint: this.activeEndpoint });
@@ -166,6 +166,42 @@ class RelayPreviewAdapter {
         }
         this.handlers.get(key)?.add(handler);
     }
+    async sendDirect(peerId, topic, data) {
+        if (!this.started)
+            return;
+        const targetPeerId = String(peerId || "").trim();
+        if (!targetPeerId)
+            return;
+        await this.maybeRefreshJoin("direct_send");
+        const envelope = {
+            version: 1,
+            message_id: (0, crypto_1.randomUUID)(),
+            topic: `${this.namespace}:${topic}`,
+            source_peer_id: this.peerId,
+            timestamp: Date.now(),
+            payload: this.topicCodec.encode(topic, data),
+        };
+        const raw = this.envelopeCodec.encode(envelope);
+        if (raw.length > this.maxMessageBytes) {
+            this.stats.dropped_oversized += 1;
+            return;
+        }
+        await this.post("/direct/send", {
+            room: this.room,
+            from_peer_id: this.peerId,
+            to_peer_id: targetPeerId,
+            envelope,
+        });
+        this.lastPublishAt = Date.now();
+        this.signalingMessagesSentTotal += 1;
+    }
+    subscribeDirect(topic, handler) {
+        const key = `${this.namespace}:${topic}`;
+        if (!this.directHandlers.has(key)) {
+            this.directHandlers.set(key, new Set());
+        }
+        this.directHandlers.get(key)?.add(handler);
+    }
     getDiagnostics() {
         const peerItems = Array.from(this.peers.values()).sort((a, b) => b.last_seen_at - a.last_seen_at);
         return {
@@ -235,6 +271,15 @@ class RelayPreviewAdapter {
                 this.signalingMessagesReceivedTotal += 1;
                 this.onEnvelope(message?.envelope);
             }
+            let directMessages = Array.isArray(payload?.direct_messages) ? payload.direct_messages : null;
+            if (!directMessages) {
+                const directPayload = await this.get(`/direct/poll?room=${encodeURIComponent(this.room)}&peer_id=${encodeURIComponent(this.peerId)}`);
+                directMessages = Array.isArray(directPayload?.messages) ? directPayload.messages : [];
+            }
+            for (const message of directMessages) {
+                this.signalingMessagesReceivedTotal += 1;
+                this.onDirectEnvelope(message?.envelope, { peerId: String(message?.from_peer_id || "") || undefined });
+            }
             if (Array.isArray(payload?.peers)) {
                 this.updatePeersFromList(payload.peers);
             }
@@ -258,10 +303,18 @@ class RelayPreviewAdapter {
         const payload = await this.get(`/peers?room=${encodeURIComponent(this.room)}`);
         this.lastPeerRefreshAt = Date.now();
         this.stats.peers_refresh_succeeded += 1;
-        const peerIds = Array.isArray(payload?.peers) ? payload.peers : [];
-        this.updatePeersFromList(peerIds);
+        const peerItems = Array.isArray(payload?.peer_details) && payload.peer_details.length
+            ? payload.peer_details
+            : Array.isArray(payload?.peers) ? payload.peers : [];
+        this.updatePeersFromList(peerItems);
     }
     onEnvelope(envelope) {
+        this.dispatchEnvelope(envelope, this.handlers);
+    }
+    onDirectEnvelope(envelope, meta) {
+        this.dispatchEnvelope(envelope, this.directHandlers, meta);
+    }
+    dispatchEnvelope(envelope, handlersByTopic, meta) {
         this.stats.received_total += 1;
         const validated = (0, messageEnvelope_1.validateNetworkMessageEnvelope)(envelope, {
             max_future_drift_ms: this.maxFutureDriftMs,
@@ -300,7 +353,7 @@ class RelayPreviewAdapter {
         this.stats.received_validated += 1;
         const topicKey = message.topic;
         const topic = topicKey.slice(this.namespace.length + 1);
-        const handlers = this.handlers.get(topicKey);
+        const handlers = handlersByTopic.get(topicKey);
         if (!handlers || handlers.size === 0)
             return;
         const peer = this.peers.get(message.source_peer_id);
@@ -318,7 +371,7 @@ class RelayPreviewAdapter {
         }
         for (const handler of handlers) {
             try {
-                handler(payload);
+                handler(payload, meta || { peerId: message.source_peer_id });
                 this.stats.delivered_total += 1;
             }
             catch {
@@ -340,15 +393,20 @@ class RelayPreviewAdapter {
     }
     async joinRoom(reason) {
         this.stats.join_attempted += 1;
-        await this.post("/join", { room: this.room, peer_id: this.peerId });
+        const payload = await this.post("/join", { room: this.room, peer_id: this.peerId });
         this.lastJoinAt = Date.now();
         this.stats.join_succeeded += 1;
+        if (Array.isArray(payload?.peers)) {
+            this.updatePeersFromList(payload.peers);
+            this.lastPeerRefreshAt = this.lastJoinAt;
+        }
         this.recordDiscovery("join_ok", { endpoint: this.activeEndpoint, detail: reason });
     }
     async maybeRefreshJoin(reason) {
         if (!this.lastJoinAt || Date.now() - this.lastJoinAt > Math.max(45_000, this.pollIntervalMs * 6)) {
             await this.joinRoom(reason);
         }
+        this.ensurePollingAlive(reason);
     }
     async get(path) {
         return this.requestJson("GET", path);
@@ -406,13 +464,38 @@ class RelayPreviewAdapter {
         throw new Error(errors.join(" | "));
     }
     updatePeersFromList(values) {
-        const peerIds = values.map((value) => String(value || "").trim()).filter(Boolean);
+        const parsedPeers = [];
+        for (const value of values) {
+            if (typeof value === "string") {
+                const peerId = String(value || "").trim();
+                if (peerId) {
+                    parsedPeers.push({ peer_id: peerId });
+                }
+                continue;
+            }
+            if (value && typeof value === "object") {
+                const raw = value;
+                const peerId = String(raw.peer_id || "").trim();
+                if (!peerId) {
+                    continue;
+                }
+                parsedPeers.push({
+                    peer_id: peerId,
+                    meta: {
+                        signal_queue_size: Number(raw.signal_queue_size ?? 0),
+                        relay_queue_size: Number(raw.relay_queue_size ?? 0),
+                    },
+                });
+            }
+        }
+        const peerIds = parsedPeers.map((peer) => peer.peer_id);
         if (!peerIds.includes(this.peerId)) {
             void this.joinRoom("self_missing_from_peers").catch(() => { });
         }
         const now = Date.now();
         const next = new Map();
-        for (const peerId of peerIds) {
+        for (const peerInfo of parsedPeers) {
+            const peerId = peerInfo.peer_id;
             if (peerId === this.peerId)
                 continue;
             const existing = this.peers.get(peerId);
@@ -426,6 +509,7 @@ class RelayPreviewAdapter {
                 last_seen_at: now,
                 messages_seen: existing?.messages_seen ?? 0,
                 reconnect_attempts: existing?.reconnect_attempts ?? 0,
+                meta: peerInfo.meta || existing?.meta,
             });
         }
         for (const peerId of this.peers.keys()) {
@@ -444,5 +528,21 @@ class RelayPreviewAdapter {
             this.pollOnce().catch(() => { });
         }, Math.max(1000, delayMs + jitterMs));
     }
+    ensurePollingAlive(reason) {
+        if (!this.started)
+            return;
+        const pollStaleMs = Math.max(45_000, this.pollIntervalMs * 6);
+        const pollMissing = !this.poller;
+        const pollStale = Boolean(this.lastPollAt) && Date.now() - this.lastPollAt > pollStaleMs;
+        if (!pollMissing && !pollStale) {
+            return;
+        }
+        this.recordDiscovery("poll_recover_scheduled", {
+            endpoint: this.activeEndpoint,
+            detail: `${reason}:${pollMissing ? "missing" : "stale"}`,
+        });
+        this.currentPollDelayMs = this.pollIntervalMs;
+        this.scheduleNextPoll(0);
+    }
 }
 exports.RelayPreviewAdapter = RelayPreviewAdapter;

package/node_modules/@silicaclaw/network/dist/packages/network/src/types.d.ts

@@ -3,4 +3,8 @@ export interface NetworkAdapter {
     stop(): Promise<void>;
     publish(topic: string, data: any): Promise<void>;
     subscribe(topic: string, handler: (data: any) => void): void;
+    sendDirect?(peerId: string, topic: string, data: any): Promise<void>;
+    subscribeDirect?(topic: string, handler: (data: any, meta?: {
+        peerId?: string;
+    }) => void): void;
 }