@dynamicweb/cli 1.1.0 → 1.1.1

package/README.md

@@ -98,6 +98,7 @@ 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
@@ -108,6 +109,9 @@ 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.
@@ -152,6 +156,7 @@ 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
@@ -161,12 +166,16 @@ 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
@@ -183,6 +192,9 @@ 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']
+const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
 
 export function commandCommand() {
     return {
@@ -22,22 +22,38 @@ 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) => {
-            if (argv.verbose) console.info(`Running command ${argv.command}`)
-            await handleCommand(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);
+            }
         }
     }
 }
 
-async function handleCommand(argv) {
+async function handleCommand(argv, output) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     if (argv.list) {
-        console.log(await getProperties(env, user, argv.command))
+        const properties = await getProperties(env, user, argv.command);
+        output.addData(properties);
+        output.log(properties);
     } else {
-        let response = await runCommand(env, user, argv.command, getQueryParams(argv), parseJsonOrPath(argv.json))
-        console.log(response)
+        let response = await runCommand(env, user, argv.command, getQueryParams(argv), parseJsonOrPath(argv.json));
+        output.addData(response);
+        output.log(response);
     }
 }
 
@@ -82,8 +98,67 @@ async function runCommand(env, user, command, queryParams, data) {
         agent: getAgent(env.protocol)
     })
     if (!res.ok) {
-        console.log(`Error when doing request ${res.url}`)
-        process.exit(1);
+        throw createCommandError(`Error when doing request ${res.url}`, res.status, await parseJsonSafe(res));
     }
     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

@@ -75,24 +75,41 @@ export function filesCommand() {
                 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'
+            })
         },
         handler: async (argv) => {
-            if (argv.verbose) console.info(`Listing directory at: ${argv.dirPath}`)
-            await handleFiles(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);
+            }
         }
     }
 }
 
-async function handleFiles(argv) {
+async function handleFiles(argv, output) {
     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;
-        console.log(files.name)
-        let hasFiles = files.files?.data && files.files?.data.length !== 0;
-        resolveTree(files.directories, '', hasFiles);
-        resolveTree(files.files?.data ?? [], '', false);
+        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);
+        }
     }
 
     if (argv.export) {
@@ -106,31 +123,31 @@ async function handleFiles(argv) {
                 let parentDirectory = path.dirname(argv.dirPath);              
                 parentDirectory = parentDirectory === '.' ? '/' : parentDirectory;
                 
-                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.iamstupid, [argv.dirPath], true);
+                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.iamstupid, [argv.dirPath], true, output);
             } else {
-                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false);
+                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, output);
             }
         } else {
             await interactiveConfirm('Are you sure you want a full export of files?', async () => {
-                console.log('Full export is starting')
+                output.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);
+                    await download(env, user, dir.name, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, output);
                 }
-                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name), false);
-                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')
+                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');
             })
         }
     } 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);
+                await processDirectory(env, user, resolvedPath, argv.outPath, resolvedPath, argv.createEmpty, true, argv.overwrite, output);
             } else {
                 let filesInDir = getFilesInDirectory(resolvedPath);
-                await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty, argv.overwrite);
+                await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty, argv.overwrite, output);
             }
         }
     }
@@ -142,20 +159,20 @@ function getFilesInDirectory(dirPath) {
             .filter(file => fs.statSync(file).isFile());
 }
 
-async function processDirectory(env, user, dirPath, outPath, originalDir, createEmpty, isRoot = false, overwrite = false) {
+async function processDirectory(env, user, dirPath, outPath, originalDir, createEmpty, isRoot = false, overwrite = false, output) {
     let filesInDir = getFilesInDirectory(dirPath);
     if (filesInDir.length > 0)
-        await uploadFiles(env, user, filesInDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), createEmpty, overwrite);
+        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());
     for (let subDir of subDirectories) {
-        await processDirectory(env, user, subDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), originalDir, createEmpty, false, overwrite);
+        await processDirectory(env, user, subDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), originalDir, createEmpty, false, overwrite, output);
     }
 }
 
-function resolveTree(dirs, indentLevel, parentHasFiles) {
+function resolveTree(dirs, indentLevel, parentHasFiles, output) {
     let end = `└──`
     let mid = `├──`
     for (let id = 0; id < dirs.length; id++) {
@@ -163,33 +180,33 @@ function resolveTree(dirs, indentLevel, parentHasFiles) {
         let indentPipe = true;
         if (dirs.length == 1) {
             if (parentHasFiles) {
-                console.log(indentLevel + mid, dir.name)
+                output.log(indentLevel + mid, dir.name)
             } else {
-                console.log(indentLevel + end, dir.name)
+                output.log(indentLevel + end, dir.name)
                 indentPipe = false;
             }
         } else if (id != dirs.length - 1) {
-            console.log(indentLevel + mid, dir.name)
+            output.log(indentLevel + mid, dir.name)
         } else {
             if (parentHasFiles) {
-                console.log(indentLevel + mid, dir.name)
+                output.log(indentLevel + mid, dir.name)
             } else {
-                console.log(indentLevel + end, dir.name)
+                output.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);
-            resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false);
+            resolveTree(dir.directories ?? [], indentLevel + '│\t', hasFiles, output);
+            resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false, output);
         } else {
-            resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles);
-            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false);  
+            resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles, output);
+            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false, output);  
         }
     }
 }
 
-async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames, singleFileMode) {
+async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames, singleFileMode, output) {
     let excludeDirectories = '';
     if (!iamstupid) {
         excludeDirectories = 'system/log';
@@ -200,7 +217,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);
+    displayDownloadMessage(dirPath, fileNames, recursive, singleFileMode, output);
 
     const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${endpoint}`, {
         method: 'POST',
@@ -212,27 +229,40 @@ async function download(env, user, dirPath, outPath, recursive, outname, raw, ia
         agent: getAgent(env.protocol)
     });
 
-    const filename = outname || tryGetFileNameFromResponse(res, dirPath);
+    const filename = outname || tryGetFileNameFromResponse(res, dirPath, output.verbose);
     if (!filename) return;
 
     const filePath = path.resolve(`${path.resolve(outPath)}/${filename}`)
-    const updater = createThrottledStatusUpdater();
+    const updater = output.json ? null : createThrottledStatusUpdater();
 
     await downloadWithProgress(res, filePath, {
         onData: (received) => {
-            updater.update(`Received:\t${formatBytes(received)}`);
+            if (updater) {
+                updater.update(`Received:\t${formatBytes(received)}`);
+            }
         }
     });
 
-    updater.stop();
+    if (updater) {
+        updater.stop();
+    }
 
     if (singleFileMode) {
-        console.log(`Successfully downloaded: ${filename}`);
+        output.log(`Successfully downloaded: ${filename}`);
     } else {
-        console.log(`Finished downloading`, dirPath === '/.' ? '.' : dirPath, 'Recursive=' + recursive);
+        output.log(`Finished downloading`, dirPath === '/.' ? '.' : dirPath, 'Recursive=' + recursive);
     }
 
-    await extractArchive(filename, filePath, outPath, raw);
+    output.addData({
+        type: 'download',
+        directoryPath: dirPath,
+        filename,
+        outPath: path.resolve(outPath),
+        recursive,
+        raw
+    });
+
+    await extractArchive(filename, filePath, outPath, raw, output);
 }
 
 function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames, recursive, singleFileMode) {
@@ -249,10 +279,10 @@ function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames
     return { endpoint: 'FileDownload', data };
 }
 
-function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileMode) {
+function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileMode, output) {
     if (singleFileMode) {
         const fileName = path.basename(fileNames[0] || 'unknown');
-        console.log('Downloading file: ' + fileName);
+        output.log('Downloading file: ' + fileName);
 
         return;
     }
@@ -261,30 +291,34 @@ function displayDownloadMessage(directoryPath, fileNames, recursive, singleFileM
         ? 'Base'
         : directoryPath;
 
-    console.log('Downloading', directoryPathDisplayName, 'Recursive=' + recursive);
+    output.log('Downloading', directoryPathDisplayName, 'Recursive=' + recursive);
 }
 
-async function extractArchive(filename, filePath, outPath, raw) {
+async function extractArchive(filename, filePath, outPath, raw, output) {
     if (raw) {
         return;
     }
 
-    console.log(`\nExtracting ${filename} to ${outPath}`);
+    output.log(`\nExtracting ${filename} to ${outPath}`);
     let destinationFilename = filename.replace('.zip', '');
     if (destinationFilename === 'Base')
         destinationFilename = '';
 
     const destinationPath = `${path.resolve(outPath)}/${destinationFilename}`;
-    const updater = createThrottledStatusUpdater();
+    const updater = output.json ? null : createThrottledStatusUpdater();
 
     await extractWithProgress(filePath, destinationPath, {
         onEntry: (processedEntries, totalEntries, percent) => {
-            updater.update(`Extracted:\t${processedEntries} of ${totalEntries} files (${percent}%)`);
+            if (updater) {
+                updater.update(`Extracted:\t${processedEntries} of ${totalEntries} files (${percent}%)`);
+            }
         }
     });
 
-    updater.stop();
-    console.log(`Finished extracting ${filename} to ${outPath}\n`);
+    if (updater) {
+        updater.stop();
+    }
+    output.log(`Finished extracting ${filename} to ${outPath}\n`);
 
     fs.unlink(filePath, function(err) {});
 }
@@ -300,14 +334,12 @@ async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
     if (res.ok) {
         return await res.json();
     } else {
-        console.log(res);
-        console.log(await res.json());
-        process.exit(1);
+        throw createCommandError('Unable to fetch file structure.', res.status, await parseJsonSafe(res));
     }
 }
 
-export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false, overwrite = false) {
-    console.log('Uploading files')
+export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false, overwrite = false, output) {
+    output.log('Uploading files')
 
     const chunkSize = 300;
     const chunks = [];
@@ -316,26 +348,37 @@ export async function uploadFiles(env, user, localFilePaths, destinationPath, cr
         chunks.push(localFilePaths.slice(i, i + chunkSize));
     }
 
+    output.mergeMeta({
+        filesProcessed: (output.response.meta.filesProcessed || 0) + localFilePaths.length,
+        chunks: (output.response.meta.chunks || 0) + chunks.length
+    });
+
     for (let i = 0; i < chunks.length; i++) {
-        console.log(`Uploading chunk ${i + 1} of ${chunks.length}`);
+        output.log(`Uploading chunk ${i + 1} of ${chunks.length}`);
 
         const chunk = chunks[i];
-        await uploadChunk(env, user, chunk, destinationPath, createEmpty, overwrite);
-
-        console.log(`Finished uploading chunk ${i + 1} of ${chunks.length}`);
+        const body = await uploadChunk(env, user, chunk, destinationPath, createEmpty, overwrite, output);
+        output.addData({
+            type: 'upload',
+            destinationPath,
+            files: chunk.map(filePath => path.resolve(filePath)),
+            response: body
+        });
+
+        output.log(`Finished uploading chunk ${i + 1} of ${chunks.length}`);
     }
 
-    console.log(`Finished uploading files. Total files: ${localFilePaths.length}, total chunks: ${chunks.length}`);
+    output.log(`Finished uploading files. Total files: ${localFilePaths.length}, total chunks: ${chunks.length}`);
 }
 
-async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmpty, overwrite) {
+async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmpty, overwrite, output) {
     const form = new FormData();
     form.append('path', destinationPath);
     form.append('skipExistingFiles', String(!overwrite));
     form.append('allowOverwrite', String(overwrite));
     
     filePathsChunk.forEach(fileToUpload => {
-        console.log(`${fileToUpload}`)
+        output.log(`${fileToUpload}`)
         form.append('files', fs.createReadStream(path.resolve(fileToUpload)));
     });
 
@@ -349,12 +392,10 @@ async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmp
     });
     
     if (res.ok) {
-        console.log(await res.json())
+        return await res.json();
     }
     else {
-        console.log(res)
-        console.log(await res.json())
-        process.exit(1);
+        throw createCommandError('File upload failed.', res.status, await parseJsonSafe(res));
     }
 }
 
@@ -376,3 +417,86 @@ function wildcardToRegExp(wildcard) {
     return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
 }
 
+function createFilesOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'files',
+        operation: getFilesOperation(argv),
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {}
+    };
+
+    return {
+        json: Boolean(argv.json),
+        verbose: Boolean(argv.verbose),
+        response,
+        log(...args) {
+            if (!this.json) {
+                console.log(...args);
+            }
+        },
+        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) {
+    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/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']
+const exclude = ['_', '$0', 'query', 'list', 'i', 'l', 'interactive', 'verbose', 'v', 'host', 'protocol', 'apiKey', 'env', 'output']
 
 export function queryCommand() {
     return {
@@ -22,30 +22,43 @@ 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: (argv) => {
-            if (argv.verbose) console.info(`Running query ${argv.query}`)
-            handleQuery(argv)
+        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);
+            }
         }
     }
 }
 
-async function handleQuery(argv) {
+async function handleQuery(argv, output) {
     let env = await setupEnv(argv);
     let user = await setupUser(argv, env);
     if (argv.list) {
-        console.log(await getProperties(argv))
+        const properties = await getProperties(env, user, argv.query);
+        output.addData(properties);
+        output.log(properties);
     } else {
-        let response = await runQuery(env, user, argv.query, await getQueryParams(argv))
-        console.log(response)
+        let response = await runQuery(env, user, argv.query, await getQueryParams(argv));
+        output.addData(response);
+        output.log(response);
     }
 }
 
-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}`, {
+async function getProperties(env, user, query) {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/QueryByName?name=${query}`, {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`
@@ -55,20 +68,20 @@ async function getProperties(argv) {
     if (res.ok) {
         let body = await res.json()
         if (body.model.properties.groups === undefined) {
-            console.log('Unable to fetch query parameters');
-            process.exit(1);
+            throw createCommandError('Unable to fetch query parameters.', res.status, body);
         }
         return body.model.properties.groups.filter(g => g.name === 'Properties')[0].fields.map(field => `${field.name} (${field.typeName})`)
     }
-    console.log('Unable to fetch query parameters');
-    console.log(res);
-    process.exit(1);
+
+    throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
 }
 
 async function getQueryParams(argv) {
     let params = {}
     if (argv.interactive) {
-        let properties = await getProperties(argv);
+        let env = await setupEnv(argv);
+        let user = await setupUser(argv, env);
+        let properties = await getProperties(env, user, argv.query);
         console.log('The following properties will be requested:')
         console.log(properties)
         for (const p of properties) {
@@ -93,8 +106,67 @@ async function runQuery(env, user, query, params) {
         agent: getAgent(env.protocol)
     })
     if (!res.ok) {
-        console.log(`Error when doing request ${res.url}`)
-        process.exit(1);
+        throw createCommandError(`Error when doing request ${res.url}`, res.status, await parseJsonSafe(res));
     }
     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/bin/downloader.js

@@ -9,7 +9,7 @@ import fs from 'fs';
 export function getFileNameFromResponse(res, dirPath) {
     const header = res.headers.get('content-disposition');
     const parts = header?.split(';');
-    
+
     if (!parts) {
         const msg = `No files found in directory '${dirPath}', if you want to download all folders recursively include the -r flag`;
         throw new Error(msg);
@@ -24,13 +24,16 @@ export function getFileNameFromResponse(res, dirPath) {
  *
  * @param {Object} res - The HTTP response object to extract the file name from.
  * @param {string} dirPath - The directory path to use for file name resolution.
+ * @param {boolean} verbose - Whether to log missing download information.
  * @returns {string|null} The extracted file name, or null if extraction fails.
  */
-export function tryGetFileNameFromResponse(res, dirPath) {
+export function tryGetFileNameFromResponse(res, dirPath, verbose = false) {
     try {
         return getFileNameFromResponse(res, dirPath);
     } catch (err) {
-        console.error(err.message);
+        if (verbose) {
+            console.log(err.message);
+        }
         return null;
     }
 }
@@ -56,7 +59,7 @@ export function downloadWithProgress(res, filePath, options) {
         res.body.on("data", chunk => {
             const isFirstChunk = receivedBytes === 0;
             const elapsed = Date.now() - startTime;
-            
+
             receivedBytes += chunk.length;
 
             if (options?.onData) {
@@ -64,4 +67,4 @@ export function downloadWithProgress(res, filePath, options) {
             }
         });
     });
-}
+}

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.0",
+  "version": "1.1.1",
   "main": "bin/index.js",
   "files": [
     "bin/**"
@@ -48,4 +48,4 @@
     "node-fetch": "^3.2.10",
     "yargs": "^17.5.1"
   }
-}
+}