@internxt/cli 1.5.8 → 1.6.0

package/dist/types/drive.types.d.ts

@@ -1,5 +1,6 @@
 import { DriveFolderData, FileMeta } from '@internxt/sdk/dist/drive/storage/types';
 export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVersion' | 'size' | 'createdAt' | 'updatedAt' | 'creationTime' | 'modificationTime' | 'type'> & {
+    itemType: 'file';
     size: number;
     createdAt: Date;
     updatedAt: Date;
@@ -8,6 +9,7 @@ export type DriveFileItem = Omit<FileMeta, 'plainName' | 'userId' | 'encryptVers
     type?: string | null;
 };
 export type DriveFolderItem = Pick<DriveFolderData, 'name' | 'bucket' | 'id' | 'parentId'> & {
+    itemType: 'folder';
     encryptedName: string;
     uuid: string;
     createdAt: Date;

package/dist/types/webdav.types.d.ts

@@ -7,7 +7,6 @@ export type WebDavMethodHandlerOptions = {
     debug: boolean;
 };
 export type WebDavRequestedResource = {
-    type: 'file' | 'folder';
     url: string;
     name: string;
     path: ParsedPath;

package/dist/utils/drive.utils.js

@@ -4,6 +4,7 @@ exports.DriveUtils = void 0;
 class DriveUtils {
     static driveFileMetaToItem(fileMeta) {
         return {
+            itemType: 'file',
             uuid: fileMeta.uuid ?? '',
             status: fileMeta.status,
             folderId: fileMeta.folderId,
@@ -22,6 +23,7 @@ class DriveUtils {
     }
     static driveFolderMetaToItem(folderMeta) {
         return {
+            itemType: 'folder',
             uuid: folderMeta.uuid,
             id: folderMeta.id,
             bucket: folderMeta.bucket,
@@ -36,6 +38,7 @@ class DriveUtils {
     }
     static createFolderResponseToItem(folderResponse) {
         return {
+            itemType: 'folder',
             uuid: folderResponse.uuid,
             id: folderResponse.id,
             bucket: folderResponse.bucket,

package/dist/utils/logger.utils.js

@@ -52,3 +52,13 @@ exports.webdavLogger = winston_1.default.createLogger({
         }),
     ],
 });
+if (process.env.NODE_ENV !== 'production') {
+    exports.webdavLogger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}
+if (process.env.NODE_ENV !== 'production') {
+    exports.logger.add(new winston_1.default.transports.Console({
+        format: winston_1.default.format.simple(),
+    }));
+}

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

@@ -1,4 +1,3 @@
-import { Request } from 'express';
 import { WebDavRequestedResource } from '../types/webdav.types';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
@@ -8,18 +7,21 @@ export declare class WebDavUtils {
     static removeHostFromURL(completeURL: string): string;
     static decodeUrl(requestUrl: string, decodeUri?: boolean): string;
     static normalizeFolderPath(path: string): string;
-    static getRequestedResource(urlObject: string | Request, decodeUri?: boolean): Promise<WebDavRequestedResource>;
-    static getDriveItemFromResource(params: {
-        resource: WebDavRequestedResource;
+    static getRequestedResource(requestUrl: string, decodeUri?: boolean): Promise<WebDavRequestedResource>;
+    static tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }: {
+        url: string;
         driveFolderService: DriveFolderService;
-        driveFileService?: never;
-    }): Promise<DriveFolderItem | undefined>;
-    static getDriveItemFromResource(params: {
-        resource: WebDavRequestedResource;
-        driveFolderService?: never;
+        driveFileService: DriveFileService;
+    }): Promise<DriveItem | undefined>;
+    static getDriveFileFromResource({ url, driveFileService, }: {
+        url: string;
         driveFileService: DriveFileService;
     }): Promise<DriveFileItem | undefined>;
-    static getDriveItemFromResource(params: {
+    static getDriveFolderFromResource({ url, driveFolderService, }: {
+        url: string;
+        driveFolderService: DriveFolderService;
+    }): Promise<DriveFolderItem | undefined>;
+    static getDriveItemFromResource({ resource, driveFolderService, driveFileService, }: {
         resource: WebDavRequestedResource;
         driveFolderService: DriveFolderService;
         driveFileService: DriveFileService;

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 logger_utils_1 = require("./logger.utils");
 class WebDavUtils {
     static joinURL(...pathComponents) {
         return node_path_1.default.posix.join(...pathComponents);
@@ -32,45 +33,54 @@ class WebDavUtils {
         }
         return normalizedPath;
     }
-    static async getRequestedResource(urlObject, decodeUri = true) {
-        let requestUrl;
-        if (typeof urlObject === 'string') {
-            requestUrl = urlObject;
-        }
-        else {
-            requestUrl = urlObject.url;
-        }
+    static async getRequestedResource(requestUrl, decodeUri = true) {
         const decodedUrl = this.decodeUrl(requestUrl, decodeUri);
         const parsedPath = node_path_1.default.parse(decodedUrl);
         const parentPath = this.normalizeFolderPath(node_path_1.default.dirname(decodedUrl));
-        const isFolder = requestUrl.endsWith('/');
-        if (isFolder) {
-            return {
-                type: 'folder',
-                url: decodedUrl,
-                name: parsedPath.base,
-                path: parsedPath,
-                parentPath,
-            };
+        return {
+            url: decodedUrl,
+            name: parsedPath.base,
+            path: parsedPath,
+            parentPath,
+        };
+    }
+    static async tryGetFileOrFolderMetadata({ url, driveFileService, driveFolderService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch {
+            return await driveFolderService.getFolderMetadataByPath(url);
+        }
+    }
+    static async getDriveFileFromResource({ url, driveFileService, }) {
+        try {
+            return await driveFileService.getFileMetadataByPath(url);
+        }
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the file metadata by path', err);
+        }
+    }
+    static async getDriveFolderFromResource({ url, driveFolderService, }) {
+        try {
+            return await driveFolderService.getFolderMetadataByPath(url);
         }
-        else {
-            return {
-                type: 'file',
-                url: decodedUrl,
-                name: parsedPath.name,
-                path: parsedPath,
-                parentPath,
-            };
+        catch (err) {
+            logger_utils_1.webdavLogger.error('Exception while getting the folder metadata by path', err);
         }
     }
     static async getDriveItemFromResource({ resource, driveFolderService, driveFileService, }) {
         let item = undefined;
+        const isFolder = resource.url.endsWith('/');
         try {
-            if (resource.type === 'folder') {
-                item = await driveFolderService?.getFolderMetadataByPath(resource.url);
+            if (isFolder) {
+                item = await driveFolderService.getFolderMetadataByPath(resource.url);
             }
-            if (resource.type === 'file') {
-                item = await driveFileService?.getFileMetadataByPath(resource.url);
+            else {
+                item = await this.tryGetFileOrFolderMetadata({
+                    url: resource.url,
+                    driveFileService,
+                    driveFolderService,
+                });
             }
         }
         catch {

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

@@ -11,8 +11,8 @@ class DELETERequestHandler {
     }
     handle = async (req, res) => {
         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 resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[DELETE] Request received for item at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
             resource,
             driveFolderService,
@@ -21,12 +21,12 @@ class DELETERequestHandler {
         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}`);
+        logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] Trashing ${driveItem.itemType}`);
         await trashService.trashItems({
-            items: [{ type: resource.type, uuid: driveItem.uuid, id: null }],
+            items: [{ type: driveItem.itemType, uuid: driveItem.uuid }],
         });
         res.status(204).send();
-        const type = resource.type.charAt(0).toUpperCase() + resource.type.substring(1);
+        const type = driveItem.itemType.charAt(0).toUpperCase() + driveItem.itemType.substring(1);
         logger_utils_1.webdavLogger.info(`[DELETE] [${driveItem.uuid}] ${type} trashed successfully`);
     };
 }

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

@@ -12,20 +12,17 @@ class GETRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService, authService, networkFacade } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
         if (resource.name.startsWith('._'))
             throw new errors_utils_1.NotFoundError('File not found');
-        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 driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        logger_utils_1.webdavLogger.info(`[GET] Request received item at ${resource.url}`);
+        const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+            url: resource.url,
             driveFileService,
         });
-        if (!driveItem) {
-            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
+        if (!driveFile) {
+            throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}, if trying to access a folder use PROPFIND instead.`);
         }
-        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

@@ -12,21 +12,16 @@ class HEADRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFileService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        if (resource.type === 'folder') {
-            res.status(200).send();
-            return;
-        }
-        logger_utils_1.webdavLogger.info(`[HEAD] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[HEAD] Request received for file at ${resource.url}`);
         try {
-            const driveItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource,
+            const driveFile = await webdav_utils_1.WebDavUtils.getDriveFileFromResource({
+                url: resource.url,
                 driveFileService,
             });
-            if (!driveItem) {
+            if (!driveFile) {
                 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

@@ -12,12 +12,12 @@ class MKCOLRequestHandler {
     }
     handle = async (req, res) => {
         const { driveFolderService, webDavFolderService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[MKCOL] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[MKCOL] Request received for folder at ${resource.url}`);
         const parentDriveFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
             (await webDavFolderService.createParentPathOrThrow(resource.parentPath));
-        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        const driveFolderItem = await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
+            url: resource.url,
             driveFolderService,
         });
         const folderAlreadyExists = !!driveFolderItem;

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

@@ -11,8 +11,8 @@ class MOVERequestHandler {
     }
     handle = async (req, res) => {
         const { driveFolderService, driveFileService, webDavFolderService } = this.dependencies;
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[MOVE] Request received for ${resource.type} at ${resource.url}`);
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        logger_utils_1.webdavLogger.info(`[MOVE] Request received for item at ${resource.url}`);
         const destinationUrl = req.header('destination');
         if (!destinationUrl) {
             throw new errors_utils_1.NotFoundError('[MOVE] Destination folder not received');
@@ -28,43 +28,45 @@ class MOVERequestHandler {
         if (!originalDriveItem) {
             throw new errors_utils_1.NotFoundError(`Resource not found on Internxt Drive at ${resource.url}`);
         }
-        const newName = destinationResource.name;
         if (destinationResource.path.dir === resource.path.dir) {
-            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
-            if (resource.type === 'folder') {
+            logger_utils_1.webdavLogger.info(`[MOVE] Renaming ${originalDriveItem.itemType}
+        with UUID ${originalDriveItem.uuid} to ${destinationResource.name}`);
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.renameFolder({
                     folderUuid: folder.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
-                const newType = destinationResource.path.ext.replace('.', '');
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.renameFile(file.uuid, {
-                    plainName: newName,
-                    type: newType,
+                    plainName: plainName,
+                    type: fileType,
                 });
             }
         }
         else {
-            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${resource.type} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
+            logger_utils_1.webdavLogger.info(`[MOVE] Moving ${originalDriveItem.itemType} with UUID ${originalDriveItem.uuid} to ${destinationPath}`);
             const destinationFolderItem = (await webDavFolderService.getDriveFolderItemFromPath(destinationResource.parentPath)) ??
                 (await webDavFolderService.createParentPathOrThrow(destinationResource.parentPath));
-            if (resource.type === 'folder') {
+            if (originalDriveItem.itemType === 'folder') {
                 const folder = originalDriveItem;
                 await driveFolderService.moveFolder(folder.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
+                    name: destinationResource.name,
                 });
             }
-            else if (resource.type === 'file') {
+            else if (originalDriveItem.itemType === 'file') {
                 const file = originalDriveItem;
-                const newType = destinationResource.path.ext.replace('.', '');
+                const plainName = destinationResource.path.name;
+                const fileType = destinationResource.path.ext.replace('.', '');
                 await driveFileService.moveFile(file.uuid, {
                     destinationFolder: destinationFolderItem.uuid,
-                    name: newName,
-                    type: newType,
+                    name: plainName,
+                    type: fileType,
                 });
             }
         }

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

@@ -5,8 +5,8 @@ const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 class OPTIONSRequestHandler {
     handle = async (req, res) => {
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`[OPTIONS] Request received for ${resource.type} at ${resource.url}`);
+        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, MKCOL, MOVE, OPTIONS, PROPFIND, PUT';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
@@ -14,7 +14,7 @@ class OPTIONSRequestHandler {
             res.header('DAV', '1, 2, ordered-collections');
             res.status(200).send();
         }
-        else if (resource.type === 'folder') {
+        else if (resource.url.endsWith('/')) {
             const allowedMethods = 'DELETE, HEAD, MKCOL, MOVE, OPTIONS, PROPFIND';
             logger_utils_1.webdavLogger.info(`[OPTIONS] Returning Allowed Options: ${allowedMethods}`);
             res.header('Allow', allowedMethods);

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

@@ -18,29 +18,18 @@ class PROPFINDRequestHandler {
     }
     handle = async (req, res) => {
         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}`);
+        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,
             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),
-                    [xml_utils_1.XMLUtils.addDefaultNamespace('propstat')]: {
-                        [xml_utils_1.XMLUtils.addDefaultNamespace('status')]: 'HTTP/1.1 404 Not Found',
-                        [xml_utils_1.XMLUtils.addDefaultNamespace('prop')]: {},
-                    },
-                },
-            }, {
-                ignoreAttributes: false,
-                suppressEmptyNode: true,
-            }));
+            res.status(404).send();
             return;
         }
-        switch (resource.type) {
+        switch (driveItem.itemType) {
             case 'file': {
                 const fileMetaXML = await this.getFileMetaXML(resource, driveItem);
                 res.status(207).send(fileMetaXML);
@@ -55,22 +44,7 @@ class PROPFINDRequestHandler {
         }
     };
     getFileMetaXML = async (resource, driveFileItem) => {
-        const driveFile = this.driveFileItemToXMLNode({
-            name: driveFileItem.name,
-            type: driveFileItem.type,
-            bucket: driveFileItem.bucket,
-            id: driveFileItem.id,
-            uuid: driveFileItem.uuid,
-            fileId: driveFileItem.fileId,
-            size: driveFileItem.size,
-            createdAt: driveFileItem.createdAt,
-            updatedAt: driveFileItem.updatedAt,
-            status: driveFileItem.status,
-            folderId: driveFileItem.folderId,
-            folderUuid: driveFileItem.folderUuid,
-            creationTime: driveFileItem.creationTime,
-            modificationTime: driveFileItem.modificationTime,
-        }, resource.url);
+        const driveFile = this.driveFileItemToXMLNode(driveFileItem, resource.url);
         const xml = xml_utils_1.XMLUtils.toWebDavXML([driveFile], {
             arrayNodeName: xml_utils_1.XMLUtils.addDefaultNamespace('response'),
         });
@@ -114,6 +88,7 @@ class PROPFINDRequestHandler {
         const foldersXML = folderContent.folders.map((folder) => {
             const folderRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, folder.plainName, '/');
             return this.driveFolderItemToXMLNode({
+                itemType: 'folder',
                 name: folder.plainName,
                 bucket: folder.bucket,
                 status: folder.deleted || folder.removed ? 'TRASHED' : 'EXISTS',
@@ -129,6 +104,7 @@ class PROPFINDRequestHandler {
         const filesXML = folderContent.files.map((file) => {
             const fileRelativePath = webdav_utils_1.WebDavUtils.joinURL(relativePath, file.type ? `${file.plainName}.${file.type}` : file.plainName);
             return this.driveFileItemToXMLNode({
+                itemType: 'file',
                 name: file.plainName,
                 bucket: file.bucket,
                 id: file.id,

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

@@ -5,10 +5,12 @@ import { AuthService } from '../../services/auth.service';
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { TrashService } from '../../services/drive/trash.service';
 import { WebDavFolderService } from '../services/webdav-folder.service';
+import { DriveFolderService } from '../../services/drive/drive-folder.service';
 export declare class PUTRequestHandler implements WebDavMethodHandler {
     private readonly dependencies;
     constructor(dependencies: {
         driveFileService: DriveFileService;
+        driveFolderService: DriveFolderService;
         webDavFolderService: WebDavFolderService;
         trashService: TrashService;
         authService: AuthService;

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

@@ -21,22 +21,24 @@ class PUTRequestHandler {
         if (!contentLength || isNaN(contentLength) || contentLength <= 0) {
             throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
         }
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        if (resource.type === 'folder')
+        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req.url);
+        const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
+            resource: resource,
+            driveFileService: this.dependencies.driveFileService,
+            driveFolderService: this.dependencies.driveFolderService,
+        });
+        if (driveFileItem?.itemType === 'folder') {
             throw new errors_utils_1.NotFoundError('Folders cannot be created with PUT. Use MKCOL instead.');
-        logger_utils_1.webdavLogger.info(`[PUT] Request received for ${resource.type} at ${resource.url}`);
+        }
+        logger_utils_1.webdavLogger.info(`[PUT] Request received for file at ${resource.url}`);
         logger_utils_1.webdavLogger.info(`[PUT] Uploading '${resource.name}' to '${resource.parentPath}'`);
         const parentDriveFolderItem = (await this.dependencies.webDavFolderService.getDriveFolderItemFromPath(resource.parentPath)) ??
             (await this.dependencies.webDavFolderService.createParentPathOrThrow(resource.parentPath));
         try {
-            const driveFileItem = await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-                resource: resource,
-                driveFileService: this.dependencies.driveFileService,
-            });
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
                 logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
                 await this.dependencies.trashService.trashItems({
-                    items: [{ type: resource.type, uuid: driveFileItem.uuid, id: null }],
+                    items: [{ type: driveFileItem.itemType, uuid: driveFileItem.uuid }],
                 });
             }
         }

package/dist/webdav/services/webdav-folder.service.js

@@ -12,9 +12,9 @@ class WebDavFolderService {
         this.dependencies = dependencies;
     }
     getDriveFolderItemFromPath = async (path) => {
-        const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
-        return await webdav_utils_1.WebDavUtils.getDriveItemFromResource({
-            resource,
+        const { url } = await webdav_utils_1.WebDavUtils.getRequestedResource(path, false);
+        return await webdav_utils_1.WebDavUtils.getDriveFolderFromResource({
+            url,
             driveFolderService: this.dependencies.driveFolderService,
         });
     };
@@ -30,7 +30,8 @@ class WebDavFolderService {
     createParentPathOrThrow = async (parentPath) => {
         const { createFullPath } = await this.dependencies.configService.readWebdavConfig();
         if (!createFullPath) {
-            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)}`);
+            throw new errors_utils_1.ConflictError(`Parent folders not found on Internxt Drive at ${webdav_utils_1.WebDavUtils.decodeUrl(parentPath, false)},
+        createFullPath flag is set to: ${createFullPath}`);
         }
         const folders = parentPath.split('/').filter((f) => f.length > 0);
         const { user } = await auth_service_1.AuthService.instance.getAuthDetails();

package/dist/webdav/webdav-server.js

@@ -104,6 +104,7 @@ class WebDavServer {
         }).handle));
         this.app.put(serverListenPath, (0, express_async_handler_1.default)(new PUT_handler_1.PUTRequestHandler({
             driveFileService: this.driveFileService,
+            driveFolderService: this.driveFolderService,
             webDavFolderService: webDavFolderService,
             authService: this.authService,
             trashService: this.trashService,

package/oclif.manifest.json

@@ -351,10 +351,10 @@
         "list.js"
       ]
     },
-    "login": {
+    "login-legacy": {
       "aliases": [],
       "args": {},
-      "description": "Logs into an Internxt account. If the account is two-factor protected, then an extra code will be required.",
+      "description": "[Legacy] Logs into an Internxt account using user and password. If the account is two-factor protected, then an extra code will be required.",
       "examples": [
         "<%= config.bin %> <%= command.id %>"
       ],
@@ -435,6 +435,63 @@
       },
       "hasDynamicHelp": false,
       "hiddenAliases": [],
+      "id": "login-legacy",
+      "pluginAlias": "@internxt/cli",
+      "pluginName": "@internxt/cli",
+      "pluginType": "core",
+      "strict": true,
+      "enableJsonFlag": true,
+      "isESM": false,
+      "relativePath": [
+        "dist",
+        "commands",
+        "login-legacy.js"
+      ]
+    },
+    "login": {
+      "aliases": [],
+      "args": {},
+      "description": "Logs into your Internxt account using the web-based login flow. A temporary local server is started to securely receive the authentication response.",
+      "examples": [
+        "<%= config.bin %> <%= command.id %>"
+      ],
+      "flags": {
+        "json": {
+          "description": "Format output as json.",
+          "helpGroup": "GLOBAL",
+          "name": "json",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "host": {
+          "aliases": [
+            "host"
+          ],
+          "char": "h",
+          "description": "IP address of the machine where the CLI is running. If you are opening the login page in a browser on another device, set this to the IP address of the machine running the CLI. Defaults to 127.0.0.1.",
+          "env": "INXT_LOGIN_SERVER_HOST",
+          "name": "host",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "port": {
+          "aliases": [
+            "port"
+          ],
+          "char": "p",
+          "description": "Port used by the temporary local server to handle the login callback. If not specified, a random available port will be used automatically.",
+          "env": "INXT_LOGIN_SERVER_PORT",
+          "name": "port",
+          "required": false,
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        }
+      },
+      "hasDynamicHelp": false,
+      "hiddenAliases": [],
       "id": "login",
       "pluginAlias": "@internxt/cli",
       "pluginName": "@internxt/cli",
@@ -1298,5 +1355,5 @@
       ]
     }
   },
-  "version": "1.5.8"
+  "version": "1.6.0"
 }