pagespace-mcp/src/server.js

Model Context Protocol (MCP) server for PageSpace with complete workspace management, powerful search, batch operations, and AI agent capabilities. Provides external access to all core PageSpace functionality.

import { Server } from '@modelcontextprotocol/sdk/server/index.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import {
  CallToolRequestSchema,
  ErrorCode,
  InitializeRequestSchema,
  ListToolsRequestSchema,
  McpError,
} from '@modelcontextprotocol/sdk/types.js'
import { loadConfig } from './config.js'
import { PageSpaceApi } from './api.js'
import { tools } from './tools.js'
import { createDriveHandler } from './handlers/drive.js'
import { createPageHandler } from './handlers/page.js'
import { createDocumentHandler } from './handlers/document.js'
import { createSearchHandler } from './handlers/search.js'
import { createBatchHandler } from './handlers/batch.js'
import { createAgentHandler } from './handlers/agent.js'

export class PageSpaceMCPServer {
  constructor() {
    this.server = new Server(
      {
        name: 'pagespace',
        version: '0.1.0',
        description: 'PageSpace MCP Server - Complete workspace management with powerful search, batch operations, and AI agent capabilities. Provides external access to all core PageSpace functionality including drive management, page operations, content search, bulk processing, and AI agent creation and consultation.',
      },
      {
        capabilities: {
          tools: {},
        },
      }
    )

    this.config = loadConfig()
    const api = new PageSpaceApi(this.config)

    this.driveHandler = createDriveHandler(api)
    this.pageHandler = createPageHandler(api)
    this.documentHandler = createDocumentHandler(api)
    this.searchHandler = createSearchHandler(api)
    this.batchHandler = createBatchHandler(api)
    this.agentHandler = createAgentHandler(api)

    this.setupRequestHandlers()
  }

  setupRequestHandlers() {
    this.server.setRequestHandler(InitializeRequestSchema, async (request) => {
      console.error('[MCP] Handling initialize request')
      return {
        protocolVersion: '2024-11-05',
        capabilities: {
          tools: {},
        },
        serverInfo: {
          name: 'pagespace',
          version: '0.1.0',
        },
      }
    })

    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
      return { tools }
    })

    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
      const { name, arguments: args } = request.params
      console.error(`[MCP] Tool called: ${name}`)
      console.error(`[MCP] Tool arguments:`, JSON.stringify(args, null, 2))

      try {
        let result
        switch (name) {
          // Drive handlers
          case 'list_drives':
            result = await this.driveHandler.handleReadDrives()
            break
          case 'create_drive':
            result = await this.driveHandler.handleCreateDrive(args)
            break
          case 'rename_drive':
            result = await this.driveHandler.handleRenameDrive(args)
            break
          case 'trash_drive':
            result = await this.driveHandler.handleTrashDrive(args)
            break
          case 'restore_drive':
            result = await this.driveHandler.handleRestoreDrive(args)
            break

          // Page handlers
          case 'list_pages':
            result = await this.pageHandler.handleListPages(args)
            break
          case 'create_page':
            result = await this.pageHandler.handleCreatePage(args)
            break
          case 'rename_page':
            result = await this.pageHandler.handleRenamePage(args)
            break
          case 'trash_page':
            result = await this.pageHandler.handleTrashPage(args)
            break
          case 'trash_page_with_children':
            result = await this.pageHandler.handleTrashPageWithChildren(args)
            break
          case 'restore_page':
            result = await this.pageHandler.handleRestorePage(args)
            break
          case 'move_page':
            result = await this.pageHandler.handleMovePage(args)
            break
          case 'list_trash':
            result = await this.pageHandler.handleListTrash(args)
            break

          // Document handlers
          case 'read_page':
            result = await this.documentHandler.handleReadDocument(args)
            break
          case 'replace_lines':
            result = await this.documentHandler.handleReplaceLines(args)
            break
          case 'insert_lines':
            result = await this.documentHandler.handleInsertAtLine(args)
            break
          case 'delete_lines':
            result = await this.documentHandler.handleDeleteLines(args)
            break
          case 'append_to_page':
            result = await this.documentHandler.handleAppendToPage(args)
            break
          case 'prepend_to_page':
            result = await this.documentHandler.handlePrependToPage(args)
            break

          // Search handlers
          case 'regex_search':
            result = await this.searchHandler.handleRegexSearch(args)
            break
          case 'glob_search':
            result = await this.searchHandler.handleGlobSearch(args)
            break
          case 'multi_drive_search':
            result = await this.searchHandler.handleMultiDriveSearch(args)
            break

          // Batch operation handlers
          case 'bulk_move_pages':
            result = await this.batchHandler.handleBulkMovePages(args)
            break
          case 'bulk_rename_pages':
            result = await this.batchHandler.handleBulkRenamePages(args)
            break
          case 'bulk_delete_pages':
            result = await this.batchHandler.handleBulkDeletePages(args)
            break
          case 'bulk_update_content':
            result = await this.batchHandler.handleBulkUpdateContent(args)
            break
          case 'create_folder_structure':
            result = await this.batchHandler.handleCreateFolderStructure(args)
            break

          // Agent handlers
          case 'create_agent':
            result = await this.agentHandler.handleCreateAgent(args)
            break
          case 'update_agent_config':
            result = await this.agentHandler.handleUpdateAgentConfig(args)
            break
          case 'list_agents':
            result = await this.agentHandler.handleListAgents(args)
            break
          case 'multi_drive_list_agents':
            result = await this.agentHandler.handleMultiDriveListAgents(args)
            break
          case 'ask_agent':
            result = await this.agentHandler.handleAskAgent(args)
            break

          default:
            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`)
        }

        console.error(`[MCP] Tool ${name} completed successfully`)
        return result
      } catch (error) {
        console.error(`[MCP] Tool ${name} error:`, error)
        throw new McpError(
          ErrorCode.InternalError,
          `Error executing tool ${name}: ${error.message}`
        )
      }
    })
  }

  async run() {
    try {
      console.error('[MCP] Starting PageSpace MCP server...')
      console.error(`[MCP] API URL: ${this.config.apiUrl}`)
      console.error(`[MCP] Auth token present: ${this.config.authToken ? 'Yes' : 'No'}`)
      
      const transport = new StdioServerTransport()
      await this.server.connect(transport)
      console.error('[MCP] PageSpace MCP server running on stdio - ready for connections!')
    } catch (error) {
      console.error('[MCP] Failed to start server:', error)
      process.exit(1)
    }
  }
}