lume-dsh-plugin 0.4.1

package/lib/host/registry.js

@@ -0,0 +1,62 @@
+export class PersonaRegistry {
+    #builtins;
+    #identity;
+    constructor(builtins, identity) {
+        this.#builtins = builtins;
+        this.#identity = identity;
+    }
+    /** 统一解析；自定义人设包装成 Persona（无语料，声音来自 promptText）。 */
+    resolve(name) {
+        if (!name)
+            return undefined;
+        const builtin = this.#builtins[name];
+        if (builtin)
+            return builtin;
+        const custom = this.#identity()?.getCustomPersona(name);
+        if (!custom)
+            return undefined;
+        return {
+            name,
+            displayName: custom.displayName,
+            description: custom.description,
+            promptText: custom.promptText,
+            corpus: custom.corpus ?? [],
+        };
+    }
+    /**
+     * 生效身份名：存储档案（用户改名）优先，回退出厂名（manifest defaultName）。
+     * 自定义人设无出厂名，返回 null（展示层用 displayName）。
+     */
+    profileNameOf(name) {
+        const identityName = this.#identity()?.getProfileName(name) ?? null;
+        if (identityName)
+            return identityName;
+        return this.#builtins[name]?.defaultName ?? null;
+    }
+    /** 下拉列表：内置 + 自定义，附生效身份名。 */
+    list() {
+        const identity = this.#identity();
+        const out = Object.values(this.#builtins).map((p) => ({
+            name: p.name,
+            displayName: p.displayName,
+            description: p.description,
+            profileName: identity?.getProfileName(p.name) ?? p.defaultName ?? null,
+            custom: false,
+        }));
+        const customs = identity?.listCustomPersonas() ?? {};
+        for (const [name, custom] of Object.entries(customs)) {
+            out.push({
+                name,
+                displayName: custom.displayName,
+                description: custom.description,
+                profileName: identity?.getProfileName(name) ?? null,
+                custom: true,
+            });
+        }
+        return out;
+    }
+}
+/** 自定义人设记录 → Persona 形状的转换（供工具/RPC 校验复用）。 */
+export function customToRecord(name, custom) {
+    return { name, displayName: custom.displayName, description: custom.description, promptText: custom.promptText, corpus: [] };
+}

package/lib/host/rpc.js

@@ -0,0 +1,284 @@
+import { settleMemoryText, STORY_MEMORY_CAP } from "./distill.js";
+import { normalizeCard, parseCard } from "../core/card.js";
+import { isCoreMemory } from "./injection.js";
+function requireString(payload, field) {
+    const value = payload?.[field];
+    return typeof value === "string" && value ? value : null;
+}
+export function createLumeRpcHandler(deps) {
+    // store/identity/registry 必须每次调用时经 deps 取（getter）—— 宿主侧存储在
+    // 插件启动后才就绪，启动时解构会把尚未就绪的值捕获住。
+    return async (endpoint, payload) => {
+        if (!deps.store) {
+            return {
+                ok: false,
+                error: { code: "storage-unavailable", message: "lume storage is not ready" },
+            };
+        }
+        const { store, registry, identity, distill } = deps;
+        switch (endpoint) {
+            case "list": {
+                return { ok: true, value: registry.list() };
+            }
+            case "select": {
+                const sessionId = requireString(payload, "sessionId");
+                const personaName = requireString(payload, "personaName");
+                if (!sessionId)
+                    return { ok: false, error: { code: "bad-request", message: "sessionId is required" } };
+                if (!personaName || !registry.resolve(personaName)) {
+                    return {
+                        ok: false,
+                        error: { code: "unknown-persona", message: `未知人设: ${String(personaName)}` },
+                    };
+                }
+                await store.select(sessionId, personaName);
+                return { ok: true };
+            }
+            case "getSessionPersona": {
+                const sessionId = requireString(payload, "sessionId");
+                if (!sessionId)
+                    return { ok: false, error: { code: "bad-request", message: "sessionId is required" } };
+                return { ok: true, value: store.get(sessionId) };
+            }
+            case "getProfile": {
+                const personaName = requireString(payload, "personaName");
+                if (!personaName || !registry.resolve(personaName)) {
+                    return { ok: false, error: { code: "unknown-persona", message: `未知人设: ${String(personaName)}` } };
+                }
+                return { ok: true, value: { name: identity?.getProfileName(personaName) ?? null } };
+            }
+            case "setProfile": {
+                const personaName = requireString(payload, "personaName");
+                const profileName = requireString(payload, "name");
+                if (!personaName || !registry.resolve(personaName)) {
+                    return { ok: false, error: { code: "unknown-persona", message: `未知人设: ${String(personaName)}` } };
+                }
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                if (!profileName)
+                    return { ok: false, error: { code: "bad-request", message: "name is required" } };
+                await identity.setProfileName(personaName, profileName);
+                return { ok: true };
+            }
+            case "deleteCustomPersona": {
+                const personaName = requireString(payload, "personaName");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                try {
+                    await identity.deleteCustomPersona(personaName);
+                }
+                catch (error) {
+                    return { ok: false, error: { code: "forbidden", message: String(error?.message ?? error) } };
+                }
+                return { ok: true };
+            }
+            case "distillStart": {
+                if (!distill)
+                    return { ok: false, error: { code: "storage-unavailable", message: "distill runner unavailable" } };
+                const text = requireString(payload, "text");
+                if (!text)
+                    return { ok: false, error: { code: "bad-request", message: "text is required" } };
+                const rawHint = payload?.hint;
+                const hint = typeof rawHint === "string" && rawHint.trim() ? rawHint.trim() : undefined;
+                try {
+                    return { ok: true, value: { jobId: distill.start({ text, hint }) } };
+                }
+                catch (error) {
+                    return { ok: false, error: { code: "bad-request", message: String(error?.message ?? error) } };
+                }
+            }
+            case "distillStatus": {
+                if (!distill)
+                    return { ok: false, error: { code: "storage-unavailable", message: "distill runner unavailable" } };
+                const jobId = requireString(payload, "jobId");
+                if (!jobId)
+                    return { ok: false, error: { code: "bad-request", message: "jobId is required" } };
+                return { ok: true, value: distill.status(jobId) };
+            }
+            case "distillCancel": {
+                if (!distill)
+                    return { ok: false, error: { code: "storage-unavailable", message: "distill runner unavailable" } };
+                const jobId = requireString(payload, "jobId");
+                if (!jobId)
+                    return { ok: false, error: { code: "bad-request", message: "jobId is required" } };
+                return { ok: true, value: { cancelled: distill.cancel(jobId) } };
+            }
+            case "saveCustomPersona": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const name = requireString(payload, "name");
+                const displayName = requireString(payload, "displayName");
+                const promptText = requireString(payload, "promptText");
+                if (!name || !displayName || !promptText) {
+                    return { ok: false, error: { code: "bad-request", message: "name, displayName and promptText are required" } };
+                }
+                const description = payload.description;
+                const corpus = payload.corpus;
+                const memory = payload.memory;
+                const distillVersion = payload.distillVersion;
+                const distillSource = payload.distillSource;
+                const distillHint = payload.distillHint;
+                const rawCreatedAt = payload.createdAt;
+                try {
+                    await identity.setCustomPersona(name, {
+                        displayName,
+                        description: typeof description === "string" ? description : "",
+                        promptText,
+                        // 编辑保存时带原 createdAt；新建（蒸馏/对话创建）落当前时间
+                        createdAt: typeof rawCreatedAt === "number" ? rawCreatedAt : Date.now(),
+                        corpus: Array.isArray(corpus) ? corpus : undefined,
+                        distillVersion: typeof distillVersion === "number" ? distillVersion : undefined,
+                        distillSource: typeof distillSource === "string" ? distillSource : undefined,
+                        distillHint: typeof distillHint === "string" ? distillHint : undefined,
+                    });
+                    // 真实记忆点：蒸馏产出的事件条写入身份域（人设即人——她记得你们的事）
+                    if (Array.isArray(memory)) {
+                        const facts = identity.getMemory(name);
+                        for (const item of memory) {
+                            const text = typeof item?.text === "string" ? item.text : "";
+                            if (!text.trim())
+                                continue;
+                            // 蒸馏层已按句末标点收尾；这里只做长度兜底（故事 80/事件 40 已在宿主层约束），
+                            // 禁止 40 字硬切——会把完整句子拦腰截断
+                            const settled = settleMemoryText(text, STORY_MEMORY_CAP);
+                            if (!settled)
+                                continue;
+                            if (facts.some((f) => f.text.includes(settled) || settled.includes(f.text)))
+                                continue;
+                            await identity.addMemory(name, settled, (candidate, all) => all.some((f) => f.text.includes(candidate) || candidate.includes(f.text)));
+                        }
+                    }
+                }
+                catch (error) {
+                    return { ok: false, error: { code: "forbidden", message: String(error?.message ?? error) } };
+                }
+                return { ok: true };
+            }
+            case "getCustomPersona": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const personaName = requireString(payload, "personaName");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                const record = identity.getCustomPersona(personaName);
+                if (!record)
+                    return { ok: false, error: { code: "unknown-persona", message: `非自定义人设或不存在: ${personaName}` } };
+                return { ok: true, value: record };
+            }
+            case "exportPersona": {
+                const personaName = requireString(payload, "personaName");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                const persona = registry.resolve(personaName);
+                if (!persona)
+                    return { ok: false, error: { code: "unknown-persona", message: `未知人设: ${personaName}` } };
+                const includeMemory = payload.includeMemory === true;
+                return {
+                    ok: true,
+                    value: {
+                        format: "lume-persona-card",
+                        version: 1,
+                        persona: {
+                            name: persona.name,
+                            displayName: persona.displayName,
+                            description: persona.description,
+                            promptText: persona.promptText,
+                            corpus: persona.corpus ?? [],
+                            profileName: registry.profileNameOf(personaName),
+                            styleRules: identity?.getStyleRules(personaName) ?? [],
+                            ...(includeMemory ? { memory: identity?.getMemory(personaName) ?? [] } : {}),
+                            ...(persona.signatureWords?.length ? { signatureWords: persona.signatureWords } : {}),
+                        },
+                    },
+                };
+            }
+            case "getMemory": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const personaName = requireString(payload, "personaName");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                return { ok: true, value: identity.getMemory(personaName).map((f) => ({ text: f.text, at: f.at, core: isCoreMemory(f.text) })) };
+            }
+            case "deleteMemory": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const personaName = requireString(payload, "personaName");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                const idx = payload.index;
+                if (typeof idx !== "number" || !Number.isFinite(idx) || idx < 0) {
+                    return { ok: false, error: { code: "bad-request", message: "index must be a non-negative integer" } };
+                }
+                const facts = identity.getMemory(personaName);
+                if (idx >= facts.length) {
+                    return { ok: false, error: { code: "bad-request", message: `index ${idx} out of range (${facts.length} items)` } };
+                }
+                facts.splice(idx, 1);
+                await identity.replaceMemory(personaName, facts);
+                return { ok: true };
+            }
+            case "updateMemory": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const personaName = requireString(payload, "personaName");
+                const text = requireString(payload, "text");
+                if (!personaName)
+                    return { ok: false, error: { code: "bad-request", message: "personaName is required" } };
+                if (!text)
+                    return { ok: false, error: { code: "bad-request", message: "text is required" } };
+                const idx = payload.index;
+                if (typeof idx !== "number" || !Number.isFinite(idx) || idx < 0) {
+                    return { ok: false, error: { code: "bad-request", message: "index must be a non-negative integer" } };
+                }
+                const facts = identity.getMemory(personaName);
+                if (idx >= facts.length) {
+                    return { ok: false, error: { code: "bad-request", message: `index ${idx} out of range (${facts.length} items)` } };
+                }
+                facts[idx] = { text, at: facts[idx].at };
+                await identity.replaceMemory(personaName, facts);
+                return { ok: true };
+            }
+            case "importPersona": {
+                if (!identity)
+                    return { ok: false, error: { code: "storage-unavailable", message: "identity store unavailable" } };
+                const raw = payload.payload;
+                if (typeof raw !== "string")
+                    return { ok: false, error: { code: "bad-request", message: "payload (JSON string) is required" } };
+                const parsed = parseCard(raw);
+                if (!parsed.ok)
+                    return { ok: false, error: { code: "bad-card", message: parsed.error } };
+                const normalized = normalizeCard(parsed.value.persona);
+                if (!normalized.ok)
+                    return { ok: false, error: { code: "forbidden", message: normalized.error } };
+                const card = normalized.value;
+                try {
+                    await identity.setCustomPersona(card.name, {
+                        displayName: card.displayName,
+                        description: card.description,
+                        promptText: card.promptText,
+                        createdAt: Date.now(),
+                        corpus: card.corpus,
+                    });
+                    if (card.profileName)
+                        await identity.setProfileName(card.name, card.profileName);
+                    if (card.styleRules.length > 0)
+                        await identity.replaceStyleRules(card.name, card.styleRules);
+                    if (card.memory && card.memory.length > 0)
+                        await identity.replaceMemory(card.name, card.memory);
+                }
+                catch (error) {
+                    return { ok: false, error: { code: "forbidden", message: String(error?.message ?? error) } };
+                }
+                return { ok: true, value: { name: card.name, displayName: card.displayName } };
+            }
+            default:
+                return {
+                    ok: false,
+                    error: { code: "bad-request", message: `unknown lume endpoint ${JSON.stringify(endpoint)}` },
+                };
+        }
+    };
+}

package/lib/host/session-runtime.js

@@ -0,0 +1,48 @@
+/** 运行时状态上限：与 PersonaStore 的 maxSessions 对齐，超限淘汰最旧。 */
+const MAX_RUNTIME_SESSIONS = 200;
+function defaultRuntime() {
+    return {
+        userText: "",
+        assistantText: "",
+        lastQuery: null,
+        turnIndex: 0,
+        lastInjected: undefined,
+        switchTurn: null,
+        prevPersona: undefined,
+        switchGreetingPending: false,
+        prevSignatures: [],
+        leakEscalated: false,
+        activeBoundary: null,
+        extracting: null,
+        lastExtractionAt: undefined,
+        lastExchange: null,
+        recentTurns: [],
+        protocolCorrection: null,
+        lastFailureQuery: null,
+        failureStreak: 0,
+    };
+}
+export class SessionRuntimeStore {
+    #map = new Map();
+    /** 取或建会话运行时；新建时触发 LRU 淘汰。 */
+    get(sid) {
+        let st = this.#map.get(sid);
+        if (!st) {
+            st = defaultRuntime();
+            this.#map.set(sid, st);
+            this.#evictOldest();
+        }
+        return st;
+    }
+    delete(sid) {
+        return this.#map.delete(sid);
+    }
+    #evictOldest() {
+        while (this.#map.size > MAX_RUNTIME_SESSIONS) {
+            const oldest = this.#map.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.#map.delete(oldest);
+        }
+    }
+}

package/lib/host/store.js

@@ -0,0 +1,123 @@
+/**
+ * 会话人设存储：storageDomain 表之上的真 LRU 语义 + 旧状态文件迁移。
+ *
+ * dsh-storage-json 的记录按插入序持久化，对已存在键 put 不会移动位置，
+ * 所以「重选」必须 delete + put 才能刷新 LRU 新旧。读取不落盘
+ * （prompt 构建每次都读，不能每次都写文件）。
+ */
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+/** 显式人设选择的存取（不含默认值语义 —— 那是宿主 apply 的职责）。 */
+export class PersonaStore {
+    #table;
+    #maxSessions;
+    constructor(table, options = {}) {
+        this.#table = table;
+        this.#maxSessions = options.maxSessions ?? 200;
+    }
+    /** 显式选择；未选择过返回 null（区别于「选了 none」）。 */
+    get(sessionId) {
+        const value = this.#table.get(String(sessionId));
+        return typeof value === "string" ? value : null;
+    }
+    /** 写入显式选择，刷新 LRU 新旧并按上限淘汰最旧会话。 */
+    async select(sessionId, personaName) {
+        const key = String(sessionId);
+        try {
+            await this.#table.delete(key);
+        }
+        catch {
+            // 键不存在或后端瞬时故障不阻断写入
+        }
+        await this.#table.put(key, personaName);
+        await this.#evictOldest();
+    }
+    async #evictOldest() {
+        while (this.#table.size > this.#maxSessions) {
+            const oldest = this.#table.keys().next().value;
+            if (oldest === undefined)
+                break;
+            await this.#table.delete(oldest);
+        }
+    }
+}
+/**
+ * 一次性迁移：把 v0.1.0 写在 assets/persona-state.json 的旧记忆
+ * 导入 storageDomain，成功后把旧文件改名 .migrated 留档。
+ * 任何失败都不抛出 —— 迁移是尽力而为，主路径不受影响。
+ */
+export async function migrateLegacyState(store, legacyPath) {
+    if (!existsSync(legacyPath))
+        return false;
+    let entries;
+    try {
+        const raw = JSON.parse(readFileSync(legacyPath, "utf8"));
+        entries = Object.entries(raw);
+    }
+    catch {
+        return false;
+    }
+    let imported = 0;
+    for (const [sessionId, personaName] of entries) {
+        if (typeof personaName !== "string" || !sessionId)
+            continue;
+        if (store.get(sessionId) !== null)
+            continue; // 已有显式选择，不覆盖
+        await store.select(sessionId, personaName);
+        imported++;
+    }
+    try {
+        renameSync(legacyPath, `${legacyPath}.migrated`);
+    }
+    catch {
+        // 改名失败则下次启动会重复导入，但 store.get 判重保证幂等
+    }
+    return imported > 0 || entries.length === 0;
+}
+/**
+ * 降级存储：storageDomain 不可用时退回 v0.1.0 的 assets JSON 文件落盘
+ * （安装目录内，升级会丢 —— 仅作可用性兜底，不再是对外承诺的存储位置）。
+ * 接口与 PersonaStore 完全一致，宿主侧无感切换。
+ */
+export class FilePersonaStore {
+    #path;
+    #maxSessions;
+    #map;
+    constructor(path, options = {}) {
+        this.#path = path;
+        this.#maxSessions = options.maxSessions ?? 200;
+        this.#map = new Map();
+        try {
+            const raw = JSON.parse(readFileSync(path, "utf8"));
+            for (const [key, value] of Object.entries(raw)) {
+                if (typeof value === "string")
+                    this.#map.set(key, value);
+            }
+        }
+        catch {
+            // 无历史文件或损坏 —— 从空表开始
+        }
+    }
+    get(sessionId) {
+        return this.#map.get(String(sessionId)) ?? null;
+    }
+    async select(sessionId, personaName) {
+        const key = String(sessionId);
+        this.#map.delete(key);
+        this.#map.set(key, personaName);
+        while (this.#map.size > this.#maxSessions) {
+            const oldest = this.#map.keys().next().value;
+            if (oldest === undefined)
+                break;
+            this.#map.delete(oldest);
+        }
+        this.#persist();
+    }
+    #persist() {
+        try {
+            writeFileSync(this.#path, JSON.stringify(Object.fromEntries(this.#map), null, 2));
+        }
+        catch {
+            // 写失败不影响会话（与 v0.1.0 行为一致）
+        }
+    }
+}