@dynamicweb/cli 1.1.1 → 2.0.0-beta.0

package/bin/commands/files.js

@@ -2,7 +2,7 @@ import fetch from 'node-fetch';
 import path from 'path';
 import fs from 'fs';
 import FormData from 'form-data';
-import { setupEnv, getAgent } from './env.js';
+import { setupEnv, getAgent, createCommandError } from './env.js';
 import { setupUser } from './login.js';
 import { interactiveConfirm, formatBytes, createThrottledStatusUpdater } from '../utils.js';
 import { downloadWithProgress, tryGetFileNameFromResponse } from '../downloader.js';
@@ -59,9 +59,31 @@ export function filesCommand() {
                 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',
-                describe: 'Includes export of log and cache folders, NOT RECOMMENDED'
+                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',
@@ -75,32 +97,45 @@ export function filesCommand() {
                 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',
-                describe: 'Outputs a single JSON response for automation-friendly parsing'
+                hidden: true,
+                describe: 'Deprecated alias for --output json'
             })
         },
         handler: async (argv) => {
+            if (argv.json && !argv.output) {
+                argv.output = 'json';
+                console.warn('Warning: --json is deprecated and will be removed in a future release. Use --output json instead.');
+            }
+            if (argv.iamstupid && !argv.dangerouslyIncludeLogsAndCache) {
+                argv.dangerouslyIncludeLogsAndCache = true;
+                console.warn('Warning: --iamstupid is deprecated and will be removed in a future release. Use --dangerouslyIncludeLogsAndCache instead.');
+            }
             const output = createFilesOutput(argv);
 
             try {
-                output.verboseLog(`Listing directory at: ${argv.dirPath}`);
                 await handleFiles(argv, output);
-                output.finish();
             } catch (err) {
                 output.fail(err);
+                process.exitCode = 1;
+            } finally {
                 output.finish();
-                process.exit(1);
             }
         }
     }
 }
 
 async function handleFiles(argv, output) {
-    let env = await setupEnv(argv);
+    let env = await setupEnv(argv, output);
     let user = await setupUser(argv, env);
 
     if (argv.list) {
+        output.verboseLog(`Listing directory at: ${argv.dirPath}`);
         let files = (await getFilesStructure(env, user, argv.dirPath, argv.recursive, argv.includeFiles)).model;
         output.setStatus(200);
         output.addData(files);
@@ -115,30 +150,34 @@ async function handleFiles(argv, output) {
     if (argv.export) {
         if (argv.dirPath) {
             
-            const isFile = argv.asFile || argv.asDirectory
-                ? argv.asFile
-                : path.extname(argv.dirPath) !== '';                
+            const isFile = isFilePath(argv, argv.dirPath);
 
             if (isFile) {
                 let parentDirectory = path.dirname(argv.dirPath);              
                 parentDirectory = parentDirectory === '.' ? '/' : parentDirectory;
                 
-                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.iamstupid, [argv.dirPath], true, output);
+                await download(env, user, parentDirectory, argv.outPath, false, null, true, argv.dangerouslyIncludeLogsAndCache, [argv.dirPath], true, output);
             } else {
-                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.iamstupid, [], false, output);
+                await download(env, user, argv.dirPath, argv.outPath, true, null, argv.raw, argv.dangerouslyIncludeLogsAndCache, [], false, output);
             }
         } else {
-            await interactiveConfirm('Are you sure you want a full export of files?', async () => {
+            const fullExport = async () => {
                 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, output);
+                    await download(env, user, dir.name, argv.outPath, true, null, argv.raw, argv.dangerouslyIncludeLogsAndCache, [], false, output);
                 }
-                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.iamstupid, Array.from(filesStructure.files.data, f => f.name), false, output);
+                await download(env, user, '/.', argv.outPath, false, 'Base.zip', argv.raw, argv.dangerouslyIncludeLogsAndCache, 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');
-            })
+            };
+
+            if (output.json) {
+                await fullExport();
+            } else {
+                await interactiveConfirm('Are you sure you want a full export of files?', fullExport);
+            }
         }
     } else if (argv.import) {
         if (argv.dirPath && argv.outPath) {
@@ -150,6 +189,44 @@ async function handleFiles(argv, output) {
                 await uploadFiles(env, user, filesInDir, argv.outPath, argv.createEmpty, argv.overwrite, output);
             }
         }
+    } else if (argv.delete) {
+        if (!argv.dirPath) {
+            throw createCommandError('A path is required for delete operations.', 400);
+        }
+
+        const isFile = isFilePath(argv, argv.dirPath);
+
+        if (argv.empty && isFile) {
+            throw createCommandError('--empty can only be used with directories.', 400);
+        }
+
+        const shouldConfirm = !output.json;
+
+        if (shouldConfirm) {
+            const action = argv.empty
+                ? `empty directory "${argv.dirPath}"`
+                : isFile
+                    ? `delete file "${argv.dirPath}"`
+                    : `delete directory "${argv.dirPath}"`;
+
+            await interactiveConfirm(`Are you sure you want to ${action}?`, async () => {
+                await deleteRemote(env, user, argv.dirPath, isFile, argv.empty, output);
+            });
+        } else {
+            await deleteRemote(env, user, argv.dirPath, isFile, argv.empty, output);
+        }
+    } else if (argv.copy) {
+        if (!argv.dirPath) {
+            throw createCommandError('A source path [dirPath] is required for copy operations.', 400);
+        }
+
+        await copyRemote(env, user, argv.dirPath, argv.copy, output);
+    } else if (argv.move) {
+        if (!argv.dirPath) {
+            throw createCommandError('A source path [dirPath] is required for move operations.', 400);
+        }
+
+        await moveRemote(env, user, argv.dirPath, argv.move, argv.overwrite, output);
     }
 }
 
@@ -206,9 +283,9 @@ function resolveTree(dirs, indentLevel, parentHasFiles, output) {
     }
 }
 
-async function download(env, user, dirPath, outPath, recursive, outname, raw, iamstupid, fileNames, singleFileMode, output) {
+async function download(env, user, dirPath, outPath, recursive, outname, raw, dangerouslyIncludeLogsAndCache, fileNames, singleFileMode, output) {
     let excludeDirectories = '';
-    if (!iamstupid) {
+    if (!dangerouslyIncludeLogsAndCache) {
         excludeDirectories = 'system/log';
         if (dirPath === 'cache.net') {
             return;
@@ -320,7 +397,11 @@ async function extractArchive(filename, filePath, outPath, raw, output) {
     }
     output.log(`Finished extracting ${filename} to ${outPath}\n`);
 
-    fs.unlink(filePath, function(err) {});
+    fs.unlink(filePath, function(err) {
+        if (err) {
+            output.verboseLog(`Warning: Failed to delete temporary archive ${filePath}: ${err.message}`);
+        }
+    });
 }
 
 async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
@@ -338,7 +419,127 @@ async function getFilesStructure(env, user, dirPath, recursive, includeFiles) {
     }
 }
 
-export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false, overwrite = false, output) {
+async function deleteRemote(env, user, remotePath, isFile, empty, output) {
+    let endpoint;
+    let mode;
+    let data;
+
+    if (isFile) {
+        endpoint = 'FileDelete';
+        mode = 'file';
+        const parentDir = path.posix.dirname(remotePath);
+        data = {
+            DirectoryPath: parentDir === '.' ? '/' : parentDir,
+            Ids: [remotePath]
+        };
+    } else if (empty) {
+        endpoint = 'DirectoryEmpty';
+        mode = 'empty';
+        data = { Path: remotePath };
+    } else {
+        endpoint = 'DirectoryDelete';
+        mode = 'directory';
+        data = { Path: remotePath };
+    }
+
+    output.log(`${mode === 'empty' ? 'Emptying' : 'Deleting'} ${mode === 'file' ? 'file' : 'directory'}: ${remotePath}`);
+
+    const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/${endpoint}`, {
+        method: 'POST',
+        body: JSON.stringify(data),
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    });
+
+    if (!res.ok) {
+        throw createCommandError(`Failed to ${mode === 'empty' ? 'empty' : 'delete'} "${remotePath}".`, res.status, await parseJsonSafe(res));
+    }
+
+    const body = await parseJsonSafe(res);
+
+    output.setStatus(200);
+    output.addData({
+        type: 'delete',
+        path: remotePath,
+        mode,
+        response: body
+    });
+
+    output.log(`Successfully ${mode === 'empty' ? 'emptied' : 'deleted'}: ${remotePath}`);
+}
+
+async function copyRemote(env, user, sourcePath, destination, output) {
+    output.log(`Copying ${sourcePath} to ${destination}`);
+
+    const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AssetCopy`, {
+        method: 'POST',
+        body: JSON.stringify({
+            Destination: destination,
+            Ids: [sourcePath]
+        }),
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    });
+
+    if (!res.ok) {
+        throw createCommandError(`Failed to copy "${sourcePath}" to "${destination}".`, res.status, await parseJsonSafe(res));
+    }
+
+    const body = await parseJsonSafe(res);
+
+    output.setStatus(200);
+    output.addData({
+        type: 'copy',
+        sourcePath,
+        destination,
+        response: body
+    });
+
+    output.log(`Successfully copied ${sourcePath} to ${destination}`);
+}
+
+async function moveRemote(env, user, sourcePath, destination, overwrite, output) {
+    output.log(`Moving ${sourcePath} to ${destination}`);
+
+    const res = await fetch(`${env.protocol}://${env.host}/Admin/Api/AssetMove`, {
+        method: 'POST',
+        body: JSON.stringify({
+            Destination: destination,
+            Overwrite: Boolean(overwrite),
+            Ids: [sourcePath]
+        }),
+        headers: {
+            'Authorization': `Bearer ${user.apiKey}`,
+            'Content-Type': 'application/json'
+        },
+        agent: getAgent(env.protocol)
+    });
+
+    if (!res.ok) {
+        throw createCommandError(`Failed to move "${sourcePath}" to "${destination}".`, res.status, await parseJsonSafe(res));
+    }
+
+    const body = await parseJsonSafe(res);
+
+    output.setStatus(200);
+    output.addData({
+        type: 'move',
+        sourcePath,
+        destination,
+        overwrite: Boolean(overwrite),
+        response: body
+    });
+
+    output.log(`Successfully moved ${sourcePath} to ${destination}`);
+}
+
+export async function uploadFiles(env, user, localFilePaths, destinationPath, createEmpty = false, overwrite = false, output = createFilesOutput({})) {
     output.log('Uploading files')
 
     const chunkSize = 300;
@@ -348,10 +549,10 @@ 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
-    });
+    output.mergeMeta((meta) => ({
+        filesProcessed: (meta.filesProcessed || 0) + localFilePaths.length,
+        chunks: (meta.chunks || 0) + chunks.length
+    }));
 
     for (let i = 0; i < chunks.length; i++) {
         output.log(`Uploading chunk ${i + 1} of ${chunks.length}`);
@@ -405,13 +606,19 @@ export function resolveFilePath(filePath) {
     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);
+        throw createCommandError(`Could not find any files with the name ${filePath}`, 1);
     }
     return path.join(p.dir, resolvedPath);
 }
 
 
+function isFilePath(argv, dirPath) {
+    if (argv.asFile || argv.asDirectory) {
+        return argv.asFile;
+    }
+    return path.extname(dirPath) !== '';
+}
+
 function wildcardToRegExp(wildcard) {
     const escaped = wildcard.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
     return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
@@ -429,7 +636,7 @@ function createFilesOutput(argv) {
     };
 
     return {
-        json: Boolean(argv.json),
+        json: argv.output === 'json' || Boolean(argv.json),
         verbose: Boolean(argv.verbose),
         response,
         log(...args) {
@@ -445,7 +652,8 @@ function createFilesOutput(argv) {
         addData(entry) {
             response.data.push(entry);
         },
-        mergeMeta(meta) {
+        mergeMeta(metaOrFn) {
+            const meta = typeof metaOrFn === 'function' ? metaOrFn(response.meta) : metaOrFn;
             response.meta = {
                 ...response.meta,
                 ...meta
@@ -483,15 +691,21 @@ function getFilesOperation(argv) {
         return 'import';
     }
 
+    if (argv.delete) {
+        return 'delete';
+    }
+
+    if (argv.copy) {
+        return 'copy';
+    }
+
+    if (argv.move) {
+        return 'move';
+    }
+
     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 {

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;
     }
-}
+}