@internxt/cli 1.5.3 → 1.5.5

package/dist/services/sdk-manager.service.d.ts

@@ -12,11 +12,9 @@ export declare class SdkManager {
         throwErrorOnMissingCredentials: boolean;
     }) => SdkManagerApiSecurity;
     static readonly getAppDetails: () => AppDetails;
-    getAuth(useNewApi?: boolean): Auth;
-    getPayments(): Drive.Payments;
-    getUsers(useNewApi?: boolean): Drive.Users;
-    getReferrals(): Drive.Referrals;
-    getStorage(useNewApi?: boolean): Drive.Storage;
+    getAuth(): Auth;
+    getUsers(): Drive.Users;
+    getStorage(): Drive.Storage;
     getTrash(): Drive.Trash;
     getShare(): Drive.Share;
     getNetwork(credentials: {

package/dist/services/sdk-manager.service.js

@@ -25,68 +25,49 @@ class SdkManager {
     };
     static getAppDetails = () => {
         return {
-            clientName: package_json_1.default.name,
+            clientName: package_json_1.default.clientName,
             clientVersion: package_json_1.default.version,
+            desktopHeader: config_service_1.ConfigService.instance.get('DESKTOP_HEADER'),
         };
     };
-    getAuth(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getAuth() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Auth.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity?.newToken : apiSecurity?.token,
+            token: apiSecurity?.newToken,
         });
     }
-    getPayments() {
-        const PAYMENTS_API_URL = config_service_1.ConfigService.instance.get('PAYMENTS_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
-        const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Payments.client(PAYMENTS_API_URL, appDetails, {
-            token: newToken,
-        });
-    }
-    getUsers(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getUsers() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity({ throwErrorOnMissingCredentials: false });
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Users.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+            token: apiSecurity.newToken,
         });
     }
-    getReferrals() {
-        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_API_URL');
-        const apiSecurity = SdkManager.getApiSecurity();
-        const appDetails = SdkManager.getAppDetails();
-        return sdk_1.Drive.Referrals.client(DRIVE_API_URL, appDetails, apiSecurity);
-    }
-    getStorage(useNewApi = false) {
-        const DRIVE_API_URL = useNewApi
-            ? config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL')
-            : config_service_1.ConfigService.instance.get('DRIVE_API_URL');
+    getStorage() {
+        const DRIVE_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
         const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Storage.client(DRIVE_API_URL, appDetails, {
-            token: useNewApi ? apiSecurity.newToken : apiSecurity.token,
+            token: apiSecurity.newToken,
         });
     }
     getTrash() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
+        const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return drive_1.Trash.client(DRIVE_NEW_API_URL, appDetails, {
-            token: newToken,
+            token: apiSecurity.newToken,
         });
     }
     getShare() {
         const DRIVE_NEW_API_URL = config_service_1.ConfigService.instance.get('DRIVE_NEW_API_URL');
-        const newToken = SdkManager.getApiSecurity().newToken;
+        const apiSecurity = SdkManager.getApiSecurity();
         const appDetails = SdkManager.getAppDetails();
         return sdk_1.Drive.Share.client(DRIVE_NEW_API_URL, appDetails, {
-            token: newToken,
+            token: apiSecurity.newToken,
         });
     }
     getNetwork(credentials) {

package/dist/services/thumbnail.service.d.ts

@@ -2,6 +2,6 @@ import { StorageTypes } from '@internxt/sdk/dist/drive';
 import { NetworkFacade } from './network/network-facade.service';
 export declare class ThumbnailService {
     static readonly instance: ThumbnailService;
-    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: number, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
-    private getThumbnailFromImageBuffer;
+    uploadThumbnail: (fileContent: Buffer, fileType: string, userBucket: string, file_id: string, networkFacade: NetworkFacade) => Promise<StorageTypes.Thumbnail | undefined>;
+    private readonly getThumbnailFromImageBuffer;
 }

package/dist/services/thumbnail.service.js

@@ -27,14 +27,14 @@ class ThumbnailService {
                 }, () => { });
             });
             const createdThumbnailFile = await drive_file_service_1.DriveFileService.instance.createThumbnail({
-                file_id: file_id,
-                max_width: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
-                max_height: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
+                fileUuid: file_id,
+                maxWidth: thumbnail_utils_1.ThumbnailConfig.MaxWidth,
+                maxHeight: thumbnail_utils_1.ThumbnailConfig.MaxHeight,
                 type: thumbnail_utils_1.ThumbnailConfig.Type,
                 size: size,
-                bucket_id: userBucket,
-                bucket_file: fileId,
-                encrypt_version: drive_1.StorageTypes.EncryptionVersion.Aes03,
+                bucketId: userBucket,
+                bucketFile: fileId,
+                encryptVersion: drive_1.StorageTypes.EncryptionVersion.Aes03,
             });
             return createdThumbnailFile;
         }

package/dist/services/usage.service.d.ts

@@ -1,7 +1,7 @@
-import { UsageResponse } from '@internxt/sdk/dist/drive/storage/types';
+import { UsageResponseV2 } from '@internxt/sdk/dist/drive/storage/types';
 export declare class UsageService {
     static readonly instance: UsageService;
     static readonly INFINITE_LIMIT: number;
-    fetchUsage: () => Promise<UsageResponse>;
+    fetchUsage: () => Promise<UsageResponseV2>;
     fetchSpaceLimit: () => Promise<number>;
 }

package/dist/services/usage.service.js

@@ -7,12 +7,12 @@ class UsageService {
     static INFINITE_LIMIT = 99 * Math.pow(1024, 4);
     fetchUsage = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const driveUsage = await storageClient.spaceUsage();
+        const driveUsage = await storageClient.spaceUsageV2();
         return driveUsage;
     };
     fetchSpaceLimit = async () => {
         const storageClient = sdk_manager_service_1.SdkManager.instance.getStorage();
-        const spaceLimit = await storageClient.spaceLimit();
+        const spaceLimit = await storageClient.spaceLimitV2();
         return spaceLimit.maxSpaceBytes;
     };
 }

package/dist/services/validation.service.js

@@ -52,10 +52,10 @@ class ValidationService {
                 return { isValid: false, expiration: { expired: true, refreshRequired: false } };
             }
             const currentTime = Math.floor(Date.now() / 1000);
-            const twoDaysInSeconds = 2 * 24 * 60 * 60;
+            const oneDayInSeconds = 1 * 24 * 60 * 60;
             const remainingSeconds = payload.exp - currentTime;
             const expired = remainingSeconds <= 0;
-            const refreshRequired = remainingSeconds > 0 && remainingSeconds <= twoDaysInSeconds;
+            const refreshRequired = remainingSeconds > 0 && remainingSeconds <= oneDayInSeconds;
             return { isValid: true, expiration: { expired, refreshRequired } };
         }
         catch {

package/dist/types/config.types.d.ts

@@ -1,11 +1,9 @@
 export interface ConfigKeys {
-    readonly DRIVE_URL: string;
-    readonly DRIVE_API_URL: string;
+    readonly DRIVE_WEB_URL: string;
     readonly DRIVE_NEW_API_URL: string;
-    readonly PAYMENTS_API_URL: string;
     readonly APP_CRYPTO_SECRET: string;
-    readonly APP_CRYPTO_SECRET2: string;
     readonly APP_MAGIC_IV: string;
     readonly APP_MAGIC_SALT: string;
     readonly NETWORK_URL: string;
+    readonly DESKTOP_HEADER: string;
 }

package/dist/utils/pm2.utils.d.ts

@@ -1,7 +1,7 @@
 import pm2 from 'pm2';
 export type WebDavProcessStatus = 'online' | 'stopping' | 'stopped' | 'launching' | 'errored' | 'one-launch-status' | 'offline' | 'unknown';
 export declare class PM2Utils {
-    private static WEBDAV_APP_NAME;
+    private static readonly WEBDAV_APP_NAME;
     static connect(): Promise<void>;
     static disconnect(): void;
     static clean(): Promise<void>;

package/dist/utils/thumbnail.utils.js

@@ -31,14 +31,14 @@ const thumbnailableImageExtension = [
 const thumbnailablePdfExtension = pdfExtensions['pdf'];
 const thumbnailableExtension = [...thumbnailableImageExtension];
 const isFileThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailableExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isFileThumbnailable = isFileThumbnailable;
 const isPDFThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailablePdfExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isPDFThumbnailable = isPDFThumbnailable;
 const isImageThumbnailable = (fileType) => {
-    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType);
+    return fileType.trim().length > 0 && thumbnailableImageExtension.includes(fileType.trim().toLowerCase());
 };
 exports.isImageThumbnailable = isImageThumbnailable;

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

@@ -7,10 +7,9 @@ export declare class WebDavUtils {
     static joinURL(...pathComponents: string[]): string;
     static removeHostFromURL(completeURL: string): string;
     static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static getDriveItemFromResource(resource: WebDavRequestedResource, driveFolderService?: DriveFolderService, driveFileService?: DriveFileService): Promise<DriveFileItem | DriveFolderItem | undefined>;
-    static getAndSearchItemFromResource({ resource, driveFolderService, driveFileService, }: {
+    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
         driveFolderService?: DriveFolderService;
         driveFileService?: DriveFileService;
-    }): Promise<DriveFileItem | DriveFolderItem>;
+    }): Promise<DriveFileItem | DriveFolderItem | undefined>;
 }

package/dist/utils/webdav.utils.js

@@ -5,7 +5,6 @@ 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 errors_utils_1 = require("./errors.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -55,30 +54,19 @@ class WebDavUtils {
             };
         }
     }
-    static async getDriveItemFromResource(resource, driveFolderService, driveFileService) {
+    static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
         let item = undefined;
-        if (resource.type === 'folder') {
-            try {
+        try {
+            if (resource.type === 'folder') {
                 item = await driveFolderService?.getFolderMetadataByPath(resource.url);
             }
-            catch (error) {
-                if (error.status === 404) {
-                    throw new errors_utils_1.ConflictError(`Resource not found on Internxt Drive at ${resource.url}`);
-                }
-                throw error;
+            if (resource.type === 'file') {
+                item = await driveFileService?.getFileMetadataByPath(resource.url);
             }
         }
-        if (resource.type === 'file') {
-            item = await driveFileService?.getFileMetadataByPath(resource.url);
+        catch {
         }
         return item;
     }
-    static async getAndSearchItemFromResource({ resource, driveFolderService, driveFileService, }) {
-        const driveItem = await this.getDriveItemFromResource(resource, driveFolderService, driveFileService);
-        if (!driveItem) {
-            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
-        }
-        return driveItem;
-    }
 }
 exports.WebDavUtils = WebDavUtils;

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DELETERequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 class DELETERequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -12,11 +13,14 @@ class DELETERequestHandler {
         const { driveFileService, driveFolderService, trashService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[DELETE] Request received for ${resource.type} at ${resource.url}`);
-        const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
             driveFileService: driveFileService,
         });
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${resource.type}`);
         await trashService.trashItems({
             items: [{ type: resource.type, uuid: driveItem.uuid }],

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

@@ -18,10 +18,14 @@ class GETRequestHandler {
         if (resource.type === 'folder')
             throw new errors_utils_1.NotFoundError('Folders cannot be listed with GET. Use PROPFIND instead.');
         logger_utils_1.webdavLogger.info(`[GET] Request received for ${resource.type} at ${resource.url}`);
-        const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFileService,
-        }));
+        });
+        if (!driveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
+        const driveFile = driveItem;
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Found Drive File`);
         const { user } = await authService.getAuthDetails();
         logger_utils_1.webdavLogger.info(`[GET] [${driveFile.uuid}] Network ready for download`);

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

@@ -4,6 +4,7 @@ exports.HEADRequestHandler = void 0;
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const network_utils_1 = require("../../utils/network.utils");
+const errors_utils_1 = require("../../utils/errors.utils");
 class HEADRequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -18,10 +19,14 @@ class HEADRequestHandler {
         }
         logger_utils_1.webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
         try {
-            const driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
                 resource,
                 driveFileService,
-            }));
+            });
+            if (!driveItem) {
+                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+            }
+            const driveFile = driveItem;
             logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
             const range = req.headers['range'];
             const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({

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

@@ -16,17 +16,19 @@ class MKCOLRequestHandler {
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[MKCOL] Request received for ${resource.type} at ${resource.url}`);
         const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const parentDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource: parentResource,
             driveFolderService,
-        }));
-        let folderAlreadyExists = true;
-        try {
-            await driveFolderService.getFolderMetadataByPath(resource.url);
-        }
-        catch {
-            folderAlreadyExists = false;
+        });
+        if (!parentDriveItem) {
+            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
         }
+        const parentFolderItem = parentDriveItem;
+        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            resource,
+            driveFolderService,
+        });
+        const folderAlreadyExists = !!driveFolderItem;
         if (folderAlreadyExists) {
             logger_utils_1.webdavLogger.info(`[MKCOL] ❌ Folder '${resource.url}' already exists`);
             throw new errors_utils_1.MethodNotAllowed('Folder already exists');

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

@@ -20,11 +20,14 @@ class MOVERequestHandler {
         const destinationPath = webdav_utils_1.WebDavUtils.removeHostFromURL(destinationUrl);
         const destinationResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationPath);
         logger_utils_1.webdavLogger.info('[MOVE] Destination resource found', { destinationResource });
-        const originalDriveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const originalDriveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
             driveFileService,
         });
+        if (!originalDriveItem) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        }
         if (destinationResource.path.dir === resource.path.dir) {
             logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
             const newName = destinationResource.name;
@@ -47,10 +50,14 @@ class MOVERequestHandler {
         else {
             logger_utils_1.webdavLogger.info(`[MOVE] Moving ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
             const destinationFolderResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationResource.parentPath);
-            const destinationFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            const destinationDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
                 resource: destinationFolderResource,
                 driveFolderService,
-            }));
+            });
+            if (!destinationDriveFolderItem) {
+                throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+            }
+            const destinationFolderItem = destinationDriveFolderItem;
             if (resource.type === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.moveFolder({

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

@@ -13,23 +13,20 @@ class OPTIONSRequestHandler {
             res.header('Allow', 'DELETE, GET, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND, PUT');
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
-            return;
         }
-        if (resource.type === 'folder') {
+        else if (resource.type === 'folder') {
             const allowedMethods = 'DELETE, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND';
             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();
-            return;
         }
-        if (resource.type === 'file') {
+        else {
             const allowedMethods = 'DELETE, GET, HEAD, MOVE, OPTIONS, PROPFIND, PUT';
             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();
-            return;
         }
     };
 }

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

@@ -20,27 +20,12 @@ class PROPFINDRequestHandler {
         const { driveFolderService, driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
         logger_utils_1.webdavLogger.info(`[PROPFIND] Request received for ${resource.type} at ${resource.url}`);
-        try {
-            const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
-                resource,
-                driveFolderService,
-                driveFileService,
-            });
-            switch (resource.type) {
-                case 'file': {
-                    const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
-                    res.status(207).send(fileMetaXML);
-                    break;
-                }
-                case 'folder': {
-                    const depth = req.header('depth') ?? '1';
-                    const folderMetaXML = await this.getFolderContentXML(resource, driveItem, depth);
-                    res.status(207).send(folderMetaXML);
-                    break;
-                }
-            }
-        }
-        catch {
+        const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            resource,
+            driveFolderService,
+            driveFileService,
+        });
+        if (!driveItem) {
             res.status(207).send(xml_utils_1.XMLUtils.toWebDavXML({
                 [xml_utils_1.XMLUtils.addDefaultNamespace('response')]: {
                     [xml_utils_1.XMLUtils.addDefaultNamespace('href')]: xml_utils_1.XMLUtils.encodeWebDavUri(resource.url),
@@ -53,6 +38,20 @@ class PROPFINDRequestHandler {
                 ignoreAttributes: false,
                 suppressEmptyNode: true,
             }));
+            return;
+        }
+        switch (resource.type) {
+            case 'file': {
+                const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
+                res.status(207).send(fileMetaXML);
+                break;
+            }
+            case 'folder': {
+                const depth = req.header('depth') ?? '1';
+                const folderMetaXML = await this.getFolderContentXML(resource, driveItem, depth);
+                res.status(207).send(folderMetaXML);
+                break;
+            }
         }
     };
     getFileMetaXML = async (resource, driveFileItem) => {

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

@@ -27,12 +27,16 @@ class PUTRequestHandler {
         logger_utils_1.webdavLogger.info(`[PUT] Request received for ${resource.type} at ${resource.url}`);
         logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' to '${resource.parentPath}'`);
         const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath, false);
-        const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+        const parentDriveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource: parentResource,
             driveFolderService,
-        }));
+        });
+        if (!parentDriveFolderItem) {
+            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${resource.url}`);
+        }
+        const parentFolderItem = parentDriveFolderItem;
         try {
-            const driveFileItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            const driveFileItem = (await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
                 resource: resource,
                 driveFileService,
             }));
@@ -93,7 +97,7 @@ class PUTRequestHandler {
             if (isThumbnailable && bufferStream) {
                 const thumbnailBuffer = bufferStream.getBuffer();
                 if (thumbnailBuffer) {
-                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.id, networkFacade);
+                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.uuid, networkFacade);
                 }
             }
         }

package/dist/webdav/index.js

@@ -15,7 +15,7 @@ const crypto_service_1 = require("../services/crypto.service");
 const trash_service_1 = require("../services/drive/trash.service");
 const logger_utils_1 = require("../utils/logger.utils");
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
-dotenv_1.default.config();
+dotenv_1.default.config({ quiet: true });
 const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtCliDataDirExists();
     await config_service_1.ConfigService.instance.ensureWebdavCertsDirExists();

package/dist/webdav/webdav-server.js

@@ -63,6 +63,7 @@ class WebDavServer {
             bridgePass: credentials.user.userId,
             bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
             encryptionKey: credentials.user.mnemonic,
+            appDetails: sdk_manager_service_1.SdkManager.getAppDetails(),
         });
         const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
         return networkFacade;

package/oclif.manifest.json

@@ -1266,5 +1266,5 @@
       ]
     }
   },
-  "version": "1.5.3"
+  "version": "1.5.5"
 }