c8y-nitro 0.3.0 → 0.4.0

package/dist/index.mjs

@@ -1,14 +1,546 @@
-import { createC8yManifestFromNitro } from "./module/manifest.mjs";
-import { writeAPIClient } from "./module/apiClient.mjs";
-import { createC8yZip } from "./module/c8yzip.mjs";
-import { setupRuntime } from "./module/runtime.mjs";
-import { setupRuntimeConfig } from "./module/runtimeConfig.mjs";
-import { registerRuntime } from "./module/register.mjs";
-import { checkProbes } from "./module/probeCheck.mjs";
-import { autoBootstrap } from "./module/autoBootstrap.mjs";
-import { name } from "./package.mjs";
+import { a as findMicroserviceByName, g as GENERATED_READINESS_ROUTE, h as GENERATED_LIVENESS_ROUTE, l as subscribeToApplication, m as createC8yManifestFromNitro, n as createBasicAuthHeader, o as getBootstrapCredentials, p as createC8yManifest, r as createMicroservice } from "./c8y-api-BBSKRwKs.mjs";
+import { t as writeBootstrapCredentials } from "./env-file-B0BK-uZW.mjs";
+import { n as name } from "./package-BAjMvZYS.mjs";
+import { basename, dirname, join, relative } from "node:path";
+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";
+import JSZip from "jszip";
+import Spinnies from "spinnies";
+import { colors } from "consola/utils";
+import { mkdirSync, writeFileSync } from "fs";
+import { fileURLToPath } from "node:url";
+import process from "node:process";
 import evlog from "evlog/nitro/v3";
+//#region src/module/apiClient.ts
+/**
+* Converts route path to PascalCase function name.
+* Examples:
+* - /health + get -> GetHealth
+* - /health + post -> PostHealth
+* - /someRoute -> SomeRoute (default)
+* - /[id] or /:id + get -> GetById
+* - /api/[multiple]/[params] -> GetApiByMultipleByParams
+* @param path - The route path (e.g., "/api/[id]" or "/api/:id")
+* @param method - HTTP method (get, post, put, delete, etc.)
+*/
+function generateFunctionName(path, method) {
+	return `${method}${path.replace(/^\//, "").replaceAll(".", "_").replaceAll("*", "").split("/").map((seg) => {
+		if (seg.startsWith("[") && seg.endsWith("]")) return `By${capitalize(seg.slice(1, -1))}`;
+		if (seg.startsWith(":")) return `By${capitalize(seg.slice(1))}`;
+		return capitalize(seg);
+	}).join("") || "Index"}`;
+}
+/**
+* Extracts route parameters from path.
+* Example: "/api/[id]/items/[itemId]" or "/api/:id/items/:itemId" -> [{name: "id", type: "string"}, {name: "itemId", type: "string"}]
+* @param path - The route path to extract parameters from
+*/
+function extractParams(path) {
+	const params = [];
+	const segments = path.split("/");
+	for (const seg of segments) if (seg.startsWith("[") && seg.endsWith("]")) {
+		const name = seg.slice(1, -1);
+		params.push(name);
+	} else if (seg.startsWith(":")) {
+		const name = seg.slice(1);
+		params.push(name);
+	}
+	return params;
+}
+/**
+* Capitalizes first letter of a string.
+* @param str - The string to capitalize
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Converts a file name to a valid JavaScript class name.
+* Only allows letters, numbers (not at start), $ and _.
+* Removes or replaces invalid characters and ensures PascalCase.
+* Always prefixed with "Generated" for clarity.
+* @param fileName - The file name to convert
+* @example "my-service-api" -> "GeneratedMyServiceApi"
+* @example "playgroundAPIClient" -> "GeneratedPlaygroundAPIClient"
+* @example "special@chars!" -> "GeneratedSpecialchars"
+*/
+function toValidClassName(fileName) {
+	let cleaned = fileName.replace(/\.(ts|js|mjs|cjs|tsx|jsx)$/, "").replace(/[-_.]/g, " ");
+	cleaned = cleaned.replace(/[^a-zA-Z0-9\s$]/g, "");
+	return `Generated${cleaned.split(/\s+/).filter((word) => word.length > 0).map((word) => capitalize(word)).join("")}`;
+}
+/**
+* Generates TypeScript method code for a route in an Angular service.
+* @param route - Parsed route information including path, method, params, and return type
+*/
+function generateMethod(route) {
+	const hasParams = route.params.length > 0;
+	let inlineParamsType = "";
+	if (hasParams) inlineParamsType = `{ ${route.params.map((name) => `${name}: string | number`).join("; ")} }`;
+	const methodParam = hasParams ? `params: ${inlineParamsType}` : "";
+	const returnTypeAnnotation = `Promise<${route.returnType}>`;
+	let pathExpression = `\`\${this.BASE_PATH}${route.path}\``;
+	if (hasParams) pathExpression = `\`\${this.BASE_PATH}${route.path.replace(/\[([^\]]+)\]/g, (_, paramName) => `\${params.${paramName}}`)}\``;
+	const fetchOptions = `{ method: '${route.method}', headers: { 'Content-Type': 'application/json' } }`;
+	return `  async ${route.functionName}(${methodParam}): ${returnTypeAnnotation} {
+    const response = await this.fetchClient.fetch(${pathExpression}, ${fetchOptions});
+    return this.serialize(response);
+  }`;
+}
+/**
+* Helper types for proper type serialization from Nitro.
+* https://github.com/nitrojs/nitro/blob/67b43f2692a41728a2759462b6982c6872ed3a81/src/types/fetch/_serialize.ts
+*/
+const serializationTypes = `type JsonPrimitive = string | number | boolean | string | number | boolean | null;
+type NonJsonPrimitive = undefined | Function | symbol;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type FilterKeys<TObj extends object, TFilter> = { [TKey in keyof TObj]: TObj[TKey] extends TFilter ? TKey : never }[keyof TObj];
+type Serialize<T> = IsAny<T> extends true ? any : T extends JsonPrimitive | undefined ? T : T extends Map<any, any> | Set<any> ? Record<string, never> : T extends NonJsonPrimitive ? never : T extends {
+  toJSON: () => infer U;
+} ? U : T extends [] ? [] : T extends [unknown, ...unknown[]] ? SerializeTuple<T> : T extends ReadonlyArray<infer U> ? (U extends NonJsonPrimitive ? null : Serialize<U>)[] : T extends object ? SerializeObject<T> : never;
+type SerializeTuple<T extends [unknown, ...unknown[]]> = { [k in keyof T]: T[k] extends NonJsonPrimitive ? null : Serialize<T[k]> };
+type SerializeObject<T extends object> = { [k in keyof Omit<T, FilterKeys<T, NonJsonPrimitive>>]: Serialize<T[k]> };
+type Simplify<TType> = TType extends any[] | Date ? TType : { [K in keyof TType]: Simplify<TType[K]> };
+type Awaited<T> = T extends PromiseLike<infer U> ? Awaited<U> : T;
+type C8ySerialize<T> = T extends void | undefined | null ? undefined : T extends string ? string : Simplify<Serialize<T>>;
+`;
+/**
+* Generates complete Angular API client service.
+* @param routes - Array of parsed routes to generate methods for
+* @param contextPath - The microservice context path (e.g., "my-service")
+* @param className - The class name for the generated service (e.g., "PlaygroundAPIClient")
+*/
+function generateAPIClient(routes, contextPath, className) {
+	return `/* eslint-disable eslint-comments/no-unlimited-disable */
+/* eslint-disable */
+/**
+ * Auto-generated Cumulocity API Client
+ * Generated by c8y-nitro
+ *
+ * This Angular service provides typed methods for all Nitro routes.
+ * Each method corresponds to a route handler and returns properly typed responses.
+ */
+import { Injectable, inject } from '@angular/core'
+import { FetchClient } from '@c8y/client'
+
+// Type helpers for proper serialization
+${serializationTypes}
 
+@Injectable({ providedIn: 'root' })
+export class ${className} {
+  private readonly BASE_PATH = '/service/${contextPath}';
+  private readonly fetchClient: FetchClient = inject(FetchClient)
+
+  /**
+   * Serializes the response based on content type and body.
+   * - Empty body (null, undefined, void) -> undefined
+   * - text/plain (string) -> raw text
+   * - application/json (number, boolean, object, array) -> JSON parsed
+   */
+  private async serialize(response: Response): Promise<any> {
+    const contentType = response.headers.get('content-type');
+    const text = await response.text();
+    
+    // Handle empty responses (null, undefined, empty return)
+    if (!text || text.length === 0) {
+      return undefined;
+    }
+    
+    // Handle plain text responses (strings)
+    if (contentType?.includes('text/plain')) {
+      return text;
+    }
+    
+    // Handle JSON responses (numbers, booleans, objects, arrays)
+    return JSON.parse(text);
+  }
+
+${routes.map((route) => generateMethod(route)).join("\n\n")}
+}`;
+}
+/**
+* Generates the TypeScript return type for a route handler.
+* @param handlerPath - Absolute path to the route handler file
+* @param outputFile - Absolute path to the output API client file
+* @returns TypeScript return type string with proper serialization wrappers
+*/
+function getReturnType(handlerPath, outputFile) {
+	const relativeHandlerPath = relative(dirname(outputFile), handlerPath);
+	return `C8ySerialize<Awaited<ReturnType<typeof import('${(relativeHandlerPath.startsWith(".") ? relativeHandlerPath : `./${relativeHandlerPath}`).replace(/\.ts$/, "")}').default>>>`;
+}
+/**
+* Writes the generated API client to disk.
+* @param nitro - Nitro instance
+* @param options - Complete module options including apiClient and manifest
+*/
+async function writeAPIClient(nitro, options) {
+	const { apiClient: apiClientOptions } = options;
+	if (!apiClientOptions) {
+		nitro.logger.debug("API client generation skipped: no apiClient options provided");
+		return;
+	}
+	const manifest = await createC8yManifestFromNitro(nitro);
+	const serviceName = manifest.name;
+	const serviceContextPath = apiClientOptions.contextPath ?? manifest.contextPath ?? serviceName;
+	const name = `${serviceName}APIClient`;
+	const rootDir = nitro.options.rootDir;
+	const outputDir = join(rootDir, apiClientOptions.dir);
+	const outputFile = join(outputDir, `${name}.ts`);
+	const routes = (nitro.routing.routes._routes ?? []).filter((route) => {
+		return !route.handler.includes("nitro/dist/runtime/internal");
+	}).map((route) => {
+		const path = route.route;
+		const method = (!route.method ? "GET" : route.method).toUpperCase();
+		const params = extractParams(path);
+		const functionName = generateFunctionName(path, method);
+		const returnType = getReturnType(route.handler, outputFile);
+		return {
+			path: path.replace(/:([^/]+)/g, "[$1]"),
+			method,
+			functionName,
+			params,
+			returnType
+		};
+	});
+	if (routes.length === 0) {
+		nitro.logger.warn("No routes found to generate API client");
+		return;
+	}
+	const code = generateAPIClient(routes, serviceContextPath, toValidClassName(name));
+	await mkdir(outputDir, { recursive: true });
+	await writeFile(outputFile, code, "utf-8");
+	nitro.logger.success(`Generated API client with ${routes.length} routes at: ${relative(rootDir, outputFile)}`);
+}
+//#endregion
+//#region src/module/docker.ts
+/**
+* Generate the Dockerfile content for a Nitro build
+* @param outputDirName - Name of the output directory (e.g., '.output')
+* @returns Dockerfile content as a string
+*/
+function getDockerfileContent(outputDirName) {
+	return `FROM node:24-slim AS runtime
+
+WORKDIR /app
+
+# Copy the Nitro build output
+COPY ${outputDirName}/ ${outputDirName}/
+
+ENV NODE_ENV=production
+ENV PORT=80
+
+EXPOSE 80
+
+# Run the Nitro server entrypoint. Use source maps to aid debugging if present.
+CMD ["node", "--enable-source-maps", "${outputDirName}/server/index.mjs"]`;
+}
+async function checkDockerInstalled() {
+	try {
+		const result = await x("docker", ["--version"]);
+		if (result.exitCode !== 0) return false;
+		if (result.stderr) return false;
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function writeDockerfile(outputDir) {
+	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");
+	return c8yDir;
+}
+async function buildDockerImage(nitro, c8yDir) {
+	const imageName = `${nitro.options.rootDir.split("/").pop() || "c8y-app"}:latest`;
+	const buildContext = join(c8yDir, "..");
+	nitro.logger.debug(`Building Docker image: ${imageName}`);
+	nitro.logger.debug(`Build context: ${buildContext}`);
+	try {
+		const result = await x("docker", [
+			"build",
+			"-t",
+			imageName,
+			"-f",
+			join(c8yDir, "Dockerfile"),
+			buildContext
+		]);
+		if (result.stdout) nitro.logger.debug(result.stdout);
+		if (result.stderr) nitro.logger.debug(result.stderr);
+		if (result.exitCode !== 0) throw new Error(`Docker build failed with exit code ${result.exitCode}`, { cause: result.stderr });
+		nitro.logger.debug(`Docker image built successfully: ${imageName}`);
+		return imageName;
+	} catch (error) {
+		throw new Error("Failed to build Docker image", { cause: error });
+	}
+}
+async function saveDockerImageToTar(nitro, c8yDir, imageName) {
+	const imageTarPath = join(c8yDir, "image.tar");
+	nitro.logger.debug(`Saving Docker image to ${imageTarPath}`);
+	try {
+		const result = await x("docker", [
+			"save",
+			"-o",
+			imageTarPath,
+			imageName
+		]);
+		if (result.stderr) nitro.logger.debug(result.stderr);
+		if (result.exitCode !== 0) throw new Error(`Docker save failed with exit code ${result.exitCode}`, { cause: result.stderr });
+		nitro.logger.debug(`Docker image saved to ${imageTarPath}`);
+		return imageTarPath;
+	} catch (error) {
+		throw new Error("Failed to save Docker image to tar file", { cause: error });
+	}
+}
+/**
+* Create a Docker image from the Nitro build output
+* @param nitro Nitro instance
+* @returns Path to the saved Docker image tar file
+*/
+async function createDockerImage(nitro) {
+	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 imageTarPath = await saveDockerImageToTar(nitro, c8yDir, await buildDockerImage(nitro, c8yDir));
+	nitro.logger.debug("Docker image creation complete.");
+	return imageTarPath;
+}
+//#endregion
+//#region src/module/c8yzip.ts
+const spinnies = new Spinnies();
+function formatBytes(bytes) {
+	if (bytes === 0) return "0 B";
+	const k = 1024;
+	const sizes = [
+		"B",
+		"kB",
+		"MB",
+		"GB"
+	];
+	const i = Math.floor(Math.log(bytes) / Math.log(k));
+	return `${(bytes / k ** i).toFixed(1)} ${sizes[i]}`;
+}
+/**
+* Resolve the output path for the zip file based on options and manifest
+* @param rootDir - Root directory of the project
+* @param options - Zip options with optional name and outputDir
+* @param manifest - Cumulocity manifest containing name and version
+* @returns Absolute path to the output zip file
+*/
+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 = {}) {
+	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);
+	spinnies.update(spinnerName, { text: "Creating manifest..." });
+	const manifest = await createC8yManifestFromNitro(nitro);
+	spinnies.update(spinnerName, { text: "Reading image.tar..." });
+	const imageTarBuffer = await readFile$1(imageTarPath);
+	spinnies.update(spinnerName, { text: "Building zip file..." });
+	const zip = new JSZip();
+	zip.file("image.tar", imageTarBuffer);
+	zip.file("cumulocity.json", JSON.stringify(manifest, null, 2));
+	const zipBuffer = await zip.generateAsync({
+		type: "nodebuffer",
+		compression: "STORE"
+	});
+	const outputFile = resolveZipOutputPath(nitro.options.rootDir, options, manifest);
+	const outputDir = join$1(outputFile, "..");
+	spinnies.update(spinnerName, { text: "Writing zip file..." });
+	await mkdir$1(outputDir, { recursive: true });
+	await writeFile$1(outputFile, zipBuffer);
+	const zipSize = formatBytes((await stat(outputFile)).size);
+	const duration = Date.now() - startTime;
+	spinnies.remove(spinnerName);
+	spinnies.stopAll();
+	nitro.logger.success(`Cumulocity zip built in ${duration}ms`);
+	nitro.logger.log(colors.gray(`  └─ ${outputFile} (${zipSize})`));
+	nitro.logger.info("Zip file can be uploaded to Cumulocity IoT platform");
+}
+//#endregion
+//#region src/module/runtime.ts
+function setupRuntime(nitro, manifestOptions = {}) {
+	nitro.logger.debug("Setting up C8Y nitro runtime");
+	const roles = manifestOptions.roles ?? [];
+	const settingKeys = (manifestOptions.settings ?? []).map((s) => s.key);
+	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
+declare module 'c8y-nitro/types' {
+  interface C8YRoles {
+${roles.map((role) => `    '${role}': '${role}';`).join("\n")}
+  }
+  type C8YTenantOptionKey = ${settingKeys.length > 0 ? `${settingKeys.map((k) => `'${k}'`).join(" | ")}` : "never"}
+  type C8YTenantOptionKeysCacheConfig = Partial<Record<C8YTenantOptionKey, number>>;
+}
+
+declare module 'c8y-nitro/runtime' {
+  import type { C8YRoles } from 'c8y-nitro/types';
+  export const c8yRoles: C8YRoles;
+  export const c8yTenantOptionKeys: readonly [${settingKeys.map((key) => `'${key}'`).join(", ")}];
+}`;
+	nitro.options.virtual["c8y-nitro/runtime"] = `
+export const c8yRoles = {
+${roles.map((role) => `  '${role}': '${role}',`).join("\n")}
+}
+
+export const c8yTenantOptionKeys = [${settingKeys.map((key) => `'${key}'`).join(", ")}]
+`;
+	mkdirSync(completeTypesDir, { recursive: true });
+	writeFileSync(typesFile, typesContent, { encoding: "utf-8" });
+	nitro.logger.debug(`Written C8Y types to ${typesFile}`);
+}
+//#endregion
+//#region src/module/runtimeConfig.ts
+/**
+* Sets up runtime configuration values from module options.
+* These can be overridden by environment variables.
+* @param nitro - The Nitro instance
+* @param options - The c8y-nitro module options
+*/
+async function setupRuntimeConfig(nitro, options) {
+	nitro.logger.debug("Setting up C8Y runtime config");
+	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);
+	nitro.options.runtimeConfig.c8ySettingsCategory = options.manifest?.settingsCategory ?? manifest.contextPath ?? manifest.name;
+}
+//#endregion
+//#region src/module/register.ts
+/**
+* Links runtime middleware, handlers, and plugins to the nitro instance.
+* Works by having the handlers in a relative path to this file.
+* Needs to be the same when built.
+* @param nitro - Nitro instance
+* @param options - C8yNitroModuleOptions
+*/
+function registerRuntime(nitro, options = {}) {
+	const thisFilePath = fileURLToPath(new URL(".", import.meta.url));
+	/**
+	* Plugins
+	*/
+	const plugins = [];
+	const c8yVariablesPluginPath = join$1(thisFilePath, "./runtime/plugins/c8y-variables");
+	plugins.push(c8yVariablesPluginPath);
+	nitro.options.plugins.push(...plugins);
+	/**
+	* Middlewares (global)
+	*/
+	const middlewares = [];
+	const devUserMiddlewarePath = join$1(thisFilePath, "./runtime/middlewares/dev-user");
+	middlewares.push(devUserMiddlewarePath);
+	nitro.options.handlers.push(...middlewares.map((handler) => ({
+		route: "/**",
+		handler,
+		middleware: true
+	})));
+	/**
+	* Handlers
+	*/
+	const handlers = [];
+	const probeHandlerPath = join$1(thisFilePath, "./runtime/handlers/liveness-readiness");
+	if (!options.manifest?.livenessProbe?.httpGet) {
+		handlers.push({
+			route: GENERATED_LIVENESS_ROUTE,
+			handler: probeHandlerPath,
+			method: "GET"
+		});
+		nitro.logger.debug(`Generated liveness probe at ${GENERATED_LIVENESS_ROUTE}`);
+	} else nitro.logger.debug("Liveness probe httpGet defined by user; skipping generation");
+	if (!options.manifest?.readinessProbe?.httpGet) {
+		handlers.push({
+			route: GENERATED_READINESS_ROUTE,
+			handler: probeHandlerPath,
+			method: "GET"
+		});
+		nitro.logger.debug(`Generated readiness probe at ${GENERATED_READINESS_ROUTE}`);
+	} else nitro.logger.debug("Readiness probe httpGet defined by user; skipping generation");
+	nitro.options.handlers.push(...handlers);
+}
+//#endregion
+//#region src/module/probeCheck.ts
+function checkProbes(nitro, manifestOptions = {}) {
+	if (manifestOptions.livenessProbe?.httpGet) {
+		const probe = manifestOptions.livenessProbe.httpGet;
+		checkProbeEndpoint(nitro, probe, "livenessProbe");
+	}
+	if (manifestOptions.readinessProbe?.httpGet) {
+		const probe = manifestOptions.readinessProbe.httpGet;
+		checkProbeEndpoint(nitro, probe, "readinessProbe");
+	}
+}
+function checkProbeEndpoint(nitro, probe, probeType) {
+	const path = probe.path;
+	const method = "GET";
+	const matchingHandlers = nitro.scannedHandlers.filter((h) => h.route === path);
+	if (matchingHandlers.length === 0) {
+		nitro.logger.warn(`${probeType} route "${path}" not found in scanned handlers. The probe will fail at runtime.`);
+		return;
+	}
+	if (!matchingHandlers.some((h) => {
+		if (!h.method) return true;
+		return h.method.toUpperCase() === method.toUpperCase();
+	})) {
+		const availableMethods = matchingHandlers.filter((h) => h.method).map((h) => h.method?.toUpperCase()).join(", ");
+		nitro.logger.warn(`${probeType} route "${path}" exists but does not accept ${method} requests. Available methods: ${availableMethods || "none specified"}. The probe will fail at runtime.`);
+	}
+}
+//#endregion
+//#region src/module/autoBootstrap.ts
+/**
+* Automatically bootstraps the microservice to the development tenant if needed.
+* Runs silently - only logs if bootstrap was performed or if errors occur.
+* @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 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 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})`);
+		}
+		await subscribeToApplication(baseUrl, process.env.C8Y_DEVELOPMENT_TENANT, appId, authHeader);
+		const credentials = await getBootstrapCredentials(baseUrl, appId, 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.success(`Auto-bootstrap complete! Bootstrap credentials written to ${envFileName}`);
+	} catch (error) {
+		nitro.logger.warn("Auto-bootstrap failed:", error instanceof Error ? error.message : String(error));
+	}
+}
+//#endregion
 //#region src/index.ts
 function c8y() {
 	return {
@@ -56,6 +588,5 @@ function c8y() {
 		}
 	};
 }
-
 //#endregion
-export { c8y, c8y as default };
+export { c8y, c8y as default };