c8y-nitro 0.6.0 → 0.7.1

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-BbRS1-Ls.mjs";
-import { t as writeBootstrapCredentials } from "./env-file-B0BK-uZW.mjs";
-import { n as name } from "./package-DsLC9Mo3.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-D5xRshsx.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}
 }`;
 }
 /**
@@ -218,14 +220,15 @@ async function writeAPIClient(nitro, options) {
 /**
 * Generate the Dockerfile content for a Nitro build
 * @param outputDirName - Name of the output directory (e.g., '.output')
+* @param options - Dockerfile customization (base image, extra instructions)
 * @returns Dockerfile content as a string
 */
-function getDockerfileContent(outputDirName) {
-	return `FROM node:24-slim AS runtime
+function getDockerfileContent(outputDirName, options = {}) {
+	return `FROM ${options.baseImage ?? "node:24-slim"} AS runtime
 
 WORKDIR /app
 
-# Copy the Nitro build output
+${options.extraInstructions?.length ? `${options.extraInstructions.join("\n")}\n\n` : ""}# Copy the Nitro build output
 COPY ${outputDirName}/ ${outputDirName}/
 
 ENV NODE_ENV=production
@@ -246,12 +249,12 @@ async function checkDockerInstalled() {
 		return false;
 	}
 }
-async function writeDockerfile(outputDir) {
+async function writeDockerfile(outputDir, options) {
 	const outputDirName = basename(outputDir);
 	const c8yDir = join(outputDir, "../.c8y");
 	const dockerfilePath = join(c8yDir, "Dockerfile");
 	await mkdir(c8yDir, { recursive: true });
-	await writeFile(dockerfilePath, getDockerfileContent(outputDirName), "utf-8");
+	await writeFile(dockerfilePath, getDockerfileContent(outputDirName, options), "utf-8");
 	return c8yDir;
 }
 async function buildDockerImage(nitro, c8yDir) {
@@ -262,6 +265,8 @@ async function buildDockerImage(nitro, c8yDir) {
 	try {
 		const result = await x("docker", [
 			"build",
+			"--platform",
+			"linux/amd64",
 			"-t",
 			imageName,
 			"-f",
@@ -298,12 +303,13 @@ async function saveDockerImageToTar(nitro, c8yDir, imageName) {
 /**
 * Create a Docker image from the Nitro build output
 * @param nitro Nitro instance
+* @param options Dockerfile customization (base image, extra instructions)
 * @returns Path to the saved Docker image tar file
 */
-async function createDockerImage(nitro) {
+async function createDockerImage(nitro, options = {}) {
 	if (!await checkDockerInstalled()) throw new Error("Docker is not installed or not available in PATH. Please install Docker to build images.");
 	nitro.logger.debug("Creating Docker image...");
-	const c8yDir = await writeDockerfile(nitro.options.output.dir);
+	const c8yDir = await writeDockerfile(nitro.options.output.dir, options);
 	const imageTarPath = await saveDockerImageToTar(nitro, c8yDir, await buildDockerImage(nitro, c8yDir));
 	nitro.logger.debug("Docker image creation complete.");
 	return imageTarPath;
@@ -333,12 +339,12 @@ function formatBytes(bytes) {
 function resolveZipOutputPath(rootDir, options, manifest) {
 	return join$1(join$1(rootDir, options.outputDir ?? "./"), typeof options.name === "function" ? options.name(manifest.name, manifest.version) : options.name ?? `${manifest.name}-${manifest.version}.zip`);
 }
-async function createC8yZip(nitro, options = {}) {
+async function createC8yZip(nitro, options = {}, dockerOptions = {}) {
 	const startTime = Date.now();
 	const spinnerName = "c8y-zip";
 	spinnies.add(spinnerName, { text: "Creating Dockerfile..." });
 	spinnies.update(spinnerName, { text: "Building Docker image..." });
-	const imageTarPath = await createDockerImage(nitro);
+	const imageTarPath = await createDockerImage(nitro, dockerOptions);
 	spinnies.update(spinnerName, { text: "Creating manifest..." });
 	const manifest = await createC8yManifestFromNitro(nitro);
 	spinnies.update(spinnerName, { text: "Reading image.tar..." });
@@ -370,6 +376,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 +386,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,8 +421,11 @@ 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;
+	const excludeInternalRoutes = options.openapi?.excludeInternalRoutes ?? true;
+	const probePaths = [options.manifest?.livenessProbe?.httpGet?.path, options.manifest?.readinessProbe?.httpGet?.path].filter((path) => Boolean(path));
+	nitro.options.runtimeConfig.c8yOpenApiExcludeRoutes = [...excludeInternalRoutes ? ["/_", ...probePaths] : [], ...options.openapi?.excludeRoutes ?? []];
 }
 //#endregion
 //#region src/module/registerRuntime.ts
@@ -454,6 +465,15 @@ function registerRuntime(nitro, options = {}) {
 		handler,
 		middleware: true
 	})));
+	if (Boolean(nitro.options.experimental?.openAPI && (isNitroDev || nitro.options.openAPI?.production))) if (!isNitroDev && nitro.options.openAPI?.production === "prerender") nitro.logger.warn("c8y-nitro cannot transform a prerendered OpenAPI document (internal routes stay listed and the server URL is baked in at build time). Use `openAPI: { production: true }` to serve the document at runtime instead.");
+	else {
+		nitro.options.handlers.push({
+			route: "/**",
+			handler: join$1(thisFilePath, "./runtime/handlers/openapi"),
+			middleware: true
+		});
+		nitro.logger.debug(`Registered OpenAPI transform middleware for ${nitro.options.openAPI?.route || "/_openapi.json"}`);
+	}
 	/**
 	* Handlers (can't be auto scanned as they need methods etc)
 	*/
@@ -515,39 +535,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 +693,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 +715,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 +738,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);
@@ -619,7 +761,7 @@ function c8y() {
 				}
 			});
 			nitro.hooks.hook("close", async () => {
-				if (nitro.options.preset !== "nitro-dev") await createC8yZip(nitro, options.zip);
+				if (nitro.options.preset !== "nitro-dev") await createC8yZip(nitro, options.zip, options.docker);
 			});
 		}
 	};

package/dist/logging-BUYT8Z2V.mjs

@@ -0,0 +1,57 @@
+import { createError } from "evlog";
+import "evlog/nitro/v3";
+//#region src/utils/logging.ts
+/**
+* Create a structured error for a Cumulocity microservice. Always prefer this
+* over Nitro/h3's built-in `createError`: the returned error is captured in the
+* wide log event **and** serialized into the JSON response under a `data` key.
+*
+* ## What the caller sees vs what stays on the server
+*
+* Every field **except `internal`** is sent to the client in the HTTP response.
+* `internal` is stripped from the response and only ever appears in your logs.
+*
+* | Field      | Sent to client? | Purpose                                                       |
+* | ---------- | :-------------: | ------------------------------------------------------------- |
+* | `message`  |       yes       | Short, safe summary of what went wrong.                       |
+* | `status`   |       yes       | HTTP status code (default `500`).                             |
+* | `code`     |       yes       | Stable machine-readable id (e.g. `'PAYMENT_DECLINED'`).       |
+* | `why`      |       yes       | Human-readable cause — safe to expose, no secrets.            |
+* | `fix`      |       yes       | What the caller can do about it.                              |
+* | `link`     |       yes       | Docs URL with more detail.                                    |
+* | `cause`    |  no (logged)    | The original `Error` you caught.                              |
+* | `internal` |  no (logged)    | Backend-only diagnostics — never reaches the client.          |
+*
+* ## Do NOT leak internal system errors
+*
+* Put anything sensitive or diagnostic (raw Cumulocity core responses, DB
+* errors, tokens, tenant internals) in `internal`, **not** in `message`/`why`.
+* `internal` is logged for debugging but never serialized to the response.
+*
+* @example
+* // User-facing error — every field here is visible to the caller:
+* throw createError({
+*   code: 'PAYMENT_DECLINED',
+*   message: 'Payment failed',
+*   status: 402,
+*   why: 'Card declined by issuer',
+*   fix: 'Try a different payment method',
+*   link: 'https://docs.example.com/payments/declined',
+* })
+*
+* @example
+* // Wrapping an upstream failure — keep the raw payload server-side only:
+* catch (cause) {
+*   throw createError({
+*     status: 502,
+*     message: 'Upstream request failed', // safe, generic — what the caller sees
+*     cause: cause as Error,
+*     internal: { upstreamStatus: cause?.res?.status, upstreamBody: cause?.data },
+*   })
+* }
+*
+* @see https://www.evlog.dev
+*/
+const createError$1 = createError;
+//#endregion
+export { createError$1 as t };

package/dist/{options-Web5UyIU.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-BbRS1-Ls.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-DsLC9Mo3.mjs → package-D5xRshsx.mjs}

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "c8y-nitro";
-var version = "0.6.0";
+var version = "0.7.1";
 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-D7rpbxPp.mjs → roles-B58Fguop.mjs}

@@ -1,5 +1,5 @@
-import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BbRS1-Ls.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):", {