@microtronics/studio-cli 0.24.1 → 0.26.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 
 
+## 0.26.0 (2025-03-18)
+
+
+### Features
+
+* implemented generic logger ([46b72a1](https://bitbucket.org/microtronics-core/vscode-studio/commits/46b72a1f5bcf9cfe85e58deb7e69bf3e56aa0875))
+* **studio-cli:** introduced generic logger with chalk as colorization tool ([6593494](https://bitbucket.org/microtronics-core/vscode-studio/commits/65934942e2d30b3dfcc965e798ad8c508bf2ed52))
+
+## 0.25.0 (2025-03-12)
+
+
+### Features
+
+* **studio-cli:** show update notification after each cli command ([c719fd8](https://bitbucket.org/microtronics-core/vscode-studio/commits/c719fd8ea6a7dda16589764d2ae77f70e006d80a))
+
 ## 0.24.1 (2025-03-12)
 
 ## 0.24.0 (2025-03-10)

package/dist/studio-cli.d.ts

@@ -115,6 +115,21 @@ declare interface BaseTagHeader {
     addon_max_sources?: number;
 }
 
+/**
+ * Builds all parts of the specified project in the given working directory.
+ *
+ * @param {URI} cwd - The current working directory where the build process will be executed.
+ * @param {LocalFS} fs - The local file system instance used for file operations during the build.
+ * @param {Logger} logger - Logger instance for logging details during the build process.
+ * @param {APM.Part} selectedParts - The project parts to be built.
+ * @return A promise that resolves when the build process is complete.
+ */
+export declare function build(cwd: URI, fs: LocalFS, logger: Log.Logger, selectedParts?: APM.Part[] | boolean): Promise<{
+    [APM.Part.dde]: Diagnostics.File[];
+    [APM.Part.dlo]: Diagnostics.File[];
+    [APM.Part.dfiles]: Diagnostics.File[];
+}>;
+
 declare interface components {
     schemas: {
         /** @default 25 */
@@ -1115,7 +1130,7 @@ export declare namespace DDE {
      * @param fs
      * @param fileName
      */
-    export function validate(cwd: URI, fs: LocalFS, fileName?: string): Promise<{
+    export function validate(cwd: URI, fs: LocalFS, logger: Log.Logger, fileName?: string): Promise<{
         manifest: Manifest.Manifest;
         libraryFiles: DDE_Core.LibraryFile[];
         main: {
@@ -1127,9 +1142,10 @@ export declare namespace DDE {
      * Run dde compiler in the given studio directory
      * @param cwd
      * @param fs
+     * @param logger
      * @param fileName
      */
-    export function compileDDE(cwd: URI, fs: LocalFS, fileName?: string): Promise<{
+    export function compileDDE(cwd: URI, fs: LocalFS, logger: Log.Logger, fileName?: string): Promise<{
         ddeJSON: DDEJson | null;
         diagnostics: Diagnostics.File[];
     }>;
@@ -1137,8 +1153,9 @@ export declare namespace DDE {
      * Validate a given dde file against the dynamic dde schema
      * @param ddeFilePath
      * @param yaml
+     * @param logger
      */
-    export function validateJsonSchema(ddeFilePath: URI, yaml: string): Promise<void>;
+    export function validateJsonSchema(ddeFilePath: URI, yaml: string, logger: Log.Logger): Promise<void>;
     /**
      * Creates and returns a new precompiler instance
      * @param manifest
@@ -1161,13 +1178,13 @@ export declare namespace DDE {
      * @param fs
      * @param ddeJSON
      */
-    export function exportMyDatanetXML(cwd: URI, fs: LocalFS, ddeJSON: DDEJson): Promise<void>;
+    export function exportMyDatanetXML(cwd: URI, fs: LocalFS, logger: Log.Logger, ddeJSON: DDEJson): Promise<void>;
     /**
      * Read the correct history.json file from the project
      * @param cwd
      * @param fs
      */
-    export function getHistoryJson(cwd: URI, fs: LocalFS): Promise<any>;
+    export function getHistoryJson(cwd: URI, fs: LocalFS, logger: Log.Logger): Promise<any>;
     /**
      * Generate the object for the history.json
      * @param ddeJson
@@ -1181,7 +1198,7 @@ export declare namespace DDE {
      * @param fs
      * @param ddeJSON
      */
-    export function exportHistoryJson(cwd: URI, fs: LocalFS, ddeJSON: DDEJson): Promise<void>;
+    export function exportHistoryJson(cwd: URI, fs: LocalFS, logger: Log.Logger, ddeJSON: DDEJson): Promise<void>;
     /**
      * Clean up the .studio/auto/dlo directory
      * @param cwd
@@ -1195,14 +1212,14 @@ export declare namespace DDE {
      * @param fs
      * @param ddeJSON
      */
-    export function exportAutoDloFiles(cwd: URI, fs: LocalFS, ddeJSON: DDEJson): Promise<void>;
+    export function exportAutoDloFiles(cwd: URI, fs: LocalFS, logger: Log.Logger, ddeJSON: DDEJson): Promise<void>;
     /**
      * Generate all dde related openapi files
      * @param cwd
      * @param fs
      * @param ddeMap
      */
-    export function exportOpenApi(cwd: URI, fs: LocalFS, ddeMap: DDEJson): Promise<void>;
+    export function exportOpenApi(cwd: URI, fs: LocalFS, logger: Log.Logger, ddeMap: DDEJson): Promise<void>;
     /**
      * Generate and export the default.inc file
      * @param cwd
@@ -1690,7 +1707,20 @@ export declare namespace DFILES {
     export interface PropertyList {
         [key: string]: Property;
     }
-    export function process(cwd: URI, fs: LocalFS): Promise<Diagnostics.File[]>;
+    export function process(cwd: URI, fs: LocalFS, logger: Log.Logger): Promise<Diagnostics.File[]>;
+    /**
+     * Parses DFILES from the specified directory and aggregates properties, diagnostics, and library files.
+     *
+     * @param {URI} cwd - The current working directory URI.
+     * @param {LocalFS} fs - The local file system instance used for file operations.
+     * @return {Promise<{properties: PropertyList, diagnostics: Diagnostics.File[], libraryFiles: any[]}>}
+     * Resolves to an object containing the aggregated properties, diagnostics, and library files information.
+     */
+    export function parseDfile(cwd: URI, fs: LocalFS): Promise<{
+        properties: PropertyList;
+        diagnostics: Diagnostics.File[];
+        libraryFiles: Dependencies.APMPartLibrary[];
+    }>;
     /**
      *
      * @param fs
@@ -1739,15 +1769,16 @@ export declare namespace DLO {
      * @param cwd
      * @param fs
      */
-    export function exportDloConfig(cwd: URI, fs: LocalFS): Promise<void>;
+    export function exportDloConfig(cwd: URI, fs: LocalFS, logger: Log.Logger): Promise<void>;
 }
 
 declare class DloCompiler {
+    private logger;
     private preCompiler;
     private dloCC;
     private stdout;
     private stderr;
-    constructor();
+    constructor(logger: Log.Logger);
     private initDloCC;
     private get MEMFS();
     compile(cwd: URI, fs: LocalFS): Promise<{
@@ -2003,6 +2034,18 @@ export declare namespace Helper {
     export function defer(token: string, timeout: number, callback: any): void;
 }
 
+/**
+ * Installs the specified dependencies or all dependencies if none are provided.
+ *
+ * @param {URI} cwd - The current working directory where the installation process takes place.
+ * @param {LocalFS} fs - The file system interface used for managing files during the installation process.
+ * @param {Globals.ENV} env - The global environment configuration used during the installation.
+ * @param {string|null} apiToken - The API token for authentication, if required, or null if not applicable.
+ * @param {string[]} dependencies - An array of dependency strings in the format "libraryId@version". If empty, all dependencies will be installed.
+ * @return {Promise<void>} A promise that resolves when the installation process completes successfully or logs an error if it fails.
+ */
+export declare function install(cwd: URI, fs: LocalFS, env: Globals.ENV, apiToken: string | null, dependencies: string[]): Promise<void>;
+
 export declare namespace Library {
     /**
      * Creates the library.tar.gz archive content
@@ -2075,6 +2118,35 @@ declare interface LocalFS {
     copy: (source: URI, target: URI) => Promise<any>;
 }
 
+export declare namespace Log {
+    export enum LogMessageType {
+        log = 0,
+        done = 1,
+        info = 2,
+        warning = 3,
+        error = 4
+    }
+    const LOG_PREFIX: {
+        1: string;
+        0: string;
+        2: string;
+        3: string;
+        4: string;
+    };
+    export class Logger {
+        private _logHandler;
+        constructor(logOutput?: {
+            log: (...args: any[]) => void;
+        });
+        _log(type: LogMessageType, msg: any, ...args: any[]): void;
+        log(msg: any, ...args: any[]): void;
+        error(msg: any, ...args: any[]): void;
+        info(msg: any, ...args: any[]): void;
+        warn(msg: any, ...args: any[]): void;
+        done(msg: any, ...args: any[]): void;
+    }
+}
+
 export declare namespace Manifest {
     /**
      * The source filename where the information is stored in
@@ -2222,37 +2294,45 @@ export declare namespace Package {
      * Build the whole project or only a specific part
      * @param cwd
      * @param fs
-     * @param apmPart - choose a specific part that should be build
+     * @param logger
+     * @param selectedParts - choose a specific part that should be build or if true all parts are build
      */
-    export function buildAll(cwd: URI, fs: LocalFS, apmPart?: APM.Part): Promise<void>;
+    export function buildAll(cwd: URI, fs: LocalFS, logger: Log.Logger, selectedParts?: APM.Part[] | boolean): Promise<{
+        [APM.Part.dde]: Diagnostics.File[];
+        [APM.Part.dlo]: Diagnostics.File[];
+        [APM.Part.dfiles]: Diagnostics.File[];
+    }>;
     /**
      * Trigger the release based on the manifest settings
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param releasePhase
      * @param allowedBackends
      * @param env
      */
-    export function release(cwd: URI, fs: LocalFS, token: Registry.AuthToken, releasePhase: APM.TagPhase, allowedBackends: Registry.ApiNewApplication['allowedBackends'], env: Globals.ENV): Promise<void>;
+    export function release(cwd: URI, fs: LocalFS, logger: Log.Logger, token: Registry.AuthToken, releasePhase: APM.TagPhase, allowedBackends: Registry.ApiNewApplication['allowedBackends'], env: Globals.ENV): Promise<void>;
     /**
      * Publish an application model tag
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param releasePhase
      * @param allowedBackends
      * @param env
      */
-    export function releaseAPM(cwd: URI, fs: LocalFS, token: Registry.AuthToken, releasePhase: APM.TagPhase, allowedBackends: Registry.ApiNewApplication['allowedBackends'], env: Globals.ENV): Promise<void>;
+    export function releaseAPM(cwd: URI, fs: LocalFS, logger: Log.Logger, token: Registry.AuthToken, releasePhase: APM.TagPhase, allowedBackends: Registry.ApiNewApplication['allowedBackends'], env: Globals.ENV): Promise<void>;
     /**
      * Publish a library project
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param env
      */
-    export function releaseLibrary(cwd: URI, fs: LocalFS, token: Registry.AuthToken, env: Globals.ENV): Promise<void>;
+    export function releaseLibrary(cwd: URI, fs: LocalFS, logger: Log.Logger, token: Registry.AuthToken, env: Globals.ENV): Promise<void>;
     /**
      * Read the projects README.md file
      * validates if the file content is the initial content
@@ -4480,6 +4560,20 @@ declare interface paths {
     };
 }
 
+/**
+ * Publishes a package to the registry with the specified settings and configurations.
+ *
+ * @param {URI} cwd - The current working directory of the package.
+ * @param {LocalFS} fs - The file system interface for reading and writing files.
+ * @param {Logger} logger - Logger instance for logging details during the publish process.
+ * @param {Globals.ENV} env - The environment configuration for the publishing process.
+ * @param {string | null} apiToken - The API token for authentication, or null if not applicable.
+ * @param {string | undefined} optsAllowedBackends - A semicolon-separated list of allowed backends, or '*' to allow all, or undefined if not specified.
+ * @param {APM.TagPhase} optsPhase - The release phase tag associated with the package publishing.
+ * @return {Promise<void>} A promise that resolves when the package has been successfully published or rejects with an error if the process fails.
+ */
+export declare function publish(cwd: URI, fs: LocalFS, logger: Log.Logger, env: Globals.ENV, apiToken: string | null, optsAllowedBackends: string | undefined, optsPhase: APM.TagPhase): Promise<void>;
+
 export declare namespace Registry {
     export type AuthToken = string | null;
     /**

package/out/api.js

@@ -1,6 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENV = exports.DFILES = exports.Library = exports.APM = exports.Package = exports.DLO = exports.Globals = exports.DeviceProfiles = exports.DefaultFiles = exports.Diagnostics = exports.Helper = exports.DDE = exports.DDE_Core = exports.Registry = exports.Manifest = exports.Dependencies = void 0;
+exports.Log = exports.ENV = exports.DFILES = exports.Library = exports.APM = exports.Package = exports.DLO = exports.Globals = exports.DeviceProfiles = exports.DefaultFiles = exports.Diagnostics = exports.Helper = exports.DDE = exports.DDE_Core = exports.Registry = exports.Manifest = exports.Dependencies = void 0;
+exports.install = install;
+exports.build = build;
+exports.publish = publish;
 const dependencies_1 = require("./dependencies");
 Object.defineProperty(exports, "Dependencies", { enumerable: true, get: function () { return dependencies_1.Dependencies; } });
 const manifest_1 = require("./manifest");
@@ -33,4 +36,68 @@ const dfiles_1 = require("./dfiles/dfiles");
 Object.defineProperty(exports, "DFILES", { enumerable: true, get: function () { return dfiles_1.DFILES; } });
 const dotenv_1 = require("./dotenv");
 Object.defineProperty(exports, "ENV", { enumerable: true, get: function () { return dotenv_1.ENV; } });
+const log_1 = require("./log");
+Object.defineProperty(exports, "Log", { enumerable: true, get: function () { return log_1.Log; } });
+/**
+ * Installs the specified dependencies or all dependencies if none are provided.
+ *
+ * @param {URI} cwd - The current working directory where the installation process takes place.
+ * @param {LocalFS} fs - The file system interface used for managing files during the installation process.
+ * @param {Globals.ENV} env - The global environment configuration used during the installation.
+ * @param {string|null} apiToken - The API token for authentication, if required, or null if not applicable.
+ * @param {string[]} dependencies - An array of dependency strings in the format "libraryId@version". If empty, all dependencies will be installed.
+ * @return {Promise<void>} A promise that resolves when the installation process completes successfully or logs an error if it fails.
+ */
+async function install(cwd, fs, env, apiToken, dependencies) {
+    try {
+        if (dependencies.length > 0) {
+            for (const dependency of dependencies) {
+                const [libraryId, version] = dependency.split('@');
+                await dependencies_1.Dependencies.installDependency(cwd, fs, env, apiToken, libraryId, version || null);
+            }
+        }
+        else {
+            return await dependencies_1.Dependencies.installDependencies(cwd, fs, env, apiToken);
+        }
+    }
+    catch (e) {
+        console.error(e);
+    }
+}
+/**
+ * Builds all parts of the specified project in the given working directory.
+ *
+ * @param {URI} cwd - The current working directory where the build process will be executed.
+ * @param {LocalFS} fs - The local file system instance used for file operations during the build.
+ * @param {Logger} logger - Logger instance for logging details during the build process.
+ * @param {APM.Part} selectedParts - The project parts to be built.
+ * @return A promise that resolves when the build process is complete.
+ */
+async function build(cwd, fs, logger, selectedParts = true) {
+    return package_1.Package.buildAll(cwd, fs, logger, selectedParts);
+}
+/**
+ * Publishes a package to the registry with the specified settings and configurations.
+ *
+ * @param {URI} cwd - The current working directory of the package.
+ * @param {LocalFS} fs - The file system interface for reading and writing files.
+ * @param {Logger} logger - Logger instance for logging details during the publish process.
+ * @param {Globals.ENV} env - The environment configuration for the publishing process.
+ * @param {string | null} apiToken - The API token for authentication, or null if not applicable.
+ * @param {string | undefined} optsAllowedBackends - A semicolon-separated list of allowed backends, or '*' to allow all, or undefined if not specified.
+ * @param {APM.TagPhase} optsPhase - The release phase tag associated with the package publishing.
+ * @return {Promise<void>} A promise that resolves when the package has been successfully published or rejects with an error if the process fails.
+ */
+async function publish(cwd, fs, logger, env, apiToken, optsAllowedBackends, optsPhase) {
+    logger.info('Publishing package...');
+    let allowedBackends = null;
+    if (optsAllowedBackends) {
+        allowedBackends = optsAllowedBackends === '*' ? optsAllowedBackends : optsAllowedBackends.split(';');
+        const errorMessage = await manifest_1.Manifest.validateRegistryAllowedBackends(allowedBackends);
+        if (errorMessage) {
+            throw new Error(errorMessage);
+        }
+    }
+    return package_1.Package.release(cwd, fs, logger, apiToken, optsPhase, allowedBackends, env);
+}
 //# sourceMappingURL=api.js.map

package/out/dde/dde.js

@@ -64,16 +64,16 @@ var DDE;
      * @param fs
      * @param fileName
      */
-    async function validate(cwd, fs, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
+    async function validate(cwd, fs, logger, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const allLibraryFiles = await getDependencies(cwd, fs, manifest);
         for (const libraryFile of allLibraryFiles) {
-            await validateJsonSchema(libraryFile.path, libraryFile.yaml);
+            await validateJsonSchema(libraryFile.path, libraryFile.yaml, logger);
         }
         // read project dde
         const mainDdePath = vscode_uri_1.Utils.joinPath(cwd, exports.DDE_PATH, fileName);
         const mainDdeYaml = await readYamlFile(mainDdePath, fs);
-        await validateJsonSchema(mainDdePath, mainDdeYaml);
+        await validateJsonSchema(mainDdePath, mainDdeYaml, logger);
         return {
             manifest,
             libraryFiles: allLibraryFiles,
@@ -88,11 +88,12 @@ var DDE;
      * Run dde compiler in the given studio directory
      * @param cwd
      * @param fs
+     * @param logger
      * @param fileName
      */
-    async function compileDDE(cwd, fs, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
-        const validated = await validate(cwd, fs, fileName);
-        const historyJson = await getHistoryJson(cwd, fs);
+    async function compileDDE(cwd, fs, logger, fileName = defaultFiles_1.DefaultFiles.fileNames.mainDDE) {
+        const validated = await validate(cwd, fs, logger, fileName);
+        const historyJson = await getHistoryJson(cwd, fs, logger);
         const preCompiler = new yamlDdePreCompiler_1.YamlPreCompiler.PreCompiler(validated.manifest, validated.libraryFiles, historyJson);
         const libraryDiagnostics = preCompiler.parseLibraries();
         const librariesHaveError = libraryDiagnostics.find(diagnostics => diagnostics.level === 'error');
@@ -115,14 +116,15 @@ var DDE;
      * Validate a given dde file against the dynamic dde schema
      * @param ddeFilePath
      * @param yaml
+     * @param logger
      */
-    async function validateJsonSchema(ddeFilePath, yaml) {
+    async function validateJsonSchema(ddeFilePath, yaml, logger) {
         const json = (0, yaml_1.parseDocument)(yaml).toJSON();
         const result = validateDynamicDde(json);
         if (!result) {
             const errors = validateDynamicDde.errors || [];
             const error = new Error(`${vscode_uri_1.Utils.basename(ddeFilePath)} has "${errors.length}" errors"`);
-            errors.forEach(error => console.error(error));
+            errors.forEach(error => logger.error(error));
             throw error;
         }
     }
@@ -154,11 +156,11 @@ var DDE;
      * @param fs
      * @param ddeJSON
      */
-    async function exportMyDatanetXML(cwd, fs, ddeJSON) {
+    async function exportMyDatanetXML(cwd, fs, logger, ddeJSON) {
         const xml = (0, xml_1.generateXMLFromMap)(ddeJSON);
         const distFile = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.ddeXmlPath);
         await fs.writeFile(distFile, xml);
-        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.dist.ddeXmlPath);
+        logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.dist.ddeXmlPath);
     }
     DDE.exportMyDatanetXML = exportMyDatanetXML;
     /**
@@ -166,7 +168,7 @@ var DDE;
      * @param cwd
      * @param fs
      */
-    async function getHistoryJson(cwd, fs) {
+    async function getHistoryJson(cwd, fs, logger) {
         const historyPath = vscode_uri_1.Utils.joinPath(cwd, exports.DDE_PATH, 'history.json');
         try {
             const binary = await fs.readFile(historyPath);
@@ -174,7 +176,7 @@ var DDE;
             return JSON.parse(historyString);
         }
         catch (e) {
-            console.warn('history.json does not exist');
+            logger.warn('history.json does not exist');
             return {};
         }
     }
@@ -205,13 +207,13 @@ var DDE;
      * @param fs
      * @param ddeJSON
      */
-    async function exportHistoryJson(cwd, fs, ddeJSON) {
-        const currentHistory = await getHistoryJson(cwd, fs);
+    async function exportHistoryJson(cwd, fs, logger, ddeJSON) {
+        const currentHistory = await getHistoryJson(cwd, fs, logger);
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const newHistory = buildHistoryJson(ddeJSON, currentHistory, manifest);
         const historyPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.historyJson);
         await fs.writeFile(historyPath, JSON.stringify(newHistory, null, '\t'));
-        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.dist.historyJson);
+        logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.dist.historyJson);
     }
     DDE.exportHistoryJson = exportHistoryJson;
     /**
@@ -230,7 +232,7 @@ var DDE;
      * @param fs
      * @param ddeJSON
      */
-    async function exportAutoDloFiles(cwd, fs, ddeJSON) {
+    async function exportAutoDloFiles(cwd, fs, logger, ddeJSON) {
         await clearAutoDloDir(cwd, fs);
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const dependencies = await getDependencies(cwd, fs, manifest);
@@ -246,7 +248,7 @@ var DDE;
             const autoIncName = defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', dependency.libraryName);
             const incPath = vscode_uri_1.Utils.joinPath(cwd, autoIncName);
             if (libraryInc.length) {
-                console.log(`Generated`, autoIncName);
+                logger.log(`Generated`, autoIncName);
                 await fs.writeFile(incPath, libraryInc);
             }
         }
@@ -254,16 +256,16 @@ var DDE;
         const autoUplink = (0, dlo_1.generateAutoUplinkIncFromMap)(ddeJSON, dependencies.map(dep => dep.libraryName));
         const autoIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoInc);
         await fs.writeFile(autoIncPath, autoInc);
-        console.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoInc);
+        logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoInc);
         const autoUplinkIncPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoUplinkInc);
         await fs.writeFile(autoUplinkIncPath, autoUplink);
-        console.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoUplinkInc);
+        logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoUplinkInc);
         const autoDdeAppPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'app'));
         await fs.writeFile(autoDdeAppPath, [...appDDEInc.globals, ...appDDEInc.helper].join('\n'));
-        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'app'));
+        logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'app'));
         const autoDdeMainPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'main'));
         await fs.writeFile(autoDdeMainPath, mainDDEInc);
-        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'main'));
+        logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.autoDdeInc.replace('X', 'main'));
         await exportDefaultInc(cwd, fs);
     }
     DDE.exportAutoDloFiles = exportAutoDloFiles;
@@ -273,7 +275,7 @@ var DDE;
      * @param fs
      * @param ddeMap
      */
-    async function exportOpenApi(cwd, fs, ddeMap) {
+    async function exportOpenApi(cwd, fs, logger, ddeMap) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const isLibrary = manifest_1.Manifest.isLibrary(manifest);
         // remove previous api description:
@@ -281,14 +283,14 @@ var DDE;
         await fs.rm(previousOpenAPIFileName).catch(() => { });
         const appPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApi);
         await fs.writeFile(appPath, (0, api_1.generateAPIFromMap)(ddeMap, manifest));
-        console.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApi);
+        logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApi);
         // generate the api description for the library part of the project
         if (isLibrary) {
             const libPath = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApiPath, `${manifest.name}.yaml`);
             const content = (0, api_1.generateAPIFromMap)(ddeMap, manifest, manifest.name);
             if (content.length) {
                 await fs.writeFile(libPath, content);
-                console.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApiPath + `${manifest.name}.yaml`);
+                logger.log(`Generated`, defaultFiles_1.DefaultFiles.filePaths.dist.ddeApiPath + `${manifest.name}.yaml`);
             }
         }
     }

package/out/dfiles/dfiles.js

@@ -29,18 +29,8 @@ var DFILES;
         Force["up"] = "up";
         Force["off"] = "off";
     })(Force = DFILES.Force || (DFILES.Force = {}));
-    async function process(cwd, fs) {
-        const allProperties = {};
-        const allDiagnostics = [];
-        const libraryFiles = await dependencies_1.Dependencies.getApmPartDependencies(cwd, fs, apm_1.APM.Part.dfiles);
-        for (const library of libraryFiles) {
-            const { properties, diagnostics } = await parseYamlFile(fs, library.path, library.name);
-            Object.assign(allProperties, properties);
-            allDiagnostics.push(...diagnostics);
-        }
-        const { properties, diagnostics } = await parseYamlFile(fs, vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dfiles.mainDFILES), null);
-        Object.assign(allProperties, properties);
-        allDiagnostics.push(...diagnostics);
+    async function process(cwd, fs, logger) {
+        const { properties, diagnostics, libraryFiles } = await parseDfile(cwd, fs);
         const distDir = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.dfilesPath);
         // clear dist directory beforehand
         if (await fs.stat(distDir)) {
@@ -48,18 +38,45 @@ var DFILES;
         }
         // copy all files to dist directory
         // copy all files to the dist directory
-        for (const [dfileName, dfileInfo] of Object.entries(allProperties)) {
+        for (const [dfileName, dfileInfo] of Object.entries(properties)) {
             await copyDfilesToDist(cwd, fs, dfileName, dfileInfo, libraryFiles);
         }
         // do not write the properties file if there aren't any dfiles
-        if (!Object.keys(allProperties).length) {
-            return allDiagnostics;
+        if (!Object.keys(properties).length) {
+            return diagnostics;
         }
-        console.log(`${Object.keys(allProperties).length} dfiles processed.`);
-        await fs.writeFile(vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.dfilesProperties), JSON.stringify(allProperties, null, '\t'));
-        return allDiagnostics;
+        logger.done(`${Object.keys(properties).length} dfiles processed.`);
+        await fs.writeFile(vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.dfilesProperties), JSON.stringify(properties, null, '\t'));
+        return diagnostics;
     }
     DFILES.process = process;
+    /**
+     * Parses DFILES from the specified directory and aggregates properties, diagnostics, and library files.
+     *
+     * @param {URI} cwd - The current working directory URI.
+     * @param {LocalFS} fs - The local file system instance used for file operations.
+     * @return {Promise<{properties: PropertyList, diagnostics: Diagnostics.File[], libraryFiles: any[]}>}
+     * Resolves to an object containing the aggregated properties, diagnostics, and library files information.
+     */
+    async function parseDfile(cwd, fs) {
+        const allDiagnostics = [];
+        const allProperties = {};
+        const libraryFiles = await dependencies_1.Dependencies.getApmPartDependencies(cwd, fs, apm_1.APM.Part.dfiles);
+        for (const library of libraryFiles) {
+            const { properties, diagnostics } = await parseYamlFile(fs, library.path, library.name);
+            Object.assign(allProperties, properties);
+            allDiagnostics.push(...diagnostics);
+        }
+        const { properties, diagnostics } = await parseYamlFile(fs, vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dfiles.mainDFILES), null);
+        Object.assign(allProperties, properties);
+        allDiagnostics.push(...diagnostics);
+        return {
+            properties: allProperties,
+            diagnostics: allDiagnostics,
+            libraryFiles: libraryFiles
+        };
+    }
+    DFILES.parseDfile = parseDfile;
     /**
      *
      * @param fs

package/out/dlo/compiler.js

@@ -37,11 +37,13 @@ var convertBlobToStringArray = helper_1.Helper.convertBlobToStringArray;
 const apm_1 = require("../package/apm");
 const DLO_MODULE = require('./dlocc.js');
 class DloCompiler {
+    logger;
     preCompiler = new preCompiler_1.DloPreCompiler();
     dloCC;
     stdout = [];
     stderr = [];
-    constructor() {
+    constructor(logger) {
+        this.logger = logger;
         this.dloCC = null;
     }
     async initDloCC(noExit = false) {
@@ -50,11 +52,11 @@ class DloCompiler {
         this.dloCC = await DLO_MODULE({
             noExitRuntime: noExit,
             print: (data) => {
-                console.log(data);
+                this.logger.log(data);
                 this.stdout.push(data);
             },
             printErr: (err) => {
-                console.error(err);
+                this.logger.error(err);
                 this.stderr.push(err);
                 this.stdout.push(err);
             }

package/out/dlo/dlo.js

@@ -20,11 +20,11 @@ var DLO;
      * @param cwd
      * @param fs
      */
-    async function exportDloConfig(cwd, fs) {
+    async function exportDloConfig(cwd, fs, logger) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         const cfgData = await (0, compiler_1.generateConfigFile)(cwd, fs, manifest);
         await fs.writeFile(cfgData.path, cfgData.data);
-        console.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
+        logger.log('Generated', defaultFiles_1.DefaultFiles.filePaths.studio.auto.dlo.cfg);
     }
     DLO.exportDloConfig = exportDloConfig;
 })(DLO || (exports.DLO = DLO = {}));

package/out/log.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+var Log;
+(function (Log) {
+    let LogMessageType;
+    (function (LogMessageType) {
+        LogMessageType[LogMessageType["log"] = 0] = "log";
+        LogMessageType[LogMessageType["done"] = 1] = "done";
+        LogMessageType[LogMessageType["info"] = 2] = "info";
+        LogMessageType[LogMessageType["warning"] = 3] = "warning";
+        LogMessageType[LogMessageType["error"] = 4] = "error";
+    })(LogMessageType = Log.LogMessageType || (Log.LogMessageType = {}));
+    Log.LOG_PREFIX = {
+        [LogMessageType.done]: chalk_1.default.bgGreen.black(' DONE '),
+        [LogMessageType.log]: '',
+        [LogMessageType.info]: chalk_1.default.bgBlueBright.black(' INFO '),
+        [LogMessageType.warning]: chalk_1.default.bgYellow.black(' WARNING '),
+        [LogMessageType.error]: chalk_1.default.bgRed.black(' ERROR ')
+    };
+    class Logger {
+        _logHandler;
+        constructor(logOutput = console) {
+            this._logHandler = logOutput;
+        }
+        _log(type, msg, ...args) {
+            args = [Log.LOG_PREFIX[type], msg, ...args];
+            this._logHandler.log(...args);
+        }
+        log(msg, ...args) {
+            this._log(LogMessageType.log, msg, ...args);
+        }
+        error(msg, ...args) {
+            this._log(LogMessageType.error, msg, ...args);
+        }
+        info(msg, ...args) {
+            this._log(LogMessageType.info, msg, ...args);
+        }
+        warn(msg, ...args) {
+            this._log(LogMessageType.warning, msg, ...args);
+        }
+        done(msg, ...args) {
+            this._log(LogMessageType.done, msg, ...args);
+        }
+    }
+    Log.Logger = Logger;
+})(Log || (exports.Log = Log = {}));
+//# sourceMappingURL=log.js.map

package/out/main.js

@@ -7,14 +7,14 @@ const commander_1 = require("commander");
 const package_json_1 = __importDefault(require("../package.json"));
 const cliFS_1 = require("./cliFS");
 const vscode_uri_1 = require("vscode-uri");
-const dependencies_1 = require("./dependencies");
-var installDependencies = dependencies_1.Dependencies.installDependencies;
-var installDependency = dependencies_1.Dependencies.installDependency;
-const package_1 = require("./package/package");
 const apm_1 = require("./package/apm");
 const globals_1 = require("./globals");
-const manifest_1 = require("./manifest");
+const update_notifier_1 = __importDefault(require("update-notifier"));
+const api_1 = require("./api");
+const log_1 = require("./log");
 const program = new commander_1.Command();
+const notifier = (0, update_notifier_1.default)({ pkg: package_json_1.default });
+const logger = new log_1.Log.Logger();
 // dummy cwd
 const devPath = () => {
     if (process.env.NODE_ENV === 'local-dev-app') {
@@ -30,6 +30,19 @@ const devPath = () => {
 };
 const cwd = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.file(process.cwd()), devPath());
 program.version(package_json_1.default.version).usage('<command>');
+/**
+ * Executes a task and ensures that the update available notification is sent after the task completes,
+ * regardless of whether it succeeds or fails.
+ *
+ * @param {Promise<void>} task - A promise representing the task to be executed.
+ * @return {void} This function does not return a value.
+ */
+function main(task) {
+    // todo add task catch handler like: https://github.com/microsoft/vscode-vsce/blob/5518f2f242983d23f1983f6dd0350474f2011543/src/main.ts#L51
+    task.finally(() => {
+        notifier.notify();
+    });
+}
 function handleStudioEnv(env) {
     process.env.STUDIO_ENV = env || globals_1.Globals.ENV.production;
     if (env && env !== globals_1.Globals.ENV.production) {
@@ -40,6 +53,12 @@ function handleStudioEnv(env) {
 function getStudioApiToken(opts) {
     return opts?.token || null;
 }
+function getDefaultOptions(opts) {
+    return {
+        env: handleStudioEnv(opts.env),
+        token: getStudioApiToken(opts)
+    };
+}
 /**
  * Generic option for the STUDIO_ENV
  */
@@ -58,29 +77,15 @@ program
     .allowExcessArguments(true)
     .addOption(optionStudioEnv)
     .addOption(optionStudioToken)
-    .action(async (dependencies, opts) => {
-    const env = handleStudioEnv(opts.env);
-    const apiToken = getStudioApiToken(opts);
-    try {
-        if (dependencies.length > 0) {
-            for (const dependency of dependencies) {
-                const [libraryId, version] = dependency.split('@');
-                await installDependency(cwd, cliFS_1.cliFS, env, apiToken, libraryId, version || null);
-            }
-        }
-        else {
-            return await installDependencies(cwd, cliFS_1.cliFS, env, apiToken);
-        }
-    }
-    catch (e) {
-        console.error(e);
-    }
+    .action((dependencies, opts) => {
+    const { env, token } = getDefaultOptions(opts);
+    main((0, api_1.install)(cwd, cliFS_1.cliFS, env, token, dependencies));
 });
 program
     .command('build')
     .addOption(new commander_1.Option('-p --part <APM part>', 'APM part that should be build').choices(Object.values(apm_1.APM.Part)))
-    .action(async (opts) => {
-    await package_1.Package.buildAll(cwd, cliFS_1.cliFS, opts.part);
+    .action(opts => {
+    main((0, api_1.build)(cwd, cliFS_1.cliFS, logger, opts.part));
 });
 const releasePhaseArguments = Object.values(apm_1.APM.TagPhase);
 program
@@ -92,17 +97,8 @@ program
     .addOption(optionStudioEnv)
     .addOption(optionStudioToken)
     .action(async (opts) => {
-    const env = handleStudioEnv(opts.env);
-    const token = getStudioApiToken(opts);
-    let allowedBackends = null;
-    if (opts.allowedBackends) {
-        allowedBackends = opts.allowedBackends === '*' ? opts.allowedBackends : opts.allowedBackends.split(';');
-        const errorMessage = await manifest_1.Manifest.validateRegistryAllowedBackends(allowedBackends);
-        if (errorMessage) {
-            throw new Error(errorMessage);
-        }
-    }
-    await package_1.Package.release(cwd, cliFS_1.cliFS, token, opts.phase, allowedBackends, env);
+    const { env, token } = getDefaultOptions(opts);
+    main((0, api_1.publish)(cwd, cliFS_1.cliFS, logger, env, token, opts.allowedBackends, opts.phase));
 });
 module.exports = function (argv) {
     program.parse(argv);

package/out/package/package.js

@@ -20,43 +20,76 @@ var Package;
      * Build the whole project or only a specific part
      * @param cwd
      * @param fs
-     * @param apmPart - choose a specific part that should be build
+     * @param logger
+     * @param selectedParts - choose a specific part that should be build or if true all parts are build
      */
-    async function buildAll(cwd, fs, apmPart) {
-        if (!apmPart || apmPart === apm_1.APM.Part.dde) {
-            await buildDDE(cwd, fs);
+    async function buildAll(cwd, fs, logger, selectedParts = true) {
+        if (selectedParts === true) {
+            logger.info('Building project...');
         }
-        if (!apmPart || apmPart === apm_1.APM.Part.dlo) {
-            await buildDLO(cwd, fs);
+        selectedParts = Object.values(apm_1.APM.Part);
+        const mergedDiagnostics = {
+            [apm_1.APM.Part.dde]: [],
+            [apm_1.APM.Part.dlo]: [],
+            [apm_1.APM.Part.dfiles]: []
+        };
+        // Helper for building parts
+        const buildMapping = {
+            [apm_1.APM.Part.dde]: buildDDE,
+            [apm_1.APM.Part.dlo]: buildDLO,
+            [apm_1.APM.Part.dfiles]: buildDfiles
+        };
+        // Build and validate specific parts
+        for (const part of [apm_1.APM.Part.dde, apm_1.APM.Part.dlo, apm_1.APM.Part.dfiles]) {
+            if (selectedParts.includes(part)) {
+                logger.info(`Building ${part.toUpperCase()}...`);
+                const hasError = await buildAndValidatePart(logger, part, 
+                /*@ts-ignore*/
+                buildMapping[part], 
+                /*@ts-ignore*/
+                mergedDiagnostics[part], cwd, fs);
+                if (hasError) {
+                    return mergedDiagnostics; // Early exit on error
+                }
+            }
+        }
+        // Handle pov and blo parts that do not return diagnostics
+        if (selectedParts.includes(apm_1.APM.Part.pov)) {
+            await scriptRunner_1.Shell.tryBuildPov(cwd, fs, logger);
         }
-        if (!apmPart || apmPart === apm_1.APM.Part.dfiles) {
-            await buildDfiles(cwd, fs);
+        else {
+            logger.info('Skipping pov build');
         }
-        if (!apmPart || apmPart === apm_1.APM.Part.pov) {
-            await scriptRunner_1.Shell.tryBuildPov(cwd, fs);
+        if (selectedParts.includes(apm_1.APM.Part.blo)) {
+            await scriptRunner_1.Shell.tryBuildBlo(cwd, fs, logger);
         }
-        if (!apmPart || apmPart === apm_1.APM.Part.blo) {
-            await scriptRunner_1.Shell.tryBuildBlo(cwd, fs);
+        else {
+            logger.info('Skipping blo build');
         }
-        console.log('DONE');
+        await processAdditionalFiles(cwd, fs, logger);
+        logger.done('Project build completed.');
+        return mergedDiagnostics;
     }
     Package.buildAll = buildAll;
     /**
      * Trigger the release based on the manifest settings
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param releasePhase
      * @param allowedBackends
      * @param env
      */
-    async function release(cwd, fs, token, releasePhase, allowedBackends, env) {
+    async function release(cwd, fs, logger, token, releasePhase, allowedBackends, env) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         if (manifest_1.Manifest.isLibrary(manifest)) {
-            await releaseLibrary(cwd, fs, token, env);
+            logger.info('Library project detected. Publishing library...');
+            return releaseLibrary(cwd, fs, logger, token, env);
         }
         else {
-            await releaseAPM(cwd, fs, token, releasePhase, allowedBackends, env);
+            logger.info('App project detected. Publishing app...');
+            return releaseAPM(cwd, fs, logger, token, releasePhase, allowedBackends, env);
         }
     }
     Package.release = release;
@@ -64,12 +97,13 @@ var Package;
      * Publish an application model tag
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param releasePhase
      * @param allowedBackends
      * @param env
      */
-    async function releaseAPM(cwd, fs, token, releasePhase, allowedBackends = null, env) {
+    async function releaseAPM(cwd, fs, logger, token, releasePhase, allowedBackends = null, env) {
         if (!Object.values(apm_1.APM.TagPhase).includes(releasePhase)) {
             throw new Error(`ReleasePhase: ${releasePhase} is not a valid release phase`);
         }
@@ -79,7 +113,7 @@ var Package;
             return;
         }
         // build the complete project
-        await buildAll(cwd, fs);
+        await buildAll(cwd, fs, logger);
         // update the store apm with the actual name/description/...
         await apm_1.APM.updateProfile(cwd, fs, token, env);
         const tagContent = await apm_1.APM.createTag(cwd, fs, releasePhase);
@@ -90,27 +124,28 @@ var Package;
             await registryAPI_1.Registry.updateExistingApplicationVersion(token, manifest.publisher, manifest.registry?.id, manifest.version, {
                 allowedBackends
             }, env);
-            console.log(`Tag "${newTag.version}" with phase "${newTag.phase}" shared with ${[...allowedBackends].join(';')}!`);
+            logger.info(`Tag "${newTag.version}" with phase "${newTag.phase}" shared with ${[...allowedBackends].join(';')}!`);
         }
-        console.log(`Tag "${newTag.version}" with phase "${newTag.phase}" published!`);
+        logger.done(`Tag "${newTag.version}" with phase "${newTag.phase}" published!`);
     }
     Package.releaseAPM = releaseAPM;
     /**
      * Publish a library project
      * @param cwd
      * @param fs
+     * @param logger
      * @param token
      * @param env
      */
-    async function releaseLibrary(cwd, fs, token, env) {
+    async function releaseLibrary(cwd, fs, logger, token, env) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         await manifest_1.Manifest.validateBasicManifest(cwd, fs, manifest);
         await validatePublishSettings(cwd, fs, token, env);
         // build the complete project
-        await buildAll(cwd, fs);
+        await buildAll(cwd, fs, logger);
         const archive = await library_1.Library.createArchive(cwd, fs);
         await library_1.Library.publishPackage(cwd, fs, token, archive, env);
-        console.log(`Library "${manifest.publisher}/${manifest.name}" with version "${manifest.version}" published!`);
+        logger.done(`Library "${manifest.publisher}/${manifest.name}" with version "${manifest.version}" published!`);
     }
     Package.releaseLibrary = releaseLibrary;
     /**
@@ -196,55 +231,73 @@ var Package;
  * Generates all needed files out of the dde declaration
  * @param cwd
  * @param fs
+ * @param logger
  */
-async function buildDDE(cwd, fs) {
-    console.log('Processing DDE...');
-    const result = await dde_1.DDE.compileDDE(cwd, fs);
-    result.diagnostics.forEach(diagnostic => {
-        const message = `${diagnostic.file.path}: ${diagnostic.message}`;
-        if (diagnostic.level === 'error') {
-            console.error(message);
-        }
-        else if (diagnostic.level === 'warning') {
-            console.warn(message);
-        }
-        else {
-            console.log(message);
-        }
-    });
-    throwIfDiagnosticsHaveError(apm_1.APM.Part.dde, result.diagnostics);
+async function buildDDE(cwd, fs, logger) {
+    const result = await dde_1.DDE.compileDDE(cwd, fs, logger);
     if (result.ddeJSON) {
-        await dde_1.DDE.exportMyDatanetXML(cwd, fs, result.ddeJSON);
+        await dde_1.DDE.exportMyDatanetXML(cwd, fs, logger, result.ddeJSON);
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         // a library does not need a history.json
         if (!manifest_1.Manifest.isLibrary(manifest)) {
-            await dde_1.DDE.exportHistoryJson(cwd, fs, result.ddeJSON);
+            await dde_1.DDE.exportHistoryJson(cwd, fs, logger, result.ddeJSON);
         }
-        await dde_1.DDE.exportOpenApi(cwd, fs, result.ddeJSON);
+        await dde_1.DDE.exportOpenApi(cwd, fs, logger, result.ddeJSON);
         if (await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.dlo, manifest)) {
-            await dde_1.DDE.exportAutoDloFiles(cwd, fs, result.ddeJSON);
-            await dlo_1.DLO.exportDloConfig(cwd, fs);
+            await dde_1.DDE.exportAutoDloFiles(cwd, fs, logger, result.ddeJSON);
+            await dlo_1.DLO.exportDloConfig(cwd, fs, logger);
         }
     }
-    else {
-        throw new Error('Project has errors!');
-    }
+    return result.diagnostics;
 }
-async function buildDLO(cwd, fs) {
-    console.log('Processing DLO...');
-    const compiler = new compiler_1.DloCompiler();
+async function buildDLO(cwd, fs, logger) {
+    const compiler = new compiler_1.DloCompiler(logger);
     const { diagnostics } = await compiler.compile(cwd, fs);
-    throwIfDiagnosticsHaveError(apm_1.APM.Part.dlo, diagnostics);
+    return diagnostics;
 }
-async function buildDfiles(cwd, fs) {
-    console.log('Processing DFILES...');
-    const diagnostics = await dfiles_1.DFILES.process(cwd, fs);
-    throwIfDiagnosticsHaveError(apm_1.APM.Part.dfiles, diagnostics);
+async function buildDfiles(cwd, fs, logger) {
+    return await dfiles_1.DFILES.process(cwd, fs, logger);
 }
-function throwIfDiagnosticsHaveError(apmPart, diagnostics) {
+/**
+ * Handle additional files like `mdn_report_template.json`
+ * @private
+ */
+async function processAdditionalFiles(cwd, fs, logger) {
+    const reportTemplate = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.fileNames.reportTemplate);
+    if (await fs.stat(reportTemplate)) {
+        const distFolder = vscode_uri_1.Utils.joinPath(cwd, defaultFiles_1.DefaultFiles.filePaths.dist.reportTemplate);
+        await fs.copy(reportTemplate, distFolder);
+        logger.log(`Copied "${defaultFiles_1.DefaultFiles.fileNames.reportTemplate}" to dist folder.`);
+    }
+}
+function validateDiagnostics(logger, apmPart, diagnostics) {
+    if (apmPart !== apm_1.APM.Part.dlo) {
+        // dlo compiler does log diagnostics by itself
+        logDiagnostics(logger, diagnostics);
+    }
+    const hasErrors = diagnostics.some(diagnostic => diagnostic.level === 'error');
+    if (hasErrors) {
+        const message = `APM part "${apmPart}" has errors. Aborted.`;
+        throw new Error(message);
+    }
+    return hasErrors;
+}
+async function buildAndValidatePart(logger, part, buildFn, mergedDiagnostics, cwd, fs) {
+    const diagnostics = await buildFn(cwd, fs, logger);
+    mergedDiagnostics.push(...diagnostics);
+    return validateDiagnostics(logger, part, diagnostics);
+}
+function logDiagnostics(logger, diagnostics) {
     diagnostics.forEach(diagnostic => {
+        const message = `${diagnostic.file.path}: ${diagnostic.message}`;
         if (diagnostic.level === 'error') {
-            throw new Error(`APM part '${apmPart}' has errors. Aborted.`);
+            logger.error(message);
+        }
+        else if (diagnostic.level === 'warning') {
+            logger.warn(message);
+        }
+        else {
+            logger.log(message);
         }
     });
 }

package/out/scriptRunner.js

@@ -34,15 +34,16 @@ var Shell;
      * Calls the POV build command defined within the manifest
      * @param cwd
      * @param fs
+     * @param logger
      */
-    async function tryBuildPov(cwd, fs) {
+    async function tryBuildPov(cwd, fs, logger) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         if (await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.pov)) {
-            console.log('Executing POV build script', manifest.pov?.details.buildCommand);
+            logger.info('Executing POV build script', manifest.pov?.details.buildCommand);
             const { buildCommand, workingPath } = manifest.pov.details;
             const povDir = vscode_uri_1.Utils.joinPath(cwd, workingPath);
             try {
-                await execShell(povDir, buildCommand);
+                await execShell(povDir, buildCommand, logger);
             }
             catch (e) {
                 if (e.code) {
@@ -59,15 +60,16 @@ var Shell;
      * Calls the BLO build command defined within the manifest
      * @param cwd
      * @param fs
+     * @param logger
      */
-    async function tryBuildBlo(cwd, fs) {
+    async function tryBuildBlo(cwd, fs, logger) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
         if (await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.blo, manifest)) {
-            console.log('Executing BLO build script', manifest.blo?.buildCommand);
+            logger.info('Executing BLO build script', manifest.blo?.buildCommand);
             const { buildCommand, workingPath } = manifest.blo;
             const bloDir = vscode_uri_1.Utils.joinPath(cwd, workingPath);
             try {
-                await execShell(bloDir, buildCommand);
+                await execShell(bloDir, buildCommand, logger);
             }
             catch (e) {
                 if (e.code) {
@@ -85,13 +87,14 @@ var Shell;
  * Generic shell executor
  * @param cwd - working dir where the command should be executed in
  * @param cmd - the shell command
+ * @param logger
  */
-async function execShell(cwd, cmd) {
+async function execShell(cwd, cmd, logger) {
     return new Promise((resolve, reject) => {
         // todo use spawn instead of exec to allow streaming to the console
         child_process.exec(cmd, { cwd: cwd.fsPath, env: process.env }, (error, stdout, stderr) => {
-            console.log(stdout);
-            console.error(stderr);
+            logger.log(stdout);
+            logger.error(stderr);
             if (error) {
                 reject(error);
             }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.24.1",
+	"version": "0.26.0",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",
@@ -28,6 +28,7 @@
 		"ajv": "^8.17.1",
 		"ajv-formats": "^3.0.1",
 		"ajv-keywords": "^5.1.0",
+		"chalk": "^5.4.1",
 		"commander": "^12.1.0",
 		"cross-fetch": "^4.0.0",
 		"dotenv": "^16.4.7",
@@ -42,6 +43,7 @@
 		"semver": "^7.6.3",
 		"tarballjs": "github:ankitrohatgi/tarballjs",
 		"tinytar-fix": "^0.1.1",
+		"update-notifier": "^7.3.1",
 		"vscode-uri": "^3.0.8",
 		"yaml": "^2.6.1"
 	},
@@ -56,6 +58,7 @@
 		"@types/mocha": "^10.0.9",
 		"@types/node": "^22.9.1",
 		"@types/semver": "^7.5.6",
+		"@types/update-notifier": "^6.0.8",
 		"@types/vscode": "^1.86.2",
 		"chai": "^4.3.8",
 		"chai-as-promised": "^7.1.2",