WebDAV MCP Server

Instructions

Implementation Reference

• src/handlers/tool-handlers.ts:86-117 (handler)

  Main tool handler function: checks if the remote file exists, then writes new content using WebDAVService

  async ({ path, content }) => {
    try {
      // Check if file exists
      const exists = await webdavService.exists(path);
      if (!exists) {
        return {
          content: [{
            type: 'text',
            text: `Error: File does not exist at ${path}`
          }],
          isError: true
        };
      }
  
      await webdavService.writeFile(path, content);
      
      return {
        content: [{
          type: 'text',
          text: `File updated successfully at ${path}`
        }]
      };
    } catch (error) {
      return {
        content: [{
          type: 'text',
          text: `Error updating file: ${(error as Error).message}`
        }],
        isError: true
      };
    }
  }

• src/handlers/tool-handlers.ts:83-85 (schema)

  Input schema validation using Zod for path and content parameters

    path: z.string().min(1, 'Path must not be empty'),
    content: z.string()
  },

• src/handlers/tool-handlers.ts:79-118 (registration)

  Registers the webdav_update_remote_file tool with the MCP server

  server.tool(
    'webdav_update_remote_file',
    'Update an existing file on a remote WebDAV server with new content',
    {
      path: z.string().min(1, 'Path must not be empty'),
      content: z.string()
    },
    async ({ path, content }) => {
      try {
        // Check if file exists
        const exists = await webdavService.exists(path);
        if (!exists) {
          return {
            content: [{
              type: 'text',
              text: `Error: File does not exist at ${path}`
            }],
            isError: true
          };
        }
  
        await webdavService.writeFile(path, content);
        
        return {
          content: [{
            type: 'text',
            text: `File updated successfully at ${path}`
          }]
        };
      } catch (error) {
        return {
          content: [{
            type: 'text',
            text: `Error updating file: ${(error as Error).message}`
          }],
          isError: true
        };
      }
    }
  );

• src/services/webdav-service.ts:144-168 (helper)

  Core helper method implementing WebDAV file update via putFileContents

  async writeFile(path: string, content: string | Buffer): Promise<void> {
    const fullPath = this.getFullPath(path);
    const contentLength = typeof content === 'string' ? content.length : content.length;
    logger.debug(`Writing file: ${fullPath}`, { contentLength });
    
    try {
      // putFileContents in v5.x returns a boolean indicating success
      const result = await this.client.putFileContents(fullPath, content);
      
      // Check result based on type
      if (typeof result === 'boolean' && !result) {
        throw new Error("Failed to write file: server returned failure status");
      } else if (this.isResponseData(result) && 
                 result.status !== undefined && 
                 result.status !== 201 && 
                 result.status !== 204) {
        throw new Error(`Failed to write file: server returned status ${result.status}`);
      }
      
      logger.debug(`Successfully wrote file: ${fullPath}`);
    } catch (error) {
      logger.error(`Error writing to file ${fullPath}:`, error);
      throw new Error(`Failed to write file: ${(error as Error).message}`);
    }
  }

• src/services/webdav-service.ts:298-324 (helper)

  Helper method to check if the remote path exists before attempting update

  async exists(path: string): Promise<boolean> {
    const fullPath = this.getFullPath(path);
    logger.debug(`Checking if exists: ${fullPath}`);
    
    try {
      const result = await this.client.exists(fullPath);
      
      // Handle both boolean and object responses
      let exists = false;
      
      if (typeof result === 'boolean') {
        exists = result;
      } else if (result && typeof result === 'object') {
        // Use type guard for better type safety
        const responseData = result as ResponseData;
        if (responseData.status !== undefined) {
          exists = responseData.status < 400; // If status is less than 400, the resource exists
        }
      }
      
      logger.debug(`Exists check for ${fullPath}: ${exists}`);
      return exists;
    } catch (error) {
      logger.error(`Error checking existence of ${fullPath}:`, error);
      return false;
    }
  }