libp2p-mesh 2026.6.19 → 2026.6.21

package/dist/src/instance-router.js

@@ -1,4 +1,4 @@
-import { matchesUserAttribute, mergeUserPublicAttributes } from "./user-attributes.js";
+import { matchesUserAttribute, mergeUserPublicAttributes, normalizeAttributeKey, normalizeAttributeValue, } from "./user-attributes.js";
 const MAX_DELIVERY_CACHE_ENTRIES = 1000;
 function parsePayload(msg) {
     try {
@@ -34,6 +34,25 @@ function describeAttributeMatch(match) {
     }
     return `structured attribute ${match.key}=${match.value}`;
 }
+function effectiveAttributeMatchScope(scope) {
+    return scope ?? "public";
+}
+function matchesLocalPeerLabel(attribute, match) {
+    if (match.kind !== "structured") {
+        return false;
+    }
+    return (normalizeAttributeKey(attribute.key) === normalizeAttributeKey(match.key) &&
+        normalizeAttributeValue(attribute.value) === normalizeAttributeValue(match.value));
+}
+function buildUserAttributeTarget(record, matchedAttribute, matchSource) {
+    return {
+        instanceId: record.instanceId,
+        ...(record.instanceName ? { instanceName: record.instanceName } : {}),
+        peerId: record.peerId,
+        matchedAttribute,
+        matchSource,
+    };
+}
 function displayTargetId(target) {
     const id = typeof target.id === "string" ? target.id.trim() : "";
     return id && id.length > 0 ? id : undefined;
@@ -101,6 +120,8 @@ export function createInstanceRouter(options) {
     const pendingAcks = new Map();
     const deliveryCache = new Map();
     const unsubs = [];
+    const pendingAttributePeers = new Set();
+    let attributeRefreshPromise;
     function localInstanceId() {
         const identity = mesh.getInstanceIdentity();
         if (!identity) {
@@ -108,20 +129,24 @@ export function createInstanceRouter(options) {
         }
         return identity.id;
     }
-    async function loadUserPublicAttributes() {
+    async function loadUserPublicAttributes(loadOptions) {
+        const userMdPromise = loadOptions?.refreshUserMd && options.userAttributeSource?.refreshTags
+            ? options.userAttributeSource.refreshTags()
+            : options.userAttributeSource?.loadTags() ?? Promise.resolve([]);
+        const profilePromise = options.userProfileStore?.listAttributes().catch((error) => {
+            logger?.warn?.(`[libp2p-mesh] Failed to load profile public attributes: ${summarizeError(error)}`);
+            return [];
+        }) ?? Promise.resolve([]);
         const [userMdTags, profileAttributes] = await Promise.all([
-            options.userAttributeSource?.loadTags().catch((error) => {
+            userMdPromise.catch((error) => {
                 logger?.warn?.(`[libp2p-mesh] Failed to load USER.md public attributes: ${summarizeError(error)}`);
                 return [];
-            }) ?? Promise.resolve([]),
-            options.userProfileStore?.listAttributes().catch((error) => {
-                logger?.warn?.(`[libp2p-mesh] Failed to load profile public attributes: ${summarizeError(error)}`);
-                return [];
-            }) ?? Promise.resolve([]),
+            }),
+            profilePromise,
         ]);
         return mergeUserPublicAttributes(userMdTags, profileAttributes);
     }
-    async function buildAnnouncePayload() {
+    function buildBaseAnnouncePayload() {
         const identity = mesh.getInstanceIdentity();
         if (!identity) {
             throw new Error("Local instance identity is not initialized");
@@ -132,15 +157,87 @@ export function createInstanceRouter(options) {
             instanceName: identity.name,
             multiaddrs: mesh.getMultiaddrs(),
             pubkey: identity.pubkey,
-            userPublicAttributes: await loadUserPublicAttributes(),
             announcedAt: Date.now(),
         };
     }
+    async function buildAttributeAnnouncePayload() {
+        return {
+            ...buildBaseAnnouncePayload(),
+            userPublicAttributes: await loadUserPublicAttributes({ refreshUserMd: true }),
+        };
+    }
+    function attributeAnnouncePeers(extraPeerId) {
+        const peers = new Set();
+        for (const peerId of mesh.getConnectedPeers()) {
+            if (isNonEmptyString(peerId) && peerId !== mesh.getLocalPeerId()) {
+                peers.add(peerId);
+            }
+        }
+        for (const peerId of announcedPeers) {
+            if (isNonEmptyString(peerId) && peerId !== mesh.getLocalPeerId()) {
+                peers.add(peerId);
+            }
+        }
+        if (extraPeerId && extraPeerId !== mesh.getLocalPeerId()) {
+            peers.add(extraPeerId);
+        }
+        return [...peers];
+    }
+    async function sendAttributeAnnounceToPeers(peers) {
+        if (peers.length === 0) {
+            return;
+        }
+        const payload = await buildAttributeAnnouncePayload();
+        for (const peerId of peers) {
+            try {
+                await mesh.sendStructuredMessage(peerId, {
+                    id: crypto.randomUUID(),
+                    type: "instance-announce",
+                    to: peerId,
+                    payload: JSON.stringify(payload),
+                });
+                logAnnounce("Sent", peerId, payload);
+            }
+            catch (error) {
+                logger?.warn?.(`[libp2p-mesh] Failed to send attribute announce to ${peerId}: ${summarizeError(error)}`);
+            }
+        }
+    }
+    function queueAttributeRefresh(extraPeerId) {
+        const peers = extraPeerId === undefined
+            ? attributeAnnouncePeers()
+            : isNonEmptyString(extraPeerId) && extraPeerId !== mesh.getLocalPeerId()
+                ? [extraPeerId]
+                : [];
+        for (const peerId of peers) {
+            pendingAttributePeers.add(peerId);
+        }
+        if (pendingAttributePeers.size === 0 && !attributeRefreshPromise) {
+            return;
+        }
+        drainAttributeRefresh();
+    }
+    function drainAttributeRefresh() {
+        if (!attributeRefreshPromise) {
+            attributeRefreshPromise = (async () => {
+                while (pendingAttributePeers.size > 0) {
+                    const peers = [...pendingAttributePeers];
+                    pendingAttributePeers.clear();
+                    await sendAttributeAnnounceToPeers(peers).catch((error) => {
+                        logger?.warn?.(`[libp2p-mesh] Failed to refresh public attributes: ${summarizeError(error)}`);
+                    });
+                }
+            })().finally(() => {
+                attributeRefreshPromise = undefined;
+            });
+        }
+        return attributeRefreshPromise;
+    }
     async function announceToPeer(peerId) {
         if (!isNonEmptyString(peerId) || peerId === mesh.getLocalPeerId()) {
             return;
         }
-        const payload = await buildAnnouncePayload();
+        const payload = buildBaseAnnouncePayload();
         await mesh.sendStructuredMessage(peerId, {
             id: crypto.randomUUID(),
             type: "instance-announce",
@@ -149,6 +246,13 @@ export function createInstanceRouter(options) {
         });
         announcedPeers.add(peerId);
         logAnnounce("Sent", peerId, payload);
+        queueAttributeRefresh(peerId);
+    }
+    async function refreshPublicAttributes() {
+        for (const peerId of attributeAnnouncePeers()) {
+            pendingAttributePeers.add(peerId);
+        }
+        await drainAttributeRefresh();
     }
     function announceSummary(direction, peerId, payload, changed) {
         const changedDetail = changed === undefined ? "" : ` changed=${changed}`;
@@ -475,27 +579,36 @@ export function createInstanceRouter(options) {
             error: ack.error,
         };
     }
-    async function resolveUserAttributeTargets(match) {
+    async function resolveUserAttributeTargets(match, scope) {
         const records = await store.list();
         const targets = [];
         for (const record of records) {
-            const matchedAttribute = record.userPublicAttributes?.find((attribute) => matchesUserAttribute(attribute, match));
-            if (!matchedAttribute) {
+            const publicAttribute = scope === "local"
+                ? undefined
+                : record.userPublicAttributes?.find((attribute) => matchesUserAttribute(attribute, match));
+            const localAttribute = scope === "public"
+                ? undefined
+                : (await options.peerLabelStore?.listLabels(record.instanceId))?.find((attribute) => matchesLocalPeerLabel(attribute, match));
+            if (publicAttribute && localAttribute && scope === "all") {
+                targets.push(buildUserAttributeTarget(record, publicAttribute, "all"));
                 continue;
             }
-            targets.push({
-                instanceId: record.instanceId,
-                instanceName: record.instanceName,
-                peerId: record.peerId,
-                matchedAttribute,
-            });
+            if (publicAttribute) {
+                targets.push(buildUserAttributeTarget(record, publicAttribute, "public"));
+                continue;
+            }
+            if (localAttribute) {
+                targets.push(buildUserAttributeTarget(record, localAttribute, "local"));
+            }
         }
         return targets;
     }
     async function sendUserAttributeMessage(match, message, sendOptions = {}) {
-        const targets = await resolveUserAttributeTargets(match);
+        const scope = effectiveAttributeMatchScope(sendOptions.scope);
+        const targets = await resolveUserAttributeTargets(match, scope);
         if (targets.length === 0) {
             return {
+                scope,
                 matched: 0,
                 sent: 0,
                 delivered: 0,
@@ -505,6 +618,7 @@ export function createInstanceRouter(options) {
         }
         if (sendOptions.dryRun === true) {
             return {
+                scope,
                 matched: targets.length,
                 sent: 0,
                 delivered: 0,
@@ -538,6 +652,7 @@ export function createInstanceRouter(options) {
             }
         }
         return {
+            scope,
             matched: targets.length,
             sent: results.filter((result) => result.sent).length,
             delivered: results.filter((result) => result.delivered).length,
@@ -552,6 +667,7 @@ export function createInstanceRouter(options) {
         stop,
         handleMessage,
         announceToPeer,
+        refreshPublicAttributes,
         listInstances,
         resolveInstance,
         sendInstanceMessage,

package/dist/src/labels-wizard.d.ts

@@ -0,0 +1,21 @@
+import { type SetupPrompter } from "./setup-wizard.js";
+import type { InstancePeerRecord, LocalPeerLabel } from "./types.js";
+export type PeerLabelsWriter = {
+    replaceLabels(instanceId: string, labels: LocalPeerLabel[]): Promise<void>;
+};
+export type RunLabelsWizardOptions = {
+    prompter: SetupPrompter;
+    instances: InstancePeerRecord[];
+    getLabels(instanceId: string): Promise<LocalPeerLabel[]>;
+    writer: PeerLabelsWriter;
+};
+export type LabelsWizardResult = {
+    status: "saved";
+    instanceId: string;
+    labels: LocalPeerLabel[];
+    message: string;
+} | {
+    status: "cancelled";
+    message: string;
+};
+export declare function runLabelsWizard(options: RunLabelsWizardOptions): Promise<LabelsWizardResult>;

package/dist/src/labels-wizard.js

@@ -0,0 +1,168 @@
+import { SetupCancelledError } from "./setup-wizard.js";
+import { normalizeAttributeKey } from "./user-attributes.js";
+const CANCELLED_MESSAGE = "Local labels update cancelled. No changes were written.";
+const SAVED_MESSAGE = "Local labels saved.";
+export async function runLabelsWizard(options) {
+    try {
+        if (options.instances.length === 0) {
+            options.prompter.print("No discovered instances found. Start the gateway and wait for peer announcements first.");
+            return cancelledResult();
+        }
+        options.prompter.print(formatInstancesOverview(options.instances));
+        let selectedInstance = options.instances[await selectInstanceIndex(options.prompter, options.instances)];
+        let labels = normalizeLabels(await options.getLabels(selectedInstance.instanceId));
+        options.prompter.print(formatLabelsOverview(selectedInstance, labels));
+        while (true) {
+            const action = await options.prompter.select("What do you want to do?", [
+                { label: "Add local label", value: "add-label" },
+                { label: "Edit local label", value: "edit-label" },
+                { label: "Remove local label", value: "remove-label" },
+                { label: "Choose another instance", value: "choose-instance" },
+                { label: "Save and finish", value: "save-finish" },
+                { label: "Cancel", value: "cancel" },
+            ]);
+            switch (action) {
+                case "add-label":
+                    labels = normalizeLabels([...labels, await promptForLabel(options.prompter)]);
+                    options.prompter.print(formatLabelsOverview(selectedInstance, labels));
+                    break;
+                case "edit-label":
+                    labels = await promptForLabelEdit(options.prompter, labels);
+                    options.prompter.print(formatLabelsOverview(selectedInstance, labels));
+                    break;
+                case "remove-label":
+                    labels = await promptForLabelRemoval(options.prompter, labels);
+                    options.prompter.print(formatLabelsOverview(selectedInstance, labels));
+                    break;
+                case "choose-instance":
+                    selectedInstance = options.instances[await selectInstanceIndex(options.prompter, options.instances)];
+                    labels = normalizeLabels(await options.getLabels(selectedInstance.instanceId));
+                    options.prompter.print(formatLabelsOverview(selectedInstance, labels));
+                    break;
+                case "save-finish":
+                    await options.writer.replaceLabels(selectedInstance.instanceId, labels);
+                    return {
+                        status: "saved",
+                        instanceId: selectedInstance.instanceId,
+                        labels,
+                        message: SAVED_MESSAGE,
+                    };
+                case "cancel":
+                    return cancelledResult();
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof SetupCancelledError) {
+            return cancelledResult();
+        }
+        throw error;
+    }
+}
+async function promptForLabel(prompter) {
+    const category = await prompter.select("Label category", [
+        { label: "Group", value: "group" },
+        { label: "Project", value: "project" },
+        { label: "Role", value: "role" },
+        { label: "Skill", value: "skill" },
+        { label: "Custom key", value: "custom" },
+    ]);
+    const key = category === "custom"
+        ? normalizeAttributeKey(await prompter.input("Custom key", { required: true }))
+        : category;
+    const value = await prompter.input("Label value", { required: true });
+    return { key, value: value.trim() };
+}
+async function promptForLabelEdit(prompter, labels) {
+    if (labels.length === 0) {
+        prompter.print("No local labels configured for this instance.");
+        return labels;
+    }
+    const selectedIndex = await selectLabelIndex(prompter, "Label to edit", labels);
+    const nextLabel = await promptForLabel(prompter);
+    return normalizeLabels(labels.map((label, index) => (index === selectedIndex ? nextLabel : label)));
+}
+async function promptForLabelRemoval(prompter, labels) {
+    if (labels.length === 0) {
+        prompter.print("No local labels configured for this instance.");
+        return labels;
+    }
+    const selectedIndex = await selectLabelIndex(prompter, "Label to remove", labels);
+    return labels.filter((_label, index) => index !== selectedIndex);
+}
+async function selectInstanceIndex(prompter, instances) {
+    const selectedKey = await prompter.select("Instance to label", instances.map((instance, index) => ({
+        label: formatInstance(instance),
+        value: `instance-index-${index}`,
+    })));
+    const match = /^instance-index-(\d+)$/.exec(selectedKey);
+    return match ? Number(match[1]) : 0;
+}
+async function selectLabelIndex(prompter, message, labels) {
+    const selectedKey = await prompter.select(message, labels.map((label, index) => ({
+        label: formatLabel(label),
+        value: `label-index-${index}`,
+    })));
+    const match = /^label-index-(\d+)$/.exec(selectedKey);
+    return match ? Number(match[1]) : -1;
+}
+function normalizeLabels(labels) {
+    const seen = new Set();
+    const normalized = [];
+    for (const label of labels) {
+        const key = normalizeAttributeKey(label.key);
+        const value = label.value.trim();
+        if (!key || !value) {
+            continue;
+        }
+        const id = `${key}\0${value}`;
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        normalized.push({ key, value });
+    }
+    return normalized;
+}
+function formatInstancesOverview(instances) {
+    return ["Discovered instances:", ...instances.map((instance, index) => `  ${index + 1}. ${formatInstance(instance)}`)].join("\n");
+}
+function formatLabelsOverview(instance, labels) {
+    return [
+        `Selected instance: ${formatInstance(instance)}`,
+        "",
+        "Local labels:",
+        ...formatLabelList(labels),
+    ].join("\n");
+}
+function formatLabelList(labels) {
+    if (labels.length === 0) {
+        return ["  none"];
+    }
+    return labels.map((label, index) => `  ${index + 1}. ${formatLabel(label)}`);
+}
+function formatInstance(instance) {
+    const name = instance.instanceName ? `${instance.instanceName} ` : "";
+    return `${name}${instance.instanceId} (${formatPublicAttributes(instance.userPublicAttributes ?? [])})`;
+}
+function formatPublicAttributes(attributes) {
+    if (attributes.length === 0) {
+        return "public attributes: none";
+    }
+    return `public attributes: ${attributes.map(formatPublicAttribute).join(", ")}`;
+}
+function formatPublicAttribute(attribute) {
+    if (attribute.kind === "tag") {
+        return attribute.label;
+    }
+    return `${attribute.key}: ${attribute.value}`;
+}
+function formatLabel(label) {
+    return `${label.key}: ${label.value}`;
+}
+function cancelledResult() {
+    return {
+        status: "cancelled",
+        message: CANCELLED_MESSAGE,
+    };
+}

package/dist/src/peer-label-store.d.ts

@@ -0,0 +1,11 @@
+import type { PeerLabelStore } from "./types.js";
+type PeerLabelStoreLogger = {
+    debug?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+export declare function resolvePeerLabelsPath(customPath?: string): string;
+export declare function createPeerLabelStore(options?: {
+    path?: string;
+    logger?: PeerLabelStoreLogger;
+}): PeerLabelStore;
+export {};

package/dist/src/peer-label-store.js

@@ -0,0 +1,172 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+import { normalizeAttributeKey, normalizeAttributeValue, } from "./user-attributes.js";
+export function resolvePeerLabelsPath(customPath) {
+    if (customPath)
+        return customPath;
+    const stateDir = process.env.OPENCLAW_STATE_DIR;
+    if (stateDir) {
+        return path.join(stateDir, "libp2p", "peer-labels.json");
+    }
+    return path.join(homedir(), ".openclaw", "libp2p", "peer-labels.json");
+}
+function emptyLabelsFile() {
+    return {
+        version: 1,
+        updatedAt: Date.now(),
+        peers: {},
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function trimmedString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function getLocalPeerLabelId(label) {
+    return `${normalizeAttributeKey(label.key)}:${normalizeAttributeValue(label.value)}`;
+}
+function normalizePeerLabel(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    const key = trimmedString(value.key);
+    const labelValue = trimmedString(value.value);
+    if (!key || !labelValue) {
+        return undefined;
+    }
+    return {
+        key: normalizeAttributeKey(key),
+        value: labelValue,
+    };
+}
+function normalizePeerLabels(labels) {
+    if (!Array.isArray(labels)) {
+        return [];
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const value of labels) {
+        const label = normalizePeerLabel(value);
+        if (!label) {
+            continue;
+        }
+        const id = getLocalPeerLabelId(label);
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        normalized.push(label);
+    }
+    return normalized;
+}
+function normalizePeerLabelsFile(value) {
+    const candidate = isRecord(value) ? value : {};
+    const peers = {};
+    const candidatePeers = isRecord(candidate.peers) ? candidate.peers : {};
+    for (const [instanceId, peerValue] of Object.entries(candidatePeers)) {
+        const peer = isRecord(peerValue) ? peerValue : {};
+        const labels = normalizePeerLabels(peer.labels);
+        if (labels.length === 0) {
+            continue;
+        }
+        peers[instanceId] = { labels };
+    }
+    return {
+        version: 1,
+        updatedAt: typeof candidate.updatedAt === "number" ? candidate.updatedAt : Date.now(),
+        peers,
+    };
+}
+export function createPeerLabelStore(options) {
+    const filePath = resolvePeerLabelsPath(options?.path);
+    const logger = options?.logger;
+    let cached;
+    let mutationQueue = Promise.resolve();
+    async function load() {
+        try {
+            const raw = await readFile(filePath, "utf8");
+            cached = normalizePeerLabelsFile(JSON.parse(raw));
+            return cached;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                cached = emptyLabelsFile();
+                return cached;
+            }
+            const backupPath = `${filePath}.corrupt-${Date.now()}`;
+            try {
+                await mkdir(path.dirname(filePath), { recursive: true });
+                await rename(filePath, backupPath);
+                logger?.warn?.(`[libp2p-mesh] Peer label store unreadable; moved to ${backupPath}`);
+            }
+            catch (renameError) {
+                logger?.warn?.(`[libp2p-mesh] Peer label store unreadable; failed to move corrupt file to ${backupPath}: ${renameError.message}`);
+            }
+            cached = emptyLabelsFile();
+            return cached;
+        }
+    }
+    async function save(file) {
+        const nextFile = {
+            version: 1,
+            updatedAt: Date.now(),
+            peers: normalizePeerLabelsFile(file).peers,
+        };
+        const dir = path.dirname(filePath);
+        const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+        await mkdir(dir, { recursive: true });
+        await writeFile(tmpPath, `${JSON.stringify(nextFile, null, 2)}\n`, "utf8");
+        await rename(tmpPath, filePath);
+        cached = nextFile;
+        logger?.debug?.(`[libp2p-mesh] Saved peer label store to ${filePath}`);
+        return nextFile;
+    }
+    async function runMutation(fn) {
+        const next = mutationQueue.then(fn, fn);
+        mutationQueue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    async function listRawLabels(instanceId) {
+        const file = await load();
+        return [...(file.peers[instanceId]?.labels ?? [])];
+    }
+    return {
+        load,
+        save,
+        listRawLabels,
+        async listLabels(instanceId) {
+            const labels = await listRawLabels(instanceId);
+            return labels.map((label) => ({
+                kind: "structured",
+                key: label.key,
+                value: label.value,
+                label: label.value,
+                source: "local",
+            }));
+        },
+        async replaceLabels(instanceId, labels) {
+            return runMutation(async () => {
+                const file = await load();
+                const peers = { ...file.peers };
+                const normalizedLabels = normalizePeerLabels(labels);
+                if (normalizedLabels.length === 0) {
+                    delete peers[instanceId];
+                }
+                else {
+                    peers[instanceId] = { labels: normalizedLabels };
+                }
+                return save({
+                    ...file,
+                    peers,
+                });
+            });
+        },
+    };
+}

package/dist/src/plugin.js

@@ -4,7 +4,8 @@ import { createOpenClawRuntimeInboundDelivery } from "./inbound-delivery.js";
 import { createInstancePeerStore } from "./instance-peer-store.js";
 import { createInstanceRouter } from "./instance-router.js";
 import { createMeshNetwork } from "./mesh.js";
-import { createUserMdAttributeSource } from "./user-md-attributes.js";
+import { createPeerLabelStore } from "./peer-label-store.js";
+import { createUserMdAgentAttributeSource } from "./user-md-agent-attributes.js";
 import { createUserProfileStore } from "./user-profile-store.js";
 import { buildP2PTools } from "./agent-tools.js";
 import { registerLibp2pMeshCli } from "./profile-cli.js";
@@ -12,7 +13,6 @@ export function registerLibp2pMesh(api) {
     registerLibp2pMeshWithDeps(api);
 }
 export function registerLibp2pMeshWithDeps(api, deps = {}) {
-    registerLibp2pMeshCli(api);
     const config = api.pluginConfig;
     let unsubscribeInbound;
     let serviceStarted = false;
@@ -22,7 +22,8 @@ export function registerLibp2pMeshWithDeps(api, deps = {}) {
         logger: api.logger,
     });
     const store = createInstancePeerStore({ logger: api.logger });
-    const userAttributeSource = createUserMdAttributeSource({ logger: api.logger });
+    const peerLabelStore = createPeerLabelStore({ logger: api.logger });
+    const userAttributeSource = createUserMdAgentAttributeSource({ logger: api.logger });
     const userProfileStore = createUserProfileStore({ logger: api.logger });
     const delivery = createOpenClawRuntimeInboundDelivery({
         config: api.config,
@@ -44,6 +45,14 @@ export function registerLibp2pMeshWithDeps(api, deps = {}) {
         logger: api.logger,
         userAttributeSource,
         userProfileStore,
+        peerLabelStore,
+    });
+    registerLibp2pMeshCli(api, {
+        profile: {
+            async afterProfileSave() {
+                await router.refreshPublicAttributes();
+            },
+        },
     });
     const channel = createLibp2pMeshChannel(mesh);
     function attachInboundHandlers() {
@@ -162,7 +171,7 @@ export function registerLibp2pMeshWithDeps(api, deps = {}) {
         plugin: channel,
     });
     // 3. Register Agent Tools
-    const tools = buildP2PTools(mesh, router);
+    const tools = buildP2PTools(mesh, router, { peerLabelStore });
     for (const tool of tools) {
         api.registerTool(tool);
     }