@capawesome/capacitor-nodejs 0.0.1

package/android/src/main/cpp/native-lib.cpp

@@ -0,0 +1,192 @@
+/*
+  JNI layer between the plugin's Java code and the Node.js engine.
+
+  Based on the `nodejs-mobile-react-native` project
+  (MIT licensed, https://github.com/nodejs-mobile/nodejs-mobile-react-native).
+*/
+#include <jni.h>
+#include <string>
+#include <cstdlib>
+#include <pthread.h>
+#include <unistd.h>
+#include <android/log.h>
+
+#include "node.h"
+#include "bridge.h"
+
+#define LOG_TAG "NodejsPlugin"
+
+// Cache the environment variable for the thread running Node.js to call into Java.
+JNIEnv* cacheEnvPointer = NULL;
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_io_capawesome_capacitorjs_plugins_nodejs_Nodejs_sendMessageToNodeChannel(
+        JNIEnv *env,
+        jclass /* clazz */,
+        jstring channelName,
+        jstring msg) {
+    const char* nativeChannelName = env->GetStringUTFChars(channelName, 0);
+    const char* nativeMessage = env->GetStringUTFChars(msg, 0);
+    capacitor_bridge_notify(nativeChannelName, nativeMessage);
+    env->ReleaseStringUTFChars(channelName, nativeChannelName);
+    env->ReleaseStringUTFChars(msg, nativeMessage);
+}
+
+extern "C"
+JNIEXPORT void JNICALL
+Java_io_capawesome_capacitorjs_plugins_nodejs_Nodejs_registerNodeDataDirPath(
+        JNIEnv *env,
+        jclass /* clazz */,
+        jstring dataDir) {
+    const char* nativeDataDir = env->GetStringUTFChars(dataDir, 0);
+    capacitor_register_node_data_dir_path(nativeDataDir);
+    env->ReleaseStringUTFChars(dataDir, nativeDataDir);
+}
+
+void rcv_message(const char* channel_name, const char* msg) {
+    JNIEnv *env = cacheEnvPointer;
+    if (!env) {
+        return;
+    }
+    jclass cls = env->FindClass("io/capawesome/capacitorjs/plugins/nodejs/Nodejs");
+    if (cls != nullptr) {
+        jmethodID m_onMessageReceived = env->GetStaticMethodID(cls, "onMessageReceived", "(Ljava/lang/String;Ljava/lang/String;)V");
+        if (m_onMessageReceived != nullptr) {
+            jstring java_channel_name = env->NewStringUTF(channel_name);
+            jstring java_msg = env->NewStringUTF(msg);
+            env->CallStaticVoidMethod(cls, m_onMessageReceived, java_channel_name, java_msg);
+            env->DeleteLocalRef(java_channel_name);
+            env->DeleteLocalRef(java_msg);
+        }
+    }
+    env->DeleteLocalRef(cls);
+}
+
+// Threads to redirect stdout and stderr to logcat.
+int pipe_stdout[2];
+int pipe_stderr[2];
+pthread_t thread_stdout;
+pthread_t thread_stderr;
+
+void *thread_stderr_func(void*) {
+    ssize_t redirect_size;
+    char buf[2048];
+    while ((redirect_size = read(pipe_stderr[0], buf, sizeof buf - 1)) > 0) {
+        // __android_log will add a new line anyway.
+        if (buf[redirect_size - 1] == '\n') {
+            --redirect_size;
+        }
+        buf[redirect_size] = 0;
+        __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, buf);
+    }
+    return 0;
+}
+
+void *thread_stdout_func(void*) {
+    ssize_t redirect_size;
+    char buf[2048];
+    while ((redirect_size = read(pipe_stdout[0], buf, sizeof buf - 1)) > 0) {
+        // __android_log will add a new line anyway.
+        if (buf[redirect_size - 1] == '\n') {
+            --redirect_size;
+        }
+        buf[redirect_size] = 0;
+        __android_log_write(ANDROID_LOG_INFO, LOG_TAG, buf);
+    }
+    return 0;
+}
+
+int start_redirecting_stdout_stderr() {
+    // Set stdout as unbuffered.
+    setvbuf(stdout, 0, _IONBF, 0);
+    pipe(pipe_stdout);
+    dup2(pipe_stdout[1], STDOUT_FILENO);
+
+    // Set stderr as unbuffered.
+    setvbuf(stderr, 0, _IONBF, 0);
+    pipe(pipe_stderr);
+    dup2(pipe_stderr[1], STDERR_FILENO);
+
+    if (pthread_create(&thread_stdout, 0, thread_stdout_func, 0) == -1) {
+        return -1;
+    }
+    pthread_detach(thread_stdout);
+
+    if (pthread_create(&thread_stderr, 0, thread_stderr_func, 0) == -1) {
+        return -1;
+    }
+    pthread_detach(thread_stderr);
+
+    return 0;
+}
+
+// Node's libuv requires all arguments being on contiguous memory.
+extern "C"
+JNIEXPORT jint JNICALL
+Java_io_capawesome_capacitorjs_plugins_nodejs_Nodejs_startNodeWithArguments(
+        JNIEnv *env,
+        jclass /* clazz */,
+        jobjectArray arguments,
+        jstring nodePath,
+        jboolean redirectOutputToLogcat) {
+
+    // Set the NODE_PATH environment variable.
+    const char* node_path = env->GetStringUTFChars(nodePath, 0);
+    setenv("NODE_PATH", node_path, 1);
+    env->ReleaseStringUTFChars(nodePath, node_path);
+
+    jsize argument_count = env->GetArrayLength(arguments);
+
+    // Compute the byte size needed for all arguments in contiguous memory.
+    int c_arguments_size = 0;
+    for (int i = 0; i < argument_count; i++) {
+        jstring argument = (jstring)env->GetObjectArrayElement(arguments, i);
+        const char* current_argument = env->GetStringUTFChars(argument, 0);
+        c_arguments_size += strlen(current_argument);
+        c_arguments_size++; // for '\0'
+        env->ReleaseStringUTFChars(argument, current_argument);
+        env->DeleteLocalRef(argument);
+    }
+
+    // Store the arguments in contiguous memory.
+    char* args_buffer = (char*)calloc(c_arguments_size, sizeof(char));
+
+    // The argv to pass into Node.js.
+    char* argv[argument_count];
+
+    // Iterate through the expected start position of each argument in args_buffer.
+    char* current_args_position = args_buffer;
+
+    // Populate the args_buffer and argv.
+    for (int i = 0; i < argument_count; i++) {
+        jstring argument = (jstring)env->GetObjectArrayElement(arguments, i);
+        const char* current_argument = env->GetStringUTFChars(argument, 0);
+
+        // Copy the current argument to its expected position in args_buffer.
+        strncpy(current_args_position, current_argument, strlen(current_argument));
+
+        // Save the current argument start position in argv.
+        argv[i] = current_args_position;
+
+        // Increment to the next argument's expected position.
+        current_args_position += strlen(current_args_position) + 1;
+
+        env->ReleaseStringUTFChars(argument, current_argument);
+        env->DeleteLocalRef(argument);
+    }
+
+    capacitor_register_bridge_cb(&rcv_message);
+
+    cacheEnvPointer = env;
+
+    if (redirectOutputToLogcat) {
+        if (start_redirecting_stdout_stderr() == -1) {
+            __android_log_write(ANDROID_LOG_ERROR, LOG_TAG, "Couldn't start redirecting stdout and stderr to logcat.");
+        }
+    }
+
+    // Start Node.js, with argc and argv. This call blocks until the
+    // Node.js event loop exits.
+    return jint(node::Start(argument_count, argv));
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/nodejs/Nodejs.java

@@ -0,0 +1,256 @@
+package io.capawesome.capacitorjs.plugins.nodejs;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.content.pm.PackageInfo;
+import android.content.res.AssetManager;
+import android.system.Os;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSArray;
+import com.getcapacitor.Logger;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.events.MessageEvent;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.options.SendOptions;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.options.StartOptions;
+import io.capawesome.capacitorjs.plugins.nodejs.interfaces.EmptyCallback;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.json.JSONObject;
+
+public class Nodejs {
+
+    private static final String ASSETS_BUILTIN_MODULES_DIR = "builtin_modules";
+    private static final String BASE_DIR = "capawesome_nodejs";
+    private static final String CHANNEL_EVENTS = "_EVENTS_";
+    private static final String CHANNEL_SYSTEM = "_SYSTEM_";
+    private static final String SHARED_PREFS = "CapawesomeNodejsPlugin";
+    private static final String SHARED_PREFS_APK_LAST_UPDATE_TIME = "apkLastUpdateTime";
+    private static final String SYSTEM_MESSAGE_PAUSE = "pause";
+    private static final String SYSTEM_MESSAGE_READY = "ready-for-app-events";
+    private static final String SYSTEM_MESSAGE_RESUME = "resume";
+
+    @Nullable
+    private static Nodejs instance;
+
+    static {
+        System.loadLibrary("node");
+        System.loadLibrary("capacitor-nodejs");
+    }
+
+    @NonNull
+    private final NodejsConfig config;
+
+    @NonNull
+    private final Context context;
+
+    @NonNull
+    private final NodejsPlugin plugin;
+
+    private volatile boolean ready = false;
+
+    private volatile boolean started = false;
+
+    public Nodejs(@NonNull NodejsPlugin plugin, @NonNull Context context, @NonNull NodejsConfig config) {
+        this.config = config;
+        this.context = context;
+        this.plugin = plugin;
+        Nodejs.instance = this;
+    }
+
+    public boolean isReady() {
+        return ready;
+    }
+
+    public void send(@NonNull SendOptions options) throws Exception {
+        if (!ready) {
+            throw CustomExceptions.NODE_NOT_READY;
+        }
+        JSONObject envelope = new JSONObject();
+        envelope.put("event", options.getEventName());
+        envelope.put("payload", options.getArgs().toString());
+        sendMessageToNodeChannel(CHANNEL_EVENTS, envelope.toString());
+    }
+
+    public synchronized void start(@NonNull StartOptions options, @NonNull EmptyCallback callback) {
+        if (started) {
+            callback.error(CustomExceptions.NODE_ALREADY_RUNNING);
+            return;
+        }
+        started = true;
+        Thread thread = new Thread(() -> {
+            try {
+                File projectDir = new File(getBaseDir(), "nodejs-project");
+                File builtinModulesDir = new File(getBaseDir(), ASSETS_BUILTIN_MODULES_DIR);
+                copyNodeProjectFromApk(projectDir, builtinModulesDir);
+                File scriptFile = resolveScriptFile(projectDir, options.getScript());
+                for (Map.Entry<String, String> entry : options.getEnv().entrySet()) {
+                    Os.setenv(entry.getKey(), entry.getValue(), true);
+                }
+                Os.setenv("TMPDIR", context.getCacheDir().getAbsolutePath(), true);
+                registerNodeDataDirPath(context.getFilesDir().getAbsolutePath());
+                List<String> args = new ArrayList<>();
+                args.add("node");
+                args.add(scriptFile.getAbsolutePath());
+                args.addAll(options.getArgs());
+                String nodePath = projectDir.getAbsolutePath() + ":" + builtinModulesDir.getAbsolutePath();
+                callback.success();
+                startNodeWithArguments(args.toArray(new String[0]), nodePath, true);
+            } catch (Exception exception) {
+                started = false;
+                callback.error(exception);
+            }
+        });
+        thread.start();
+    }
+
+    public void handleOnPause() {
+        if (ready) {
+            sendMessageToNodeChannel(CHANNEL_SYSTEM, SYSTEM_MESSAGE_PAUSE);
+        }
+    }
+
+    public void handleOnResume() {
+        if (ready) {
+            sendMessageToNodeChannel(CHANNEL_SYSTEM, SYSTEM_MESSAGE_RESUME);
+        }
+    }
+
+    @SuppressWarnings("unused")
+    private static void onMessageReceived(@NonNull String channelName, @NonNull String message) {
+        Nodejs instance = Nodejs.instance;
+        if (instance == null) {
+            return;
+        }
+        try {
+            instance.handleMessage(channelName, message);
+        } catch (Exception exception) {
+            Logger.error(NodejsPlugin.TAG, "Failed to handle message from the Node.js runtime.", exception);
+        }
+    }
+
+    private void handleMessage(@NonNull String channelName, @NonNull String message) throws Exception {
+        if (CHANNEL_SYSTEM.equals(channelName)) {
+            if (SYSTEM_MESSAGE_READY.equals(message)) {
+                ready = true;
+                plugin.notifyReadyListeners();
+            }
+        } else if (CHANNEL_EVENTS.equals(channelName)) {
+            JSONObject envelope = new JSONObject(message);
+            String eventName = envelope.getString("event");
+            JSArray args = new JSArray(envelope.optString("payload", "[]"));
+            plugin.notifyMessageListeners(new MessageEvent(eventName, args));
+        }
+    }
+
+    private void copyNodeProjectFromApk(@NonNull File projectDir, @NonNull File builtinModulesDir) throws Exception {
+        AssetManager assetManager = context.getAssets();
+        String projectAssetsPath = "public/" + config.getNodeDir();
+        String[] projectAssets = assetManager.list(projectAssetsPath);
+        if (projectAssets == null || projectAssets.length == 0) {
+            throw CustomExceptions.PROJECT_NOT_FOUND;
+        }
+        SharedPreferences sharedPreferences = context.getSharedPreferences(SHARED_PREFS, Context.MODE_PRIVATE);
+        long previousLastUpdateTime = sharedPreferences.getLong(SHARED_PREFS_APK_LAST_UPDATE_TIME, 0);
+        PackageInfo packageInfo = context.getPackageManager().getPackageInfo(context.getPackageName(), 0);
+        long lastUpdateTime = packageInfo.lastUpdateTime;
+        if (lastUpdateTime != previousLastUpdateTime || !projectDir.exists()) {
+            deleteRecursively(projectDir);
+            deleteRecursively(builtinModulesDir);
+            copyAssetDirectory(assetManager, projectAssetsPath, projectDir);
+            copyAssetDirectory(assetManager, ASSETS_BUILTIN_MODULES_DIR, builtinModulesDir);
+            sharedPreferences.edit().putLong(SHARED_PREFS_APK_LAST_UPDATE_TIME, lastUpdateTime).apply();
+        }
+    }
+
+    @NonNull
+    private File resolveScriptFile(@NonNull File projectDir, @Nullable String script) throws Exception {
+        String scriptPath = script;
+        if (scriptPath == null) {
+            scriptPath = getMainFromPackageJson(projectDir);
+        }
+        if (scriptPath == null) {
+            scriptPath = "index.js";
+        }
+        File scriptFile = new File(projectDir, scriptPath);
+        if (!scriptFile.exists()) {
+            throw CustomExceptions.SCRIPT_NOT_FOUND;
+        }
+        return scriptFile;
+    }
+
+    @Nullable
+    private String getMainFromPackageJson(@NonNull File projectDir) {
+        try {
+            File packageJsonFile = new File(projectDir, "package.json");
+            if (!packageJsonFile.exists()) {
+                return null;
+            }
+            byte[] bytes = new byte[(int) packageJsonFile.length()];
+            try (InputStream inputStream = new java.io.FileInputStream(packageJsonFile)) {
+                int read = inputStream.read(bytes);
+                if (read != bytes.length) {
+                    return null;
+                }
+            }
+            JSONObject packageJson = new JSONObject(new String(bytes, StandardCharsets.UTF_8));
+            return packageJson.optString("main", null);
+        } catch (Exception exception) {
+            return null;
+        }
+    }
+
+    @NonNull
+    private File getBaseDir() {
+        return new File(context.getFilesDir(), BASE_DIR);
+    }
+
+    private void copyAssetDirectory(@NonNull AssetManager assetManager, @NonNull String assetPath, @NonNull File targetDir)
+        throws Exception {
+        String[] children = assetManager.list(assetPath);
+        if (children == null || children.length == 0) {
+            copyAssetFile(assetManager, assetPath, targetDir);
+        } else {
+            if (!targetDir.exists() && !targetDir.mkdirs()) {
+                throw new Exception("Failed to create directory: " + targetDir.getAbsolutePath());
+            }
+            for (String child : children) {
+                copyAssetDirectory(assetManager, assetPath + "/" + child, new File(targetDir, child));
+            }
+        }
+    }
+
+    private void copyAssetFile(@NonNull AssetManager assetManager, @NonNull String assetPath, @NonNull File targetFile) throws Exception {
+        try (InputStream inputStream = assetManager.open(assetPath); OutputStream outputStream = new FileOutputStream(targetFile)) {
+            byte[] buffer = new byte[8192];
+            int length;
+            while ((length = inputStream.read(buffer)) > 0) {
+                outputStream.write(buffer, 0, length);
+            }
+        }
+    }
+
+    private void deleteRecursively(@NonNull File file) {
+        if (file.isDirectory()) {
+            File[] children = file.listFiles();
+            if (children != null) {
+                for (File child : children) {
+                    deleteRecursively(child);
+                }
+            }
+        }
+        file.delete();
+    }
+
+    private static native void registerNodeDataDirPath(String dataDir);
+
+    private static native void sendMessageToNodeChannel(String channelName, String msg);
+
+    private static native int startNodeWithArguments(String[] arguments, String nodePath, boolean redirectOutputToLogcat);
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/nodejs/NodejsConfig.java

@@ -0,0 +1,30 @@
+package io.capawesome.capacitorjs.plugins.nodejs;
+
+import androidx.annotation.NonNull;
+
+public class NodejsConfig {
+
+    @NonNull
+    private String nodeDir = "nodejs";
+
+    @NonNull
+    private String startMode = "auto";
+
+    @NonNull
+    public String getNodeDir() {
+        return nodeDir;
+    }
+
+    public void setNodeDir(@NonNull String nodeDir) {
+        this.nodeDir = nodeDir;
+    }
+
+    @NonNull
+    public String getStartMode() {
+        return startMode;
+    }
+
+    public void setStartMode(@NonNull String startMode) {
+        this.startMode = startMode;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/nodejs/NodejsPlugin.java

@@ -0,0 +1,159 @@
+package io.capawesome.capacitorjs.plugins.nodejs;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Logger;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.CustomException;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.CustomExceptions;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.events.MessageEvent;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.options.SendOptions;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.options.StartOptions;
+import io.capawesome.capacitorjs.plugins.nodejs.classes.results.IsReadyResult;
+import io.capawesome.capacitorjs.plugins.nodejs.interfaces.EmptyCallback;
+import io.capawesome.capacitorjs.plugins.nodejs.interfaces.Result;
+
+@CapacitorPlugin(name = "Nodejs")
+public class NodejsPlugin extends Plugin {
+
+    public static final String ERROR_UNKNOWN_ERROR = "An unknown error has occurred.";
+    public static final String EVENT_MESSAGE = "message";
+    public static final String EVENT_READY = "ready";
+    public static final String START_MODE_AUTO = "auto";
+    public static final String START_MODE_MANUAL = "manual";
+    public static final String TAG = "NodejsPlugin";
+
+    private NodejsConfig config;
+    private Nodejs implementation;
+
+    @Override
+    public void load() {
+        config = getNodejsConfig();
+        implementation = new Nodejs(this, getContext(), config);
+        if (START_MODE_AUTO.equals(config.getStartMode())) {
+            implementation.start(
+                new StartOptions(),
+                new EmptyCallback() {
+                    @Override
+                    public void success() {}
+
+                    @Override
+                    public void error(Exception exception) {
+                        Logger.error(TAG, "Failed to start the Node.js runtime.", exception);
+                    }
+                }
+            );
+        }
+    }
+
+    @PluginMethod
+    public void isReady(PluginCall call) {
+        try {
+            IsReadyResult result = new IsReadyResult(implementation.isReady());
+            resolveCall(call, result);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void send(PluginCall call) {
+        try {
+            SendOptions options = new SendOptions(call);
+
+            implementation.send(options);
+            resolveCall(call);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    @PluginMethod
+    public void start(PluginCall call) {
+        try {
+            if (!START_MODE_MANUAL.equals(config.getStartMode())) {
+                rejectCall(call, CustomExceptions.START_MODE_NOT_MANUAL);
+                return;
+            }
+            StartOptions options = new StartOptions(call);
+            EmptyCallback callback = new EmptyCallback() {
+                @Override
+                public void success() {
+                    resolveCall(call);
+                }
+
+                @Override
+                public void error(Exception exception) {
+                    rejectCall(call, exception);
+                }
+            };
+
+            implementation.start(options, callback);
+        } catch (Exception exception) {
+            rejectCall(call, exception);
+        }
+    }
+
+    public void notifyMessageListeners(@NonNull MessageEvent event) {
+        notifyListeners(EVENT_MESSAGE, event.toJSObject(), true);
+    }
+
+    public void notifyReadyListeners() {
+        notifyListeners(EVENT_READY, new JSObject(), true);
+    }
+
+    @Override
+    protected void handleOnPause() {
+        super.handleOnPause();
+        implementation.handleOnPause();
+    }
+
+    @Override
+    protected void handleOnResume() {
+        super.handleOnResume();
+        implementation.handleOnResume();
+    }
+
+    @NonNull
+    private NodejsConfig getNodejsConfig() {
+        NodejsConfig config = new NodejsConfig();
+        String nodeDir = getConfig().getString("nodeDir", null);
+        if (nodeDir != null) {
+            config.setNodeDir(nodeDir);
+        }
+        String startMode = getConfig().getString("startMode", null);
+        if (startMode != null) {
+            config.setStartMode(startMode);
+        }
+        return config;
+    }
+
+    private void rejectCall(@NonNull PluginCall call, @NonNull Exception exception) {
+        String message = exception.getMessage();
+        if (message == null) {
+            message = ERROR_UNKNOWN_ERROR;
+        }
+        String code = null;
+        if (exception instanceof CustomException) {
+            code = ((CustomException) exception).getCode();
+        }
+        Logger.error(TAG, message, exception);
+        call.reject(message, code);
+    }
+
+    private void resolveCall(@NonNull PluginCall call) {
+        call.resolve();
+    }
+
+    private void resolveCall(@NonNull PluginCall call, @Nullable Result result) {
+        if (result == null) {
+            call.resolve();
+        } else {
+            call.resolve(result.toJSObject());
+        }
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/nodejs/classes/CustomException.java

@@ -0,0 +1,20 @@
+package io.capawesome.capacitorjs.plugins.nodejs.classes;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+public class CustomException extends Exception {
+
+    @Nullable
+    private final String code;
+
+    public CustomException(@Nullable String code, @NonNull String message) {
+        super(message);
+        this.code = code;
+    }
+
+    @Nullable
+    public String getCode() {
+        return code;
+    }
+}

package/android/src/main/java/io/capawesome/capacitorjs/plugins/nodejs/classes/CustomExceptions.java

@@ -0,0 +1,23 @@
+package io.capawesome.capacitorjs.plugins.nodejs.classes;
+
+public class CustomExceptions {
+
+    public static final CustomException EVENT_NAME_MISSING = new CustomException("EVENT_NAME_MISSING", "eventName must be provided.");
+    public static final CustomException NODE_ALREADY_RUNNING = new CustomException(
+        "NODE_ALREADY_RUNNING",
+        "The Node.js runtime is already running."
+    );
+    public static final CustomException NODE_NOT_READY = new CustomException(
+        "NODE_NOT_READY",
+        "The Node.js runtime is not ready to receive messages."
+    );
+    public static final CustomException PROJECT_NOT_FOUND = new CustomException(
+        "PROJECT_NOT_FOUND",
+        "The Node.js project directory was not found."
+    );
+    public static final CustomException SCRIPT_NOT_FOUND = new CustomException("SCRIPT_NOT_FOUND", "The script file was not found.");
+    public static final CustomException START_MODE_NOT_MANUAL = new CustomException(
+        "START_MODE_NOT_MANUAL",
+        "The startMode configuration option must be set to 'manual'."
+    );
+}