@leeoohoo/ui-apps-devkit 0.1.0

package/templates/notepad/plugin/apps/app/layers.mjs

@@ -0,0 +1,338 @@
+function noop() {}
+
+function safeSetStatus(setStatus, text) {
+  if (typeof setStatus !== 'function') return;
+  try {
+    setStatus(String(text || ''), 'bad');
+  } catch {
+    // ignore
+  }
+}
+
+export function createNotepadLayerManager({ getDisposed, setStatus } = {}) {
+  const isDisposed = typeof getDisposed === 'function' ? getDisposed : () => false;
+
+  let activeLayer = null;
+
+  const closeActiveLayer = () => {
+    const layer = activeLayer;
+    activeLayer = null;
+    if (!layer) return;
+    try {
+      layer.dispose?.();
+    } catch {
+      // ignore
+    }
+  };
+
+  const showMenu = (x, y, items = []) => {
+    if (isDisposed()) return;
+    closeActiveLayer();
+
+    const overlay = document.createElement('div');
+    overlay.className = 'np-menu-overlay';
+
+    const menu = document.createElement('div');
+    menu.className = 'np-menu';
+
+    const close = () => {
+      try {
+        document.removeEventListener('keydown', onKeyDown, true);
+      } catch {
+        // ignore
+      }
+      try {
+        overlay.remove();
+      } catch {
+        // ignore
+      }
+      if (activeLayer?.overlay === overlay) activeLayer = null;
+    };
+
+    const onKeyDown = (ev) => {
+      if (ev?.key !== 'Escape') return;
+      try {
+        ev.preventDefault();
+      } catch {
+        // ignore
+      }
+      close();
+    };
+
+    overlay.addEventListener('mousedown', (ev) => {
+      if (ev?.target !== overlay) return;
+      close();
+    });
+    overlay.addEventListener('contextmenu', (ev) => {
+      try {
+        ev.preventDefault();
+      } catch {
+        // ignore
+      }
+      close();
+    });
+
+    (Array.isArray(items) ? items : []).forEach((item) => {
+      const label = typeof item?.label === 'string' ? item.label : '';
+      if (!label) return;
+      const btn = document.createElement('button');
+      btn.type = 'button';
+      btn.className = 'np-menu-item';
+      btn.textContent = label;
+      btn.disabled = item?.disabled === true;
+      btn.dataset.danger = item?.danger === true ? '1' : '0';
+      btn.addEventListener('click', async () => {
+        if (btn.disabled) return;
+        close();
+        try {
+          await item?.onClick?.();
+        } catch (err) {
+          safeSetStatus(setStatus, `Notes: ${err?.message || String(err)}`);
+        }
+      });
+      menu.appendChild(btn);
+    });
+
+    overlay.appendChild(menu);
+    document.body.appendChild(overlay);
+    document.addEventListener('keydown', onKeyDown, true);
+
+    menu.style.left = `${Math.max(0, Math.floor(x))}px`;
+    menu.style.top = `${Math.max(0, Math.floor(y))}px`;
+    try {
+      const rect = menu.getBoundingClientRect();
+      const margin = 8;
+      let left = Math.floor(x);
+      let top = Math.floor(y);
+      if (left + rect.width + margin > window.innerWidth) left = Math.max(margin, window.innerWidth - rect.width - margin);
+      if (top + rect.height + margin > window.innerHeight) top = Math.max(margin, window.innerHeight - rect.height - margin);
+      menu.style.left = `${left}px`;
+      menu.style.top = `${top}px`;
+    } catch {
+      // ignore
+    }
+
+    activeLayer = { overlay, dispose: close };
+  };
+
+  const showDialog = ({
+    title,
+    description = '',
+    fields = [],
+    confirmText = '确定',
+    cancelText = '取消',
+    danger = false,
+  } = {}) =>
+    new Promise((resolve) => {
+      if (isDisposed()) return resolve(null);
+      closeActiveLayer();
+
+      const overlay = document.createElement('div');
+      overlay.className = 'np-modal-overlay';
+      const modal = document.createElement('div');
+      modal.className = 'np-modal';
+
+      const header = document.createElement('div');
+      header.className = 'np-modal-header';
+      header.textContent = typeof title === 'string' && title.trim() ? title.trim() : '提示';
+
+      const body = document.createElement('div');
+      body.className = 'np-modal-body';
+
+      const desc = document.createElement('div');
+      desc.className = 'np-modal-desc';
+      desc.textContent = typeof description === 'string' ? description : '';
+      if (desc.textContent.trim()) {
+        body.appendChild(desc);
+      }
+
+      const errorEl = document.createElement('div');
+      errorEl.className = 'np-modal-error';
+      errorEl.textContent = '';
+
+      const inputs = [];
+      (Array.isArray(fields) ? fields : []).forEach((field) => {
+        if (!field || typeof field !== 'object') return;
+        const name = typeof field.name === 'string' ? field.name.trim() : '';
+        if (!name) return;
+        const row = document.createElement('div');
+        row.className = 'np-modal-field';
+
+        const label = document.createElement('div');
+        label.className = 'np-modal-label';
+        label.textContent = typeof field.label === 'string' ? field.label : name;
+        row.appendChild(label);
+
+        let control = null;
+        const kind = field.kind === 'select' ? 'select' : 'text';
+        if (kind === 'select') {
+          const select = document.createElement('select');
+          select.className = 'np-select';
+          const options = Array.isArray(field.options) ? field.options : [];
+          options.forEach((opt) => {
+            const value = typeof opt?.value === 'string' ? opt.value : '';
+            const labelText = typeof opt?.label === 'string' ? opt.label : value;
+            const option = document.createElement('option');
+            option.value = value;
+            option.textContent = labelText || value || '（空）';
+            select.appendChild(option);
+          });
+          select.value = typeof field.value === 'string' ? field.value : '';
+          control = select;
+        } else {
+          const input = document.createElement('input');
+          input.className = 'np-input';
+          input.type = 'text';
+          input.placeholder = typeof field.placeholder === 'string' ? field.placeholder : '';
+          input.value = typeof field.value === 'string' ? field.value : '';
+          control = input;
+        }
+
+        row.appendChild(control);
+        body.appendChild(row);
+        inputs.push({
+          name,
+          required: field.required === true,
+          control,
+          label: typeof field.label === 'string' ? field.label : name,
+        });
+      });
+
+      if (inputs.length > 0) {
+        body.appendChild(errorEl);
+      }
+
+      const actions = document.createElement('div');
+      actions.className = 'np-modal-actions';
+
+      const btnCancel = document.createElement('button');
+      btnCancel.type = 'button';
+      btnCancel.className = 'np-btn';
+      btnCancel.textContent = cancelText || '取消';
+
+      const btnOk = document.createElement('button');
+      btnOk.type = 'button';
+      btnOk.className = 'np-btn';
+      btnOk.textContent = confirmText || '确定';
+      btnOk.dataset.variant = danger ? 'danger' : '';
+
+      const cleanup = () => {
+        try {
+          document.removeEventListener('keydown', onKeyDown, true);
+        } catch {
+          // ignore
+        }
+        try {
+          overlay.remove();
+        } catch {
+          // ignore
+        }
+        if (activeLayer?.overlay === overlay) activeLayer = null;
+      };
+
+      const close = (result) => {
+        cleanup();
+        resolve(result);
+      };
+
+      const validateAndClose = () => {
+        const values = {};
+        for (const it of inputs) {
+          const raw = it?.control?.value;
+          const value = typeof raw === 'string' ? raw.trim() : String(raw ?? '').trim();
+          if (it.required && !value) {
+            errorEl.textContent = `请填写：${it.label}`;
+            try {
+              it.control?.focus?.();
+            } catch {
+              // ignore
+            }
+            return;
+          }
+          values[it.name] = value;
+        }
+        close(values);
+      };
+
+      const onKeyDown = (ev) => {
+        if (ev?.key === 'Escape') {
+          try {
+            ev.preventDefault();
+          } catch {
+            // ignore
+          }
+          close(null);
+          return;
+        }
+        if (ev?.key === 'Enter') {
+          const active = document.activeElement;
+          const isTextArea = active && active.tagName === 'TEXTAREA';
+          if (isTextArea) return;
+          try {
+            ev.preventDefault();
+          } catch {
+            // ignore
+          }
+          validateAndClose();
+        }
+      };
+
+      overlay.addEventListener('mousedown', (ev) => {
+        if (ev?.target !== overlay) return;
+        close(null);
+      });
+
+      btnOk.addEventListener('click', () => validateAndClose());
+      btnCancel.addEventListener('click', () => close(null));
+
+      actions.appendChild(btnCancel);
+      actions.appendChild(btnOk);
+      modal.appendChild(header);
+      modal.appendChild(body);
+      modal.appendChild(actions);
+      overlay.appendChild(modal);
+      document.body.appendChild(overlay);
+      document.addEventListener('keydown', onKeyDown, true);
+
+      activeLayer = { overlay, dispose: () => close(null) };
+
+      const first = inputs[0]?.control;
+      if (first) {
+        setTimeout(() => {
+          try {
+            first.focus();
+          } catch {
+            // ignore
+          }
+        }, 0);
+      } else {
+        setTimeout(() => {
+          try {
+            btnOk.focus();
+          } catch {
+            // ignore
+          }
+        }, 0);
+      }
+    });
+
+  const confirmDialog = async (message, options = {}) => {
+    const res = await showDialog({
+      title: options?.title || '确认',
+      description: typeof message === 'string' ? message : '',
+      fields: [],
+      confirmText: options?.confirmText || '确定',
+      cancelText: options?.cancelText || '取消',
+      danger: options?.danger === true,
+    });
+    return Boolean(res);
+  };
+
+  return {
+    closeActiveLayer,
+    showMenu,
+    showDialog,
+    confirmDialog,
+  };
+}
+

package/templates/notepad/plugin/apps/app/markdown.mjs

@@ -0,0 +1,120 @@
+function escapeHtml(input) {
+  return String(input ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+function renderInlineMd(text) {
+  let out = escapeHtml(text);
+  out = out.replace(/`([^`]+?)`/g, '<code>$1</code>');
+  out = out.replace(/\*\*([^*]+?)\*\*/g, '<strong>$1</strong>');
+  out = out.replace(/\*([^*]+?)\*/g, '<em>$1</em>');
+  out = out.replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img alt="$1" src="$2" />');
+  out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2" target="_blank" rel="noreferrer">$1</a>');
+  return out;
+}
+
+export function renderMarkdown(md) {
+  const text = String(md || '').replace(/\r\n/g, '\n');
+  const lines = text.split('\n');
+  let html = '';
+  let inCode = false;
+  let listMode = '';
+  let paragraph = [];
+
+  const flushParagraph = () => {
+    if (paragraph.length === 0) return;
+    const content = paragraph.map((l) => renderInlineMd(l)).join('<br />');
+    html += `<p>${content}</p>`;
+    paragraph = [];
+  };
+
+  const closeList = () => {
+    if (!listMode) return;
+    html += listMode === 'ol' ? '</ol>' : '</ul>';
+    listMode = '';
+  };
+
+  for (const rawLine of lines) {
+    const line = String(rawLine ?? '');
+    const trimmed = line.trimEnd();
+
+    const fence = trimmed.trim().match(/^```(\S+)?\s*$/);
+    if (fence) {
+      flushParagraph();
+      closeList();
+      if (!inCode) {
+        inCode = true;
+        const lang = escapeHtml(fence[1] || '');
+        html += `<pre><code data-lang="${lang}">`;
+      } else {
+        inCode = false;
+        html += '</code></pre>';
+      }
+      continue;
+    }
+
+    if (inCode) {
+      html += `${escapeHtml(line)}\n`;
+      continue;
+    }
+
+    if (!trimmed.trim()) {
+      flushParagraph();
+      closeList();
+      continue;
+    }
+
+    const heading = trimmed.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      flushParagraph();
+      closeList();
+      const level = Math.min(6, heading[1].length);
+      html += `<h${level}>${renderInlineMd(heading[2])}</h${level}>`;
+      continue;
+    }
+
+    const quote = trimmed.match(/^>\s?(.*)$/);
+    if (quote) {
+      flushParagraph();
+      closeList();
+      html += `<blockquote>${renderInlineMd(quote[1] || '')}</blockquote>`;
+      continue;
+    }
+
+    const ul = trimmed.match(/^[-*+]\s+(.+)$/);
+    if (ul) {
+      flushParagraph();
+      if (listMode && listMode !== 'ul') closeList();
+      if (!listMode) {
+        listMode = 'ul';
+        html += '<ul>';
+      }
+      html += `<li>${renderInlineMd(ul[1])}</li>`;
+      continue;
+    }
+
+    const ol = trimmed.match(/^\d+\.\s+(.+)$/);
+    if (ol) {
+      flushParagraph();
+      if (listMode && listMode !== 'ol') closeList();
+      if (!listMode) {
+        listMode = 'ol';
+        html += '<ol>';
+      }
+      html += `<li>${renderInlineMd(ol[1])}</li>`;
+      continue;
+    }
+
+    paragraph.push(trimmed);
+  }
+
+  flushParagraph();
+  closeList();
+  if (inCode) html += '</code></pre>';
+  return html;
+}
+

package/templates/notepad/plugin/apps/app/mcp-prompt.en.md

@@ -0,0 +1,22 @@
+# __PLUGIN_NAME__ (Markdown Notes)
+
+This app exposes MCP tools to manage local Markdown notes (folders + tags):
+
+- `init`: initialize storage (data dir, index, notes root)
+- `list_folders`: list folders (categories)
+- `create_folder`: create a folder (supports nested paths)
+- `rename_folder`: rename/move a folder
+- `delete_folder`: delete a folder (optionally recursive)
+- `list_notes`: list notes filtered by folder/tags/title
+- `create_note`: create a note (folder/title/content/tags)
+- `read_note`: read a note (metadata + markdown content)
+- `update_note`: update a note (title/content/tags/move folder)
+- `delete_note`: delete a note
+- `list_tags`: list tags with counts
+- `search_notes`: search by keyword (optional content search + folder/tags filters)
+
+Guidelines:
+
+1) If you don't know the structure, start with `list_folders` + `list_notes`/`list_tags` before making changes.
+2) Ask for confirmation before destructive operations (especially `delete_folder` with `recursive=true`).
+3) For quick lookup by folder + tags, prefer `list_notes` (folder+tags) or `search_notes` with filters, instead of scanning everything.

package/templates/notepad/plugin/apps/app/mcp-prompt.zh.md

@@ -0,0 +1,22 @@
+# __PLUGIN_NAME__（Markdown Notes）
+
+本应用向 ChatOS 暴露了一组 MCP tools，用于管理本地 Markdown 笔记（文件夹分类 + 标签检索）：
+
+- `init`：初始化存储（数据目录、索引、notes 根目录）
+- `list_folders`：列出文件夹（分类）
+- `create_folder`：创建文件夹（支持多级路径）
+- `rename_folder`：重命名/移动文件夹
+- `delete_folder`：删除文件夹（可递归删除）
+- `list_notes`：按文件夹/标签/标题筛选列出笔记
+- `create_note`：创建笔记（可指定文件夹、标题、内容、标签）
+- `read_note`：读取笔记（返回元数据与 Markdown 内容）
+- `update_note`：更新笔记（标题/内容/标签/移动文件夹）
+- `delete_note`：删除笔记
+- `list_tags`：列出全部标签与使用次数
+- `search_notes`：按关键字搜索（可选：搜内容 + 叠加文件夹/标签过滤）
+
+使用建议（重要）：
+
+1) 不确定结构时，先 `list_folders` + `list_notes`/`list_tags` 再做编辑或移动。
+2) 移动或删除（尤其是 `delete_folder` 且 `recursive=true`）前先向用户确认。
+3) 若需要“按标签 + 分类”快速定位，优先用 `list_notes`（folder+tags）或 `search_notes`（叠加过滤），不要盲目遍历全部内容。

package/templates/notepad/plugin/apps/app/mcp-server.mjs

@@ -0,0 +1,200 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import { createNotepadStore } from '../../shared/notepad-store.mjs';
+import { resolveUiAppDataDir } from '../../shared/notepad-paths.mjs';
+
+const PLUGIN_ID = '__PLUGIN_ID__';
+const SERVER_NAME = '__PLUGIN_ID__.__APP_ID__';
+
+const store = createNotepadStore({ dataDir: resolveUiAppDataDir({ pluginId: PLUGIN_ID }) });
+
+const server = new McpServer({
+  name: SERVER_NAME,
+  version: '0.1.0',
+});
+
+const toText = (payload) => ({
+  content: [
+    {
+      type: 'text',
+      text: JSON.stringify(payload, null, 2),
+    },
+  ],
+});
+
+server.registerTool(
+  'init',
+  {
+    title: 'Init Notepad Storage',
+    description: 'Initialize the Notepad storage (data directory, index, notes root).',
+    inputSchema: z.object({}).optional(),
+  },
+  async () => toText(await store.init())
+);
+
+server.registerTool(
+  'list_folders',
+  {
+    title: 'List Folders',
+    description: 'List all folders (categories) under Notepad notes root.',
+    inputSchema: z.object({}).optional(),
+  },
+  async () => toText(await store.listFolders())
+);
+
+server.registerTool(
+  'create_folder',
+  {
+    title: 'Create Folder',
+    description: 'Create a folder (category). Supports nested paths like "work/ideas".',
+    inputSchema: z.object({
+      folder: z.string().min(1).describe('Folder path, relative to notes root (e.g., "work/ideas")'),
+    }),
+  },
+  async ({ folder }) => toText(await store.createFolder({ folder }))
+);
+
+server.registerTool(
+  'rename_folder',
+  {
+    title: 'Rename Folder',
+    description: 'Rename/move a folder (and updates indexed notes folder paths).',
+    inputSchema: z.object({
+      from: z.string().min(1).describe('Source folder path'),
+      to: z.string().min(1).describe('Target folder path'),
+    }),
+  },
+  async ({ from, to }) => toText(await store.renameFolder({ from, to }))
+);
+
+server.registerTool(
+  'delete_folder',
+  {
+    title: 'Delete Folder',
+    description: 'Delete a folder. If recursive=true, deletes all notes under it and removes them from index.',
+    inputSchema: z.object({
+      folder: z.string().min(1).describe('Folder path to delete'),
+      recursive: z.boolean().optional().describe('Delete folder recursively'),
+    }),
+  },
+  async ({ folder, recursive } = {}) => toText(await store.deleteFolder({ folder, recursive: recursive === true }))
+);
+
+server.registerTool(
+  'list_notes',
+  {
+    title: 'List Notes',
+    description: 'List notes with optional folder/tags/title filtering.',
+    inputSchema: z.object({
+      folder: z.string().optional().describe('Folder path; empty means all'),
+      recursive: z.boolean().optional().describe('Include notes in subfolders (default true)'),
+      tags: z.array(z.string()).optional().describe('Filter notes by tags'),
+      match: z.enum(['all', 'any']).optional().describe('Tag match mode'),
+      query: z.string().optional().describe('Substring filter for title/folder'),
+      limit: z.number().int().min(1).max(500).optional().describe('Max notes to return'),
+    }),
+  },
+  async ({ folder, recursive, tags, match, query, limit } = {}) =>
+    toText(await store.listNotes({ folder, recursive, tags, match, query, limit }))
+);
+
+server.registerTool(
+  'create_note',
+  {
+    title: 'Create Note',
+    description: 'Create a new markdown note under a folder with optional title/content/tags.',
+    inputSchema: z.object({
+      folder: z.string().optional().describe('Folder path to create note in'),
+      title: z.string().optional().describe('Note title'),
+      content: z.string().optional().describe('Markdown content (optional)'),
+      tags: z.array(z.string()).optional().describe('Tags (optional)'),
+    }),
+  },
+  async ({ folder, title, content, tags } = {}) => toText(await store.createNote({ folder, title, content, tags }))
+);
+
+server.registerTool(
+  'read_note',
+  {
+    title: 'Read Note',
+    description: 'Read a note by id (returns metadata and markdown content).',
+    inputSchema: z.object({
+      id: z.string().min(1).describe('Note id'),
+    }),
+  },
+  async ({ id }) => toText(await store.getNote({ id }))
+);
+
+server.registerTool(
+  'update_note',
+  {
+    title: 'Update Note',
+    description: 'Update note metadata/content by id. You can also move it by changing folder.',
+    inputSchema: z.object({
+      id: z.string().min(1).describe('Note id'),
+      title: z.string().optional().describe('New title'),
+      content: z.string().optional().describe('New markdown content'),
+      folder: z.string().optional().describe('New folder path'),
+      tags: z.array(z.string()).optional().describe('Replace tags'),
+    }),
+  },
+  async ({ id, title, content, folder, tags } = {}) => toText(await store.updateNote({ id, title, content, folder, tags }))
+);
+
+server.registerTool(
+  'delete_note',
+  {
+    title: 'Delete Note',
+    description: 'Delete a note by id (removes file and index entry).',
+    inputSchema: z.object({
+      id: z.string().min(1).describe('Note id'),
+    }),
+  },
+  async ({ id }) => toText(await store.deleteNote({ id }))
+);
+
+server.registerTool(
+  'list_tags',
+  {
+    title: 'List Tags',
+    description: 'List all tags with usage counts.',
+    inputSchema: z.object({}).optional(),
+  },
+  async () => toText(await store.listTags())
+);
+
+server.registerTool(
+  'search_notes',
+  {
+    title: 'Search Notes',
+    description: 'Search notes by query, optionally filtered by folder/tags; can include content search.',
+    inputSchema: z.object({
+      query: z.string().min(1).describe('Search keyword'),
+      folder: z.string().optional().describe('Folder path filter'),
+      recursive: z.boolean().optional().describe('Include notes in subfolders (default true)'),
+      tags: z.array(z.string()).optional().describe('Tag filter'),
+      match: z.enum(['all', 'any']).optional().describe('Tag match mode'),
+      includeContent: z.boolean().optional().describe('Search in content (default true)'),
+      limit: z.number().int().min(1).max(200).optional().describe('Max results'),
+    }),
+  },
+  async ({ query, folder, recursive, tags, match, includeContent, limit } = {}) =>
+    toText(await store.searchNotes({ query, folder, recursive, tags, match, includeContent: includeContent !== false, limit }))
+);
+
+async function main() {
+  const initRes = await store.init();
+  if (!initRes?.ok) {
+    // eslint-disable-next-line no-console
+    console.error('Notepad MCP init failed:', initRes?.message || initRes);
+  }
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch((error) => {
+  // eslint-disable-next-line no-console
+  console.error('MCP server error:', error);
+  process.exit(1);
+});