dsh-knowledge-library 0.0.0-stage → 0.1.0

package/dist/core/library.js

@@ -0,0 +1,386 @@
+import { DatabaseSync } from 'node:sqlite';
+import { randomUUID, createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, lstatSync, unlinkSync, openSync, closeSync } from 'node:fs';
+import { resolve, join, dirname, basename, extname, relative, isAbsolute } from 'node:path';
+import { extractArticle, formatTime, parseSubtitles, splitSegments } from './extract.js';
+import { validateUrl } from './fetch.js';
+export const MAX_FILE_BYTES = 64 * 1024 * 1024;
+export const MAX_TEXT_CHARS = 2_000_000;
+const hash = (data) => createHash('sha256').update(data).digest('hex');
+const now = () => new Date().toISOString();
+const cleanString = (value, max = 200) => typeof value === 'string' ? value.trim().slice(0, max) : '';
+export function categoryName(value) {
+    const parts = cleanString(value, 180).split(/[\\/]/).filter(Boolean);
+    if (parts.length > 5 || parts.some(p => p === '.' || p === '..' || /[<>:"|?*\x00-\x1f]/.test(p) || /[. ]$/.test(p) || /^(con|prn|aux|nul|com[0-9]|lpt[0-9])(?:\.|$)/i.test(p))) {
+        throw new Error('分类最多 5 层，不能包含路径跳转、保留名称或特殊文件名字符');
+    }
+    return parts.join('/') || '收件箱';
+}
+export function atomicJson(path, value) {
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(tmp, JSON.stringify(value, null, 2), { encoding: 'utf8', flag: 'wx' });
+    renameSync(tmp, path);
+}
+export class Library {
+    root;
+    db;
+    warnings = [];
+    lockPath;
+    closed = false;
+    constructor(root) {
+        if (!isAbsolute(root))
+            throw new Error('资料库目录必须是绝对路径');
+        this.root = resolve(root);
+        mkdirSync(join(this.root, '.system'), { recursive: true });
+        mkdirSync(join(this.root, 'materials'), { recursive: true });
+        this.lockPath = join(this.root, '.system', 'writer.lock');
+        if (existsSync(this.lockPath)) {
+            const previous = Number(readFileSync(this.lockPath, 'utf8'));
+            if (!Number.isInteger(previous) || previous <= 0)
+                throw new Error('资料库锁文件无效，请确认没有其他实例后移除 .system/writer.lock');
+            let alive = false;
+            try {
+                process.kill(previous, 0);
+                alive = true;
+            }
+            catch (error) {
+                if (error.code !== 'ESRCH')
+                    alive = true;
+            }
+            if (alive)
+                throw new Error('这个资料库已被另一实例打开，请关闭独立预览或另一个 Harness 实例');
+            unlinkSync(this.lockPath);
+        }
+        const fd = openSync(this.lockPath, 'wx');
+        writeFileSync(fd, String(process.pid));
+        closeSync(fd);
+        try {
+            this.db = new DatabaseSync(join(this.root, '.system', 'index.sqlite'));
+            this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;
+        CREATE TABLE IF NOT EXISTS materials (id TEXT PRIMARY KEY, path TEXT NOT NULL, meta TEXT NOT NULL, content TEXT NOT NULL, content_hash TEXT NOT NULL, updated_at TEXT NOT NULL);
+        CREATE VIRTUAL TABLE IF NOT EXISTS material_fts USING fts5(id UNINDEXED, title, content, tokenize='trigram');`);
+            this.rebuild();
+        }
+        catch (error) {
+            try {
+                this.db.close();
+            }
+            catch { }
+            unlinkSync(this.lockPath);
+            throw error;
+        }
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.db.close();
+        if (existsSync(this.lockPath) && readFileSync(this.lockPath, 'utf8') === String(process.pid))
+            unlinkSync(this.lockPath);
+    }
+    assertContained(path) {
+        const rel = relative(this.root, resolve(path));
+        if (rel.startsWith('..') || isAbsolute(rel))
+            throw new Error('路径超出资料库');
+        let current = this.root;
+        for (const part of rel.split(/[\\/]/).filter(Boolean)) {
+            current = join(current, part);
+            if (existsSync(current) && lstatSync(current).isSymbolicLink())
+                throw new Error('资料库不支持符号链接目录');
+        }
+    }
+    index(meta, path, content) {
+        this.db.prepare('INSERT OR REPLACE INTO materials VALUES (?,?,?,?,?,?)').run(meta.id, path, JSON.stringify(meta), content, meta.contentHash, meta.updatedAt);
+        this.db.prepare('DELETE FROM material_fts WHERE id=?').run(meta.id);
+        this.db.prepare('INSERT INTO material_fts (id,title,content) VALUES (?,?,?)').run(meta.id, meta.title, content);
+    }
+    rebuild() {
+        this.warnings.length = 0;
+        const entries = [];
+        const visit = (directory, depth) => {
+            if (depth > 7)
+                return;
+            for (const entry of readdirSync(directory, { withFileTypes: true })) {
+                if (!entry.isDirectory() || entry.name.startsWith('.') || entry.isSymbolicLink())
+                    continue;
+                const path = join(directory, entry.name);
+                if (!existsSync(join(path, 'metadata.json'))) {
+                    visit(path, depth + 1);
+                    continue;
+                }
+                try {
+                    this.assertContained(path);
+                    const meta = JSON.parse(readFileSync(join(path, 'metadata.json'), 'utf8'));
+                    if (meta.schemaVersion !== 1 || !/^r_[a-f0-9-]+$/.test(meta.id) || meta.id !== entry.name || !Array.isArray(meta.tags) || !Array.isArray(meta.citations))
+                        throw new Error('元数据格式不正确');
+                    if (!['text', 'web', 'file', 'video', 'transcript', 'note'].includes(meta.kind))
+                        throw new Error('未知资料类型');
+                    const content = readFileSync(join(path, 'content.md'), 'utf8');
+                    const segmentsRaw = readFileSync(join(path, 'segments.json'), 'utf8');
+                    const segments = JSON.parse(segmentsRaw);
+                    if (!Array.isArray(segments))
+                        throw new Error('缺少可引用段落');
+                    if ((meta.textChecksum && hash(content) !== meta.textChecksum) || (meta.segmentsChecksum && hash(segmentsRaw) !== meta.segmentsChecksum)) {
+                        throw new Error('正文或引用段落被外部修改，请恢复原文件或将修改后的内容重新导入');
+                    }
+                    // The physical category remains recoverable after an interrupted move.
+                    meta.category = relative(join(this.root, 'materials'), dirname(path)).split('\\').join('/');
+                    entries.push({ meta, path, content });
+                }
+                catch (error) {
+                    this.warnings.push(`${entry.name}: ${error.message}`);
+                }
+            }
+        };
+        visit(join(this.root, 'materials'), 0);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.exec('DELETE FROM materials; DELETE FROM material_fts');
+            for (const entry of entries)
+                this.index(entry.meta, entry.path, entry.content);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return { indexed: entries.length, warnings: [...this.warnings] };
+    }
+    row(id) {
+        const row = this.db.prepare('SELECT * FROM materials WHERE id=?').get(id);
+        if (!row)
+            throw new Error('资料不存在');
+        this.assertContained(row.path);
+        return row;
+    }
+    get(id) {
+        const row = this.row(id);
+        return { ...JSON.parse(row.meta), content: row.content, segments: JSON.parse(readFileSync(join(row.path, 'segments.json'), 'utf8')), path: row.path };
+    }
+    original(id) {
+        const item = this.get(id);
+        if (!item.originalFile || basename(item.originalFile) !== item.originalFile)
+            throw new Error('该资料没有原始附件');
+        const path = join(item.path, item.originalFile);
+        this.assertContained(path);
+        return { bytes: readFileSync(path), name: item.originalName || item.originalFile };
+    }
+    save(content, fields, extra, original, suppliedSegments) {
+        if (content.length > MAX_TEXT_CHARS)
+            throw new Error('正文超过 200 万字符，请拆分后导入');
+        const digest = hash(`${extra.kind}\0${original ? hash(original.bytes) : content}\0${fields.sourceUrl ?? ''}\0${JSON.stringify(extra.citations ?? [])}`);
+        const duplicate = this.db.prepare('SELECT id FROM materials WHERE content_hash=? LIMIT 1').get(digest);
+        if (duplicate)
+            return { material: this.get(duplicate.id), duplicate: true };
+        const category = categoryName(fields.category);
+        const id = `r_${randomUUID()}`;
+        const timestamp = now();
+        const meta = {
+            schemaVersion: 1, id, title: cleanString(fields.title, 300) || content.split('\n').find(line => line.trim())?.replace(/^#+\s*/, '').slice(0, 100) || '未命名资料',
+            status: 'ready', category, tags: this.tags(fields.tags),
+            collection: cleanString(fields.collection), sourceNote: cleanString(fields.sourceNote, 2000),
+            createdAt: timestamp, updatedAt: timestamp, contentHash: digest, revision: 1, citations: [],
+            extraction: '原始文本', ...extra,
+        };
+        if (fields.sourceUrl)
+            meta.sourceUrl = validateUrl(fields.sourceUrl).href;
+        const path = join(this.root, 'materials', ...category.split('/'), id);
+        this.assertContained(path);
+        const stage = join(dirname(path), `.pending-${id}`);
+        mkdirSync(stage, { recursive: true });
+        if (original) {
+            if (original.bytes.length > MAX_FILE_BYTES)
+                throw new Error('文件超过 64 MB');
+            const extension = extname(original.name).toLowerCase().replace(/[^.a-z0-9]/g, '').slice(0, 16);
+            meta.originalName = basename(original.name);
+            meta.originalFile = `original${extension || '.bin'}`;
+            writeFileSync(join(stage, meta.originalFile), original.bytes);
+        }
+        const segmentsJson = JSON.stringify(suppliedSegments ?? splitSegments(content), null, 2);
+        meta.textChecksum = hash(content);
+        meta.segmentsChecksum = hash(segmentsJson);
+        writeFileSync(join(stage, 'content.md'), content, 'utf8');
+        writeFileSync(join(stage, 'segments.json'), segmentsJson, 'utf8');
+        atomicJson(join(stage, 'metadata.json'), meta);
+        renameSync(stage, path); // A committed material always has all canonical files.
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.index(meta, path, content);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return { material: this.get(id), duplicate: false };
+    }
+    tags(values) {
+        if (values === undefined)
+            return [];
+        if (!Array.isArray(values) || values.some(v => typeof v !== 'string'))
+            throw new Error('标签必须是字符串数组');
+        return [...new Set(values.map(v => cleanString(v, 40)).filter(Boolean))].slice(0, 30);
+    }
+    captureText(text, fields = {}) {
+        if (typeof text !== 'string' || !text.trim())
+            throw new Error('请填写要保存的正文');
+        return this.save(text.trim(), fields, { kind: 'text' });
+    }
+    captureHtml(html, url, fields = {}) {
+        const source = validateUrl(url).href;
+        const article = extractArticle(html, source);
+        return this.save(article.content, { ...fields, title: fields.title || article.title, sourceUrl: source }, {
+            kind: 'web', author: article.author, extraction: 'Readability 正文提取；图片保留远程引用，未离线下载',
+        }, { name: 'page.html', bytes: Buffer.from(html) });
+    }
+    importFile(path, fields = {}) {
+        if (!isAbsolute(path))
+            throw new Error('请输入文件的绝对路径');
+        const info = statSync(path);
+        if (!info.isFile() || info.size > MAX_FILE_BYTES)
+            throw new Error('仅支持不超过 64 MB 的普通文件');
+        return this.importBytes(basename(path), readFileSync(path), fields);
+    }
+    importBytes(name, bytes, fields = {}) {
+        if (bytes.length > MAX_FILE_BYTES || !bytes.length)
+            throw new Error('文件不能为空，且不能超过 64 MB');
+        const extension = extname(name).toLowerCase();
+        const original = { name: basename(name), bytes };
+        const data = { ...fields, title: fields.title || basename(name, extension) };
+        if (['.vtt', '.srt'].includes(extension)) {
+            const segments = parseSubtitles(this.decode(bytes));
+            return this.save(segments.map(p => `[${formatTime(p.startSeconds)}] ${p.text}`).join('\n\n'), data, { kind: 'transcript', extraction: '导入字幕；包含时间戳，未分析视频画面' }, original, segments);
+        }
+        if (['.html', '.htm'].includes(extension)) {
+            const article = extractArticle(this.decode(bytes), fields.sourceUrl || 'https://import.invalid/');
+            return this.save(article.content, { ...data, title: fields.title || article.title }, { kind: 'file', extraction: '本地 HTML 正文提取', author: article.author }, original);
+        }
+        if (['.txt', '.md', '.markdown', '.csv', '.json', '.log'].includes(extension)) {
+            return this.save(this.decode(bytes), data, { kind: 'file', extraction: 'UTF-8 文本导入' }, original);
+        }
+        const video = ['.mp4', '.mkv', '.mov', '.webm', '.mp3', '.wav', '.m4a', '.ogg'].includes(extension);
+        return this.save('', data, {
+            kind: video ? 'video' : 'file', status: 'stored',
+            extraction: video ? '已保存原文件；尚未转写，也未分析画面。请另行导入 SRT/VTT 字幕并归入同一专题。' : '已保存原文件；此格式暂不支持正文提取。',
+        }, original, []);
+    }
+    decode(bytes) {
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new Error('文本编码不是 UTF-8，请转换编码后导入');
+        }
+    }
+    update(id, fields) {
+        const item = this.get(id);
+        const { content, segments: _segments, path: oldPath, ...meta } = item;
+        if (fields.title !== undefined) {
+            if (!cleanString(fields.title))
+                throw new Error('标题不能为空');
+            meta.title = cleanString(fields.title, 300);
+        }
+        if (fields.tags !== undefined)
+            meta.tags = this.tags(fields.tags);
+        if (fields.category !== undefined)
+            meta.category = categoryName(fields.category);
+        if (fields.collection !== undefined)
+            meta.collection = cleanString(fields.collection);
+        if (fields.sourceNote !== undefined)
+            meta.sourceNote = cleanString(fields.sourceNote, 2000);
+        meta.updatedAt = now();
+        const path = join(this.root, 'materials', ...meta.category.split('/'), id);
+        this.assertContained(path);
+        if (path !== oldPath) {
+            mkdirSync(dirname(path), { recursive: true });
+            renameSync(oldPath, path);
+        }
+        atomicJson(join(path, 'metadata.json'), meta);
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.index(meta, path, content);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+        return this.get(id);
+    }
+    saveNote(content, citations, fields) {
+        if (!content?.trim())
+            throw new Error('笔记内容不能为空');
+        if (!Array.isArray(citations) || citations.length > 200)
+            throw new Error('引用必须是数组且最多 200 条');
+        for (const citation of citations) {
+            const source = this.get(citation.materialId);
+            if (citation.segmentId && !source.segments.some(s => s.id === citation.segmentId))
+                throw new Error(`引用段落不存在：${citation.segmentId}`);
+        }
+        return this.save(content.trim(), fields, { kind: 'note', citations, extraction: '知识笔记；内容由用户或 Agent 提供，请结合引用核验' });
+    }
+    search(options = {}) {
+        const query = cleanString(options.query, 500);
+        const limit = Math.max(1, Math.min(100, Number(options.limit) || 40));
+        const offset = Math.max(0, Math.floor(Number(options.offset) || 0));
+        const terms = query.toLocaleLowerCase().split(/\s+/).filter(Boolean);
+        const rows = this.db.prepare('SELECT id,meta,content FROM materials ORDER BY updated_at DESC').all();
+        // Literal substring matching guarantees one- and two-character Chinese searches.
+        // FTS narrows body/title candidates for longer terms; metadata is always searched too.
+        let indexed;
+        if (terms.length === 1 && [...terms[0]].length >= 3) {
+            indexed = new Set(this.db.prepare('SELECT id FROM material_fts WHERE material_fts MATCH ?').all(`"${terms[0].replaceAll('"', '""')}"`).map(row => row.id));
+        }
+        const matched = rows.filter(row => {
+            const meta = JSON.parse(row.meta);
+            if (options.category && meta.category !== options.category && !meta.category.startsWith(`${options.category}/`))
+                return false;
+            if (options.kind && meta.kind !== options.kind)
+                return false;
+            if (options.tag && !meta.tags.includes(options.tag))
+                return false;
+            if (options.collection && meta.collection !== options.collection)
+                return false;
+            const metadataText = `${meta.title}\n${meta.category}\n${meta.tags.join(' ')}\n${meta.collection}\n${meta.sourceNote}`.toLocaleLowerCase();
+            if (!terms.length)
+                return true;
+            const haystack = metadataText + '\n' + row.content.toLocaleLowerCase();
+            // FTS is an optimization hint only; punctuation and Unicode never change correctness.
+            return indexed?.has(row.id) || terms.every(term => haystack.includes(term));
+        });
+        return {
+            total: matched.length,
+            items: matched.slice(offset, offset + limit).map(row => {
+                const item = this.get(row.id);
+                const { content, segments, path: _path, ...meta } = item;
+                const matches = terms.length ? segments.filter(p => terms.some(t => p.text.toLocaleLowerCase().includes(t))).slice(0, 3) : [];
+                return { ...meta, excerpt: (matches[0]?.text ?? content).slice(0, 240), matches: matches.map(p => ({ ...p, text: p.text.slice(0, 600), citation: `library://${item.id}/${p.id}` })) };
+            }),
+        };
+    }
+    stats() {
+        const rows = this.db.prepare('SELECT meta FROM materials').all();
+        const materials = rows.map(row => JSON.parse(row.meta));
+        const count = (select) => {
+            const map = new Map();
+            for (const m of materials)
+                for (const key of select(m))
+                    if (key)
+                        map.set(key, (map.get(key) || 0) + 1);
+            return [...map].sort((a, b) => a[0].localeCompare(b[0], 'zh')).map(([name, count]) => ({ name, count }));
+        };
+        return { total: materials.length, ready: materials.filter(m => m.status === 'ready').length, notes: materials.filter(m => m.kind === 'note').length,
+            inbox: materials.filter(m => m.category === '收件箱').length, categories: count(m => [m.category]),
+            tags: count(m => m.tags), collections: count(m => [m.collection]), root: this.root, warnings: [...this.warnings] };
+    }
+    exportMarkdown(id) {
+        const item = this.get(id);
+        const header = JSON.stringify({ id: item.id, title: item.title, category: item.category, tags: item.tags, collection: item.collection, sourceUrl: item.sourceUrl, createdAt: item.createdAt, revision: item.revision }, null, 2);
+        const references = item.citations.map(c => {
+            const source = this.get(c.materialId);
+            const segment = c.segmentId ? source.segments.find(p => p.id === c.segmentId) : undefined;
+            return `- ${source.title} — library://${source.id}${c.segmentId ? `/${c.segmentId}` : ''}${segment?.startSeconds !== undefined ? ` (${formatTime(segment.startSeconds)})` : ''}${source.sourceUrl ? ` — ${source.sourceUrl}` : ''}`;
+        }).join('\n');
+        return `---\n${header}\n---\n\n# ${item.title}\n\n${item.content}${references ? `\n\n## 来源\n\n${references}` : ''}\n`;
+    }
+}

package/dist/http.d.ts

@@ -0,0 +1,6 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { Library } from './core/library.js';
+import type { ImportQueue } from './core/jobs.js';
+export declare const API_PATH = "/knowledge-library/api";
+export declare function createHandler(library: Library, queue: ImportQueue, getOrigin: () => string): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+export declare function serveAsset(req: IncomingMessage, res: ServerResponse): void;

package/dist/http.js

@@ -0,0 +1,157 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export const API_PATH = '/knowledge-library/api';
+function send(res, status, value) {
+    res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8', 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' });
+    res.end(JSON.stringify(value));
+}
+async function body(req) {
+    if (!req.headers['content-type']?.startsWith('application/json'))
+        throw new Error('请求必须使用 application/json');
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of req) {
+        length += chunk.length;
+        if (length > 90 * 1024 * 1024)
+            throw new Error('请求体超过限制');
+        chunks.push(chunk);
+    }
+    const data = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (!data || typeof data !== 'object' || Array.isArray(data))
+        throw new Error('请求内容必须是 JSON 对象');
+    return data;
+}
+function fields(data) {
+    for (const key of ['title', 'category', 'collection', 'sourceNote', 'sourceUrl']) {
+        if (data[key] !== undefined && typeof data[key] !== 'string')
+            throw new Error(`${key} 必须是字符串`);
+    }
+    if (data.tags !== undefined && (!Array.isArray(data.tags) || data.tags.some((tag) => typeof tag !== 'string')))
+        throw new Error('标签必须是字符串数组');
+    return { title: data.title, category: data.category, collection: data.collection, tags: data.tags, sourceNote: data.sourceNote, sourceUrl: data.sourceUrl };
+}
+const localAddress = (address = '') => address === '::1' || address === '127.0.0.1' || address === '::ffff:127.0.0.1';
+export function createHandler(library, queue, getOrigin) {
+    return async (req, res) => {
+        try {
+            const origin = getOrigin();
+            if (!localAddress(req.socket.remoteAddress) || req.headers.host !== new URL(origin).host) {
+                send(res, 403, { error: '资料库接口仅允许本机访问' });
+                return;
+            }
+            if (req.headers.origin && req.headers.origin !== origin) {
+                send(res, 403, { error: '不允许跨站访问' });
+                return;
+            }
+            const url = new URL(req.url || '/', origin);
+            const path = url.pathname.slice(API_PATH.length);
+            if (req.method === 'GET') {
+                if (path === '/stats') {
+                    send(res, 200, library.stats());
+                    return;
+                }
+                if (path === '/materials') {
+                    send(res, 200, library.search({ ...Object.fromEntries(url.searchParams), limit: Number(url.searchParams.get('limit')) || 40, offset: Number(url.searchParams.get('offset')) || 0 }));
+                    return;
+                }
+                if (path === '/jobs') {
+                    send(res, 200, queue.list());
+                    return;
+                }
+                const match = path.match(/^\/materials\/(r_[a-f0-9-]+)(?:\/(export|original))?$/);
+                if (match) {
+                    if (match[2] === 'export') {
+                        res.writeHead(200, { 'Content-Type': 'text/markdown; charset=utf-8', 'Content-Disposition': `attachment; filename="${match[1]}.md"`, 'Cache-Control': 'no-store', 'X-Content-Type-Options': 'nosniff' });
+                        res.end(library.exportMarkdown(match[1]));
+                        return;
+                    }
+                    if (match[2] === 'original') {
+                        const original = library.original(match[1]);
+                        res.writeHead(200, { 'Content-Type': 'application/octet-stream', 'Content-Disposition': `attachment; filename*=UTF-8''${encodeURIComponent(original.name).replaceAll("'", '%27')}`, 'X-Content-Type-Options': 'nosniff', 'Cache-Control': 'no-store' });
+                        res.end(original.bytes);
+                        return;
+                    }
+                    send(res, 200, library.get(match[1]));
+                    return;
+                }
+            }
+            if (req.method === 'POST' || req.method === 'PATCH') {
+                if (req.headers['x-knowledge-library'] !== '1') {
+                    send(res, 403, { error: '缺少同源请求标记' });
+                    return;
+                }
+                const data = await body(req);
+                if (req.method === 'POST' && path === '/capture') {
+                    const captureFields = fields(data);
+                    if (data.type === 'url' && typeof data.content === 'string') {
+                        send(res, 202, { job: queue.add(data.content, captureFields) });
+                        return;
+                    }
+                    if (data.type !== 'text')
+                        throw new Error('请选择网页或文本');
+                    send(res, 201, library.captureText(data.content, captureFields));
+                    return;
+                }
+                if (req.method === 'POST' && path === '/upload') {
+                    if (typeof data.name !== 'string' || typeof data.base64 !== 'string' || !/^[A-Za-z0-9+/]*={0,2}$/.test(data.base64))
+                        throw new Error('文件数据格式不正确');
+                    send(res, 201, library.importBytes(data.name, Buffer.from(data.base64, 'base64'), fields(data)));
+                    return;
+                }
+                if (req.method === 'POST' && path === '/notes') {
+                    if (typeof data.content !== 'string' || !Array.isArray(data.citations) || data.citations.some((c) => !c || typeof c.materialId !== 'string' || (c.segmentId !== undefined && typeof c.segmentId !== 'string')))
+                        throw new Error('笔记内容或引用格式不正确');
+                    send(res, 201, library.saveNote(data.content, data.citations, fields(data)));
+                    return;
+                }
+                const match = path.match(/^\/materials\/(r_[a-f0-9-]+)$/);
+                if (req.method === 'PATCH' && match) {
+                    send(res, 200, library.update(match[1], fields(data)));
+                    return;
+                }
+                const retry = path.match(/^\/jobs\/(job_[a-f0-9-]+)\/retry$/);
+                if (req.method === 'POST' && retry) {
+                    send(res, 200, queue.retry(retry[1]));
+                    return;
+                }
+                if (req.method === 'POST' && path === '/rebuild') {
+                    send(res, 200, library.rebuild());
+                    return;
+                }
+            }
+            send(res, 404, { error: '接口不存在' });
+        }
+        catch (error) {
+            if (!res.headersSent)
+                send(res, 400, { error: error instanceof Error ? error.message : '操作失败' });
+            else
+                res.end();
+        }
+    };
+}
+export function serveAsset(req, res) {
+    const path = new URL(req.url || '/', 'http://localhost').pathname;
+    const names = {
+        '/': ['index.html', 'text/html; charset=utf-8'],
+        '/app.js': ['app.js', 'text/javascript; charset=utf-8'],
+        '/app.css': ['app.css', 'text/css; charset=utf-8'],
+    };
+    const item = names[path];
+    if (!item) {
+        res.writeHead(404);
+        res.end();
+        return;
+    }
+    try {
+        const bytes = readFileSync(fileURLToPath(new URL(`../dist/public/${item[0]}`, import.meta.url)));
+        res.writeHead(200, {
+            'Content-Type': item[1], 'X-Content-Type-Options': 'nosniff',
+            'Content-Security-Policy': "default-src 'self'; script-src 'self'; style-src 'self'; img-src 'self' data:; connect-src 'self'; frame-ancestors 'none'; object-src 'none'; base-uri 'none'",
+        });
+        res.end(bytes);
+    }
+    catch {
+        res.writeHead(503);
+        res.end('请先运行 npm run build');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+export declare const name = "knowledge-library";
+export declare const inject: string[];
+export interface Config {
+    root: string;
+    allowProxyFakeIp?: boolean;
+}
+export declare const Config: z<Schemastery.ObjectS<NoInfer<{
+    root: z<string, string, "defined">;
+    allowProxyFakeIp: z<boolean, boolean, "defined">;
+}>>, Schemastery.ObjectT<NoInfer<{
+    root: z<string, string, "defined">;
+    allowProxyFakeIp: z<boolean, boolean, "defined">;
+}>>, "plain">;
+export declare function apply(ctx: Context, config: Config): void;

package/dist/index.js

@@ -0,0 +1,35 @@
+import z from '@deepseek-ai/schemastery';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { Library } from './core/library.js';
+import { ImportQueue } from './core/jobs.js';
+import { createTools } from './tools.js';
+import { API_PATH, createHandler } from './http.js';
+import { fetchPublicPage } from './core/fetch.js';
+export const name = 'knowledge-library';
+export const inject = ['tools'];
+export const Config = z.object({
+    root: z.string().default(join(homedir(), 'Documents', 'DSH-Knowledge-Library')).description('资料库绝对路径；更改后重新加载插件。资料独立于聊天和插件安装目录。'),
+    allowProxyFakeIp: z.boolean().default(false).description('仅在本机使用 Clash/Mihomo TUN fake-IP DNS 时启用。允许公网域名解析到 198.18.0.0/15，仍拒绝本机和其他内网地址。'),
+});
+export function apply(ctx, config) {
+    const library = new Library(config.root);
+    let queue;
+    try {
+        queue = new ImportQueue(library, (url, signal) => fetchPublicPage(url, signal, { allowProxyFakeIp: config.allowProxyFakeIp }));
+    }
+    catch (error) {
+        library.close();
+        throw error;
+    }
+    ctx.effect(() => async () => { await queue.close(); library.close(); });
+    for (const tool of createTools(library, queue))
+        ctx.tools.register(tool);
+    ctx.inject(['webServer'], child => {
+        child.webServer.register({
+            kind: 'prefix', path: API_PATH,
+            handler: createHandler(library, queue, () => child.webServer.getOrigin()),
+        });
+    });
+    ctx.logger.info(`资料库已加载：${library.root}`);
+}