dsh-knowledge-library 0.1.1 → 0.3.0

package/dist/core/page-images.js

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+import { splitSegments } from './extract.js';
+export const imageHash = (value) => createHash('sha256').update(value).digest('hex');
+export const imageFilePattern = /^img_[a-f0-9-]{36}\.(png|jpg|webp|gif)$/;
+export function validateImageManifest(value) {
+    const data = value;
+    if (!data || data.schemaVersion !== 1 || typeof data.model !== 'string' || !data.model || data.model.length > 300 || !Number.isInteger(data.limit) || data.limit < 1 || data.limit > 10 || !Number.isInteger(data.excluded) || data.excluded < 0 || !Array.isArray(data.records) || data.records.length > data.limit)
+        throw new Error('网页图片记录损坏');
+    const seen = new Set();
+    for (const record of data.records) {
+        if (!record || !/^img_[a-f0-9-]{36}$/.test(record.id) || seen.has(record.id) || typeof record.url !== 'string' || record.url.length > 8192 || !/^https?:\/\//.test(record.url) || typeof record.alt !== 'string' || record.alt.length > 500 || !['pending', 'downloading', 'recognizing', 'completed', 'failed', 'skipped'].includes(record.status) || !Number.isInteger(record.attempts) || record.attempts < 0 || record.attempts > 3)
+            throw new Error('网页图片条目损坏');
+        seen.add(record.id);
+        if (record.fileName !== undefined && (!imageFilePattern.test(record.fileName) || !record.fileName.startsWith(record.id + '.') || !/^[a-f0-9]{64}$/.test(record.checksum || '') || !['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(record.mediaType || '')))
+            throw new Error('网页原图记录无效');
+        for (const [key, max] of [['text', 8000], ['description', 3000], ['uncertainty', 1000], ['error', 2000]])
+            if (record[key] !== undefined && (typeof record[key] !== 'string' || record[key].length > max))
+                throw new Error('图片识别文字记录无效');
+        if (record.status === 'completed' && (!record.fileName || (!record.text?.trim() && !record.description?.trim())))
+            throw new Error('图片识别结果不完整');
+    }
+    return data;
+}
+export function imageSupplement(data) {
+    const sections = [];
+    const segments = [];
+    for (const [index, image] of (data?.records || []).entries()) {
+        if (image.status !== 'completed')
+            continue;
+        const section = `## 图片 ${index + 1} 识别补充（模型输出，请核对）\n\n来源图片：${image.url}\n模型：${data.model}${image.alt ? `\n原图说明：${image.alt}` : ''}\n\n${image.text ? `### 图中文字\n${image.text}\n\n` : ''}${image.description ? `### 图示解读（模型推断）\n${image.description}\n\n` : ''}${image.uncertainty ? `### 不确定与待核实\n${image.uncertainty}` : '请结合原图核验文字、数字与适用条件。'}`;
+        sections.push(section);
+        segments.push(...splitSegments(section).map((segment, i) => ({ ...segment, id: `v_${image.id.slice(4).replaceAll('-', '')}_${i + 1}` })));
+    }
+    return { text: sections.join('\n\n'), segments };
+}
+/** Sniff raster bytes and dimensions without decoding scripts or unbounded compressed content. */
+export function inspectImage(bytes) {
+    if (!bytes.length || bytes.length > 6 * 1024 * 1024)
+        throw new Error('图片不能为空且最多6MB');
+    let type;
+    let width = 0;
+    let height = 0;
+    if (bytes.length >= 24 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])) && bytes.toString('ascii', 12, 16) === 'IHDR') {
+        type = 'png';
+        width = bytes.readUInt32BE(16);
+        height = bytes.readUInt32BE(20);
+    }
+    else if (bytes.length >= 10 && /^GIF8[79]a$/.test(bytes.toString('ascii', 0, 6))) {
+        type = 'gif';
+        width = bytes.readUInt16LE(6);
+        height = bytes.readUInt16LE(8);
+    }
+    else if (bytes.length >= 12 && bytes[0] === 255 && bytes[1] === 216) {
+        for (let offset = 2; offset + 8 < bytes.length;) {
+            if (bytes[offset++] !== 255)
+                continue;
+            const marker = bytes[offset++];
+            if (marker === 0xd9 || marker === 0xda)
+                break;
+            if (marker === 0xff || marker === 0x00 || (marker >= 0xd0 && marker <= 0xd8))
+                continue;
+            const length = bytes.readUInt16BE(offset);
+            if (length < 2 || offset + length > bytes.length)
+                break;
+            if (marker >= 0xc0 && marker <= 0xcf && ![0xc4, 0xc8, 0xcc].includes(marker)) {
+                type = 'jpg';
+                height = bytes.readUInt16BE(offset + 3);
+                width = bytes.readUInt16BE(offset + 5);
+                break;
+            }
+            offset += length;
+        }
+    }
+    else if (bytes.length >= 30 && bytes.toString('ascii', 0, 4) === 'RIFF' && bytes.toString('ascii', 8, 12) === 'WEBP') {
+        const chunk = bytes.toString('ascii', 12, 16);
+        if (chunk === 'VP8X') {
+            width = bytes.readUIntLE(24, 3) + 1;
+            height = bytes.readUIntLE(27, 3) + 1;
+        }
+        else if (chunk === 'VP8 ' && bytes.subarray(23, 26).equals(Buffer.from([157, 1, 42]))) {
+            width = bytes.readUInt16LE(26) & 0x3fff;
+            height = bytes.readUInt16LE(28) & 0x3fff;
+        }
+        else if (chunk === 'VP8L' && bytes[20] === 0x2f) {
+            const packed = bytes.readUInt32LE(21);
+            width = (packed & 0x3fff) + 1;
+            height = ((packed >>> 14) & 0x3fff) + 1;
+        }
+        if (width && height)
+            type = 'webp';
+    }
+    if (!type || !width || !height)
+        throw new Error('不是有效的PNG、JPEG、WebP或GIF图片（不支持SVG/HTML）');
+    if (width > 20_000 || height > 20_000 || width * height > 24_000_000)
+        throw new Error('图片尺寸超过限制（最长边2万像素、总计2400万像素）');
+    return { extension: type, mediaType: `image/${type === 'jpg' ? 'jpeg' : type}`, width, height };
+}

package/dist/core/purge.d.ts

@@ -0,0 +1,20 @@
+export interface PurgeTicket {
+    id: string;
+    source: string;
+    staged: string;
+    manifest: string;
+}
+/** Durable, confirmed cleanup work. Only owned material directories are removable. */
+export declare class PurgeStore {
+    private root;
+    readonly directory: string;
+    constructor(root: string);
+    private contained;
+    private tree;
+    private ticket;
+    validate(id: string, source: string): void;
+    list(): PurgeTicket[];
+    stage(id: string, source: string): PurgeTicket;
+    rollback(ticket: PurgeTicket): void;
+    finish(ticket: PurgeTicket): void;
+}

package/dist/core/purge.js

@@ -0,0 +1,106 @@
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, isAbsolute, join, relative, resolve, sep } from 'node:path';
+const validId = (id) => typeof id === 'string' && /^r_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/.test(id);
+/** Durable, confirmed cleanup work. Only owned material directories are removable. */
+export class PurgeStore {
+    root;
+    directory;
+    constructor(root) {
+        this.root = root;
+        this.directory = join(root, '.system', 'purge');
+    }
+    contained(path) {
+        const rel = relative(this.root, resolve(path));
+        if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            throw new Error('清理路径超出资料库');
+        let current = this.root;
+        if (lstatSync(current).isSymbolicLink())
+            throw new Error('清理不支持符号链接');
+        for (const part of rel.split(sep)) {
+            current = join(current, part);
+            try {
+                if (lstatSync(current).isSymbolicLink())
+                    throw new Error('清理不支持符号链接');
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT')
+                    throw error;
+            }
+        }
+    }
+    tree(path) {
+        this.contained(path);
+        const info = lstatSync(path);
+        if (info.isSymbolicLink())
+            throw new Error('清理不支持符号链接');
+        if (info.isDirectory())
+            for (const entry of readdirSync(path))
+                this.tree(join(path, entry));
+    }
+    ticket(id, source) {
+        if (!validId(id))
+            throw new Error('清理资料 ID 无效');
+        source = resolve(source);
+        const rel = relative(join(this.root, 'materials'), source);
+        if (!rel || rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel) || basename(source) !== id)
+            throw new Error('清理目标不是资料目录');
+        const ticket = { id, source, staged: join(this.directory, id), manifest: join(this.directory, `${id}.json`) };
+        for (const path of [ticket.source, ticket.staged, ticket.manifest])
+            this.contained(path);
+        return ticket;
+    }
+    validate(id, source) { this.tree(this.ticket(id, source).source); }
+    list() {
+        this.contained(this.directory);
+        if (!existsSync(this.directory))
+            return [];
+        return readdirSync(this.directory).filter(name => name.endsWith('.json')).sort().map(name => {
+            const manifest = join(this.directory, name);
+            this.contained(manifest);
+            const data = JSON.parse(readFileSync(manifest, 'utf8'));
+            if (data.schemaVersion !== 1 || !validId(data.id) || name !== `${data.id}.json` || typeof data.source !== 'string' || isAbsolute(data.source))
+                throw new Error('待清理记录损坏');
+            return this.ticket(data.id, resolve(this.root, data.source));
+        });
+    }
+    stage(id, source) {
+        const ticket = this.ticket(id, source);
+        this.tree(ticket.source);
+        if (existsSync(ticket.staged))
+            throw new Error('该资料仍有待完成的文件清理');
+        mkdirSync(this.directory, { recursive: true });
+        writeFileSync(ticket.manifest, JSON.stringify({ schemaVersion: 1, id, source: relative(this.root, source) }), { flag: 'wx' });
+        try {
+            renameSync(ticket.source, ticket.staged);
+        }
+        catch (error) {
+            unlinkSync(ticket.manifest);
+            throw error;
+        }
+        return ticket;
+    }
+    rollback(ticket) {
+        const checked = this.ticket(ticket.id, ticket.source);
+        if (existsSync(checked.source))
+            throw new Error('原目录已有内容，无法回退文件清理');
+        this.tree(checked.staged);
+        renameSync(checked.staged, checked.source);
+        unlinkSync(checked.manifest);
+    }
+    finish(ticket) {
+        const checked = this.ticket(ticket.id, ticket.source);
+        if (existsSync(checked.source)) {
+            if (existsSync(checked.staged))
+                throw new Error('清理目录与原目录冲突，文件已保留');
+            // The process stopped before the move; no original file may be deleted.
+            unlinkSync(checked.manifest);
+            return;
+        }
+        if (existsSync(checked.staged)) {
+            this.tree(checked.staged);
+            // Both the absolute boundary and every descendant were checked above.
+            rmSync(checked.staged, { recursive: true, maxRetries: 2, retryDelay: 50 });
+        }
+        unlinkSync(checked.manifest);
+    }
+}

package/dist/directory-settings.d.ts

@@ -0,0 +1,18 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { DirectoryListing } from '@deepseek-ai/dsh-host-directory-picker';
+import { Library } from './core/library.js';
+import type { FetchPolicy } from './core/fetch.js';
+export type { DirectoryListing };
+export interface DirectorySettings {
+    status(): {
+        canChange: boolean;
+        canChangeNetwork: boolean;
+        picker: 'native' | 'browse' | null;
+        allowProxyFakeIp: boolean;
+    };
+    pick(signal: AbortSignal): Promise<string | null>;
+    list(path: string | undefined, signal: AbortSignal): Promise<DirectoryListing>;
+    change(root: string, expectedRoot: string): Promise<string>;
+    setProxyMode(enabled: boolean, expected: boolean, expectedRoot: string): Promise<boolean>;
+}
+export declare function createDirectorySettings(ctx: Context, library: Library, policy?: FetchPolicy): DirectorySettings;

package/dist/directory-settings.js

@@ -0,0 +1,92 @@
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+import { Library } from './core/library.js';
+export function createDirectorySettings(ctx, library, policy = {}) {
+    let changing = false;
+    let picking = false;
+    const editorEntry = () => {
+        const editor = ctx.get('configEditor');
+        const entry = editor?.entries().find(entry => entry.fiber === ctx.fiber);
+        return editor && entry ? { editor, entry } : undefined;
+    };
+    const capability = () => ctx.get('directoryPicker')?.capability();
+    return {
+        status() {
+            const kind = capability()?.kind;
+            const editable = !!editorEntry();
+            return { canChange: editable, canChangeNetwork: editable, picker: kind === 'native' || kind === 'browse' ? kind : null, allowProxyFakeIp: policy.allowProxyFakeIp === true };
+        },
+        async pick(signal) {
+            const picker = capability();
+            if (picker?.kind !== 'native')
+                throw new Error('当前环境不支持系统目录选择，请浏览目录或填写绝对路径');
+            if (picking)
+                throw new Error('目录选择窗口已打开');
+            picking = true;
+            try {
+                return await picker.pick(signal);
+            }
+            finally {
+                picking = false;
+            }
+        },
+        async list(path, signal) {
+            const picker = capability();
+            if (picker?.kind !== 'browse')
+                throw new Error('当前环境不支持目录浏览，请使用系统目录选择');
+            return picker.list(path, signal);
+        },
+        async change(root, expectedRoot) {
+            if (changing)
+                throw new Error('正在切换资料库，请稍候');
+            if (expectedRoot !== library.root)
+                throw new Error('资料库目录已改变，请刷新设置后重试');
+            if (!root.trim() || !isAbsolute(root) || (process.platform === 'win32' && !/^(?:[A-Za-z]:[\\/]|[\\/]{2}[^\\/]+[\\/]+[^\\/]+)/.test(root)))
+                throw new Error('请选择或填写完整的资料库绝对路径');
+            const next = resolve(root);
+            if (next === library.root)
+                return library.root;
+            const rel = relative(library.root, next);
+            const back = relative(next, library.root);
+            const inside = (value) => !!value && !isAbsolute(value) && value !== '..' && !value.startsWith(`..${sep}`);
+            if (inside(rel) || inside(back))
+                throw new Error('新旧资料库不能互相包含，请选择独立目录');
+            const target = editorEntry();
+            if (!target)
+                throw new Error('当前环境无法保存插件配置，请在 Harness 中修改资料库目录');
+            changing = true;
+            try {
+                // Check write access, the index and the single-writer lock before reloading.
+                const probe = new Library(next);
+                probe.close();
+                await target.editor.edit(target.entry, current => ({ ...current, root: next }));
+                return next;
+            }
+            finally {
+                changing = false;
+            }
+        },
+        async setProxyMode(enabled, expected, expectedRoot) {
+            if (changing)
+                throw new Error('正在保存资料库设置，请稍候');
+            if (expectedRoot !== library.root || expected !== (policy.allowProxyFakeIp === true))
+                throw new Error('资料库设置已改变，请重新打开设置后重试');
+            const target = editorEntry();
+            if (!target)
+                throw new Error('当前环境无法保存插件配置，请在 Harness 中修改采集设置');
+            if (enabled === expected)
+                return enabled;
+            changing = true;
+            try {
+                await target.editor.edit(target.entry, current => {
+                    if ((current.allowProxyFakeIp === true) !== expected)
+                        throw new Error('代理兼容设置已改变，请重新打开设置后重试');
+                    return { ...current, allowProxyFakeIp: enabled };
+                });
+                return enabled;
+            }
+            finally {
+                changing = false;
+            }
+        },
+    };
+}

package/dist/http.d.ts

@@ -1,6 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { Library } from './core/library.js';
 import type { ImportQueue } from './core/jobs.js';
+import type { DirectorySettings } from './directory-settings.js';
+import type { KnowledgeQueue } from './core/knowledge.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 createHandler(library: Library, queue: ImportQueue, getOrigin: () => string, directories?: DirectorySettings, knowledge?: KnowledgeQueue): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
 export declare function serveAsset(req: IncomingMessage, res: ServerResponse): void;

package/dist/http.js

@@ -31,7 +31,7 @@ function fields(data) {
     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) {
+export function createHandler(library, queue, getOrigin, directories, knowledge) {
     return async (req, res) => {
         try {
             const origin = getOrigin();
@@ -46,18 +46,46 @@ export function createHandler(library, queue, getOrigin) {
             const url = new URL(req.url || '/', origin);
             const path = url.pathname.slice(API_PATH.length);
             if (req.method === 'GET') {
+                if (path === '/settings') {
+                    send(res, 200, { root: library.root, ...(directories?.status() ?? { canChange: false, canChangeNetwork: false, picker: null, allowProxyFakeIp: false }) });
+                    return;
+                }
+                if (path === '/settings/images') {
+                    send(res, 200, queue.imageCapture ? await queue.imageCapture.status() : { supported: false, available: false, enabled: false, maxImages: 6, version: 0, reason: '请重启服务以启用网页图片识别' });
+                    return;
+                }
                 if (path === '/stats') {
                     send(res, 200, library.stats());
                     return;
                 }
+                if (path === '/trash') {
+                    send(res, 200, library.trashSnapshot());
+                    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 }));
+                    send(res, 200, library.search({ ...Object.fromEntries(url.searchParams), trashed: url.searchParams.get('trashed') === '1', limit: Number(url.searchParams.get('limit')) || 40, offset: Number(url.searchParams.get('offset')) || 0 }));
                     return;
                 }
                 if (path === '/jobs') {
                     send(res, 200, queue.list());
                     return;
                 }
+                if (path === '/knowledge') {
+                    send(res, 200, knowledge?.overview() ?? { supported: false, available: false, reason: '当前服务未启用知识整理，请重启升级后的资料库服务', jobs: [], states: {} });
+                    return;
+                }
+                const knowledgeJob = path.match(/^\/knowledge\/jobs\/(knowledge_[a-f0-9-]+)$/);
+                if (knowledgeJob && knowledge) {
+                    send(res, 200, knowledge.get(knowledgeJob[1]));
+                    return;
+                }
+                const pageImage = path.match(/^\/materials\/(r_[a-f0-9-]+)\/images\/(img_[a-f0-9-]+)$/);
+                if (pageImage) {
+                    const original = library.pageImageFile(pageImage[1], pageImage[2]);
+                    res.writeHead(200, { 'Content-Type': original.mediaType, 'X-Content-Type-Options': 'nosniff', 'Cache-Control': 'no-store', 'Content-Security-Policy': "default-src 'none'; sandbox" });
+                    res.end(original.bytes);
+                    return;
+                }
                 const match = path.match(/^\/materials\/(r_[a-f0-9-]+)(?:\/(export|original))?$/);
                 if (match) {
                     if (match[2] === 'export') {
@@ -71,16 +99,129 @@ export function createHandler(library, queue, getOrigin) {
                         res.end(original.bytes);
                         return;
                     }
-                    send(res, 200, library.get(match[1]));
+                    const item = library.get(match[1]);
+                    send(res, 200, { ...item, missingSources: item.citations.filter(c => !library.has(c.materialId)).map(c => c.materialId) });
                     return;
                 }
             }
-            if (req.method === 'POST' || req.method === 'PATCH') {
+            if (req.method === 'POST' || req.method === 'PATCH' || req.method === 'DELETE') {
                 if (req.headers['x-knowledge-library'] !== '1') {
                     send(res, 403, { error: '缺少同源请求标记' });
                     return;
                 }
                 const data = await body(req);
+                if (path === '/settings/images') {
+                    if (!queue.imageCapture)
+                        throw new Error('请重启服务以启用图片识别');
+                    send(res, 200, await queue.imageCapture.save(data.settings, data.version, data.expectedRoot, data.expectedModel, data.confirmed));
+                    return;
+                }
+                const imageRetry = path.match(/^\/materials\/(r_[a-f0-9-]+)\/images\/retry$/);
+                const imageCancel = path.match(/^\/jobs\/(job_[a-f0-9-]+)\/images\/cancel$/);
+                if (imageRetry || imageCancel) {
+                    if (req.method !== 'POST' || data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后操作');
+                    if (imageRetry) {
+                        if (data.confirmed !== true)
+                            throw new Error('请核对图片重试范围和模型费用');
+                        send(res, 202, await queue.retryImagesForMaterial(imageRetry[1], data.expectedModel, data.imageIds));
+                    }
+                    else
+                        send(res, 200, queue.cancelImages(imageCancel[1]));
+                    return;
+                }
+                if (path.startsWith('/knowledge/')) {
+                    if (!knowledge)
+                        throw new Error('当前服务未启用知识整理，请重启资料库服务');
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    if (path === '/knowledge/jobs' && req.method === 'POST') {
+                        send(res, 202, knowledge.add(data.sourceIds, data.topic, data.mode));
+                        return;
+                    }
+                    const job = path.match(/^\/knowledge\/jobs\/(knowledge_[a-f0-9-]+)(?:\/(cancel|discard|confirm|plan|confirm-plan|rollback-plan))?$/);
+                    if (job) {
+                        if (req.method === 'PATCH' && job[2] === 'plan') {
+                            send(res, 200, knowledge.editPlan(job[1], data.plan, data.version));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'confirm-plan') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认分组与分类修改后再生成草稿');
+                            send(res, 200, knowledge.confirmPlan(job[1], data.version, data.applyClassification, data.expectedModel));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'rollback-plan') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认回退未完成的分类修改');
+                            send(res, 200, knowledge.rollbackPlan(job[1]));
+                            return;
+                        }
+                        if (req.method === 'PATCH' && !job[2]) {
+                            send(res, 200, knowledge.edit(job[1], data.draft, data.version, data.integration));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'cancel') {
+                            send(res, 200, knowledge.cancel(job[1]));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'discard') {
+                            send(res, 200, knowledge.discard(job[1]));
+                            return;
+                        }
+                        if (req.method === 'POST' && job[2] === 'confirm') {
+                            if (data.confirmed !== true)
+                                throw new Error('请确认保存知识笔记');
+                            const current = knowledge.get(job[1]);
+                            if (current.integration?.choice && current.integration.choice !== 'new' && data.integrationChoice !== current.integration.choice)
+                                throw new Error('请核对增量处理方式后确认，旧版页面请刷新');
+                            send(res, 200, knowledge.confirm(job[1], data.version, data.category));
+                            return;
+                        }
+                    }
+                }
+                if (req.method === 'POST' && path === '/trash/empty') {
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    if (data.confirmed !== true || typeof data.token !== 'string')
+                        throw new Error('请先确认永久清空回收站');
+                    send(res, 200, library.emptyTrash(data.token));
+                    return;
+                }
+                if (req.method === 'POST' && ['/directory/pick', '/directory/list', '/settings/root', '/settings/network'].includes(path)) {
+                    if (!directories)
+                        throw new Error('请在 Harness 中修改资料库设置');
+                    if (path === '/settings/network') {
+                        if (typeof data.allowProxyFakeIp !== 'boolean' || typeof data.expected !== 'boolean' || typeof data.expectedRoot !== 'string')
+                            throw new Error('代理兼容设置必须是布尔值，并提供当前资料库目录');
+                        const allowProxyFakeIp = await directories.setProxyMode(data.allowProxyFakeIp, data.expected, data.expectedRoot);
+                        send(res, 200, { allowProxyFakeIp });
+                        return;
+                    }
+                    if (path === '/settings/root') {
+                        if (typeof data.root !== 'string' || typeof data.expectedRoot !== 'string')
+                            throw new Error('资料库目录必须是字符串');
+                        const root = await directories.change(data.root, data.expectedRoot);
+                        send(res, 200, { root });
+                        return;
+                    }
+                    const abort = new AbortController();
+                    const disconnected = () => abort.abort();
+                    res.once('close', disconnected);
+                    try {
+                        if (path === '/directory/pick')
+                            send(res, 200, { path: await directories.pick(abort.signal) });
+                        else {
+                            if (data.path !== undefined && typeof data.path !== 'string')
+                                throw new Error('目录路径必须是字符串');
+                            send(res, 200, await directories.list(data.path, abort.signal));
+                        }
+                    }
+                    finally {
+                        res.off('close', disconnected);
+                    }
+                    return;
+                }
                 if (req.method === 'POST' && path === '/capture') {
                     const captureFields = fields(data);
                     if (data.type === 'url' && typeof data.content === 'string') {
@@ -109,6 +250,13 @@ export function createHandler(library, queue, getOrigin) {
                     send(res, 200, library.update(match[1], fields(data)));
                     return;
                 }
+                const restore = path.match(/^\/materials\/(r_[a-f0-9-]+)\/restore$/);
+                if ((req.method === 'DELETE' && match) || (req.method === 'POST' && restore)) {
+                    if (data.expectedRoot !== library.root)
+                        throw new Error('资料库目录已改变，请刷新后再操作');
+                    send(res, 200, match ? library.trash(match[1]) : library.restore(restore[1]));
+                    return;
+                }
                 const retry = path.match(/^\/jobs\/(job_[a-f0-9-]+)\/retry$/);
                 if (req.method === 'POST' && retry) {
                     send(res, 200, queue.retry(retry[1]));

package/dist/index.js

@@ -5,7 +5,11 @@ 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';
+import { fetchPublicImage, fetchPublicPage } from './core/fetch.js';
+import { ImageCapture } from './core/image-capture.js';
+import { createDirectorySettings } from './directory-settings.js';
+import { KnowledgeQueue } from './core/knowledge.js';
+import { harnessKnowledgeModel } from './knowledge-model.js';
 export const name = 'knowledge-library';
 export const inject = ['tools'];
 export const Config = z.object({
@@ -15,21 +19,32 @@ export const Config = z.object({
 export function apply(ctx, config) {
     const library = new Library(config.root);
     let queue;
+    let knowledge;
+    const model = harnessKnowledgeModel(ctx);
     try {
-        queue = new ImportQueue(library, (url, signal) => fetchPublicPage(url, signal, { allowProxyFakeIp: config.allowProxyFakeIp }));
+        knowledge = new KnowledgeQueue(library, model);
     }
     catch (error) {
         library.close();
         throw error;
     }
-    ctx.effect(() => async () => { await queue.close(); library.close(); });
-    for (const tool of createTools(library, queue))
+    try {
+        const images = new ImageCapture(library, model, (url, signal, _policy, referer) => fetchPublicImage(url, signal, { allowProxyFakeIp: config.allowProxyFakeIp }, referer));
+        queue = new ImportQueue(library, (url, signal) => fetchPublicPage(url, signal, { allowProxyFakeIp: config.allowProxyFakeIp }), images);
+    }
+    catch (error) {
+        void knowledge.close();
+        library.close();
+        throw error;
+    }
+    ctx.effect(() => async () => { await Promise.all([queue.close(), knowledge.close()]); library.close(); });
+    for (const tool of createTools(library, queue, knowledge))
         ctx.tools.register(tool);
     ctx.inject(['webServer'], child => {
-        child.webServer.register({
+        child.effect(() => child.webServer.register({
             kind: 'prefix', path: API_PATH,
-            handler: createHandler(library, queue, () => child.webServer.getOrigin()),
-        });
+            handler: createHandler(library, queue, () => child.webServer.getOrigin(), createDirectorySettings(ctx, library, config), knowledge),
+        }));
     });
     ctx.logger.info(`资料库已加载：${library.root}`);
 }

package/dist/knowledge-model.d.ts

@@ -0,0 +1,30 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { ImageMediaType } from '@deepseek-ai/dsh-attachment';
+export interface ModelRequest {
+    system: string;
+    prompt: string;
+    signal: AbortSignal;
+    expectedModel?: string;
+    images?: Array<{
+        data: Uint8Array;
+        mediaType: ImageMediaType;
+        name?: string;
+    }>;
+}
+export interface VisionStatus {
+    available: boolean;
+    model?: string;
+    reason?: string;
+}
+export interface KnowledgeModel {
+    status(): {
+        available: boolean;
+        model?: string;
+        reason?: string;
+    };
+    generate(request: ModelRequest): Promise<string>;
+    visionStatus?(): Promise<VisionStatus>;
+}
+export declare function harnessKnowledgeModel(ctx: Context): KnowledgeModel;
+/** Preview credentials stay on the server and are never returned through HTTP. */
+export declare function previewKnowledgeModel(env?: NodeJS.ProcessEnv): KnowledgeModel;