libp2p-mesh 2026.6.12 → 2026.6.13

package/dist/src/user-attributes.js

@@ -0,0 +1,92 @@
+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;
+}
+export function normalizeAttributeValue(value) {
+    return value.trim().toLowerCase();
+}
+export function normalizeAttributeKey(key) {
+    return key.trim().toLowerCase();
+}
+export function normalizeUserPublicAttribute(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    if (value.kind === "tag") {
+        if (value.source !== "USER.md") {
+            return undefined;
+        }
+        const attributeValue = trimmedString(value.value);
+        const label = trimmedString(value.label);
+        if (!attributeValue || !label) {
+            return undefined;
+        }
+        return {
+            kind: "tag",
+            value: attributeValue,
+            label,
+            source: "USER.md",
+        };
+    }
+    if (value.kind === "structured") {
+        if (value.source !== "profile") {
+            return undefined;
+        }
+        const key = trimmedString(value.key);
+        const attributeValue = trimmedString(value.value);
+        const label = trimmedString(value.label);
+        if (!key || !attributeValue || !label) {
+            return undefined;
+        }
+        return {
+            kind: "structured",
+            key: normalizeAttributeKey(key),
+            value: attributeValue,
+            label,
+            source: "profile",
+        };
+    }
+    return undefined;
+}
+function attributeDedupeKey(attribute) {
+    if (attribute.kind === "tag") {
+        return `tag:${normalizeAttributeValue(attribute.value)}`;
+    }
+    return `structured:${normalizeAttributeKey(attribute.key)}:${normalizeAttributeValue(attribute.value)}`;
+}
+export function mergeUserPublicAttributes(userMdTags, profileAttributes) {
+    const merged = [];
+    const seen = new Set();
+    for (const rawAttribute of [...userMdTags, ...profileAttributes]) {
+        const attribute = normalizeUserPublicAttribute(rawAttribute);
+        if (!attribute) {
+            continue;
+        }
+        const key = attributeDedupeKey(attribute);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        merged.push(attribute);
+    }
+    return merged;
+}
+export function matchesUserAttribute(attribute, match) {
+    if (attribute.kind !== match.kind) {
+        return false;
+    }
+    if (attribute.kind === "tag") {
+        return normalizeAttributeValue(attribute.value) === normalizeAttributeValue(match.value);
+    }
+    if (match.kind !== "structured") {
+        return false;
+    }
+    return (normalizeAttributeKey(attribute.key) === normalizeAttributeKey(match.key) &&
+        normalizeAttributeValue(attribute.value) === normalizeAttributeValue(match.value));
+}

package/dist/src/user-md-attributes.d.ts

@@ -0,0 +1,12 @@
+import type { UserPublicAttribute } from "./types.js";
+export type UserMdAttributeSource = {
+    path?: string;
+    logger?: {
+        debug?: (message: string) => void;
+        warn?: (message: string) => void;
+    };
+};
+export declare function extractUserMdTags(markdown: string): UserPublicAttribute[];
+export declare function createUserMdAttributeSource(options?: UserMdAttributeSource): {
+    loadTags(): Promise<UserPublicAttribute[]>;
+};

package/dist/src/user-md-attributes.js

@@ -0,0 +1,202 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { normalizeAttributeValue } from "./user-attributes.js";
+const MAX_TAGS = 10;
+const MAX_TAG_LENGTH = 40;
+const FIELD_PREFIX_PATTERN = /^(?:[-*]\s*)?(?:#{1,6}\s*)?(?:name|what to call them|notes?|context|project|projects|skills?|interests?)\s*[:：-]\s*/i;
+const FIELD_LINE_PATTERN = /^(?:[-*]\s*)?(?:#{1,6}\s*)?(name|what to call them|notes?|context|project|projects|skills?|interests?)\s*[:：-]\s*(.*)$/i;
+const TEMPLATE_PATTERN = /\b(?:todo|tbd|n\/a|none|unknown|your name|add notes here|template placeholder|placeholder)\b/i;
+const EXPLICIT_LIST_SEPARATOR_PATTERN = /[,，、;；|/]/;
+const ENGLISH_TAG_PATTERN = /^(?:[A-Za-z][A-Za-z0-9]*(?:\.[A-Za-z0-9]+)?|libp2p|node\.js)$/i;
+const CHINESE_TAG_PATTERN = /[\p{Script=Han}]{2,8}/gu;
+const CHINESE_CONTEXT_PATTERNS = [
+    /(?:在|来自|加入|参与|负责)([\p{Script=Han}]{2,8})(?:做|写|用|项目|团队|实验室|方向)?/gu,
+    /(?:做|写|维护|负责|参与)([\p{Script=Han}]{2,8})(?:项目|插件|工具|方向)?/gu,
+];
+const CHINESE_SENTENCE_WORD_PATTERN = /(?:今天|明天|昨天|今晚|晚上|早上|上午|下午|八点|同步|一下|进展|开会|讨论|安排|提醒|需要|已经|可以|应该|我们|你们|他们)/u;
+const COMMON_WORDS = new Set([
+    "and",
+    "also",
+    "with",
+    "works",
+    "work",
+    "interested",
+    "in",
+    "the",
+    "for",
+    "user",
+    "name",
+    "notes",
+    "context",
+    "project",
+    "projects",
+    "skills",
+]);
+const ENGLISH_TAG_FIELDS = new Set([
+    "name",
+    "what to call them",
+    "project",
+    "projects",
+    "skill",
+    "skills",
+    "interest",
+    "interests",
+]);
+function isTemplateText(value) {
+    const trimmed = value.trim();
+    return trimmed.length === 0 || TEMPLATE_PATTERN.test(trimmed) || /^\[[^\]]+\]$/.test(trimmed);
+}
+function stripMarkdown(line) {
+    return line
+        .replace(FIELD_PREFIX_PATTERN, "")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/[*_~#>]/g, " ")
+        .trim();
+}
+function trimCandidate(value) {
+    return value
+        .replace(/^[\s"'“”‘’()[\]{}<>，。；：、,.;:!?/\\|-]+/, "")
+        .replace(/[\s"'“”‘’()[\]{}<>，。；：、,.;:!?/\\|-]+$/, "")
+        .trim();
+}
+function trimChineseCandidate(value) {
+    return trimCandidate(value)
+        .replace(/^(?:我|俺|在|和|与|跟|做|写|用|是|的|也|经常|正在|参与)+/u, "")
+        .replace(/(?:做|写|用|是|的|了|中|相关|项目|插件)+$/u, "")
+        .trim();
+}
+function isStableChineseCandidate(value) {
+    return (/^[\p{Script=Han}]{2,8}$/u.test(value) &&
+        !CHINESE_SENTENCE_WORD_PATTERN.test(value));
+}
+function collectChineseCandidates(value) {
+    const candidates = [];
+    for (const match of value.matchAll(CHINESE_TAG_PATTERN)) {
+        const candidate = trimChineseCandidate(match[0]);
+        if (isStableChineseCandidate(candidate)) {
+            candidates.push(candidate);
+        }
+    }
+    return candidates;
+}
+function looksLikeSentence(value) {
+    return /[。.!?]/.test(value) || value.split(/\s+/).filter(Boolean).length > 4;
+}
+function fieldValue(line) {
+    const match = line.match(FIELD_LINE_PATTERN);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        field: (match[1] ?? "").toLowerCase(),
+        value: stripMarkdown(match[2] ?? ""),
+    };
+}
+function isStableEnglishCandidate(value) {
+    const candidate = trimCandidate(value).replace(/^(?:and|or)\s+/i, "");
+    return (ENGLISH_TAG_PATTERN.test(candidate) &&
+        !COMMON_WORDS.has(candidate.toLowerCase()) &&
+        !/^\d+$/.test(candidate));
+}
+function allowsEnglishTags(field) {
+    return field !== undefined && ENGLISH_TAG_FIELDS.has(field);
+}
+function isValidTagCandidate(value) {
+    if (!value || value.length > MAX_TAG_LENGTH || isTemplateText(value) || looksLikeSentence(value)) {
+        return false;
+    }
+    if (/^\d+$/.test(value)) {
+        return false;
+    }
+    return true;
+}
+function pushTag(tags, seen, rawValue) {
+    const value = trimCandidate(rawValue);
+    if (!isValidTagCandidate(value)) {
+        return;
+    }
+    const key = normalizeAttributeValue(value);
+    if (seen.has(key)) {
+        return;
+    }
+    seen.add(key);
+    tags.push({
+        kind: "tag",
+        value,
+        label: value,
+        source: "USER.md",
+    });
+}
+function collectCandidates(line) {
+    const candidates = [];
+    const text = stripMarkdown(line);
+    if (isTemplateText(text)) {
+        return candidates;
+    }
+    const explicitField = fieldValue(line);
+    const explicitFieldValue = explicitField?.value;
+    if (/^[\p{Script=Han}]{2,8}$/u.test(text) && isStableChineseCandidate(text)) {
+        candidates.push(text);
+    }
+    if (EXPLICIT_LIST_SEPARATOR_PATTERN.test(text)) {
+        for (const part of text.split(EXPLICIT_LIST_SEPARATOR_PATTERN)) {
+            candidates.push(...collectChineseCandidates(part));
+            if (explicitFieldValue && allowsEnglishTags(explicitField?.field)) {
+                const value = trimCandidate(part).replace(/^(?:and|or)\s+/i, "");
+                if (isStableEnglishCandidate(value)) {
+                    candidates.push(value);
+                }
+            }
+        }
+    }
+    for (const pattern of CHINESE_CONTEXT_PATTERNS) {
+        for (const match of text.matchAll(pattern)) {
+            const value = trimChineseCandidate(match[1] ?? "");
+            if (isStableChineseCandidate(value)) {
+                candidates.push(value);
+            }
+        }
+    }
+    if (explicitField &&
+        allowsEnglishTags(explicitField.field) &&
+        !EXPLICIT_LIST_SEPARATOR_PATTERN.test(explicitField.value) &&
+        !looksLikeSentence(explicitField.value)) {
+        const value = trimCandidate(explicitField.value).replace(/^(?:and|or)\s+/i, "");
+        if (isStableEnglishCandidate(value)) {
+            candidates.push(value);
+        }
+    }
+    return candidates;
+}
+export function extractUserMdTags(markdown) {
+    const tags = [];
+    const seen = new Set();
+    for (const line of markdown.split(/\r?\n/)) {
+        for (const candidate of collectCandidates(line)) {
+            pushTag(tags, seen, candidate);
+            if (tags.length >= MAX_TAGS) {
+                return tags;
+            }
+        }
+    }
+    return tags;
+}
+export function createUserMdAttributeSource(options) {
+    const filePath = options?.path ?? path.join(process.cwd(), "USER.md");
+    const logger = options?.logger;
+    return {
+        async loadTags() {
+            try {
+                return extractUserMdTags(await readFile(filePath, "utf8"));
+            }
+            catch (error) {
+                if (error.code === "ENOENT") {
+                    return [];
+                }
+                logger?.warn?.(`[libp2p-mesh] Failed to read USER.md at ${filePath}: ${error.message}`);
+                return [];
+            }
+        },
+    };
+}

package/dist/src/user-profile-store.d.ts

@@ -0,0 +1,25 @@
+import type { UserPublicAttribute } from "./types.js";
+export type UserProfile = {
+    version: 1;
+    updatedAt: number;
+    attributes: UserPublicAttribute[];
+};
+export type UserProfileLogger = {
+    debug?: (message: string) => void;
+    warn?: (message: string) => void;
+};
+export type UserProfileAttributeTarget = string | number;
+export type UserProfileStore = {
+    load(): Promise<UserProfile>;
+    save(profile: UserProfile): Promise<UserProfile>;
+    listAttributes(): Promise<UserPublicAttribute[]>;
+    replaceAttributes(attributes: UserPublicAttribute[]): Promise<UserProfile>;
+    updateAttribute(target: UserProfileAttributeTarget, attribute: UserPublicAttribute): Promise<UserProfile>;
+    removeAttribute(target: UserProfileAttributeTarget): Promise<UserProfile>;
+};
+export declare function resolveUserProfilePath(customPath?: string): string;
+export declare function getUserProfileAttributeId(attribute: UserPublicAttribute): string;
+export declare function createUserProfileStore(options?: {
+    path?: string;
+    logger?: UserProfileLogger;
+}): UserProfileStore;

package/dist/src/user-profile-store.js

@@ -0,0 +1,187 @@
+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 resolveUserProfilePath(customPath) {
+    if (customPath)
+        return customPath;
+    const stateDir = process.env.OPENCLAW_STATE_DIR;
+    if (stateDir) {
+        return path.join(stateDir, "libp2p", "user-profile.json");
+    }
+    return path.join(homedir(), ".openclaw", "libp2p", "user-profile.json");
+}
+export function getUserProfileAttributeId(attribute) {
+    if (attribute.kind !== "structured") {
+        return "";
+    }
+    return `structured:${normalizeAttributeKey(attribute.key)}:${normalizeAttributeValue(attribute.value)}`;
+}
+function emptyProfile() {
+    return {
+        version: 1,
+        updatedAt: Date.now(),
+        attributes: [],
+    };
+}
+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 normalizeProfileAttribute(value) {
+    if (!isRecord(value) || value.kind !== "structured") {
+        return undefined;
+    }
+    if (value.source !== undefined && value.source !== "profile") {
+        return undefined;
+    }
+    const key = trimmedString(value.key);
+    const attributeValue = trimmedString(value.value);
+    const label = trimmedString(value.label);
+    if (!key || !attributeValue || !label) {
+        return undefined;
+    }
+    return {
+        kind: "structured",
+        key: normalizeAttributeKey(key),
+        value: attributeValue,
+        label,
+        source: "profile",
+    };
+}
+function normalizeProfileAttributes(attributes) {
+    if (!Array.isArray(attributes)) {
+        return [];
+    }
+    const normalized = [];
+    const seen = new Set();
+    for (const value of attributes) {
+        const attribute = normalizeProfileAttribute(value);
+        if (!attribute) {
+            continue;
+        }
+        const id = getUserProfileAttributeId(attribute);
+        if (seen.has(id)) {
+            continue;
+        }
+        seen.add(id);
+        normalized.push(attribute);
+    }
+    return normalized;
+}
+function normalizeProfile(value) {
+    const candidate = isRecord(value) ? value : {};
+    return {
+        version: 1,
+        updatedAt: typeof candidate.updatedAt === "number" ? candidate.updatedAt : Date.now(),
+        attributes: normalizeProfileAttributes(candidate.attributes),
+    };
+}
+function resolveTargetIndex(attributes, target) {
+    if (typeof target === "number") {
+        return Number.isInteger(target) && target >= 0 && target < attributes.length ? target : -1;
+    }
+    return attributes.findIndex((attribute) => getUserProfileAttributeId(attribute) === target);
+}
+export function createUserProfileStore(options) {
+    const filePath = resolveUserProfilePath(options?.path);
+    const logger = options?.logger;
+    let cached;
+    let mutationQueue = Promise.resolve();
+    async function load() {
+        try {
+            const raw = await readFile(filePath, "utf8");
+            cached = normalizeProfile(JSON.parse(raw));
+            return cached;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOENT") {
+                cached = emptyProfile();
+                return cached;
+            }
+            const backupPath = `${filePath}.corrupt-${Date.now()}`;
+            try {
+                await mkdir(path.dirname(filePath), { recursive: true });
+                await rename(filePath, backupPath);
+                logger?.warn?.(`[libp2p-mesh] User profile store unreadable; moved to ${backupPath}`);
+            }
+            catch (renameError) {
+                logger?.warn?.(`[libp2p-mesh] User profile store unreadable; failed to move corrupt file to ${backupPath}: ${renameError.message}`);
+            }
+            cached = emptyProfile();
+            return cached;
+        }
+    }
+    async function save(profile) {
+        const nextProfile = {
+            version: 1,
+            updatedAt: Date.now(),
+            attributes: normalizeProfileAttributes(profile.attributes),
+        };
+        const dir = path.dirname(filePath);
+        const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+        await mkdir(dir, { recursive: true });
+        await writeFile(tmpPath, `${JSON.stringify(nextProfile, null, 2)}\n`, "utf8");
+        await rename(tmpPath, filePath);
+        cached = nextProfile;
+        logger?.debug?.(`[libp2p-mesh] Saved user profile store to ${filePath}`);
+        return nextProfile;
+    }
+    async function runMutation(fn) {
+        const next = mutationQueue.then(fn, fn);
+        mutationQueue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    return {
+        load,
+        save,
+        async listAttributes() {
+            const profile = cached ?? (await load());
+            return [...profile.attributes];
+        },
+        async replaceAttributes(attributes) {
+            return runMutation(async () => {
+                const profile = await load();
+                return save({
+                    ...profile,
+                    attributes,
+                });
+            });
+        },
+        async updateAttribute(target, attribute) {
+            return runMutation(async () => {
+                const profile = await load();
+                const index = resolveTargetIndex(profile.attributes, target);
+                if (index < 0) {
+                    throw new RangeError(`User profile attribute not found: ${String(target)}`);
+                }
+                const attributes = [...profile.attributes];
+                attributes[index] = attribute;
+                return save({
+                    ...profile,
+                    attributes,
+                });
+            });
+        },
+        async removeAttribute(target) {
+            return runMutation(async () => {
+                const profile = await load();
+                const index = resolveTargetIndex(profile.attributes, target);
+                if (index < 0) {
+                    throw new RangeError(`User profile attribute not found: ${String(target)}`);
+                }
+                return save({
+                    ...profile,
+                    attributes: profile.attributes.filter((_, attributeIndex) => attributeIndex !== index),
+                });
+            });
+        },
+    };
+}

package/openclaw.plugin.json

@@ -197,7 +197,8 @@
       "p2p_get_network_info",
       "p2p_list_instances",
       "p2p_resolve_instance",
-      "p2p_send_instance_message"
+      "p2p_send_instance_message",
+      "p2p_send_user_attribute_message"
     ]
   },
   "uiHints": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-mesh",
-  "version": "2026.6.12",
+  "version": "2026.6.13",
   "description": "OpenClaw libp2p P2P mesh network plugin for cross-instance agent communication",
   "type": "module",
   "main": "dist/index.js",