@silicaclaw/cli 2026.3.20-2 → 2026.3.20-21

package/packages/network/src/relayPreview.ts

@@ -34,6 +34,10 @@ type RelayPeer = {
   last_seen_at: number;
   messages_seen: number;
   reconnect_attempts: number;
+  meta?: {
+    signal_queue_size?: number;
+    relay_queue_size?: number;
+  };
 };
 
 type RelayDiagnostics = {
@@ -144,7 +148,8 @@ export class RelayPreviewAdapter implements NetworkAdapter {
 
   private started = false;
   private poller: NodeJS.Timeout | null = null;
-  private handlers = new Map<string, Set<(data: any) => void>>();
+  private handlers = new Map<string, Set<(data: any, meta?: { peerId?: string }) => void>>();
+  private directHandlers = new Map<string, Set<(data: any, meta?: { peerId?: string }) => void>>();
   private peers = new Map<string, RelayPeer>();
   private seenMessageIds = new Set<string>();
   private activeEndpoint = "";
@@ -227,7 +232,6 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     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 });
@@ -281,7 +285,43 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     if (!this.handlers.has(key)) {
       this.handlers.set(key, new Set());
     }
-    this.handlers.get(key)?.add(handler);
+    this.handlers.get(key)?.add(handler as (data: any, meta?: { peerId?: string }) => void);
+  }
+
+  async sendDirect(peerId: string, topic: string, data: any): Promise<void> {
+    if (!this.started) return;
+    const targetPeerId = String(peerId || "").trim();
+    if (!targetPeerId) return;
+    await this.maybeRefreshJoin("direct_send");
+    const envelope: NetworkMessageEnvelope = {
+      version: 1,
+      message_id: 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: string, handler: (data: any, meta?: { peerId?: string }) => void): void {
+    const key = `${this.namespace}:${topic}`;
+    if (!this.directHandlers.has(key)) {
+      this.directHandlers.set(key, new Set());
+    }
+    this.directHandlers.get(key)?.add(handler);
   }
 
   getDiagnostics(): RelayDiagnostics {
@@ -354,6 +394,15 @@ export class RelayPreviewAdapter implements NetworkAdapter {
         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);
       } else if (!this.lastPeerRefreshAt || Date.now() - this.lastPeerRefreshAt >= this.peerRefreshIntervalMs) {
@@ -375,11 +424,25 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     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);
   }
 
   private onEnvelope(envelope: unknown): void {
+    this.dispatchEnvelope(envelope, this.handlers);
+  }
+
+  private onDirectEnvelope(envelope: unknown, meta?: { peerId?: string }): void {
+    this.dispatchEnvelope(envelope, this.directHandlers, meta);
+  }
+
+  private dispatchEnvelope(
+    envelope: unknown,
+    handlersByTopic: Map<string, Set<(data: any, meta?: { peerId?: string }) => void>>,
+    meta?: { peerId?: string }
+  ): void {
     this.stats.received_total += 1;
     const validated = validateNetworkMessageEnvelope(envelope, {
       max_future_drift_ms: this.maxFutureDriftMs,
@@ -416,7 +479,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
 
     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);
@@ -434,7 +497,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     }
     for (const handler of handlers) {
       try {
-        handler(payload);
+        handler(payload, meta || { peerId: message.source_peer_id });
         this.stats.delivered_total += 1;
       } catch {
         this.stats.dropped_handler_error += 1;
@@ -457,9 +520,13 @@ export class RelayPreviewAdapter implements NetworkAdapter {
 
   private async joinRoom(reason: string): Promise<void> {
     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 });
   }
 
@@ -467,6 +534,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     if (!this.lastJoinAt || Date.now() - this.lastJoinAt > Math.max(45_000, this.pollIntervalMs * 6)) {
       await this.joinRoom(reason);
     }
+    this.ensurePollingAlive(reason);
   }
 
   private async get(path: string): Promise<any> {
@@ -527,13 +595,38 @@ export class RelayPreviewAdapter implements NetworkAdapter {
   }
 
   private updatePeersFromList(values: unknown[]): void {
-    const peerIds = values.map((value) => String(value || "").trim()).filter(Boolean);
+    const parsedPeers: Array<{ peer_id: string; meta?: RelayPeer["meta"] }> = [];
+    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 as Record<string, unknown>;
+        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<string, RelayPeer>();
-    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);
       if (!existing) {
@@ -546,6 +639,7 @@ export class RelayPreviewAdapter implements NetworkAdapter {
         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()) {
@@ -565,4 +659,20 @@ export class RelayPreviewAdapter implements NetworkAdapter {
       this.pollOnce().catch(() => {});
     }, Math.max(1000, delayMs + jitterMs));
   }
+
+  private ensurePollingAlive(reason: string): void {
+    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);
+  }
 }

package/packages/network/src/types.ts

@@ -3,4 +3,6 @@ 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;
 }

package/packages/storage/dist/packages/core/src/index.d.ts

@@ -4,6 +4,8 @@ export * from "./identity";
 export * from "./profile";
 export * from "./presence";
 export * from "./socialMessage";
+export * from "./privateCrypto";
+export * from "./privateMessage";
 export * from "./indexing";
 export * from "./directory";
 export * from "./publicProfileSummary";

package/packages/storage/dist/packages/core/src/index.js

@@ -20,6 +20,8 @@ __exportStar(require("./identity"), exports);
 __exportStar(require("./profile"), exports);
 __exportStar(require("./presence"), exports);
 __exportStar(require("./socialMessage"), exports);
+__exportStar(require("./privateCrypto"), exports);
+__exportStar(require("./privateMessage"), exports);
 __exportStar(require("./indexing"), exports);
 __exportStar(require("./directory"), exports);
 __exportStar(require("./publicProfileSummary"), exports);

package/packages/storage/dist/packages/core/src/privateCrypto.d.ts

@@ -0,0 +1,17 @@
+import { PrivateEncryptionKeyPair } from "./types";
+export declare function createPrivateEncryptionKeyPair(now?: number): PrivateEncryptionKeyPair;
+export declare function encryptPrivatePayload(input: {
+    plaintext: string;
+    recipient_public_key: string;
+    sender_keypair?: PrivateEncryptionKeyPair | null;
+}): {
+    ciphertext: string;
+    nonce: string;
+    sender_encryption_public_key: string;
+};
+export declare function decryptPrivatePayload(input: {
+    ciphertext: string;
+    nonce: string;
+    sender_encryption_public_key: string;
+    recipient_private_key: string;
+}): string | null;

package/packages/storage/dist/packages/core/src/privateCrypto.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrivateEncryptionKeyPair = createPrivateEncryptionKeyPair;
+exports.encryptPrivatePayload = encryptPrivatePayload;
+exports.decryptPrivatePayload = decryptPrivatePayload;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const crypto_1 = require("./crypto");
+function createPrivateEncryptionKeyPair(now = Date.now()) {
+    const pair = tweetnacl_1.default.box.keyPair();
+    return {
+        public_key: (0, crypto_1.toBase64)(pair.publicKey),
+        private_key: (0, crypto_1.toBase64)(pair.secretKey),
+        created_at: now,
+    };
+}
+function encryptPrivatePayload(input) {
+    const sender = input.sender_keypair || createPrivateEncryptionKeyPair();
+    const nonce = tweetnacl_1.default.randomBytes(tweetnacl_1.default.box.nonceLength);
+    const message = Buffer.from(String(input.plaintext || ""), "utf8");
+    const ciphertext = tweetnacl_1.default.box(new Uint8Array(message), nonce, (0, crypto_1.fromBase64)(input.recipient_public_key), (0, crypto_1.fromBase64)(sender.private_key));
+    return {
+        ciphertext: (0, crypto_1.toBase64)(ciphertext),
+        nonce: (0, crypto_1.toBase64)(nonce),
+        sender_encryption_public_key: sender.public_key,
+    };
+}
+function decryptPrivatePayload(input) {
+    try {
+        const opened = tweetnacl_1.default.box.open((0, crypto_1.fromBase64)(input.ciphertext), (0, crypto_1.fromBase64)(input.nonce), (0, crypto_1.fromBase64)(input.sender_encryption_public_key), (0, crypto_1.fromBase64)(input.recipient_private_key));
+        if (!opened)
+            return null;
+        return Buffer.from(opened).toString("utf8");
+    }
+    catch {
+        return null;
+    }
+}

package/packages/storage/dist/packages/core/src/privateMessage.d.ts

@@ -0,0 +1,23 @@
+import { AgentIdentity, PrivateMessageReceiptRecord, PrivateMessageRecord } from "./types";
+export declare 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;
+export declare function verifyPrivateMessage(record: PrivateMessageRecord): boolean;
+export declare 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;
+export declare function verifyPrivateMessageReceipt(record: PrivateMessageReceiptRecord): boolean;

package/packages/storage/dist/packages/core/src/privateMessage.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signPrivateMessage = signPrivateMessage;
+exports.verifyPrivateMessage = verifyPrivateMessage;
+exports.signPrivateMessageReceipt = signPrivateMessageReceipt;
+exports.verifyPrivateMessageReceipt = verifyPrivateMessageReceipt;
+const crypto_1 = require("./crypto");
+function unsignedPrivateMessage(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function unsignedPrivateMessageReceipt(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function signPrivateMessage(input) {
+    const payload = {
+        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: (0, crypto_1.signPayload)(payload, input.identity.private_key),
+    };
+}
+function verifyPrivateMessage(record) {
+    try {
+        if ((0, crypto_1.hashPublicKey)((0, crypto_1.fromBase64)(record.sender_public_key)) !== record.from_agent_id) {
+            return false;
+        }
+        return (0, crypto_1.verifyPayload)(unsignedPrivateMessage(record), record.signature, record.sender_public_key);
+    }
+    catch {
+        return false;
+    }
+}
+function signPrivateMessageReceipt(input) {
+    const payload = {
+        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: (0, crypto_1.signPayload)(payload, input.identity.private_key),
+    };
+}
+function verifyPrivateMessageReceipt(record) {
+    try {
+        if ((0, crypto_1.hashPublicKey)((0, crypto_1.fromBase64)(record.sender_public_key)) !== record.from_agent_id) {
+            return false;
+        }
+        return (0, crypto_1.verifyPayload)(unsignedPrivateMessageReceipt(record), record.signature, record.sender_public_key);
+    }
+    catch {
+        return false;
+    }
+}

package/packages/storage/dist/packages/core/src/profile.js

@@ -15,6 +15,7 @@ function signProfile(input, identity) {
         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 @@ function createDefaultProfileInput(agentId) {
         bio: "",
         tags: [],
         avatar_url: "",
+        private_encryption_public_key: "",
         public_enabled: false,
     };
 }

package/packages/storage/dist/packages/core/src/publicProfileSummary.d.ts

@@ -7,9 +7,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;
@@ -30,6 +32,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;
@@ -57,6 +60,7 @@ export type PublicProfileSummary = {
 export declare function deriveCapabilitiesSummary(tags: string[]): string[];
 export declare function buildPublicProfileSummary(args: {
     profile: PublicProfile;
+    is_self?: boolean;
     online: boolean;
     last_seen_at: number | null;
     network_mode?: string;

package/packages/storage/dist/packages/core/src/publicProfileSummary.js

@@ -53,9 +53,11 @@ function buildPublicProfileSummary(args) {
     ].filter((field) => Boolean(field));
     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,
@@ -76,6 +78,7 @@ 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/packages/storage/dist/packages/core/src/types.d.ts

@@ -4,12 +4,18 @@ export type AgentIdentity = {
     private_key: string;
     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;
@@ -51,6 +57,40 @@ export type SocialMessageObservationRecord = {
     observed_at: number;
     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/packages/storage/dist/packages/storage/src/repos.d.ts

@@ -1,4 +1,4 @@
-import { AgentIdentity, DirectoryState, PublicProfile } from "@silicaclaw/core";
+import { AgentIdentity, DirectoryState, PrivateEncryptionKeyPair, PrivateMessageReceiptRecord, PrivateMessageRecord, PublicProfile } from "@silicaclaw/core";
 import { JsonFileRepo } from "./jsonRepo";
 export type LogEntry = {
     id: string;
@@ -37,6 +37,20 @@ export type SocialMessageGovernanceConfig = {
     blocked_agent_ids: string[];
     blocked_terms: string[];
 };
+export type PrivateMessageDecryptedContent = {
+    body: string;
+};
+export type PrivateMessagingRuntimeState = {
+    schema_version: number;
+    app_version: string;
+    last_started_at: number;
+    encryption_public_key: string;
+    encryption_public_key_fingerprint: string;
+    message_count: number;
+    self_sent_count: number;
+    cached_plaintext_count: number;
+    warnings: string[];
+};
 export declare class IdentityRepo extends JsonFileRepo<AgentIdentity | null> {
     constructor(rootDir?: string);
 }
@@ -59,3 +73,15 @@ export declare class SocialMessageObservationRepo extends JsonFileRepo<SocialMes
 export declare class SocialMessageGovernanceRepo extends JsonFileRepo<SocialMessageGovernanceConfig> {
     constructor(rootDir?: string);
 }
+export declare class PrivateMessageRepo extends JsonFileRepo<PrivateMessageRecord[]> {
+    constructor(rootDir?: string);
+}
+export declare class PrivateMessageReceiptRepo extends JsonFileRepo<PrivateMessageReceiptRecord[]> {
+    constructor(rootDir?: string);
+}
+export declare class PrivateEncryptionKeyRepo extends JsonFileRepo<PrivateEncryptionKeyPair | null> {
+    constructor(rootDir?: string);
+}
+export declare class PrivateMessagingRuntimeRepo extends JsonFileRepo<PrivateMessagingRuntimeState> {
+    constructor(rootDir?: string);
+}

package/packages/storage/dist/packages/storage/src/repos.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SocialMessageGovernanceRepo = exports.SocialMessageObservationRepo = exports.SocialMessageRepo = exports.LogRepo = exports.CacheRepo = exports.ProfileRepo = exports.IdentityRepo = void 0;
+exports.PrivateMessagingRuntimeRepo = exports.PrivateEncryptionKeyRepo = exports.PrivateMessageReceiptRepo = exports.PrivateMessageRepo = exports.SocialMessageGovernanceRepo = exports.SocialMessageObservationRepo = exports.SocialMessageRepo = exports.LogRepo = exports.CacheRepo = exports.ProfileRepo = exports.IdentityRepo = void 0;
 const path_1 = require("path");
 const core_1 = require("@silicaclaw/core");
 const jsonRepo_1 = require("./jsonRepo");
@@ -65,3 +65,37 @@ class SocialMessageGovernanceRepo extends jsonRepo_1.JsonFileRepo {
     }
 }
 exports.SocialMessageGovernanceRepo = SocialMessageGovernanceRepo;
+class PrivateMessageRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, "data", "private-messages.json"), () => []);
+    }
+}
+exports.PrivateMessageRepo = PrivateMessageRepo;
+class PrivateMessageReceiptRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, "data", "private-message-receipts.json"), () => []);
+    }
+}
+exports.PrivateMessageReceiptRepo = PrivateMessageReceiptRepo;
+class PrivateEncryptionKeyRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, "data", "private-encryption-keypair.json"), () => null);
+    }
+}
+exports.PrivateEncryptionKeyRepo = PrivateEncryptionKeyRepo;
+class PrivateMessagingRuntimeRepo extends jsonRepo_1.JsonFileRepo {
+    constructor(rootDir = process.cwd()) {
+        super((0, path_1.resolve)(rootDir, ".silicaclaw", "private-messaging.runtime.json"), () => ({
+            schema_version: 1,
+            app_version: "",
+            last_started_at: 0,
+            encryption_public_key: "",
+            encryption_public_key_fingerprint: "",
+            message_count: 0,
+            self_sent_count: 0,
+            cached_plaintext_count: 0,
+            warnings: [],
+        }));
+    }
+}
+exports.PrivateMessagingRuntimeRepo = PrivateMessagingRuntimeRepo;

package/packages/storage/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@silicaclaw/storage",
   "version": "0.1.0",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "dist/packages/storage/src/index.js",
+  "types": "dist/packages/storage/src/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.json",
     "check": "tsc -p tsconfig.json --noEmit"