@internxt/cli 1.6.7 → 1.6.9

package/dist/utils/errors.utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
+exports.RangeNotSatisfiableError = exports.PreconditionFailedError = exports.NotImplementedError = exports.MethodNotAllowed = exports.UnsupportedMediaTypeError = exports.BadRequestError = exports.NotFoundError = exports.ConflictError = exports.ErrorUtils = void 0;
 const logger_utils_1 = require("./logger.utils");
 class ErrorUtils {
     static isError = (error) => {
@@ -80,3 +80,21 @@ class NotImplementedError extends Error {
     }
 }
 exports.NotImplementedError = NotImplementedError;
+class PreconditionFailedError extends Error {
+    statusCode = 412;
+    constructor(message) {
+        super(message);
+        this.name = 'PreconditionFailedError';
+        Object.setPrototypeOf(this, PreconditionFailedError.prototype);
+    }
+}
+exports.PreconditionFailedError = PreconditionFailedError;
+class RangeNotSatisfiableError extends Error {
+    statusCode = 416;
+    constructor(message) {
+        super(message);
+        this.name = 'RangeNotSatisfiableError';
+        Object.setPrototypeOf(this, RangeNotSatisfiableError.prototype);
+    }
+}
+exports.RangeNotSatisfiableError = RangeNotSatisfiableError;

package/dist/utils/logger.utils.js

@@ -4,14 +4,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.webdavLogger = exports.logger = void 0;
+const node_os_1 = __importDefault(require("node:os"));
 const winston_1 = __importDefault(require("winston"));
 const configs_1 = require("../constants/configs");
+const package_json_1 = __importDefault(require("../../package.json"));
 const maxLogSize = 40 * 1024 * 1024;
 const maxLogsFiles = 5;
+const environmentMeta = {
+    version: package_json_1.default.version,
+    os: `${node_os_1.default.platform()} ${node_os_1.default.release()} (${node_os_1.default.arch()})`,
+    node: process.version,
+};
 exports.logger = winston_1.default.createLogger({
     level: 'info',
     format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
-    defaultMeta: { service: 'internxt-cli' },
+    defaultMeta: { service: 'internxt-cli', ...environmentMeta },
     transports: [
         new winston_1.default.transports.File({
             filename: 'internxt-cli-error.log',
@@ -33,7 +40,7 @@ exports.logger = winston_1.default.createLogger({
 exports.webdavLogger = winston_1.default.createLogger({
     level: 'info',
     format: winston_1.default.format.combine(winston_1.default.format.timestamp(), winston_1.default.format.json()),
-    defaultMeta: { service: 'internxt-webdav' },
+    defaultMeta: { service: 'internxt-webdav', ...environmentMeta },
     transports: [
         new winston_1.default.transports.File({
             filename: 'internxt-webdav-error.log',

package/dist/utils/network.utils.js

@@ -10,6 +10,7 @@ const node_path_1 = __importDefault(require("node:path"));
 const selfsigned_1 = __importDefault(require("selfsigned"));
 const range_parser_1 = __importDefault(require("range-parser"));
 const configs_1 = require("../constants/configs");
+const errors_utils_1 = require("./errors.utils");
 class NetworkUtils {
     static getAuthFromCredentials(creds) {
         return {
@@ -81,10 +82,10 @@ class NetworkUtils {
         const parsed = (0, range_parser_1.default)(rangeOptions.totalFileSize, rangeOptions.range);
         if (Array.isArray(parsed)) {
             if (parsed.length > 1) {
-                throw new Error(`Multi Range-Requests functionality is not implemented. ${JSON.stringify(rangeOptions)}`);
+                throw new errors_utils_1.BadRequestError(`Multi Range-Requests functionality is not implemented. ${JSON.stringify(rangeOptions)}`);
             }
             else if (parsed.length <= 0) {
-                throw new Error(`Empty Range-Request. ${JSON.stringify(rangeOptions)}`);
+                throw new errors_utils_1.RangeNotSatisfiableError(`Empty Range-Request. ${JSON.stringify(rangeOptions)}`);
             }
             if (parsed.type === 'bytes') {
                 const rangeSize = parsed[0].end - parsed[0].start + 1;
@@ -96,17 +97,17 @@ class NetworkUtils {
                 };
             }
             else {
-                throw new Error(`Unkwnown Range-Request type "${parsed.type}". ${JSON.stringify(rangeOptions)}`);
+                throw new errors_utils_1.BadRequestError(`Unkwnown Range-Request type "${parsed.type}". ${JSON.stringify(rangeOptions)}`);
             }
         }
         else if (parsed === -1) {
-            throw new Error(`Unsatisfiable Range-Request. ${JSON.stringify(rangeOptions)}`);
+            throw new errors_utils_1.RangeNotSatisfiableError(`Unsatisfiable Range-Request. ${JSON.stringify(rangeOptions)}`);
         }
         else if (parsed === -2) {
-            throw new Error(`Malformed Range-Request. ${JSON.stringify(rangeOptions)}`);
+            throw new errors_utils_1.BadRequestError(`Malformed Range-Request. ${JSON.stringify(rangeOptions)}`);
         }
         else {
-            throw new Error(`Unknown error from Range-Request. ${JSON.stringify(rangeOptions)}`);
+            throw new errors_utils_1.BadRequestError(`Unknown error from Range-Request. ${JSON.stringify(rangeOptions)}`);
         }
     }
 }

package/dist/utils/stream.utils.d.ts

@@ -6,10 +6,10 @@ export declare class StreamUtils {
     static joinReadableBinaryStreams(streams: ReadableStream<Uint8Array>[]): ReadableStream<Uint8Array>;
 }
 export declare class BufferStream extends Transform {
-    buffer: Buffer | null;
+    private chunks;
     constructor(opts?: TransformOptions);
     _transform(chunk: Buffer, _: BufferEncoding, callback: TransformCallback): void;
     _flush(callback: TransformCallback): void;
     reset(): void;
-    getBuffer(): Buffer | null;
+    getBuffer(): Buffer | undefined;
 }

package/dist/utils/stream.utils.js

@@ -56,24 +56,25 @@ class StreamUtils {
 }
 exports.StreamUtils = StreamUtils;
 class BufferStream extends node_stream_1.Transform {
-    buffer;
+    chunks;
     constructor(opts) {
         super(opts);
-        this.buffer = null;
+        this.chunks = [];
     }
     _transform(chunk, _, callback) {
-        const currentBuffer = this.buffer ?? Buffer.alloc(0);
-        this.buffer = Buffer.concat([currentBuffer, chunk]);
+        this.chunks.push(chunk);
         callback(null, chunk);
     }
     _flush(callback) {
         callback();
     }
     reset() {
-        this.buffer = null;
+        this.chunks = [];
     }
     getBuffer() {
-        return this.buffer;
+        if (this.chunks.length === 0)
+            return undefined;
+        return Buffer.concat(this.chunks);
     }
 }
 exports.BufferStream = BufferStream;

package/dist/utils/thumbnail.utils.d.ts

@@ -5,8 +5,6 @@ export declare const ThumbnailConfig: {
     readonly Type: "png";
 };
 export declare class ThumbnailUtils {
-    static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB: number;
-    static readonly isFileThumbnailable: (fileType: string) => boolean;
-    static readonly isPDFThumbnailable: (fileType: string) => boolean;
+    static readonly MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES: number;
     static readonly isImageThumbnailable: (fileType: string, size: number) => boolean;
 }

package/dist/utils/thumbnail.utils.js

@@ -18,9 +18,6 @@ const imageExtensions = {
     raw: ['raw', 'cr2', 'nef', 'orf', 'sr2'],
     webp: ['webp'],
 };
-const pdfExtensions = {
-    pdf: ['pdf'],
-};
 const thumbnailableImageExtension = new Set([
     ...imageExtensions['jpg'],
     ...imageExtensions['png'],
@@ -28,19 +25,12 @@ const thumbnailableImageExtension = new Set([
     ...imageExtensions['gif'],
     ...imageExtensions['tiff'],
 ]);
-const thumbnailablePdfExtension = new Set(pdfExtensions['pdf']);
-const thumbnailableExtension = new Set(thumbnailableImageExtension);
 class ThumbnailUtils {
-    static MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB = 500 * 1024 * 1024;
-    static isFileThumbnailable = (fileType) => {
-        return fileType.trim().length > 0 && thumbnailableExtension.has(fileType.trim().toLowerCase());
-    };
-    static isPDFThumbnailable = (fileType) => {
-        return fileType.trim().length > 0 && thumbnailablePdfExtension.has(fileType.trim().toLowerCase());
-    };
+    static MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES = 128 * 1024 * 1024;
     static isImageThumbnailable = (fileType, size) => {
-        if (size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_MB)
+        if (size <= 0 || size > ThumbnailUtils.MAX_IMAGE_THUMBNAILABLE_SIZE_IN_BYTES) {
             return false;
+        }
         return fileType.trim().length > 0 && thumbnailableImageExtension.has(fileType.trim().toLowerCase());
     };
 }

package/dist/utils/upload.utils.d.ts

@@ -2,7 +2,7 @@ import { Readable } from 'node:stream';
 import { BufferStream } from './stream.utils';
 export declare class UploadUtils {
     static readonly checkUploadSizeLimits: (size: number) => Promise<void>;
-    static readonly prepareUploadStreams: (readable: Readable, fileType: string) => {
+    static readonly prepareUploadStreams: (readable: Readable, fileType: string, size: number) => {
         fileStream: Readable;
         thumbnailStream: BufferStream | undefined;
         isThumbnailable: boolean;

package/dist/utils/upload.utils.js

@@ -19,8 +19,8 @@ class UploadUtils {
             throw new Error('File is too big (more than 100 GB)');
         }
     };
-    static prepareUploadStreams = (readable, fileType) => {
-        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isFileThumbnailable(fileType);
+    static prepareUploadStreams = (readable, fileType, size) => {
+        const isThumbnailable = thumbnail_utils_1.ThumbnailUtils.isImageThumbnailable(fileType, size);
         if (!isThumbnailable) {
             return { fileStream: readable, thumbnailStream: undefined, isThumbnailable };
         }

package/dist/utils/webdav.utils.d.ts

@@ -13,4 +13,6 @@ export declare class WebDavUtils {
         itemType: 'file' | 'folder';
         uuid: string;
     }>(driveItem: T): Promise<void>;
+    static generateETag(parts: Array<string | number | null | undefined>): string;
+    static getItemETag(driveItem: DriveFileItem | DriveFolderItem): string;
 }

package/dist/utils/webdav.utils.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebDavUtils = void 0;
 const node_path_1 = __importDefault(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 const drive_item_service_1 = require("../services/drive/drive-item.service");
 const logger_utils_1 = require("./logger.utils");
 const config_service_1 = require("../services/config.service");
@@ -100,5 +101,20 @@ class WebDavUtils {
         }
         await drive_item_repository_1.DriveItemRepository.instance.delete([driveItem.uuid]);
     }
+    static generateETag(parts) {
+        const normalized = parts.map((part) => part ?? '-');
+        const hash = (0, node_crypto_1.createHash)('sha256').update(normalized.join('|')).digest('hex');
+        return `"${hash}"`;
+    }
+    static getItemETag(driveItem) {
+        return this.generateETag([
+            driveItem.uuid,
+            driveItem.itemType === 'file' ? driveItem.size : undefined,
+            driveItem.createdAt.getTime(),
+            driveItem.updatedAt.getTime(),
+            driveItem.creationTime.getTime(),
+            driveItem.modificationTime.getTime(),
+        ]);
+    }
 }
 exports.WebDavUtils = WebDavUtils;

package/dist/webdav/handlers/DELETE.handler.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
-const drive_item_repository_1 = require("../../services/database/drive-item/drive-item.repository");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
@@ -14,7 +13,6 @@ class DELETERequestHandler {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
         await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveItem);
-        await drive_item_repository_1.DriveItemRepository.instance.delete([driveItem.uuid]);
         res.status(204).send();
     };
 }

package/dist/webdav/handlers/GET.handler.js

@@ -21,17 +21,28 @@ class GETRequestHandler {
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);
         res.header('Content-Type', 'application/octet-stream');
         res.header('Accept-Ranges', 'bytes');
+        res.header('ETag', webdav_utils_1.WebDavUtils.getItemETag(driveFile));
         const fileSize = driveFile.size ?? 0;
         if (fileSize > 0) {
             const range = req.headers['range'];
-            const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
-                range,
-                totalFileSize: fileSize,
-            });
+            let rangeOptions;
+            try {
+                rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+                    range,
+                    totalFileSize: fileSize,
+                });
+            }
+            catch (error) {
+                if (error instanceof errors_utils_1.RangeNotSatisfiableError) {
+                    res.header('Content-Range', `bytes */${fileSize}`);
+                }
+                throw error;
+            }
             let contentLength = fileSize;
             if (rangeOptions) {
                 logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Range request received:`, { rangeOptions });
                 contentLength = rangeOptions.rangeSize;
+                res.header('Content-Range', `bytes ${rangeOptions.parsed.start}-${rangeOptions.parsed.end}/${fileSize}`);
             }
             res.header('Content-length', contentLength.toString());
             const writable = new WritableStream({
@@ -45,10 +56,10 @@ class GETRequestHandler {
             if (!driveFile.fileId) {
                 throw new command_types_1.NotValidFileIdError();
             }
-            const { networkFacade, bucket, mnemonic } = await cli_utils_1.CLIUtils.prepareNetwork(user);
-            const [executeDownload] = await networkFacade.downloadToStream(bucket, mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
+            const { networkFacade, mnemonic } = await cli_utils_1.CLIUtils.prepareNetwork(user);
+            const [executeDownload] = await networkFacade.downloadToStream(driveFile.bucket, mnemonic, driveFile.fileId, contentLength, writable, rangeOptions);
             logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Download prepared, executing...`);
-            res.status(200);
+            res.status(rangeOptions ? 206 : 200);
             await executeDownload;
             logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] ✅ Download ready, replying to client`);
         }

package/dist/webdav/handlers/HEAD.handler.js

@@ -14,22 +14,33 @@ class HEADRequestHandler {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
         logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Found Drive item`);
+        res.header('ETag', webdav_utils_1.WebDavUtils.getItemETag(driveItem));
+        let rangeOptions;
         if (driveItem.itemType === 'file') {
             const range = req.headers['range'];
-            const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
-                range,
-                totalFileSize: driveItem.size,
-            });
+            try {
+                rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+                    range,
+                    totalFileSize: driveItem.size,
+                });
+            }
+            catch (error) {
+                if (error instanceof errors_utils_1.RangeNotSatisfiableError) {
+                    res.header('Content-Range', `bytes */${driveItem.size}`);
+                }
+                throw error;
+            }
             let contentLength = driveItem.size;
+            res.header('Content-Type', 'application/octet-stream');
+            res.header('Accept-Ranges', 'bytes');
             if (rangeOptions) {
                 logger_utils_1.webdavLogger.info(`[HEAD] [${driveItem.uuid}] Range request received:`, { rangeOptions });
                 contentLength = rangeOptions.rangeSize;
+                res.header('Content-Range', `bytes ${rangeOptions.parsed.start}-${rangeOptions.parsed.end}/${driveItem.size}`);
             }
-            res.header('Content-Type', 'application/octet-stream');
-            res.header('Accept-Ranges', 'bytes');
             res.header('Content-length', contentLength.toString());
         }
-        res.status(200).send();
+        res.status(rangeOptions ? 206 : 200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

package/dist/webdav/handlers/LOCK.handler.js

@@ -4,6 +4,7 @@ exports.LOCKRequestHandler = void 0;
 const node_crypto_1 = require("node:crypto");
 const logger_utils_1 = require("../../utils/logger.utils");
 const xml_utils_1 = require("../../utils/xml.utils");
+const webdav_utils_1 = require("../../utils/webdav.utils");
 const LOCK_TIMEOUT_SECONDS = 300;
 class LOCKRequestHandler {
     handle = async (req, res) => {
@@ -42,9 +43,12 @@ class LOCKRequestHandler {
                 },
             },
         }, { suppressEmptyNode: true }, 'prop');
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
+        const statusCode = driveItem ? 200 : 201;
         res.set('Lock-Token', `<${lockToken}>`);
         res.set('Content-Type', 'application/xml; charset="utf-8"');
-        res.status(200).send(lockDiscoveryXml);
+        res.status(statusCode).send(lockDiscoveryXml);
     };
 }
 exports.LOCKRequestHandler = LOCKRequestHandler;

package/dist/webdav/handlers/MOVE.handler.js

@@ -23,6 +23,17 @@ class MOVERequestHandler {
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
+        let isOverwrite = false;
+        const destinationDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(destinationResource);
+        if (destinationDriveItem && destinationDriveItem.uuid !== originalDriveItem.uuid) {
+            const overwrite = (req.header('overwrite') ?? 'T').toUpperCase();
+            if (overwrite === 'F') {
+                throw new errors_utils_1.PreconditionFailedError(`Destination '${destinationResource.url}' already exists`);
+            }
+            isOverwrite = true;
+            logger_utils_1.webdavLogger.info(`[MOVE] Destination '${destinationResource.url}' already exists, overwriting it`);
+            await webdav_utils_1.WebDavUtils.deleteOrTrashItem(destinationDriveItem);
+        }
         if (destinationResource.path.dir === resource.path.dir) {
             logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${originalDriveItem.itemType}
         with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
@@ -75,7 +86,8 @@ class MOVERequestHandler {
                 updatedAt: new Date(),
             },
         ]);
-        res.status(204).send();
+        const statusCode = isOverwrite ? 204 : 201;
+        res.status(statusCode).send();
     };
 }
 exports.MOVERequestHandler = MOVERequestHandler;

package/dist/webdav/handlers/OPTIONS.handler.js

@@ -8,21 +8,21 @@ class OPTIONSRequestHandler {
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[OPTIONS] Request received for item at ${resource.url}`);
         if (resource.url === '/' || resource.url === '') {
-            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, PUT, UNLOCK';
+            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, PROPPATCH, PUT, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
         else if (resource.url.endsWith('/')) {
-            const allowedMethods = 'DELETE, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, UNLOCK';
+            const allowedMethods = 'DELETE, HEAD, LOCK, MKCOL, MOVE, OPTIONS, PROPFIND, PROPPATCH, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
         else {
-            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MOVE, OPTIONS, PROPFIND, PUT, UNLOCK';
+            const allowedMethods = 'DELETE, GET, HEAD, LOCK, MOVE, OPTIONS, PROPFIND, PROPPATCH, PUT, UNLOCK';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);
             res.header('DAV', '1, 2, ordered-collections');

package/dist/webdav/handlers/PROPFIND.handler.js

@@ -10,19 +10,18 @@ const drive_item_repository_1 = require("../../services/database/drive-item/driv
 const drive_folder_service_1 = require("../../services/drive/drive-folder.service");
 const drive_utils_1 = require("../../utils/drive.utils");
 const format_utils_1 = require("../../utils/format.utils");
-const node_crypto_1 = require("node:crypto");
 const mime_types_1 = __importDefault(require("mime-types"));
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const usage_service_1 = require("../../services/usage.service");
+const errors_utils_1 = require("../../utils/errors.utils");
 class PROPFINDRequestHandler {
     handle = async (req, res) => {
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         logger_utils_1.webdavLogger.info(`[PROPFIND] Request received for item at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
         if (!driveItem) {
-            res.status(404).send();
-            return;
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
         res.set('Content-Type', 'application/xml; charset="utf-8"');
         switch (driveItem.itemType) {
@@ -143,7 +142,7 @@ class PROPFINDRequestHandler {
                 [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
                 [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: 'httpd/unix-directory',
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: '"' + (0, node_crypto_1.randomUUID)().replaceAll('-', '') + '"',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: webdav_utils_1.WebDavUtils.getItemETag(driveFolderItem),
                     'x1:lastmodified': {
                         '#text': format_utils_1.FormatUtils.formatDateForWebDav(driveFolderItem.updatedAt),
                         '@_xmlns:x1': 'SAR:',
@@ -177,7 +176,7 @@ class PROPFINDRequestHandler {
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: format_utils_1.FormatUtils.formatDateForWebDav(driveFolderItem.updatedAt),
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontentlength')]: 0,
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: 'httpd/unix-directory',
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: '"' + (0, node_crypto_1.randomUUID)().replaceAll('-', '') + '"',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: webdav_utils_1.WebDavUtils.getItemETag(driveFolderItem),
                     [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: {
                         [xml_utils_1.XMLUtils.addDefaultNamespace('collection')]: '',
                     },
@@ -195,7 +194,7 @@ class PROPFINDRequestHandler {
                 [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 200 OK',
                 [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {
                     [xml_utils_1.XMLUtils.addDefaultNamespace('resourcetype')]: '',
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: '"' + (0, node_crypto_1.randomUUID)().replaceAll('-', '') + '"',
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('getetag')]: webdav_utils_1.WebDavUtils.getItemETag(driveFileItem),
                     [xml_utils_1.XMLUtils.addDefaultNamespace('displayname')]: displayName,
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getcontenttype')]: mime_types_1.default.lookup(displayName) || 'application/octet-stream',
                     [xml_utils_1.XMLUtils.addDefaultNamespace('getlastmodified')]: lastModified,

package/dist/webdav/handlers/PROPPATCH.handler.d.ts

@@ -1,4 +1,6 @@
+import { Request, Response } from 'express';
 import { WebDavMethodHandler } from '../../types/webdav.types';
 export declare class PROPPATCHRequestHandler implements WebDavMethodHandler {
-    handle(): Promise<void>;
+    handle: (req: Request, res: Response) => Promise<void>;
+    private readonly getRequestedPropertyNames;
 }

package/dist/webdav/handlers/PROPPATCH.handler.js

@@ -1,10 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PROPPATCHRequestHandler = void 0;
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
+const xml_utils_1 = require("../../utils/xml.utils");
 const errors_utils_1 = require("../../utils/errors.utils");
 class PROPPATCHRequestHandler {
-    async handle() {
-        throw new errors_utils_1.NotImplementedError('PROPPATCH is not implemented yet.');
-    }
+    handle = async (req, res) => {
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[PROPPATCH] Request received for item at ${resource.url}`);
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource(resource);
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
+        const propertyNames = this.getRequestedPropertyNames(req.body);
+        const propNode = Object.fromEntries(propertyNames.map((name) => [name, '']));
+        const responseXML = xml_utils_1.XMLUtils.toWebDavXML({
+            [xml_utils_1.XMLUtils.addDefaultNamespace('response')]: {
+                [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(resource.url),
+                [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: propNode,
+                    [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 403 Forbidden',
+                },
+            },
+        }, { suppressEmptyNode: true });
+        res.set('Content-Type', 'application/xml; charset="utf-8"');
+        res.status(207).send(responseXML);
+    };
+    getRequestedPropertyNames = (body) => {
+        if (typeof body !== 'string' || body.trim().length === 0) {
+            return [];
+        }
+        try {
+            const parsed = xml_utils_1.XMLUtils.toJSON(body, { ignoreAttributes: false });
+            const propertyUpdate = parsed?.['D:propertyupdate'] ?? parsed?.propertyupdate;
+            const sections = [
+                propertyUpdate?.['D:set'] ?? propertyUpdate?.set,
+                propertyUpdate?.['D:remove'] ?? propertyUpdate?.remove,
+            ];
+            const names = new Set();
+            for (const section of sections) {
+                const prop = section?.['D:prop'] ?? section?.prop;
+                if (prop && typeof prop === 'object') {
+                    for (const key of Object.keys(prop)) {
+                        if (!key.startsWith('@_')) {
+                            names.add(key);
+                        }
+                    }
+                }
+            }
+            return Array.from(names);
+        }
+        catch (error) {
+            logger_utils_1.webdavLogger.warn(`[PROPPATCH] Failed to parse request body: ${error instanceof Error ? error.message : String(error)}`);
+            return [];
+        }
+    };
 }
 exports.PROPPATCHRequestHandler = PROPPATCHRequestHandler;

package/dist/webdav/handlers/PUT.handler.js

@@ -39,16 +39,10 @@ class PUTRequestHandler {
             }
             isReplacement = true;
             logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', it will be replaced...`);
-            try {
-                await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveFileItem);
-                await drive_item_repository_1.DriveItemRepository.instance.delete([driveFileItem.uuid]);
-            }
-            catch {
-            }
         }
         const { user } = await auth_service_1.AuthService.instance.getAuthDetails();
         const fileType = resource.path.ext.replace('.', '');
-        const { fileStream, thumbnailStream } = upload_utils_1.UploadUtils.prepareUploadStreams(req, fileType);
+        const { fileStream, thumbnailStream } = upload_utils_1.UploadUtils.prepareUploadStreams(req, fileType, contentLength);
         const { networkFacade, bucket } = await cli_utils_1.CLIUtils.prepareNetwork(user);
         let fileId;
         if (contentLength > 0) {
@@ -79,7 +73,7 @@ class PUTRequestHandler {
             logger_utils_1.webdavLogger.info('[PUT] ✅ File uploaded to network');
         }
         const driveTimer = cli_utils_1.CLIUtils.timer();
-        const file = await drive_file_service_1.DriveFileService.instance.createFile({
+        const filePayload = {
             plainName: resource.path.name,
             type: fileType,
             size: contentLength,
@@ -87,7 +81,21 @@ class PUTRequestHandler {
             fileId,
             bucket,
             encryptVersion: types_1.EncryptionVersion.Aes03,
-        });
+        };
+        let file;
+        if (driveFileItem?.itemType === 'file') {
+            try {
+                file = await drive_file_service_1.DriveFileService.instance.replaceFile(driveFileItem.uuid, filePayload);
+            }
+            catch (error) {
+                logger_utils_1.webdavLogger.warn(`[PUT] File replace failed for '${resource.url}', falling back to delete and create: ${error instanceof Error ? error.message : String(error)}`);
+                await webdav_utils_1.WebDavUtils.deleteOrTrashItem(driveFileItem);
+                file = await drive_file_service_1.DriveFileService.instance.createFile(filePayload);
+            }
+        }
+        else {
+            file = await drive_file_service_1.DriveFileService.instance.createFile(filePayload);
+        }
         timings.driveUpload = driveTimer.stop();
         await drive_item_repository_1.DriveItemRepository.instance.createOrUpdate([
             {
@@ -101,7 +109,7 @@ class PUTRequestHandler {
         const thumbnailTimer = cli_utils_1.CLIUtils.timer();
         await thumbnail_service_1.ThumbnailService.instance.tryUploadThumbnail({
             fileUuid: file.uuid,
-            bufferStream: thumbnailStream,
+            input: thumbnailStream?.getBuffer(),
             fileType,
             bucket,
             networkFacade,
@@ -115,6 +123,7 @@ class PUTRequestHandler {
         const statusCode = isReplacement ? 204 : 201;
         logger_utils_1.webdavLogger.info(`[PUT] [RESPONSE-${statusCode}] ${resource.url} - Returning ${statusCode} ` +
             `after ${cli_utils_1.CLIUtils.formatDuration(totalTime)}`);
+        res.header('ETag', webdav_utils_1.WebDavUtils.getItemETag(file));
         res.status(statusCode).send();
     };
 }

package/dist/webdav/index.js

@@ -18,8 +18,8 @@ const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtLogsDirExists();
     await database_service_1.DatabaseService.instance.initialize();
     await database_service_1.DatabaseService.instance.clear();
-    const { token, workspace } = await auth_service_1.AuthService.instance.getAuthDetails();
-    sdk_manager_service_1.SdkManager.init({ token, workspaceToken: workspace?.workspaceCredentials.token });
+    const { token } = await auth_service_1.AuthService.instance.getAuthDetails();
+    sdk_manager_service_1.SdkManager.init({ token });
     new webdav_server_1.WebDavServer((0, express_1.default)())
         .start()
         .then()