@max-null/dsh-memory 0.2.1 → 0.3.7

package/dist/remote.js

@@ -42,6 +42,7 @@ var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn,
 };
 import { TypertRemoteService, Remote } from '@deepseek-ai/dsh-typert-protocol';
 import { MemoryId } from "./engine.js";
+import { SELF_DESCRIPTION } from "./self.js";
 /** Client-callable memory surface; registered as the `memory` Typert namespace. */
 let MemoryGateway = (() => {
     let _classSuper = TypertRemoteService;
@@ -49,18 +50,27 @@ let MemoryGateway = (() => {
     let _list_decorators;
     let _search_decorators;
     let _confirm_decorators;
+    let _setInjected_decorators;
     let _forget_decorators;
+    let _reload_decorators;
+    let _injectionPreview_decorators;
     return class MemoryGateway extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _list_decorators = [Remote('list')];
             _search_decorators = [Remote('search')];
             _confirm_decorators = [Remote('confirm')];
+            _setInjected_decorators = [Remote('setInjected')];
             _forget_decorators = [Remote('forget')];
+            _reload_decorators = [Remote('reload')];
+            _injectionPreview_decorators = [Remote('injectionPreview')];
             __esDecorate(this, null, _list_decorators, { kind: "method", name: "list", static: false, private: false, access: { has: obj => "list" in obj, get: obj => obj.list }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _search_decorators, { kind: "method", name: "search", static: false, private: false, access: { has: obj => "search" in obj, get: obj => obj.search }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _confirm_decorators, { kind: "method", name: "confirm", static: false, private: false, access: { has: obj => "confirm" in obj, get: obj => obj.confirm }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _setInjected_decorators, { kind: "method", name: "setInjected", static: false, private: false, access: { has: obj => "setInjected" in obj, get: obj => obj.setInjected }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _forget_decorators, { kind: "method", name: "forget", static: false, private: false, access: { has: obj => "forget" in obj, get: obj => obj.forget }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _reload_decorators, { kind: "method", name: "reload", static: false, private: false, access: { has: obj => "reload" in obj, get: obj => obj.reload }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _injectionPreview_decorators, { kind: "method", name: "injectionPreview", static: false, private: false, access: { has: obj => "injectionPreview" in obj, get: obj => obj.injectionPreview }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         static inject = ['memory'];
@@ -70,21 +80,40 @@ let MemoryGateway = (() => {
             super(ctx, 'memoryRemote', { namespace: 'memory' });
             __runInitializers(this, _instanceExtraInitializers);
         }
-        /** List every stored memory, optionally filtered by namespace or status. */
-        list(filter) {
-            return this.ctx.memory.list(filter);
+        /** List every stored memory, optionally filtered by namespace/status/injected and workspace cwd. */
+        async list(filter, cwd) {
+            return this.ctx.memory.list(filter, cwd);
         }
         /** Recall memories by keyword; deterministic literal matching. */
-        search(query, filter) {
-            return this.ctx.memory.search(query, filter);
+        async search(query, filter, cwd) {
+            return this.ctx.memory.search(query, filter, cwd);
         }
-        /** Confirm a suggested memory so it becomes effective (`auto`). */
-        confirm(id) {
-            return this.ctx.memory.setStatus(MemoryId(id), 'auto');
+        /** Approve a suggested memory (review status `suggested` → `approved`); does not change injection. */
+        confirm(id, cwd) {
+            return this.ctx.memory.setStatus(MemoryId(id), 'approved', cwd);
+        }
+        /**
+         * Toggle the persistent-injection switch (`injected`) — the UI panel's
+         * 「常驻注入」 switch; does not change the review status.
+         */
+        setInjected(id, injected, cwd) {
+            return this.ctx.memory.setInjected(MemoryId(id), injected, cwd);
         }
         /** Delete one stored memory by id. */
-        forget(id) {
-            return this.ctx.memory.forget(MemoryId(id));
+        forget(id, cwd) {
+            return this.ctx.memory.forget(MemoryId(id), cwd);
+        }
+        /** Force-reload storage files (external edits; JsonStorageBackend has no watch). */
+        async reload(cwd) {
+            await this.ctx.memory.reload();
+            return this.ctx.memory.list({}, cwd);
+        }
+        /**
+         * 注入预览（0.3.5）：开发者查看当前注入到 system prompt 的记忆内容
+         * ——self 自述 + 实际注入的 global approved+injected 记忆。
+         */
+        injectionPreview() {
+            return { self: SELF_DESCRIPTION, injected: this.ctx.memory.recallRecords() };
         }
     };
 })();

package/dist/routes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * dsh-memory 自带面板的 HTTP 数据通道（0.3.6）。
+ * 背景：client 侧 `remote.memory` 命名空间依赖 Typert 构建期产物（独立
+ * npm 包生成不了——2026-08-16 设计文档结论），导致自带面板无法经 remote
+ * 取数。改走本端点（panels /ssid/api 同模式：host 插件注册 HTTP 路由，
+ * client fetch）——任何 profile 装 dsh-memory 即有面板，脱离 SSiD 也成立。
+ * 信任围栏同 /ssid/api：loopback / trustedHosts，拒绝 cross-site。
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** 挂载 /memory/api 路由（apply 调用）。 */
+export declare function mountMemoryApi(ctx: Context): void;

package/dist/routes.js

@@ -0,0 +1,211 @@
+import { createRequire } from 'node:module';
+import { SELF_DESCRIPTION } from "./self.js";
+const require = createRequire(import.meta.url);
+/** Body size bound of one JSON request. */
+const MAX_BODY_BYTES = 1 << 20;
+class MemoryApiError extends Error {
+    code;
+    status;
+    constructor(code, message, status = 400) {
+        super(message);
+        this.code = code;
+        this.status = status;
+        this.name = 'MemoryApiError';
+    }
+}
+function writeJson(res, status, body) {
+    const r = res;
+    r.writeHead(status, { 'content-type': 'application/json; charset=utf-8' });
+    r.end(JSON.stringify(body));
+}
+function writeError(res, error) {
+    if (error instanceof MemoryApiError) {
+        writeJson(res, error.status, { ok: false, error: { code: error.code, message: error.message } });
+        return;
+    }
+    writeJson(res, 500, { ok: false, error: { code: 'internal', message: error instanceof Error ? error.message : String(error) } });
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.from(chunk);
+        total += buffer.length;
+        if (total > MAX_BODY_BYTES)
+            throw new MemoryApiError('bad-request', 'request body too large');
+        chunks.push(buffer);
+    }
+    const text = Buffer.concat(chunks).toString('utf8');
+    if (text.trim() === '')
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw new MemoryApiError('bad-request', 'request body is not valid JSON');
+    }
+}
+function header(headers, name) {
+    const value = headers[name];
+    return typeof value === 'string' ? value : undefined;
+}
+function parseAuthority(authority) {
+    try {
+        return new URL(`http://${authority}`);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isLoopbackHostname(hostname) {
+    if (hostname === 'localhost' || hostname === '[::1]')
+        return true;
+    const parts = hostname.split('.');
+    return parts.length === 4
+        && parts[0] === '127'
+        && parts.every(part => /^\d{1,3}$/.test(part) && Number(part) <= 255);
+}
+/** Whether one request may reach the plugin routes (mirror of the /api gateway fence). */
+function isTrusted(request, trustedHosts) {
+    const host = header(request.headers, 'host');
+    if (host === undefined)
+        return false;
+    const hostUrl = parseAuthority(host);
+    if (hostUrl === undefined)
+        return false;
+    const trusted = isLoopbackHostname(hostUrl.hostname)
+        || trustedHosts.some((entry) => {
+            const entryUrl = parseAuthority(entry);
+            return entryUrl !== undefined && entryUrl.host === hostUrl.host;
+        });
+    if (!trusted)
+        return false;
+    if (header(request.headers, 'sec-fetch-site') === 'cross-site')
+        return false;
+    const origin = header(request.headers, 'origin');
+    if (origin === undefined)
+        return true;
+    try {
+        return new URL(origin).host === hostUrl.host;
+    }
+    catch {
+        return false;
+    }
+}
+/** String-ish cwd payload guard. */
+function cwdOf(payload) {
+    const value = payload?.cwd;
+    return typeof value === 'string' && value !== '' ? value : undefined;
+}
+/** 挂载 /memory/api 路由（apply 调用）。 */
+export function mountMemoryApi(ctx) {
+    // webServer/webRuntime 由 index.ts 的 inject 声明（Context 类型未扩展，断言访问）
+    const webServer = ctx.webServer;
+    const webRuntime = ctx.webRuntime;
+    const api = {
+        'list': (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            const record = payload;
+            const filter = record?.filter;
+            return memory.list({
+                ...filter?.namespace !== undefined && typeof filter.namespace === 'string' ? { namespace: filter.namespace } : {},
+                ...filter?.status !== undefined && typeof filter.status === 'string' ? { status: filter.status } : {},
+                ...filter?.injected !== undefined && typeof filter.injected === 'boolean' ? { injected: filter.injected } : {},
+            }, cwdOf(record));
+        },
+        'reload': async (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            await memory.reload();
+            return memory.list({}, cwdOf(payload));
+        },
+        'confirm': (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            const record = payload;
+            if (typeof record?.id !== 'string')
+                throw new MemoryApiError('bad-request', 'missing or invalid "id"');
+            return memory.setStatus(record.id, 'approved', cwdOf(record));
+        },
+        'forget': (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            const record = payload;
+            if (typeof record?.id !== 'string')
+                throw new MemoryApiError('bad-request', 'missing or invalid "id"');
+            return memory.forget(record.id, cwdOf(record));
+        },
+        'setInjected': (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            const record = payload;
+            if (typeof record?.id !== 'string')
+                throw new MemoryApiError('bad-request', 'missing or invalid "id"');
+            if (typeof record?.injected !== 'boolean')
+                throw new MemoryApiError('bad-request', 'missing or invalid "injected"');
+            return memory.setInjected(record.id, record.injected, cwdOf(record));
+        },
+        'update': (payload) => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            const record = payload;
+            if (typeof record?.id !== 'string')
+                throw new MemoryApiError('bad-request', 'missing or invalid "id"');
+            if (record.content !== undefined && typeof record.content !== 'string')
+                throw new MemoryApiError('bad-request', 'invalid "content"');
+            if (record.keywords !== undefined && !(Array.isArray(record.keywords) && record.keywords.every(k => typeof k === 'string'))) {
+                throw new MemoryApiError('bad-request', 'invalid "keywords"');
+            }
+            return memory.update(record.id, {
+                ...record.content === undefined ? {} : { content: record.content },
+                ...record.keywords === undefined ? {} : { keywords: record.keywords },
+            }, cwdOf(record));
+        },
+        'injectionPreview': () => {
+            const memory = ctx.get('memory');
+            if (memory === undefined)
+                throw new MemoryApiError('service-unavailable', 'memory service unavailable', 503);
+            return { self: SELF_DESCRIPTION, injected: memory.recallRecords() };
+        },
+    };
+    const fence = (req) => isTrusted(req, webRuntime.trustedHosts);
+    ctx.effect(() => webServer.register({
+        kind: 'prefix',
+        path: '/memory/api',
+        handler: async (req, res) => {
+            const request = req;
+            if (!fence(request)) {
+                writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } });
+                return;
+            }
+            if (request.method !== 'POST') {
+                writeJson(res, 405, { ok: false, error: { code: 'method-error', message: 'method not allowed' } });
+                return;
+            }
+            const pathname = new URL(request.url ?? '/', 'http://dsh.internal').pathname;
+            const method = pathname.startsWith('/memory/api/') ? pathname.slice('/memory/api/'.length) : undefined;
+            if (method === undefined || method.includes('/')) {
+                writeError(res, new MemoryApiError('not-found', 'unknown memory API method', 404));
+                return;
+            }
+            try {
+                const payload = await readJsonBody(req);
+                const handler = api[method];
+                if (handler === undefined) {
+                    throw new MemoryApiError('not-found', `unknown memory API method "${method}"`, 404);
+                }
+                writeJson(res, 200, { ok: true, value: await handler(payload) });
+            }
+            catch (error) {
+                writeError(res, error);
+            }
+        },
+    }), '@max-null/dsh-memory: /memory/api routes');
+}

package/dist/self.d.ts

@@ -0,0 +1 @@
+export declare const SELF_DESCRIPTION: string;

package/dist/self.js

@@ -0,0 +1,26 @@
+/**
+ * 记忆机制自述（memory:self 注入内容 + 面板「注入预览」共用）。
+ * 0.3.2 起：LLM 每轮知道本环境有记忆机制；不落用户存储，随发版更新，
+ * 版本号动态读取 package.json（"只跟随 dsh-memory 组件发版变动"）。
+ */
+import { createRequire } from 'node:module';
+const SELF_VERSION = (() => {
+    try {
+        // dist/index.js 位于包根 package.json 同级（../package.json）
+        const require = createRequire(import.meta.url);
+        const pkg = require('../package.json');
+        return pkg.version ?? 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+})();
+export const SELF_DESCRIPTION = `[记忆系统自述] 当前环境内置跨会话记忆服务（dsh-memory v${SELF_VERSION}）。`
+    + '工作机制：①记忆以明文 JSON 存储（global→$DSH_HOME/storages、工作区→会话工作区 .dsh/storages 随 git 分享）；'
+    + '②模型写入即 suggested（待审核），仅人工审核（memory_confirm）后才 approved；'
+    + '③每轮注入 system prompt 的只有「global 的 approved + injected 开关打开」的记忆（常驻注入由用户控制，审核≠注入）；'
+    + '④工作区记忆按会话工作区路由，靠 memory_search 检索（含待审核条目，可先评估再引用）；'
+    + '⑤修正过时内容用 memory_update（改动重置待审核，注入开关保留）。'
+    + `可用记忆工具共 6 个：memory_save / memory_list / memory_search / memory_confirm / memory_forget / memory_update。`
+    + '使用建议：相关历史上下文先 memory_search 检索再引用；新习惯/约定用 memory_save 写入（落在待审核）。'
+    + '（中/英文同义：This environment has a cross-session memory service; write suggestions via memory_save, retrieve via memory_search, and expect human review before approved.)';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@max-null/dsh-memory",
-  "version": "0.2.1",
+  "version": "0.3.7",
   "description": "Cross-session plaintext memory plugin for the DeepSeek Harness — deterministic BM25 recall, human-owned, no embeddings",
   "license": "MIT",
   "publishConfig": {
@@ -13,7 +13,9 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./client": "./client.js",
+    "./package.json": "./package.json"
   },
   "files": [
     "dist",
@@ -22,6 +24,13 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-locale"
+      ],
+      "platform": "web"
     }
   },
   "keywords": [
@@ -39,7 +48,7 @@
     "url": "git+https://github.com/Max-Null/dsh-memory.git"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node build-client.mjs",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run",
     "prepublishOnly": "npm run build"