@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/packages/network/src/realPreview.ts

@@ -12,6 +12,7 @@ import { JsonMessageEnvelopeCodec } from "./codec/jsonMessageEnvelopeCodec";
 import { JsonTopicCodec } from "./codec/jsonTopicCodec";
 import { UdpLanBroadcastTransport } from "./transport/udpLanBroadcastTransport";
 import { HeartbeatPeerDiscovery } from "./discovery/heartbeatPeerDiscovery";
+import defaults from "../../../config/silicaclaw-defaults.json";
 
 type RealNetworkAdapterPreviewOptions = {
   peerId?: string;
@@ -124,7 +125,7 @@ export class RealNetworkAdapterPreview implements NetworkAdapter {
 
   constructor(options: RealNetworkAdapterPreviewOptions = {}) {
     this.peerId = options.peerId ?? `peer-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
-    this.namespace = this.normalizeNamespace(options.namespace ?? "silicaclaw.preview");
+    this.namespace = this.normalizeNamespace(options.namespace ?? defaults.network.default_namespace);
     this.transport = options.transport ?? new UdpLanBroadcastTransport();
     this.envelopeCodec = options.envelopeCodec ?? new JsonMessageEnvelopeCodec();
     this.topicCodec = options.topicCodec ?? new JsonTopicCodec();
@@ -424,7 +425,7 @@ export class RealNetworkAdapterPreview implements NetworkAdapter {
 
   private normalizeNamespace(namespace: string): string {
     const normalized = namespace.trim();
-    return normalized.length > 0 ? normalized : "silicaclaw.preview";
+    return normalized.length > 0 ? normalized : defaults.network.default_namespace;
   }
 
   private errorMessage(error: unknown): string {

package/packages/network/src/relayPreview.ts

@@ -8,6 +8,7 @@ import {
 import { TopicCodec } from "./abstractions/topicCodec";
 import { JsonMessageEnvelopeCodec } from "./codec/jsonMessageEnvelopeCodec";
 import { JsonTopicCodec } from "./codec/jsonTopicCodec";
+import defaults from "../../../config/silicaclaw-defaults.json";
 
 type RelayPreviewOptions = {
   peerId?: string;
@@ -33,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 = {
@@ -143,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 = "";
@@ -196,7 +202,8 @@ export class RelayPreviewAdapter implements NetworkAdapter {
 
   constructor(options: RelayPreviewOptions = {}) {
     this.peerId = options.peerId ?? `peer-${process.pid}-${Math.random().toString(36).slice(2, 10)}`;
-    this.namespace = String(options.namespace || "silicaclaw.preview").trim() || "silicaclaw.preview";
+    this.namespace =
+      String(options.namespace || defaults.network.default_namespace).trim() || defaults.network.default_namespace;
     this.signalingEndpoints = dedupe(
       (options.signalingUrls && options.signalingUrls.length > 0
         ? options.signalingUrls
@@ -204,7 +211,8 @@ export class RelayPreviewAdapter implements NetworkAdapter {
     );
     this.activeEndpoint = this.signalingEndpoints[0] || "http://localhost:4510";
     this.activeEndpointIndex = 0;
-    this.room = String(options.room || "silicaclaw-global-preview").trim() || "silicaclaw-global-preview";
+    this.room =
+      String(options.room || defaults.network.global_preview.room).trim() || defaults.network.global_preview.room;
     this.seedPeers = dedupe(options.seedPeers || []);
     this.bootstrapHints = dedupe(options.bootstrapHints || []);
     this.bootstrapSources = dedupe(options.bootstrapSources || []);
@@ -224,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 });
@@ -278,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 {
@@ -351,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) {
@@ -372,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,
@@ -413,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);
@@ -431,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;
@@ -454,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 });
   }
 
@@ -464,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> {
@@ -524,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) {
@@ -543,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()) {
@@ -562,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/transport/udpLanBroadcastTransport.ts

@@ -1,4 +1,5 @@
 import dgram from "dgram";
+import defaults from "../../../../config/silicaclaw-defaults.json";
 import {
   NetworkTransport,
   TransportConfigSnapshot,
@@ -38,7 +39,7 @@ export class UdpLanBroadcastTransport implements NetworkTransport {
   private broadcastAddress: string;
 
   constructor(options: UdpLanBroadcastTransportOptions = {}) {
-    this.port = options.port ?? 44123;
+    this.port = options.port ?? defaults.ports.network_default;
     this.bindAddress = options.bindAddress ?? "0.0.0.0";
     this.broadcastAddress = options.broadcastAddress ?? "255.255.255.255";
   }

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/network/src/webrtcPreview.ts

@@ -8,6 +8,7 @@ import {
 import { TopicCodec } from "./abstractions/topicCodec";
 import { JsonMessageEnvelopeCodec } from "./codec/jsonMessageEnvelopeCodec";
 import { JsonTopicCodec } from "./codec/jsonTopicCodec";
+import defaults from "../../../config/silicaclaw-defaults.json";
 
 type WebRTCPreviewOptions = {
   peerId?: string;
@@ -261,7 +262,7 @@ export class WebRTCPreviewAdapter implements NetworkAdapter {
 
   constructor(options: WebRTCPreviewOptions = {}) {
     this.peerId = options.peerId ?? `webrtc-${process.pid}-${Math.random().toString(36).slice(2, 9)}`;
-    this.namespace = (options.namespace ?? "silicaclaw.preview").trim() || "silicaclaw.preview";
+    this.namespace = (options.namespace ?? defaults.network.default_namespace).trim() || defaults.network.default_namespace;
     const configuredSignalingUrls = dedupeArray([
       ...(options.signalingUrls ?? []),
       options.signalingUrl ?? "",

package/packages/storage/config/silicaclaw-defaults.json

@@ -0,0 +1,19 @@
+{
+  "ports": {
+    "local_console": 4310,
+    "public_explorer": 4311,
+    "openclaw_gateway": 18789,
+    "network_default": 44123
+  },
+  "network": {
+    "default_mode": "global-preview",
+    "default_namespace": "silicaclaw.preview",
+    "global_preview": {
+      "relay_url": "https://relay.silicaclaw.com",
+      "room": "silicaclaw-global-preview"
+    }
+  },
+  "bridge": {
+    "api_base": "http://localhost:4310"
+  }
+}

package/packages/storage/dist/config/silicaclaw-defaults.json

@@ -0,0 +1,19 @@
+{
+    "ports": {
+        "local_console": 4310,
+        "public_explorer": 4311,
+        "openclaw_gateway": 18789,
+        "network_default": 44123
+    },
+    "network": {
+        "default_mode": "global-preview",
+        "default_namespace": "silicaclaw.preview",
+        "global_preview": {
+            "relay_url": "https://relay.silicaclaw.com",
+            "room": "silicaclaw-global-preview"
+        }
+    },
+    "bridge": {
+        "api_base": "http://localhost:4310"
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare function toBase64(input: Uint8Array): string;
+export declare function fromBase64(input: string): Uint8Array;
+export declare function hashPublicKey(publicKey: Uint8Array): string;
+export declare function stableStringify(input: unknown): string;
+export declare function signPayload(payload: unknown, privateKeyBase64: string): string;
+export declare function verifyPayload(payload: unknown, signatureBase64: string, publicKeyBase64: string): boolean;

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

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBase64 = toBase64;
+exports.fromBase64 = fromBase64;
+exports.hashPublicKey = hashPublicKey;
+exports.stableStringify = stableStringify;
+exports.signPayload = signPayload;
+exports.verifyPayload = verifyPayload;
+const crypto_1 = require("crypto");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+function toBase64(input) {
+    return Buffer.from(input).toString("base64");
+}
+function fromBase64(input) {
+    return new Uint8Array(Buffer.from(input, "base64"));
+}
+function hashPublicKey(publicKey) {
+    return (0, crypto_1.createHash)("sha256").update(publicKey).digest("hex");
+}
+function stableStringify(input) {
+    if (input === null || typeof input !== "object") {
+        return JSON.stringify(input);
+    }
+    if (Array.isArray(input)) {
+        return `[${input.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    const entries = Object.entries(input)
+        .filter(([, value]) => value !== undefined)
+        .sort(([a], [b]) => a.localeCompare(b));
+    return `{${entries
+        .map(([key, value]) => `${JSON.stringify(key)}:${stableStringify(value)}`)
+        .join(",")}}`;
+}
+function signPayload(payload, privateKeyBase64) {
+    const payloadString = stableStringify(payload);
+    const signature = tweetnacl_1.default.sign.detached(Buffer.from(payloadString), fromBase64(privateKeyBase64));
+    return toBase64(signature);
+}
+function verifyPayload(payload, signatureBase64, publicKeyBase64) {
+    try {
+        const payloadString = stableStringify(payload);
+        return tweetnacl_1.default.sign.detached.verify(Buffer.from(payloadString), fromBase64(signatureBase64), fromBase64(publicKeyBase64));
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,17 @@
+import { DirectoryState, IndexRefRecord, PresenceRecord, PublicProfile, SignedProfileRecord } from "./types";
+export declare const DEFAULT_PRESENCE_TTL_MS = 30000;
+export declare function createEmptyDirectoryState(): DirectoryState;
+export declare function ingestProfileRecord(state: DirectoryState, record: SignedProfileRecord): DirectoryState;
+export declare function ingestPresenceRecord(state: DirectoryState, record: PresenceRecord): DirectoryState;
+export declare function ingestIndexRecord(state: DirectoryState, record: IndexRefRecord): DirectoryState;
+export declare function isAgentOnline(lastSeenAt: number | undefined, now?: number, ttlMs?: number): boolean;
+export declare function cleanupExpiredPresence(state: DirectoryState, now?: number, ttlMs?: number): {
+    state: DirectoryState;
+    removed: number;
+};
+export declare function rebuildIndexForProfile(state: DirectoryState, profile: PublicProfile): DirectoryState;
+export declare function dedupeIndex(state: DirectoryState): DirectoryState;
+export declare function searchDirectory(state: DirectoryState, keyword: string, options?: {
+    now?: number;
+    presenceTTLms?: number;
+}): PublicProfile[];

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

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PRESENCE_TTL_MS = void 0;
+exports.createEmptyDirectoryState = createEmptyDirectoryState;
+exports.ingestProfileRecord = ingestProfileRecord;
+exports.ingestPresenceRecord = ingestPresenceRecord;
+exports.ingestIndexRecord = ingestIndexRecord;
+exports.isAgentOnline = isAgentOnline;
+exports.cleanupExpiredPresence = cleanupExpiredPresence;
+exports.rebuildIndexForProfile = rebuildIndexForProfile;
+exports.dedupeIndex = dedupeIndex;
+exports.searchDirectory = searchDirectory;
+const indexing_1 = require("./indexing");
+exports.DEFAULT_PRESENCE_TTL_MS = 30_000;
+function createEmptyDirectoryState() {
+    return {
+        profiles: {},
+        presence: {},
+        index: {},
+    };
+}
+function ingestProfileRecord(state, record) {
+    const next = {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: { ...state.index },
+    };
+    next.profiles[record.profile.agent_id] = record.profile;
+    return rebuildIndexForProfile(next, record.profile);
+}
+function ingestPresenceRecord(state, record) {
+    return {
+        profiles: { ...state.profiles },
+        presence: {
+            ...state.presence,
+            [record.agent_id]: record.timestamp,
+        },
+        index: { ...state.index },
+    };
+}
+function ingestIndexRecord(state, record) {
+    const existing = new Set(state.index[record.key] ?? []);
+    if (existing.has(record.agent_id)) {
+        return state;
+    }
+    existing.add(record.agent_id);
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: {
+            ...state.index,
+            [record.key]: Array.from(existing),
+        },
+    };
+}
+function isAgentOnline(lastSeenAt, now = Date.now(), ttlMs = exports.DEFAULT_PRESENCE_TTL_MS) {
+    if (!lastSeenAt) {
+        return false;
+    }
+    return now - lastSeenAt <= ttlMs;
+}
+function cleanupExpiredPresence(state, now = Date.now(), ttlMs = exports.DEFAULT_PRESENCE_TTL_MS) {
+    let removed = 0;
+    const presence = {};
+    for (const [agentId, timestamp] of Object.entries(state.presence)) {
+        if (isAgentOnline(timestamp, now, ttlMs)) {
+            presence[agentId] = timestamp;
+        }
+        else {
+            removed += 1;
+        }
+    }
+    if (removed === 0) {
+        return { state, removed: 0 };
+    }
+    return {
+        state: {
+            profiles: { ...state.profiles },
+            presence,
+            index: { ...state.index },
+        },
+        removed,
+    };
+}
+function rebuildIndexForProfile(state, profile) {
+    const keys = (0, indexing_1.buildIndexKeys)(profile);
+    const nextIndex = {};
+    for (const [key, ids] of Object.entries(state.index)) {
+        const filtered = ids.filter((id) => id !== profile.agent_id);
+        if (filtered.length > 0) {
+            nextIndex[key] = Array.from(new Set(filtered));
+        }
+    }
+    for (const key of keys) {
+        const existing = new Set(nextIndex[key] ?? []);
+        existing.add(profile.agent_id);
+        nextIndex[key] = Array.from(existing);
+    }
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index: nextIndex,
+    };
+}
+function dedupeIndex(state) {
+    const index = {};
+    for (const [key, ids] of Object.entries(state.index)) {
+        index[key] = Array.from(new Set(ids));
+    }
+    return {
+        profiles: { ...state.profiles },
+        presence: { ...state.presence },
+        index,
+    };
+}
+function searchDirectory(state, keyword, options) {
+    const now = options?.now ?? Date.now();
+    const presenceTTLms = options?.presenceTTLms ?? exports.DEFAULT_PRESENCE_TTL_MS;
+    const normalized = keyword.trim().toLowerCase();
+    const baseList = normalized.length === 0
+        ? Object.values(state.profiles)
+        : Array.from(new Set([
+            ...(state.index[`tag:${normalized}`] ?? []),
+            ...(state.index[`name:${normalized.replace(/[^a-z0-9]+/g, "")}`] ?? []),
+        ]))
+            .map((agentId) => state.profiles[agentId])
+            .filter((profile) => Boolean(profile));
+    return baseList
+        .slice()
+        .sort((a, b) => {
+        const aOnline = isAgentOnline(state.presence[a.agent_id], now, presenceTTLms) ? 1 : 0;
+        const bOnline = isAgentOnline(state.presence[b.agent_id], now, presenceTTLms) ? 1 : 0;
+        if (aOnline !== bOnline) {
+            return bOnline - aOnline;
+        }
+        if (a.updated_at !== b.updated_at) {
+            return b.updated_at - a.updated_at;
+        }
+        const byName = a.display_name.localeCompare(b.display_name);
+        if (byName !== 0) {
+            return byName;
+        }
+        return a.agent_id.localeCompare(b.agent_id);
+    });
+}

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

@@ -0,0 +1,2 @@
+import { AgentIdentity } from "./types";
+export declare function createIdentity(now?: number): AgentIdentity;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentity = createIdentity;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const crypto_1 = require("./crypto");
+function createIdentity(now = Date.now()) {
+    const pair = tweetnacl_1.default.sign.keyPair();
+    const publicKey = (0, crypto_1.toBase64)(pair.publicKey);
+    return {
+        agent_id: (0, crypto_1.hashPublicKey)(pair.publicKey),
+        public_key: publicKey,
+        private_key: (0, crypto_1.toBase64)(pair.secretKey),
+        created_at: now,
+    };
+}

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

@@ -0,0 +1,14 @@
+export * from "./types";
+export * from "./crypto";
+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";
+export * from "./socialConfig";
+export * from "./socialResolver";
+export * from "./socialTemplate";

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

@@ -0,0 +1,30 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./crypto"), exports);
+__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);
+__exportStar(require("./socialConfig"), exports);
+__exportStar(require("./socialResolver"), exports);
+__exportStar(require("./socialTemplate"), exports);

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

@@ -0,0 +1,6 @@
+import { IndexRefRecord, PublicProfile } from "./types";
+export declare function normalizeTag(tag: string): string;
+export declare function buildTagIndexKeys(tags: string[]): string[];
+export declare function buildNamePrefixKeys(displayName: string): string[];
+export declare function buildIndexKeys(profile: PublicProfile): string[];
+export declare function buildIndexRecords(profile: PublicProfile): IndexRefRecord[];