c8y-nitro 0.5.0 → 0.7.0

package/dist/cli/index.mjs

@@ -1,4 +1,4 @@
-import { n as name, r as version, t as description } from "../package-bfMasPPg.mjs";
+import { n as name, r as version, t as description } from "../package-BhFLRPOb.mjs";
 import { defineCommand, runMain } from "citty";
 //#region src/cli/index.ts
 runMain(defineCommand({
@@ -8,9 +8,9 @@ runMain(defineCommand({
 		description
 	},
 	subCommands: {
-		bootstrap: () => import("../bootstrap-BSdVwFWO.mjs").then((r) => r.default),
-		roles: () => import("../roles-CoBPqvDv.mjs").then((r) => r.default),
-		options: () => import("../options-BkWL1FOa.mjs").then((r) => r.default)
+		bootstrap: () => import("../bootstrap-ObaEF7rN.mjs").then((r) => r.default),
+		roles: () => import("../roles-B58Fguop.mjs").then((r) => r.default),
+		options: () => import("../options-B7_yb_wr.mjs").then((r) => r.default)
 	}
 }));
 //#endregion

package/dist/credentials-eKnJ7m9Y.d.mts

@@ -0,0 +1,5 @@
+import { ICredentials } from "@c8y/client";
+//#region src/types/credentials.d.ts
+type TenantCredentials = Record<string, ICredentials>;
+//#endregion
+export { TenantCredentials as t };

package/dist/{index-Bvu7DqDt.d.mts → index-ByDSMEvU.d.mts}

@@ -1,5 +1,5 @@
+import "./credentials-eKnJ7m9Y.mjs";
 import { C8YTenantOptionKeysCacheConfig } from "c8y-nitro/types";
-
 //#region src/types/apiClient.d.ts
 interface C8YAPIClientOptions {
   /**
@@ -16,7 +16,7 @@ interface C8YAPIClientOptions {
 }
 //#endregion
 //#region src/types/manifest.d.ts
-type C8YManifestOptions = Omit<C8YManifest, 'name' | 'version' | 'apiVersion' | 'key' | 'type' | 'provider'>;
+type C8YManifestOptions = Omit<C8YManifest, 'name' | 'version' | 'apiVersion' | 'key' | 'type' | 'provider' | 'openApiSpec'>;
 interface C8YManifest {
   /**
    * API version (e.g., "v2", "2"). Version 2 required for enhanced container security.
@@ -126,6 +126,16 @@ interface C8YManifest {
    * Platform extensions (e.g., UI plugins).
    */
   extensions?: Extension[];
+  /**
+   * OpenAPI specification path exposed by this microservice. Auto-populated
+   * by c8y-nitro when Nitro's `experimental.openAPI` is enabled and
+   * `openAPI.production` is configured. Used by clients (e.g., mc8yp) to
+   * auto-discover the API.
+   *
+   * Path is relative to the microservice context path.
+   * @example "/_openapi.json"
+   */
+  openApiSpec?: string;
 }
 /**
  * Company/organization information.
@@ -383,10 +393,16 @@ interface C8YRoles$1 {}
  */
 type C8YTenantOptionKeysCacheConfig$1 = Partial<Record<C8YTenantOptionKey$1, number>>;
 /**
- * Type for tenant option keys.
+ * Union of tenant option keys declared in `manifest.settings`.
  * Overwritten by generated types from manifest settings (manifest.settings[].key).
  */
 type C8YTenantOptionKey$1 = string;
+/**
+ * The microservice's own tenant option settings category, resolved from
+ * `manifest.settingsCategory` (falling back to `contextPath`, then `name`).
+ * Overwritten by generated types from the manifest.
+ */
+type C8YSettingsCategory$1 = string;
 //#endregion
 //#region src/types/index.d.ts
 interface C8yDevOptions {
@@ -411,7 +427,7 @@ interface C8yNitroModuleOptions {
    *
    * Query params:
    * - `all`: invalidate all created tenant option fetchers
-   * - `key`: invalidate a single manifest-defined tenant option key if its fetcher exists
+   * - `key`: invalidate a single manifest-defined tenant option key if it exists
    *
    * `all` takes priority over `key`.
    * @default false
@@ -428,4 +444,4 @@ interface C8yNitroModuleOptions {
   skipBootstrap?: boolean;
 }
 //#endregion
-export { C8YRoles$1 as a, C8YManifest as c, C8YTenantOptionKeysCacheConfig$1 as i, C8YManifestOptions as l, C8yNitroModuleOptions as n, C8yCacheOptions as o, C8YTenantOptionKey$1 as r, C8YZipOptions as s, C8yDevOptions as t, C8YAPIClientOptions as u };
+export { C8YTenantOptionKeysCacheConfig$1 as a, C8YZipOptions as c, C8YAPIClientOptions as d, C8YTenantOptionKey$1 as i, C8YManifest as l, C8yNitroModuleOptions as n, C8YRoles$1 as o, C8YSettingsCategory$1 as r, C8yCacheOptions as s, C8yDevOptions as t, C8YManifestOptions as u };

package/dist/index.d.mts

@@ -1,12 +1,17 @@
-import { n as C8yNitroModuleOptions } from "./index-Bvu7DqDt.mjs";
+import { n as C8yNitroModuleOptions } from "./index-ByDSMEvU.mjs";
+import { t as TenantCredentials } from "./credentials-eKnJ7m9Y.mjs";
 import { NitroModule } from "nitro/types";
-
 //#region src/index.d.ts
 declare module 'nitro/types' {
   interface NitroOptions {
     c8y?: C8yNitroModuleOptions;
   }
 }
+declare module 'nitro/types' {
+  interface NitroRuntimeHooks {
+    'c8y:tenantCredentialsUpdated': (prev: TenantCredentials | null, next: TenantCredentials) => void;
+  }
+}
 declare function c8y(): NitroModule;
 //#endregion
 export { c8y, c8y as default };

package/dist/index.mjs

@@ -1,8 +1,8 @@
-import { _ as GENERATED_READINESS_ROUTE, a as findMicroserviceByName, g as GENERATED_LIVENESS_ROUTE, h as GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE, l as subscribeToApplication, m as createC8yManifestFromNitro, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BgTNTqHd.mjs";
-import { t as writeBootstrapCredentials } from "./env-file-B0BK-uZW.mjs";
-import { n as name } from "./package-bfMasPPg.mjs";
+import { _ as GENERATED_READINESS_ROUTE, a as findMicroserviceByName, d as updateMicroservice, g as GENERATED_LIVENESS_ROUTE, h as GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE, l as subscribeToApplication, m as createC8yManifestFromNitro, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BFjK6AYb.mjs";
+import { t as writeBootstrapCredentials } from "./env-file-BrOTmVjA.mjs";
+import { n as name } from "./package-BhFLRPOb.mjs";
 import { basename, dirname, join, relative } from "node:path";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { x } from "tinyexec";
 import { join as join$1 } from "pathe";
 import { mkdir as mkdir$1, readFile as readFile$1, stat, writeFile as writeFile$1 } from "fs/promises";
@@ -11,6 +11,7 @@ import Spinnies from "spinnies";
 import { colors } from "consola/utils";
 import { mkdirSync, writeFileSync } from "fs";
 import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
 import process from "node:process";
 import evlog from "evlog/nitro/v3";
 //#region src/module/apiClient.ts
@@ -113,6 +114,7 @@ type C8ySerialize<T> = T extends void | undefined | null ? undefined : T extends
 * @param className - The class name for the generated service (e.g., "PlaygroundAPIClient")
 */
 function generateAPIClient(routes, contextPath, className) {
+	const methods = routes.map((route) => generateMethod(route)).join("\n\n");
 	return `/* eslint-disable eslint-comments/no-unlimited-disable */
 /* eslint-disable */
 /**
@@ -157,7 +159,7 @@ export class ${className} {
     return JSON.parse(text);
   }
 
-${routes.map((route) => generateMethod(route)).join("\n\n")}
+${methods}
 }`;
 }
 /**
@@ -262,6 +264,8 @@ async function buildDockerImage(nitro, c8yDir) {
 	try {
 		const result = await x("docker", [
 			"build",
+			"--platform",
+			"linux/amd64",
 			"-t",
 			imageName,
 			"-f",
@@ -370,6 +374,7 @@ function setupRuntime(nitro, manifest) {
 	nitro.logger.debug("Setting up C8Y nitro runtime");
 	const roles = manifest.roles ?? [];
 	const settingKeys = (manifest.settings ?? []).map((s) => s.key);
+	const settingsCategory = manifest.settingsCategory ?? manifest.contextPath ?? manifest.name;
 	const completeTypesDir = join$1(nitro.options.rootDir, nitro.options.typescript.generatedTypesDir ?? "node_modules/.nitro/types");
 	const typesFile = join$1(completeTypesDir, "c8y-nitro.d.ts");
 	const typesContent = `// generated by c8y-nitro
@@ -379,6 +384,7 @@ ${roles.map((role) => `    '${role}': '${role}';`).join("\n")}
   }
   type C8YTenantOptionKey = ${settingKeys.length > 0 ? `${settingKeys.map((k) => `'${k}'`).join(" | ")}` : "never"}
   type C8YTenantOptionKeysCacheConfig = Partial<Record<C8YTenantOptionKey, number>>;
+  type C8YSettingsCategory = ${settingsCategory ? `'${settingsCategory}'` : "string"};
 }
 
 declare module 'c8y-nitro/runtime' {
@@ -413,7 +419,7 @@ async function setupRuntimeConfig(nitro, options) {
 	nitro.options.runtimeConfig.c8yCredentialsCacheTTL = options.cache?.credentialsTTL ?? 600;
 	nitro.options.runtimeConfig.c8yDefaultTenantOptionsTTL = options.cache?.defaultTenantOptionsTTL ?? 600;
 	nitro.options.runtimeConfig.c8yTenantOptionsPerKeyTTL = options.cache?.tenantOptions ?? {};
-	const manifest = await createC8yManifest(nitro.options.rootDir, options.manifest, nitro.logger);
+	const manifest = await createC8yManifest(nitro.options.rootDir, nitro.options, nitro.logger);
 	nitro.options.runtimeConfig.c8ySettingsCategory = options.manifest?.settingsCategory ?? manifest.contextPath ?? manifest.name;
 }
 //#endregion
@@ -515,39 +521,156 @@ function checkProbeEndpoint(nitro, probe, probeType) {
 	}
 }
 //#endregion
+//#region src/module/manifestCache.ts
+/**
+* Directory (inside the project's `node_modules`) where c8y-nitro persists
+* local dev state such as the last-synced manifest hash. Lives in
+* `node_modules` so it is naturally gitignored and scoped per-checkout.
+*/
+const CACHE_DIR_SEGMENTS = ["node_modules", ".c8y-nitro"];
+const CACHE_FILE_NAME = "bootstrap-state.json";
+const CACHE_SCHEMA_VERSION = 1;
+function getCacheDir(rootDir) {
+	return join(rootDir, ...CACHE_DIR_SEGMENTS);
+}
+function getCacheFile(rootDir) {
+	return join(getCacheDir(rootDir), CACHE_FILE_NAME);
+}
+/**
+* Compute a hash over the manifest and the deployment target it will be synced
+* to. Folding the target in means switching tenant/baseURL invalidates the
+* cached hash even if the manifest itself is unchanged.
+*
+* @param manifest - The generated Cumulocity manifest
+* @param target - The deployment target identity
+*/
+function hashManifest(manifest, target) {
+	const payload = JSON.stringify({
+		manifest,
+		target
+	});
+	return createHash("sha256").update(payload).digest("hex");
+}
+/**
+* Read the persisted bootstrap state, or `null` when absent, unreadable, or
+* from an incompatible schema version.
+* @param rootDir - Project root directory (containing `node_modules`)
+*/
+async function readManifestCache(rootDir) {
+	try {
+		const content = await readFile(getCacheFile(rootDir), "utf-8");
+		const state = JSON.parse(content);
+		if (state.schemaVersion !== CACHE_SCHEMA_VERSION) return null;
+		return state;
+	} catch {
+		return null;
+	}
+}
+/**
+* Persist the bootstrap state for future dev restarts.
+* @param rootDir - Project root directory (containing `node_modules`)
+* @param state - The state to persist (schema version is filled in automatically)
+*/
+async function writeManifestCache(rootDir, state) {
+	await mkdir(getCacheDir(rootDir), { recursive: true });
+	const payload = {
+		schemaVersion: CACHE_SCHEMA_VERSION,
+		...state
+	};
+	await writeFile(getCacheFile(rootDir), JSON.stringify(payload, null, 2), "utf-8");
+}
+//#endregion
 //#region src/module/autoBootstrap.ts
+const BOOTSTRAP_ENV_VARS = [
+	"C8Y_BOOTSTRAP_TENANT",
+	"C8Y_BOOTSTRAP_USER",
+	"C8Y_BOOTSTRAP_PASSWORD"
+];
+const DEV_ENV_VARS = [
+	"C8Y_BASEURL",
+	"C8Y_DEVELOPMENT_TENANT",
+	"C8Y_DEVELOPMENT_USER",
+	"C8Y_DEVELOPMENT_PASSWORD"
+];
 /**
-* Automatically bootstraps the microservice to the development tenant if needed.
-* Runs silently - only logs if bootstrap was performed or if errors occur.
+* Verifies the microservice on the development tenant and keeps it in sync with
+* the local manifest, bootstrapping (or re-bootstrapping) when needed.
+*
+* Unlike a purely env-var-based check, this always verifies against the tenant
+* when development credentials are available, so it also handles:
+* - the manifest changing between dev restarts (auto-updates a placeholder), and
+* - the application being deleted on the tenant while stale bootstrap env vars
+*   still linger locally (re-creates it).
+*
+* A previously *deployed* microservice (one with an active version) is never
+* overwritten automatically - we only warn about the drift.
+*
+* Runs silently unless a bootstrap/sync was performed or an error occurs.
 * @param nitro - Nitro instance
 */
 async function autoBootstrap(nitro) {
 	try {
-		if ([
-			"C8Y_BOOTSTRAP_TENANT",
-			"C8Y_BOOTSTRAP_USER",
-			"C8Y_BOOTSTRAP_PASSWORD"
-		].every((v) => process.env[v])) return;
-		if ([
-			"C8Y_BASEURL",
-			"C8Y_DEVELOPMENT_TENANT",
-			"C8Y_DEVELOPMENT_USER",
-			"C8Y_DEVELOPMENT_PASSWORD"
-		].filter((v) => !process.env[v]).length > 0) return;
+		const rootDir = nitro.options.rootDir;
+		if (DEV_ENV_VARS.filter((v) => !process.env[v]).length > 0) return;
 		const baseUrl = process.env.C8Y_BASEURL.endsWith("/") ? process.env.C8Y_BASEURL.slice(0, -1) : process.env.C8Y_BASEURL;
-		const authHeader = createBasicAuthHeader(process.env.C8Y_DEVELOPMENT_TENANT, process.env.C8Y_DEVELOPMENT_USER, process.env.C8Y_DEVELOPMENT_PASSWORD);
-		const manifest = await createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
+		const developmentTenant = process.env.C8Y_DEVELOPMENT_TENANT;
+		const authHeader = createBasicAuthHeader(developmentTenant, process.env.C8Y_DEVELOPMENT_USER, process.env.C8Y_DEVELOPMENT_PASSWORD);
+		const manifest = await createC8yManifest(rootDir, nitro.options, nitro.logger);
+		const target = {
+			baseUrl,
+			developmentTenant,
+			name: manifest.name
+		};
+		const currentHash = hashManifest(manifest, target);
 		const existingApp = await findMicroserviceByName(baseUrl, manifest.name, authHeader);
-		let appId;
-		if (existingApp) {
-			appId = existingApp.id;
-			nitro.logger.debug(`Microservice "${manifest.name}" already exists (ID: ${appId}), retrieving bootstrap credentials...`);
-		} else {
-			appId = (await createMicroservice(baseUrl, manifest, authHeader)).id;
-			nitro.logger.debug(`Microservice "${manifest.name}" created (ID: ${appId})`);
+		if (!existingApp) {
+			const createdApp = await createMicroservice(baseUrl, manifest, authHeader);
+			nitro.logger.debug(`Microservice "${manifest.name}" created (ID: ${createdApp.id})`);
+			await finalizeBootstrap(nitro, {
+				baseUrl,
+				developmentTenant,
+				appId: createdApp.id,
+				authHeader,
+				target,
+				manifestHash: currentHash,
+				forceCredentials: true
+			});
+			nitro.logger.success(`Auto-bootstrap complete! Microservice "${manifest.name}" created on tenant.`);
+			return;
+		}
+		const appId = existingApp.id;
+		const isRealService = Boolean(existingApp.activeVersionId);
+		const cache = await readManifestCache(rootDir);
+		if (!cache || cache.manifestHash !== currentHash || cache.appId !== appId) if (isRealService) nitro.logger.warn(`Local manifest for "${manifest.name}" differs from the deployed microservice on the development tenant. The running service was left untouched. Redeploy or run \`npx c8y-nitro bootstrap\` to update it explicitly.`);
+		else {
+			await updateMicroservice(baseUrl, appId, manifest, authHeader);
+			nitro.logger.success(`Auto-bootstrap: updated microservice "${manifest.name}" with changed manifest.`);
 		}
-		await subscribeToApplication(baseUrl, process.env.C8Y_DEVELOPMENT_TENANT, appId, authHeader);
-		const credentials = await getBootstrapCredentials(baseUrl, appId, authHeader);
+		const hasBootstrapCreds = BOOTSTRAP_ENV_VARS.every((v) => process.env[v]);
+		const appChanged = cache?.appId !== appId;
+		await finalizeBootstrap(nitro, {
+			baseUrl,
+			developmentTenant,
+			appId,
+			authHeader,
+			target,
+			manifestHash: currentHash,
+			forceCredentials: !hasBootstrapCreds || appChanged
+		});
+	} catch (error) {
+		nitro.logger.warn("Auto-bootstrap failed:", error instanceof Error ? error.message : String(error));
+	}
+}
+/**
+* Subscribe the tenant, optionally (re)write bootstrap credentials, and persist
+* the synced state to the local cache.
+* @param nitro
+* @param opts
+*/
+async function finalizeBootstrap(nitro, opts) {
+	await subscribeToApplication(opts.baseUrl, opts.developmentTenant, opts.appId, opts.authHeader);
+	if (opts.forceCredentials) {
+		const credentials = await getBootstrapCredentials(opts.baseUrl, opts.appId, opts.authHeader);
 		const envFileName = await writeBootstrapCredentials(nitro.options.rootDir, {
 			C8Y_BOOTSTRAP_TENANT: credentials.tenant,
 			C8Y_BOOTSTRAP_USER: credentials.name,
@@ -556,10 +679,13 @@ async function autoBootstrap(nitro) {
 		process.env.C8Y_BOOTSTRAP_TENANT = credentials.tenant;
 		process.env.C8Y_BOOTSTRAP_USER = credentials.name;
 		process.env.C8Y_BOOTSTRAP_PASSWORD = credentials.password;
-		nitro.logger.success(`Auto-bootstrap complete! Bootstrap credentials written to ${envFileName}`);
-	} catch (error) {
-		nitro.logger.warn("Auto-bootstrap failed:", error instanceof Error ? error.message : String(error));
+		nitro.logger.debug(`Bootstrap credentials written to ${envFileName}`);
 	}
+	await writeManifestCache(nitro.options.rootDir, {
+		manifestHash: opts.manifestHash,
+		target: opts.target,
+		appId: opts.appId
+	});
 }
 //#endregion
 //#region src/index.ts
@@ -575,7 +701,8 @@ function c8y() {
 			nitro.options.noExternals = nitro.options.noExternals === true ? true : [
 				...Array.isArray(nitro.options.noExternals) ? nitro.options.noExternals : [],
 				name,
-				"@c8y/client"
+				"@c8y/client",
+				"tslib"
 			];
 			nitro.options.rolldownConfig = {
 				...nitro.options.rolldownConfig,
@@ -597,12 +724,13 @@ function c8y() {
 				exclude: [manifest.livenessProbe?.httpGet?.path, manifest.readinessProbe?.httpGet?.path].filter(Boolean)
 			});
 			await setupEvlog(nitro);
-			if (!options.skipBootstrap) await autoBootstrap(nitro);
+			if (nitro.options.preset === "nitro-dev" && !options.skipBootstrap) await autoBootstrap(nitro);
 			await setupRuntimeConfig(nitro, options);
 			setupRuntime(nitro, manifest);
 			nitro.hooks.hook("dev:reload", async () => {
 				manifest = await createC8yManifestFromNitro(nitro);
 				setupRuntime(nitro, manifest);
+				if (!options.skipBootstrap) await autoBootstrap(nitro);
 				if (options.apiClient) {
 					nitro.logger.debug("Generating C8Y API client");
 					await writeAPIClient(nitro, options);

package/dist/{options-BkWL1FOa.mjs → options-B7_yb_wr.mjs}

@@ -1,5 +1,5 @@
-import { c as getTenantOptionsByCategory, f as upsertTenantOption, i as deleteTenantOption, n as createBasicAuthHeader, p as createC8yManifest, s as getTenantOption } from "./c8y-api-BgTNTqHd.mjs";
-import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
+import { c as getTenantOptionsByCategory, f as upsertTenantOption, i as deleteTenantOption, n as createBasicAuthHeader, p as createC8yManifest, s as getTenantOption } from "./c8y-api-BFjK6AYb.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/options.ts
@@ -11,11 +11,11 @@ var options_default = defineCommand({
 	args: {},
 	async run() {
 		consola.info("Loading configuration...");
-		const { env, c8yOptions, configDir } = await loadC8yConfig();
+		const { env, nitroConfig, configDir } = await loadC8yConfig();
 		consola.info("Validating environment variables...");
 		const envVars = validateBootstrapEnv(env);
 		consola.info("Loading manifest...");
-		const manifest = await createC8yManifest(configDir, c8yOptions?.manifest);
+		const manifest = await createC8yManifest(configDir, nitroConfig);
 		const category = manifest.settingsCategory || manifest.contextPath || manifest.name;
 		if (!manifest.settings || manifest.settings.length === 0) throw new Error("No settings defined in manifest. Add settings to your c8y.manifest configuration.");
 		consola.success(`Using category: ${category}`);

package/dist/{package-bfMasPPg.mjs → package-BhFLRPOb.mjs}

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "c8y-nitro";
-var version = "0.5.0";
+var version = "0.7.0";
 var description = "Lightning fast Cumulocity IoT microservice development powered by Nitro";
 //#endregion
 export { name as n, version as r, description as t };

package/dist/{roles-CoBPqvDv.mjs → roles-B58Fguop.mjs}

@@ -1,5 +1,5 @@
-import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BgTNTqHd.mjs";
-import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
+import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BFjK6AYb.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
 import { defineCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/roles.ts
@@ -11,11 +11,11 @@ var roles_default = defineCommand({
 	args: {},
 	async run() {
 		consola.info("Loading configuration...");
-		const { env, c8yOptions, configDir } = await loadC8yConfig();
+		const { env, nitroConfig, configDir } = await loadC8yConfig();
 		consola.info("Validating environment variables...");
 		const envVars = validateBootstrapEnv(env);
 		consola.info("Building manifest...");
-		const manifest = await createC8yManifest(configDir, c8yOptions?.manifest);
+		const manifest = await createC8yManifest(configDir, nitroConfig);
 		const authHeader = createBasicAuthHeader(envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, envVars.C8Y_DEVELOPMENT_PASSWORD);
 		if (manifest.roles && manifest.roles.length > 0) {
 			const rolesToAssign = await consola.prompt("Select roles to assign to your user (unselected roles will be removed):", {