@internxt/cli 1.4.2 → 1.5.1

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

@@ -1,9 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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");
 class HEADRequestHandler {
-    handle = async (_, res) => {
-        res.status(405).send();
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    handle = async (req, res) => {
+        const { driveDatabaseManager, 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 driveFile = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
+            resource,
+            driveDatabaseManager,
+            driveFileService,
+        }));
+        logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Found Drive File`);
+        const range = req.headers['range'];
+        const rangeOptions = network_utils_1.NetworkUtils.parseRangeHeader({
+            range,
+            totalFileSize: driveFile.size,
+        });
+        let contentLength = driveFile.size;
+        if (rangeOptions) {
+            logger_utils_1.webdavLogger.info(`[HEAD] [${driveFile.uuid}] Range request received:`, { rangeOptions });
+            contentLength = rangeOptions.rangeSize;
+        }
+        res.header('Content-Type', 'application/octet-stream');
+        res.header('Content-length', contentLength.toString());
+        res.status(200).send();
     };
 }
 exports.HEADRequestHandler = HEADRequestHandler;

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

@@ -13,7 +13,7 @@ class MKCOLRequestHandler {
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFolderService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info('Resource received for MKCOL request', { resource });
+        logger_utils_1.webdavLogger.info(`[MKCOL] Request received for ${resource.type} at ${resource.url}`);
         const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath);
         const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource: parentResource,
@@ -21,11 +21,11 @@ class MKCOLRequestHandler {
             driveFolderService,
         }));
         const [createFolder] = driveFolderService.createFolder({
-            plainName: resource.name,
+            plainName: resource.path.base,
             parentFolderUuid: parentFolderItem.uuid,
         });
         const newFolder = await createFolder;
-        logger_utils_1.webdavLogger.info(`✅ Folder created with UUID ${newFolder.uuid}`);
+        logger_utils_1.webdavLogger.info(`[MKCOL] ✅ Folder created with UUID ${newFolder.uuid}`);
         await driveDatabaseManager.createFolder({
             name: newFolder.plainName,
             status: 'EXISTS',

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

@@ -12,10 +12,10 @@ class MOVERequestHandler {
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info('[MOVE] Resource found', { resource });
+        logger_utils_1.webdavLogger.info(`[MOVE] Request received for ${resource.type} at ${resource.url}`);
         const destinationUrl = req.header('destination');
         if (!destinationUrl) {
-            throw new errors_utils_1.NotFoundError('Destination folder not received');
+            throw new errors_utils_1.NotFoundError('[MOVE] Destination folder not received');
         }
         const destinationPath = webdav_utils_1.WebDavUtils.removeHostFromURL(destinationUrl);
         const destinationResource = await webdav_utils_1.WebDavUtils.getRequestedResource(destinationPath);

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

@@ -1,5 +1,5 @@
 import { WebDavMethodHandler } from '../../types/webdav.types';
 import { Request, Response } from 'express';
 export declare class OPTIONSRequestHandler implements WebDavMethodHandler {
-    handle: (_: Request, res: Response) => Promise<void>;
+    handle: (req: Request, res: Response) => Promise<void>;
 }

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

@@ -1,11 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OPTIONSRequestHandler = void 0;
+const webdav_utils_1 = require("../../utils/webdav.utils");
+const logger_utils_1 = require("../../utils/logger.utils");
 class OPTIONSRequestHandler {
-    handle = async (_, res) => {
-        res.header('Allow', 'OPTIONS, GET, HEAD, POST, PUT, DELETE, PROPFIND, PROPPATCH, MKCOL, COPY, MOVE, LOCK, UNLOCK');
-        res.header('DAV', '1, 2, ordered-collections');
-        res.status(200).send();
+    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}`);
+        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}`);
+            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') {
+            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') {
+            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;
+        }
     };
 }
 exports.OPTIONSRequestHandler = OPTIONSRequestHandler;

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

@@ -19,7 +19,7 @@ class PROPFINDRequestHandler {
     handle = async (req, res) => {
         const { driveDatabaseManager, driveFolderService, driveFileService } = this.dependencies;
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info('[PROPFIND] Request received', { resource });
+        logger_utils_1.webdavLogger.info(`[PROPFIND] Request received for ${resource.type} at ${resource.url}`);
         const driveItem = await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource,
             driveDatabaseManager,

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

@@ -6,6 +6,10 @@ const errors_utils_1 = require("../../utils/errors.utils");
 const webdav_utils_1 = require("../../utils/webdav.utils");
 const logger_utils_1 = require("../../utils/logger.utils");
 const types_1 = require("@internxt/sdk/dist/drive/storage/types");
+const cli_utils_1 = require("../../utils/cli.utils");
+const stream_utils_1 = require("../../utils/stream.utils");
+const thumbnail_utils_1 = require("../../utils/thumbnail.utils");
+const thumbnail_service_1 = require("../../services/thumbnail.service");
 class PUTRequestHandler {
     dependencies;
     constructor(dependencies) {
@@ -18,7 +22,10 @@ class PUTRequestHandler {
             throw new errors_utils_1.UnsupportedMediaTypeError('Empty files are not supported');
         }
         const resource = await webdav_utils_1.WebDavUtils.getRequestedResource(req);
-        logger_utils_1.webdavLogger.info(`PUT request received for uploading file '${resource.name}' to '${resource.parentPath}'`);
+        if (resource.type === '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] Uploading '${resource.name}' to '${resource.parentPath}'`);
         const parentResource = await webdav_utils_1.WebDavUtils.getRequestedResource(resource.parentPath);
         const parentFolderItem = (await webdav_utils_1.WebDavUtils.getAndSearchItemFromResource({
             resource: parentResource,
@@ -32,7 +39,7 @@ class PUTRequestHandler {
                 driveFileService,
             }));
             if (driveFileItem && driveFileItem.status === 'EXISTS') {
-                logger_utils_1.webdavLogger.info(`File '${resource.name}' already exists in '${resource.path.dir}', trashing it before PUT`);
+                logger_utils_1.webdavLogger.info(`[PUT] File '${resource.name}' already exists in '${resource.path.dir}', trashing it...`);
                 await driveDatabaseManager.deleteFileById(driveFileItem.id);
                 await trashService.trashItems({
                     items: [{ type: resource.type, uuid: driveFileItem.uuid }],
@@ -42,29 +49,62 @@ class PUTRequestHandler {
         catch {
         }
         const { user } = await authService.getAuthDetails();
-        let lastLoggedProgress = 0;
-        const [uploadPromise] = await networkFacade.uploadFromStream(user.bucket, user.mnemonic, contentLength, req, {
-            progressCallback: (progress) => {
-                const percentage = Math.floor(100 * progress);
-                if (percentage >= lastLoggedProgress + 1) {
-                    lastLoggedProgress = percentage;
-                    logger_utils_1.webdavLogger.info(`Upload progress for file ${resource.name}: ${percentage}%`);
+        const fileType = resource.path.ext.replace('.', '');
+        const timer = cli_utils_1.CLIUtils.timer();
+        let bufferStream;
+        let fileStream = req;
+        const isThumbnailable = (0, thumbnail_utils_1.isFileThumbnailable)(fileType);
+        if (isThumbnailable) {
+            bufferStream = new stream_utils_1.BufferStream();
+            fileStream = req.pipe(bufferStream);
+        }
+        let uploaded = false, aborted = false;
+        const progressCallback = (progress) => {
+            if (!uploaded && !aborted) {
+                logger_utils_1.webdavLogger.info(`[PUT] Upload progress for file ${resource.name}: ${(progress * 100).toFixed(2)}%`);
+            }
+        };
+        const fileId = await new Promise((resolve, reject) => {
+            const state = networkFacade.uploadFile(fileStream, contentLength, user.bucket, (err, res) => {
+                if (err) {
+                    aborted = true;
+                    return reject(err);
                 }
-            },
+                resolve(res);
+            }, progressCallback);
+            res.on('close', async () => {
+                aborted = true;
+                if (!uploaded) {
+                    logger_utils_1.webdavLogger.info('[PUT] ❌ HTTP Client has been disconnected, res has been closed.');
+                    state.stop();
+                }
+            });
         });
-        const uploadResult = await uploadPromise;
-        logger_utils_1.webdavLogger.info('✅ File uploaded to network');
+        uploaded = true;
+        logger_utils_1.webdavLogger.info('[PUT] ✅ File uploaded to network');
         const file = await drive_file_service_1.DriveFileService.instance.createFile({
             plain_name: resource.path.name,
-            type: resource.path.ext.replace('.', ''),
+            type: fileType,
             size: contentLength,
             folder_id: parentFolderItem.uuid,
-            id: uploadResult.fileId,
+            id: fileId,
             bucket: user.bucket,
             encrypt_version: types_1.EncryptionVersion.Aes03,
             name: '',
         });
-        logger_utils_1.webdavLogger.info('✅ File uploaded to internxt drive');
+        try {
+            if (isThumbnailable && bufferStream) {
+                const thumbnailBuffer = bufferStream.getBuffer();
+                if (thumbnailBuffer) {
+                    await thumbnail_service_1.ThumbnailService.instance.uploadThumbnail(thumbnailBuffer, fileType, user.bucket, file.id, networkFacade);
+                }
+            }
+        }
+        catch (error) {
+            logger_utils_1.webdavLogger.info(`[PUT] ❌ File thumbnail upload failed ${error.message}`);
+        }
+        const uploadTime = timer.stop();
+        logger_utils_1.webdavLogger.info(`[PUT] ✅ File uploaded in ${uploadTime}ms to Internxt Drive`);
         await driveDatabaseManager.createFile(file, resource.path.dir + '/');
         res.status(200).send();
     };

package/dist/webdav/index.js

@@ -12,21 +12,29 @@ const drive_database_manager_service_1 = require("../services/database/drive-dat
 const drive_file_repository_1 = require("../services/database/drive-file/drive-file.repository");
 const drive_folder_repository_1 = require("../services/database/drive-folder/drive-folder.repository");
 const drive_file_service_1 = require("../services/drive/drive-file.service");
-const upload_service_1 = require("../services/network/upload.service");
 const download_service_1 = require("../services/network/download.service");
 const auth_service_1 = require("../services/auth.service");
 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();
 const init = async () => {
     await config_service_1.ConfigService.instance.ensureInternxtCliDataDirExists();
     await config_service_1.ConfigService.instance.ensureWebdavCertsDirExists();
     await config_service_1.ConfigService.instance.ensureInternxtLogsDirExists();
     await drive_database_manager_service_1.DriveDatabaseManager.init();
-    new webdav_server_1.WebDavServer((0, express_1.default)(), config_service_1.ConfigService.instance, drive_file_service_1.DriveFileService.instance, drive_folder_service_1.DriveFolderService.instance, new drive_database_manager_service_1.DriveDatabaseManager(new drive_file_repository_1.DriveFileRepository(), new drive_folder_repository_1.DriveFolderRepository()), upload_service_1.UploadService.instance, download_service_1.DownloadService.instance, auth_service_1.AuthService.instance, crypto_service_1.CryptoService.instance, trash_service_1.TrashService.instance)
+    const { token, newToken } = await auth_service_1.AuthService.instance.getAuthDetails();
+    sdk_manager_service_1.SdkManager.init({
+        token,
+        newToken,
+    });
+    new webdav_server_1.WebDavServer((0, express_1.default)(), config_service_1.ConfigService.instance, drive_file_service_1.DriveFileService.instance, drive_folder_service_1.DriveFolderService.instance, new drive_database_manager_service_1.DriveDatabaseManager(new drive_file_repository_1.DriveFileRepository(), new drive_folder_repository_1.DriveFolderRepository()), download_service_1.DownloadService.instance, auth_service_1.AuthService.instance, crypto_service_1.CryptoService.instance, trash_service_1.TrashService.instance)
         .start()
         .then()
         .catch((err) => logger_utils_1.webdavLogger.error('Failed to start WebDAV server', err));
 };
+process.on('uncaughtException', (err) => {
+    logger_utils_1.webdavLogger.error('Unhandled exception:', err);
+});
 init();

package/dist/webdav/middewares/auth.middleware.d.ts

@@ -1,3 +1,3 @@
 import { RequestHandler } from 'express';
-import { ConfigService } from '../../services/config.service';
-export declare const AuthMiddleware: (configService: ConfigService) => RequestHandler;
+import { AuthService } from '../../services/auth.service';
+export declare const AuthMiddleware: (authService: AuthService) => RequestHandler;

package/dist/webdav/middewares/auth.middleware.js

@@ -2,24 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthMiddleware = void 0;
 const sdk_manager_service_1 = require("../../services/sdk-manager.service");
-const AuthMiddleware = (configService) => {
+const logger_utils_1 = require("../../utils/logger.utils");
+const AuthMiddleware = (authService) => {
     return (req, res, next) => {
         (async () => {
             try {
-                const credentials = await configService.readUser();
-                if (!credentials)
-                    throw new Error('Unauthorized');
+                const { token, newToken, user } = await authService.getAuthDetails();
                 sdk_manager_service_1.SdkManager.init({
-                    token: credentials.token,
-                    newToken: credentials.newToken,
+                    token,
+                    newToken,
                 });
                 req.user = {
-                    uuid: credentials.user.uuid,
-                    rootFolderId: credentials.user.root_folder_id,
+                    uuid: user.uuid,
+                    rootFolderId: user.root_folder_id,
                 };
                 next();
             }
             catch (error) {
+                logger_utils_1.webdavLogger.error('Error from AuthMiddleware: ' + error.message);
                 res.status(401).send({ error: error.message });
             }
         })();

package/dist/webdav/webdav-server.d.ts

@@ -3,7 +3,6 @@ import { ConfigService } from '../services/config.service';
 import { DriveFolderService } from '../services/drive/drive-folder.service';
 import { DriveDatabaseManager } from '../services/database/drive-database-manager.service';
 import { DriveFileService } from '../services/drive/drive-file.service';
-import { UploadService } from '../services/network/upload.service';
 import { DownloadService } from '../services/network/download.service';
 import { AuthService } from '../services/auth.service';
 import { CryptoService } from '../services/crypto.service';
@@ -14,12 +13,11 @@ export declare class WebDavServer {
     private readonly driveFileService;
     private readonly driveFolderService;
     private readonly driveDatabaseManager;
-    private readonly uploadService;
     private readonly downloadService;
     private readonly authService;
     private readonly cryptoService;
     private readonly trashService;
-    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, driveDatabaseManager: DriveDatabaseManager, uploadService: UploadService, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
+    constructor(app: Express, configService: ConfigService, driveFileService: DriveFileService, driveFolderService: DriveFolderService, driveDatabaseManager: DriveDatabaseManager, downloadService: DownloadService, authService: AuthService, cryptoService: CryptoService, trashService: TrashService);
     private readonly getNetworkFacade;
     private readonly registerMiddlewares;
     private readonly registerHandlers;

package/dist/webdav/webdav-server.js

@@ -15,6 +15,9 @@ const auth_middleware_1 = require("./middewares/auth.middleware");
 const request_logger_middleware_1 = require("./middewares/request-logger.middleware");
 const GET_handler_1 = require("./handlers/GET.handler");
 const HEAD_handler_1 = require("./handlers/HEAD.handler");
+const download_service_1 = require("../services/network/download.service");
+const auth_service_1 = require("../services/auth.service");
+const crypto_service_1 = require("../services/crypto.service");
 const errors_middleware_1 = require("./middewares/errors.middleware");
 const express_async_handler_1 = __importDefault(require("express-async-handler"));
 const sdk_manager_service_1 = require("../services/sdk-manager.service");
@@ -26,24 +29,23 @@ const DELETE_handler_1 = require("./handlers/DELETE.handler");
 const PROPPATCH_handler_1 = require("./handlers/PROPPATCH.handler");
 const MOVE_handler_1 = require("./handlers/MOVE.handler");
 const COPY_handler_1 = require("./handlers/COPY.handler");
+const inxt_js_1 = require("@internxt/inxt-js");
 class WebDavServer {
     app;
     configService;
     driveFileService;
     driveFolderService;
     driveDatabaseManager;
-    uploadService;
     downloadService;
     authService;
     cryptoService;
     trashService;
-    constructor(app, configService, driveFileService, driveFolderService, driveDatabaseManager, uploadService, downloadService, authService, cryptoService, trashService) {
+    constructor(app, configService, driveFileService, driveFolderService, driveDatabaseManager, downloadService, authService, cryptoService, trashService) {
         this.app = app;
         this.configService = configService;
         this.driveFileService = driveFileService;
         this.driveFolderService = driveFolderService;
         this.driveDatabaseManager = driveDatabaseManager;
-        this.uploadService = uploadService;
         this.downloadService = downloadService;
         this.authService = authService;
         this.cryptoService = cryptoService;
@@ -57,23 +59,32 @@ class WebDavServer {
             user: credentials.user.bridgeUser,
             pass: credentials.user.userId,
         });
-        return new network_facade_service_1.NetworkFacade(networkModule, this.uploadService, this.downloadService, this.cryptoService);
+        const environment = new inxt_js_1.Environment({
+            bridgeUser: credentials.user.bridgeUser,
+            bridgePass: credentials.user.userId,
+            bridgeUrl: config_service_1.ConfigService.instance.get('NETWORK_URL'),
+            encryptionKey: credentials.user.mnemonic,
+        });
+        const networkFacade = new network_facade_service_1.NetworkFacade(networkModule, environment, download_service_1.DownloadService.instance, crypto_service_1.CryptoService.instance);
+        return networkFacade;
     };
     registerMiddlewares = async () => {
         this.app.use(body_parser_1.default.text({ type: ['application/xml', 'text/xml'] }));
         this.app.use(errors_middleware_1.ErrorHandlingMiddleware);
-        this.app.use((0, auth_middleware_1.AuthMiddleware)(config_service_1.ConfigService.instance));
+        this.app.use((0, auth_middleware_1.AuthMiddleware)(auth_service_1.AuthService.instance));
         this.app.use((0, request_logger_middleware_1.RequestLoggerMiddleware)({
             enable: true,
         }));
     };
     registerHandlers = async () => {
         const networkFacade = await this.getNetworkFacade();
-        this.app.head('*', (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler().handle));
+        this.app.head('*', (0, express_async_handler_1.default)(new HEAD_handler_1.HEADRequestHandler({
+            driveFileService: this.driveFileService,
+            driveDatabaseManager: this.driveDatabaseManager,
+        }).handle));
         this.app.get('*', (0, express_async_handler_1.default)(new GET_handler_1.GETRequestHandler({
             driveFileService: this.driveFileService,
             driveDatabaseManager: this.driveDatabaseManager,
-            uploadService: this.uploadService,
             downloadService: this.downloadService,
             cryptoService: this.cryptoService,
             authService: this.authService,
@@ -127,7 +138,8 @@ class WebDavServer {
         }
         server.requestTimeout = 15 * 60 * 1000;
         server.listen(configs.port, () => {
-            logger_utils_1.webdavLogger.info(`Internxt WebDav server listening at ${configs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${configs.port}`);
+            logger_utils_1.webdavLogger.info(`Internxt ${sdk_manager_service_1.SdkManager.getAppDetails().clientVersion} WebDav server ` +
+                `listening at ${configs.protocol}://${config_service_1.ConfigService.WEBDAV_LOCAL_URL}:${configs.port}`);
         });
     };
 }

package/oclif.manifest.json

@@ -1257,5 +1257,5 @@
       ]
     }
   },
-  "version": "1.4.2"
+  "version": "1.5.1"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "author": "Internxt <hello@internxt.com>",
-  "version": "1.4.2",
+  "version": "1.5.1",
   "description": "Internxt CLI to manage your encrypted storage",
   "scripts": {
     "build": "yarn clean && tsc",
@@ -20,7 +20,7 @@
     "migrate:undo": "sequelize db:migrate:undo",
     "publish:npm": "npm run build && npm publish --scope=@internxt --registry=https://registry.npmjs.org/ --access public",
     "publish:github": "npm run build && npm publish --scope=@internxt --registry=https://npm.pkg.github.com",
-    "postinstall": "node ./scripts/skip-in-ci.js || node ./bin/run.js webdav restart"
+    "postinstall": "node ./scripts/restart-webdav.js"
   },
   "homepage": "https://github.com/internxt/cli",
   "license": "MIT",
@@ -37,13 +37,14 @@
     "/oclif.manifest.json"
   ],
   "dependencies": {
-    "@inquirer/prompts": "7.2.0",
-    "@internxt/inxt-js": "2.0.11",
+    "@inquirer/prompts": "7.3.2",
+    "@internxt/inxt-js": "2.1.0",
     "@internxt/lib": "1.2.1",
     "@internxt/sdk": "1.7.0",
-    "@oclif/core": "4.0.37",
+    "@oclif/core": "4.2.8",
     "@types/validator": "13.12.2",
-    "axios": "1.7.9",
+    "async": "3.2.6",
+    "axios": "1.8.1",
     "bip39": "3.1.0",
     "body-parser": "1.20.3",
     "cli-progress": "3.12.0",
@@ -52,15 +53,16 @@
     "express": "4.21.2",
     "express-async-handler": "1.2.0",
     "express-basic-auth": "1.2.1",
-    "fast-xml-parser": "4.5.1",
+    "fast-xml-parser": "5.0.8",
     "mime-types": "2.1.35",
-    "node-fetch": "2.7.0",
     "openpgp": "5.11.2",
     "pm2": "5.4.3",
+    "range-parser": "1.2.1",
     "reflect-metadata": "0.2.2",
     "selfsigned": "2.4.1",
     "sequelize": "6.37.5",
     "sequelize-typescript": "2.1.6",
+    "sharp": "0.33.5",
     "sqlite3": "5.1.7",
     "tty-table": "4.2.3",
     "winston": "3.17.0"
@@ -68,31 +70,32 @@
   "devDependencies": {
     "@internxt/eslint-config-internxt": "2.0.0",
     "@internxt/prettier-config": "internxt/prettier-config#v1.0.2",
-    "@oclif/test": "4.1.4",
-    "@openpgp/web-stream-tools": "0.0.11-patch-0",
+    "@oclif/test": "4.1.11",
+    "@openpgp/web-stream-tools": "0.0.11-patch-1",
+    "@types/async": "3.2.24",
     "@types/cli-progress": "3.11.6",
     "@types/express": "5.0.0",
     "@types/mime-types": "2.1.4",
-    "@types/node": "22.10.2",
-    "@types/node-fetch": "2.6.12",
-    "@vitest/coverage-istanbul": "2.1.8",
-    "@vitest/spy": "2.1.8",
-    "eslint": "9.17.0",
+    "@types/node": "22.10.7",
+    "@types/range-parser": "1.2.7",
+    "@vitest/coverage-istanbul": "3.0.7",
+    "@vitest/spy": "3.0.7",
+    "eslint": "9.21.0",
     "husky": "9.1.7",
-    "lint-staged": "15.2.11",
-    "nock": "13.5.6",
+    "lint-staged": "15.4.3",
+    "nock": "14.0.1",
     "nodemon": "3.1.9",
-    "oclif": "4.16.5",
-    "prettier": "3.4.2",
+    "oclif": "4.17.34",
+    "prettier": "3.5.3",
     "rimraf": "6.0.1",
     "sequelize-cli": "6.6.2",
     "ts-node": "10.9.2",
-    "typescript": "5.7.2",
-    "vitest": "2.1.8",
+    "typescript": "5.8.2",
+    "vitest": "3.0.7",
     "vitest-mock-express": "2.2.0"
   },
   "engines": {
-    "node": ">=20.5.0"
+    "node": ">=20.12.1"
   },
   "bin": {
     "internxt": "./bin/run.js"

package/scripts/restart-webdav.js

@@ -0,0 +1,16 @@
+const { exec } = require('child_process');
+
+async function runCommand() {
+  await new Promise((resolve, reject) => {
+    exec('node ./bin/run.js webdav restart', (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      }
+      resolve(stdout || stderr);
+    });
+  });
+}
+
+runCommand().finally(() => {
+  process.exit(0);
+});

package/dist/services/network/upload.service.d.ts

@@ -1,8 +0,0 @@
-import { Readable } from 'node:stream';
-import { UploadOptions } from '../../types/network.types';
-export declare class UploadService {
-    static readonly instance: UploadService;
-    uploadFile(url: string, from: Readable, options: UploadOptions): Promise<{
-        etag: string;
-    }>;
-}

package/dist/services/network/upload.service.js

@@ -1,24 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UploadService = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
-class UploadService {
-    static instance = new UploadService();
-    async uploadFile(url, from, options) {
-        const response = await (0, node_fetch_1.default)(url, {
-            method: 'PUT',
-            body: from,
-            signal: options.abortController?.signal,
-        });
-        const etag = response.headers.get('etag');
-        options.progressCallback(1);
-        if (!etag) {
-            throw new Error('Missing Etag in response when uploading file');
-        }
-        return { etag };
-    }
-}
-exports.UploadService = UploadService;

package/dist/utils/hash.utils.d.ts

@@ -1,12 +0,0 @@
-import { Hash } from 'node:crypto';
-import { Transform, TransformCallback, TransformOptions } from 'node:stream';
-export declare class HashStream extends Transform {
-    hasher: Hash;
-    finalHash: Buffer;
-    constructor(opts?: TransformOptions);
-    _transform(chunk: Buffer, enc: BufferEncoding, cb: TransformCallback): void;
-    _flush(cb: (err: Error | null) => void): Hash;
-    reset(): void;
-    readHash(): Buffer<ArrayBufferLike>;
-    getHash(): Buffer<ArrayBufferLike>;
-}