c8y-nitro 0.6.0 → 0.7.0

package/dist/{bootstrap-DUDpmXcU.mjs → bootstrap-ObaEF7rN.mjs}

@@ -1,6 +1,6 @@
-import { a as findMicroserviceByName, d as updateMicroservice, l as subscribeToApplication, 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 validateBootstrapEnv, t as loadC8yConfig } from "./config-BRnvtthI.mjs";
+import { a as findMicroserviceByName, d as updateMicroservice, l as subscribeToApplication, 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 validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
 import { defineCommand, runCommand } from "citty";
 import { consola } from "consola";
 //#region src/cli/commands/bootstrap.ts
@@ -12,11 +12,11 @@ var bootstrap_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);
 		consola.success(`Manifest created for: ${manifest.name} v${manifest.version}`);
 		const authHeader = createBasicAuthHeader(envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, envVars.C8Y_DEVELOPMENT_PASSWORD);
 		consola.info(`Checking if microservice "${manifest.name}" exists...`);
@@ -52,7 +52,7 @@ var bootstrap_default = defineCommand({
 		});
 		consola.success(`Bootstrap credentials written to ${envFileName}`);
 		if (manifest.roles && manifest.roles.length > 0) {
-			if (await consola.prompt("Do you want to manage microservice roles for your development user?", { type: "confirm" })) await runCommand(await import("./roles-D7rpbxPp.mjs").then((r) => r.default), { rawArgs: [] });
+			if (await consola.prompt("Do you want to manage microservice roles for your development user?", { type: "confirm" })) await runCommand(await import("./roles-B58Fguop.mjs").then((r) => r.default), { rawArgs: [] });
 		}
 		consola.success("Bootstrap complete!");
 	}

package/dist/{c8y-api-BbRS1-Ls.mjs → c8y-api-BFjK6AYb.mjs}

@@ -6,8 +6,29 @@ const GENERATED_READINESS_ROUTE = "/_c8y_nitro/readiness";
 const GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE = "/_c8y_nitro/invalidate-tenant-options";
 //#endregion
 //#region src/module/manifest.ts
+const DEFAULT_OPENAPI_ROUTE = "/_openapi.json";
 const ROLE_OPTION_MANAGEMENT_READ = "ROLE_OPTION_MANAGEMENT_READ";
-const ROLE_OPTION_MANAGEMENT_ADMIN = "ROLE_OPTION_MANAGEMENT_ADMIN";
+/**
+* Decide whether Nitro will expose an OpenAPI spec in the deployed build,
+* and if so return the configured route (with leading slash).
+* Returns null when OpenAPI is not enabled for production.
+* @param config - Nitro config (or options) to inspect
+*/
+function resolveNitroOpenApiRoute(config) {
+	if (!config.experimental?.openAPI) return null;
+	if (!config.openAPI?.production) return null;
+	return config.openAPI?.route || DEFAULT_OPENAPI_ROUTE;
+}
+/**
+* Pull the parts of a Nitro config that feed manifest generation.
+* @param config - Nitro config (or options) loaded from disk or from a Nitro instance
+*/
+function extractManifestInputs(config) {
+	return {
+		options: config.c8y?.manifest ?? {},
+		openApiSpec: resolveNitroOpenApiRoute(config) ?? void 0
+	};
+}
 function validateManifestSettings(options) {
 	const invalidSettings = options.settings?.filter((setting) => typeof setting.defaultValue !== "string" || setting.defaultValue.length === 0) ?? [];
 	if (invalidSettings.length === 0) return;
@@ -39,13 +60,18 @@ async function readPackageJsonFieldsForManifest(rootDir, logger) {
 	};
 }
 /**
-* Creates a Cumulocity manifest from rootDir and options.
-* Standalone function that can be used by CLI or module.
-* @param rootDir - Directory containing package.json
-* @param options - Manifest options
+* Create a Cumulocity manifest from a project root and its Nitro config.
+* Reads `package.json` for identity fields, takes user manifest options from
+* `nitroConfig.c8y.manifest`, and auto-injects `openApiSpec` when Nitro
+* OpenAPI is enabled for production.
+*
+* Used by both the Nitro module and the CLI commands.
+* @param rootDir - Directory containing the project's `package.json`
+* @param nitroConfig - Nitro config (or options) for this project
 * @param logger - Optional logger for debug output
 */
-async function createC8yManifest(rootDir, options = {}, logger) {
+async function createC8yManifest(rootDir, nitroConfig = {}, logger) {
+	const { options, openApiSpec } = extractManifestInputs(nitroConfig);
 	validateManifestSettings(options);
 	const { name, version, provider, ...restManifestFields } = await readPackageJsonFieldsForManifest(rootDir, logger);
 	const probeFields = {};
@@ -59,7 +85,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 	};
 	const key = `${name}-key`;
 	let requiredRoles = options.requiredRoles ? [...options.requiredRoles] : void 0;
-	if (options.settings && options.settings.length > 0 && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_READ) && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_ADMIN)) {
+	if (options.settings && options.settings.length > 0 && !requiredRoles?.includes(ROLE_OPTION_MANAGEMENT_READ)) {
 		requiredRoles = [...requiredRoles ?? [], ROLE_OPTION_MANAGEMENT_READ];
 		logger?.debug(`Auto-added ${ROLE_OPTION_MANAGEMENT_READ} to requiredRoles because manifest.settings are defined`);
 	}
@@ -68,6 +94,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 		...probeFields,
 		...options,
 		...requiredRoles !== void 0 ? { requiredRoles } : {},
+		...openApiSpec ? { openApiSpec } : {},
 		provider,
 		name,
 		version,
@@ -75,6 +102,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 		key,
 		type: "MICROSERVICE"
 	};
+	if (openApiSpec) logger?.debug(`Auto-added openApiSpec="${openApiSpec}" to manifest (Nitro OpenAPI is enabled)`);
 	logger?.debug(`Created Cumulocity manifest: ${JSON.stringify(manifest, null, 2)}`);
 	return manifest;
 }
@@ -84,7 +112,7 @@ async function createC8yManifest(rootDir, options = {}, logger) {
 * @param nitro - The Nitro instance
 */
 async function createC8yManifestFromNitro(nitro) {
-	return createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
+	return createC8yManifest(nitro.options.rootDir, nitro.options, nitro.logger);
 }
 //#endregion
 //#region src/cli/utils/c8y-api.ts

package/dist/cli/index.mjs

@@ -1,4 +1,4 @@
-import { n as name, r as version, t as description } from "../package-DsLC9Mo3.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-DUDpmXcU.mjs").then((r) => r.default),
-		roles: () => import("../roles-D7rpbxPp.mjs").then((r) => r.default),
-		options: () => import("../options-Web5UyIU.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-9FO7rTIR.d.mts → credentials-eKnJ7m9Y.d.mts}

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

package/dist/{index-uOwpI6rD.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 {
@@ -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,7 +1,6 @@
-import { n as C8yNitroModuleOptions } from "./index-uOwpI6rD.mjs";
-import { t as TenantCredentials } from "./credentials-9FO7rTIR.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 {

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-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-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-BhFLRPOb.mjs}

@@ -1,6 +1,6 @@
 //#region package.json
 var name = "c8y-nitro";
-var version = "0.6.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-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):", {