@dynamicweb/cli 2.0.0-beta.0 → 2.0.0-beta.2

package/README.md

@@ -440,7 +440,7 @@ Download the latest Swift release, a specific tag, or the nightly build.
 
 ```sh
 dw swift -l
-dw swift . --tag v1.25.1 --force
+dw swift . --tag v2.3.0 --force
 dw swift . --nightly --force
 ```
 
@@ -465,6 +465,15 @@ dw query HealthCheck \
 
 For longer-lived runners, you can configure a saved environment once with `dw login --oauth`. Full CI/CD guidance will be expanded in the documentation.
 
+## QA Smoke Testing
+
+This repository now includes a reusable QA harness in [qa/README.md](qa/README.md). It runs the CLI against a real DynamicWeb solution using OAuth client credentials, keeps its own isolated `HOME`, and can exercise both:
+
+- saved-environment developer flow
+- ephemeral CI/CD-style flow with `--host --auth oauth`
+
+The harness currently excludes `database` and `swift`.
+
 ## Using Git Bash
 
 Git Bash can rewrite relative paths in a way that interferes with CLI file operations. If you see the path-conversion warning, disable it for the session before running file commands:

package/bin/commands/command.js

@@ -8,24 +8,24 @@ const exclude = ['_', '$0', 'command', 'list', 'json', 'verbose', 'v', 'host', '
 
 export function commandCommand() {
     return {
-        command: 'command [command]', 
-        describe: 'Runs the given command', 
+        command: 'command [command]',
+        describe: 'Runs the given command',
         builder: (yargs) => {
             return yargs
-            .positional('command', {
-                describe: 'The command to execute'
-            })
-            .option('json', {
-                describe: 'Literal json or location of json file to send'
-            })
-            .option('list', {
-                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'
-            })
+                .positional('command', {
+                    describe: 'The command to execute'
+                })
+                .option('json', {
+                    describe: 'Literal json or location of json file to send'
+                })
+                .option('list', {
+                    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);
@@ -61,19 +61,22 @@ async function getProperties(env, user, command) {
     throw createCommandError('The --list option is not currently implemented for commands.');
 }
 
-function getQueryParams(argv) {
+export function getQueryParams(argv) {
     let params = {}
     Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params['Command.' + k] = argv[k])
     return params
 }
 
-function parseJsonOrPath(json) {
+export function parseJsonOrPath(json) {
     if (!json) return
+    const trimmed = json.trim();
+    if (trimmed.startsWith('{') || trimmed.startsWith('[')) {
+        return JSON.parse(trimmed);
+    }
     if (fs.existsSync(json)) {
-        return JSON.parse(fs.readFileSync(path.resolve(json)))
-    } else {
-        return JSON.parse(json)
+        return JSON.parse(fs.readFileSync(path.resolve(json)));
     }
+    return JSON.parse(json);
 }
 
 async function runCommand(env, user, command, queryParams, data) {

package/bin/commands/config.js

@@ -27,10 +27,22 @@ export function setupConfig() {
 }
 
 export function getConfig() {
-    return localConfig;
+    return localConfig || {};
+}
+
+/**
+ * Overrides the in-memory config for testing.
+ * @param {Object} config - Must be a plain, non-null object; handleConfig writes keys directly onto it.
+ */
+export function setConfigForTests(config) {
+    if (config === null || typeof config !== 'object') {
+        throw new Error('setConfigForTests: config must be a plain object');
+    }
+    localConfig = config;
 }
 
 export function handleConfig(argv) {
+    localConfig = localConfig || {};
     Object.keys(argv).forEach(a => {
         if (a != '_' && a != '$0') {
             localConfig[a] = resolveConfig(a, argv[a], localConfig[a] || {});
@@ -52,4 +64,4 @@ function resolveConfig(key, obj, conf) {
         conf[a] = resolveConfig(key, obj[a], conf[a]);
     })
     return conf;
-}
+}

package/bin/commands/env.js

@@ -22,6 +22,30 @@ export function getAgent(protocol) {
     return protocol === 'http' ? httpAgent : httpsAgent;
 }
 
+export function parseHostInput(hostValue) {
+    if (!hostValue || typeof hostValue !== 'string' || !hostValue.trim()) {
+        throw createCommandError(`Invalid host value: ${hostValue}`);
+    }
+    hostValue = hostValue.trim();
+    const hostSplit = hostValue.split('://');
+
+    if (hostSplit.length === 1) {
+        return {
+            protocol: 'https',
+            host: hostSplit[0]
+        };
+    }
+
+    if (hostSplit.length === 2) {
+        return {
+            protocol: hostSplit[0],
+            host: hostSplit[1]
+        };
+    }
+
+    throw createCommandError(`Issues resolving host ${hostValue}`);
+}
+
 export function envCommand() {
     return {
         command: 'env [env]',
@@ -61,7 +85,9 @@ export function envCommand() {
     }
 }
 
-export async function setupEnv(argv, output = null) {
+export async function setupEnv(argv, output = null, deps = {}) {
+    const interactiveEnvFn = deps.interactiveEnvFn || interactiveEnv;
+    const cfg = getConfig();
     let env = {};
     let askEnv = true;
 
@@ -75,8 +101,8 @@ export async function setupEnv(argv, output = null) {
         }
     }
 
-    if (askEnv && getConfig().env) {
-        env = getConfig().env[argv.env] || getConfig().env[getConfig()?.current?.env];
+    if (askEnv && cfg.env) {
+        env = cfg.env[argv.env] || cfg.env[cfg?.current?.env];
         if (env && !env.protocol) {
             logMessage(argv, 'Protocol for environment not set, defaulting to https');
             env.protocol = 'https';
@@ -88,7 +114,7 @@ export async function setupEnv(argv, output = null) {
         }
 
         logMessage(argv, 'Current environment not set, please set it');
-        await interactiveEnv(argv, {
+        await interactiveEnvFn(argv, {
             environment: {
                 type: 'input'
             },
@@ -96,7 +122,8 @@ export async function setupEnv(argv, output = null) {
                 default: true
             }
         }, output)
-        env = getConfig().env[getConfig()?.current?.env];
+        const updatedConfig = getConfig();
+        env = updatedConfig.env?.[updatedConfig?.current?.env];
     }
 
     if (!env || Object.keys(env).length === 0) {
@@ -119,7 +146,9 @@ async function handleEnv(argv, output) {
         output.log(`Users in environment ${env}: ${users}`);
     } else if (argv.env) {
         const result = await changeEnv(argv, output);
-        output.addData(result);
+        if (result !== null) {
+            output.addData(result);
+        }
     } else if (argv.list) {
         const environments = Object.keys(getConfig().env || {});
         output.addData({ environments });
@@ -160,16 +189,9 @@ export async function interactiveEnv(argv, options, output) {
     }
     getConfig().env[result.environment] = getConfig().env[result.environment] || {};
     if (result.host) {
-        const hostSplit = result.host.split("://");
-        if (hostSplit.length == 1) {
-            getConfig().env[result.environment].protocol = 'https';
-            getConfig().env[result.environment].host = hostSplit[0];
-        } else if (hostSplit.length == 2) {
-            getConfig().env[result.environment].protocol = hostSplit[0];
-            getConfig().env[result.environment].host = hostSplit[1];
-        } else {
-            throw createCommandError(`Issues resolving host ${result.host}`);
-        }
+        const resolvedHost = parseHostInput(result.host);
+        getConfig().env[result.environment].protocol = resolvedHost.protocol;
+        getConfig().env[result.environment].host = resolvedHost.host;
     }
     if (result.environment) {
         getConfig().current = getConfig().current || {};
@@ -182,7 +204,7 @@ export async function interactiveEnv(argv, options, output) {
     const currentEnv = getConfig().env[result.environment];
     const data = {
         environment: result.environment,
-        protocol: currentEnv.protocol,
+        protocol: currentEnv.protocol || null,
         host: currentEnv.host || null,
         current: getConfig().current.env
     };
@@ -197,13 +219,13 @@ export async function interactiveEnv(argv, options, output) {
 async function changeEnv(argv, output) {
     const environments = getConfig().env || {};
 
-    if (!Object.keys(environments).includes(argv.env)) {
+    if (!Object.hasOwn(environments, argv.env)) {
         if (isJsonOutput(argv)) {
             throw createCommandError(`The specified environment ${argv.env} doesn't exist, please create it`, 404);
         }
 
         logMessage(argv, `The specified environment ${argv.env} doesn't exist, please create it`);
-        return await interactiveEnv(argv, {
+        await interactiveEnv(argv, {
             environment: {
                 type: 'input',
                 default: argv.env,
@@ -218,6 +240,7 @@ async function changeEnv(argv, output) {
                 default: true
             }
         }, output)
+        return null;
     } else {
         getConfig().current.env = argv.env;
         updateConfig();
@@ -226,7 +249,10 @@ async function changeEnv(argv, output) {
             current: getConfig().current.env
         };
         logMessage(argv, `Your current environment is now ${getConfig().current.env}`);
-        return data;
+        if (output) {
+            output.addData(data);
+        }
+        return null;
     }
 }
 

package/bin/commands/files.js

@@ -10,102 +10,102 @@ 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('dangerouslyIncludeLogsAndCache', {
-                type: 'boolean',
-                describe: 'Includes log and cache folders during export. Risky and usually not recommended'
-            })
-            .option('iamstupid', {
-                type: 'boolean',
-                hidden: true,
-                describe: 'Deprecated alias for --dangerouslyIncludeLogsAndCache'
-            })
-            .option('delete', {
-                alias: 'd',
-                type: 'boolean',
-                describe: 'Deletes the file or directory at [dirPath]. Detects type from path (use --asFile/--asDirectory to override)'
-            })
-            .option('empty', {
-                type: 'boolean',
-                describe: 'Used with --delete, empties a directory instead of deleting it'
-            })
-            .option('copy', {
-                type: 'string',
-                describe: 'Copies the file or directory at [dirPath] to the given destination path'
-            })
-            .option('move', {
-                type: 'string',
-                describe: 'Moves the file or directory at [dirPath] to the given destination path'
-            })
-            .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('output', {
-                choices: ['json'],
-                describe: 'Outputs a single JSON response for automation-friendly parsing'
-            })
-            .option('json', {
-                type: 'boolean',
-                hidden: true,
-                describe: 'Deprecated alias for --output json'
-            })
+                .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('dangerouslyIncludeLogsAndCache', {
+                    type: 'boolean',
+                    describe: 'Includes log and cache folders during export. Risky and usually not recommended'
+                })
+                .option('iamstupid', {
+                    type: 'boolean',
+                    hidden: true,
+                    describe: 'Deprecated alias for --dangerouslyIncludeLogsAndCache'
+                })
+                .option('delete', {
+                    alias: 'd',
+                    type: 'boolean',
+                    describe: 'Deletes the file or directory at [dirPath]. Detects type from path (use --asFile/--asDirectory to override)'
+                })
+                .option('empty', {
+                    type: 'boolean',
+                    describe: 'Used with --delete, empties a directory instead of deleting it'
+                })
+                .option('copy', {
+                    type: 'string',
+                    describe: 'Copies the file or directory at [dirPath] to the given destination path'
+                })
+                .option('move', {
+                    type: 'string',
+                    describe: 'Moves the file or directory at [dirPath] to the given destination path'
+                })
+                .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('output', {
+                    choices: ['json'],
+                    describe: 'Outputs a single JSON response for automation-friendly parsing'
+                })
+                .option('json', {
+                    type: 'boolean',
+                    hidden: true,
+                    describe: 'Deprecated alias for --output json'
+                })
         },
         handler: async (argv) => {
             if (argv.json && !argv.output) {
@@ -149,13 +149,13 @@ async function handleFiles(argv, output) {
 
     if (argv.export) {
         if (argv.dirPath) {
-            
+
             const isFile = isFilePath(argv, 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.dangerouslyIncludeLogsAndCache, [argv.dirPath], true, output);
             } else {
                 await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.dangerouslyIncludeLogsAndCache, [], false, output);
@@ -231,9 +231,9 @@ async function handleFiles(argv, output) {
 }
 
 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) {
@@ -242,8 +242,8 @@ async function processDirectory(env, user, dirPath, outPath, originalDir, create
         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);
     }
@@ -278,7 +278,7 @@ function resolveTree(dirs, indentLevel, parentHasFiles, output) {
             resolveTree(dir.files?.data ?? [], indentLevel + '│\t', false, output);
         } else {
             resolveTree(dir.directories ?? [], indentLevel + '\t', hasFiles, output);
-            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false, output);  
+            resolveTree(dir.files?.data ?? [], indentLevel + '\t', false, output);
         }
     }
 }
@@ -342,7 +342,7 @@ async function download(env, user, dirPath, outPath, recursive, outname, raw, da
     await extractArchive(filename, filePath, outPath, raw, output);
 }
 
-function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames, recursive, singleFileMode) {
+export function prepareDownloadCommandData(directoryPath, excludeDirectories, fileNames, recursive, singleFileMode) {
     const data = {
         'DirectoryPath': directoryPath ?? '/',
         'ExcludeDirectories': [excludeDirectories],
@@ -397,10 +397,8 @@ async function extractArchive(filename, filePath, outPath, raw, output) {
     }
     output.log(`Finished extracting ${filename} to ${outPath}\n`);
 
-    fs.unlink(filePath, function(err) {
-        if (err) {
-            output.verboseLog(`Warning: Failed to delete temporary archive ${filePath}: ${err.message}`);
-        }
+    await fs.promises.unlink(filePath).catch(err => {
+        output.verboseLog(`Warning: Failed to delete temporary archive ${filePath}: ${err.message}`);
     });
 }
 
@@ -577,13 +575,13 @@ async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmp
     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: {
@@ -591,7 +589,7 @@ async function uploadChunk(env, user, filePathsChunk, destinationPath, createEmp
         },
         agent: getAgent(env.protocol)
     });
-    
+
     if (res.ok) {
         return await res.json();
     }
@@ -604,22 +602,21 @@ 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)
-    {
+    if (resolvedPath === undefined) {
         throw createCommandError(`Could not find any files with the name ${filePath}`, 1);
     }
     return path.join(p.dir, resolvedPath);
 }
 
 
-function isFilePath(argv, dirPath) {
+export function isFilePath(argv, dirPath) {
     if (argv.asFile || argv.asDirectory) {
-        return argv.asFile;
+        return Boolean(argv.asFile);
     }
     return path.extname(dirPath) !== '';
 }
 
-function wildcardToRegExp(wildcard) {
+export function wildcardToRegExp(wildcard) {
     const escaped = wildcard.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
     return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
 }
@@ -678,7 +675,7 @@ function createFilesOutput(argv) {
     };
 }
 
-function getFilesOperation(argv) {
+export function getFilesOperation(argv) {
     if (argv.list) {
         return 'list';
     }

package/bin/commands/install.js

@@ -6,22 +6,22 @@ import { uploadFiles, resolveFilePath } from './files.js';
 
 export function installCommand() {
     return {
-        command: 'install [filePath]',
+        command: 'install <filePath>',
         describe: 'Installs the addin on the given path, allowed file extensions are .dll, .nupkg',
         builder: (yargs) => {
             return yargs
-            .positional('filePath', {
-                describe: 'Path to the file to install'
-            })
-            .option('queue', {
-                alias: 'q',
-                type: 'boolean',
-                describe: 'Queues the install for next Dynamicweb recycle'
-            })
-            .option('output', {
-                choices: ['json'],
-                describe: 'Outputs a single JSON response for automation-friendly parsing'
-            })
+                .positional('filePath', {
+                    describe: 'Path to the file to install'
+                })
+                .option('queue', {
+                    alias: 'q',
+                    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) => {
             const output = createInstallOutput(argv);
@@ -43,7 +43,7 @@ async function handleInstall(argv, output) {
     let env = await setupEnv(argv, output);
     let user = await setupUser(argv, env);
     let resolvedPath = resolveFilePath(argv.filePath);
-    await uploadFiles(env, user, [ resolvedPath ], 'System/AddIns/Local', false, true, output);
+    await uploadFiles(env, user, [resolvedPath], 'System/AddIns/Local', false, true, output);
     await installAddin(env, user, resolvedPath, argv.queue, output);
 }
 
@@ -56,15 +56,29 @@ async function installAddin(env, user, resolvedPath, queue, output) {
             `${filename.substring(0, filename.lastIndexOf('.')) || filename}|${path.extname(resolvedPath)}`
         ]
     }
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AddinInstall`, {
-        method: 'POST',
-        body: JSON.stringify(data),
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${user.apiKey}`
-        },
-        agent: getAgent(env.protocol)
-    });
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 30_000);
+
+    let res;
+    try {
+        res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AddinInstall`, {
+            method: 'POST',
+            body: JSON.stringify(data),
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${user.apiKey}`
+            },
+            agent: getAgent(env.protocol),
+            signal: controller.signal
+        });
+    } catch (err) {
+        if (err.name === 'AbortError') {
+            throw createCommandError('Addin installation request timed out.', 408);
+        }
+        throw err;
+    } finally {
+        clearTimeout(timeoutId);
+    }
 
     if (res.ok) {
         const body = await parseJsonSafe(res);

package/bin/commands/login.js

@@ -216,7 +216,7 @@ async function login(username, password, env, protocol, verbose) {
     }
 }
 
-function parseCookies (cookieHeader) {
+export function parseCookies (cookieHeader) {
     const list = {};
     if (!cookieHeader) {
         return list;
@@ -415,7 +415,7 @@ async function authenticateWithOAuth(argv, env) {
     };
 }
 
-function shouldUseOAuth(argv, env = {}) {
+export function shouldUseOAuth(argv, env = {}) {
     if (argv.auth === 'user') {
         return false;
     }
@@ -435,7 +435,7 @@ function shouldUseOAuth(argv, env = {}) {
     return env?.auth?.type === 'oauth_client_credentials';
 }
 
-function resolveOAuthConfig(argv, env = {}, requireCredentials = true) {
+export function resolveOAuthConfig(argv, env = {}, requireCredentials = true) {
     const authConfig = env?.auth || {};
     const clientIdEnv = argv.clientIdEnv || authConfig.clientIdEnv || DEFAULT_CLIENT_ID_ENV;
     const clientSecretEnv = argv.clientSecretEnv || authConfig.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV;

package/bin/commands/query.js

@@ -74,33 +74,57 @@ async function getProperties(env, user, query) {
         if (body?.model?.properties?.groups === undefined) {
             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})`)
+        return extractQueryPropertyPrompts(body);
     }
 
     throw createCommandError('Unable to fetch query parameters.', res.status, await parseJsonSafe(res));
 }
 
-async function getQueryParams(env, user, argv, output) {
+export async function getQueryParams(env, user, argv, output, deps = {}) {
     let params = {}
+    const getPropertiesFn = deps.getPropertiesFn || getProperties;
+    const promptFn = deps.promptFn || input;
     if (argv.interactive) {
-        let properties = await getProperties(env, user, argv.query);
+        let properties = await getPropertiesFn(env, user, argv.query);
         output.log('The following properties will be requested:')
         output.log(properties)
-        for (const p of properties) {
-            const value = await input({ message: p });
-            if (value) {
-                const fieldName = p.split(' (')[0];
-                params[fieldName] = value;
-            }
-        }
+        params = await buildInteractiveQueryParams(properties, promptFn);
     } else {
-        Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params[k] = argv[k])
+        params = buildQueryParamsFromArgv(argv);
+    }
+    return params
+}
+
+export function extractQueryPropertyPrompts(body) {
+    const fields = body?.model?.properties?.groups?.find(g => g.name === 'Properties')?.fields || [];
+    return fields.map(field => `${field.name} (${field.typeName})`);
+}
+
+export function getFieldNameFromPropertyPrompt(prompt) {
+    return prompt.replace(/\s+\([^)]+\)$/, '');
+}
+
+export async function buildInteractiveQueryParams(properties, promptFn = input) {
+    const params = {};
+
+    for (const propertyPrompt of properties) {
+        const value = await promptFn({ message: propertyPrompt });
+        if (value) {
+            params[getFieldNameFromPropertyPrompt(propertyPrompt)] = value;
+        }
     }
+
+    return params;
+}
+
+export function buildQueryParamsFromArgv(argv) {
+    let params = {}
+    Object.keys(argv).filter(k => !exclude.includes(k)).forEach(k => params[k] = argv[k])
     return params
 }
 
 async function runQuery(env, user, query, params) {
-    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${query}?` + new URLSearchParams(params), {
+    let res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${encodeURIComponent(query)}?` + new URLSearchParams(params), {
         method: 'GET',
         headers: {
             'Authorization': `Bearer ${user.apiKey}`

package/bin/index.js

@@ -84,8 +84,12 @@ function baseCommand() {
             } else if (currentEnv?.current?.user) {
                 console.log(`User: ${currentEnv.current.user}`);
             }
-            console.log(`Protocol: ${currentEnv.protocol}`);
-            console.log(`Host: ${currentEnv.host}`);
+            if (currentEnv.protocol) {
+                console.log(`Protocol: ${currentEnv.protocol}`);
+            }
+            if (currentEnv.host) {
+                console.log(`Host: ${currentEnv.host}`);
+            }
         }
     }
 }

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": "2.0.0-beta.0",
+  "version": "2.0.0-beta.2",
   "main": "bin/index.js",
   "files": [
     "bin/**"
@@ -15,7 +15,8 @@
     "devops"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node --test",
+    "qa:smoke": "node qa/run-smoke.mjs"
   },
   "author": "Dynamicweb A/S (https://www.dynamicweb.com)",
   "repository": {