@dcrays/mbh-memory 0.1.1-beta.5 → 0.1.1-beta.7

package/README.md

@@ -1,5 +1,5 @@
 # @dcrays/mbh-memory
 
-书灵墨宝的 DSH 云端记忆接入插件。加载后注册 `get_memory` 与 `set_memory`，把模型工具映射到配置的 HTTP API；插件本身不持久化记忆。
+书灵墨宝的 DSH 长期记忆插件。加载后注册 `get_memory` 与 `set_memory`：未配置 `baseUrl` 时原子写入 `$DSH_HOME/memory/users/<account-hash>/MEMORY.md`，配置后使用原有云端 HTTP API。
 
-单一发布包同时适用于生产与测试桌面。API 地址由 Cordis 插件配置下发，不读取 `.env`。
+单一发布包同时适用于生产与测试桌面。API 地址由 Cordis 插件配置下发，不读取 `.env`；本地与云端数据不会自动互相覆盖。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcrays/mbh-memory",
-  "version": "0.1.1-beta.5",
+  "version": "0.1.1-beta.7",
   "description": "DeepSeek Harness memory plugin for Mobook",
   "type": "module",
   "main": "plugin/index.js",
@@ -30,6 +30,8 @@
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
+    "@deepseek-ai/dsh-atomic-write": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.5-rc.2",
     "@deepseek-ai/dsh-tools": "0.1.5-rc.2",
     "@deepseek-ai/schemastery": "^3.18.1"
   },

package/plugin/index.d.ts

@@ -1,7 +1,7 @@
 import type { Context } from '@deepseek-ai/cordis';
 import { Service } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
-import { type MemoryApiValue } from '../src/index.js';
+import { type MemoryApiValue, type MemoryOperations } from '../src/index.js';
 export declare const name = "mbh-memory";
 export declare const inject: string[];
 export interface Config {
@@ -13,6 +13,9 @@ export interface Config {
     maxResponseBytes: number;
 }
 export declare const Config: z<Config>;
+export declare function localMemoryAccountScope(metadata: unknown): string;
+export declare function resolveLocalMemoryFile(): string;
+export declare function createMemoryOperations(config: Config): MemoryOperations | undefined;
 declare module '@deepseek-ai/cordis' {
     interface Context {
         mbhMemory: MbhMemoryService;
@@ -24,6 +27,7 @@ export declare class MbhMemoryService extends Service {
     constructor(ctx: Context, config: Config);
     isEnabled(): boolean;
     isConfigured(): boolean;
+    backend(): 'disabled' | 'local' | 'cloud';
     getMemory(signal?: AbortSignal): Promise<MemoryApiValue>;
     setMemory(memory: string, signal?: AbortSignal): Promise<MemoryApiValue>;
 }

package/plugin/index.js

@@ -1,7 +1,10 @@
 import { createRequire as __mobookCreateRequire } from 'node:module'; const require = __mobookCreateRequire(import.meta.url);
 
 // dist/plugin/index.js
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync } from "node:fs";
 import { Service } from "@deepseek-ai/cordis";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import z from "@deepseek-ai/schemastery";
 
 // dist/src/api-client.js
@@ -133,6 +136,121 @@ var MemoryApiClient = class {
   }
 };
 
+// dist/src/local-memory.js
+import { createHash } from "node:crypto";
+import { mkdir, readFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { withFileLock, writeFileAtomic } from "@deepseek-ai/dsh-atomic-write";
+var HEADER = `# Long-term Memory
+
+<!-- Managed by mbh-memory. This Markdown file is the canonical local memory source. -->
+`;
+var LocalMemoryError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+    this.name = "LocalMemoryError";
+  }
+};
+function normalizeMemory(memory) {
+  return memory.replaceAll("\r\n", "\n").trim();
+}
+function entryId(memory) {
+  return createHash("sha256").update(memory).digest("hex");
+}
+function entry(memory, now) {
+  const id = entryId(memory);
+  return {
+    id,
+    markdown: `
+## ${now.toISOString()}
+
+<!-- mbh-memory:id=${id} -->
+
+${memory}
+`
+  };
+}
+function isMissing(error) {
+  return error?.code === "ENOENT";
+}
+var LocalMemoryStore = class {
+  config;
+  now;
+  constructor(config) {
+    this.config = config;
+    if (!config.file.trim())
+      throw new LocalMemoryError("INVALID_CONFIG", "mbh-memory local file is required");
+    if (!Number.isSafeInteger(config.maxMemoryChars) || config.maxMemoryChars <= 0) {
+      throw new LocalMemoryError("INVALID_CONFIG", "mbh-memory maxMemoryChars must be a positive integer");
+    }
+    if (!Number.isSafeInteger(config.maxFileBytes) || config.maxFileBytes <= 0) {
+      throw new LocalMemoryError("INVALID_CONFIG", "mbh-memory maxFileBytes must be a positive integer");
+    }
+    this.now = config.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  async getMemory(signal) {
+    signal?.throwIfAborted();
+    let markdown;
+    try {
+      markdown = await readFile(this.config.file, "utf8");
+    } catch (error) {
+      if (isMissing(error))
+        return { backend: "local", memory: "" };
+      throw new LocalMemoryError("STORAGE_ERROR", "mbh-memory local memory could not be read", { cause: error });
+    }
+    signal?.throwIfAborted();
+    if (Buffer.byteLength(markdown) > this.config.maxFileBytes) {
+      throw new LocalMemoryError("STORAGE_LIMIT", `mbh-memory local memory exceeds ${this.config.maxFileBytes} bytes`);
+    }
+    return { backend: "local", memory: markdown };
+  }
+  async setMemory(memory, signal) {
+    const normalized = normalizeMemory(memory);
+    if (!normalized)
+      throw new LocalMemoryError("INVALID_MEMORY", "memory must not be empty");
+    if (normalized.length > this.config.maxMemoryChars) {
+      throw new LocalMemoryError("INVALID_MEMORY", `memory exceeds ${this.config.maxMemoryChars} characters`);
+    }
+    signal?.throwIfAborted();
+    await mkdir(dirname(this.config.file), { recursive: true, mode: 448 }).catch((error) => {
+      throw new LocalMemoryError("STORAGE_ERROR", "mbh-memory local memory directory could not be prepared", {
+        cause: error
+      });
+    });
+    try {
+      return await withFileLock(this.config.file, async () => {
+        signal?.throwIfAborted();
+        let current = HEADER;
+        try {
+          current = await readFile(this.config.file, "utf8");
+        } catch (error) {
+          if (!isMissing(error))
+            throw error;
+        }
+        const nextEntry = entry(normalized, this.now());
+        if (current.includes(`<!-- mbh-memory:id=${nextEntry.id} -->`)) {
+          return { backend: "local", saved: true, duplicate: true };
+        }
+        const prefix = current.trimEnd() || HEADER.trimEnd();
+        const next = `${prefix}
+${nextEntry.markdown}`;
+        if (Buffer.byteLength(next) > this.config.maxFileBytes) {
+          throw new LocalMemoryError("STORAGE_LIMIT", `mbh-memory local memory would exceed ${this.config.maxFileBytes} bytes`);
+        }
+        signal?.throwIfAborted();
+        await writeFileAtomic(this.config.file, next, { mode: 384, dirMode: 448 });
+        return { backend: "local", saved: true, duplicate: false };
+      }, { waitMs: 5e3 });
+    } catch (error) {
+      if (error instanceof LocalMemoryError || signal?.aborted)
+        throw error;
+      throw new LocalMemoryError("STORAGE_ERROR", "mbh-memory local memory could not be written", { cause: error });
+    }
+  }
+};
+
 // dist/src/tools.js
 import { defineTool } from "@deepseek-ai/dsh-tools";
 function render(value) {
@@ -141,7 +259,7 @@ function render(value) {
 function createMemoryTools(memory) {
   const getMemory = defineTool({
     name: "get_memory",
-    description: "Read the user's long-term memory from the configured Mobook memory API. Use it only when prior preferences, facts, or experience are relevant to the current request.",
+    description: "Read the user's long-term memory from Mobook's configured memory storage. Use it only when prior preferences, facts, or experience are relevant to the current request.",
     parameters: {},
     output: {
       schema: { type: "json" },
@@ -153,7 +271,7 @@ function createMemoryTools(memory) {
   });
   const setMemory = defineTool({
     name: "set_memory",
-    description: "Write one durable memory through the configured Mobook memory API. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.",
+    description: "Write one durable memory through the configured Mobook memory storage. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.",
     parameters: {
       memory: {
         type: "string",
@@ -186,19 +304,58 @@ var Config = z.object({
   maxMemoryChars: z.natural().min(1).default(2e4),
   maxResponseBytes: z.natural().min(1).default(128 * 1024)
 });
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function identifier(value) {
+  if (typeof value === "number" && Number.isSafeInteger(value))
+    return String(value);
+  if (typeof value !== "string")
+    return void 0;
+  return value.trim() || void 0;
+}
+function localMemoryAccountScope(metadata) {
+  const account = record(record(metadata)?.account);
+  const userId = identifier(account?.userId);
+  if (!userId || userId === "0")
+    return "anonymous";
+  const identity = JSON.stringify([userId, identifier(account?.appId) ?? "", identifier(account?.domainId) ?? ""]);
+  return createHash2("sha256").update(identity).digest("hex").slice(0, 32);
+}
+function resolveLocalMemoryFile() {
+  let metadata;
+  try {
+    metadata = JSON.parse(readFileSync(dshHomePath("mobook.json"), "utf8"));
+  } catch {
+    metadata = void 0;
+  }
+  return dshHomePath("memory", "users", localMemoryAccountScope(metadata), "MEMORY.md");
+}
+function createMemoryOperations(config) {
+  if (!config.enabled)
+    return void 0;
+  if (config.baseUrl.trim()) {
+    return new MemoryApiClient({
+      baseUrl: config.baseUrl.trim(),
+      ...config.authorizationToken.trim() ? { authorizationToken: config.authorizationToken.trim() } : {},
+      timeoutMs: config.timeoutMs,
+      maxMemoryChars: config.maxMemoryChars,
+      maxResponseBytes: config.maxResponseBytes
+    });
+  }
+  return new LocalMemoryStore({
+    file: resolveLocalMemoryFile(),
+    maxMemoryChars: config.maxMemoryChars,
+    maxFileBytes: config.maxResponseBytes
+  });
+}
 var MbhMemoryService = class extends Service {
   config;
   operations;
   constructor(ctx, config) {
     super(ctx, MBH_MEMORY_SERVICE_KEY);
     this.config = config;
-    this.operations = config.enabled && config.baseUrl.trim() ? new MemoryApiClient({
-      baseUrl: config.baseUrl.trim(),
-      ...config.authorizationToken.trim() ? { authorizationToken: config.authorizationToken.trim() } : {},
-      timeoutMs: config.timeoutMs,
-      maxMemoryChars: config.maxMemoryChars,
-      maxResponseBytes: config.maxResponseBytes
-    }) : void 0;
+    this.operations = createMemoryOperations(config);
   }
   isEnabled() {
     return this.config.enabled;
@@ -206,14 +363,19 @@ var MbhMemoryService = class extends Service {
   isConfigured() {
     return this.operations !== void 0;
   }
+  backend() {
+    if (!this.operations)
+      return "disabled";
+    return this.config.baseUrl.trim() ? "cloud" : "local";
+  }
   getMemory(signal) {
     if (!this.operations)
-      return Promise.reject(new Error("mbh-memory API is not configured"));
+      return Promise.reject(new Error("mbh-memory storage is disabled"));
     return this.operations.getMemory(signal);
   }
   setMemory(memory, signal) {
     if (!this.operations)
-      return Promise.reject(new Error("mbh-memory API is not configured"));
+      return Promise.reject(new Error("mbh-memory storage is disabled"));
     return this.operations.setMemory(memory, signal);
   }
 };
@@ -223,12 +385,10 @@ function apply(ctx, config) {
     const logger = ctx.logger(name);
     if (!service.isEnabled())
       return () => void 0;
-    if (!service.isConfigured()) {
-      logger.info("%s plugin loaded without an API baseUrl; memory tools are unavailable", name);
+    if (!service.isConfigured())
       return () => void 0;
-    }
     const unregister = createMemoryTools(service).map((tool) => ctx.tools.register(tool));
-    logger.info("%s plugin loaded with get_memory and set_memory tools", name);
+    logger.info("%s plugin loaded with get_memory and set_memory tools using %s storage", name, service.backend());
     return () => {
       for (const dispose of unregister.reverse())
         dispose();
@@ -239,6 +399,9 @@ export {
   Config,
   MbhMemoryService,
   apply,
+  createMemoryOperations,
   inject,
-  name
+  localMemoryAccountScope,
+  name,
+  resolveLocalMemoryFile
 };

package/src/index.d.ts

@@ -1,4 +1,5 @@
 export declare const MBH_MEMORY_PLUGIN_NAME = "mbh-memory";
 export declare const MBH_MEMORY_SERVICE_KEY = "mbhMemory";
 export * from './api-client.js';
+export * from './local-memory.js';
 export * from './tools.js';

package/src/index.js

@@ -1,4 +1,5 @@
 export const MBH_MEMORY_PLUGIN_NAME = 'mbh-memory';
 export const MBH_MEMORY_SERVICE_KEY = 'mbhMemory';
 export * from './api-client.js';
+export * from './local-memory.js';
 export * from './tools.js';

package/src/local-memory.d.ts

@@ -0,0 +1,18 @@
+import type { MemoryApiValue, MemoryOperations } from './api-client.js';
+export interface LocalMemoryStoreConfig {
+    file: string;
+    maxMemoryChars: number;
+    maxFileBytes: number;
+    now?: () => Date;
+}
+export declare class LocalMemoryError extends Error {
+    readonly code: 'INVALID_CONFIG' | 'INVALID_MEMORY' | 'STORAGE_LIMIT' | 'STORAGE_ERROR';
+    constructor(code: 'INVALID_CONFIG' | 'INVALID_MEMORY' | 'STORAGE_LIMIT' | 'STORAGE_ERROR', message: string, options?: ErrorOptions);
+}
+export declare class LocalMemoryStore implements MemoryOperations {
+    private readonly config;
+    private readonly now;
+    constructor(config: LocalMemoryStoreConfig);
+    getMemory(signal?: AbortSignal): Promise<MemoryApiValue>;
+    setMemory(memory: string, signal?: AbortSignal): Promise<MemoryApiValue>;
+}

package/src/local-memory.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname } from 'node:path';
+import { withFileLock, writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
+const HEADER = `# Long-term Memory
+
+<!-- Managed by mbh-memory. This Markdown file is the canonical local memory source. -->
+`;
+export class LocalMemoryError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+        this.name = 'LocalMemoryError';
+    }
+}
+function normalizeMemory(memory) {
+    return memory.replaceAll('\r\n', '\n').trim();
+}
+function entryId(memory) {
+    return createHash('sha256').update(memory).digest('hex');
+}
+function entry(memory, now) {
+    const id = entryId(memory);
+    return {
+        id,
+        markdown: `\n## ${now.toISOString()}\n\n<!-- mbh-memory:id=${id} -->\n\n${memory}\n`
+    };
+}
+function isMissing(error) {
+    return error?.code === 'ENOENT';
+}
+export class LocalMemoryStore {
+    config;
+    now;
+    constructor(config) {
+        this.config = config;
+        if (!config.file.trim())
+            throw new LocalMemoryError('INVALID_CONFIG', 'mbh-memory local file is required');
+        if (!Number.isSafeInteger(config.maxMemoryChars) || config.maxMemoryChars <= 0) {
+            throw new LocalMemoryError('INVALID_CONFIG', 'mbh-memory maxMemoryChars must be a positive integer');
+        }
+        if (!Number.isSafeInteger(config.maxFileBytes) || config.maxFileBytes <= 0) {
+            throw new LocalMemoryError('INVALID_CONFIG', 'mbh-memory maxFileBytes must be a positive integer');
+        }
+        this.now = config.now ?? (() => new Date());
+    }
+    async getMemory(signal) {
+        signal?.throwIfAborted();
+        let markdown;
+        try {
+            markdown = await readFile(this.config.file, 'utf8');
+        }
+        catch (error) {
+            if (isMissing(error))
+                return { backend: 'local', memory: '' };
+            throw new LocalMemoryError('STORAGE_ERROR', 'mbh-memory local memory could not be read', { cause: error });
+        }
+        signal?.throwIfAborted();
+        if (Buffer.byteLength(markdown) > this.config.maxFileBytes) {
+            throw new LocalMemoryError('STORAGE_LIMIT', `mbh-memory local memory exceeds ${this.config.maxFileBytes} bytes`);
+        }
+        return { backend: 'local', memory: markdown };
+    }
+    async setMemory(memory, signal) {
+        const normalized = normalizeMemory(memory);
+        if (!normalized)
+            throw new LocalMemoryError('INVALID_MEMORY', 'memory must not be empty');
+        if (normalized.length > this.config.maxMemoryChars) {
+            throw new LocalMemoryError('INVALID_MEMORY', `memory exceeds ${this.config.maxMemoryChars} characters`);
+        }
+        signal?.throwIfAborted();
+        await mkdir(dirname(this.config.file), { recursive: true, mode: 0o700 }).catch((error) => {
+            throw new LocalMemoryError('STORAGE_ERROR', 'mbh-memory local memory directory could not be prepared', {
+                cause: error
+            });
+        });
+        try {
+            return await withFileLock(this.config.file, async () => {
+                signal?.throwIfAborted();
+                let current = HEADER;
+                try {
+                    current = await readFile(this.config.file, 'utf8');
+                }
+                catch (error) {
+                    if (!isMissing(error))
+                        throw error;
+                }
+                const nextEntry = entry(normalized, this.now());
+                if (current.includes(`<!-- mbh-memory:id=${nextEntry.id} -->`)) {
+                    return { backend: 'local', saved: true, duplicate: true };
+                }
+                const prefix = current.trimEnd() || HEADER.trimEnd();
+                const next = `${prefix}\n${nextEntry.markdown}`;
+                if (Buffer.byteLength(next) > this.config.maxFileBytes) {
+                    throw new LocalMemoryError('STORAGE_LIMIT', `mbh-memory local memory would exceed ${this.config.maxFileBytes} bytes`);
+                }
+                signal?.throwIfAborted();
+                await writeFileAtomic(this.config.file, next, { mode: 0o600, dirMode: 0o700 });
+                return { backend: 'local', saved: true, duplicate: false };
+            }, { waitMs: 5_000 });
+        }
+        catch (error) {
+            if (error instanceof LocalMemoryError || signal?.aborted)
+                throw error;
+            throw new LocalMemoryError('STORAGE_ERROR', 'mbh-memory local memory could not be written', { cause: error });
+        }
+    }
+}

package/src/tools.js

@@ -5,7 +5,7 @@ function render(value) {
 export function createMemoryTools(memory) {
     const getMemory = defineTool({
         name: 'get_memory',
-        description: "Read the user's long-term memory from the configured Mobook memory API. Use it only when prior preferences, facts, or experience are relevant to the current request.",
+        description: "Read the user's long-term memory from Mobook's configured memory storage. Use it only when prior preferences, facts, or experience are relevant to the current request.",
         parameters: {},
         output: {
             schema: { type: 'json' },
@@ -17,7 +17,7 @@ export function createMemoryTools(memory) {
     });
     const setMemory = defineTool({
         name: 'set_memory',
-        description: 'Write one durable memory through the configured Mobook memory API. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.',
+        description: 'Write one durable memory through the configured Mobook memory storage. Use this when the user explicitly asks you to remember something useful for future conversations. Never store passwords, access tokens, API keys, or other secrets.',
         parameters: {
             memory: {
                 type: 'string',