mnote-mcp 1.0.1

package/dist/api-client.d.ts

@@ -0,0 +1,101 @@
+export interface NowenApiConfig {
+    baseUrl: string;
+    username?: string;
+    password?: string;
+    token?: string;
+}
+export declare class NowenApiClient {
+    private baseUrl;
+    private username;
+    private password;
+    private token;
+    private readonly isApiToken;
+    constructor(config: NowenApiConfig);
+    private login;
+    private ensureAuth;
+    private get authHeader();
+    private request;
+    listNotebooks(): Promise<any[]>;
+    createNotebook(params: {
+        name: string;
+        parentId?: string;
+        icon?: string;
+        color?: string;
+    }): Promise<any>;
+    updateNotebook(id: string, params: {
+        name?: string;
+        icon?: string;
+        color?: string;
+        parentId?: string;
+    }): Promise<any>;
+    deleteNotebook(id: string): Promise<any>;
+    listNotes(params?: {
+        notebookId?: string;
+        isFavorite?: string;
+        isTrashed?: string;
+        tagId?: string;
+        search?: string;
+        dateFrom?: string;
+        dateTo?: string;
+    }): Promise<any[]>;
+    getNote(id: string): Promise<any>;
+    createNote(params: {
+        notebookId: string;
+        title?: string;
+        content?: string;
+        contentText?: string;
+    }): Promise<any>;
+    updateNote(id: string, params: {
+        title?: string;
+        content?: string;
+        contentText?: string;
+        notebookId?: string;
+        isPinned?: number;
+        isFavorite?: number;
+        isLocked?: number;
+        isTrashed?: number;
+        version?: number;
+    }): Promise<any>;
+    deleteNote(id: string): Promise<any>;
+    listTags(): Promise<any[]>;
+    createTag(params: {
+        name: string;
+        color?: string;
+    }): Promise<any>;
+    addTagToNote(noteId: string, tagId: string): Promise<any>;
+    removeTagFromNote(noteId: string, tagId: string): Promise<any>;
+    search(q: string): Promise<any[]>;
+    askKnowledge(question: string): Promise<{
+        answer: string;
+        references: {
+            id: string;
+            title: string;
+        }[];
+    }>;
+    aiChat(params: {
+        action: string;
+        text: string;
+        context?: string;
+        customPrompt?: string;
+    }): Promise<string>;
+    knowledgeStats(): Promise<any>;
+    listPlugins(): Promise<any[]>;
+    executePlugin(name: string, params: Record<string, any>): Promise<any>;
+    listWebhooks(): Promise<any[]>;
+    createWebhook(params: {
+        url: string;
+        events?: string[];
+        description?: string;
+    }): Promise<any>;
+    queryAuditLogs(params?: Record<string, string>): Promise<any>;
+    getAuditStats(): Promise<any>;
+    listBackups(): Promise<any[]>;
+    createBackup(type?: string): Promise<any>;
+    listApiTokens(): Promise<any>;
+    createApiToken(params: {
+        name: string;
+        scopes?: string[];
+        expiresInDays?: number;
+    }): Promise<any>;
+    deleteApiToken(id: string): Promise<any>;
+}

package/dist/api-client.js

@@ -0,0 +1,234 @@
+export class NowenApiClient {
+    baseUrl;
+    username;
+    password;
+    token = null;
+    isApiToken;
+    constructor(config) {
+        this.baseUrl = config.baseUrl.replace(/\/+$/, "");
+        this.username = config.username || "";
+        this.password = config.password || "";
+        this.isApiToken = !!config.token;
+        if (config.token) {
+            this.token = config.token;
+        }
+    }
+    async login() {
+        const res = await fetch(`${this.baseUrl}/api/auth/login`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ username: this.username, password: this.password }),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`登录失败 (${res.status}): ${err}`);
+        }
+        const data = await res.json();
+        this.token = data.token;
+    }
+    async ensureAuth() {
+        if (!this.token) {
+            if (this.isApiToken) {
+                throw new Error("API Token 未设置，请检查 NOWEN_TOKEN 环境变量");
+            }
+            await this.login();
+        }
+    }
+    get authHeader() {
+        return `Bearer ${this.token}`;
+    }
+    async request(path, options = {}) {
+        await this.ensureAuth();
+        let url = `${this.baseUrl}${path}`;
+        if (options.query) {
+            const params = new URLSearchParams();
+            for (const [k, v] of Object.entries(options.query)) {
+                if (v !== undefined && v !== null && v !== "") {
+                    params.set(k, v);
+                }
+            }
+            const qs = params.toString();
+            if (qs)
+                url += `?${qs}`;
+        }
+        const headers = {
+            "Authorization": this.authHeader,
+        };
+        if (options.body) {
+            headers["Content-Type"] = "application/json";
+        }
+        const res = await fetch(url, {
+            method: options.method || "GET",
+            headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        if (res.status === 401 && !this.isApiToken) {
+            this.token = null;
+            await this.login();
+            headers["Authorization"] = this.authHeader;
+            const retryRes = await fetch(url, {
+                method: options.method || "GET",
+                headers,
+                body: options.body ? JSON.stringify(options.body) : undefined,
+            });
+            if (!retryRes.ok) {
+                const err = await retryRes.text();
+                throw new Error(`API 请求失败 (${retryRes.status}): ${err}`);
+            }
+            return retryRes.json();
+        }
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`API 请求失败 (${res.status}): ${err}`);
+        }
+        return res.json();
+    }
+    async listNotebooks() {
+        return this.request("/api/notebooks");
+    }
+    async createNotebook(params) {
+        return this.request("/api/notebooks", { method: "POST", body: params });
+    }
+    async updateNotebook(id, params) {
+        return this.request(`/api/notebooks/${id}`, { method: "PUT", body: params });
+    }
+    async deleteNotebook(id) {
+        return this.request(`/api/notebooks/${id}`, { method: "DELETE" });
+    }
+    async listNotes(params) {
+        return this.request("/api/notes", { query: params });
+    }
+    async getNote(id) {
+        return this.request(`/api/notes/${id}`);
+    }
+    async createNote(params) {
+        return this.request("/api/notes", { method: "POST", body: params });
+    }
+    async updateNote(id, params) {
+        return this.request(`/api/notes/${id}`, { method: "PUT", body: params });
+    }
+    async deleteNote(id) {
+        return this.request(`/api/notes/${id}`, { method: "DELETE" });
+    }
+    async listTags() {
+        return this.request("/api/tags");
+    }
+    async createTag(params) {
+        return this.request("/api/tags", { method: "POST", body: params });
+    }
+    async addTagToNote(noteId, tagId) {
+        return this.request(`/api/tags/note/${noteId}/tag/${tagId}`, { method: "POST" });
+    }
+    async removeTagFromNote(noteId, tagId) {
+        return this.request(`/api/tags/note/${noteId}/tag/${tagId}`, { method: "DELETE" });
+    }
+    async search(q) {
+        return this.request("/api/search", { query: { q } });
+    }
+    async askKnowledge(question) {
+        await this.ensureAuth();
+        const res = await fetch(`${this.baseUrl}/api/ai/ask`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": this.authHeader,
+            },
+            body: JSON.stringify({ question }),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`AI 请求失败 (${res.status}): ${err}`);
+        }
+        const text = await res.text();
+        const lines = text.split("\n");
+        let answer = "";
+        let references = [];
+        for (const line of lines) {
+            if (line.startsWith("event: references")) {
+                continue;
+            }
+            if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                if (data === "[DONE]")
+                    break;
+                try {
+                    const parsed = JSON.parse(data);
+                    if (Array.isArray(parsed) && parsed[0]?.id && parsed[0]?.title) {
+                        references = parsed;
+                        continue;
+                    }
+                }
+                catch {
+                }
+                answer += data;
+            }
+        }
+        return { answer, references };
+    }
+    async aiChat(params) {
+        await this.ensureAuth();
+        const res = await fetch(`${this.baseUrl}/api/ai/chat`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": this.authHeader,
+            },
+            body: JSON.stringify(params),
+        });
+        if (!res.ok) {
+            const err = await res.text();
+            throw new Error(`AI 请求失败 (${res.status}): ${err}`);
+        }
+        const text = await res.text();
+        const lines = text.split("\n");
+        let result = "";
+        for (const line of lines) {
+            if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                if (data === "[DONE]")
+                    break;
+                result += data;
+            }
+        }
+        return result;
+    }
+    async knowledgeStats() {
+        return this.request("/api/ai/knowledge-stats");
+    }
+    async listPlugins() {
+        return this.request("/api/plugins");
+    }
+    async executePlugin(name, params) {
+        return this.request("/api/plugins/" + name + "/execute", {
+            method: "POST",
+            body: params,
+        });
+    }
+    async listWebhooks() {
+        return this.request("/api/webhooks");
+    }
+    async createWebhook(params) {
+        return this.request("/api/webhooks", { method: "POST", body: params });
+    }
+    async queryAuditLogs(params) {
+        return this.request("/api/audit", { query: params });
+    }
+    async getAuditStats() {
+        return this.request("/api/audit/stats");
+    }
+    async listBackups() {
+        return this.request("/api/backups");
+    }
+    async createBackup(type = "db-only") {
+        return this.request("/api/backups", { method: "POST", body: { type } });
+    }
+    async listApiTokens() {
+        return this.request("/api/tokens");
+    }
+    async createApiToken(params) {
+        return this.request("/api/tokens", { method: "POST", body: params });
+    }
+    async deleteApiToken(id) {
+        return this.request(`/api/tokens/${id}`, { method: "DELETE" });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Nowen Note MCP Server
+ *
+ * 让 Codex CLI / Claude Desktop / Cursor 等 AI 工具直接操作 Nowen Note 笔记系统。
+ *
+ * 环境变量：
+ *   NOWEN_URL      — Nowen Note 后端地址（默认 http://localhost:3001）
+ *   NOWEN_USERNAME — 登录用户名（默认 admin）
+ *   NOWEN_PASSWORD — 登录密码（默认 admin123）
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,491 @@
+#!/usr/bin/env node
+/**
+ * Nowen Note MCP Server
+ *
+ * 让 Codex CLI / Claude Desktop / Cursor 等 AI 工具直接操作 Nowen Note 笔记系统。
+ *
+ * 环境变量：
+ *   NOWEN_URL      — Nowen Note 后端地址（默认 http://localhost:3001）
+ *   NOWEN_USERNAME — 登录用户名（默认 admin）
+ *   NOWEN_PASSWORD — 登录密码（默认 admin123）
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { NowenApiClient } from "./api-client.js";
+// ===== 从环境变量读取配置 =====
+const config = {
+    baseUrl: process.env.NOWEN_URL || "http://localhost:3001",
+};
+// NOWEN_TOKEN 优先，其次 USERNAME/PASSWORD
+if (process.env.NOWEN_TOKEN) {
+    config.token = process.env.NOWEN_TOKEN;
+}
+else {
+    config.username = process.env.NOWEN_USERNAME || "admin";
+    config.password = process.env.NOWEN_PASSWORD || "admin123";
+}
+const api = new NowenApiClient(config);
+// ===== 创建 MCP Server =====
+const server = new McpServer({
+    name: "nowen-note",
+    version: "1.0.0",
+});
+// ==================== 笔记本工具 ====================
+server.tool("nowen_list_notebooks", "获取 Nowen Note 中的所有笔记本列表（支持树形结构），返回每个笔记本的 id、名称、图标、颜色和笔记数量", {}, async () => {
+    try {
+        const notebooks = await api.listNotebooks();
+        const summary = notebooks.map((nb) => ({
+            id: nb.id,
+            name: nb.name,
+            icon: nb.icon,
+            color: nb.color,
+            parentId: nb.parentId,
+            noteCount: nb.noteCount,
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_create_notebook", "在 Nowen Note 中创建一个新笔记本", {
+    name: z.string().describe("笔记本名称"),
+    parentId: z.string().optional().describe("父笔记本 ID（可选，创建子笔记本时使用）"),
+    icon: z.string().optional().describe("笔记本图标 emoji（默认 📒）"),
+}, async ({ name, parentId, icon }) => {
+    try {
+        const notebook = await api.createNotebook({ name, parentId, icon });
+        return {
+            content: [{ type: "text", text: `笔记本创建成功:\n${JSON.stringify(notebook, null, 2)}` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 笔记工具 ====================
+server.tool("nowen_list_notes", "获取 Nowen Note 中的笔记列表。可按笔记本、标签、收藏状态、日期范围等筛选。返回笔记概要（不含完整内容）", {
+    notebookId: z.string().optional().describe("按笔记本 ID 筛选"),
+    tagId: z.string().optional().describe("按标签 ID 筛选"),
+    isFavorite: z.boolean().optional().describe("是否只返回收藏笔记"),
+    isTrashed: z.boolean().optional().describe("是否只返回回收站笔记"),
+    search: z.string().optional().describe("全文搜索关键词"),
+    dateFrom: z.string().optional().describe("开始日期 YYYY-MM-DD"),
+    dateTo: z.string().optional().describe("结束日期 YYYY-MM-DD"),
+}, async ({ notebookId, tagId, isFavorite, isTrashed, search, dateFrom, dateTo }) => {
+    try {
+        const query = {};
+        if (notebookId)
+            query.notebookId = notebookId;
+        if (tagId)
+            query.tagId = tagId;
+        if (isFavorite)
+            query.isFavorite = "1";
+        if (isTrashed)
+            query.isTrashed = "1";
+        if (search)
+            query.search = search;
+        if (dateFrom)
+            query.dateFrom = dateFrom;
+        if (dateTo)
+            query.dateTo = dateTo;
+        const notes = await api.listNotes(query);
+        const summary = notes.map((n) => ({
+            id: n.id,
+            title: n.title,
+            notebookId: n.notebookId,
+            isPinned: n.isPinned,
+            isFavorite: n.isFavorite,
+            isLocked: n.isLocked,
+            updatedAt: n.updatedAt,
+            contentPreview: n.contentText?.slice(0, 100),
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_read_note", "读取 Nowen Note 中指定笔记的完整内容（包括标题、正文、标签等全部信息）", {
+    noteId: z.string().describe("笔记 ID"),
+}, async ({ noteId }) => {
+    try {
+        const note = await api.getNote(noteId);
+        // 提取纯文本内容供 AI 阅读
+        const result = {
+            id: note.id,
+            title: note.title,
+            notebookId: note.notebookId,
+            contentText: note.contentText,
+            isPinned: note.isPinned,
+            isFavorite: note.isFavorite,
+            isLocked: note.isLocked,
+            version: note.version,
+            tags: note.tags?.map((t) => ({ id: t.id, name: t.name })),
+            createdAt: note.createdAt,
+            updatedAt: note.updatedAt,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_create_note", "在 Nowen Note 中创建一篇新笔记。需要指定目标笔记本 ID", {
+    notebookId: z.string().describe("目标笔记本 ID"),
+    title: z.string().optional().describe("笔记标题(默认为'无标题笔记')"),
+    content: z.string().optional().describe("笔记内容（Markdown 纯文本）"),
+}, async ({ notebookId, title, content }) => {
+    try {
+        const body = { notebookId };
+        if (title)
+            body.title = title;
+        if (content) {
+            // 将纯文本包装为 TipTap JSON 格式
+            body.content = JSON.stringify({
+                type: "doc",
+                content: [{ type: "paragraph", content: [{ type: "text", text: content }] }],
+            });
+            body.contentText = content;
+        }
+        const note = await api.createNote(body);
+        return {
+            content: [{ type: "text", text: `笔记创建成功:\n${JSON.stringify({ id: note.id, title: note.title }, null, 2)}` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_update_note", "更新 Nowen Note 中已有笔记的标题或内容", {
+    noteId: z.string().describe("笔记 ID"),
+    title: z.string().optional().describe("新标题"),
+    content: z.string().optional().describe("新内容（Markdown 纯文本）"),
+}, async ({ noteId, title, content }) => {
+    try {
+        const body = {};
+        if (title)
+            body.title = title;
+        if (content) {
+            body.content = JSON.stringify({
+                type: "doc",
+                content: [{ type: "paragraph", content: [{ type: "text", text: content }] }],
+            });
+            body.contentText = content;
+        }
+        const note = await api.updateNote(noteId, body);
+        return {
+            content: [{ type: "text", text: `笔记更新成功:\n${JSON.stringify({ id: note.id, title: note.title, version: note.version }, null, 2)}` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_delete_note", "将 Nowen Note 中指定笔记移入回收站（软删除），或从回收站永久删除", {
+    noteId: z.string().describe("笔记 ID"),
+    permanent: z.boolean().optional().describe("是否永久删除（默认 false，仅移入回收站）"),
+}, async ({ noteId, permanent }) => {
+    try {
+        if (permanent) {
+            await api.deleteNote(noteId);
+            return { content: [{ type: "text", text: `笔记已永久删除: ${noteId}` }] };
+        }
+        else {
+            await api.updateNote(noteId, { isTrashed: 1 });
+            return { content: [{ type: "text", text: `笔记已移入回收站: ${noteId}` }] };
+        }
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 搜索工具 ====================
+server.tool("nowen_search", "在 Nowen Note 中全文搜索笔记。使用 FTS5 全文索引，支持模糊匹配，返回匹配的笔记摘要和高亮片段", {
+    query: z.string().describe("搜索关键词"),
+}, async ({ query }) => {
+    try {
+        const results = await api.search(query);
+        const summary = results.map((r) => ({
+            id: r.id,
+            title: r.title,
+            snippet: r.snippet,
+            notebookId: r.notebookId,
+            updatedAt: r.updatedAt,
+        }));
+        return {
+            content: [{ type: "text", text: `找到 ${results.length} 条结果:\n${JSON.stringify(summary, null, 2)}` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 标签工具 ====================
+server.tool("nowen_list_tags", "获取 Nowen Note 中的所有标签列表，包含每个标签的颜色和关联笔记数", {}, async () => {
+    try {
+        const tags = await api.listTags();
+        const summary = tags.map((t) => ({
+            id: t.id,
+            name: t.name,
+            color: t.color,
+            noteCount: t.noteCount,
+        }));
+        return {
+            content: [{ type: "text", text: JSON.stringify(summary, null, 2) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_manage_tags", "管理 Nowen Note 中笔记的标签：创建标签、给笔记添加标签、或移除笔记标签", {
+    action: z.enum(["create", "add_to_note", "remove_from_note"]).describe("操作类型: create=创建标签, add_to_note=给笔记添加标签, remove_from_note=移除笔记标签"),
+    tagName: z.string().optional().describe("标签名称（创建时必填）"),
+    tagColor: z.string().optional().describe("标签颜色（创建时可选，默认蓝色）"),
+    tagId: z.string().optional().describe("标签 ID（添加/移除时必填）"),
+    noteId: z.string().optional().describe("笔记 ID（添加/移除时必填）"),
+}, async ({ action, tagName, tagColor, tagId, noteId }) => {
+    try {
+        switch (action) {
+            case "create": {
+                if (!tagName)
+                    throw new Error("创建标签时 tagName 必填");
+                const tag = await api.createTag({ name: tagName, color: tagColor });
+                return { content: [{ type: "text", text: `标签创建成功:\n${JSON.stringify(tag, null, 2)}` }] };
+            }
+            case "add_to_note": {
+                if (!noteId || !tagId)
+                    throw new Error("添加标签时 noteId 和 tagId 必填");
+                await api.addTagToNote(noteId, tagId);
+                return { content: [{ type: "text", text: `已为笔记 ${noteId} 添加标签 ${tagId}` }] };
+            }
+            case "remove_from_note": {
+                if (!noteId || !tagId)
+                    throw new Error("移除标签时 noteId 和 tagId 必填");
+                await api.removeTagFromNote(noteId, tagId);
+                return { content: [{ type: "text", text: `已移除笔记 ${noteId} 的标签 ${tagId}` }] };
+            }
+        }
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== AI 工具 ====================
+server.tool("nowen_ai_ask", "向 Nowen Note 知识库提问。系统会自动检索相关笔记内容，结合 AI 生成回答，并标注信息来源", {
+    question: z.string().describe("要提问的问题"),
+}, async ({ question }) => {
+    try {
+        const { answer, references } = await api.askKnowledge(question);
+        let text = answer;
+        if (references.length > 0) {
+            text += "\n\n📌 参考笔记:\n";
+            text += references.map((r, i) => `  ${i + 1}. [${r.title}] (id: ${r.id})`).join("\n");
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_ai_process", "使用 AI 处理笔记文本。支持续写、改写、润色、精简、扩展、翻译、摘要、解释、纠错、格式化等操作", {
+    action: z.enum([
+        "continue", "rewrite", "polish", "shorten", "expand",
+        "translate_en", "translate_zh", "summarize", "explain",
+        "fix_grammar", "format_markdown", "format_code", "custom",
+    ]).describe("处理类型"),
+    text: z.string().describe("要处理的文本内容"),
+    customPrompt: z.string().optional().describe("自定义指令（action 为 custom 时必填）"),
+}, async ({ action, text, customPrompt }) => {
+    try {
+        const result = await api.aiChat({ action, text, customPrompt });
+        return { content: [{ type: "text", text: result }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_knowledge_stats", "获取 Nowen Note 知识库的统计信息，包括笔记数、笔记本数、标签数、FTS 索引状态等", {}, async () => {
+    try {
+        const stats = await api.knowledgeStats();
+        return {
+            content: [{ type: "text", text: JSON.stringify(stats, null, 2) }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 插件工具 ====================
+server.tool("nowen_list_plugins", "获取 Nowen Note 中已加载的插件列表，每个插件声明了它支持的能力（action）", {}, async () => {
+    try {
+        const plugins = await api.listPlugins();
+        return { content: [{ type: "text", text: JSON.stringify(plugins, null, 2) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_execute_plugin", "执行 Nowen Note 中指定名称的插件，传入参数并获取处理结果", {
+    pluginName: z.string().describe("插件名称"),
+    params: z.record(z.string(), z.any()).describe("传给插件的参数对象"),
+}, async ({ pluginName, params }) => {
+    try {
+        const result = await api.executePlugin(pluginName, params);
+        if (result.text) {
+            return { content: [{ type: "text", text: result.text }] };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== Webhook 工具 ====================
+server.tool("nowen_list_webhooks", "获取 Nowen Note 中已配置的 Webhook 列表", {}, async () => {
+    try {
+        const webhooks = await api.listWebhooks();
+        return { content: [{ type: "text", text: JSON.stringify(webhooks, null, 2) }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_create_webhook", "在 Nowen Note 中创建新的 Webhook，当指定事件发生时自动推送 HTTP 通知", {
+    url: z.string().describe("Webhook 回调 URL"),
+    events: z.array(z.string()).optional().describe("监听的事件列表，如 ['note.created', 'note.updated']，默认为 ['*'] 接收所有"),
+    description: z.string().optional().describe("描述"),
+}, async ({ url, events, description }) => {
+    try {
+        const webhook = await api.createWebhook({ url, events, description });
+        return { content: [{ type: "text", text: `Webhook 创建成功!\nID: ${webhook.id}\nSecret: ${webhook.secret}\n\n请妥善保存 Secret，后续不会再显示。` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 审计日志工具 ====================
+server.tool("nowen_audit_stats", "获取 Nowen Note 的操作审计统计（按分类、级别统计，以及最近操作记录）", {}, async () => {
+    try {
+        const stats = await api.getAuditStats();
+        let text = `📊 审计统计\n总记录: ${stats.total} | 今日: ${stats.todayCount}\n\n`;
+        text += `按分类:\n`;
+        for (const c of stats.byCategory || []) {
+            text += `  ${c.category}: ${c.count}\n`;
+        }
+        text += `\n最近操作:\n`;
+        for (const r of (stats.recent || []).slice(0, 5)) {
+            text += `  [${r.level}] ${r.category}.${r.action} — ${r.createdAt}\n`;
+        }
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 备份工具 ====================
+server.tool("nowen_list_backups", "获取 Nowen Note 的数据备份列表", {}, async () => {
+    try {
+        const backups = await api.listBackups();
+        if (backups.length === 0) {
+            return { content: [{ type: "text", text: "暂无备份" }] };
+        }
+        const text = backups.map(b => `📦 ${b.filename}\n   大小: ${(b.size / 1024).toFixed(1)}KB | 类型: ${b.type} | 笔记: ${b.noteCount} | 时间: ${b.createdAt}`).join("\n\n");
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_create_backup", "创建 Nowen Note 数据备份。db-only 仅备份数据库，full 备份所有数据", {
+    type: z.enum(["db-only", "full"]).optional().describe("备份类型，默认 db-only"),
+}, async ({ type }) => {
+    try {
+        const backup = await api.createBackup(type || "db-only");
+        return { content: [{ type: "text", text: `✅ 备份创建成功!\n文件: ${backup.filename}\n大小: ${(backup.size / 1024).toFixed(1)}KB\n笔记: ${backup.noteCount} 篇\n校验: ${backup.checksum}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== API Token 管理 ====================
+server.tool("nowen_list_api_tokens", "列出当前用户的所有 API Token（不返回明文），包含可用 scope 列表", {}, async () => {
+    try {
+        const data = await api.listApiTokens();
+        const lines = data.tokens.map((t) => `${t.revokedAt ? "❌ [已吊销]" : "✅ [活跃]"} ${t.name} (${t.id.slice(0, 8)}...)\n   scope: ${t.scopes?.join(", ") || "全部"} | 过期: ${t.expiresAt || "永不过期"} | 最近使用: ${t.lastUsedAt || "从未"}`);
+        const text = [`可用 scope: ${data.availableScopes?.join(", ") || "全部"}`, "", ...lines].join("\n");
+        return { content: [{ type: "text", text }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_create_api_token", "创建一个新的长期 API Token（nkn_xxx 格式）。注意：明文只返回一次，请妥善保存。\n创建需要登录 JWT 凭证，不能用 API Token 创建 API Token", {
+    name: z.string().describe("Token 名称，例如 'claude-mcp'"),
+    scopes: z.array(z.string()).optional().describe("scope 列表，空数组或留空表示全部权限。可选值: notes:read, notes:write, notebooks:read, notebooks:write, attachments:write, tags:read, tags:write, export:import"),
+    expiresInDays: z.number().optional().describe("过期天数，不传则永不过期。推荐: 30/90/365"),
+}, async ({ name, scopes, expiresInDays }) => {
+    try {
+        const result = await api.createApiToken({ name, scopes, expiresInDays });
+        return {
+            content: [{ type: "text", text: `✅ API Token 创建成功!
+  名称: ${result.name}
+  明文: ${result.token}
+  scope: ${result.scopes?.join(", ") || "全部"}
+  过期: ${result.expiresAt || "永不过期"}
+
+⚠️  该 token 只会显示这一次，请立即保存！
+    设置环境变量: NOWEN_TOKEN=${result.token}` }],
+        };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+server.tool("nowen_delete_api_token", "吊销指定 ID 的 API Token，吊销后不可恢复", {
+    tokenId: z.string().describe("要吊销的 Token ID（可用 nowen_list_api_tokens 查看）"),
+}, async ({ tokenId }) => {
+    try {
+        await api.deleteApiToken(tokenId);
+        return { content: [{ type: "text", text: `✅ Token 已吊销: ${tokenId}` }] };
+    }
+    catch (err) {
+        return { content: [{ type: "text", text: `错误: ${err.message}` }], isError: true };
+    }
+});
+// ==================== 资源：笔记本列表 ====================
+server.resource("notebooks", "nowen://notebooks", async (uri) => {
+    const notebooks = await api.listNotebooks();
+    return {
+        contents: [{
+                uri: uri.href,
+                mimeType: "application/json",
+                text: JSON.stringify(notebooks, null, 2),
+            }],
+    };
+});
+// ==================== 启动 ====================
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`🚀 Nowen Note MCP Server 已启动`);
+    console.error(`   连接目标: ${config.baseUrl}`);
+    if (config.token) {
+        console.error(`   认证方式: NOWEN_TOKEN (静态 Token)`);
+    }
+    else {
+        console.error(`   用户: ${config.username}`);
+    }
+}
+main().catch((err) => {
+    console.error("MCP Server 启动失败:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "mnote-mcp",
+  "version": "1.0.1",
+  "description": "mnote MCP Server — 让 AI 工具直接操作笔记系统",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "mnote-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "tsx": "latest",
+    "typescript": "latest"
+  }
+}