snapshot of https://github.com/RocketChat/Rocket.Chat.git (develop, 2026-09-16; blobs > 131072B omitted)

apps/meteor/server/bridges/webdav/README.md

@@ -0,0 +1,3 @@
+# RocketChat WebDAV
+
+Package for RocketChat users to interact with WebDAV servers (Tested with ownCloud and Nextcloud).

apps/meteor/server/bridges/webdav/index.ts

@@ -0,0 +1,5 @@
+import './methods/addWebdavAccount';
+import './methods/getWebdavFileList';
+import './methods/getWebdavFilePreview';
+import './methods/getFileFromWebdav';
+import './methods/uploadFileToWebdav';

apps/meteor/server/bridges/webdav/lib/getWebdavCredentials.ts

@@ -0,0 +1,11 @@
+import type { WebDAVClientOptions } from 'webdav';
+
+export function getWebdavCredentials(account: WebDAVClientOptions): WebDAVClientOptions {
+	const cred = account.token
+		? { token: account.token }
+		: {
+				username: account.username,
+				password: account.password,
+			};
+	return cred;
+}

apps/meteor/server/bridges/webdav/lib/uploadFileToWebdav.ts

@@ -0,0 +1,21 @@
+import type { IWebdavAccount } from '@rocket.chat/core-typings';
+import { WebdavAccounts } from '@rocket.chat/models';
+
+import { getWebdavCredentials } from './getWebdavCredentials';
+import { WebdavClientAdapter } from './webdavClientAdapter';
+
+export const uploadFileToWebdav = async (accountId: IWebdavAccount['_id'], fileData: string | Buffer, name: string): Promise<void> => {
+	const account = await WebdavAccounts.findOneById(accountId);
+	if (!account) {
+		throw new Error('error-invalid-account');
+	}
+
+	const uploadFolder = 'Rocket.Chat Uploads/';
+	const buffer = Buffer.isBuffer(fileData) ? fileData : Buffer.from(fileData);
+
+	const cred = getWebdavCredentials(account);
+	const client = new WebdavClientAdapter(account.serverURL, cred);
+	// eslint-disable-next-line @typescript-eslint/no-empty-function
+	await client.createDirectory(uploadFolder).catch(() => {});
+	await client.putFileContents(`${uploadFolder}/${name}`, buffer, { overwrite: false });
+};

apps/meteor/server/bridges/webdav/lib/webdavClientAdapter.ts

@@ -0,0 +1,91 @@
+import stream from 'node:stream';
+import type { Readable, Writable } from 'node:stream';
+
+import type { WebDAVClient, FileStat, ResponseDataDetailed, WebDAVClientOptions } from 'webdav';
+import { createClient } from 'webdav';
+
+export class WebdavClientAdapter {
+	_client: WebDAVClient;
+
+	constructor(serverConfig: string, cred: WebDAVClientOptions) {
+		if (cred.token) {
+			this._client = createClient(serverConfig, { token: cred.token });
+		} else {
+			this._client = createClient(serverConfig, {
+				username: cred.username,
+				password: cred.password,
+			});
+		}
+	}
+
+	async stat(path: string): Promise<FileStat | ResponseDataDetailed<FileStat>> {
+		try {
+			return await this._client.stat(path);
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ? error.response.statusText : 'Error checking if directory exists on webdav');
+		}
+	}
+
+	async createDirectory(path: string): Promise<void> {
+		try {
+			return await this._client.createDirectory(path);
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ? error.response.statusText : 'Error creating directory on webdav');
+		}
+	}
+
+	async deleteFile(path: string): Promise<void> {
+		try {
+			return await this._client.deleteFile(path);
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ? error.response.statusText : 'Error deleting file on webdav');
+		}
+	}
+
+	async getFileContents(filename: string): Promise<Buffer> {
+		try {
+			return (await this._client.getFileContents(filename)) as Buffer;
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ? error.response.statusText : 'Error getting file contents webdav');
+		}
+	}
+
+	async getDirectoryContents(path: string): Promise<FileStat[] | ResponseDataDetailed<FileStat[]>> {
+		try {
+			return await this._client.getDirectoryContents(path);
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ? error.response.statusText : 'Error getting directory contents webdav');
+		}
+	}
+
+	async putFileContents(path: string, data: Buffer, options: Record<string, any> = {}): Promise<any> {
+		try {
+			return await this._client.putFileContents(path, data, options);
+		} catch (error: any) {
+			throw new Error(error.response?.statusText ?? 'Error updating file contents.');
+		}
+	}
+
+	createReadStream(path: string, options?: Record<string, any>): Readable {
+		return this._client.createReadStream(path, options);
+	}
+
+	createWriteStream(path: string, fileSize: number): Writable {
+		const ws = new stream.PassThrough();
+
+		this._client
+			.customRequest(path, {
+				method: 'PUT',
+				headers: {
+					...(fileSize ? { 'Content-Length': String(fileSize) } : {}),
+				},
+				data: ws,
+				maxRedirects: 0,
+			})
+			.catch((err) => {
+				ws.emit('error', err);
+			});
+
+		return ws;
+	}
+}

apps/meteor/server/bridges/webdav/methods/addWebdavAccount.ts

@@ -0,0 +1,153 @@
+import { api } from '@rocket.chat/core-services';
+import type { IWebdavAccountPayload } from '@rocket.chat/core-typings';
+import type { ServerMethods } from '@rocket.chat/ddp-client';
+import { WebdavAccounts } from '@rocket.chat/models';
+import { Match, check } from 'meteor/check';
+import { Meteor } from 'meteor/meteor';
+
+import { settings } from '../../../settings';
+import { WebdavClientAdapter } from '../lib/webdavClientAdapter';
+
+declare module '@rocket.chat/ddp-client' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface ServerMethods {
+		addWebdavAccount(formData: IWebdavAccountPayload): boolean;
+		addWebdavAccountByToken(data: IWebdavAccountPayload): boolean;
+	}
+}
+
+export const addWebdavAccountByToken = async (userId: string, data: IWebdavAccountPayload): Promise<boolean> => {
+	if (!userId) {
+		throw new Meteor.Error('error-invalid-user', 'Invalid User', { method: 'addWebdavAccount' });
+	}
+
+	if (!settings.get('Webdav_Integration_Enabled')) {
+		throw new Meteor.Error('error-not-allowed', 'WebDAV Integration Not Allowed', {
+			method: 'addWebdavAccount',
+		});
+	}
+
+	check(
+		data,
+		Match.ObjectIncluding({
+			serverURL: String,
+			token: Match.ObjectIncluding({
+				access_token: String,
+				token_type: String,
+				refresh_token: Match.Optional(String),
+			}),
+			name: Match.Maybe(String),
+		}),
+	);
+
+	try {
+		const client = new WebdavClientAdapter(data.serverURL, { token: data.token });
+
+		const accountData = {
+			userId,
+			serverURL: data.serverURL,
+			token: data.token,
+			name: data.name ?? '',
+		};
+
+		await client.stat('/');
+		await WebdavAccounts.updateOne(
+			{
+				userId,
+				serverURL: data.serverURL,
+				name: data.name ?? '',
+			},
+			{
+				$set: accountData,
+			},
+			{
+				upsert: true,
+			},
+		);
+		void api.broadcast('notify.webdav', userId, {
+			type: 'changed',
+			account: accountData,
+		});
+	} catch (error) {
+		throw new Meteor.Error('could-not-access-webdav', 'Could not access webdav', {
+			method: 'addWebdavAccount',
+		});
+	}
+
+	return true;
+};
+
+Meteor.methods<ServerMethods>({
+	async addWebdavAccount(formData) {
+		const userId = Meteor.userId();
+
+		if (!userId) {
+			throw new Meteor.Error('error-invalid-user', 'Invalid User', { method: 'addWebdavAccount' });
+		}
+
+		if (!settings.get('Webdav_Integration_Enabled')) {
+			throw new Meteor.Error('error-not-allowed', 'WebDAV Integration Not Allowed', {
+				method: 'addWebdavAccount',
+			});
+		}
+
+		check(
+			formData,
+			Match.ObjectIncluding({
+				serverURL: String,
+				username: String,
+				password: String,
+				name: Match.Maybe(String),
+			}),
+		);
+
+		const duplicateAccount = await WebdavAccounts.findOneByUserIdServerUrlAndUsername(
+			{ userId, serverURL: formData.serverURL, username: formData.username },
+			{},
+		);
+
+		if (duplicateAccount !== null) {
+			throw new Meteor.Error('duplicated-account', 'Account not found', {
+				method: 'addWebdavAccount',
+			});
+		}
+
+		try {
+			const client = new WebdavClientAdapter(formData.serverURL, {
+				username: formData.username,
+				password: formData.password,
+			});
+
+			const accountData = {
+				userId,
+				serverURL: formData.serverURL,
+				username: formData.username,
+				password: formData.password,
+				name: formData.name ?? '',
+			};
+
+			await client.stat('/');
+			await WebdavAccounts.insertOne(accountData);
+
+			void api.broadcast('notify.webdav', userId, {
+				type: 'changed',
+				account: accountData,
+			});
+		} catch (error) {
+			throw new Meteor.Error('could-not-access-webdav', 'Could not access webdav', {
+				method: 'addWebdavAccount',
+			});
+		}
+		return true;
+	},
+
+	async addWebdavAccountByToken(data) {
+		const userId = Meteor.userId();
+
+		if (!userId) {
+			throw new Meteor.Error('error-invalid-user', 'Invalid User', { method: 'addWebdavAccount' });
+		}
+
+		return addWebdavAccountByToken(userId, data);
+	},
+});

apps/meteor/server/bridges/webdav/methods/getFileFromWebdav.ts

@@ -0,0 +1,49 @@
+import type { IWebdavAccount, IWebdavNode } from '@rocket.chat/core-typings';
+import type { ServerMethods } from '@rocket.chat/ddp-client';
+import { WebdavAccounts } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+
+import { settings } from '../../../settings';
+import { getWebdavCredentials } from '../lib/getWebdavCredentials';
+import { WebdavClientAdapter } from '../lib/webdavClientAdapter';
+
+declare module '@rocket.chat/ddp-client' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface ServerMethods {
+		getFileFromWebdav(accountId: IWebdavAccount['_id'], file: IWebdavNode): Promise<{ success: boolean; data: Uint8Array<ArrayBuffer> }>;
+	}
+}
+
+Meteor.methods<ServerMethods>({
+	async getFileFromWebdav(accountId, file) {
+		const userId = Meteor.userId();
+
+		if (!userId) {
+			throw new Meteor.Error('error-invalid-user', 'Invalid User', { method: 'getFileFromWebdav' });
+		}
+		if (!settings.get('Webdav_Integration_Enabled')) {
+			throw new Meteor.Error('error-not-allowed', 'WebDAV Integration Not Allowed', {
+				method: 'getFileFromWebdav',
+			});
+		}
+
+		const account = await WebdavAccounts.findOneByIdAndUserId(accountId, userId, {});
+		if (!account) {
+			throw new Meteor.Error('error-invalid-account', 'Invalid WebDAV Account', {
+				method: 'getFileFromWebdav',
+			});
+		}
+
+		try {
+			const cred = getWebdavCredentials(account);
+			const client = new WebdavClientAdapter(account.serverURL, cred);
+			const fileContent = await client.getFileContents(file.filename);
+			const data = new Uint8Array(fileContent);
+			return { success: true, data };
+		} catch (error) {
+			throw new Meteor.Error('unable-to-get-file', 'Unable to get file', {
+				method: 'getFileFromWebdav',
+			});
+		}
+	},
+});

apps/meteor/server/bridges/webdav/methods/getWebdavFileList.ts

@@ -0,0 +1,49 @@
+import type { IWebdavAccount, IWebdavNode } from '@rocket.chat/core-typings';
+import type { ServerMethods } from '@rocket.chat/ddp-client';
+import { WebdavAccounts } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+
+import { settings } from '../../../settings';
+import { getWebdavCredentials } from '../lib/getWebdavCredentials';
+import { WebdavClientAdapter } from '../lib/webdavClientAdapter';
+
+declare module '@rocket.chat/ddp-client' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface ServerMethods {
+		getWebdavFileList(accountId: IWebdavAccount['_id'], path: string): { success: boolean; data: IWebdavNode[] };
+	}
+}
+
+Meteor.methods<ServerMethods>({
+	async getWebdavFileList(accountId, path) {
+		const userId = Meteor.userId();
+
+		if (!userId) {
+			throw new Meteor.Error('error-invalid-user', 'Invalid User', { method: 'getWebdavFileList' });
+		}
+
+		if (!settings.get('Webdav_Integration_Enabled')) {
+			throw new Meteor.Error('error-not-allowed', 'WebDAV Integration Not Allowed', {
+				method: 'getWebdavFileList',
+			});
+		}
+
+		const account = await WebdavAccounts.findOneByIdAndUserId(accountId, userId, {});
+		if (!account) {
+			throw new Meteor.Error('error-invalid-account', 'Invalid WebDAV Account', {
+				method: 'getWebdavFileList',
+			});
+		}
+
+		try {
+			const cred = getWebdavCredentials(account);
+			const client = new WebdavClientAdapter(account.serverURL, cred);
+			const data = (await client.getDirectoryContents(path)) as IWebdavNode[];
+			return { success: true, data };
+		} catch (error) {
+			throw new Meteor.Error('could-not-access-webdav', 'Could not access webdav', {
+				method: 'getWebdavFileList',
+			});
+		}
+	},
+});

apps/meteor/server/bridges/webdav/methods/getWebdavFilePreview.ts

@@ -0,0 +1,53 @@
+import type { IWebdavAccount } from '@rocket.chat/core-typings';
+import type { ServerMethods } from '@rocket.chat/ddp-client';
+import { WebdavAccounts } from '@rocket.chat/models';
+import { Meteor } from 'meteor/meteor';
+import { createClient } from 'webdav';
+
+import { settings } from '../../../settings';
+import { getWebdavCredentials } from '../lib/getWebdavCredentials';
+
+declare module '@rocket.chat/ddp-client' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface ServerMethods {
+		getWebdavFilePreview(accountId: IWebdavAccount['_id'], path: string): { success: true; data: ArrayBuffer } | undefined;
+	}
+}
+
+Meteor.methods<ServerMethods>({
+	async getWebdavFilePreview(accountId, path) {
+		const userId = Meteor.userId();
+
+		if (!userId) {
+			throw new Meteor.Error('error-invalid-user', 'Invalid User', {
+				method: 'getWebdavFilePreview',
+			});
+		}
+
+		if (!settings.get('Webdav_Integration_Enabled') || !settings.get('Accounts_OAuth_Nextcloud_URL')) {
+			throw new Meteor.Error('error-not-allowed', 'WebDAV Integration Not Allowed', {
+				method: 'getWebdavFilePreview',
+			});
+		}
+
+		const account = await WebdavAccounts.findOneByIdAndUserId(accountId, userId, {});
+		if (!account) {
+			throw new Meteor.Error('error-invalid-account', 'Invalid WebDAV Account', {
+				method: 'getWebdavFilePreview',
+			});
+		}
+
+		try {
+			const cred = getWebdavCredentials(account);
+			const client = createClient(account.serverURL, cred);
+			const serverURL = settings.get('Accounts_OAuth_Nextcloud_URL');
+			const res = await client.customRequest(`${serverURL}/index.php/core/preview.png?file=${path}&x=64&y=64`, {
+				method: 'GET',
+				responseType: 'arraybuffer',
+			});
+			return { success: true, data: res.data as ArrayBuffer };
+		} catch (error) {
+			// ignore error
+		}
+	},
+});

apps/meteor/server/bridges/webdav/methods/uploadFileToWebdav.ts

@@ -0,0 +1,65 @@
+import { MeteorError } from '@rocket.chat/core-services';
+import type { IWebdavAccount } from '@rocket.chat/core-typings';
+import type { ServerMethods } from '@rocket.chat/ddp-client';
+import { Logger } from '@rocket.chat/logger';
+import type { TranslationKey } from '@rocket.chat/ui-contexts';
+import { Meteor } from 'meteor/meteor';
+
+import { settings } from '../../../settings';
+import { uploadFileToWebdav } from '../lib/uploadFileToWebdav';
+
+const logger = new Logger('WebDAV_Upload');
+
+declare module '@rocket.chat/ddp-client' {
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	interface ServerMethods {
+		uploadFileToWebdav(
+			accountId: IWebdavAccount['_id'],
+			fileData: string | Buffer | ArrayBuffer,
+			name: string,
+		): { success: boolean; message?: TranslationKey };
+	}
+}
+
+Meteor.methods<ServerMethods>({
+	async uploadFileToWebdav(accountId, fileData, name) {
+		if (!Meteor.userId()) {
+			throw new MeteorError('error-invalid-user', 'Invalid User', {
+				method: 'uploadFileToWebdav',
+			});
+		}
+
+		if (!settings.get('Webdav_Integration_Enabled')) {
+			throw new MeteorError('error-not-allowed', 'WebDAV Integration Not Allowed', {
+				method: 'uploadFileToWebdav',
+			});
+		}
+
+		try {
+			await uploadFileToWebdav(accountId, fileData instanceof ArrayBuffer ? Buffer.from(fileData) : fileData, name);
+			return { success: true };
+		} catch (err: any) {
+			if (typeof err === 'object' && err instanceof Error && err.name === 'error-invalid-account') {
+				throw new MeteorError(err.name, 'Invalid WebDAV Account', {
+					method: 'uploadFileToWebdav',
+				});
+			}
+
+			logger.error({ err });
+
+			if (err.response) {
+				const { status } = err.response;
+				if (status === 404) {
+					return { success: false, message: 'webdav-server-not-found' };
+				}
+				if (status === 401) {
+					return { success: false, message: 'error-invalid-account' };
+				}
+				if (status === 412) {
+					return { success: false, message: 'Duplicate_file_name_found' };
+				}
+			}
+			return { success: false, message: 'FileUpload_Error' };
+		}
+	},
+});