pagedex 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pagedex",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Local-first Markdown knowledge viewer, editor, Git bridge, and MCP v2 server for any directory.",
   "license": "MIT",
   "repository": {
@@ -29,6 +29,7 @@
     "start": "node --no-warnings src/server/index.js",
     "prepublishOnly": "vite build",
     "test": "node --no-warnings --test test/*.test.js",
+    "test:playwright": "node --no-warnings --test test/playwright/*.spec.js",
     "smoke": "node --no-warnings test/smoke.js all",
     "smoke:api": "node --no-warnings test/smoke.js api",
     "smoke:mcp": "node --no-warnings test/smoke.js mcp"
@@ -42,6 +43,7 @@
     "@tiptap/starter-kit": "^3.34.0",
     "highlight.js": "^11.12.0",
     "hono": "^4.7.0",
+    "lucide-react": "^1.73.0",
     "marked": "^15.0.0",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
@@ -50,6 +52,7 @@
   },
   "devDependencies": {
     "@vitejs/plugin-react": "^4.4.0",
+    "playwright-core": "^1.64.1",
     "vite": "^6.3.0"
   }
 }

package/src/server/index.js

@@ -12,6 +12,7 @@ import { registerEventRoutes, startVaultWatcher } from './routes/events.js';
 
 const HOST = process.env.HOST || '127.0.0.1';
 const PORT = Number(process.env.PORT || 4321);
+const READ_ONLY = process.env.PAGEDEX_READ_ONLY === '1' || process.env.PAGEDEX_READ_ONLY === 'true';
 
 try {
   syncIndex();
@@ -27,6 +28,9 @@ const app = new Hono();
 app.use('/api/v1/*', async (c, next) => {
   const method = c.req.method.toUpperCase();
   if (method !== 'GET' && method !== 'HEAD' && method !== 'OPTIONS') {
+    if (READ_ONLY) {
+      return c.json({ error: 'Server is running in read-only mode' }, 403);
+    }
     if (c.req.header('origin') === 'null') {
       return c.json({ error: 'Forbidden origin' }, 403);
     }

package/src/server/mcp.js

@@ -1,9 +1,57 @@
-import { randomUUID } from 'node:crypto';
+import { randomUUID, timingSafeEqual } from 'node:crypto';
 import fs from 'node:fs';
 import { McpServer, createMcpHandler, parseJSONRPCMessage } from '@modelcontextprotocol/server';
 import { z } from 'zod';
-import { deleteNote, editNote, getCachedVault, resolveSafe, writeNote } from './vault.js';
-import { removeFileFromIndex, searchFts, upsertFileInIndex } from './search-index.js';
+import {
+  deleteNote,
+  discardGitChange,
+  editNote,
+  getCachedVault,
+  getGitChanges,
+  getGitDiff,
+  gitCommitAndPush,
+  renameDir,
+  renameNote,
+  resolveSafe,
+  writeNote
+} from './vault.js';
+import { removeFileFromIndex, searchFts, syncIndex, upsertFileInIndex } from './search-index.js';
+
+const VALID_MCP_MODES = new Set(['read', 'write', 'full', 'off']);
+
+export function getMcpConfig() {
+  const readOnly = process.env.PAGEDEX_READ_ONLY === '1' || process.env.PAGEDEX_READ_ONLY === 'true';
+  const rawMode = (process.env.PAGEDEX_MCP_MODE || 'full').toLowerCase();
+  const normalized = VALID_MCP_MODES.has(rawMode) ? rawMode : 'full';
+  const mode = normalized === 'off' ? 'off' : readOnly ? 'read' : normalized;
+  const allowWrite = mode === 'write' || mode === 'full';
+  const allowDelete = mode === 'full';
+  const allowGit =
+    !readOnly &&
+    (process.env.PAGEDEX_MCP_GIT === '1' || process.env.PAGEDEX_MCP_GIT === 'true') &&
+    allowWrite;
+  return { mode, readOnly, allowWrite, allowDelete, allowGit };
+}
+
+function readMcpToken() {
+  const tokenFile = process.env.PAGEDEX_MCP_TOKEN_FILE;
+  if (tokenFile) {
+    return fs.readFileSync(tokenFile, 'utf8').trim();
+  }
+  return (process.env.PAGEDEX_MCP_TOKEN || '').trim();
+}
+
+function isAuthorizedMcpRequest(req) {
+  const expected = readMcpToken();
+  if (!expected) return true;
+  const auth = req.headers.get('authorization') || '';
+  const match = auth.match(/^Bearer\s+(.+)$/i);
+  if (!match) return false;
+  const provided = match[1].trim();
+  const a = Buffer.from(provided, 'utf8');
+  const b = Buffer.from(expected, 'utf8');
+  return a.length === b.length && timingSafeEqual(a, b);
+}
 
 const sseSessions = new Map();
 const encoder = new TextEncoder();
@@ -88,7 +136,7 @@ class WebStandardSSEServerTransport {
   }
 }
 
-function createVaultMcpServer() {
+function createVaultMcpServer(config = getMcpConfig()) {
   const server = new McpServer({
     name: 'vault-mcp',
     version: '0.1.0'
@@ -233,68 +281,142 @@ function createVaultMcpServer() {
   );
 
   server.registerTool(
-    'write_note',
+    'get_vault_info',
     {
-      title: 'Write or Edit Note',
-      description:
-        'Create/overwrite/append a note (with content), or partially edit an existing note (with target + replacement).',
+      title: 'Get Vault Info',
+      description: 'Return vault summary: total indexed files and the most recently modified files.',
       inputSchema: z.object({
-        path: z.string(),
-        content: z.string().optional(),
-        append: z.boolean().optional(),
-        target: z.string().optional(),
-        replacement: z.string().optional(),
-        replaceAll: z.boolean().optional()
+        recentLimit: z.number().int().min(1).max(50).optional()
+      }),
+      outputSchema: z.object({
+        totalFiles: z.number(),
+        recentFiles: z.array(
+          z.object({
+            path: z.string(),
+            mtimeMs: z.number()
+          })
+        )
+      })
+    },
+    async ({ recentLimit }) => {
+      const { flatFiles, fileStats } = getCachedVault();
+      const limit = recentLimit ?? 15;
+      const recentFiles = [...(fileStats || [])]
+        .sort((a, b) => (b.mtimeMs || 0) - (a.mtimeMs || 0))
+        .slice(0, limit)
+        .map((f) => ({ path: f.path, mtimeMs: f.mtimeMs || 0 }));
+      const lines = recentFiles.map((f) => f.path);
+      return {
+        structuredContent: {
+          totalFiles: flatFiles.length,
+          recentFiles
+        },
+        content: [
+          {
+            type: 'text',
+            text: `Total files: ${flatFiles.length}\nRecent files:\n${lines.length ? lines.join('\n') : '(none)'}`
+          }
+        ]
+      };
+    }
+  );
+
+  server.registerTool(
+    'get_note_links',
+    {
+      title: 'Get Note Links and Outline',
+      description: 'Return outgoing [[wikilinks]], incoming backlinks, and Markdown headings for a note.',
+      inputSchema: z.object({
+        path: z.string()
       }),
       outputSchema: z.object({
-        ok: z.boolean(),
         path: z.string(),
-        mode: z.enum(['write', 'append', 'edit']),
-        bytes: z.number().optional(),
-        replacements: z.number().optional()
+        outgoingLinks: z.array(z.string()),
+        backlinks: z.array(z.string()),
+        headings: z.array(
+          z.object({
+            level: z.number(),
+            text: z.string()
+          })
+        )
       })
     },
-    async ({ path: relPath, content, append, target, replacement, replaceAll }) => {
-      if (typeof target === 'string' && typeof replacement === 'string') {
-        const result = editNote(relPath, target, replacement, { replaceAll: Boolean(replaceAll) });
-        if (result.error) {
-          return { isError: true, content: [{ type: 'text', text: result.error }] };
-        }
-        upsertFileInIndex(result.path);
-        return {
-          structuredContent: {
-            ok: true,
-            path: result.path,
-            mode: 'edit',
-            replacements: result.replacements
-          },
-          content: [
-            {
-              type: 'text',
-              text: `Edited ${result.path} (${result.replacements} replacement${result.replacements === 1 ? '' : 's'})`
-            }
-          ]
-        };
+    async ({ path: relPath }) => {
+      const full = resolveSafe(relPath);
+      if (!full || !fs.existsSync(full) || !fs.statSync(full).isFile()) {
+        return { isError: true, content: [{ type: 'text', text: `Not found: ${relPath}` }] };
       }
-      if (typeof content !== 'string') {
-        return { isError: true, content: [{ type: 'text', text: 'Provide either content or target + replacement' }] };
+      const raw = fs.readFileSync(full, 'utf8');
+      const outgoingSet = new Set();
+      for (const m of raw.matchAll(/\[\[([^\]|#]+)(?:[|#][^\]]*)?\]\]/g)) {
+        const target = m[1].trim();
+        if (target) outgoingSet.add(target);
       }
-      const result = writeNote(relPath, content, { append: Boolean(append) });
-      if (!result) {
-        return { isError: true, content: [{ type: 'text', text: `Invalid or protected path: ${relPath}` }] };
+      const headings = [];
+      for (const line of raw.split('\n')) {
+        const hm = line.match(/^(#{1,6})\s+(.+?)\s*#*$/);
+        if (hm) headings.push({ level: hm[1].length, text: hm[2].trim() });
       }
-      upsertFileInIndex(result.path);
+      const { backlinks } = getCachedVault();
+      const outgoingLinks = [...outgoingSet];
+      const incoming = backlinks[relPath] || [];
+      return {
+        structuredContent: {
+          path: relPath,
+          outgoingLinks,
+          backlinks: incoming,
+          headings
+        },
+        content: [
+          {
+            type: 'text',
+            text: [
+              `# ${relPath}`,
+              `Outgoing: ${outgoingLinks.length ? outgoingLinks.join(', ') : 'none'}`,
+              `Backlinks: ${incoming.length ? incoming.join(', ') : 'none'}`,
+              `Headings: ${headings.length ? headings.map((h) => `${'#'.repeat(h.level)} ${h.text}`).join(' | ') : 'none'}`
+            ].join('\n')
+          }
+        ]
+      };
+    }
+  );
+
+  server.registerTool(
+    'git_status',
+    {
+      title: 'Git Status',
+      description: 'List uncommitted modified, added, or untracked files in the vault.',
+      inputSchema: z.object({}),
+      outputSchema: z.object({
+        isGit: z.boolean(),
+        count: z.number(),
+        changes: z.array(
+          z.object({
+            status: z.string(),
+            path: z.string(),
+            mtimeMs: z.number()
+          })
+        )
+      })
+    },
+    async () => {
+      const { isGit, changes } = getGitChanges();
+      const lines = changes.map((c) => `[${c.status}] ${c.path}`);
       return {
         structuredContent: {
-          ok: true,
-          path: result.path,
-          mode: append ? 'append' : 'write',
-          bytes: result.bytes
+          isGit,
+          count: changes.length,
+          changes
         },
         content: [
           {
             type: 'text',
-            text: `${append ? 'Appended' : 'Wrote'} ${result.path} (${result.bytes} bytes)`
+            text: !isGit
+              ? 'Not a git repository'
+              : lines.length
+                ? lines.join('\n')
+                : 'Working tree clean'
           }
         ]
       };
@@ -302,40 +424,276 @@ function createVaultMcpServer() {
   );
 
   server.registerTool(
-    'delete_note',
+    'git_diff',
     {
-      title: 'Delete Note',
-      description: 'Delete a note/file from the vault by relative path.',
+      title: 'Git Diff',
+      description: 'Get the unified git diff for a specific file in the vault.',
       inputSchema: z.object({
         path: z.string()
       }),
       outputSchema: z.object({
-        ok: z.boolean(),
-        path: z.string()
+        path: z.string(),
+        untracked: z.boolean(),
+        raw: z.string()
       })
     },
     async ({ path: relPath }) => {
-      const result = deleteNote(relPath);
-      if (!result) {
-        return { isError: true, content: [{ type: 'text', text: `Not found or protected path: ${relPath}` }] };
+      const diff = getGitDiff(relPath);
+      if (diff.error) {
+        return { isError: true, content: [{ type: 'text', text: diff.error }] };
       }
-      removeFileFromIndex(result.path);
       return {
         structuredContent: {
-          ok: true,
-          path: result.path
+          path: diff.path,
+          untracked: Boolean(diff.untracked),
+          raw: diff.raw || ''
         },
-        content: [{ type: 'text', text: `Deleted ${result.path}` }]
+        content: [
+          {
+            type: 'text',
+            text: diff.raw ? diff.raw : `No changes in ${diff.path}`
+          }
+        ]
       };
     }
   );
 
+  if (config.allowWrite) {
+    server.registerTool(
+      'write_note',
+      {
+        title: 'Write or Edit Note',
+        description:
+          'Create/overwrite/append a note (with content), or partially edit an existing note (with target + replacement).',
+        inputSchema: z.object({
+          path: z.string(),
+          content: z.string().optional(),
+          append: z.boolean().optional(),
+          target: z.string().optional(),
+          replacement: z.string().optional(),
+          replaceAll: z.boolean().optional()
+        }),
+        outputSchema: z.object({
+          ok: z.boolean(),
+          path: z.string(),
+          mode: z.enum(['write', 'append', 'edit']),
+          bytes: z.number().optional(),
+          replacements: z.number().optional()
+        })
+      },
+      async ({ path: relPath, content, append, target, replacement, replaceAll }) => {
+        if (typeof target === 'string' && typeof replacement === 'string') {
+          const result = editNote(relPath, target, replacement, { replaceAll: Boolean(replaceAll) });
+          if (result.error) {
+            return { isError: true, content: [{ type: 'text', text: result.error }] };
+          }
+          upsertFileInIndex(result.path);
+          return {
+            structuredContent: {
+              ok: true,
+              path: result.path,
+              mode: 'edit',
+              replacements: result.replacements
+            },
+            content: [
+              {
+                type: 'text',
+                text: `Edited ${result.path} (${result.replacements} replacement${result.replacements === 1 ? '' : 's'})`
+              }
+            ]
+          };
+        }
+        if (typeof content !== 'string') {
+          return { isError: true, content: [{ type: 'text', text: 'Provide either content or target + replacement' }] };
+        }
+        const result = writeNote(relPath, content, { append: Boolean(append) });
+        if (!result) {
+          return { isError: true, content: [{ type: 'text', text: `Invalid or protected path: ${relPath}` }] };
+        }
+        upsertFileInIndex(result.path);
+        return {
+          structuredContent: {
+            ok: true,
+            path: result.path,
+            mode: append ? 'append' : 'write',
+            bytes: result.bytes
+          },
+          content: [
+            {
+              type: 'text',
+              text: `${append ? 'Appended' : 'Wrote'} ${result.path} (${result.bytes} bytes)`
+            }
+          ]
+        };
+      }
+    );
+
+    server.registerTool(
+      'move_path',
+      {
+        title: 'Move or Rename File/Folder',
+        description: 'Rename or move a file or folder within the vault.',
+        inputSchema: z.object({
+          oldPath: z.string(),
+          newPath: z.string(),
+          type: z.enum(['auto', 'file', 'dir']).optional()
+        }),
+        outputSchema: z.object({
+          ok: z.boolean(),
+          type: z.enum(['file', 'dir']),
+          oldPath: z.string(),
+          newPath: z.string()
+        })
+      },
+      async ({ oldPath, newPath, type = 'auto' }) => {
+        const full = resolveSafe(oldPath);
+        if (!full || !fs.existsSync(full)) {
+          return { isError: true, content: [{ type: 'text', text: `Source not found: ${oldPath}` }] };
+        }
+        const isDir = type === 'dir' || (type === 'auto' && fs.statSync(full).isDirectory());
+        const result = isDir ? renameDir(oldPath, newPath) : renameNote(oldPath, newPath);
+        if (result.error) {
+          return { isError: true, content: [{ type: 'text', text: result.error }] };
+        }
+        if (isDir) {
+          syncIndex();
+        } else {
+          removeFileFromIndex(result.oldPath);
+          upsertFileInIndex(result.newPath);
+        }
+        return {
+          structuredContent: {
+            ok: true,
+            type: isDir ? 'dir' : 'file',
+            oldPath: result.oldPath,
+            newPath: result.newPath
+          },
+          content: [{ type: 'text', text: `Moved ${result.oldPath} -> ${result.newPath}` }]
+        };
+      }
+    );
+  }
+
+  if (config.allowDelete) {
+    server.registerTool(
+      'delete_note',
+      {
+        title: 'Delete Note',
+        description: 'Delete a note/file from the vault by relative path.',
+        inputSchema: z.object({
+          path: z.string()
+        }),
+        outputSchema: z.object({
+          ok: z.boolean(),
+          path: z.string()
+        })
+      },
+      async ({ path: relPath }) => {
+        const result = deleteNote(relPath);
+        if (!result) {
+          return { isError: true, content: [{ type: 'text', text: `Not found or protected path: ${relPath}` }] };
+        }
+        removeFileFromIndex(result.path);
+        return {
+          structuredContent: {
+            ok: true,
+            path: result.path
+          },
+          content: [{ type: 'text', text: `Deleted ${result.path}` }]
+        };
+      }
+    );
+  }
+
+  if (config.allowGit) {
+    server.registerTool(
+      'git_commit',
+      {
+        title: 'Git Commit',
+        description: 'Stage and commit vault changes locally (never pushes).',
+        inputSchema: z.object({
+          message: z.string(),
+          files: z.array(z.string()).optional()
+        }),
+        outputSchema: z.object({
+          ok: z.boolean(),
+          output: z.string()
+        })
+      },
+      async ({ message, files }) => {
+        const result = gitCommitAndPush({ message, files, push: false });
+        if (result.error) {
+          return { isError: true, content: [{ type: 'text', text: result.error }] };
+        }
+        return {
+          structuredContent: {
+            ok: true,
+            output: result.output || ''
+          },
+          content: [{ type: 'text', text: result.output || 'Committed' }]
+        };
+      }
+    );
+
+    server.registerTool(
+      'git_discard',
+      {
+        title: 'Git Discard File Changes',
+        description: 'Discard all uncommitted changes to a file (or remove an untracked file).',
+        inputSchema: z.object({
+          path: z.string()
+        }),
+        outputSchema: z.object({
+          ok: z.boolean(),
+          path: z.string(),
+          discarded: z.string()
+        })
+      },
+      async ({ path: relPath }) => {
+        const result = discardGitChange({ path: relPath });
+        if (result.error) {
+          return { isError: true, content: [{ type: 'text', text: result.error }] };
+        }
+        syncIndex();
+        return {
+          structuredContent: {
+            ok: true,
+            path: result.path,
+            discarded: result.discarded || 'file'
+          },
+          content: [{ type: 'text', text: `Discarded changes in ${result.path} (${result.discarded})` }]
+        };
+      }
+    );
+  }
+
   return server;
 }
 
-const mcpHandler = createMcpHandler(createVaultMcpServer);
+const mcpHandlers = new Map();
+
+function getMcpHandler(config) {
+  const key = `${config.mode}:${config.allowGit}`;
+  let handler = mcpHandlers.get(key);
+  if (!handler) {
+    handler = createMcpHandler(() => createVaultMcpServer(config));
+    mcpHandlers.set(key, handler);
+  }
+  return handler;
+}
 
 export async function handleMcpRequest(req) {
+  const config = getMcpConfig();
+  if (config.mode === 'off') {
+    return Response.json({ error: 'MCP endpoint is disabled' }, { status: 404 });
+  }
+  if (!isAuthorizedMcpRequest(req)) {
+    return Response.json(
+      { error: 'Unauthorized' },
+      { status: 401, headers: { 'WWW-Authenticate': 'Bearer' } }
+    );
+  }
+
   const url = new URL(req.url, 'http://localhost');
   const sessionId = url.searchParams.get('sessionId');
   const isStreamableHttpGet =
@@ -345,7 +703,7 @@ export async function handleMcpRequest(req) {
   if (req.method === 'GET' && !sessionId && !isStreamableHttpGet) {
     const transport = new WebStandardSSEServerTransport(url.pathname);
     sseSessions.set(transport.sessionId, transport);
-    const server = createVaultMcpServer();
+    const server = createVaultMcpServer(config);
     await server.connect(transport);
     return transport.createResponse(req.signal);
   }
@@ -360,5 +718,5 @@ export async function handleMcpRequest(req) {
   }
 
   // 3. Official MCP v2 handler: supports BOTH Modern (2026-07-28 server/discover) and Legacy Streamable HTTP (2025-11-25 initialize)
-  return mcpHandler.fetch(req);
+  return getMcpHandler(config).fetch(req);
 }

package/dist/assets/TiptapEditor-OFHNcjy3.js

@@ -1 +0,0 @@
-import{a as d,j as e}from"./vendor-react-E4kvVwMA.js";import{u as p,E as b,s as h,M as x}from"./vendor-tiptap-ChgD7Piv.js";import"./vendor-markdown-C94ubdL7.js";function N({content:n,fileKey:u,fontSize:m,lineHeight:f,maxWidth:g,saving:c,dirty:o,onChange:l,onSave:v}){const t=p({extensions:[h,x],content:n});return d.useEffect(()=>{var s,i;if(!t)return;(((i=(s=t.storage.markdown)==null?void 0:s.getMarkdown)==null?void 0:i.call(s))??"")!==n&&!o&&t.commands.setContent(n)},[u,n,t,o]),d.useEffect(()=>{if(!t)return;const a=()=>{var i,r;const s=((r=(i=t.storage.markdown)==null?void 0:i.getMarkdown)==null?void 0:r.call(i))??"";l(s)};return t.on("update",a),()=>t.off("update",a)},[t,l]),t?e.jsxs("div",{className:"tiptap-wrap",style:{maxWidth:`${g}px`},children:[e.jsxs("div",{className:"tiptap-toolbar",children:[e.jsx("button",{className:`btn${t.isActive("bold")?" active":""}`,onClick:()=>t.chain().focus().toggleBold().run(),children:"B"}),e.jsx("button",{className:`btn${t.isActive("italic")?" active":""}`,onClick:()=>t.chain().focus().toggleItalic().run(),children:"I"}),e.jsx("button",{className:`btn${t.isActive("heading",{level:1})?" active":""}`,onClick:()=>t.chain().focus().toggleHeading({level:1}).run(),children:"H1"}),e.jsx("button",{className:`btn${t.isActive("heading",{level:2})?" active":""}`,onClick:()=>t.chain().focus().toggleHeading({level:2}).run(),children:"H2"}),e.jsx("button",{className:`btn${t.isActive("bulletList")?" active":""}`,onClick:()=>t.chain().focus().toggleBulletList().run(),children:"List"}),e.jsx("button",{className:`btn${t.isActive("codeBlock")?" active":""}`,onClick:()=>t.chain().focus().toggleCodeBlock().run(),children:"Code"}),e.jsx("button",{className:`btn${o?" primary":""}`,style:{marginLeft:"auto"},disabled:c,onClick:()=>{var a,s;return v(((s=(a=t.storage.markdown)==null?void 0:a.getMarkdown)==null?void 0:s.call(a))??"")},children:c?"Saving...":o?"Save *":"Saved"})]}),e.jsx("div",{className:"doc tiptap-body",style:{fontSize:`${m}px`,lineHeight:f},children:e.jsx(b,{editor:t})})]}):null}export{N as default};