c8y-nitro 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 schplitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,292 @@
+# c8y-nitro
+
+Lightning fast Cumulocity IoT microservice development powered by [Nitro](https://v3.nitro.build).
+
+## Features
+
+- ⚡️ **Lightning Fast** - Built on Nitro's high performance engine
+- 🔧 **Fully Configurable** - Everything configured via module options
+- 📁 **Auto Zip Creation** - Automatically generates the deployable microservice zip
+- 🎯 **API Client Generation** - Creates Cumulocity-compatible Angular API clients
+- 📦 **Built-in Probes** - Automatic setup for liveliness and readiness probes
+- 🚀 **Hot Module Reload** - Instant feedback during development
+- 🔥 **File-based Routing** - Auto-discovered routes from your file structure
+- 🛠️ **TypeScript First** - Full type safety with excellent DX
+- 🔄 **Auto-Bootstrap** - Automatically registers and configures your microservice in development
+
+## Getting Started
+
+### Installation
+
+```sh
+pnpm add c8y-nitro nitro@latest
+```
+
+## Usage
+
+Configure your Cumulocity microservice in `nitro.config.ts`:
+
+```ts
+import c8y from 'c8y-nitro'
+
+export default defineNitroConfig({
+  c8y: {
+    // c8y-nitro configuration options go here
+  },
+  modules: [c8y()],
+})
+```
+
+## Getting Started
+
+Create a `.env` or `.env.local` file with your development tenant credentials:
+
+```sh
+C8Y_BASEURL=https://your-tenant.cumulocity.com
+C8Y_DEVELOPMENT_TENANT=t12345
+C8Y_DEVELOPMENT_USER=your-username
+C8Y_DEVELOPMENT_PASSWORD=your-password
+```
+
+Then simply run `pnpm dev` - that's it! The module will automatically:
+
+1. Check if the microservice exists on the tenant
+2. Create it if needed (or use existing one without overwriting)
+3. Subscribe your tenant to the microservice
+4. Retrieve and save bootstrap credentials to your env file
+
+After auto-bootstrap, your env file will contain:
+
+```sh
+C8Y_BOOTSTRAP_TENANT=<bootstrap-tenant-id>
+C8Y_BOOTSTRAP_USER=<bootstrap-username>
+C8Y_BOOTSTRAP_PASSWORD=<generated-password>
+```
+
+> **Manual Bootstrap**: For more control or troubleshooting, you can use the [CLI bootstrap command](#cli-commands) to manually register your microservice.
+
+## Automatic Zip Creation
+
+`c8y-nitro` automatically generates a ready-to-deploy microservice zip package after each build. The process includes:
+
+1. **Dockerfile Generation** - Creates an optimized Dockerfile using Node.js 22-slim
+2. **Docker Image Build** - Builds and saves the Docker image to `image.tar`
+3. **Manifest Generation** - Creates `cumulocity.json` from your package.json and configuration
+4. **Zip Package** - Combines `image.tar` and `cumulocity.json` into a deployable zip file
+
+> **Note**: Docker must be installed and available in your PATH.
+
+The generated zip file (default: `<package-name>-<version>.zip` in root directory) is ready to upload directly to Cumulocity.
+
+### Configuration
+
+```ts
+import { defineNitroConfig } from 'nitro/config'
+import c8y from 'c8y-nitro'
+
+export default defineNitroConfig({
+  c8y: {
+    zip: {
+      name: 'my-microservice.zip', // Custom zip name
+      outputDir: './dist', // Output directory
+    }
+  },
+  modules: [c8y()],
+})
+```
+
+## Manifest Configuration
+
+The `cumulocity.json` manifest is automatically generated from your `package.json` and can be customized via the `manifest` option.
+
+**Auto-generated from package.json:**
+
+- `name` (scope stripped), `version` - from package fields
+- `provider.name` - from `author` field
+- `provider.domain` - from `author.url` or `homepage`
+- `provider.support` - from `bugs` or `author.email`
+- `contextPath` - defaults to package name
+
+### Basic Configuration
+
+```ts
+export default defineNitroConfig({
+  c8y: {
+    manifest: {
+      // Required API roles for the microservice
+      requiredRoles: ['ROLE_INVENTORY_READ', 'ROLE_ALARM_ADMIN'],
+
+      // Custom roles this microservice provides
+      roles: ['CUSTOM_MICROSERVICE_ROLE'],
+
+      // Resource limits
+      resources: {
+        cpu: '1',
+        memory: '1G'
+      }
+    }
+  },
+  modules: [c8y()],
+})
+```
+
+For all available manifest options, see the [Cumulocity Microservice Manifest documentation](https://cumulocity.com/docs/microservice-sdk/general-aspects/#microservice-manifest).
+
+> **Note**: Custom roles defined in the manifest are automatically available as TypeScript types for use in middleware and runtime code during development.
+
+> **Note**: Health probe endpoints (`/_c8y_nitro/liveness` and `/_c8y_nitro/readiness`) are automatically injected if not manually defined.
+
+## Development User Injection
+
+During development, `c8y-nitro` automatically injects your development user credentials into all requests. This allows you to test authentication and authorization middlewares locally.
+
+The module uses the development credentials from your `.env` file:
+
+```sh
+C8Y_DEVELOPMENT_TENANT=t12345
+C8Y_DEVELOPMENT_USER=your-username
+C8Y_DEVELOPMENT_PASSWORD=your-password
+```
+
+This enables testing of access control middlewares like `hasUserRequiredRole()` and `isUserFromAllowedTenant()` without needing to manually set authorization headers.
+
+### Managing Development User Roles
+
+Use the [CLI roles command](#cli-commands) to assign or remove your microservice's custom roles to your development user:
+
+```sh
+npx c8y-nitro roles
+```
+
+This interactive command lets you select which roles from your manifest to assign to your development user for testing.
+
+## API Client Generation
+
+For monorepo architectures, `c8y-nitro` can generate TypeScript Angular services that provide fully typed access to your microservice routes.
+
+### Configuration
+
+```ts
+export default defineNitroConfig({
+  c8y: {
+    apiClient: {
+      dir: '../ui/src/app/services', // Output directory for generated client
+      contextPath: 'my-service' // Optional: override context path
+    }
+  },
+  modules: [c8y()],
+})
+```
+
+### Generated Client
+
+The generated service creates one method per route with automatic type inference:
+
+```ts
+// Generated: my-serviceAPIClient.ts
+@Injectable({ providedIn: 'root' })
+export class GeneratedMyServiceAPIClient {
+  async GETHealth(): Promise<{ status: string }> { }
+  async GETUsersById(params: { id: string | number }): Promise<User> { }
+  async POSTUsers(body: CreateUserDto): Promise<User> { }
+}
+```
+
+### Usage in Angular
+
+```ts
+import { GeneratedMyServiceAPIClient } from './services/my-serviceAPIClient'
+
+@Component({
+  /**
+   * ...
+   */
+})
+export class MyComponent {
+  private api = inject(GeneratedMyServiceAPIClient)
+
+  async ngOnInit() {
+    const health = await this.api.GETHealth()
+    const user = await this.api.GETUsersById({ id: 123 })
+  }
+}
+```
+
+> **Note**: The client regenerates automatically when routes change during development.
+
+## Utilities
+
+`c8y-nitro` provides several utility functions to simplify common tasks in Cumulocity microservices.
+
+To use these utilities, simply import them from `c8y-nitro/utils`:
+
+```ts
+import { useUser, useUserClient } from 'c8y-nitro/utils'
+```
+
+### Credentials
+
+| Function                           | Description                                               | Request Context |
+| ---------------------------------- | --------------------------------------------------------- | :-------------: |
+| `useSubscribedTenantCredentials()` | Get credentials for all subscribed tenants (cached 10min) |       ❌        |
+| `useDeployedTenantCredentials()`   | Get credentials for the deployed tenant (cached 10 min)   |       ❌        |
+| `useUserTenantCredentials()`       | Get credentials for the current user's tenant             |       ✅        |
+
+> **Note**: `useDeployedTenantCredentials()` shares its cache with `useSubscribedTenantCredentials()`. Both functions support `.invalidate()` and `.refresh()` methods. Invalidating or refreshing one will affect the other.
+
+### Resources
+
+| Function         | Description                        | Request Context |
+| ---------------- | ---------------------------------- | :-------------: |
+| `useUser()`      | Fetch current user from Cumulocity |       ✅        |
+| `useUserRoles()` | Get roles of the current user      |       ✅        |
+
+### Client
+
+| Function                       | Description                                         | Request Context |
+| ------------------------------ | --------------------------------------------------- | :-------------: |
+| `useUserClient()`              | Create client authenticated with user's credentials |       ✅        |
+| `useUserTenantClient()`        | Create client for user's tenant (microservice user) |       ✅        |
+| `useSubscribedTenantClients()` | Create clients for all subscribed tenants           |       ❌        |
+| `useDeployedTenantClient()`    | Create client for the deployed tenant               |       ❌        |
+
+### Middleware
+
+| Function                                   | Description                               | Request Context |
+| ------------------------------------------ | ----------------------------------------- | :-------------: |
+| `hasUserRequiredRole(role\|roles)`         | Check if user has required role(s)        |       ✅        |
+| `isUserFromAllowedTenant(tenant\|tenants)` | Check if user is from allowed tenant(s)   |       ✅        |
+| `isUserFromDeployedTenant()`               | Check if user is from the deployed tenant |       ✅        |
+
+## CLI Commands
+
+| Command     | Description                                             |
+| ----------- | ------------------------------------------------------- |
+| `bootstrap` | Manually register microservice and retrieve credentials |
+| `roles`     | Manage development user roles                           |
+
+For more information, run:
+
+```sh
+npx c8y-nitro -h
+```
+
+## Development
+
+```sh
+# Install dependencies
+pnpm install
+
+# Run dev watcher
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Run tests
+pnpm test
+```
+
+## License
+
+MIT

package/dist/cli/commands/bootstrap.mjs

@@ -0,0 +1,64 @@
+import { createC8yManifest } from "../../module/manifest.mjs";
+import { createBasicAuthHeader, createMicroservice, findMicroserviceByName, getBootstrapCredentials, subscribeToApplication, updateMicroservice } from "../utils/c8y-api.mjs";
+import { writeBootstrapCredentials } from "../utils/env-file.mjs";
+import { loadC8yConfig, validateBootstrapEnv } from "../utils/config.mjs";
+import { defineCommand, runCommand } from "citty";
+import { consola } from "consola";
+
+//#region src/cli/commands/bootstrap.ts
+var bootstrap_default = defineCommand({
+	meta: {
+		name: "bootstrap",
+		description: "Bootstrap your microservice to the development tenant"
+	},
+	args: {},
+	async run() {
+		consola.info("Loading configuration...");
+		const { env, c8yOptions, configDir } = await loadC8yConfig();
+		consola.info("Validating environment variables...");
+		const envVars = validateBootstrapEnv(env);
+		consola.info("Building manifest...");
+		const manifest = await createC8yManifest(configDir, c8yOptions?.manifest);
+		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...`);
+		const existingApp = await findMicroserviceByName(envVars.C8Y_BASEURL, manifest.name, authHeader);
+		let appId;
+		if (existingApp) {
+			consola.warn(`Microservice "${manifest.name}" already exists on development tenant (ID: ${existingApp.id})`);
+			if (!await consola.prompt("Do you want to update the existing microservice?", {
+				type: "confirm",
+				cancel: "reject"
+			})) {
+				consola.info("Bootstrap cancelled.");
+				return;
+			}
+			consola.info("Updating microservice...");
+			appId = (await updateMicroservice(envVars.C8Y_BASEURL, existingApp.id, manifest, authHeader)).id;
+			consola.success(`Microservice updated successfully (ID: ${appId})`);
+		} else {
+			consola.info("Creating microservice...");
+			appId = (await createMicroservice(envVars.C8Y_BASEURL, manifest, authHeader)).id;
+			consola.success(`Microservice created successfully (ID: ${appId})`);
+		}
+		consola.info("Subscribing tenant to application...");
+		await subscribeToApplication(envVars.C8Y_BASEURL, envVars.C8Y_DEVELOPMENT_TENANT, appId, authHeader);
+		consola.success("Tenant subscribed to application");
+		consola.info("Fetching bootstrap credentials...");
+		const credentials = await getBootstrapCredentials(envVars.C8Y_BASEURL, appId, authHeader);
+		consola.info("Writing bootstrap credentials...");
+		const envFileName = await writeBootstrapCredentials(configDir, {
+			C8Y_BOOTSTRAP_TENANT: credentials.tenant,
+			C8Y_BOOTSTRAP_USER: credentials.name,
+			C8Y_BOOTSTRAP_PASSWORD: credentials.password
+		});
+		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.mjs").then((r) => r.default), { rawArgs: [] });
+		}
+		consola.success("Bootstrap complete!");
+	}
+});
+
+//#endregion
+export { bootstrap_default as default };

package/dist/cli/commands/roles.mjs

@@ -0,0 +1,41 @@
+import { createC8yManifest } from "../../module/manifest.mjs";
+import { assignUserRole, createBasicAuthHeader, unassignUserRole } from "../utils/c8y-api.mjs";
+import { loadC8yConfig, validateBootstrapEnv } from "../utils/config.mjs";
+import { defineCommand } from "citty";
+import { consola } from "consola";
+
+//#region src/cli/commands/roles.ts
+var roles_default = defineCommand({
+	meta: {
+		name: "roles",
+		description: "Manage microservice roles for the development user"
+	},
+	args: {},
+	async run() {
+		consola.info("Loading configuration...");
+		const { env, c8yOptions, configDir } = await loadC8yConfig();
+		consola.info("Validating environment variables...");
+		const envVars = validateBootstrapEnv(env);
+		consola.info("Building manifest...");
+		const manifest = await createC8yManifest(configDir, c8yOptions?.manifest);
+		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):", {
+				type: "multiselect",
+				options: manifest.roles,
+				cancel: "reject",
+				required: false
+			});
+			consola.info("Managing user roles...");
+			const rolePromises = manifest.roles.map(async (role) => {
+				if (rolesToAssign.includes(role)) return await assignUserRole(envVars.C8Y_BASEURL, envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, role, authHeader);
+				else return await unassignUserRole(envVars.C8Y_BASEURL, envVars.C8Y_DEVELOPMENT_TENANT, envVars.C8Y_DEVELOPMENT_USER, role, authHeader);
+			});
+			await Promise.all(rolePromises);
+			consola.success("Role management complete");
+		} else consola.warn("No roles defined in manifest. Nothing to manage.");
+	}
+});
+
+//#endregion
+export { roles_default as default };

package/dist/cli/index.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli/index.mjs

@@ -0,0 +1,18 @@
+import { description, name, version } from "../package.mjs";
+import { defineCommand, runMain } from "citty";
+
+//#region src/cli/index.ts
+runMain(defineCommand({
+	meta: {
+		name,
+		version,
+		description
+	},
+	subCommands: {
+		bootstrap: () => import("./commands/bootstrap.mjs").then((r) => r.default),
+		roles: () => import("./commands/roles.mjs").then((r) => r.default)
+	}
+}));
+
+//#endregion
+export {  };

package/dist/cli/utils/c8y-api.mjs

@@ -0,0 +1,172 @@
+import { Buffer } from "node:buffer";
+
+//#region src/cli/utils/c8y-api.ts
+/**
+* Creates a Basic Auth header for Cumulocity API requests.
+* Format: base64(tenant/user:password)
+* @param tenant - The Cumulocity tenant ID
+* @param user - The username
+* @param password - The password
+*/
+function createBasicAuthHeader(tenant, user, password) {
+	const credentials = `${tenant}/${user}:${password}`;
+	return `Basic ${Buffer.from(credentials).toString("base64")}`;
+}
+/**
+* Checks if a microservice with the given name already exists.
+* @param baseUrl - The Cumulocity base URL
+* @param name - The microservice name to search for
+* @param authHeader - The Basic Auth header
+* @returns The application if found, undefined otherwise
+*/
+async function findMicroserviceByName(baseUrl, name, authHeader) {
+	const url = `${baseUrl}/application/applications?name=${encodeURIComponent(name)}`;
+	const response = await fetch(url, {
+		method: "GET",
+		headers: {
+			Authorization: authHeader,
+			Accept: "application/json"
+		}
+	});
+	if (!response.ok) throw new Error(`Failed to query microservices: ${response.status} ${response.statusText}`, { cause: response });
+	return (await response.json()).applications.find((app) => app.name === name);
+}
+/**
+* Creates a new microservice in Cumulocity.
+* @param baseUrl - The Cumulocity base URL
+* @param manifest - The microservice manifest
+* @param authHeader - The Basic Auth header
+* @returns The created application
+*/
+async function createMicroservice(baseUrl, manifest, authHeader) {
+	const url = `${baseUrl}/application/applications`;
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Authorization": authHeader,
+			"Content-Type": "application/json",
+			"Accept": "application/json"
+		},
+		body: JSON.stringify(manifest)
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Failed to create microservice: ${response.status} ${response.statusText}\n${errorText}`, { cause: response });
+	}
+	return await response.json();
+}
+/**
+* Updates an existing microservice in Cumulocity.
+* @param baseUrl - The Cumulocity base URL
+* @param appId - The application ID to update
+* @param manifest - The microservice manifest
+* @param authHeader - The Basic Auth header
+* @returns The updated application
+*/
+async function updateMicroservice(baseUrl, appId, manifest, authHeader) {
+	const url = `${baseUrl}/application/applications/${appId}`;
+	const { type, ...manifestWithoutType } = manifest;
+	const response = await fetch(url, {
+		method: "PUT",
+		headers: {
+			"Authorization": authHeader,
+			"Content-Type": "application/json",
+			"Accept": "application/json"
+		},
+		body: JSON.stringify(manifestWithoutType)
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Failed to update microservice: ${response.status} ${response.statusText}\n${errorText}`, { cause: response });
+	}
+	return await response.json();
+}
+/**
+* Subscribes a tenant to an application.
+* @param baseUrl - The Cumulocity base URL
+* @param tenantId - The tenant ID to subscribe
+* @param appId - The application ID
+* @param authHeader - The Basic Auth header
+*/
+async function subscribeToApplication(baseUrl, tenantId, appId, authHeader) {
+	const url = `${baseUrl}/tenant/tenants/${tenantId}/applications`;
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Authorization": authHeader,
+			"Content-Type": "application/json",
+			"Accept": "application/json"
+		},
+		body: JSON.stringify({ application: { self: `${baseUrl}/application/applications/${appId}` } })
+	});
+	if (response.status === 409) return;
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Failed to subscribe tenant to application: ${response.status} ${response.statusText}\n${errorText}`, { cause: response });
+	}
+}
+/**
+* Fetches the bootstrap credentials for a microservice.
+* @param baseUrl - The Cumulocity base URL
+* @param appId - The application ID
+* @param authHeader - The Basic Auth header
+*/
+async function getBootstrapCredentials(baseUrl, appId, authHeader) {
+	const url = `${baseUrl}/application/applications/${appId}/bootstrapUser`;
+	const response = await fetch(url, {
+		method: "GET",
+		headers: {
+			Authorization: authHeader,
+			Accept: "application/json"
+		}
+	});
+	if (!response.ok) throw new Error(`Failed to get bootstrap credentials: ${response.status} ${response.statusText}`, { cause: response });
+	return await response.json();
+}
+/**
+* Assigns a role to a user in a tenant.
+* @param baseUrl - The Cumulocity base URL
+* @param tenantId - The tenant ID
+* @param userId - The user ID
+* @param roleId - The role ID to assign
+* @param authHeader - The Basic Auth header
+*/
+async function assignUserRole(baseUrl, tenantId, userId, roleId, authHeader) {
+	const url = `${baseUrl}/user/${tenantId}/users/${userId}/roles`;
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Authorization": authHeader,
+			"Content-Type": "application/vnd.com.nsn.cumulocity.rolereference+json",
+			"Accept": "application/json"
+		},
+		body: JSON.stringify({ role: { self: `${baseUrl}/user/roles/${roleId}` } })
+	});
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Failed to assign role ${roleId}: ${response.status} ${response.statusText}\n${errorText}`, { cause: response });
+	}
+}
+/**
+* Unassigns a role from a user in a tenant.
+* @param baseUrl - The Cumulocity base URL
+* @param tenantId - The tenant ID
+* @param userId - The user ID
+* @param roleId - The role ID to unassign
+* @param authHeader - The Basic Auth header
+*/
+async function unassignUserRole(baseUrl, tenantId, userId, roleId, authHeader) {
+	const url = `${baseUrl}/user/${tenantId}/users/${userId}/roles/${roleId}`;
+	const response = await fetch(url, {
+		method: "DELETE",
+		headers: { Authorization: authHeader }
+	});
+	if (response.status === 404) return;
+	if (!response.ok) {
+		const errorText = await response.text();
+		throw new Error(`Failed to unassign role ${roleId}: ${response.status} ${response.statusText}\n${errorText}`, { cause: response });
+	}
+}
+
+//#endregion
+export { assignUserRole, createBasicAuthHeader, createMicroservice, findMicroserviceByName, getBootstrapCredentials, subscribeToApplication, unassignUserRole, updateMicroservice };

package/dist/cli/utils/config.mjs

@@ -0,0 +1,57 @@
+import { dirname } from "pathe";
+import { loadConfig, loadDotenv } from "c12";
+import process from "process";
+
+//#region src/cli/utils/config.ts
+/**
+* Loads c8y configuration from nitro.config and .env files.
+* Searches in cwd.
+*/
+async function loadC8yConfig() {
+	const cwd = process.cwd();
+	const env = await loadDotenv({
+		cwd,
+		fileName: [".env", ".env.local"]
+	});
+	const { config, _configFile } = await loadConfig({
+		configFile: "nitro.config",
+		cwd
+	});
+	if (!_configFile) throw new Error("No nitro.config file found. Please ensure you have a valid nitro.config file.");
+	const configDir = dirname(_configFile);
+	return {
+		env,
+		nitroConfig: config,
+		c8yOptions: config.c8y,
+		configDir,
+		configFile: _configFile
+	};
+}
+/**
+* Required environment variables for bootstrap command
+*/
+const REQUIRED_BOOTSTRAP_ENV_VARS = [
+	"C8Y_BASEURL",
+	"C8Y_DEVELOPMENT_TENANT",
+	"C8Y_DEVELOPMENT_USER",
+	"C8Y_DEVELOPMENT_PASSWORD"
+];
+/**
+* Validates that all required environment variables are present.
+* @param env - Environment variables object
+* @returns The validated environment variables
+* @throws Error if any required variable is missing
+*/
+function validateBootstrapEnv(env) {
+	const missing = REQUIRED_BOOTSTRAP_ENV_VARS.filter((key) => !env[key]);
+	if (missing.length > 0) throw new Error(`Missing required environment variables:\n${missing.map((k) => `  - ${k}`).join("\n")}\n\nPlease set these in your .env or .env.local file.`);
+	return {
+		C8Y_BASEURL: env.C8Y_BASEURL.endsWith("/") ? env.C8Y_BASEURL.slice(0, -1) : env.C8Y_BASEURL,
+		C8Y_DEVELOPMENT_TENANT: env.C8Y_DEVELOPMENT_TENANT,
+		C8Y_DEVELOPMENT_USER: env.C8Y_DEVELOPMENT_USER,
+		C8Y_DEVELOPMENT_PASSWORD: env.C8Y_DEVELOPMENT_PASSWORD
+	};
+}
+
+//#endregion
+export { loadC8yConfig, validateBootstrapEnv };