@dynamicweb/cli 1.1.0 → 2.0.0-beta.0

package/bin/commands/install.js

@@ -1,13 +1,13 @@
 import fetch from 'node-fetch';
 import path from 'path';
-import { setupEnv, getAgent } from './env.js';
+import { setupEnv, getAgent, createCommandError } from './env.js';
 import { setupUser } from './login.js';
 import { uploadFiles, resolveFilePath } from './files.js';
 
 export function installCommand() {
     return {
-        command: 'install [filePath]', 
-        describe: 'Installs the addin on the given path, allowed file extensions are .dll, .nupkg', 
+        command: 'install [filePath]',
+        describe: 'Installs the addin on the given path, allowed file extensions are .dll, .nupkg',
         builder: (yargs) => {
             return yargs
             .positional('filePath', {
@@ -18,24 +18,37 @@ 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) {
-    let env = await setupEnv(argv);
+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);
-    await installAddin(env, user, resolvedPath, argv.queue)
+    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 +67,79 @@ 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 parseJsonSafe(res);
+        output.verboseLog(body);
+        output.addData({
+            type: 'install',
+            filePath: resolvedPath,
+            filename,
+            queued: Boolean(queue),
+            response: body
+        });
+        output.log('Addin installed');
+    } else {
+        const body = await parseJsonSafe(res);
+        throw createCommandError('Addin installation failed.', res.status, body);
     }
-    else {
-        console.log('Request failed, returned error:')
-        console.log(await res.json())
-        process.exit(1);
+}
+
+function createInstallOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'install',
+        operation: argv.queue ? 'queue' : 'install',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {
+            filePath: argv.filePath
+        }
+    };
+
+    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(metaOrFn) {
+            const meta = typeof metaOrFn === 'function' ? metaOrFn(response.meta) : metaOrFn;
+            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));
+            }
+        }
+    };
+}
+
+
+async function parseJsonSafe(res) {
+    try {
+        return await res.json();
+    } catch {
+        return null;
     }
-}
+}

package/bin/commands/login.js

@@ -1,8 +1,12 @@
 import fetch from 'node-fetch';
-import { interactiveEnv, getAgent } from './env.js'
+import { interactiveEnv, getAgent, isJsonOutput, createCommandError } from './env.js'
 import { updateConfig, getConfig } from './config.js';
 import { input, password } from '@inquirer/prompts';
 
+const DEFAULT_OAUTH_TOKEN_PATH = '/Admin/OAuth/token';
+const DEFAULT_CLIENT_ID_ENV = 'DW_CLIENT_ID';
+const DEFAULT_CLIENT_SECRET_ENV = 'DW_CLIENT_SECRET';
+
 export function loginCommand() {
     return {
         command: 'login [user]',
@@ -12,8 +16,27 @@ export function loginCommand() {
             .positional('user', {
                 describe: 'user'
             })
+            .option('oauth', {
+                type: 'boolean',
+                describe: 'Configures OAuth client_credentials authentication for the current environment'
+            })
+            .option('output', {
+                choices: ['json'],
+                describe: 'Outputs a single JSON response for automation-friendly parsing'
+            })
         },
-        handler: (argv) => handleLogin(argv)
+        handler: async (argv) => {
+            const output = createLoginOutput(argv);
+
+            try {
+                await handleLogin(argv, output);
+            } catch (err) {
+                output.fail(err);
+                process.exitCode = 1;
+            } finally {
+                output.finish();
+            }
+        }
     }
 }
 
@@ -26,17 +49,24 @@ export async function setupUser(argv, env) {
         askLogin = false;
     }
 
+    if (!user.apiKey && shouldUseOAuth(argv, env)) {
+        return await authenticateWithOAuth(argv, env);
+    }
+
     if (!user.apiKey && env.users && (argv.user || env.current?.user)) {
         user = env.users[argv.user] || env.users[env.current?.user];
         askLogin = false;
     }
 
     if (askLogin && argv.host) {
-        console.log('Please add an --apiKey to the command as overriding the host requires that.')
-        process.exit();
+        throw createCommandError('Please add an --apiKey, or provide OAuth client credentials when overriding the host.');
     }
     else if (askLogin) {
-        console.log('Current user not set, please login')
+        if (isJsonOutput(argv)) {
+            throw createCommandError('Current user not set, please login');
+        }
+
+        logMessage(argv, 'Current user not set, please login');
         await interactiveLogin(argv, {
             environment: {
                 type: 'input',
@@ -59,27 +89,40 @@ export async function setupUser(argv, env) {
     return user;
 }
 
-async function handleLogin(argv) {
-    argv.user ? changeUser(argv) : await interactiveLogin(argv, {
+async function handleLogin(argv, output) {
+    if (shouldUseOAuth(argv, getCurrentEnv(argv))) {
+        if (isJsonOutput(argv)) {
+            output.addData(await nonInteractiveOAuthLogin(argv));
+        } else {
+            output.addData(await interactiveOAuthLogin(argv, output));
+        }
+    } else if (argv.user) {
+        output.addData(await changeUser(argv));
+    } else {
+        if (isJsonOutput(argv)) {
+            throw createCommandError('Interactive login is not supported with --output json. Use --apiKey, or configure OAuth with --oauth --clientIdEnv/--clientSecretEnv.');
+        }
+        output.addData(await interactiveLogin(argv, {
         environment: {
             type: 'input',
             default: getConfig()?.current?.env || 'dev',
             prompt: 'if-no-arg'
           },
-          username: { 
+          username: {
             type: 'input'
           },
-          password: { 
+          password: {
             type: 'password'
           },
           interactive: {
               default: true
           }
-    })
+    }, output))
+    }
 }
 
-export async function interactiveLogin(argv, options) {
-    if (argv.verbose) console.info('Now logging in')
+export async function interactiveLogin(argv, options, output) {
+    verboseLog(argv, 'Now logging in');
     const result = {};
     for (const [key, config] of Object.entries(options)) {
         if (key === 'interactive') continue;
@@ -95,41 +138,57 @@ export async function interactiveLogin(argv, options) {
         });
     }
     if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
-        if (!argv.host)
-            console.log(`The environment specified is missing parameters, please specify them`)
-        await interactiveEnv(argv, {
-            environment: {
-                type: 'input',
-                default: result.environment,
-                prompt: 'never'
-            },
-            host: {
-                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
-                type: 'input',
-                prompt: 'always'
-            },
-            interactive: {
-                default: true
-            }
-        })
+        if (argv.host) {
+            ensureEnvironmentFromArgs(result.environment, argv);
+        } else {
+            logMessage(argv, `The environment specified is missing parameters, please specify them`);
+            await interactiveEnv(argv, {
+                environment: {
+                    type: 'input',
+                    default: result.environment,
+                    prompt: 'never'
+                },
+                host: {
+                    describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
+                    type: 'input',
+                    prompt: 'always'
+                },
+                interactive: {
+                    default: true
+                }
+            }, output)
+        }
     }
-    await loginInteractive(result, argv.verbose);
+    return await loginInteractive(result, argv.verbose, argv);
 }
 
-async function loginInteractive(result, verbose) {
+async function loginInteractive(result, verbose, argv) {
     var protocol = getConfig().env[result.environment].protocol;
     var token = await login(result.username, result.password, result.environment, protocol, verbose);
-    if (!token) return;
+    if (!token) {
+        throw createCommandError(`Could not fetch a login token for user ${result.username}.`);
+    }
     var apiKey = await getApiKey(token, result.environment, protocol, verbose)
-    if (!apiKey) return;
+    if (!apiKey) {
+        throw createCommandError(`Could not create an API Key for the logged in user ${result.username}.`);
+    }
     getConfig().env = getConfig().env || {};
     getConfig().env[result.environment].users = getConfig().env[result.environment].users || {};
     getConfig().env[result.environment].users[result.username] = getConfig().env[result.environment].users[result.username] || {};
     getConfig().env[result.environment].users[result.username].apiKey = apiKey;
     getConfig().env[result.environment].current = getConfig().env[result.environment].current || {};
     getConfig().env[result.environment].current.user = result.username;
-    console.log("You're now logged in as " + result.username)
+    getConfig().env[result.environment].current.authType = 'user';
+    logMessage(argv, "You're now logged in as " + result.username);
     updateConfig();
+
+    return {
+        environment: result.environment,
+        username: result.username,
+        apiKey,
+        host: getConfig().env[result.environment].host,
+        protocol
+    };
 }
 
 async function login(username, password, env, protocol, verbose) {
@@ -153,14 +212,13 @@ async function login(username, password, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Login attempt failed with username ${username}, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Login attempt failed with username ${username}, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
 function parseCookies (cookieHeader) {
     const list = {};
     if (!cookieHeader) {
-        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
         return list;
     }
 
@@ -173,10 +231,6 @@ function parseCookies (cookieHeader) {
         list[name] = decodeURIComponent(value);
     });
 
-    if (!list.user) {
-        console.log(`Could not get the necessary information from the login request, please verify its a valid user in your Dynamicweb solution.`)
-    }
-
     return list;
 }
 
@@ -193,7 +247,7 @@ async function getToken(user, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Could not fetch the token for the logged in user ${user}, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Could not fetch the token for the logged in user ${user}, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
@@ -218,12 +272,297 @@ async function getApiKey(token, env, protocol, verbose) {
     }
     else {
         if (verbose) console.info(res)
-        console.log(`Could not create an API Key for the logged in user, please verify its a valid user in your Dynamicweb solution.`)
+        throw createCommandError(`Could not create an API Key for the logged in user, please verify its a valid user in your Dynamicweb solution.`, res.status)
     }
 }
 
 async function changeUser(argv) {
+    if (!getConfig().current?.env || !getConfig().env?.[getConfig().current.env]) {
+        throw createCommandError('Current environment not set, please set it before changing user.');
+    }
+
+    getConfig().env[getConfig().current.env].current = getConfig().env[getConfig().current.env].current || {};
     getConfig().env[getConfig().current.env].current.user = argv.user;
+    getConfig().env[getConfig().current.env].current.authType = 'user';
     updateConfig();
-    console.log(`You're now logged in as ${getConfig().env[getConfig().current.env].current.user}`);
-}
+    logMessage(argv, `You're now logged in as ${getConfig().env[getConfig().current.env].current.user}`);
+
+    return {
+        environment: getConfig().current.env,
+        username: getConfig().env[getConfig().current.env].current.user
+    };
+}
+
+async function interactiveOAuthLogin(argv, output) {
+    verboseLog(argv, 'Configuring OAuth client credentials authentication');
+
+    const currentEnvName = getConfig()?.current?.env || 'dev';
+    const environment = await input({
+        message: 'environment',
+        default: currentEnvName
+    });
+    const existingEnv = getConfig()?.env?.[environment] || {};
+    const existingAuth = existingEnv.auth || {};
+
+    const result = {
+        environment,
+        clientIdEnv: argv.clientIdEnv || existingAuth.clientIdEnv || DEFAULT_CLIENT_ID_ENV,
+        clientSecretEnv: argv.clientSecretEnv || existingAuth.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV
+    };
+
+    if (!argv.clientIdEnv) {
+        result.clientIdEnv = await input({
+            message: 'clientIdEnv',
+            default: result.clientIdEnv
+        });
+    }
+
+    if (!argv.clientSecretEnv) {
+        result.clientSecretEnv = await input({
+            message: 'clientSecretEnv',
+            default: result.clientSecretEnv
+        });
+    }
+
+    if (argv.host) {
+        ensureEnvironmentFromArgs(result.environment, argv);
+    } else if (!getConfig().env || !getConfig().env[result.environment] || !getConfig().env[result.environment].host || !getConfig().env[result.environment].protocol) {
+        logMessage(argv, 'The environment specified is missing parameters, please specify them');
+        await interactiveEnv(argv, {
+            environment: {
+                type: 'input',
+                default: result.environment,
+                prompt: 'never'
+            },
+            host: {
+                describe: 'Enter your host including protocol, i.e "https://yourHost.com":',
+                type: 'input',
+                prompt: 'always'
+            },
+            interactive: {
+                default: true
+            }
+        }, output);
+    }
+
+    const oauthResult = await finalizeOAuthLogin(result.environment, result.clientIdEnv, result.clientSecretEnv, argv);
+
+    logMessage(argv, `OAuth authentication is now configured for ${result.environment}`);
+
+    return oauthResult;
+}
+
+async function nonInteractiveOAuthLogin(argv) {
+    verboseLog(argv, 'Configuring OAuth client credentials authentication (non-interactive)');
+
+    const environment = getConfig()?.current?.env;
+    if (!environment) {
+        throw createCommandError('No environment set. Configure one with "dw env" first.');
+    }
+
+    if (argv.host) {
+        ensureEnvironmentFromArgs(environment, argv);
+    } else if (!getConfig().env?.[environment]?.host) {
+        throw createCommandError(`Environment "${environment}" has no host configured. Pass --host or set it up with "dw env" first.`);
+    }
+
+    const clientIdEnv = argv.clientIdEnv || getConfig().env?.[environment]?.auth?.clientIdEnv || DEFAULT_CLIENT_ID_ENV;
+    const clientSecretEnv = argv.clientSecretEnv || getConfig().env?.[environment]?.auth?.clientSecretEnv || DEFAULT_CLIENT_SECRET_ENV;
+
+    return await finalizeOAuthLogin(environment, clientIdEnv, clientSecretEnv, argv);
+}
+
+async function finalizeOAuthLogin(environment, clientIdEnv, clientSecretEnv, argv) {
+    const env = getConfig().env[environment];
+    const oauthConfig = resolveOAuthConfig({
+        ...argv,
+        clientIdEnv,
+        clientSecretEnv,
+        oauth: true
+    }, env);
+
+    const tokenResult = await fetchOAuthToken(env, oauthConfig, argv.verbose);
+
+    getConfig().current = getConfig().current || {};
+    getConfig().current.env = environment;
+    env.auth = {
+        type: 'oauth_client_credentials',
+        clientIdEnv,
+        clientSecretEnv
+    };
+    env.current = env.current || {};
+    env.current.authType = 'oauth_client_credentials';
+    delete env.current.user;
+    updateConfig();
+
+    return {
+        environment,
+        authType: 'oauth_client_credentials',
+        clientIdEnv,
+        clientSecretEnv,
+        expires: tokenResult.expires || null
+    };
+}
+
+async function authenticateWithOAuth(argv, env) {
+    const oauthConfig = resolveOAuthConfig(argv, env, true);
+    const tokenResult = await fetchOAuthToken(env, oauthConfig, argv.verbose);
+
+    return {
+        apiKey: tokenResult.token,
+        authType: 'oauth_client_credentials',
+        expires: tokenResult.expires || null
+    };
+}
+
+function shouldUseOAuth(argv, env = {}) {
+    if (argv.auth === 'user') {
+        return false;
+    }
+
+    if (argv.oauth || argv.auth === 'oauth') {
+        return true;
+    }
+
+    if (argv.clientId || argv.clientSecret || argv.clientIdEnv || argv.clientSecretEnv) {
+        return true;
+    }
+
+    if (env?.current?.authType) {
+        return env.current.authType === 'oauth_client_credentials';
+    }
+
+    return env?.auth?.type === 'oauth_client_credentials';
+}
+
+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;
+    const clientId = argv.clientId || process.env[clientIdEnv];
+    const clientSecret = argv.clientSecret || process.env[clientSecretEnv];
+
+    if (requireCredentials) {
+        if (!clientId) {
+            throw createCommandError(`OAuth client ID not found. Set --clientId or export ${clientIdEnv}.`);
+        }
+
+        if (!clientSecret) {
+            throw createCommandError(`OAuth client secret not found. Set --clientSecret or export ${clientSecretEnv}.`);
+        }
+    }
+
+    return {
+        clientId,
+        clientSecret,
+        clientIdEnv,
+        clientSecretEnv
+    };
+}
+
+async function fetchOAuthToken(env, oauthConfig, verbose) {
+    const res = await fetch(`${env.protocol}://${env.host}${DEFAULT_OAUTH_TOKEN_PATH}`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            grant_type: 'client_credentials',
+            client_id: oauthConfig.clientId,
+            client_secret: oauthConfig.clientSecret
+        }),
+        agent: getAgent(env.protocol)
+    });
+
+    const body = await parseJsonSafe(res);
+
+    if (!res.ok) {
+        if (verbose) {
+            console.info(res);
+        }
+
+        throw createCommandError(`OAuth token request failed at ${DEFAULT_OAUTH_TOKEN_PATH}.`, res.status, body);
+    }
+
+    const token = body?.token || body?.Token;
+    const expires = body?.expires || body?.Expires || null;
+
+    if (!token) {
+        throw createCommandError('OAuth token response did not include a token.', res.status, body);
+    }
+
+    return { token, expires };
+}
+
+function getCurrentEnv(argv) {
+    if (argv.host) {
+        return {
+            host: argv.host,
+            protocol: argv.protocol || 'https'
+        };
+    }
+
+    return getConfig()?.env?.[getConfig()?.current?.env] || {};
+}
+
+function ensureEnvironmentFromArgs(environment, argv) {
+    getConfig().env = getConfig().env || {};
+    getConfig().env[environment] = getConfig().env[environment] || {};
+    getConfig().env[environment].host = argv.host;
+    getConfig().env[environment].protocol = argv.protocol || 'https';
+    getConfig().current = getConfig().current || {};
+    getConfig().current.env = environment;
+    updateConfig();
+}
+
+function logMessage(argv, ...args) {
+    if (!isJsonOutput(argv)) {
+        console.log(...args);
+    }
+}
+
+function verboseLog(argv, ...args) {
+    if (argv?.verbose && !isJsonOutput(argv)) {
+        console.info(...args);
+    }
+}
+
+function createLoginOutput(argv) {
+    const response = {
+        ok: true,
+        command: 'login',
+        operation: shouldUseOAuth(argv, getCurrentEnv(argv)) ? 'oauth-login' : argv.user ? 'select-user' : 'login',
+        status: 200,
+        data: [],
+        errors: [],
+        meta: {}
+    };
+
+    return {
+        json: isJsonOutput(argv),
+        addData(entry) {
+            response.data.push(entry);
+        },
+        fail(err) {
+            response.ok = false;
+            response.status = err?.status || 1;
+            response.errors.push({
+                message: err?.message || 'Unknown login command error.',
+                details: err?.details ?? null
+            });
+        },
+        finish() {
+            if (this.json) {
+                console.log(JSON.stringify(response, null, 2));
+            }
+        }
+    };
+}
+
+async function parseJsonSafe(res) {
+    try {
+        return await res.json();
+    } catch {
+        return null;
+    }
+}