outline-mcp-server 4.12.2 → 5.0.0

package/build/tools/getDocument.js

@@ -1,24 +1,20 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('get_document', {
     name: 'get_document',
     description: 'Get details about a specific document. At least id XOR shareId are required.',
     inputSchema: {
-        properties: {
-            id: {
-                type: 'string',
-                description: 'Unique identifier for the document. Either the UUID or the urlId is acceptable',
-            },
-        },
-        required: ['id'],
-        type: 'object',
+        id: z
+            .string()
+            .describe('Unique identifier for the document. Either the UUID or the urlId is acceptable'),
     },
-    handler: async function handleGetDocument(args) {
+    async callback(args) {
         try {
             const response = await outlineClient.post('/documents.info', { id: args.id });
-            return response.data.data;
+            return { content: [{ type: 'text', text: JSON.stringify(response.data.data) }] };
         }
         catch (error) {
             console.error('Error getting document:', error.message);

package/build/tools/listCollections.js

@@ -1,27 +1,33 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('list_collections', {
     name: 'list_collections',
     description: 'List all collections in the Outline workspace',
     inputSchema: {
-        properties: {
-            limit: {
-                type: 'number',
-                description: 'Maximum number of collections to return (optional)',
-            },
-        },
-        type: 'object',
+        limit: z.number().describe('Maximum number of collections to return (optional)').optional(),
     },
-    handler: async function handleListCollections(args) {
+    async callback(args) {
         try {
             const payload = {};
             if (args.limit) {
                 payload.limit = args.limit;
             }
             const response = await outlineClient.post('/collections.list', payload);
-            return response.data.data;
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `collections: ${JSON.stringify(response.data.data)}`,
+                    },
+                    {
+                        type: 'text',
+                        text: `pagination: ${JSON.stringify(response.data.pagination)}`,
+                    },
+                ],
+            };
         }
         catch (error) {
             console.error('Error listing collections:', error.message);

package/build/tools/listDocuments.js

@@ -1,57 +1,33 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('list_documents', {
     name: 'list_documents',
     description: 'List documents in the Outline workspace with optional filters',
     inputSchema: {
-        properties: {
-            collectionId: {
-                type: 'string',
-                description: 'Filter by collection ID (optional)',
-            },
-            query: {
-                type: 'string',
-                description: 'Search query to filter documents (optional)',
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum number of documents to return (optional)',
-            },
-            offset: {
-                type: 'number',
-                description: 'Pagination offset (optional)',
-            },
-            sort: {
-                type: 'string',
-                description: 'Field to sort by (e.g. "updatedAt") (optional)',
-            },
-            direction: {
-                type: 'string',
-                description: 'Sort direction, either "ASC" or "DESC" (optional)',
-                enum: ['ASC', 'DESC'],
-            },
-            template: {
-                type: 'boolean',
-                description: 'Optionally filter to only templates (optional)',
-            },
-            userId: {
-                type: 'string',
-                description: 'Optionally filter by user ID (optional)',
-            },
-            parentDocumentId: {
-                type: 'string',
-                description: 'Optionally filter by parent document ID (optional)',
-            },
-            backlinkDocumentId: {
-                type: 'string',
-                description: 'Optionally filter by backlink document ID (optional)',
-            },
-        },
-        type: 'object',
+        collectionId: z.string().describe('Filter by collection ID (optional)').optional(),
+        query: z.string().describe('Search query to filter documents (optional)').optional(),
+        limit: z.number().describe('Maximum number of documents to return (optional)').optional(),
+        offset: z.number().describe('Pagination offset (optional)').optional(),
+        sort: z.string().describe('Field to sort by (e.g. "updatedAt") (optional)').optional(),
+        direction: z
+            .enum(['ASC', 'DESC'])
+            .describe('Sort direction, either "ASC" or "DESC" (optional)')
+            .optional(),
+        template: z.boolean().describe('Optionally filter to only templates (optional)').optional(),
+        userId: z.string().describe('Optionally filter by user ID (optional)').optional(),
+        parentDocumentId: z
+            .string()
+            .describe('Optionally filter by parent document ID (optional)')
+            .optional(),
+        backlinkDocumentId: z
+            .string()
+            .describe('Optionally filter by backlink document ID (optional)')
+            .optional(),
     },
-    handler: async function handleListDocuments(args) {
+    async callback(args) {
         try {
             // Create the payload object
             const payload = {
@@ -78,13 +54,16 @@ registerTool({
             const documents = response.data.data;
             // Return the documents with additional metadata
             return {
-                documents,
-                pagination: {
-                    offset: response.data.pagination.offset,
-                    limit: response.data.pagination.limit,
-                    nextPath: response.data.pagination.nextPath,
-                    totalCount: response.data.pagination.totalCount,
-                },
+                content: [
+                    {
+                        type: 'text',
+                        text: `documents: ${JSON.stringify(documents)}`,
+                    },
+                    {
+                        type: 'text',
+                        text: `pagination: ${JSON.stringify(response.data.pagination)}`,
+                    },
+                ],
             };
         }
         catch (error) {

package/build/tools/listUsers.js

@@ -1,54 +1,34 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('list_users', {
     name: 'list_users',
     description: 'List all users in the Outline workspace',
     inputSchema: {
-        properties: {
-            offset: {
-                type: 'number',
-                description: 'Pagination offset (optional)',
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum number of users to return (optional)',
-            },
-            sort: {
-                type: 'string',
-                description: 'Field to sort by (e.g. "name", "email", "createdAt") (optional)',
-            },
-            direction: {
-                type: 'string',
-                description: 'Sort direction, either "ASC" or "DESC" (optional)',
-                enum: ['ASC', 'DESC'],
-            },
-            query: {
-                type: 'string',
-                description: 'Search query to filter users (optional)',
-            },
-            emails: {
-                type: 'array',
-                items: {
-                    type: 'string',
-                },
-                description: 'Filter by email addresses (optional)',
-            },
-            filter: {
-                type: 'string',
-                description: 'Filter by user status (optional)',
-                enum: ['all', 'invited', 'active', 'suspended'],
-            },
-            role: {
-                type: 'string',
-                description: 'Filter by user role (optional)',
-                enum: ['admin', 'member', 'viewer', 'guest'],
-            },
-        },
-        type: 'object',
+        offset: z.number().describe('Pagination offset (optional)').optional(),
+        limit: z.number().describe('Maximum number of users to return (optional)').optional(),
+        sort: z
+            .string()
+            .describe('Field to sort by (e.g. "name", "email", "createdAt") (optional)')
+            .optional(),
+        direction: z
+            .enum(['ASC', 'DESC'])
+            .describe('Sort direction, either "ASC" or "DESC" (optional)')
+            .optional(),
+        query: z.string().describe('Search query to filter users (optional)').optional(),
+        emails: z.array(z.string()).describe('Filter by email addresses (optional)').optional(),
+        filter: z
+            .enum(['all', 'invited', 'active', 'suspended'])
+            .describe('Filter by user status (optional)')
+            .optional(),
+        role: z
+            .enum(['admin', 'member', 'viewer', 'guest'])
+            .describe('Filter by user role (optional)')
+            .optional(),
     },
-    handler: async function handleListUsers(args) {
+    async callback(args) {
         try {
             const payload = {};
             if (args.offset !== undefined) {
@@ -76,7 +56,12 @@ registerTool({
                 payload.role = args.role;
             }
             const response = await outlineClient.post('/users.list', payload);
-            return response.data.data;
+            return {
+                content: [
+                    { type: 'text', text: `users: ${JSON.stringify(response.data.data)}` },
+                    { type: 'text', text: `pagination: ${JSON.stringify(response.data.pagination)}` },
+                ],
+            };
         }
         catch (error) {
             console.error('Error listing users:', error.message);

package/build/tools/moveDocument.js

@@ -1,29 +1,23 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('move_document', {
     name: 'move_document',
     description: 'Move a document to a different collection or parent document',
     inputSchema: {
-        properties: {
-            id: {
-                type: 'string',
-                description: 'ID of the document to move',
-            },
-            collectionId: {
-                type: 'string',
-                description: 'ID of the collection to move the document to (optional)',
-            },
-            parentDocumentId: {
-                type: 'string',
-                description: 'ID of the parent document to move under (optional)',
-            },
-        },
-        required: ['id'],
-        type: 'object',
+        id: z.string().describe('ID of the document to move'),
+        collectionId: z
+            .string()
+            .describe('ID of the collection to move the document to (optional)')
+            .optional(),
+        parentDocumentId: z
+            .string()
+            .describe('ID of the parent document to move under (optional)')
+            .optional(),
     },
-    handler: async function handleMoveDocument(args) {
+    async callback(args) {
         try {
             const payload = {
                 id: args.id,
@@ -35,7 +29,7 @@ registerTool({
                 payload.parentDocumentId = args.parentDocumentId;
             }
             const response = await outlineClient.post('/documents.move', payload);
-            return response.data.data;
+            return { content: [{ type: 'text', text: JSON.stringify(response.data.data) }] };
         }
         catch (error) {
             console.error('Error moving document:', error.message);

package/build/tools/searchDocuments.js

@@ -1,29 +1,17 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('search_documents', {
     name: 'search_documents',
     description: 'Search for documents in the Outline workspace',
     inputSchema: {
-        properties: {
-            query: {
-                type: 'string',
-                description: 'Search query to filter documents',
-            },
-            collectionId: {
-                type: 'string',
-                description: 'Filter by collection ID (optional)',
-            },
-            limit: {
-                type: 'number',
-                description: 'Maximum number of documents to return (optional)',
-            },
-        },
-        required: ['query'],
-        type: 'object',
+        query: z.string().describe('Search query to filter documents'),
+        collectionId: z.string().describe('Filter by collection ID (optional)').optional(),
+        limit: z.number().describe('Maximum number of documents to return (optional)').optional(),
     },
-    handler: async function handleSearchDocuments(args) {
+    async callback(args) {
         try {
             const payload = {
                 query: args.query,
@@ -35,7 +23,12 @@ registerTool({
                 payload.limit = args.limit;
             }
             const response = await outlineClient.post('/documents.search', payload);
-            return response.data.data;
+            return {
+                content: [
+                    { type: 'text', text: `documents: ${JSON.stringify(response.data.data)}` },
+                    { type: 'text', text: `pagination: ${JSON.stringify(response.data.pagination)}` },
+                ],
+            };
         }
         catch (error) {
             console.error('Error searching documents:', error.message);

package/build/tools/updateCollection.js

@@ -1,37 +1,22 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('update_collection', {
     name: 'update_collection',
     description: 'Update an existing collection',
     inputSchema: {
-        properties: {
-            id: {
-                type: 'string',
-                description: 'ID of the collection to update',
-            },
-            name: {
-                type: 'string',
-                description: 'New name for the collection (optional)',
-            },
-            description: {
-                type: 'string',
-                description: 'New description for the collection (optional)',
-            },
-            permission: {
-                type: 'string',
-                description: 'New permission setting for the collection (optional)',
-            },
-            color: {
-                type: 'string',
-                description: 'New color for the collection (optional)',
-            },
-        },
-        required: ['id'],
-        type: 'object',
+        id: z.string().describe('ID of the collection to update'),
+        name: z.string().describe('New name for the collection (optional)').optional(),
+        description: z.string().describe('New description for the collection (optional)').optional(),
+        permission: z
+            .string()
+            .describe('New permission setting for the collection (optional)')
+            .optional(),
+        color: z.string().describe('New color for the collection (optional)').optional(),
     },
-    handler: async function handleUpdateCollection(args) {
+    async callback(args) {
         try {
             const payload = {
                 id: args.id,
@@ -49,7 +34,7 @@ registerTool({
                 payload.color = args.color;
             }
             const response = await outlineClient.post('/collections.update', payload);
-            return response.data.data;
+            return { content: [{ type: 'text', text: JSON.stringify(response.data.data) }] };
         }
         catch (error) {
             console.error('Error updating collection:', error.message);

package/build/tools/updateComment.js

@@ -1,29 +1,17 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('update_comment', {
     name: 'update_comment',
     description: 'Update an existing comment',
     inputSchema: {
-        properties: {
-            id: {
-                type: 'string',
-                description: 'ID of the comment to update',
-            },
-            text: {
-                type: 'string',
-                description: 'New content for the comment in markdown format',
-            },
-            data: {
-                type: 'object',
-                description: 'Additional data for the comment (optional)',
-            },
-        },
-        required: ['id'],
-        type: 'object',
+        id: z.string().describe('ID of the comment to update'),
+        text: z.string().describe('New content for the comment in markdown format').optional(),
+        data: z.object({}).describe('Additional data for the comment (optional)').optional(),
     },
-    handler: async function handleUpdateComment(args) {
+    async callback(args) {
         try {
             const payload = {
                 id: args.id,
@@ -35,7 +23,7 @@ registerTool({
                 payload.data = args.data;
             }
             const response = await outlineClient.post('/comments.update', payload);
-            return response.data.data;
+            return { content: [{ type: 'text', text: JSON.stringify(response.data.data) }] };
         }
         catch (error) {
             console.error('Error updating comment:', error.message);

package/build/tools/updateDocument.js

@@ -1,37 +1,19 @@
 import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { outlineClient } from '../client.js';
-import { registerTool } from '../utils/listTools.js';
+import { outlineClient } from '../outline/outlineClient.js';
+import toolRegistry from '../utils/toolRegistry.js';
+import z from 'zod';
 // Register this tool
-registerTool({
+toolRegistry.register('update_document', {
     name: 'update_document',
     description: 'Update an existing document',
     inputSchema: {
-        properties: {
-            documentId: {
-                type: 'string',
-                description: 'ID of the document to update',
-            },
-            title: {
-                type: 'string',
-                description: 'New title for the document',
-            },
-            text: {
-                type: 'string',
-                description: 'New content for the document in markdown format',
-            },
-            publish: {
-                type: 'boolean',
-                description: 'Whether to publish the document',
-            },
-            done: {
-                type: 'boolean',
-                description: 'Whether the document is marked as done',
-            },
-        },
-        required: ['documentId'],
-        type: 'object',
+        documentId: z.string().describe('ID of the document to update'),
+        title: z.string().describe('New title for the document').optional(),
+        text: z.string().describe('New content for the document in markdown format').optional(),
+        publish: z.boolean().describe('Whether to publish the document').optional(),
+        done: z.boolean().describe('Whether the document is marked as done').optional(),
     },
-    handler: async function handleUpdateDocument(args) {
+    async callback(args) {
         try {
             const payload = {
                 id: args.documentId,
@@ -49,7 +31,7 @@ registerTool({
                 payload.done = args.done;
             }
             const response = await outlineClient.post('/documents.update', payload);
-            return response.data.data;
+            return { content: [{ type: 'text', text: JSON.stringify(response.data.data) }] };
         }
         catch (error) {
             console.error('Error updating document:', error.message);

package/build/utils/getMcpServer.js

@@ -0,0 +1,16 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { loadAllTools } from './loadAllTools.js';
+// Helper to create a new MCP server instance with all tools registered
+export async function getMcpServer() {
+    const server = new McpServer({
+        name: 'outline-mcp',
+        version: process.env.npm_package_version || 'unknown',
+        description: 'Outline Model Context Protocol server',
+    });
+    await loadAllTools(tool => server.registerTool(tool.name, {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+    }, tool.callback));
+    return server;
+}

package/build/utils/{importTools.js → loadAllTools.js}

@@ -1,23 +1,26 @@
 import fs from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
-import { getToolDefinitions } from './listTools.js';
+import toolRegistry from './toolRegistry.js';
 /**
  * Dynamically imports all tool files from the tools directory
  */
-export async function registerTools() {
+export async function loadAllTools(onToolLoaded) {
     // Get the directory path
     const __filename = fileURLToPath(import.meta.url);
     const __dirname = path.dirname(__filename);
     const toolsDir = path.join(__dirname, '..', 'tools');
-    // Import all tool files
+    // List tool files
     const toolFiles = fs
         .readdirSync(toolsDir)
         .filter(file => file.endsWith('.ts') || file.endsWith('.js'));
+    // Import all tool files, causing them to be restered via `registerTool`
     for (const file of toolFiles) {
         const resolved = path.resolve(toolsDir, file);
         await import(resolved);
     }
-    // return tool definitions
-    return getToolDefinitions();
+    // configure McpServer with all definitions
+    for (const tool of toolRegistry.tools) {
+        await onToolLoaded?.(tool);
+    }
 }

package/build/utils/toolRegistry.js

@@ -0,0 +1,27 @@
+class ToolRegistry {
+    constructor() {
+        this.registry = new Map();
+        this.registry = new Map();
+    }
+    get tools() {
+        return Array.from(this.registry.values());
+    }
+    has(name) {
+        return this.registry.has(name);
+    }
+    get(name) {
+        return this.registry.get(name);
+    }
+    /**
+     * Registers a tool with the global registry
+     */
+    register(name, definition) {
+        if (this.has(name)) {
+            throw new Error(`Attempted to register duplicate tool: "${name}"`);
+        }
+        this.registry.set(name, definition);
+    }
+}
+// We'll collect all tool definitions here, keyed by name
+const toolRegistry = new ToolRegistry();
+export default toolRegistry;