@dynamicweb/cli 1.1.0 → 1.1.2

package/bin/commands/files.js

@@ -10,71 +10,71 @@ 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'
-            })
+                .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) => {
             if (argv.verbose) console.info(`Listing directory at: ${argv.dirPath}`)
@@ -97,18 +97,18 @@ async function handleFiles(argv) {
 
     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);
+
+                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);
+                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 () => {
@@ -117,9 +117,9 @@ async function handleFiles(argv) {
                 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, argv.verbose);
                 }
-                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name), false);
+                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')
             })
         }
@@ -137,21 +137,21 @@ async function handleFiles(argv) {
 }
 
 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) {
+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);
+        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);
+        await processDirectory(env, user, subDir, isRoot ? outPath : path.join(outPath, path.basename(dirPath)), originalDir, createEmpty, false, overwrite, output);
     }
 }
 
@@ -184,12 +184,12 @@ function resolveTree(dirs, indentLevel, parentHasFiles) {
             resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false);
         } else {
             resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles);
-            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false);  
+            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false);
         }
     }
 }
 
-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, verbose = false) {
     let excludeDirectories = '';
     if (!iamstupid) {
         excludeDirectories = 'system/log';
@@ -212,7 +212,7 @@ 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, verbose);
     if (!filename) return;
 
     const filePath = path.resolve(`${path.resolve(outPath)}/${filename}`)
@@ -286,7 +286,7 @@ async function extractArchive(filename, filePath, outPath, raw) {
     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) {
@@ -306,8 +306,9 @@ async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
     }
 }
 
-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 = resolveUploadOutput(output);
+    output.log('Uploading files')
 
     const chunkSize = 300;
     const chunks = [];
@@ -316,30 +317,41 @@ 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 = console) {
     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)));
     });
 
-    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: {
@@ -347,25 +359,66 @@ async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmp
         },
         agent: getAgent(env.protocol)
     });
-    
+
     if (res.ok) {
-        console.log(await res.json())
+        return await res.json()
     }
     else {
-        console.log(res)
-        console.log(await res.json())
+        if (output.structured) {
+            throw createUploadError('File upload failed.', res.status, await parseJsonSafe(res));
+        }
+
+        output.log(res)
+        output.log(await parseJsonSafe(res))
         process.exit(1);
     }
 }
 
+export function resolveUploadOutput(output) {
+    const response = output?.response ?? {};
+    response.meta = response.meta ?? {};
+
+    return {
+        structured: Boolean(output),
+        response,
+        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
+                };
+            }
+    };
+}
+
+function createUploadError(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;
+    }
+}
+
 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);
-        process.exit(1);
+    if (resolvedPath === undefined) {
+        throw new Error('Could not find any files with the name ' + filePath);
     }
     return path.join(p.dir, resolvedPath);
 }
@@ -375,4 +428,3 @@ 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/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.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": {