@microtronics/studio-cli 0.18.0 → 0.19.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 
 
+## 0.19.1 (2025-02-20)
+
+# Changelog
+
+## 0.19.0 (2025-02-19)
+
+* test(studio-cli): tag header should not have property type ([5082db8](https://bitbucket.org/microtronics-core/vscode-studio/commits/5082db8))
+* test(studio-cli): test if type addon can only used from specific version onwards ([213bc7c](https://bitbucket.org/microtronics-core/vscode-studio/commits/213bc7c))
+* test(studio-cli): validate apm tag header creation ([e74acc8](https://bitbucket.org/microtronics-core/vscode-studio/commits/e74acc8))
+* test(studio-cli): validate openapi generation for addons ([08176bc](https://bitbucket.org/microtronics-core/vscode-studio/commits/08176bc))
+* feat(studio-cli): added function to validate if app id is an uuid ([60bda6f](https://bitbucket.org/microtronics-core/vscode-studio/commits/60bda6f))
+* feat(studio-cli): allow creating an apm tag for addons ([a7d32c4](https://bitbucket.org/microtronics-core/vscode-studio/commits/a7d32c4))
+* feat(studio-cli): generate api routes for addons ([a075407](https://bitbucket.org/microtronics-core/vscode-studio/commits/a075407))
+* feat(studio-cli): improved manifest validation if type is addon ([c3ae0c9](https://bitbucket.org/microtronics-core/vscode-studio/commits/c3ae0c9))
+* feat(studio-cli): only allow project type addon for a specific backend version ([46f0f28](https://bitbucket.org/microtronics-core/vscode-studio/commits/46f0f28))
+* feat(studio-cli): support for new app type `apm` ([8041db3](https://bitbucket.org/microtronics-core/vscode-studio/commits/8041db3))
+* chore(studio-cli): add run file for local addon development ([465a1f0](https://bitbucket.org/microtronics-core/vscode-studio/commits/465a1f0))
+* chore(studio-cli): disable dlo per default if project type is addon ([a7f98af](https://bitbucket.org/microtronics-core/vscode-studio/commits/a7f98af))
+* chore(studio-cli): dissallow setting hw/fw & productId if project type is addon ([74c90c3](https://bitbucket.org/microtronics-core/vscode-studio/commits/74c90c3))
+* chore(studio-cli): improve type to allow `Manifest.ProjectTypes` ([fe6535f](https://bitbucket.org/microtronics-core/vscode-studio/commits/fe6535f))
+* chore(studio-cli): validate for device profile id if dlo is enabled ([908fc9a](https://bitbucket.org/microtronics-core/vscode-studio/commits/908fc9a))
+* revert(studio-cli): remove type property from tagheader object ([65f90ad](https://bitbucket.org/microtronics-core/vscode-studio/commits/65f90ad))
+* refactor(studio-cli): added function to create the `baseTagHeader` ([ac9f83f](https://bitbucket.org/microtronics-core/vscode-studio/commits/ac9f83f))
+
 ## 0.18.0 (2025-02-13)
 
 

package/dist/studio-cli.d.ts

@@ -23,37 +23,14 @@ export declare namespace APM {
         blo = "blo",
         dfiles = "dfiles"
     }
-    export interface TagHeader extends ApplicationTagInformation {
-        author: string;
-        version: string;
-        blo_level?: Manifest.BloAccessLevel;
-        required_be?: string;
-        required_hwfw?: string;
-        required_productcode?: string;
+    export interface TagHeader extends BaseTagHeader {
+        phase: TagPhase;
+        version: string | number;
     }
-    export interface DevTagHeader {
-        name: string;
-        abstract: string;
-        author: string;
-        pip_id: string;
-        pov_location: Manifest.PovLocation;
-        pov_details_lowlevel: boolean;
-        blo_level: Manifest.BloAccessLevel;
+    export interface DevTagHeader extends BaseTagHeader {
         blo_autostart: boolean;
-        /**
-         * ONE specific
-         * the version 0 for ONE
-         */
-        version?: number;
-        /**
-         * ONE specific
-         * owner_id is the organizationID
-         */
-        owner_id?: string;
-        required_be?: string;
-        required_hwfw?: string;
-        required_productcode?: string;
     }
+    export function createBaseTagHeader(manifest: Manifest.Manifest): BaseTagHeader;
     /**
      * Create new release tag
      * @param cwd
@@ -117,7 +94,26 @@ export declare namespace APM {
     }>;
 }
 
-declare type ApplicationTagInformation = components['schemas']['ApplicationTagInformation'];
+declare interface BaseTagHeader {
+    name: string;
+    abstract: string;
+    author: string;
+    blo_level?: Manifest.BloAccessLevel;
+    required_be?: string;
+    required_hwfw?: string;
+    required_productcode?: string;
+    pov_location: Manifest.PovLocation;
+    pov_details_lowlevel: boolean;
+    pip_id: '';
+    /**
+     * exists only when app type is addon
+     */
+    addon_max_per_site?: number;
+    /**
+     * exists only when app type is addon
+     */
+    addon_max_sources?: number;
+}
 
 declare interface components {
     schemas: {
@@ -173,6 +169,7 @@ declare interface components {
         NewApplication: {
             /** @description The project name */
             name: string;
+            type?: components["schemas"]["ApplicationType"];
             /** @description Short description what this library does */
             description: string;
             targetSystem: components["schemas"]["TargetSystem"];
@@ -180,7 +177,11 @@ declare interface components {
             organizationId?: string;
             /** @description Defines which servers are allowed to see this application. If null, the application wont be shared with anyone */
             allowedBackends?: ("*" | string[]) | null;
+            /** @description Sites with the given APM ID are allowed to be defined as addon parent. This property is only available if the project type is 'addon' */
+            allowedApplications?: ("*" | string[]) | null;
         };
+        /** @enum {string} */
+        ApplicationType: "app" | "addon";
         ApplicationInformationBase: {
             version: components["parameters"]["ApplicationVersion"];
             publisherId: components["parameters"]["PublisherId"];
@@ -2045,13 +2046,21 @@ export declare namespace Manifest {
      * The source filename where the information is stored in
      */
     const fileName = "studio.json";
-    export type DeviceProfiles = 'm22x' | 'm23x' | 'nrf91' | 'm2blegw' | 'm2easyv3' | 'm2easyiot';
+    export enum DeviceProfiles {
+        m22x = "m22x",
+        m23x = "m23x",
+        nrf91 = "nrf91",
+        m2blegw = "m2blegw",
+        m2easyv3 = "m2easyv3",
+        m2easyiot = "m2easyiot"
+    }
     /**
      * Type of the iot app project
      */
     export enum ProjectTypes {
         app = "app",
-        library = "library"
+        library = "library",
+        addon = "addon"
     }
     export interface Manifest {
         version: string;
@@ -2061,7 +2070,7 @@ export declare namespace Manifest {
         type: ProjectTypes;
         legacyProject?: boolean;
         icon?: string;
-        dpid: DeviceProfiles;
+        dpid?: DeviceProfiles;
         engines?: {
             backend?: string;
             hwfw?: string[];
@@ -2118,7 +2127,7 @@ export declare namespace Manifest {
      */
     export function read(cwd: URI, fs: LocalFS): Promise<Manifest>;
     /**
-     * Reads the studio.json as an uint8array
+     * Reads the studio.json as an Uint8Array
      * @param cwd
      * @param fs
      */
@@ -2134,6 +2143,16 @@ export declare namespace Manifest {
      * Check if the current project is a library project
      */
     export function isLibrary(manifest: Manifest.Manifest): boolean;
+    /**
+     * Check if the current project is an addon project
+     * @param manifest
+     */
+    export function isAddon(manifest: Manifest.Manifest): boolean;
+    /**
+     * Check if the current project is an app project
+     * @param manifest
+     */
+    export function isApp(manifest: Manifest.Manifest): boolean;
     /**
      * Validates if the properties within
      * @param cwd
@@ -2148,6 +2167,7 @@ export declare namespace Manifest {
     export function validatePublisherId(publisher: string): "No publisher set yet" | "Publisher can only contain 'A' through 'Z', 'a' through 'z', '0' through '9' and '-'. The Publisher start with an alphabetic or numeric character." | null;
     export function validatePublisherOnline(token: Registry.AuthToken, publisher: string): Promise<string | null>;
     export function validateRegistryAllowedBackends(allowedBackends: undefined | null | string | string[]): Promise<string | null>;
+    export function validateRegistryAllowedApplications(allowedApplications: undefined | null | string | string[]): Promise<string | null>;
     export function validateApplicationIcon(cwd: URI, fs: LocalFS, manifest: Manifest.Manifest): Promise<void>;
     export function validateEngineSettings(manifest: Manifest.Manifest): void;
     /**
@@ -4289,7 +4309,9 @@ export declare namespace Registry {
     export function fetchCustomContent(token: AuthToken, contentURL: string, json?: boolean, env?: Globals.ENV): Promise<ArrayBuffer | any>;
     export type Publisher = components['schemas']['Publisher'];
     export function getPublisher(token: AuthToken, publisherId: string): Promise<Publisher | null>;
-    export type ApiNewApplication = components['schemas']['NewApplication'];
+    export type ApiNewApplication = components['schemas']['NewApplication'] & {
+        type?: string | Manifest.ProjectTypes;
+    };
     export function createNewApplication(token: AuthToken, publisherId: string, newApplication: ApiNewApplication, env?: Globals.ENV): Promise<string | null | undefined>;
     export type ApplicationDetailInformation = components['schemas']['ApplicationDetailInformation'];
     export function getExistingApplication(token: AuthToken, publisherId: string, applicationId: string, env?: Globals.ENV): Promise<ApplicationDetailInformation>;

package/out/dde/fileGenerators/api.js

@@ -30,7 +30,9 @@ const coreDefinitions_1 = require("../coreDefinitions");
 var ContainerType = coreDefinitions_1.DDE_Core.ContainerType;
 var TransferDirection = coreDefinitions_1.DDE_Core.TransferDirection;
 var fieldTypeDefinitions = coreDefinitions_1.DDE_Core.fieldTypeDefinitions;
+const manifest_1 = require("../../manifest");
 const contextIdRef = { $ref: '#/components/parameters/contextId' };
+const addonIdRef = { $ref: '#/components/parameters/addonId' };
 const histdataResponseRef = { $ref: '#/components/schemas/histdataResponse' };
 const histdataRequestRef = { $ref: '#/components/schemas/histdataRequest' };
 const rapidM2MStampRef = { $ref: '#/components/schemas/rapidM2MStamp' };
@@ -179,6 +181,19 @@ function generateAPIFromMap(ddeMap, manifest, context = null) {
     else {
         Object.assign(apiDescription.components, structuredClone(defaultAppComponents));
     }
+    const isAddon = manifest_1.Manifest.isAddon(manifest);
+    if (isAddon) {
+        // add addonUid parameter if this is an addon project
+        apiDescription.components.parameters['addonId'] = {
+            name: 'addonUid',
+            in: 'path',
+            description: 'The addon uid',
+            schema: {
+                type: 'string'
+            },
+            required: true
+        };
+    }
     for (const containerDefinition of Object.values(ddeMap.containers)) {
         if ((context &&
             (!containerDefinition.libraries.includes(context) || containerDefinition.containerType === ContainerType.hx)) ||
@@ -188,10 +203,12 @@ function generateAPIFromMap(ddeMap, manifest, context = null) {
         }
         generateTagDescriptionFromContainer(apiDescription, containerDefinition);
         generateSchemasFromContainer(apiDescription, containerDefinition, context);
-        generatePathInformationFromContainer(apiDescription, containerDefinition);
+        generatePathInformationFromContainer(apiDescription, containerDefinition, isAddon);
         // legacy routes
-        generateLegacySchemasFromContainer(apiDescription, containerDefinition, context);
-        generateLegacyPathInformationFromContainer(apiDescription, containerDefinition);
+        if (!isAddon) {
+            generateLegacySchemasFromContainer(apiDescription, containerDefinition, context);
+            generateLegacyPathInformationFromContainer(apiDescription, containerDefinition);
+        }
     }
     return (0, yaml_1.stringify)(apiDescription);
 }
@@ -434,10 +451,15 @@ function generateLegacyPathInformationFromContainer(apiDescription, containerDef
     }
     apiDescription.paths[apiPath] = apiPathMethods;
 }
-function generatePathInformationFromContainer(apiDescription, containerDefinition) {
+function generatePathInformationFromContainer(apiDescription, containerDefinition, isAddonProject = false) {
     const isTimeseriesContainer = containerDefinition.containerType === ContainerType.hx;
     const containerType = isTimeseriesContainer ? 'timeseries' : 'containers';
-    const apiPath = `/api/1/sites/{siteUid}/${containerType}/${containerDefinition.title}`;
+    const pathParameters = [contextIdRef];
+    let apiPath = `/api/1/sites/{siteUid}/${containerType}/${containerDefinition.title}`;
+    if (isAddonProject) {
+        apiPath = `/api/1/sites/{siteUid}/addons/{addonUid}/${containerType}/${containerDefinition.title}`;
+        pathParameters.push(addonIdRef);
+    }
     const apiPathMethods = {
         get: undefined,
         put: undefined
@@ -445,7 +467,7 @@ function generatePathInformationFromContainer(apiDescription, containerDefinitio
     const getMethod = {
         tags: [tagNameFromContainerTitle(containerDefinition.title)],
         summary: `Retrieve the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-        parameters: [contextIdRef],
+        parameters: [...pathParameters],
         responses: {
             '200': {
                 ...successfulOperationResponse,
@@ -478,7 +500,7 @@ function generatePathInformationFromContainer(apiDescription, containerDefinitio
             apiPathMethods.put = {
                 tags: [tagNameFromContainerTitle(containerDefinition.title)],
                 summary: `Modify the data of the "${tagNameFromContainerTitle(containerDefinition.title)}" container`,
-                parameters: [contextIdRef],
+                parameters: [...pathParameters],
                 requestBody: {
                     content: {
                         'application/json': {
@@ -506,7 +528,7 @@ function generatePathInformationFromContainer(apiDescription, containerDefinitio
             tags: [tagNameFromContainerTitle(containerDefinition.title)],
             summary: `Get the historical data of "${containerDefinition.title}"`,
             parameters: [
-                contextIdRef,
+                ...pathParameters,
                 {
                     name: 'json',
                     in: 'query',

package/out/dde/fileGenerators/dlo.js

@@ -101,6 +101,9 @@ function generateAutoIncFromMap(ddeMap, globalDefines, manifest) {
         pwn(`#define ${name} ${quotes}${value}${quotes}`);
     }
     const { dpid, registry } = manifest;
+    if (!dpid) {
+        throw new Error('Setting "dpid" is required to generate dlo files');
+    }
     const { auto_inc } = DeviceProfiles_1.DeviceProfiles[dpid];
     addDefinition(`APM_DPID`, `${dpid}`);
     addDefinition(`APM_DPID_${dpid}`, `1`);

package/out/main.js

@@ -22,6 +22,9 @@ const devPath = () => {
     else if (process.env.NODE_ENV === 'local-dev-lib') {
         return './dev/lib';
     }
+    else if (process.env.NODE_ENV === 'local-dev-addon') {
+        return './dev/addon';
+    }
     return '';
 };
 const cwd = vscode_uri_1.Utils.joinPath(vscode_uri_1.URI.file(process.cwd()), devPath());

package/out/manifest.js

@@ -12,8 +12,11 @@ const registryAPI_1 = require("./registryAPI");
 const globals_1 = require("./globals");
 const preload_1 = __importDefault(require("semver/preload"));
 const DeviceProfiles_1 = require("./DeviceProfiles");
-var isNumeric = helper_1.Helper.isNumeric;
 const apm_1 = require("./package/apm");
+var isNumeric = helper_1.Helper.isNumeric;
+const PRODUCT_ID_SUPPORTED = '52v007';
+// todo fill with actual version
+const ADDON_SUPPORTED = '52v099';
 // Cache to reduce the disk read requests
 const manifestCache = {
     _manifest: null,
@@ -43,6 +46,15 @@ var Manifest;
      * The source filename where the information is stored in
      */
     Manifest.fileName = 'studio.json';
+    let DeviceProfiles;
+    (function (DeviceProfiles) {
+        DeviceProfiles["m22x"] = "m22x";
+        DeviceProfiles["m23x"] = "m23x";
+        DeviceProfiles["nrf91"] = "nrf91";
+        DeviceProfiles["m2blegw"] = "m2blegw";
+        DeviceProfiles["m2easyv3"] = "m2easyv3";
+        DeviceProfiles["m2easyiot"] = "m2easyiot";
+    })(DeviceProfiles = Manifest.DeviceProfiles || (Manifest.DeviceProfiles = {}));
     /**
      * Type of the iot app project
      */
@@ -50,6 +62,7 @@ var Manifest;
     (function (ProjectTypes) {
         ProjectTypes["app"] = "app";
         ProjectTypes["library"] = "library";
+        ProjectTypes["addon"] = "addon";
     })(ProjectTypes = Manifest.ProjectTypes || (Manifest.ProjectTypes = {}));
     let BloAccessLevel;
     (function (BloAccessLevel) {
@@ -84,7 +97,7 @@ var Manifest;
     }
     Manifest.read = read;
     /**
-     * Reads the studio.json as an uint8array
+     * Reads the studio.json as an Uint8Array
      * @param cwd
      * @param fs
      */
@@ -118,6 +131,22 @@ var Manifest;
         }
     }
     Manifest.isLibrary = isLibrary;
+    /**
+     * Check if the current project is an addon project
+     * @param manifest
+     */
+    function isAddon(manifest) {
+        return manifest.type === ProjectTypes.addon;
+    }
+    Manifest.isAddon = isAddon;
+    /**
+     * Check if the current project is an app project
+     * @param manifest
+     */
+    function isApp(manifest) {
+        return manifest.type === ProjectTypes.app;
+    }
+    Manifest.isApp = isApp;
     /**
      * Validates if the properties within
      * @param cwd
@@ -228,6 +257,30 @@ var Manifest;
         return null;
     }
     Manifest.validateRegistryAllowedBackends = validateRegistryAllowedBackends;
+    const REGEX_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    async function validateRegistryAllowedApplications(allowedApplications) {
+        if (allowedApplications === undefined) {
+            return 'Allowed applications not specified yet';
+        }
+        if (allowedApplications === null) {
+            return null;
+        }
+        if (Array.isArray(allowedApplications) || allowedApplications?.includes(';')) {
+            const validationArray = allowedApplications?.includes(';')
+                ? allowedApplications.split(';')
+                : allowedApplications;
+            for (const uid of validationArray) {
+                if (!uid.match(REGEX_UUID)) {
+                    return `Application id "${uid}" is invalid`;
+                }
+            }
+        }
+        else if (!allowedApplications?.match(REGEX_UUID) && allowedApplications !== '*') {
+            return `Invalid value for "allowedApplications"`;
+        }
+        return null;
+    }
+    Manifest.validateRegistryAllowedApplications = validateRegistryAllowedApplications;
     async function validateApplicationIcon(cwd, fs, manifest) {
         const iconPath = manifest.icon;
         if (!iconPath) {
@@ -262,6 +315,7 @@ var Manifest;
             throw new Error('Setting "engines.backend" is invalid');
         }
         validateHwFwOrProductId(manifest);
+        validateAddonSupported(manifest);
     }
     Manifest.validateEngineSettings = validateEngineSettings;
     /**
@@ -275,9 +329,10 @@ var Manifest;
         if (!manifest) {
             manifest = await Manifest.read(cwd, fs);
         }
+        const isAddon = Manifest.isAddon(manifest);
         switch (apmPart) {
             case apm_1.APM.Part.dlo:
-                return !!manifest?.dlo?.mainFile;
+                return !!manifest?.dlo?.mainFile && !isAddon;
             case apm_1.APM.Part.blo:
                 return !!(manifest.blo?.buildCommand && manifest.blo?.workingPath);
             case apm_1.APM.Part.pov:
@@ -324,13 +379,31 @@ function validateBLOSettings(manifest) {
 }
 function validateHwFwOrProductId(manifest) {
     const { backend, productId, hwfw } = manifest.engines;
-    if (backend && backend >= '52v007') {
+    if (Manifest.isAddon(manifest) && (productId || hwfw)) {
+        throw new Error('For project type "addon", "engines.hwfw" or "engines.productId" is not allowed!"');
+    }
+    if (backend && backend >= PRODUCT_ID_SUPPORTED) {
         if (hwfw && productId) {
             throw new Error('Only "engines.hwfw" or "engines.productId" is allowed!"');
         }
     }
     else if (productId) {
-        throw new Error('"engines.productId" requires "engines.backend" to be ">=52v007"');
+        throw new Error(`"engines.productId" requires "engines.backend" to be "${PRODUCT_ID_SUPPORTED}"`);
+    }
+}
+function validateAddonSupported(manifest) {
+    if (!Manifest.isAddon(manifest)) {
+        return;
+    }
+    const { backend } = manifest.engines;
+    if (!backend || backend < ADDON_SUPPORTED) {
+        throw new Error(`Project type "addon" requires "engines.backend" to be ">=${ADDON_SUPPORTED}"`);
+    }
+    if (manifest.dlo) {
+        throw new Error('For project type "addon", "dlo" is not supported!"');
+    }
+    if (manifest.dpid) {
+        throw new Error('For project type "addon", "dpid" is not supported!"');
     }
 }
 /**

package/out/package/apm.js

@@ -31,30 +31,47 @@ var APM;
         Part["blo"] = "blo";
         Part["dfiles"] = "dfiles";
     })(Part = APM.Part || (APM.Part = {}));
-    /**
-     * Create new release tag
-     * @param cwd
-     * @param fs
-     * @param phase
-     */
-    async function createTag(cwd, fs, phase) {
-        const manifest = await manifest_1.Manifest.read(cwd, fs);
-        const { version, description, name, pov, engines, blo, publisher } = manifest;
+    function createBaseTagHeader(manifest) {
+        const { description, name, pov, engines, blo, publisher, type } = manifest;
+        const projectType = type || manifest_1.Manifest.ProjectTypes.app;
         const tagHeader = {
             name: name,
             abstract: description,
-            phase: phase,
             author: publisher || '',
             pov_location: manifest_1.Manifest.PovLocation.embedded,
-            version: version,
+            pov_details_lowlevel: false,
             required_be: engines?.backend,
             required_hwfw: engines?.hwfw?.join(';'),
             required_productcode: engines?.productId?.join(';'),
-            blo_level: blo?.accessLevel || manifest_1.Manifest.BloAccessLevel.restricted
+            blo_level: blo?.accessLevel || manifest_1.Manifest.BloAccessLevel.restricted,
+            pip_id: ''
         };
         if (pov && pov.details) {
             tagHeader.pov_location = manifest_1.Manifest.PovLocation.pure;
         }
+        if (projectType === 'addon') {
+            tagHeader.required_hwfw = undefined;
+            tagHeader.required_productcode = undefined;
+            tagHeader.addon_max_sources = 1;
+            tagHeader.addon_max_per_site = 1;
+        }
+        return tagHeader;
+    }
+    APM.createBaseTagHeader = createBaseTagHeader;
+    /**
+     * Create new release tag
+     * @param cwd
+     * @param fs
+     * @param phase
+     */
+    async function createTag(cwd, fs, phase) {
+        const manifest = await manifest_1.Manifest.read(cwd, fs);
+        const baseTagHeader = createBaseTagHeader(manifest);
+        const tagHeader = {
+            version: manifest.version,
+            ...baseTagHeader,
+            phase: phase
+        };
         return await createBuffer(cwd, fs, manifest, tagHeader);
     }
     APM.createTag = createTag;
@@ -65,23 +82,11 @@ var APM;
      */
     async function createDevTag(cwd, fs) {
         const manifest = await manifest_1.Manifest.read(cwd, fs);
-        const { publisher, name, engines, blo } = manifest;
+        const baseTag = createBaseTagHeader(manifest);
         const apmTagHeader = {
-            name: name,
-            author: publisher || '',
-            abstract: '',
-            blo_level: blo?.accessLevel || manifest_1.Manifest.BloAccessLevel.restricted,
-            pip_id: '',
-            pov_details_lowlevel: false,
-            pov_location: manifest_1.Manifest.PovLocation.embedded,
-            required_be: engines?.backend,
-            required_hwfw: engines?.hwfw?.join(';'),
-            required_productcode: engines?.productId?.join(';'),
+            ...baseTag,
             blo_autostart: false
         };
-        if (manifest.pov?.details) {
-            apmTagHeader.pov_location = manifest_1.Manifest.PovLocation.pure;
-        }
         return createBuffer(cwd, fs, manifest, apmTagHeader);
     }
     APM.createDevTag = createDevTag;
@@ -178,11 +183,17 @@ var APM;
         const backendTarget = 'myDatanet';
         const { publisher, name, description } = manifest;
         const newApplication = {
+            // @ts-ignore
+            type: manifest.type || manifest_1.Manifest.ProjectTypes.app,
             name: name,
             targetSystem: backendTarget,
             description: description || '',
             allowedBackends: null
         };
+        // initialize allowedApplications for addon
+        if (manifest_1.Manifest.isAddon(manifest)) {
+            newApplication.allowedApplications = null;
+        }
         // create new application
         const projectId = await registryAPI_1.Registry.createNewApplication(token, publisher, newApplication, env);
         if (!projectId) {

package/out/package/package.js

@@ -171,6 +171,12 @@ var Package;
         if (!manifest_1.Manifest.isLibrary(manifest)) {
             await manifest_1.Manifest.validateApplicationIcon(cwd, fs, manifest);
             manifest_1.Manifest.validateEngineSettings(manifest);
+            // validate for dpid
+            if (manifest_1.Manifest.isApp(manifest) &&
+                (await manifest_1.Manifest.isApmPartEnabled(cwd, fs, apm_1.APM.Part.dlo, manifest)) &&
+                (!manifest.dpid || !Object.values(manifest_1.Manifest.DeviceProfiles).includes(manifest.dpid))) {
+                throw new Error(`dpid: The device profile is needed to compile a dlo`);
+            }
         }
     }
     Package.validatePublishSettings = validatePublishSettings;
@@ -204,8 +210,10 @@ async function buildDDE(cwd, fs) {
             await dde_1.DDE.exportHistoryJson(cwd, fs, result.ddeJSON);
         }
         await dde_1.DDE.exportOpenApi(cwd, fs, result.ddeJSON);
-        await dde_1.DDE.exportAutoDloFiles(cwd, fs, result.ddeJSON);
-        await dlo_1.DLO.exportDloConfig(cwd, fs);
+        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);
+        }
     }
     else {
         throw new Error('Project has errors!');

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@microtronics/studio-cli",
-	"version": "0.18.0",
+	"version": "0.19.1",
 	"description": "Microtronics Studio CLI Tool",
 	"main": "./out/api.js",
 	"typings": "./dist/studio-cli.d.ts",

package/studio-cli-addon

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+// used for local development only
+process.env.NODE_ENV = 'local-dev-addon';
+require('./out/main')(process.argv);