c8y-nitro 0.7.0 → 0.7.2

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { n as C8yNitroModuleOptions } from "./index-ByDSMEvU.mjs";
+import { n as C8yNitroModuleOptions } from "./index-vu4xaFkz.mjs";
 import { t as TenantCredentials } from "./credentials-eKnJ7m9Y.mjs";
 import { NitroModule } from "nitro/types";
 //#region src/index.d.ts

package/dist/index.mjs

@@ -1,8 +1,8 @@
-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 { _ as GENERATED_READINESS_ROUTE, g as GENERATED_LIVENESS_ROUTE, h as GENERATED_INVALIDATE_TENANT_OPTIONS_ROUTE, m as createC8yManifestFromNitro, p as createC8yManifest } from "./c8y-api-DscUs-Kd.mjs";
+import { t as autoBootstrap } from "./autoBootstrap-Drk7ltXK.mjs";
+import { n as name } from "./package-BHOzdhHp.mjs";
 import { basename, dirname, join, relative } from "node:path";
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, 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,8 +11,6 @@ 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
 /**
@@ -220,14 +218,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
@@ -248,12 +247,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) {
@@ -302,12 +301,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;
@@ -337,12 +337,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..." });
@@ -421,6 +421,9 @@ async function setupRuntimeConfig(nitro, options) {
 	nitro.options.runtimeConfig.c8yTenantOptionsPerKeyTTL = options.cache?.tenantOptions ?? {};
 	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
@@ -461,6 +464,31 @@ function registerRuntime(nitro, options = {}) {
 		middleware: true
 	})));
 	/**
+	* Request URL rewrite middleware (always on in production builds).
+	* Rewrites `event.url` to the public tenant endpoint so handlers that build
+	* absolute URLs from the request don't leak internal cluster URLs.
+	* Registered after the scanned middlewares (which observe the original
+	* cluster-local URL) and before the OpenAPI transform, which reuses the
+	* resolved tenant domain from its cache.
+	*/
+	if (!isNitroDev) {
+		nitro.options.handlers.push({
+			route: "/**",
+			handler: join$1(thisFilePath, "./runtime/handlers/rewriteRequestUrl"),
+			middleware: true
+		});
+		nitro.logger.debug("Registered public request URL rewrite middleware");
+	}
+	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)
 	*/
 	const handlers = [];
@@ -521,173 +549,6 @@ 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"
-];
-/**
-* 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 {
-		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 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);
-		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.`);
-		}
-		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,
-			C8Y_BOOTSTRAP_PASSWORD: credentials.password
-		});
-		process.env.C8Y_BOOTSTRAP_TENANT = credentials.tenant;
-		process.env.C8Y_BOOTSTRAP_USER = credentials.name;
-		process.env.C8Y_BOOTSTRAP_PASSWORD = credentials.password;
-		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
 function c8y() {
 	return {
@@ -747,7 +608,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-CmLpZ3Qf.mjs

@@ -0,0 +1,179 @@
+import { c as getTenantOptionsByCategory, f as upsertTenantOption, i as deleteTenantOption, n as createBasicAuthHeader, p as createC8yManifest, s as getCurrentApplicationSettings } from "./c8y-api-DscUs-Kd.mjs";
+import { n as readBootstrapCredentialsFromEnv, r as syncBootstrappedMicroservice } from "./autoBootstrap-Drk7ltXK.mjs";
+import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+import { createInterface } from "node:readline/promises";
+//#region src/cli/commands/options.ts
+var options_default = defineCommand({
+	meta: {
+		name: "options",
+		description: "Manage tenant options on the development tenant"
+	},
+	args: {},
+	async run() {
+		consola.info("Loading configuration...");
+		const { env, nitroConfig, configDir } = await loadC8yConfig();
+		consola.info("Validating environment variables...");
+		const envVars = validateBootstrapEnv(env);
+		consola.info("Loading 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}`);
+		const devAuthHeader = createBasicAuthHeader(envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, envVars.C8Y_DEVELOPMENT_PASSWORD);
+		let bootstrapCredentials;
+		try {
+			consola.info("Checking microservice on development tenant...");
+			bootstrapCredentials = await syncBootstrappedMicroservice({
+				rootDir: configDir,
+				baseUrl: envVars.C8Y_BASEURL,
+				developmentTenant: envVars.C8Y_DEVELOPMENT_TENANT,
+				authHeader: devAuthHeader,
+				manifest,
+				logger: consola,
+				env
+			});
+		} catch (error) {
+			consola.warn(`Could not sync microservice with the development tenant: ${error instanceof Error ? error.message : String(error)}`);
+			bootstrapCredentials = readBootstrapCredentialsFromEnv(env);
+		}
+		const bootstrapAuthHeader = bootstrapCredentials ? createBasicAuthHeader(bootstrapCredentials.tenant, bootstrapCredentials.name, bootstrapCredentials.password) : void 0;
+		if (!bootstrapAuthHeader) consola.warn("No bootstrap credentials available - reading with the development user. Encrypted credentials.* options cannot be decrypted.");
+		consola.info("Fetching current tenant options...");
+		const currentOptions = await getTenantOptionsByCategory(envVars.C8Y_BASEURL, category, devAuthHeader);
+		if (bootstrapAuthHeader) try {
+			const decryptedSettings = await getCurrentApplicationSettings(envVars.C8Y_BASEURL, bootstrapAuthHeader);
+			for (const [key, value] of Object.entries(decryptedSettings)) if (currentOptions[key] !== void 0 || key.startsWith("credentials.")) currentOptions[key] = value;
+		} catch (error) {
+			consola.warn(`Could not read decrypted settings with the bootstrap user: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const availableKeys = manifest.settings.map((s) => s.key);
+		const setManifestKeys = availableKeys.filter((k) => currentOptions[k] !== void 0);
+		consola.success(`Found ${Object.keys(currentOptions).length} options set on tenant (${setManifestKeys.length} of ${availableKeys.length} manifest settings)`);
+		const ctx = {
+			baseUrl: envVars.C8Y_BASEURL,
+			category,
+			devAuthHeader,
+			bootstrapAuthHeader,
+			availableKeys,
+			currentOptions
+		};
+		const action = await consola.prompt("What do you want to do?", {
+			type: "select",
+			options: [
+				{
+					label: "Read option value",
+					value: "read"
+				},
+				{
+					label: "Update/Create option",
+					value: "update"
+				},
+				{
+					label: "Delete option(s)",
+					value: "delete"
+				}
+			]
+		});
+		if (action === "read") await handleRead(ctx);
+		else if (action === "update") await handleUpdate(ctx);
+		else if (action === "delete") await handleDelete(ctx);
+	}
+});
+/**
+* Handle reading options: prints all options at once (decrypted where
+* possible), then - after the user confirms with Enter - rewrites the output
+* in place with `credentials.*` values masked, so secrets don't linger in the
+* terminal scrollback.
+* @param ctx - The shared options context
+*/
+async function handleRead(ctx) {
+	const { bootstrapAuthHeader, availableKeys, currentOptions } = ctx;
+	if (!bootstrapAuthHeader && availableKeys.some((k) => k.startsWith("credentials."))) consola.warn("Encrypted credentials.* options cannot be read in decrypted form without bootstrap credentials. Run `npx c8y-nitro bootstrap` first.");
+	const keys = [.../* @__PURE__ */ new Set([...availableKeys, ...Object.keys(currentOptions)])];
+	const padWidth = Math.max(...keys.map((k) => k.length));
+	const renderLine = (key, maskCredentials) => {
+		const value = currentOptions[key];
+		const shownValue = value === void 0 ? "(not set)" : maskCredentials && key.startsWith("credentials.") ? "****" : value;
+		const suffix = availableKeys.includes(key) ? "" : " (not in manifest)";
+		return `  ${key.padEnd(padWidth)} = ${shownValue}${suffix}`;
+	};
+	const revealedLines = keys.map((key) => renderLine(key, false));
+	process.stdout.write(`${revealedLines.join("\n")}\n`);
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	await rl.question("Press <Enter> to hide credential values...");
+	rl.close();
+	if (process.stdout.isTTY) {
+		const columns = process.stdout.columns || 80;
+		const rowsFor = (line) => Math.max(1, Math.ceil(line.length / columns));
+		const rowsToErase = revealedLines.reduce((rows, line) => rows + rowsFor(line), 1);
+		process.stdout.write(`\x1B[${rowsToErase}A\x1B[0J`);
+		process.stdout.write(`${keys.map((key) => renderLine(key, true)).join("\n")}\n`);
+	}
+}
+/**
+* Handle updating options (with loop for multiple updates)
+* @param ctx - The shared options context
+*/
+async function handleUpdate(ctx) {
+	const { baseUrl, category, devAuthHeader, bootstrapAuthHeader, availableKeys, currentOptions } = ctx;
+	let continueUpdating = true;
+	while (continueUpdating) {
+		const key = await consola.prompt("Select option to update:", {
+			type: "select",
+			options: availableKeys.map((k) => ({
+				label: currentOptions[k] !== void 0 ? `${k} (current: ${currentOptions[k]})` : k.startsWith("credentials.") && !bootstrapAuthHeader ? `${k} (current: unknown)` : `${k} (not set)`,
+				value: k
+			})),
+			cancel: "reject"
+		});
+		const currentValue = currentOptions[key];
+		const newValue = await consola.prompt("Enter new value:", {
+			type: "text",
+			default: currentValue,
+			cancel: "reject"
+		});
+		consola.info(`Updating option: ${key}`);
+		await upsertTenantOption(baseUrl, category, key, newValue, devAuthHeader);
+		currentOptions[key] = newValue;
+		consola.success(`Option '${key}' updated successfully`);
+		if (!await consola.prompt("Update another option?", {
+			type: "confirm",
+			initial: false,
+			cancel: "reject"
+		})) continueUpdating = false;
+	}
+}
+/**
+* Handle deleting multiple options
+* @param ctx - The shared options context
+*/
+async function handleDelete(ctx) {
+	const { baseUrl, category, devAuthHeader, bootstrapAuthHeader, availableKeys, currentOptions } = ctx;
+	const allKeys = bootstrapAuthHeader ? availableKeys.filter((k) => currentOptions[k] !== void 0) : [...availableKeys.filter((k) => !k.startsWith("credentials.") && currentOptions[k] !== void 0), ...availableKeys.filter((k) => k.startsWith("credentials."))];
+	if (allKeys.length === 0) {
+		consola.warn("No options are currently set");
+		return;
+	}
+	const keysToDelete = await consola.prompt("Select option(s) to delete:", {
+		type: "multiselect",
+		options: allKeys,
+		required: true,
+		cancel: "reject"
+	});
+	consola.info(`Deleting ${keysToDelete.length} option(s)...`);
+	for (const key of keysToDelete) {
+		consola.info(`Deleting option: ${key}`);
+		await deleteTenantOption(baseUrl, category, key, devAuthHeader);
+		delete currentOptions[key];
+		consola.success(`✓ Deleted: ${key}`);
+	}
+	consola.success("Delete operation completed");
+}
+//#endregion
+export { options_default as default };

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

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

@@ -1,4 +1,4 @@
-import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-BFjK6AYb.mjs";
+import { n as createBasicAuthHeader, p as createC8yManifest, t as assignUserRole, u as unassignUserRole } from "./c8y-api-DscUs-Kd.mjs";
 import { n as validateBootstrapEnv, t as loadC8yConfig } from "./config-BVQHqlgV.mjs";
 import { defineCommand } from "citty";
 import { consola } from "consola";