c8y-nitro 0.1.0

package/dist/cli/utils/env-file.mjs

@@ -0,0 +1,61 @@
+import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+//#region src/cli/utils/env-file.ts
+/**
+* Writes or updates environment variables in a file.
+* Existing variables are overwritten, new ones are appended.
+* @param filePath - Absolute path to the .env file
+* @param variables - Key-value pairs to write
+*/
+async function writeEnvVariables(filePath, variables) {
+	let content = "";
+	if (existsSync(filePath)) content = await readFile(filePath, "utf-8");
+	const lines = content.split("\n");
+	const variableNames = Object.keys(variables);
+	const foundVariables = /* @__PURE__ */ new Set();
+	const updatedLines = lines.map((line) => {
+		for (const varName of variableNames) if (new RegExp(`^${varName}\\s*=`).test(line)) {
+			foundVariables.add(varName);
+			return `${varName}=${variables[varName]}`;
+		}
+		return line;
+	});
+	const missingVariables = variableNames.filter((v) => !foundVariables.has(v));
+	if (missingVariables.length > 0) {
+		if (updatedLines[updatedLines.length - 1] !== "" && updatedLines.length > 0) updatedLines.push("");
+		for (const varName of missingVariables) updatedLines.push(`${varName}=${variables[varName]}`);
+	}
+	let finalContent = updatedLines.join("\n");
+	if (!finalContent.endsWith("\n")) finalContent += "\n";
+	await writeFile(filePath, finalContent, "utf-8");
+}
+/**
+* Determines which .env file to write to and writes the variables.
+* Priority: .env.local (if exists) > .env (if exists) > create .env
+* @param configDir - Directory containing the config files
+* @param variables - Key-value pairs to write
+* @returns The filename that was written to (e.g., '.env.local' or '.env')
+*/
+async function writeBootstrapCredentials(configDir, variables) {
+	const envLocalPath = join(configDir, ".env.local");
+	const envPath = join(configDir, ".env");
+	let targetPath;
+	let targetName;
+	if (existsSync(envLocalPath)) {
+		targetPath = envLocalPath;
+		targetName = ".env.local";
+	} else if (existsSync(envPath)) {
+		targetPath = envPath;
+		targetName = ".env";
+	} else {
+		targetPath = envPath;
+		targetName = ".env";
+	}
+	await writeEnvVariables(targetPath, variables);
+	return targetName;
+}
+
+//#endregion
+export { writeBootstrapCredentials };

package/dist/index.d.mts

@@ -0,0 +1,12 @@
+import { C8yNitroModuleOptions } from "./types.mjs";
+import { NitroModule } from "nitro/types";
+
+//#region src/index.d.ts
+declare module 'nitro/types' {
+  interface NitroOptions {
+    c8y?: C8yNitroModuleOptions;
+  }
+}
+declare function c8y(): NitroModule;
+//#endregion
+export { c8y, c8y as default };

package/dist/index.mjs

@@ -0,0 +1,51 @@
+import { writeAPIClient } from "./module/apiClient.mjs";
+import { createC8yZip } from "./module/c8yzip.mjs";
+import { setupRuntime } from "./module/runtime.mjs";
+import { registerRuntime } from "./module/register.mjs";
+import { checkProbes } from "./module/probeCheck.mjs";
+import { autoBootstrap } from "./module/autoBootstrap.mjs";
+
+//#region src/index.ts
+function c8y() {
+	return {
+		name: "c8y-nitro",
+		setup: async (nitro) => {
+			const options = nitro.options.c8y ?? {};
+			nitro.options.typescript.generateTsConfig = true;
+			nitro.options.typescript.tsConfig = {};
+			nitro.options.typescript.tsConfig.include = ["./**/*.d.ts"];
+			nitro.options.typescript.tsConfig.exclude = [];
+			nitro.options.experimental.asyncContext = true;
+			if (!nitro.options.preset.startsWith("nitro") && !nitro.options.preset.startsWith("node")) {
+				nitro.logger.error(`Unsupported preset "${nitro.options.preset}" for c8y-nitro module, only node presets are supported.`);
+				throw new Error("Unsupported preset for c8y-nitro module");
+			}
+			await autoBootstrap(nitro);
+			setupRuntime(nitro, options.manifest);
+			registerRuntime(nitro, options);
+			nitro.hooks.hook("dev:reload", async () => {
+				setupRuntime(nitro, options.manifest);
+				if (options.apiClient) {
+					nitro.logger.debug("Generating C8Y API client");
+					await writeAPIClient(nitro, options);
+				}
+			});
+			nitro.hooks.hook("build:before", async () => {
+				if (options.manifest) checkProbes(nitro, options.manifest);
+			});
+			nitro.hooks.hook("types:extend", async () => {
+				if (options.apiClient) {
+					nitro.logger.debug("Generating C8Y API client");
+					await writeAPIClient(nitro, options);
+				}
+			});
+			nitro.hooks.hook("close", async () => {
+				if (nitro.options.preset !== "nitro-dev") await createC8yZip(nitro, options.zip);
+			});
+		}
+	};
+}
+var src_default = c8y;
+
+//#endregion
+export { c8y, src_default as default };

package/dist/module/apiClient.mjs

@@ -0,0 +1,207 @@
+import { createC8yManifestFromNitro } from "./manifest.mjs";
+import { dirname, join, relative } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+
+//#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
+export { writeAPIClient };

package/dist/module/autoBootstrap.mjs

@@ -0,0 +1,54 @@
+import { createC8yManifest } from "./manifest.mjs";
+import { createBasicAuthHeader, createMicroservice, findMicroserviceByName, getBootstrapCredentials, subscribeToApplication } from "../cli/utils/c8y-api.mjs";
+import { writeBootstrapCredentials } from "../cli/utils/env-file.mjs";
+import process from "node:process";
+
+//#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
+export { autoBootstrap };

package/dist/module/c8yzip.mjs

@@ -0,0 +1,66 @@
+import { createC8yManifestFromNitro } from "./manifest.mjs";
+import { createDockerImage } from "./docker.mjs";
+import { join } from "pathe";
+import { mkdir, readFile, stat, writeFile } from "fs/promises";
+import JSZip from "jszip";
+import Spinnies from "spinnies";
+import { colors } from "consola/utils";
+
+//#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(join(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(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(outputFile, "..");
+	spinnies.update(spinnerName, { text: "Writing zip file..." });
+	await mkdir(outputDir, { recursive: true });
+	await writeFile(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
+export { createC8yZip };

package/dist/module/constants.mjs

@@ -0,0 +1,6 @@
+//#region src/module/constants.ts
+const GENERATED_LIVENESS_ROUTE = "/_c8y_nitro/liveness";
+const GENERATED_READINESS_ROUTE = "/_c8y_nitro/readiness";
+
+//#endregion
+export { GENERATED_LIVENESS_ROUTE, GENERATED_READINESS_ROUTE };

package/dist/module/docker.mjs

@@ -0,0 +1,101 @@
+import { basename, join } from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+import { x } from "tinyexec";
+
+//#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:22-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
+export { createDockerImage };

package/dist/module/manifest.mjs

@@ -0,0 +1,72 @@
+import { GENERATED_LIVENESS_ROUTE, GENERATED_READINESS_ROUTE } from "./constants.mjs";
+import { readPackage } from "pkg-types";
+
+//#region src/module/manifest.ts
+async function readPackageJsonFieldsForManifest(rootDir, logger) {
+	logger?.debug(`Reading package file from ${rootDir}`);
+	const pkg = await readPackage(rootDir);
+	const name = pkg.name?.replace(/^@[^/]+\//, "");
+	const version = pkg.version;
+	const author = pkg.author;
+	const authorName = typeof author === "string" ? author : author?.name;
+	const authorEmail = typeof author === "string" ? void 0 : author?.email;
+	const authorUrl = typeof author === "string" ? void 0 : author?.url;
+	if (!name || !version || !authorName) throw new Error("package.json must contain name, version, and author name fields");
+	const support = typeof pkg.bugs === "string" ? pkg.bugs : pkg.bugs?.url ?? pkg.bugs?.email;
+	const provider = {
+		name: authorName ?? name,
+		domain: authorUrl ?? pkg.homepage,
+		support: support ?? authorEmail
+	};
+	logger?.debug(`Found package.json fields for manifest: name=${name}, version=${version}, provider=${JSON.stringify(provider)}`);
+	return {
+		name,
+		version,
+		provider,
+		contextPath: name
+	};
+}
+/**
+* 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
+* @param logger - Optional logger for debug output
+*/
+async function createC8yManifest(rootDir, options = {}, logger) {
+	const { name, version, provider, ...restManifestFields } = await readPackageJsonFieldsForManifest(rootDir, logger);
+	const probeFields = {};
+	if (!options.livenessProbe?.httpGet) probeFields.livenessProbe = {
+		...options.livenessProbe,
+		httpGet: { path: GENERATED_LIVENESS_ROUTE }
+	};
+	if (!options.readinessProbe?.httpGet) probeFields.readinessProbe = {
+		...options.readinessProbe,
+		httpGet: { path: GENERATED_READINESS_ROUTE }
+	};
+	const key = `${name}-key`;
+	const manifest = {
+		...restManifestFields,
+		provider,
+		...probeFields,
+		...options,
+		name,
+		version,
+		apiVersion: "v2",
+		key,
+		type: "MICROSERVICE"
+	};
+	logger?.debug(`Created Cumulocity manifest: ${JSON.stringify(manifest, null, 2)}`);
+	return manifest;
+}
+/**
+* Creates a Cumulocity manifest from a Nitro instance.
+* Convenience wrapper for use in the Nitro module.
+* @param nitro - The Nitro instance
+*/
+async function createC8yManifestFromNitro(nitro) {
+	return createC8yManifest(nitro.options.rootDir, nitro.options.c8y?.manifest, nitro.logger);
+}
+
+//#endregion
+export { createC8yManifest, createC8yManifestFromNitro };

package/dist/module/probeCheck.mjs

@@ -0,0 +1,30 @@
+//#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
+export { checkProbes };