javonet-nodejs-sdk 2.5.9 → 2.5.11

package/Binaries/Perl/Windows/X64/lib/Javonet/Core/Transmitter/PerlTransmitter.pm

@@ -2,7 +2,7 @@ package Javonet::Core::Transmitter::PerlTransmitter;
 use strict;
 use warnings;
 use Cwd;
-use aliased 'Javonet::Core::Transmitter::PerlTransmitterWrapper' => 'PerlTransmitterWrapper' , qw(send_command activate);
+use aliased 'Javonet::Core::Transmitter::PerlTransmitterWrapper' => 'PerlTransmitterWrapper' , qw(send_command activate set_config_source set_javonet_working_directory);
 
 sub send_command {
     my ($self, $message_byte_array_ref) = @_;
@@ -20,4 +20,9 @@ sub set_config_source {
     PerlTransmitterWrapper->set_config_source($config_path);
 }
 
+sub set_javonet_working_directory {
+    my ($self, $working_directory) = @_;
+    PerlTransmitterWrapper->set_javonet_working_directory($working_directory);
+}
+
 1;

package/Binaries/Perl/Windows/X64/lib/Javonet/Core/Transmitter/PerlTransmitterWrapper.pm

@@ -15,6 +15,7 @@ my $read_response_native;
 my $activate_native;
 my $get_native_error_native;
 my $set_config_source_native;
+my $set_working_directory_native;
 
 sub initialize {
     my $osname = $^O;
@@ -53,6 +54,7 @@ sub initialize {
         $activate_native = $ffi->function('Activate' => ['string'] => 'int');
         $get_native_error_native = $ffi->function('GetNativeError' => [] => 'string');
         $set_config_source_native = $ffi->function('SetConfigSource' => ['string'] => 'int');
+        $set_working_directory_native = $ffi->function('SetWorkingDirectory' => ['string'] => 'int');
     }
 }
 
@@ -102,4 +104,17 @@ sub set_config_source {
     }
 }
 
+sub set_javonet_working_directory {
+    my ($self, $working_directory) = @_;
+    initialize();
+    my $set_working_directory_result = $set_working_directory_native->($working_directory);
+    if ($set_working_directory_result < 0) {
+        my $error_message = $get_native_error_native->();
+        die "Javonet set working directory result: $set_working_directory_result. Native error message: $error_message";
+    }
+    else {
+        return $set_working_directory_result;
+    }
+}
+
 1;

package/Binaries/Perl/Windows/X64/lib/Javonet/Javonet.pm

@@ -6,12 +6,12 @@ use lib 'lib';
 use Try::Tiny;
 use threads;
 use aliased 'Javonet::Sdk::Internal::RuntimeFactory' => 'RuntimeFactory';
-use aliased 'Javonet::Core::Transmitter::PerlTransmitter' => 'Transmitter', qw(activate_with_license_file activate_with_credentials activate_with_credentials_and_proxy);
+use aliased 'Javonet::Core::Transmitter::PerlTransmitter' => 'Transmitter', qw(activate send_command set_config_source set_javonet_working_directory);
 use aliased 'Javonet::Core::Exception::SdkExceptionHelper' => 'SdkExceptionHelper';
 use aliased 'Javonet::Sdk::Core::RuntimeLogger' => 'RuntimeLogger', qw(get_runtime_info);
 
 BEGIN {
-    SdkExceptionHelper->send_exception_to_app_insights("SdkMessage","Javonet Sdk initialized");
+    SdkExceptionHelper->send_exception_to_app_insights("SdkMessage", "Javonet Sdk initialized");
 }
 
 sub activate {
@@ -40,7 +40,7 @@ sub with_config {
         Transmitter->set_config_source($config_path);
         return RuntimeFactory->new(Javonet::Sdk::Internal::ConnectionType::get_connection_type('WithConfig'), undef, $config_path);
     } catch {
-        SdkExceptionHelper->send_exception_to_app_insights($_,"withConfig");
+        SdkExceptionHelper->send_exception_to_app_insights("SdkException", $_);
         die $_;
     };
 }
@@ -54,9 +54,27 @@ sub set_config_source {
     try {
         Transmitter->set_config_source($config_path);
     } catch {
-        SdkExceptionHelper->send_exception_to_app_insights($_,"setConfigSource");
+        SdkExceptionHelper->send_exception_to_app_insights("SdkException", $_);
         die $_;
     };
 }
 
+# Sets the working directory for the Javonet SDK.
+# @param $path [String] The working directory path.
+sub set_javonet_working_directory {
+    my ($self, $path) = @_;
+    try {
+        $path =~ s{\\}{/}g;
+        $path .= '/' unless $path =~ m{/$};
+        mkdir $path, 0700 unless -d $path;
+        #ActivationHelper->working_directory($path);
+        Transmitter->set_javonet_working_directory($path);
+    } catch {
+        SdkExceptionHelper->send_exception_to_app_insights("SdkException", $_);
+        die $_;
+    };
+}
+
+
+
 1;

package/Binaries/Python/javonet/core/handler/GetTypeHandler.py

@@ -45,7 +45,7 @@ class GetTypeHandler(AbstractCommandHandler):
             exc_type, exc_value = type(e), e
             sys_path = "\n".join(sys.path)
             available_types = "\n".join(self.get_all_available_types())
-            new_message = str(e) + "\nLoaded directories: " + sys_path  + "\nAvailable user types:\n" + available_types + "\n\n\n"
+            new_message = str(e) + "\nLoaded directories:\n" + sys_path  + "\nAvailable user types:\n" + available_types + "\n\n\n"
             new_exc = exc_type(new_message).with_traceback(e.__traceback__)
             raise new_exc from None
 
@@ -65,22 +65,21 @@ class GetTypeHandler(AbstractCommandHandler):
         loaded_module = import_module(module_name)
         return getattr(loaded_module, class_name)
 
-
     def get_all_available_types(self):
-        available_types = []
+        available_types = set()
         for directory in LoadLibraryHandler.loaded_directories:
             for root, _, files in os.walk(directory):
+                if "Binaries" in root:
+                    continue
                 for file in files:
                     if file.lower().endswith(".py") and file != "__init__.py":
                         module_name = os.path.splitext(file)[0]
-                        module_path = os.path.relpath(os.path.join(root, module_name), directory)
-                        module_path = module_path.replace(os.sep, ".")
+                        module_path = os.path.relpath(os.path.join(root, module_name), directory).replace(os.sep, ".")
                         try:
                             module = importlib.import_module(module_path)
                             for name, obj in inspect.getmembers(module, inspect.isclass):
-                                # Store the fully qualified class name
                                 qualified_name = f"{module_path}.{name}"
-                                available_types.append(qualified_name)
-                        except Exception as e:
-                            logging.error(f"Error importing {module_path}: {e}")
-        return available_types
+                                available_types.add(qualified_name)
+                        except Exception:
+                            pass
+        return list(available_types)

package/Binaries/Python/javonet/core/transmitter/Transmitter.py

@@ -13,4 +13,8 @@ class Transmitter:
 
     @staticmethod
     def set_config_source(source_path):
-        return TransmitterWrapper.set_config_source(source_path)
+        return TransmitterWrapper.set_config_source(source_path)
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        return TransmitterWrapper.set_javonet_working_directory(path)

package/Binaries/Python/javonet/core/transmitter/TransmitterWrapper.py

@@ -90,4 +90,23 @@ class TransmitterWrapper:
                 "Javonet set config source result: " + str(set_config_result) + ". Native error message: " + str(
                     error_message))
         else:
-            return set_config_result
+            return set_config_result
+
+    @staticmethod
+    def set_javonet_working_directory(path):
+        set_working_directory = TransmitterWrapper.python_lib.SetWorkingDirectory
+        set_working_directory.restype = c_int
+        set_working_directory.argtypes = [c_char_p]
+
+        set_working_directory_result = set_working_directory(path.encode('utf-8'))
+
+        if set_working_directory_result < 0:
+            get_native_error = TransmitterWrapper.python_lib.GetNativeError
+            get_native_error.restype = c_char_p
+            get_native_error.argtypes = []
+            error_message = get_native_error()
+            raise RuntimeError(
+                "Javonet set working directory result: " + str(set_working_directory_result) + ". Native error message: " + str(
+                    error_message))
+        else:
+            return set_working_directory_result

package/Binaries/Ruby/Linux/X64/core/transmitter/transmitter.rb

@@ -45,4 +45,14 @@ class Transmitter
       return set_config_result
     end
   end
+
+  def self.set_javonet_working_directory(config_path)
+    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
+    if set_working_directory_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
+    else
+      return set_working_directory_result
+    end
+  end
 end

package/Binaries/Ruby/Linux/X64/core/transmitter/transmitter_wrapper.rb

@@ -28,4 +28,5 @@ module TransmitterWrapper
   attach_function :Activate, [:pointer], :int
   attach_function :GetNativeError, [], :string
   attach_function :SetConfigSource, [:pointer], :int
+  attach_function :SetWorkingDirectory, [:pointer], :int
 end

package/Binaries/Ruby/MacOs/X64/core/transmitter/transmitter.rb

@@ -45,4 +45,14 @@ class Transmitter
       return set_config_result
     end
   end
+
+  def self.set_javonet_working_directory(config_path)
+    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
+    if set_working_directory_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
+    else
+      return set_working_directory_result
+    end
+  end
 end

package/Binaries/Ruby/MacOs/X64/core/transmitter/transmitter_wrapper.rb

@@ -28,4 +28,5 @@ module TransmitterWrapper
   attach_function :Activate, [:pointer], :int
   attach_function :GetNativeError, [], :string
   attach_function :SetConfigSource, [:pointer], :int
+  attach_function :SetWorkingDirectory, [:pointer], :int
 end

package/Binaries/Ruby/Windows/X64/core/transmitter/transmitter.rb

@@ -45,4 +45,14 @@ class Transmitter
       return set_config_result
     end
   end
+
+  def self.set_javonet_working_directory(config_path)
+    set_working_directory_result = TransmitterWrapper.SetWorkingDirectory(config_path)
+    if set_working_directory_result < 0
+      error_message = get_native_error
+      raise Exception.new "Javonet set working directory result: " + set_working_directory_result.to_s + ". Native error message: " + error_message
+    else
+      return set_working_directory_result
+    end
+  end
 end

package/Binaries/Ruby/Windows/X64/core/transmitter/transmitter_wrapper.rb

@@ -28,4 +28,5 @@ module TransmitterWrapper
   attach_function :Activate, [:pointer], :int
   attach_function :GetNativeError, [], :string
   attach_function :SetConfigSource, [:pointer], :int
+  attach_function :SetWorkingDirectory, [:pointer], :int
 end

package/Binaries/version.txt

@@ -1 +1 @@
-2.5.9
+2.5.11

package/addon/JavonetNodejsRuntimeAddon.cpp

@@ -1,10 +1,12 @@
 #include "JavonetNodejsRuntimeAddon.h"
 
 void InitializeTransmitter(const FunctionCallbackInfo<Value>& args) {
-	isolate = args.GetIsolate();
+    isolate = args.GetIsolate();
+    permanentContext.Reset(isolate, isolate->GetCurrentContext());
+
 	if (args.Length() != 1 || !args[0]->IsString()) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon InitializeTransmitter: Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -24,8 +26,8 @@ arch = "X86";
     nativeLibFullPath = nodeJsAddonPath + "\\Binaries\\Native\\Windows\\" + arch + "\\JavonetNodejsRuntimeNative.dll";
 	JavonetNodejsRuntimeNativeLibInstance = LoadLibraryA(nativeLibFullPath.c_str());
 	if (!JavonetNodejsRuntimeNativeLibInstance) {
-		char errorMessage[300];
-		sprintf_s(errorMessage, "%s %s", "Native library not found in: ", nativeLibFullPath.c_str());
+		char errorMessage[1024];
+		sprintf_s(errorMessage, "%s %s", "JavonetAddon InitializeTransmitter: Native library not found in: ", nativeLibFullPath.c_str());
 		isolate->ThrowException(Exception::Error(
 			String::NewFromUtf8(isolate, errorMessage,
 				NewStringType::kNormal).ToLocalChecked()));
@@ -57,7 +59,7 @@ arch = "X86";
 	if (JavonetNodejsRuntimeNativeLibInstance == NULL || error != NULL) {
 		char errorMessage[300];
 
-		sprintf(errorMessage, "%s %s \n%s %s", "Native library not found in: ", nativeLibFullPath.c_str(), "Error: ", error);
+		sprintf(errorMessage, "%s %s \n%s %s", "JavonetAddon InitializeTransmitter: Native library not found in: ", nativeLibFullPath.c_str(), "Error: ", error);
 		isolate->ThrowException(Exception::Error(
 			String::NewFromUtf8(isolate, errorMessage,
 				NewStringType::kNormal).ToLocalChecked()));
@@ -70,18 +72,24 @@ arch = "X86";
 	ActivateNative_Fn = (ActivateNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "Activate");
 	GetNativeErrorNative_Fn = (GetNativeErrorNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "GetNativeError");
 	SetConfigSourceNative_Fn = (SetConfigSourceNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetConfigSource");
+	SetWorkingDirectoryNative_Fn = (SetWorkingDirectoryNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetWorkingDirectory");
+	SetCallbackNative_Fn = (SetCallbackNative)getProccessAddress(JavonetNodejsRuntimeNativeLibInstance, "SetCallback");
+
 
 	if (SendCommandNative_Fn == nullptr ||
 		ReadResponseNative_Fn == nullptr ||
 		ActivateNative_Fn == nullptr ||
 		GetNativeErrorNative_Fn == nullptr||
-		SetConfigSourceNative_Fn == nullptr
+		SetConfigSourceNative_Fn == nullptr ||
+		SetWorkingDirectoryNative_Fn == nullptr ||
+		SetCallbackNative_Fn == nullptr
 		)
 	{
 		isolate->ThrowException(Exception::Error(
-			String::NewFromUtf8(isolate, "Exported functions not found in native library",
+			String::NewFromUtf8(isolate, "JavonetAddon InitializeTransmitter: Exported functions not found in native library",
 				NewStringType::kNormal).ToLocalChecked()));
 	}
+
 	bool result = false;
 	args.GetReturnValue().Set(result);
 	return;
@@ -89,8 +97,7 @@ arch = "X86";
 
 void SendCommand(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
-	context = isolate->GetCurrentContext();
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
 	messageArray = args[0].As<Uint8Array>();
 	messageArrayLen = messageArray->Length();
 	messageByteArray = new byte[messageArrayLen];
@@ -122,9 +129,9 @@ void SendCommand(const FunctionCallbackInfo<Value>& args)
 		args.GetReturnValue().Set(responseArray);
 	}
 	else if (responseArrayLen == 0) {
-		isolate->ThrowException(Exception::Error(
-			String::NewFromUtf8(isolate, "Response is empty",
-				NewStringType::kNormal).ToLocalChecked()));
+        isolate->ThrowException(Exception::Error(
+            String::NewFromUtf8(isolate, "JavonetAddon SendCommand: Response is empty",
+                NewStringType::kNormal).ToLocalChecked()));
 		args.GetReturnValue().Set(Number::New(isolate, responseArrayLen));
 		return;
 	}
@@ -142,13 +149,12 @@ void SendCommand(const FunctionCallbackInfo<Value>& args)
 
 void Activate(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
 	if (
 		args.Length() != 1 ||
 		!args[0]->IsString()
 		) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon Activate:  Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -170,10 +176,9 @@ void Activate(const FunctionCallbackInfo<Value>& args)
 
 void SetConfigSource(const FunctionCallbackInfo<Value>& args)
 {
-	isolate = args.GetIsolate();
 	if (args.Length() != 1 || !args[0]->IsString()) {
 		isolate->ThrowException(Exception::TypeError(
-			String::NewFromUtf8(isolate, "Wrong number of arguments or wrong argument types.",
+			String::NewFromUtf8(isolate, "JavonetAddon SetConfigSource: Wrong number of arguments or wrong argument types.",
 				NewStringType::kNormal).ToLocalChecked()));
 		return;
 	}
@@ -191,11 +196,104 @@ void SetConfigSource(const FunctionCallbackInfo<Value>& args)
 	return;
 }
 
+void SetJavonetWorkingDirectory(const FunctionCallbackInfo<Value>& args)
+{
+    if (args.Length() != 1 || !args[0]->IsString()) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon SetJavonetWorkingDirectory: Wrong number of arguments or wrong argument types.",
+                NewStringType::kNormal).ToLocalChecked()));
+        return;
+    }
+    v8::String::Utf8Value str(isolate, args[0]);
+    std::string workingDirectory(*str);
+    int result = SetWorkingDirectoryNative_Fn(workingDirectory.c_str());
+    args.GetReturnValue().Set(result);
+    if (result < 0) {
+        const char* errorMessage = GetNativeErrorNative_Fn();
+        std::string errorMessage2 = std::string("Javonet set working directory result: ") + std::to_string(result) + ". Native error message: " + std::string(errorMessage);
+        isolate->ThrowException(Exception::Error(
+            String::NewFromUtf8(isolate, errorMessage2.c_str(),
+                NewStringType::kNormal).ToLocalChecked()));
+    }
+    return;
+}
+
+std::vector<byte> nodejsRuntimeCallback(byte* messageByteArray, int32_t messageByteArrayLen) {
+    std::vector<byte> responseVector;
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
+
+    // Get the `sendCommand` method
+    v8::Local<v8::Object> receiverNativeLocal = v8::Local<v8::Object>::New(isolate, receiverNative);
+
+    v8::Local<v8::Value> sendCommandVal = receiverNativeLocal->Get(
+        isolate->GetCurrentContext(),
+        v8::String::NewFromUtf8(isolate, "sendCommand", v8::NewStringType::kNormal).ToLocalChecked()
+    ).ToLocalChecked();
+
+    if (!sendCommandVal->IsFunction()) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Cannot find sendCommand in NativeReceiver",
+                NewStringType::kNormal).ToLocalChecked()));
+        return responseVector;
+    }
+
+    v8::Local<v8::Function> sendCommandFunc = sendCommandVal.As<v8::Function>();
+
+    // Convert messageByteArray to Uint8Array
+    v8::Local<v8::ArrayBuffer> arrayBuffer = v8::ArrayBuffer::New(isolate, messageByteArrayLen);
+    memcpy(arrayBuffer->GetBackingStore()->Data(), messageByteArray, messageByteArrayLen);
+    v8::Local<v8::Uint8Array> uint8Array = v8::Uint8Array::New(arrayBuffer, 0, messageByteArrayLen);
+
+    // Call `sendCommand` with uint8Array
+    v8::Local<v8::Value> args[1] = { uint8Array };
+    v8::Local<v8::Value> result;
+
+    if (!sendCommandFunc->Call(context, receiverNativeLocal, 1, args).ToLocal(&result)) {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Error during calling callback",
+                NewStringType::kNormal).ToLocalChecked()));
+        return responseVector;
+    }
+
+    // Convert the result (assumed to be Int8Array) back to std::vector<byte>
+    if (result->IsInt8Array()) {
+        v8::Local<v8::Int8Array> resultArray = result.As<v8::Int8Array>();
+        size_t length = resultArray->Length();
+        responseVector.resize(length);
+        resultArray->CopyContents(responseVector.data(), length);
+    } else {
+        isolate->ThrowException(Exception::TypeError(
+            String::NewFromUtf8(isolate, "JavonetAddon nodejsRuntimeCallback:  Wrong return type",
+                NewStringType::kNormal).ToLocalChecked()));
+    }
+
+    return responseVector;
+}
+
+void SetReceiverNative(const v8::FunctionCallbackInfo<v8::Value>& args) {
+    v8::Local<v8::Context> context = v8::Local<v8::Context>::New(isolate, permanentContext);
+
+    if (args.Length() != 1 || !args[0]->IsObject()) {
+        isolate->ThrowException(v8::Exception::TypeError(
+            v8::String::NewFromUtf8(isolate, "JavonetAddon SetReceiverNative: Wrong number of arguments or wrong argument types", v8::NewStringType::kNormal).ToLocalChecked()
+        ));
+        return;
+    }
+
+    // store the receiver object
+    receiverNative.Reset(isolate, args[0].As<v8::Object>());
+
+    // set the callback in native
+    SetCallbackNative_Fn(nodejsRuntimeCallback);
+}
+
 void Initialize(Local<Object> exports) {
 	NODE_SET_METHOD(exports, "initializeTransmitter", InitializeTransmitter);
 	NODE_SET_METHOD(exports, "sendCommand", SendCommand);
 	NODE_SET_METHOD(exports, "activate", Activate);
 	NODE_SET_METHOD(exports, "setConfigSource", SetConfigSource);
+	NODE_SET_METHOD(exports, "setReceiverNative", SetReceiverNative);
+	NODE_SET_METHOD(exports, "setJavonetWorkingDirectory", SetJavonetWorkingDirectory);
 }
 
 NODE_MODULE(NODE_GYP_MODULE_NAME, Initialize)

package/addon/JavonetNodejsRuntimeAddon.h

@@ -1,6 +1,7 @@
 #include "node.h"
 #include "v8.h"
 #include <iostream>
+#include <vector>
 
 
 using v8::FunctionCallbackInfo;
@@ -16,6 +17,7 @@ using v8::Exception;
 using v8::Number;
 using v8::Uint32;
 using v8::Uint8Array;
+using v8::Persistent;
 
 #ifdef _WIN32
 #include "windows.h"
@@ -37,7 +39,8 @@ void* JavonetNodejsRuntimeNativeLibInstance{ nullptr };
 std::string nativeLibFullPath{ "" };
 
 Isolate* isolate = nullptr;
-Local<Context> context;
+Persistent<v8::Context> permanentContext; // permanent context
+v8::Persistent<v8::Object> receiverNative; // permanent receiver object
 
 Local<Uint8Array> messageArray;
 Local<Array> responseArray;
@@ -46,15 +49,22 @@ byte* messageByteArray{ nullptr };
 byte* responseByteArray{ nullptr };
 int messageArrayLen{ 0 };
 int responseArrayLen{ 0 };
+typedef std::vector<byte>(*nodejsCallback)(byte* messageByteArray, int32_t messageByteArrayLen); // type of the callback function
 
 typedef int(*SendCommandNative)(byte*, int);
 typedef int(*ReadResponseNative)(byte*, int);
 typedef int(*ActivateNative)(const char*);
 typedef const char*(*GetNativeErrorNative)();
 typedef int(*SetConfigSourceNative)(const char*);
+typedef int(*SetWorkingDirectoryNative)(const char*);
+typedef bool(*SetCallbackNative)(nodejsCallback); // type of the function to pass callback to the native library
 
 SendCommandNative SendCommandNative_Fn{ nullptr };
 ReadResponseNative ReadResponseNative_Fn{ nullptr };
 ActivateNative ActivateNative_Fn{ nullptr };
 GetNativeErrorNative GetNativeErrorNative_Fn{ nullptr };
-SetConfigSourceNative SetConfigSourceNative_Fn{ nullptr };
+SetConfigSourceNative SetConfigSourceNative_Fn{ nullptr };
+SetWorkingDirectoryNative SetWorkingDirectoryNative_Fn{ nullptr };
+SetCallbackNative SetCallbackNative_Fn{ nullptr }; // function to pass callback to the native library
+
+std::vector<byte> nodejsRuntimeCallback(byte* messageByteArray, int32_t messageByteArrayLen); // callback function to be passed to the native library