@dynamicweb/cli 1.1.1 → 1.1.2

package/README.md

@@ -98,7 +98,6 @@ The files command is used to list out and export the structure in your Dynamicwe
 - `-e` `--export`       It will export \<dirPath\> into \<outPath\> on your local machine, unzipped by default
 - `--raw`             This will keep the content zipped
 - `--iamstupid`       This will include the export of the /files/system/log and /files/.cache folders
-- `--json`            This will output a single JSON object for automation-friendly parsing
 
 #### Examples
 Exporting all templates from current environment to local solution
@@ -109,9 +108,6 @@ Exporting all templates from current environment to local solution
 Listing the system files structure of the current environment
 > $ dw files system -lr
 
-Uploading files with JSON output for automation
-> $ dw files ./Files templates -i -r --json
-
 ### Files Source Type Detection
 By default, the `dw files` command automatically detects the source type based on the \<dirPath\>:
 If the path contains a file extension (e.g., 'templates/Translations.xml'), it is treated as a file.
@@ -156,7 +152,6 @@ Pulling and overriding local solution with latest nightly build
 The query command will fire any query towards the admin Api with the given query parameters. This means any query parameter that's necessary for the given query, is required as an option in this command. It's also possible to list which parameters is necessary for the given query through the options;
 - `-l` `--list`         Will list all the properties for the given \<query\>
 - `-i` `--interactive`  Will perform the \<query\> but without any parameters, as they will be asked for one by one in interactive mode
-- `--output json`       Will output a single JSON object for automation-friendly parsing
 - `--<queryParam>`  Any parameter the query needs will be sent by '--key value'
 
 #### Examples
@@ -166,16 +161,12 @@ Getting all properties for a query
 Getting file information on a specific file by name
 > $ dw query FileByName --name DefaultMail.html --directorypath /Templates/Forms/Mail
 
-Running a query with JSON output
-> $ dw query FileByName --name DefaultMail.html --output json
-
 ### Command
 > $ dw command \<command\>
 
 Using command will, like query, fire any given command in the solution. It works like query, given the query parameters necessary, however if a `DataModel` is required for the command, it is given in a json-format, either through a path to a .json file or a literal json-string in the command.
 - `-l` `--list` Lists all the properties for the command, as well as the json model required
 - `--json` Takes a path to a .json file or a literal json, i.e --json '{ abc: "123" }'
-- `--output json` Outputs a single JSON object for automation-friendly parsing
 
 #### Examples
 Creating a copy of a page using a json-string
@@ -192,9 +183,6 @@ Where PageMove.json contains
 Deleting a page
 > $ dw command PageDelete --json '{ "id": "1383" }'
 
-Running a command with JSON output
-> $ dw command PageDelete --json '{ "id": "1383" }' --output json
-
 ### Install
 > $ dw install \<filePath\>
 

package/bin/commands/command.js

@@ -4,7 +4,7 @@ import fs from 'fs';
 import { setupEnv, getAgent } from './env.js';
 import { setupUser } from './login.js';
 
-const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
+const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env']
 
 export function commandCommand() {
     return {
@@ -22,38 +22,22 @@ export function commandCommand() {
                 alias: 'l',
                 describe: 'Lists all the properties for the command, currently not working'
             })
-            .option('output', {
-                choices: ['json'],
-                describe: 'Outputs a single JSON response for automation-friendly parsing'
-            })
         },
         handler: async (argv) => {
-            const output = createCommandOutput(argv);
-
-            try {
-                output.verboseLog(`Running command ${argv.command}`);
-                await handleCommand(argv, output);
-                output.finish();
-            } catch (err) {
-                output.fail(err);
-                output.finish();
-                process.exit(1);
-            }
+            if (argv.verbose) console.info(`Running command ${argv.command}`)
+            await handleCommand(argv)
         }
     }
 }
 
-async function handleCommand(argv, output) {
+async function handleCommand(argv) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     if (argv.list) {
-        const properties = await getProperties(env, user, argv.command);
-        output.addData(properties);
-        output.log(properties);
+        console.log(await getProperties(env, user, argv.command))
     } else {
-        let response = await runCommand(env, user, argv.command, getQueryParams(argv), parseJsonOrPath(argv.json));
-        output.addData(response);
-        output.log(response);
+        let response = await runCommand(env, user, argv.command, getQueryParams(argv), parseJsonOrPath(argv.json))
+        console.log(response)
     }
 }
 
@@ -98,67 +82,8 @@ async function runCommand(env, user, command, queryParams, data) {
         agent: getAgent(env.protocol)
     })
     if (!res.ok) {
-        throw createCommandError(`Error when doing request ${res.url}`, res.status, await parseJsonSafe(res));
+        console.log(`Error when doing request ${res.url}`)
+        process.exit(1);
     }
     return await res.json()
-}
-
-function createCommandOutput(argv) {
-    const response = {
-        ok: true,
-        command: 'command',
-        operation: argv.list ? 'list' : 'run',
-        status: 200,
-        data: [],
-        errors: [],
-        meta: {
-            commandName: argv.command
-        }
-    };
-
-    return {
-        json: argv.output === 'json',
-        response,
-        log(value) {
-            if (!this.json) {
-                console.log(value);
-            }
-        },
-        verboseLog(...args) {
-            if (argv.verbose && !this.json) {
-                console.info(...args);
-            }
-        },
-        addData(entry) {
-            response.data.push(entry);
-        },
-        fail(err) {
-            response.ok = false;
-            response.status = err?.status || 1;
-            response.errors.push({
-                message: err?.message || 'Unknown command error.',
-                details: err?.details ?? null
-            });
-        },
-        finish() {
-            if (this.json) {
-                console.log(JSON.stringify(response, null, 2));
-            }
-        }
-    };
-}
-
-function createCommandError(message, status, details = null) {
-    const error = new Error(message);
-    error.status = status;
-    error.details = details;
-    return error;
-}
-
-async function parseJsonSafe(res) {
-    try {
-        return await res.json();
-    } catch {
-        return null;
-    }
-}
+}

package/bin/commands/files.js

@@ -10,169 +10,152 @@ import { extractWithProgress } from '../extractor.js';
 
 export function filesCommand() {
     return {
-        command: 'files [dirPath] [outPath]', 
-        describe: 'Handles files', 
+        command: 'files [dirPath] [outPath]',
+        describe: 'Handles files',
         builder: (yargs) => {
             return yargs
-            .positional('dirPath', {
-                describe: 'The directory to list or export'
-            })
-            .positional('outPath', {
-                describe: 'The directory to export the specified directory to',
-                default: '.'
-            })
-            .option('list', {
-                alias: 'l',
-                type: 'boolean',
-                describe: 'Lists all directories and files'
-            })
-            .option('export', {
-                alias: 'e',
-                type: 'boolean',
-                describe: 'Exports the specified directory and all subdirectories at [dirPath] to [outPath]'
-            })
-            .option('import', {
-                alias: 'i',
-                type: 'boolean',
-                describe: 'Imports the file at [dirPath] to [outPath]'
-            })
-            .option('overwrite', {
-                alias: 'o',
-                type: 'boolean',
-                describe: 'Used with import, will overwrite existing files at destination if set to true'
-            })
-            .option('createEmpty', {
-                type: 'boolean',
-                describe: 'Used with import, will create a file even if its empty'
-            })
-            .option('includeFiles', {
-                alias: 'f',
-                type: 'boolean',
-                describe: 'Used with export, includes files in list of directories and files'
-            })
-            .option('recursive', {
-                alias: 'r',
-                type: 'boolean',
-                describe: 'Used with list, import and export, handles all directories recursively'
-            })
-            .option('raw', {
-                type: 'boolean',
-                describe: 'Used with export, keeps zip file instead of unpacking it'
-            })
-            .option('iamstupid', {
-                type: 'boolean',
-                describe: 'Includes export of log and cache folders, NOT RECOMMENDED'
-            })
-            .option('asFile', {
-                type: 'boolean',
-                alias: 'af',
-                describe: 'Forces the command to treat the path as a single file, even if it has no extension.',
-                conflicts: 'asDirectory'
-            })
-            .option('asDirectory', {
-                type: 'boolean',
-                alias: 'ad',
-                describe: 'Forces the command to treat the path as a directory, even if its name contains a dot.',
-                conflicts: 'asFile'
-            })
-            .option('json', {
-                type: 'boolean',
-                describe: 'Outputs a single JSON response for automation-friendly parsing'
-            })
+                .positional('dirPath', {
+                    describe: 'The directory to list or export'
+                })
+                .positional('outPath', {
+                    describe: 'The directory to export the specified directory to',
+                    default: '.'
+                })
+                .option('list', {
+                    alias: 'l',
+                    type: 'boolean',
+                    describe: 'Lists all directories and files'
+                })
+                .option('export', {
+                    alias: 'e',
+                    type: 'boolean',
+                    describe: 'Exports the specified directory and all subdirectories at [dirPath] to [outPath]'
+                })
+                .option('import', {
+                    alias: 'i',
+                    type: 'boolean',
+                    describe: 'Imports the file at [dirPath] to [outPath]'
+                })
+                .option('overwrite', {
+                    alias: 'o',
+                    type: 'boolean',
+                    describe: 'Used with import, will overwrite existing files at destination if set to true'
+                })
+                .option('createEmpty', {
+                    type: 'boolean',
+                    describe: 'Used with import, will create a file even if its empty'
+                })
+                .option('includeFiles', {
+                    alias: 'f',
+                    type: 'boolean',
+                    describe: 'Used with export, includes files in list of directories and files'
+                })
+                .option('recursive', {
+                    alias: 'r',
+                    type: 'boolean',
+                    describe: 'Used with list, import and export, handles all directories recursively'
+                })
+                .option('raw', {
+                    type: 'boolean',
+                    describe: 'Used with export, keeps zip file instead of unpacking it'
+                })
+                .option('iamstupid', {
+                    type: 'boolean',
+                    describe: 'Includes export of log and cache folders, NOT RECOMMENDED'
+                })
+                .option('asFile', {
+                    type: 'boolean',
+                    alias: 'af',
+                    describe: 'Forces the command to treat the path as a single file, even if it has no extension.',
+                    conflicts: 'asDirectory'
+                })
+                .option('asDirectory', {
+                    type: 'boolean',
+                    alias: 'ad',
+                    describe: 'Forces the command to treat the path as a directory, even if its name contains a dot.',
+                    conflicts: 'asFile'
+                })
         },
         handler: async (argv) => {
-            const output = createFilesOutput(argv);
-
-            try {
-                output.verboseLog(`Listing directory at: ${argv.dirPath}`);
-                await handleFiles(argv, output);
-                output.finish();
-            } catch (err) {
-                output.fail(err);
-                output.finish();
-                process.exit(1);
-            }
+            if (argv.verbose) console.info(`Listing directory at: ${argv.dirPath}`)
+            await handleFiles(argv)
         }
     }
 }
 
-async function handleFiles(argv, output) {
+async function handleFiles(argv) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
 
     if (argv.list) {
         let files = (await getFilesStructure(env, user, argv.dirPath, argv.recursive, argv.includeFiles)).model;
-        output.setStatus(200);
-        output.addData(files);
-        if (!output.json) {
-            output.log(files.name);
-            let hasFiles = files.files?.data && files.files?.data.length !== 0;
-            resolveTree(files.directories, '', hasFiles, output);
-            resolveTree(files.files?.data ?? [], '', false, output);
-        }
+        console.log(files.name)
+        let hasFiles = files.files?.data && files.files?.data.length !== 0;
+        resolveTree(files.directories, '', hasFiles);
+        resolveTree(files.files?.data ?? [], '', false);
     }
 
     if (argv.export) {
         if (argv.dirPath) {
-            
+
             const isFile = argv.asFile || argv.asDirectory
                 ? argv.asFile
-                : path.extname(argv.dirPath) !== '';                
+                : path.extname(argv.dirPath) !== '';
 
             if (isFile) {
-                let parentDirectory = path.dirname(argv.dirPath);              
+                let parentDirectory = path.dirname(argv.dirPath);
                 parentDirectory = parentDirectory === '.' ? '/' : parentDirectory;
-                
-                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.iamstupid, [argv.dirPath], true, output);
+
+                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.iamstupid, [argv.dirPath], true, argv.verbose);
             } else {
-                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, output);
+                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, argv.verbose);
             }
         } else {
             await interactiveConfirm('Are you sure you want a full export of files?', async () => {
-                output.log('Full export is starting');
+                console.log('Full export is starting')
                 let filesStructure = (await getFilesStructure(env, user, '/', false, true)).model;
                 let dirs = filesStructure.directories;
                 for (let id = 0; id < dirs.length; id++) {
                     const dir = dirs[id];
-                    await download(env, user, dir.name, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, output);
+                    await download(env, user, dir.name, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, argv.verbose);
                 }
-                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name), false, output);
-                if (argv.raw) output.log('The files in the base "files" folder is in Base.zip, each directory in "files" is in its own zip');
+                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name), false, argv.verbose);
+                if (argv.raw) console.log('The files in the base "files" folder is in Base.zip, each directory in "files" is in its own zip')
             })
         }
     } else if (argv.import) {
         if (argv.dirPath && argv.outPath) {
             let resolvedPath = path.resolve(argv.dirPath);
             if (argv.recursive) {
-                await processDirectory(env, user, resolvedPath, argv.outPath, resolvedPath, argv.createEmpty, true, argv.overwrite, output);
+                await processDirectory(env, user, resolvedPath, argv.outPath, resolvedPath, argv.createEmpty, true, argv.overwrite);
             } else {
                 let filesInDir = getFilesInDirectory(resolvedPath);
-                await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty, argv.overwrite, output);
+                await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty, argv.overwrite);
             }
         }
     }
 }
 
 function getFilesInDirectory(dirPath) {
-    return fs.statSync(dirPath).isFile() ? [ dirPath ] : fs.readdirSync(dirPath)
-            .map(file => path.join(dirPath, file))
-            .filter(file => fs.statSync(file).isFile());
+    return fs.statSync(dirPath).isFile() ? [dirPath] : fs.readdirSync(dirPath)
+        .map(file => path.join(dirPath, file))
+        .filter(file => fs.statSync(file).isFile());
 }
 
-async function processDirectory(env, user, dirPath, outPath, originalDir, createEmpty, isRoot = false, overwrite = false, output) {
+async function processDirectory(env, user, dirPath, outPath, originalDir, createEmpty, isRoot = false, overwrite = false, output = console) {
     let filesInDir = getFilesInDirectory(dirPath);
     if (filesInDir.length > 0)
         await uploadFiles(env, user, filesInDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), createEmpty, overwrite, output);
 
     const subDirectories = fs.readdirSync(dirPath)
-                            .map(subDir => path.join(dirPath, subDir))
-                            .filter(subDir => fs.statSync(subDir).isDirectory());
+        .map(subDir => path.join(dirPath, subDir))
+        .filter(subDir => fs.statSync(subDir).isDirectory());
     for (let subDir of subDirectories) {
         await processDirectory(env, user, subDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), originalDir, createEmpty, false, overwrite, output);
     }
 }
 
-function resolveTree(dirs, indentLevel, parentHasFiles, output) {
+function resolveTree(dirs, indentLevel, parentHasFiles) {
     let end = `└──`
     let mid = `├──`
     for (let id = 0; id < dirs.length; id++) {
@@ -180,33 +163,33 @@ function resolveTree(dirs, indentLevel, parentHasFiles, output) {
         let indentPipe = true;
         if (dirs.length == 1) {
             if (parentHasFiles) {
-                output.log(indentLevel + mid, dir.name)
+                console.log(indentLevel + mid, dir.name)
             } else {
-                output.log(indentLevel + end, dir.name)
+                console.log(indentLevel + end, dir.name)
                 indentPipe = false;
             }
         } else if (id != dirs.length - 1) {
-            output.log(indentLevel + mid, dir.name)
+            console.log(indentLevel + mid, dir.name)
         } else {
             if (parentHasFiles) {
-                output.log(indentLevel + mid, dir.name)
+                console.log(indentLevel + mid, dir.name)
             } else {
-                output.log(indentLevel + end, dir.name)
+                console.log(indentLevel + end, dir.name)
                 indentPipe = false;
             }
         }
         let hasFiles = dir.files?.data && dir.files?.data.length !== 0;
         if (indentPipe) {
-            resolveTree(dir.directories ?? [], indentLevel + '│\t', hasFiles, output);
-            resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false, output);
+            resolveTree(dir.directories ?? [], indentLevel + '│\t', hasFiles);
+            resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false);
         } else {
-            resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles, output);
-            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false, output);  
+            resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles);
+            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false);
         }
     }
 }
 
-async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames, singleFileMode, output) {
+async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames, singleFileMode, verbose = false) {
     let excludeDirectories = '';
     if (!iamstupid) {
         excludeDirectories = 'system/log';
@@ -217,7 +200,7 @@ async function download(env, user, dirPath, outPath, recursive, outname, raw, ia
 
     const { endpoint, data } = prepareDownloadCommandData(dirPath, excludeDirectories, fileNames, recursive, singleFileMode);
 
-    displayDownloadMessage(dirPath, fileNames, recursive, singleFileMode, output);
+    displayDownloadMessage(dirPath, fileNames, recursive, singleFileMode);
 
     const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${endpoint}`, {
         method: 'POST',
@@ -229,40 +212,27 @@ async function download(env, user, dirPath, outPath, recursive, outname, raw, ia
         agent: getAgent(env.protocol)
     });
 
-    const filename = outname || tryGetFileNameFromResponse(res, dirPath, output.verbose);
+    const filename = outname || tryGetFileNameFromResponse(res, dirPath, verbose);
     if (!filename) return;
 
     const filePath = path.resolve(`${path.resolve(outPath)}/${filename}`)
-    const updater = output.json ? null : createThrottledStatusUpdater();
+    const updater = createThrottledStatusUpdater();
 
     await downloadWithProgress(res, filePath, {
         onData: (received) => {
-            if (updater) {
-                updater.update(`Received:\t${formatBytes(received)}`);
-            }
+            updater.update(`Received:\t${formatBytes(received)}`);
         }
     });
 
-    if (updater) {
-        updater.stop();
-    }
+    updater.stop();
 
     if (singleFileMode) {
-        output.log(`Successfully downloaded: ${filename}`);
+        console.log(`Successfully downloaded: ${filename}`);
     } else {
-        output.log(`Finished downloading`, dirPath === '/.' ? '.' : dirPath, 'Recursive=' + recursive);
+        console.log(`Finished downloading`, dirPath === '/.' ? '.' : dirPath, 'Recursive=' + recursive);
     }
 
-    output.addData({
-        type: 'download',
-        directoryPath: dirPath,
-        filename,
-        outPath: path.resolve(outPath),
-        recursive,
-        raw
-    });
-
-    await extractArchive(filename, filePath, outPath, raw, output);
+    await extractArchive(filename, filePath, outPath, raw);
 }
 
 function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames, recursive, singleFileMode) {
@@ -279,10 +249,10 @@ function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames
     return { endpoint: 'FileDownload', data };
 }
 
-function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileMode, output) {
+function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileMode) {
     if (singleFileMode) {
         const fileName = path.basename(fileNames[0] || 'unknown');
-        output.log('Downloading file: ' + fileName);
+        console.log('Downloading file: ' + fileName);
 
         return;
     }
@@ -291,36 +261,32 @@ function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileM
         ? 'Base'
         : directoryPath;
 
-    output.log('Downloading', directoryPathDisplayName, 'Recursive=' + recursive);
+    console.log('Downloading', directoryPathDisplayName, 'Recursive=' + recursive);
 }
 
-async function extractArchive(filename, filePath, outPath, raw, output) {
+async function extractArchive(filename, filePath, outPath, raw) {
     if (raw) {
         return;
     }
 
-    output.log(`\nExtracting ${filename} to ${outPath}`);
+    console.log(`\nExtracting ${filename} to ${outPath}`);
     let destinationFilename = filename.replace('.zip', '');
     if (destinationFilename === 'Base')
         destinationFilename = '';
 
     const destinationPath = `${path.resolve(outPath)}/${destinationFilename}`;
-    const updater = output.json ? null : createThrottledStatusUpdater();
+    const updater = createThrottledStatusUpdater();
 
     await extractWithProgress(filePath, destinationPath, {
         onEntry: (processedEntries, totalEntries, percent) => {
-            if (updater) {
-                updater.update(`Extracted:\t${processedEntries} of ${totalEntries} files (${percent}%)`);
-            }
+            updater.update(`Extracted:\t${processedEntries} of ${totalEntries} files (${percent}%)`);
         }
     });
 
-    if (updater) {
-        updater.stop();
-    }
-    output.log(`Finished extracting ${filename} to ${outPath}\n`);
+    updater.stop();
+    console.log(`Finished extracting ${filename} to ${outPath}\n`);
 
-    fs.unlink(filePath, function(err) {});
+    fs.unlink(filePath, function (err) { });
 }
 
 async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
@@ -334,11 +300,14 @@ async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
     if (res.ok) {
         return await res.json();
     } else {
-        throw createCommandError('Unable to fetch file structure.', res.status, await parseJsonSafe(res));
+        console.log(res);
+        console.log(await res.json());
+        process.exit(1);
     }
 }
 
 export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false, overwrite = false, output) {
+    output = resolveUploadOutput(output);
     output.log('Uploading files')
 
     const chunkSize = 300;
@@ -371,18 +340,18 @@ export async function uploadFiles(env, user, localFilePaths, destinationPath, cr
     output.log(`Finished uploading files. Total files: ${localFilePaths.length}, total chunks: ${chunks.length}`);
 }
 
-async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmpty, overwrite, output) {
+async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmpty, overwrite, output = console) {
     const form = new FormData();
     form.append('path', destinationPath);
     form.append('skipExistingFiles', String(!overwrite));
     form.append('allowOverwrite', String(overwrite));
-    
+
     filePathsChunk.forEach(fileToUpload => {
         output.log(`${fileToUpload}`)
         form.append('files', fs.createReadStream(path.resolve(fileToUpload)));
     });
 
-    const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/Upload?` + new URLSearchParams({"createEmptyFiles": createEmpty, "createMissingDirectories": true}), {
+    const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/Upload?` + new URLSearchParams({ "createEmptyFiles": createEmpty, "createMissingDirectories": true }), {
         method: 'POST',
         body: form,
         headers: {
@@ -390,103 +359,46 @@ async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmp
         },
         agent: getAgent(env.protocol)
     });
-    
+
     if (res.ok) {
-        return await res.json();
+        return await res.json()
     }
     else {
-        throw createCommandError('File upload failed.', res.status, await parseJsonSafe(res));
-    }
-}
+        if (output.structured) {
+            throw createUploadError('File upload failed.', res.status, await parseJsonSafe(res));
+        }
 
-export function resolveFilePath(filePath) {
-    let p = path.parse(path.resolve(filePath))
-    let regex = wildcardToRegExp(p.base);
-    let resolvedPath = fs.readdirSync(p.dir).filter((allFilesPaths) => allFilesPaths.match(regex) !== null)[0]
-    if (resolvedPath === undefined)
-    {
-        console.log('Could not find any files with the name ' + filePath);
+        output.log(res)
+        output.log(await parseJsonSafe(res))
         process.exit(1);
     }
-    return path.join(p.dir, resolvedPath);
-}
-
-
-function wildcardToRegExp(wildcard) {
-    const escaped = wildcard.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
-    return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
 }
 
-function createFilesOutput(argv) {
-    const response = {
-        ok: true,
-        command: 'files',
-        operation: getFilesOperation(argv),
-        status: 200,
-        data: [],
-        errors: [],
-        meta: {}
-    };
+export function resolveUploadOutput(output) {
+    const response = output?.response ?? {};
+    response.meta = response.meta ?? {};
 
     return {
-        json: Boolean(argv.json),
-        verbose: Boolean(argv.verbose),
+        structured: Boolean(output),
         response,
-        log(...args) {
-            if (!this.json) {
-                console.log(...args);
+        log: typeof output?.log === 'function'
+            ? output.log.bind(output)
+            : (...args) => console.log(...args),
+        addData: typeof output?.addData === 'function'
+            ? output.addData.bind(output)
+            : () => { },
+        mergeMeta: typeof output?.mergeMeta === 'function'
+            ? output.mergeMeta.bind(output)
+            : (meta) => {
+                response.meta = {
+                    ...response.meta,
+                    ...meta
+                };
             }
-        },
-        verboseLog(...args) {
-            if (this.verbose && !this.json) {
-                console.info(...args);
-            }
-        },
-        addData(entry) {
-            response.data.push(entry);
-        },
-        mergeMeta(meta) {
-            response.meta = {
-                ...response.meta,
-                ...meta
-            };
-        },
-        setStatus(status) {
-            response.status = status;
-        },
-        fail(err) {
-            response.ok = false;
-            response.status = err?.status || 1;
-            response.errors.push({
-                message: err?.message || 'Unknown files command error.',
-                details: err?.details ?? null
-            });
-        },
-        finish() {
-            if (this.json) {
-                console.log(JSON.stringify(response, null, 2));
-            }
-        }
     };
 }
 
-function getFilesOperation(argv) {
-    if (argv.list) {
-        return 'list';
-    }
-
-    if (argv.export) {
-        return 'export';
-    }
-
-    if (argv.import) {
-        return 'import';
-    }
-
-    return 'unknown';
-}
-
-function createCommandError(message, status, details = null) {
+function createUploadError(message, status, details = null) {
     const error = new Error(message);
     error.status = status;
     error.details = details;
@@ -500,3 +412,19 @@ async function parseJsonSafe(res) {
         return null;
     }
 }
+
+export function resolveFilePath(filePath) {
+    let p = path.parse(path.resolve(filePath))
+    let regex = wildcardToRegExp(p.base);
+    let resolvedPath = fs.readdirSync(p.dir).filter((allFilesPaths) => allFilesPaths.match(regex) !== null)[0]
+    if (resolvedPath === undefined) {
+        throw new Error('Could not find any files with the name ' + filePath);
+    }
+    return path.join(p.dir, resolvedPath);
+}
+
+
+function wildcardToRegExp(wildcard) {
+    const escaped = wildcard.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+}

package/bin/commands/files.test.js

@@ -0,0 +1,76 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import { resolveFilePath, resolveUploadOutput } from './files.js';
+
+test('resolveUploadOutput falls back to a console-compatible output object', () => {
+    const output = resolveUploadOutput();
+
+    assert.equal(typeof output.log, 'function');
+    assert.equal(typeof output.addData, 'function');
+    assert.equal(typeof output.mergeMeta, 'function');
+    assert.deepEqual(output.response.meta, {});
+
+    output.mergeMeta({ chunks: 1, filesProcessed: 2 });
+
+    assert.deepEqual(output.response.meta, {
+        chunks: 1,
+        filesProcessed: 2
+    });
+});
+
+test('resolveUploadOutput preserves custom logging and merges meta when mergeMeta is absent', () => {
+    const calls = [];
+    const data = [];
+    const output = {
+        log: (...args) => calls.push(args),
+        addData: (entry) => data.push(entry),
+        response: {
+            meta: {
+                existing: true
+            }
+        }
+    };
+
+    const resolved = resolveUploadOutput(output);
+
+    resolved.log('Uploading chunk 1 of 1');
+    resolved.addData({ file: 'addon.nupkg' });
+    resolved.mergeMeta({ chunks: 1 });
+
+    assert.deepEqual(calls, [[ 'Uploading chunk 1 of 1' ]]);
+    assert.deepEqual(data, [{ file: 'addon.nupkg' }]);
+    assert.deepEqual(resolved.response.meta, {
+        existing: true,
+        chunks: 1
+    });
+});
+
+test('resolveUploadOutput initializes response.meta for partial output objects', () => {
+    const resolved = resolveUploadOutput({
+        log: () => {},
+        response: {}
+    });
+
+    resolved.mergeMeta({ chunks: 2 });
+
+    assert.deepEqual(resolved.response.meta, {
+        chunks: 2
+    });
+});
+
+test('resolveFilePath throws when no matching file exists', () => {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dw-cli-files-test-'));
+
+    try {
+        assert.throws(
+            () => resolveFilePath(path.join(tempDir, 'missing*.nupkg')),
+            /Could not find any files with the name/
+        );
+    } finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+});

package/bin/commands/install.js

@@ -18,24 +18,40 @@ export function installCommand() {
                 type: 'boolean',
                 describe: 'Queues the install for next Dynamicweb recycle'
             })
+            .option('output', {
+                choices: ['json'],
+                describe: 'Outputs a single JSON response for automation-friendly parsing'
+            })
         },
         handler: async (argv) => {
-            if (argv.verbose) console.info(`Installing file located at :${argv.filePath}`)
-            await handleInstall(argv)
+            const output = createInstallOutput(argv);
+
+            try {
+                output.verboseLog(`Installing file located at: ${argv.filePath}`);
+                await handleInstall(argv, output)
+            } catch (err) {
+                output.fail(err);
+                process.exitCode = 1;
+            } finally {
+                output.finish();
+            }
         }
     }
 }
 
-async function handleInstall(argv) {
+async function handleInstall(argv, output) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     let resolvedPath = resolveFilePath(argv.filePath);
-    await uploadFiles(env, user, [ resolvedPath ], 'System/AddIns/Local', false, true);
-    await installAddin(env, user, resolvedPath, argv.queue)
+    output.mergeMeta({
+        resolvedPath
+    });
+    await uploadFiles(env, user, [ resolvedPath ], 'System/AddIns/Local', false, true, output);
+    await installAddin(env, user, resolvedPath, argv.queue, output)
 }
 
-async function installAddin(env, user, resolvedPath, queue) {
-    console.log('Installing addin')
+async function installAddin(env, user, resolvedPath, queue, output) {
+    output.log('Installing addin')
     let filename = path.basename(resolvedPath);
     let data = {
         'Queue': queue,
@@ -54,12 +70,82 @@ async function installAddin(env, user, resolvedPath, queue) {
     });
 
     if (res.ok) {
-        if (env.verbose) console.log(await res.json())
-        console.log(`Addin installed`)
+        const body = await res.json();
+        output.addData({
+            type: 'install',
+            filename,
+            queued: Boolean(queue),
+            response: body
+        });
+        output.log(`Addin installed`)
     }
     else {
-        console.log('Request failed, returned error:')
-        console.log(await res.json())
-        process.exit(1);
+        throw createInstallError('Addin install failed.', res.status, await parseJsonSafe(res));
+    }
+}
+
+export function createInstallOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'install',
+        operation: 'install',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {
+            queued: Boolean(argv.queue)
+        }
+    };
+
+    return {
+        json: argv.output === 'json',
+        response,
+        log(...args) {
+            if (!this.json) {
+                console.log(...args);
+            }
+        },
+        verboseLog(...args) {
+            if (argv.verbose && !this.json) {
+                console.info(...args);
+            }
+        },
+        addData(entry) {
+            response.data.push(entry);
+        },
+        mergeMeta(meta) {
+            response.meta = {
+                ...response.meta,
+                ...meta
+            };
+        },
+        fail(err) {
+            response.ok = false;
+            response.status = err?.status || 1;
+            response.errors.push({
+                message: err?.message || 'Unknown install command error.',
+                details: err?.details ?? null
+            });
+        },
+        finish() {
+            if (this.json) {
+                console.log(JSON.stringify(response, null, 2));
+            }
+        }
+    };
+}
+
+function createInstallError(message, status, details = null) {
+    const error = new Error(message);
+    error.status = status;
+    error.details = details;
+    return error;
+}
+
+async function parseJsonSafe(res) {
+    try {
+        return await res.json();
+    } catch {
+        return null;
     }
-}
+}

package/bin/commands/install.test.js

@@ -0,0 +1,48 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+import { createInstallOutput } from './install.js';
+
+test('createInstallOutput suppresses regular logs in json mode and emits the final envelope', () => {
+    const logCalls = [];
+    const infoCalls = [];
+    const originalLog = console.log;
+    const originalInfo = console.info;
+
+    console.log = (...args) => logCalls.push(args);
+    console.info = (...args) => infoCalls.push(args);
+
+    try {
+        const output = createInstallOutput({
+            output: 'json',
+            queue: true,
+            verbose: true
+        });
+
+        output.log('hidden');
+        output.verboseLog('hidden verbose');
+        output.addData({ type: 'install', filename: 'addon.nupkg' });
+        output.mergeMeta({ resolvedPath: '/tmp/addon.nupkg' });
+        output.finish();
+
+        assert.deepEqual(infoCalls, []);
+        assert.equal(logCalls.length, 1);
+
+        const rendered = JSON.parse(logCalls[0][0]);
+        assert.deepEqual(rendered, {
+            ok: true,
+            command: 'install',
+            operation: 'install',
+            status: 200,
+            data: [{ type: 'install', filename: 'addon.nupkg' }],
+            errors: [],
+            meta: {
+                queued: true,
+                resolvedPath: '/tmp/addon.nupkg'
+            }
+        });
+    } finally {
+        console.log = originalLog;
+        console.info = originalInfo;
+    }
+});

package/bin/commands/query.js

@@ -3,7 +3,7 @@ import { setupEnv, getAgent } from './env.js';
 import { setupUser } from './login.js';
 import { input } from '@inquirer/prompts';
 
-const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
+const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env']
 
 export function queryCommand() {
     return {
@@ -22,43 +22,30 @@ export function queryCommand() {
                     alias: 'i',
                     describe: 'Runs in interactive mode to ask for query parameters one by one'
                 })
-                .option('output', {
-                    choices: ['json'],
-                    describe: 'Outputs a single JSON response for automation-friendly parsing'
-                })
         },
-        handler: async (argv) => {
-            const output = createQueryOutput(argv);
-
-            try {
-                output.verboseLog(`Running query ${argv.query}`);
-                await handleQuery(argv, output);
-                output.finish();
-            } catch (err) {
-                output.fail(err);
-                output.finish();
-                process.exit(1);
-            }
+        handler: (argv) => {
+            if (argv.verbose) console.info(`Running query ${argv.query}`)
+            handleQuery(argv)
         }
     }
 }
 
-async function handleQuery(argv, output) {
+async function handleQuery(argv) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     if (argv.list) {
-        const properties = await getProperties(env, user, argv.query);
-        output.addData(properties);
-        output.log(properties);
+        console.log(await getProperties(argv))
     } else {
-        let response = await runQuery(env, user, argv.query, await getQueryParams(argv));
-        output.addData(response);
-        output.log(response);
+        let response = await runQuery(env, user, argv.query, await getQueryParams(argv))
+        console.log(response)
     }
 }
 
-async function getProperties(env, user, query) {
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${query}`, {
+async function getProperties(argv) {
+    let env = await setupEnv(argv);
+    let user = await setupUser(argv, env);
+
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${argv.query}`, {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`
@@ -68,20 +55,20 @@ async function getProperties(env, user, query) {
     if (res.ok) {
         let body = await res.json()
         if (body.model.properties.groups === undefined) {
-            throw createCommandError('Unable to fetch query parameters.', res.status, body);
+            console.log('Unable to fetch query parameters');
+            process.exit(1);
         }
         return body.model.properties.groups.filter(g => g.name === 'Properties')[0].fields.map(field => `${field.name} (${field.typeName})`)
     }
-
-    throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
+    console.log('Unable to fetch query parameters');
+    console.log(res);
+    process.exit(1);
 }
 
 async function getQueryParams(argv) {
     let params = {}
     if (argv.interactive) {
-        let env = await setupEnv(argv);
-        let user = await setupUser(argv, env);
-        let properties = await getProperties(env, user, argv.query);
+        let properties = await getProperties(argv);
         console.log('The following properties will be requested:')
         console.log(properties)
         for (const p of properties) {
@@ -106,67 +93,8 @@ async function runQuery(env, user, query, params) {
         agent: getAgent(env.protocol)
     })
     if (!res.ok) {
-        throw createCommandError(`Error when doing request ${res.url}`, res.status, await parseJsonSafe(res));
+        console.log(`Error when doing request ${res.url}`)
+        process.exit(1);
     }
     return await res.json()
-}
-
-function createQueryOutput(argv) {
-    const response = {
-        ok: true,
-        command: 'query',
-        operation: argv.list ? 'list' : 'run',
-        status: 200,
-        data: [],
-        errors: [],
-        meta: {
-            query: argv.query
-        }
-    };
-
-    return {
-        json: argv.output === 'json',
-        response,
-        log(value) {
-            if (!this.json) {
-                console.log(value);
-            }
-        },
-        verboseLog(...args) {
-            if (argv.verbose && !this.json) {
-                console.info(...args);
-            }
-        },
-        addData(entry) {
-            response.data.push(entry);
-        },
-        fail(err) {
-            response.ok = false;
-            response.status = err?.status || 1;
-            response.errors.push({
-                message: err?.message || 'Unknown query command error.',
-                details: err?.details ?? null
-            });
-        },
-        finish() {
-            if (this.json) {
-                console.log(JSON.stringify(response, null, 2));
-            }
-        }
-    };
-}
-
-function createCommandError(message, status, details = null) {
-    const error = new Error(message);
-    error.status = status;
-    error.details = details;
-    return error;
-}
-
-async function parseJsonSafe(res) {
-    try {
-        return await res.json();
-    } catch {
-        return null;
-    }
-}
+}

package/package.json

@@ -2,7 +2,7 @@
   "name": "@dynamicweb/cli",
   "type": "module",
   "description": "CLI for interacting with Dynamicweb 10 solutions from the command line.",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "main": "bin/index.js",
   "files": [
     "bin/**"
@@ -15,7 +15,7 @@
     "devops"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test"
   },
   "author": "Dynamicweb A/S (https://www.dynamicweb.com)",
   "repository": {
@@ -48,4 +48,4 @@
     "node-fetch": "^3.2.10",
     "yargs": "^17.5.1"
   }
-}
+}