@dsh-libing/memory-manager 0.0.0-stage → 0.1.0

package/lib/storage-worker.js

@@ -0,0 +1,256 @@
+/** Database authority. Every change is serialized and revisions/approvals commit atomically. */
+import { DatabaseSync } from 'node:sqlite';
+import { parentPort, workerData } from 'node:worker_threads';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { z } from 'zod';
+import { activitySchema, candidateSchema, draftSchema, entrySchema, jobSchema, mutationSchema, scopeSchema, settingsSchema, sourceSchema, visible, MemoryError } from "./shared.js";
+const directory = z.string().parse(workerData), port = parentPort;
+if (!port)
+    throw new Error('Database worker requires a message port');
+const db = new DatabaseSync(join(directory, 'memory.sqlite'));
+db.exec(`PRAGMA journal_mode=WAL; PRAGMA busy_timeout=3000;
+CREATE TABLE IF NOT EXISTS records (id TEXT PRIMARY KEY, body TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS versions (id TEXT NOT NULL, version INTEGER NOT NULL, body TEXT NOT NULL, PRIMARY KEY(id,version));
+CREATE TABLE IF NOT EXISTS candidates (id TEXT PRIMARY KEY, body TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS activities (id TEXT PRIMARY KEY, body TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS jobs (id TEXT PRIMARY KEY, body TEXT NOT NULL);
+CREATE TABLE IF NOT EXISTS budgets (day TEXT PRIMARY KEY, calls INTEGER NOT NULL);
+CREATE TABLE IF NOT EXISTS config (id TEXT PRIMARY KEY, body TEXT NOT NULL);`);
+const now = () => new Date().toISOString();
+function list(table, schema) { return db.prepare(`SELECT body FROM ${table} ORDER BY rowid DESC`).all().map(row => schema.parse(JSON.parse(z.string().parse(row.body)))); }
+function put(table, id, body) { db.prepare(`INSERT INTO ${table}(id,body) VALUES(?,?) ON CONFLICT(id) DO UPDATE SET body=excluded.body`).run(id, JSON.stringify(body)); }
+function one(table, id, schema) { const row = db.prepare(`SELECT body FROM ${table} WHERE id=?`).get(id); if (!row)
+    throw new MemoryError('notFound', 404); return schema.parse(JSON.parse(z.string().parse(row.body))); }
+function transaction(fn) { db.exec('BEGIN IMMEDIATE'); try {
+    const value = fn();
+    db.exec('COMMIT');
+    return value;
+}
+catch (error) {
+    db.exec('ROLLBACK');
+    throw error;
+} }
+function settings() { const row = db.prepare("SELECT body FROM config WHERE id='settings'").get(); return settingsSchema.parse(row ? JSON.parse(z.string().parse(row.body)) : {}); }
+function checkScope(value, scope) { if (!visible(value, scope))
+    throw new MemoryError('outsideScope', 403); }
+function save(value) { entrySchema.parse(value); put('records', value.id, value); db.prepare('INSERT INTO versions(id,version,body) VALUES(?,?,?)').run(value.id, value.version, JSON.stringify(value)); return value; }
+const storedJobSchema = jobSchema.extend({ input: z.string().max(12000), source: sourceSchema, provider: z.string(), model: z.string() });
+function proposed(raw) {
+    const args = z.object({ scope: scopeSchema, draft: draftSchema, source: sourceSchema, target: z.string().optional(), expected: z.number().int().optional(), id: z.string().optional() }).strict().parse(raw);
+    if (args.id) {
+        const found = db.prepare('SELECT body FROM candidates WHERE id=?').get(args.id);
+        if (found) {
+            const old = candidateSchema.parse(JSON.parse(z.string().parse(found.body)));
+            checkScope(old, args.scope);
+            if (JSON.stringify(old.draft) !== JSON.stringify(args.draft) || old.target !== (args.target ?? null) || old.expected !== (args.expected ?? 0))
+                throw new MemoryError('revisionConflict');
+            return old;
+        }
+    }
+    if (args.target) {
+        const target = one('records', args.target, entrySchema);
+        checkScope(target, args.scope);
+        if (target.state !== 'active' || target.version !== args.expected)
+            throw new MemoryError('revisionConflict');
+    }
+    if (list('candidates', candidateSchema).filter(row => row.state === 'pending').length >= 500)
+        throw new MemoryError('candidateLimit');
+    db.exec("DELETE FROM candidates WHERE rowid NOT IN (SELECT rowid FROM candidates ORDER BY rowid DESC LIMIT 2000) AND json_extract(body,'$.state') != 'pending'");
+    const item = { id: args.id ?? randomUUID(), revision: randomUUID(), target: args.target ?? null, expected: args.expected ?? 0, workspace: args.draft.range === 'personal' ? 'personal' : args.scope.workspace, session: args.draft.range === 'session' ? args.scope.session : null, draft: args.draft, source: args.source, state: 'pending', updated: now() };
+    if (item.draft.range === 'session' && !item.session)
+        throw new MemoryError('sessionRequired');
+    put('candidates', item.id, item);
+    return item;
+}
+function current(id, scope, version) { const value = one('records', id, entrySchema); checkScope(value, scope); if (value.version !== version)
+    throw new MemoryError('revisionConflict'); return value; }
+function state(raw) {
+    const scope = scopeSchema.parse(raw);
+    return { entries: list('records', entrySchema).filter(row => visible(row, scope)), candidates: list('candidates', candidateSchema).filter(row => row.state === 'pending' && visible(row, scope)), activities: list('activities', activitySchema).filter(row => visible(row, scope)).slice(0, 200), jobs: list('jobs', storedJobSchema).filter(row => visible(row, scope)).map(({ input: _input, source: _source, provider: _provider, model: _model, ...row }) => row).slice(0, 100), settings: settings() };
+}
+function mutate(raw) {
+    const { scope, mutation, source } = z.object({ scope: scopeSchema, mutation: mutationSchema, source: sourceSchema }).strict().parse(raw);
+    const stamp = now();
+    if (mutation.action === 'settings') {
+        if (settings().revision !== mutation.settings.revision)
+            throw new MemoryError('revisionConflict');
+        const value = { ...mutation.settings, revision: mutation.settings.revision + 1 };
+        put('config', 'settings', value);
+        if (!value.autoCapture)
+            cancelJobs(true);
+        return value;
+    }
+    if (mutation.action === 'propose')
+        return proposed({ scope, source, draft: mutation.draft, ...mutation.target ? { target: mutation.target, expected: mutation.expected } : {} });
+    if (mutation.action === 'create') {
+        if (list('records', entrySchema).length >= 1000)
+            throw new MemoryError('memoryLimit');
+        if (mutation.draft.range === 'session' && !scope.session)
+            throw new MemoryError('sessionRequired');
+        return save({ ...mutation.draft, id: randomUUID(), version: 1, workspace: mutation.draft.range === 'personal' ? 'personal' : scope.workspace, session: mutation.draft.range === 'session' ? scope.session : null, source, state: 'active', updated: stamp });
+    }
+    if (mutation.action === 'approve' || mutation.action === 'reject') {
+        const row = one('candidates', mutation.id, candidateSchema);
+        checkScope(row, scope);
+        if (row.revision !== mutation.revision || row.state !== 'pending')
+            throw new MemoryError('revisionConflict');
+        if (mutation.action === 'reject') {
+            put('candidates', row.id, { ...row, state: 'rejected', updated: stamp });
+            return { committed: true };
+        }
+        const old = row.target ? current(row.target, scope, row.expected) : null;
+        if (old?.state === 'trash')
+            throw new MemoryError('revisionConflict');
+        if (!old && list('records', entrySchema).length >= 1000)
+            throw new MemoryError('memoryLimit');
+        const draft = mutation.draft;
+        if (draft.range === 'session' && !scope.session)
+            throw new MemoryError('sessionRequired');
+        const result = save({ ...draft, id: old?.id ?? randomUUID(), version: (old?.version ?? 0) + 1, workspace: draft.range === 'personal' ? 'personal' : scope.workspace, session: draft.range === 'session' ? scope.session : null, state: 'active', source: row.source, updated: stamp });
+        put('candidates', row.id, { ...row, draft, state: 'accepted', target: result.id, updated: stamp });
+        return result;
+    }
+    if (mutation.action === 'capture' || mutation.action === 'cancel')
+        throw new MemoryError('invalidOperation');
+    const old = current(mutation.id, scope, mutation.version);
+    if (mutation.action === 'purge') {
+        if (old.state !== 'trash' || mutation.confirmTitle !== old.title)
+            throw new MemoryError('purgeConfirmation');
+        db.prepare('DELETE FROM records WHERE id=?').run(old.id);
+        db.prepare('DELETE FROM versions WHERE id=?').run(old.id);
+        for (const row of list('candidates', candidateSchema))
+            if (row.target === old.id)
+                db.prepare('DELETE FROM candidates WHERE id=?').run(row.id);
+        for (const row of list('activities', activitySchema))
+            if (row.items.some(item => item.id === old.id))
+                put('activities', row.id, { ...row, items: row.items.map(item => item.id === old.id ? { ...item, title: '', summary: '', status: 'deleted' } : item) });
+        return { committed: true };
+    }
+    if ((mutation.action === 'trash' || mutation.action === 'toggle') && old.state !== 'active' || mutation.action === 'restore' && old.state !== 'trash')
+        throw new MemoryError('revisionConflict');
+    return save({ ...old, version: old.version + 1, state: mutation.action === 'trash' ? 'trash' : 'active', recall: mutation.action === 'toggle' ? !old.recall : old.recall, updated: stamp });
+}
+function cancelJobs(automatic) { return list('jobs', storedJobSchema).filter(row => (!automatic || row.automatic) && ['queued', 'running'].includes(row.state)).map(row => { put('jobs', row.id, { ...row, state: 'cancelled', input: '', reason: 'userCancelled', updated: now() }); return row.id; }); }
+function operation(op, raw) {
+    if (op === 'ready') {
+        const { identity } = z.object({ identity: z.string() }).parse(raw), owner = db.prepare("SELECT body FROM config WHERE id='owner'").get();
+        if (owner && JSON.parse(z.string().parse(owner.body)) !== identity)
+            throw new MemoryError('profileMismatch');
+        if (!owner)
+            put('config', 'owner', identity);
+        for (const row of list('jobs', storedJobSchema))
+            if (row.state === 'queued' || row.state === 'running')
+                put('jobs', row.id, { ...row, state: 'interrupted', reason: 'restart', input: '', updated: now() });
+        for (const row of list('activities', activitySchema))
+            if (row.kind === 'prepared')
+                put('activities', row.id, { ...row, kind: 'notAdmitted', reason: 'restart', items: [], updated: now() });
+        for (const row of list('records', entrySchema)) {
+            const version = db.prepare('SELECT body FROM versions WHERE id=? AND version=?').get(row.id, row.version);
+            if (!version || JSON.stringify(entrySchema.parse(JSON.parse(z.string().parse(version.body)))) !== JSON.stringify(row))
+                throw new MemoryError('invariantViolation');
+        }
+        return null;
+    }
+    if (op === 'state')
+        return state(raw);
+    if (op === 'settings')
+        return settings();
+    if (op === 'mutate')
+        return transaction(() => mutate(raw));
+    if (op === 'propose')
+        return transaction(() => proposed(raw));
+    if (op === 'history') {
+        const args = z.object({ id: z.string(), scope: scopeSchema }).strict().parse(raw);
+        checkScope(one('records', args.id, entrySchema), args.scope);
+        return db.prepare('SELECT body FROM versions WHERE id=? ORDER BY version DESC LIMIT 100').all(args.id).map(row => entrySchema.parse(JSON.parse(z.string().parse(row.body)))).filter(row => visible(row, args.scope));
+    }
+    if (op === 'read') {
+        const args = z.object({ id: z.string(), version: z.number().int().optional(), scope: scopeSchema, history: z.boolean().default(false) }).strict().parse(raw), row = one('records', args.id, entrySchema);
+        checkScope(row, args.scope);
+        if (!args.history && (row.state !== 'active' || !row.recall))
+            throw new MemoryError('notReadable', 403);
+        const old = args.version && args.version !== row.version ? db.prepare('SELECT body FROM versions WHERE id=? AND version=?').get(row.id, args.version) : null;
+        const value = old ? entrySchema.parse(JSON.parse(z.string().parse(old.body))) : row;
+        if (args.version && value.version !== args.version)
+            throw new MemoryError('notFound', 404);
+        checkScope(value, args.scope);
+        if (!args.history && value.state !== 'active')
+            throw new MemoryError('notReadable', 403);
+        return value;
+    }
+    if (op === 'activity') {
+        const parsed = activitySchema.parse(raw), row = { ...parsed, items: parsed.items.map(item => db.prepare('SELECT id FROM records WHERE id=?').get(item.id) ? item : { ...item, title: '', summary: '', status: 'deleted' }) };
+        put('activities', row.id, row);
+        db.exec('DELETE FROM activities WHERE rowid NOT IN (SELECT rowid FROM activities ORDER BY rowid DESC LIMIT 2000)');
+        return row;
+    }
+    if (op === 'settle') {
+        const args = z.object({ scope: scopeSchema, turn: z.number(), reason: z.string() }).parse(raw);
+        for (const row of list('activities', activitySchema))
+            if (row.session === args.scope.session && row.turn === args.turn && row.kind === 'prepared')
+                put('activities', row.id, { ...row, kind: 'notAdmitted', reason: args.reason, items: [], updated: now() });
+        return null;
+    }
+    if (op === 'enqueue')
+        return transaction(() => {
+            const job = storedJobSchema.parse(raw), duplicate = db.prepare('SELECT body FROM jobs WHERE id=?').get(job.id);
+            if (duplicate)
+                return jobSchema.parse(JSON.parse(z.string().parse(duplicate.body)));
+            const all = list('jobs', storedJobSchema), config = settings();
+            if (all.filter(row => ['queued', 'running'].includes(row.state)).length >= 20)
+                throw new MemoryError('queueFull');
+            const day = now().slice(0, 10), budget = db.prepare('SELECT calls FROM budgets WHERE day=?').get(day);
+            const count = budget ? z.number().parse(budget.calls) : 0;
+            const value = job.automatic && !config.autoCapture ? { ...job, state: 'skipped', reason: 'autoCaptureOff', input: '' } : count >= config.maxDailyCalls ? { ...job, state: 'skipped', reason: 'dailyBudget', input: '' } : job;
+            if (value.state !== 'skipped')
+                db.prepare('INSERT INTO budgets(day,calls) VALUES(?,1) ON CONFLICT(day) DO UPDATE SET calls=calls+1').run(day);
+            db.exec("DELETE FROM jobs WHERE rowid NOT IN (SELECT rowid FROM jobs ORDER BY rowid DESC LIMIT 2000) AND json_extract(body,'$.state') NOT IN ('queued','running')");
+            put('jobs', job.id, value);
+            return jobSchema.parse(value);
+        });
+    if (op === 'next') {
+        const job = list('jobs', storedJobSchema).reverse().find(row => row.state === 'queued');
+        if (!job)
+            return null;
+        const value = { ...job, state: 'running', updated: now() };
+        put('jobs', job.id, value);
+        return value;
+    }
+    if (op === 'finish')
+        return transaction(() => {
+            const args = z.object({ id: z.string(), state: z.enum(['done', 'failed', 'cancelled']), reason: z.string(), drafts: z.array(draftSchema).max(4) }).strict().parse(raw), job = one('jobs', args.id, storedJobSchema);
+            if (job.state !== 'running')
+                return jobSchema.parse(job);
+            const scope = { workspace: job.workspace, session: job.session };
+            const ids = args.state === 'done' ? args.drafts.map((draft, index) => proposed({ scope, draft: { ...draft, range: 'workspace' }, source: job.source, id: `${job.id}:${index}` }).id) : [];
+            const value = { ...job, state: args.state, reason: args.reason, candidateIds: ids, input: '', updated: now() };
+            put('jobs', job.id, value);
+            return jobSchema.parse(value);
+        });
+    if (op === 'cancel') {
+        const args = z.object({ id: z.string(), scope: scopeSchema }).parse(raw), row = one('jobs', args.id, storedJobSchema);
+        checkScope(row, args.scope);
+        if (!['queued', 'running'].includes(row.state))
+            return jobSchema.parse(row);
+        const value = { ...row, state: 'cancelled', input: '', reason: 'userCancelled', updated: now() };
+        put('jobs', row.id, value);
+        return jobSchema.parse(value);
+    }
+    if (op === 'cancelAll')
+        return transaction(() => cancelJobs(false));
+    if (op === 'close') {
+        db.close();
+        return null;
+    }
+    throw new MemoryError('invalidOperation');
+}
+port.on('message', (raw) => {
+    const request = z.object({ id: z.number(), op: z.string(), args: z.unknown() }).parse(raw);
+    try {
+        port.postMessage({ id: request.id, value: operation(request.op, request.args) });
+    }
+    catch (error) {
+        port.postMessage({ id: request.id, error: error instanceof MemoryError ? error.code : 'storageFailed', status: error instanceof MemoryError ? error.status : 503 });
+    }
+});

package/lib/store.d.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+export declare class Store {
+    readonly ready: Promise<void>;
+    private worker?;
+    private root;
+    private id;
+    private closing;
+    private owned;
+    private pending;
+    constructor(directory: string, profileDirectory?: string);
+    private start;
+    private request;
+    call<T>(op: string, args: unknown, schema: z.ZodType<T>): Promise<T>;
+    close(): Promise<void>;
+}

package/lib/store.js

@@ -0,0 +1,113 @@
+/** One worker owns SQLite; all responses cross a schema checked boundary. */
+import { Worker } from 'node:worker_threads';
+import { mkdir, realpath, open, unlink, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { createHash } from 'node:crypto';
+import { MemoryError } from "./shared.js";
+const roots = new Set();
+export class Store {
+    ready;
+    worker;
+    root = '';
+    id = 0;
+    closing = false;
+    owned = false;
+    pending = new Map();
+    constructor(directory, profileDirectory) { this.ready = this.start(directory, profileDirectory); }
+    async start(directory, profileDirectory) {
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        this.root = await realpath(directory);
+        if (roots.has(this.root))
+            throw new MemoryError('dataRootBusy');
+        roots.add(this.root);
+        try {
+            // Kernel lock file is process-labelled; a live foreign owner is never stolen.
+            const lock = join(this.root, 'owner.lock');
+            const claim = async () => { const file = await open(lock, 'wx', 0o600); try {
+                await file.writeFile(String(process.pid));
+            }
+            finally {
+                await file.close();
+            } };
+            try {
+                await claim();
+            }
+            catch (error) {
+                if (!(error instanceof Error && 'code' in error && error.code === 'EEXIST'))
+                    throw error;
+                const pid = Number(await readFile(lock, 'utf8'));
+                if (!Number.isSafeInteger(pid) || pid <= 0)
+                    throw new MemoryError('dataRootBusy');
+                try {
+                    process.kill(pid, 0);
+                    throw new MemoryError('dataRootBusy');
+                }
+                catch (reason) {
+                    if (!(reason instanceof Error && 'code' in reason && reason.code === 'ESRCH'))
+                        throw reason;
+                }
+                // Only one stale-owner recoverer may remove the dead owner's file.
+                const guard = await open(join(this.root, 'owner.recover'), 'wx', 0o600);
+                try {
+                    if (Number(await readFile(lock, 'utf8')) !== pid)
+                        throw new MemoryError('dataRootBusy');
+                    await unlink(lock);
+                    await claim();
+                }
+                finally {
+                    await guard.close();
+                    await unlink(join(this.root, 'owner.recover'));
+                }
+            }
+            this.owned = true;
+        }
+        catch (error) {
+            roots.delete(this.root);
+            throw error;
+        }
+        const worker = this.worker = new Worker(new URL(import.meta.url.endsWith('.ts') ? './storage-worker.ts' : './storage-worker.js', import.meta.url), { workerData: this.root });
+        worker.on('message', (raw) => {
+            const reply = z.object({ id: z.number(), value: z.unknown().optional(), error: z.string().optional(), status: z.number().optional() }).parse(raw), slot = this.pending.get(reply.id);
+            if (!slot)
+                return;
+            this.pending.delete(reply.id);
+            if (reply.error)
+                slot.reject(new MemoryError(reply.error, reply.status ?? 503));
+            else
+                slot.resolve(reply.value);
+        });
+        const fail = (error) => { this.closing = true; for (const slot of this.pending.values())
+            slot.reject(error); this.pending.clear(); };
+        worker.on('error', fail);
+        worker.on('exit', code => { if (this.pending.size)
+            fail(new Error(`Database worker exited: ${code}`)); });
+        const identity = profileDirectory ? createHash('sha256').update(await realpath(profileDirectory)).digest('hex') : 'test';
+        await this.request('ready', { identity });
+    }
+    request(op, args) {
+        if (this.closing || !this.worker)
+            return Promise.reject(new MemoryError('closed', 503));
+        if (this.pending.size >= 128)
+            return Promise.reject(new MemoryError('busy', 503));
+        const id = ++this.id;
+        return new Promise((resolve, reject) => { this.pending.set(id, { resolve, reject }); this.worker?.postMessage({ id, op, args }); });
+    }
+    async call(op, args, schema) { await this.ready; return schema.parse(await this.request(op, args)); }
+    async close() {
+        try {
+            await this.ready;
+            if (!this.closing)
+                await this.request('close', {});
+        }
+        finally {
+            this.closing = true;
+            await this.worker?.terminate();
+            if (this.owned) {
+                this.owned = false;
+                roots.delete(this.root);
+                await unlink(join(this.root, 'owner.lock'));
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,126 @@
 {
   "name": "@dsh-libing/memory-manager",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "记忆中心：候选复核、按会话召回与可追溯的记忆管理",
+  "type": "module",
+  "icon": "icon.svg",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/client-types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "icon.svg",
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "license": "UNLICENSED",
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitcode.com/LiBing-DSH/dsh-libing.git",
+    "directory": "plugins/memory-manager"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "dependencies": {
+    "zod": "4.4.3"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/dsh-app-boot": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-query": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-workspace": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "0.2.0-rc.2"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/dsh-app-boot": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-session-query": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-workspace": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-llm": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-tools": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-system-prompt": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-connection": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-locale": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-layout": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-sidebar": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-slots": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-renderer": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-conversation": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-chat": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-session": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-api-session-controller": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-workspace": "0.2.0-rc.2",
+    "@deepseek-ai/dsh-agent-default-model": "0.2.0-rc.2"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-sidebar",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-chat",
+        "@deepseek-ai/dsh-client-ui-workspace"
+      ]
+    },
+    "market": {
+      "displayName": {
+        "zh": "记忆中心",
+        "en": "Memory Center"
+      },
+      "category": "utilities",
+      "icon": "icon.svg",
+      "maintainers": [
+        "@lujinxing"
+      ],
+      "compatibility": {
+        "dsh": "0.2.0-rc.2"
+      },
+      "allowedBuilds": []
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && tsc -p tsconfig.client.build.json && node --import tsx/esm ../../scripts/build-client.ts memory-manager",
+    "typecheck:client": "tsc -p tsconfig.client.json --noEmit"
+  }
 }