@twin.org/node-core 0.0.1-next.2

package/dist/cjs/index.cjs

@@ -0,0 +1,612 @@
+'use strict';
+
+var apiAuthEntityStorageService = require('@twin.org/api-auth-entity-storage-service');
+var core = require('@twin.org/core');
+var crypto = require('@twin.org/crypto');
+var engineTypes = require('@twin.org/engine-types');
+var entityStorageModels = require('@twin.org/entity-storage-models');
+var identityModels = require('@twin.org/identity-models');
+var vaultModels = require('@twin.org/vault-models');
+var walletModels = require('@twin.org/wallet-models');
+var promises = require('node:fs/promises');
+var path = require('node:path');
+var dotenv = require('dotenv');
+var engine = require('@twin.org/engine');
+var engineCore = require('@twin.org/engine-core');
+var engineModels = require('@twin.org/engine-models');
+var engineServer = require('@twin.org/engine-server');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var dotenv__namespace = /*#__PURE__*/_interopNamespaceDefault(dotenv);
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * The features that can be enabled on the node.
+ */
+// eslint-disable-next-line @typescript-eslint/naming-convention
+const NodeFeatures = {
+    /**
+     * NodeIdentity - generates an identity for the node if not provided in config.
+     */
+    NodeIdentity: "node-identity",
+    /**
+     * NodeUser - generates a user for the node if not provided in config.
+     */
+    NodeUser: "node-user"
+};
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-console */
+/**
+ * Initialise the locales for the application.
+ * @param localesDirectory The directory containing the locales.
+ */
+async function initialiseLocales(localesDirectory) {
+    const localesFile = path.resolve(path.join(localesDirectory, "en.json"));
+    console.info("Locales File:", localesFile);
+    if (await fileExists(localesFile)) {
+        const enLangContent = await promises.readFile(localesFile, "utf8");
+        core.I18n.addDictionary("en", JSON.parse(enLangContent));
+    }
+    else {
+        console.warn(`Locales file not found: ${localesFile}`);
+    }
+}
+/**
+ * Get the directory where the application is being executed.
+ * @returns The execution directory.
+ */
+function getExecutionDirectory() {
+    return process.cwd();
+}
+/**
+ * Does the specified file exist.
+ * @param filename The filename to check for existence.
+ * @returns True if the file exists.
+ */
+async function fileExists(filename) {
+    try {
+        const stats = await promises.stat(filename);
+        return stats.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get the features that are enabled on the node.
+ * @param env The environment variables for the node.
+ * @returns The features that are enabled on the node.
+ */
+function getFeatures(env) {
+    if (core.Is.empty(env.features)) {
+        return [];
+    }
+    const features = [];
+    const allFeatures = Object.values(NodeFeatures);
+    const splitFeatures = env.features.split(",");
+    for (const feature of splitFeatures) {
+        const featureTrimmed = feature.trim();
+        if (allFeatures.includes(featureTrimmed)) {
+            features.push(featureTrimmed);
+        }
+    }
+    return features;
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+const DEFAULT_NODE_USERNAME = "admin@node";
+/**
+ * Bootstrap the application.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ */
+async function bootstrap(engineCore, context, envVars) {
+    const features = getFeatures(envVars);
+    await bootstrapNodeIdentity(engineCore, context, envVars, features);
+    await bootstrapNodeUser(engineCore, context, envVars, features);
+    await bootstrapAuth(engineCore, context, envVars);
+    await bootstrapBlobEncryption(engineCore, context, envVars);
+    await bootstrapAttestationMethod(engineCore, context, envVars);
+    await bootstrapImmutableProofMethod(engineCore, context, envVars);
+}
+/**
+ * Bootstrap the node creating any necessary resources.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node. The features that are enabled on the node.
+ */
+async function bootstrapNodeIdentity(engineCore, context, envVars, features) {
+    if (features.includes(NodeFeatures.NodeIdentity)) {
+        // When we bootstrap the node we need to generate an identity for it,
+        // But we have a chicken and egg problem in that we can't create the identity
+        // to store the mnemonic in the vault without an identity. We use a temporary identity
+        // and then replace it with the new identity later in the process.
+        const engineDefaultTypes = engineCore.getDefaultTypes();
+        if (!core.Is.empty(engineDefaultTypes.vaultConnector)) {
+            const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+            const workingIdentity = envVars.identity ??
+                context.state.nodeIdentity ??
+                `bootstrap-temp-${core.Converter.bytesToHex(core.RandomHelper.generate(16))}`;
+            await bootstrapMnemonic(engineCore, envVars, features, vaultConnector, workingIdentity);
+            const addresses = await bootstrapWallet(engineCore, envVars, features, workingIdentity);
+            const finalIdentity = await bootstrapIdentity(engineCore, envVars, features, workingIdentity);
+            await finaliseWallet(engineCore, envVars, features, finalIdentity, addresses);
+            await finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity);
+            context.state.nodeIdentity = finalIdentity;
+            context.state.addresses = addresses;
+            context.stateDirty = true;
+            engineCore.logInfo(core.I18n.formatMessage("node.nodeIdentity", {
+                identity: context.state.nodeIdentity
+            }));
+        }
+    }
+}
+/**
+ * Bootstrap the identity for the node.
+ * @param engineCore The engine core for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node. The features that are enabled on the node.
+ * @param nodeIdentity The identity of the node.
+ * @returns The addresses for the wallet.
+ */
+async function bootstrapIdentity(engineCore, envVars, features, nodeIdentity) {
+    const engineDefaultTypes = engineCore.getDefaultTypes();
+    // Now create an identity for the node controlled by the address we just funded
+    const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+    let identityDocument;
+    try {
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        identityDocument = await identityResolverConnector.resolveDocument(nodeIdentity);
+        engineCore.logInfo(core.I18n.formatMessage("node.existingNodeIdentity"));
+    }
+    catch { }
+    if (core.Is.empty(identityDocument)) {
+        engineCore.logInfo(core.I18n.formatMessage("node.generatingNodeIdentity"));
+        identityDocument = await identityConnector.createDocument(nodeIdentity);
+    }
+    if (engineDefaultTypes.identityConnector === engineTypes.IdentityConnectorType.Iota) {
+        const didUrn = core.Urn.fromValidString(identityDocument.id);
+        const didParts = didUrn.parts();
+        const objectId = didParts[3];
+        engineCore.logInfo(core.I18n.formatMessage("node.identityExplorer", {
+            url: `${envVars.iotaExplorerEndpoint}object/${objectId}?network=${envVars.iotaNetwork}`
+        }));
+    }
+    return identityDocument.id;
+}
+/**
+ * Bootstrap the wallet for the node.
+ * @param engineCore The engine core for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ * @param nodeIdentity The identity of the node.
+ * @returns The addresses for the wallet.
+ */
+async function bootstrapWallet(engineCore, envVars, features, nodeIdentity) {
+    const engineDefaultTypes = engineCore.getDefaultTypes();
+    const walletConnector = walletModels.WalletConnectorFactory.get(engineDefaultTypes.walletConnector);
+    const addresses = await walletConnector.getAddresses(nodeIdentity, 0, 0, 5);
+    const balance = await walletConnector.getBalance(nodeIdentity, addresses[0]);
+    if (balance === 0n) {
+        let address0 = addresses[0];
+        if (engineDefaultTypes.walletConnector === engineTypes.WalletConnectorType.Iota) {
+            address0 = `${envVars.iotaExplorerEndpoint}address/${address0}?network=${envVars.iotaNetwork}`;
+        }
+        engineCore.logInfo(core.I18n.formatMessage("node.fundingWallet", { address: address0 }));
+        // Add some funds to the wallet from the faucet
+        await walletConnector.ensureBalance(nodeIdentity, addresses[0], 1000000000n);
+    }
+    else {
+        engineCore.logInfo(core.I18n.formatMessage("node.fundedWallet"));
+    }
+    return addresses;
+}
+/**
+ * Bootstrap the identity for the node.
+ * @param engineCore The engine core for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ * @param finalIdentity The identity of the node.
+ * @param addresses The addresses for the wallet.
+ */
+async function finaliseWallet(engineCore, envVars, features, finalIdentity, addresses) {
+    const engineDefaultTypes = engineCore.getDefaultTypes();
+    // If we are using entity storage for wallet the identity associated with the
+    // address will be wrong, so fix it
+    if (engineDefaultTypes.walletConnector === "entity-storage") {
+        const walletAddress = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("WalletAddress"));
+        const addr = await walletAddress.get(addresses[0]);
+        if (!core.Is.empty(addr)) {
+            addr.identity = finalIdentity;
+            await walletAddress.set(addr);
+        }
+    }
+}
+/**
+ * Generate a mnemonic for the node identity.
+ * @param engineCore The engine core for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ * @param vaultConnector The vault connector to use.
+ * @param nodeIdentity The identity of the node.
+ */
+async function bootstrapMnemonic(engineCore, envVars, features, vaultConnector, nodeIdentity) {
+    let mnemonic = envVars.mnemonic;
+    let storeMnemonic = false;
+    try {
+        const storedMnemonic = await vaultConnector.getSecret(`${nodeIdentity}/mnemonic`);
+        storeMnemonic = storedMnemonic !== mnemonic;
+        mnemonic = storedMnemonic;
+    }
+    catch {
+        storeMnemonic = true;
+    }
+    // If there is no mnemonic then we need to generate one
+    if (core.Is.empty(mnemonic)) {
+        mnemonic = crypto.Bip39.randomMnemonic();
+        storeMnemonic = true;
+        engineCore.logInfo(core.I18n.formatMessage("node.generatingMnemonic", { mnemonic }));
+    }
+    // If there is no mnemonic stored in the vault then we need to store it
+    if (storeMnemonic) {
+        engineCore.logInfo(core.I18n.formatMessage("node.storingMnemonic"));
+        await vaultConnector.setSecret(`${nodeIdentity}/mnemonic`, mnemonic);
+    }
+    else {
+        engineCore.logInfo(core.I18n.formatMessage("node.existingMnemonic"));
+    }
+}
+/**
+ * Finalise the mnemonic for the node identity.
+ * @param vaultConnector The vault connector to use.
+ * @param workingIdentity The identity of the node.
+ * @param finalIdentity The final identity for the node.
+ */
+async function finaliseMnemonic(vaultConnector, workingIdentity, finalIdentity) {
+    // Now that we have an identity we can remove the temporary one
+    // and store the mnemonic with the new identity
+    if (workingIdentity.startsWith("bootstrap-temp-") && workingIdentity !== finalIdentity) {
+        const mnemonic = await vaultConnector.getSecret(`${workingIdentity}/mnemonic`);
+        await vaultConnector.setSecret(`${finalIdentity}/mnemonic`, mnemonic);
+        await vaultConnector.removeSecret(`${workingIdentity}/mnemonic`);
+    }
+}
+/**
+ * Bootstrap the user.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapNodeUser(engineCore, context, envVars, features) {
+    if (features.includes(NodeFeatures.NodeUser)) {
+        const engineDefaultTypes = engineCore.getDefaultTypes();
+        if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+            core.Is.stringValue(context.state.nodeIdentity)) {
+            const authUserEntityStorage = entityStorageModels.EntityStorageConnectorFactory.get(core.StringHelper.kebabCase("AuthenticationUser"));
+            const email = envVars.username ?? DEFAULT_NODE_USERNAME;
+            let nodeAdminUser = await authUserEntityStorage.get(email);
+            const generatedPassword = envVars.password ?? crypto.PasswordGenerator.generate(16);
+            const passwordBytes = core.Converter.utf8ToBytes(generatedPassword);
+            if (core.Is.empty(nodeAdminUser)) {
+                engineCore.logInfo(core.I18n.formatMessage("node.creatingNodeUser"));
+                const saltBytes = core.RandomHelper.generate(16);
+                const hashedPassword = await apiAuthEntityStorageService.PasswordHelper.hashPassword(passwordBytes, saltBytes);
+                nodeAdminUser = {
+                    email,
+                    password: hashedPassword,
+                    salt: core.Converter.bytesToBase64(saltBytes),
+                    identity: context.state.nodeIdentity
+                };
+                engineCore.logInfo(core.I18n.formatMessage("node.nodeAdminUserEmail", { email: nodeAdminUser.email }));
+                engineCore.logInfo(core.I18n.formatMessage("node.nodeAdminUserPassword", { password: generatedPassword }));
+                await authUserEntityStorage.set(nodeAdminUser);
+            }
+            else {
+                engineCore.logInfo(core.I18n.formatMessage("node.existingNodeUser"));
+                // The user already exists, so double check the other details match
+                const saltBytes = core.Converter.base64ToBytes(nodeAdminUser.salt);
+                const hashedPassword = await apiAuthEntityStorageService.PasswordHelper.hashPassword(passwordBytes, saltBytes);
+                if (nodeAdminUser.identity !== context.state.nodeIdentity ||
+                    nodeAdminUser.password !== hashedPassword) {
+                    nodeAdminUser.password = hashedPassword;
+                    nodeAdminUser.identity = context.state.nodeIdentity;
+                    await authUserEntityStorage.set(nodeAdminUser);
+                }
+            }
+            // We have create a node user, now we need to create a profile for the user
+            const identityProfileConnector = identityModels.IdentityProfileConnectorFactory.get(engineDefaultTypes.identityProfileConnector);
+            if (identityProfileConnector) {
+                let userProfile;
+                try {
+                    userProfile = await identityProfileConnector.get(context.state.nodeIdentity);
+                }
+                catch { }
+                if (core.Is.empty(userProfile)) {
+                    engineCore.logInfo(core.I18n.formatMessage("node.creatingUserProfile"));
+                    const publicProfile = {
+                        "@context": "https://schema.org",
+                        "@type": "Person",
+                        name: "Node Administrator"
+                    };
+                    const privateProfile = {
+                        "@context": "https://schema.org",
+                        "@type": "Person",
+                        givenName: "Node",
+                        familyName: "Administrator",
+                        email
+                    };
+                    await identityProfileConnector.create(context.state.nodeIdentity, publicProfile, privateProfile);
+                }
+                else {
+                    engineCore.logInfo(core.I18n.formatMessage("node.existingUserProfile"));
+                }
+            }
+        }
+    }
+}
+/**
+ * Bootstrap the attestation verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapAttestationMethod(engineCore, context, envVars, features) {
+    if (core.Is.stringValue(context.state.nodeIdentity) &&
+        core.Is.arrayValue(context.config.types.identityConnector) &&
+        core.Is.stringValue(envVars.attestationVerificationMethodId)) {
+        const engineDefaultTypes = engineCore.getDefaultTypes();
+        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        let createVm = true;
+        try {
+            identityModels.DocumentHelper.getVerificationMethod(identityDocument, `${identityDocument.id}#${envVars.attestationVerificationMethodId}`, "assertionMethod");
+            createVm = false;
+        }
+        catch { }
+        if (createVm) {
+            // Add attestation verification method to DID, the correct node context is now in place
+            // so the keys for the verification method will be stored correctly
+            engineCore.logInfo(core.I18n.formatMessage("node.addingAttestation"));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.attestationVerificationMethodId);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingAttestation"));
+        }
+    }
+}
+/**
+ * Bootstrap the immutable proof verification methods.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapImmutableProofMethod(engineCore, context, envVars, features) {
+    const engineDefaultTypes = engineCore.getDefaultTypes();
+    if (core.Is.stringValue(context.state.nodeIdentity) &&
+        core.Is.arrayValue(context.config.types.identityConnector) &&
+        core.Is.stringValue(envVars.immutableProofVerificationMethodId)) {
+        const identityConnector = identityModels.IdentityConnectorFactory.get(engineDefaultTypes.identityConnector);
+        const identityResolverConnector = identityModels.IdentityResolverConnectorFactory.get(engineDefaultTypes.identityResolverConnector);
+        const identityDocument = await identityResolverConnector.resolveDocument(context.state.nodeIdentity);
+        let createVm = true;
+        try {
+            identityModels.DocumentHelper.getVerificationMethod(identityDocument, `${identityDocument.id}#${envVars.immutableProofVerificationMethodId}`, "assertionMethod");
+            createVm = false;
+        }
+        catch { }
+        if (createVm) {
+            // Add AIG verification method to DID, the correct node context is now in place
+            // so the keys for the verification method will be stored correctly
+            engineCore.logInfo(core.I18n.formatMessage("node.addingImmutableProof"));
+            await identityConnector.addVerificationMethod(context.state.nodeIdentity, context.state.nodeIdentity, "assertionMethod", envVars.immutableProofVerificationMethodId);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingImmutableProof"));
+        }
+    }
+}
+/**
+ * Bootstrap the keys for blob encryption.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapBlobEncryption(engineCore, context, envVars, features) {
+    if ((core.Coerce.boolean(envVars.blobStorageEnableEncryption) ?? false) &&
+        core.Is.stringValue(context.state.nodeIdentity)) {
+        const engineDefaultTypes = engineCore.getDefaultTypes();
+        // Create a new key for encrypting blobs
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+        const keyName = `${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`;
+        let existingKey;
+        try {
+            existingKey = await vaultConnector.getKey(keyName);
+        }
+        catch { }
+        if (core.Is.empty(existingKey)) {
+            engineCore.logInfo(core.I18n.formatMessage("node.creatingBlobEncryptionKey"));
+            await vaultConnector.createKey(`${context.state.nodeIdentity}/${envVars.blobStorageEncryptionKey}`, vaultModels.VaultKeyType.ChaCha20Poly1305);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingBlobEncryptionKey"));
+        }
+    }
+}
+/**
+ * Bootstrap the JWT signing key.
+ * @param engineCore The engine core for the node.
+ * @param context The context for the node.
+ * @param envVars The environment variables for the node.
+ * @param features The features that are enabled on the node.
+ */
+async function bootstrapAuth(engineCore, context, envVars, features) {
+    const engineDefaultTypes = engineCore.getDefaultTypes();
+    if (engineDefaultTypes.authenticationComponent === "authentication-entity-storage" &&
+        core.Is.stringValue(context.state.nodeIdentity)) {
+        // Create a new JWT signing key and a user login for the node
+        const vaultConnector = vaultModels.VaultConnectorFactory.get(engineDefaultTypes.vaultConnector);
+        const keyName = `${context.state.nodeIdentity}/${envVars.authSigningKeyId}`;
+        let existingKey;
+        try {
+            existingKey = await vaultConnector.getKey(keyName);
+        }
+        catch { }
+        if (core.Is.empty(existingKey)) {
+            engineCore.logInfo(core.I18n.formatMessage("node.creatingAuthKey"));
+            await vaultConnector.createKey(`${context.state.nodeIdentity}/${envVars.authSigningKeyId}`, vaultModels.VaultKeyType.Ed25519);
+        }
+        else {
+            engineCore.logInfo(core.I18n.formatMessage("node.existingAuthKey"));
+        }
+    }
+}
+
+/**
+ * Start the engine server.
+ * @param serverInfo The server information.
+ * @param envVars The environment variables.
+ * @param openApiSpecFile Path to the OpenAPI spec file.
+ * @param stateStorage The state storage.
+ * @param extendConfig Extends the engine configuration with any additional custom configuration.
+ * @returns The engine server.
+ */
+async function start(serverInfo, envVars, openApiSpecFile, stateStorage, extendConfig) {
+    envVars.storageFileRoot ??= "";
+    if ((envVars.entityStorageConnectorType === engineTypes.EntityStorageConnectorType.File ||
+        envVars.blobStorageConnectorType === engineTypes.BlobStorageConnectorType.File ||
+        core.Is.empty(stateStorage)) &&
+        !core.Is.stringValue(envVars.storageFileRoot)) {
+        throw new core.GeneralError("node", "storageFileRootNotSet");
+    }
+    // Build the engine configuration from the environment variables.
+    const engineConfig = engine.buildEngineConfiguration(envVars);
+    // Extend the engine configuration with a custom type.
+    if (core.Is.function(extendConfig)) {
+        await extendConfig(engineConfig);
+    }
+    // Build the server configuration from the environment variables.
+    const serverConfig = engineServer.buildEngineServerConfiguration(envVars, engineConfig, serverInfo, openApiSpecFile);
+    // Create the engine instance using file state storage and custom bootstrap.
+    const engine$1 = new engine.Engine({
+        config: { ...engineConfig, ...serverConfig },
+        stateStorage: stateStorage ?? new engineCore.FileStateStorage(envVars.stateFilename ?? ""),
+        customBootstrap: async (core, engineContext) => bootstrap(core, engineContext, envVars)
+    });
+    // Need to register the engine with the factory so that background tasks
+    // can clone it to spawn new instances.
+    engineModels.EngineCoreFactory.register("engine", () => engine$1);
+    // Construct the server with the engine.
+    const server = new engineServer.EngineServer({ engineCore: engine$1 });
+    // Start the server, which also starts the engine.
+    const canContinue = await server.start();
+    if (canContinue) {
+        return {
+            engine: engine$1,
+            server
+        };
+    }
+}
+
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/* eslint-disable no-console */
+/**
+ * Run the TWIN Node server.
+ * @param options Optional options for the server.
+ * @param options.serverName Optional name of the server, defaults to "TWIN Node Server".
+ * @param options.serverVersion Optional version of the server, defaults to current version.
+ * @param options.envFilenames Additional environment variable filenames to load, defaults to .env.
+ * @param options.envPrefix Optional prefix for environment variables, defaults to "TWIN_NODE_".
+ * @param options.executionDirectory Optional directory to override the execution location, defaults to process directory.
+ * @param options.localesDirectory Optional directory to override the locales directory, defaults to the locales directory.
+ * @param options.openApiSpecFile Optional path to the OpenAPI spec file, defaults to docs/open-api/spec.json.
+ * @returns A promise that resolves when the server is started.
+ */
+async function run(options) {
+    try {
+        const serverInfo = {
+            name: options?.serverName ?? "TWIN Node Server",
+            version: options?.serverVersion ?? "0.0.1-next.1" // x-release-please-version
+        };
+        console.log(`\u001B[4m🌩️  ${serverInfo.name} v${serverInfo.version}\u001B[24m\n`);
+        const executionDirectory = options?.executionDirectory ?? getExecutionDirectory();
+        console.info("Execution Directory:", process.cwd());
+        await initialiseLocales(options?.localesDirectory ?? path.resolve(path.join(executionDirectory, "dist", "locales")));
+        if (core.Is.empty(options?.openApiSpecFile)) {
+            const specFile = path.resolve(path.join(executionDirectory, "docs", "open-api", "spec.json"));
+            console.info("Default OpenAPI Spec File:", specFile);
+            if (await fileExists(specFile)) {
+                options ??= {};
+                options.openApiSpecFile = specFile;
+            }
+        }
+        if (core.Is.empty(options?.envFilenames)) {
+            const envFile = path.resolve(path.join(executionDirectory, ".env"));
+            console.info("Default Environment File:", envFile);
+            options ??= {};
+            options.envFilenames = [envFile];
+        }
+        dotenv__namespace.config({
+            path: options?.envFilenames
+        });
+        const envPrefix = options?.envPrefix ?? "TWIN_NODE_";
+        console.info("Environment Prefix:", envPrefix);
+        const envVars = core.EnvHelper.envToJson(process.env, envPrefix);
+        console.info();
+        const startResult = await start(serverInfo, envVars, options?.openApiSpecFile);
+        if (!core.Is.empty(startResult)) {
+            for (const signal of ["SIGHUP", "SIGINT", "SIGTERM"]) {
+                process.on(signal, async () => {
+                    await startResult.server.stop();
+                });
+            }
+        }
+    }
+    catch (err) {
+        console.error(core.ErrorHelper.formatErrors(err).join("\n"));
+        // eslint-disable-next-line unicorn/no-process-exit
+        process.exit(1);
+    }
+}
+
+exports.NodeFeatures = NodeFeatures;
+exports.bootstrap = bootstrap;
+exports.bootstrapAttestationMethod = bootstrapAttestationMethod;
+exports.bootstrapAuth = bootstrapAuth;
+exports.bootstrapBlobEncryption = bootstrapBlobEncryption;
+exports.bootstrapImmutableProofMethod = bootstrapImmutableProofMethod;
+exports.bootstrapNodeIdentity = bootstrapNodeIdentity;
+exports.bootstrapNodeUser = bootstrapNodeUser;
+exports.fileExists = fileExists;
+exports.getExecutionDirectory = getExecutionDirectory;
+exports.getFeatures = getFeatures;
+exports.initialiseLocales = initialiseLocales;
+exports.run = run;
+exports.start = start;