@silicaclaw/cli 2026.3.19-9 → 2026.3.20-10

package/packages/core/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/core/dist/packages/core/src/identity.d.ts

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

package/packages/core/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/core/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/core/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/core/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[];

package/packages/core/dist/packages/core/src/indexing.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTag = normalizeTag;
+exports.buildTagIndexKeys = buildTagIndexKeys;
+exports.buildNamePrefixKeys = buildNamePrefixKeys;
+exports.buildIndexKeys = buildIndexKeys;
+exports.buildIndexRecords = buildIndexRecords;
+function normalizeTag(tag) {
+    return tag.trim().toLowerCase();
+}
+function buildTagIndexKeys(tags) {
+    return tags
+        .map(normalizeTag)
+        .filter(Boolean)
+        .map((tag) => `tag:${tag}`);
+}
+function buildNamePrefixKeys(displayName) {
+    const normalized = displayName.trim().toLowerCase().replace(/\s+/g, " ");
+    const collapsed = normalized.replace(/[^a-z0-9]+/g, "");
+    const source = collapsed || normalized.replace(/\s+/g, "");
+    const keys = [];
+    for (let i = 1; i <= source.length; i += 1) {
+        keys.push(`name:${source.slice(0, i)}`);
+    }
+    return keys;
+}
+function buildIndexKeys(profile) {
+    const keys = new Set();
+    for (const key of buildTagIndexKeys(profile.tags)) {
+        keys.add(key);
+    }
+    for (const key of buildNamePrefixKeys(profile.display_name)) {
+        keys.add(key);
+    }
+    return Array.from(keys);
+}
+function buildIndexRecords(profile) {
+    return buildIndexKeys(profile).map((key) => ({
+        type: "index",
+        key,
+        agent_id: profile.agent_id,
+    }));
+}

package/packages/core/dist/packages/core/src/presence.d.ts

@@ -0,0 +1,4 @@
+import { AgentIdentity } from "./types";
+import { PresenceRecord } from "./types";
+export declare function signPresence(identity: AgentIdentity, timestamp?: number): PresenceRecord;
+export declare function verifyPresence(record: PresenceRecord, publicKey: string): boolean;

package/packages/core/dist/packages/core/src/presence.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signPresence = signPresence;
+exports.verifyPresence = verifyPresence;
+const crypto_1 = require("./crypto");
+function unsignedPresence(record) {
+    const { signature: _signature, ...rest } = record;
+    return rest;
+}
+function signPresence(identity, timestamp = Date.now()) {
+    const payload = {
+        type: "presence",
+        agent_id: identity.agent_id,
+        timestamp,
+    };
+    return {
+        ...payload,
+        signature: (0, crypto_1.signPayload)(payload, identity.private_key),
+    };
+}
+function verifyPresence(record, publicKey) {
+    return (0, crypto_1.verifyPayload)(unsignedPresence(record), record.signature, publicKey);
+}

package/packages/core/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/core/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/core/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/core/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/core/dist/packages/core/src/profile.d.ts

@@ -0,0 +1,4 @@
+import { AgentIdentity, ProfileInput, PublicProfile } from "./types";
+export declare function signProfile(input: ProfileInput, identity: AgentIdentity): PublicProfile;
+export declare function verifyProfile(profile: PublicProfile, publicKey: string): boolean;
+export declare function createDefaultProfileInput(agentId: string): ProfileInput;

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signProfile = signProfile;
+exports.verifyProfile = verifyProfile;
+exports.createDefaultProfileInput = createDefaultProfileInput;
+const crypto_1 = require("./crypto");
+function payloadWithoutSignature(profile) {
+    const { signature: _signature, ...payload } = profile;
+    return payload;
+}
+function signProfile(input, identity) {
+    const unsigned = {
+        agent_id: input.agent_id,
+        display_name: input.display_name,
+        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(),
+    };
+    const signature = (0, crypto_1.signPayload)(unsigned, identity.private_key);
+    return {
+        ...unsigned,
+        signature,
+    };
+}
+function verifyProfile(profile, publicKey) {
+    return (0, crypto_1.verifyPayload)(payloadWithoutSignature(profile), profile.signature, publicKey);
+}
+function createDefaultProfileInput(agentId) {
+    return {
+        agent_id: agentId,
+        display_name: "",
+        bio: "",
+        tags: [],
+        avatar_url: "",
+        private_encryption_public_key: "",
+        public_enabled: false,
+    };
+}

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

@@ -0,0 +1,74 @@
+import { PublicProfile } from "./types";
+export type CapabilityKey = "browser" | "computer" | "research" | "openclaw";
+export type ProfileVisibility = {
+    show_tags: boolean;
+    show_last_seen: boolean;
+    show_capabilities_summary: boolean;
+};
+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;
+    last_seen_at: number | null;
+    tags: string[];
+    network_mode: string;
+    openclaw_bound: boolean;
+    capabilities_summary: string[];
+    profile_version: string;
+    public_key_fingerprint: string | null;
+    profile_updated_at: number;
+    presence_seen_at: number | null;
+    freshness_status: "live" | "recently_seen" | "stale";
+    verified_profile: boolean;
+    verified_presence_recent: boolean;
+    verification_status: "verified" | "stale" | "unverified";
+    signed_claims: {
+        display_name: string;
+        bio: string;
+        avatar_url?: string;
+        private_encryption_public_key?: string;
+        tags: string[];
+        public_enabled: boolean;
+        profile_version: string;
+        profile_updated_at: number;
+        public_key_fingerprint: string | null;
+        verified_profile: boolean;
+    };
+    observed_state: {
+        online: boolean;
+        freshness_status: "live" | "recently_seen" | "stale";
+        presence_seen_at: number | null;
+        verified_presence_recent: boolean;
+    };
+    integration_metadata: {
+        network_mode: string;
+        openclaw_bound: boolean;
+        verification_status: "verified" | "stale" | "unverified";
+    };
+    public_visibility: {
+        visible_fields: string[];
+        hidden_fields: string[];
+    };
+    visibility: ProfileVisibility;
+};
+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;
+    openclaw_bound?: boolean;
+    visibility?: Partial<ProfileVisibility>;
+    profile_version?: string;
+    public_key_fingerprint?: string | null;
+    verified_profile?: boolean;
+    now?: number;
+    presence_ttl_ms?: number;
+}): PublicProfileSummary;