simplex-chat 6.5.0-beta.4.1 → 6.5.0-beta.4.2

package/README.md

@@ -14,7 +14,7 @@ Please share your use cases and implementations.
 ## Quick start: a simple bot
 
 ```
-npm i simplex-chat@6.5.0-beta.4
+npm i simplex-chat@6.5.0-beta.4.2
 ```
 
 Simple bot that replies with squares of numbers you send to it:

package/cpp/simplex.cc

@@ -0,0 +1,414 @@
+#include <napi.h>
+#include <sstream>
+#include <string>
+#include <functional>
+#include <cstdlib>
+#include "simplex.h"
+
+namespace simplex {
+
+using namespace Napi;
+
+void haskell_init() {
+  int argc = 6;
+  const char *argv[] = {
+      "simplex",
+      "+RTS",  // requires `hs_init_with_rtsopts`
+      "-A64m", // chunk size for new allocations
+      "-H64m", // initial heap size
+      "-xn",   // non-moving GC
+      "--install-signal-handlers=no",
+      nullptr};
+  char **pargv = const_cast<char **>(argv);
+  hs_init_with_rtsopts(&argc, &pargv);
+}
+
+class ResultAsyncWorker : public AsyncWorker {
+ public:
+  using ExecuteFn = std::function<void(ResultAsyncWorker*)>;
+  using ResultProcessor = std::function<void(ResultAsyncWorker*, Napi::Env)>;
+
+  ResultAsyncWorker(Function& callback, ExecuteFn execute_fn, ResultProcessor result_processor = nullptr)
+      : AsyncWorker(callback), execute_fn_(std::move(execute_fn)), result_processor_(std::move(result_processor)) {}
+
+  void Execute() override {
+    execute_fn_(this);
+  }
+
+  void OnOK() override {
+    HandleScope scope(Env());
+    if (result_processor_) {
+      result_processor_(this, Env());
+    } else {
+      Callback().Call({Env().Null(), String::New(Env(), result_)});
+    }
+  }
+
+  void OnError(const Error& e) override {
+    HandleScope scope(Env());
+    Callback().Call({e.Value(), Env().Undefined()});
+  }
+
+  void SetResult(std::string result) {
+    result_ = std::move(result);
+  }
+
+  void SetWorkerError(const std::string& msg) {
+    SetError(msg);
+  }
+
+  const std::string& GetStringResult() const {
+    return result_;
+  }
+
+  void SetCtrl(uintptr_t ctrl) {
+    ctrl_ = ctrl;
+  }
+
+  uintptr_t GetCtrl() const {
+    return ctrl_;
+  }
+
+ protected:
+  std::string result_;
+  uintptr_t ctrl_ = 0;
+
+ private:
+  ExecuteFn execute_fn_;
+  ResultProcessor result_processor_;
+};
+
+class BinaryAsyncWorker : public AsyncWorker {
+ public:
+  using ExecuteFn = std::function<void(BinaryAsyncWorker*)>;
+
+  BinaryAsyncWorker(Function& callback, ExecuteFn execute_fn)
+      : AsyncWorker(callback), execute_fn_(std::move(execute_fn)) {}
+
+  void Execute() override {
+    execute_fn_(this);
+  }
+
+  void OnOK() override {
+    HandleScope scope(Env());
+    if (original_buf == nullptr || binary_len == 0) {
+      Callback().Call({Env().Null(), Env().Undefined()});
+      return;
+    }
+    char* data_ptr = original_buf + 5;
+    auto finalizer = [](Napi::Env env, char* finalize_data, char* orig) {
+      free(orig);
+    };
+    Napi::Buffer<char> buffer = Napi::Buffer<char>::New(Env(), data_ptr, binary_len, finalizer, original_buf);
+    Callback().Call({Env().Null(), buffer});
+  }
+
+  void OnError(const Error& e) override {
+    HandleScope scope(Env());
+    Callback().Call({e.Value(), Env().Undefined()});
+  }
+
+  void SetWorkerError(const std::string& msg) {
+    SetError(msg);
+  }
+
+  char* original_buf = nullptr;
+  size_t binary_len = 0;
+
+ private:
+  ExecuteFn execute_fn_;
+};
+
+// Helper for converting chat_ctrl pointer to BigInt
+Napi::BigInt ToChatCtrlBigInt(Napi::Env env, uintptr_t ctrl) {
+  return Napi::BigInt::New(env, static_cast<uint64_t>(ctrl));
+}
+
+// Helper for converting BigInt to chat_ctrl pointer
+chat_ctrl FromChatCtrlBigInt(const Napi::Value& value) {
+  Napi::Env env = value.Env();
+  if (!value.IsBigInt()) {
+    Napi::TypeError::New(env, "Expected BigInt for ctrl").ThrowAsJavaScriptException();
+    return nullptr;
+  }
+  Napi::BigInt big = value.As<Napi::BigInt>();
+  bool lossless;
+  uint64_t val = big.Uint64Value(&lossless);
+  if (!lossless) {
+    Napi::TypeError::New(env, "BigInt too large for ctrl").ThrowAsJavaScriptException();
+    return nullptr;
+  }
+  return reinterpret_cast<chat_ctrl>(val);
+}
+
+// Helper for handling common C result patterns (no empty check)
+void HandleCResult(ResultAsyncWorker* worker, char* c_res, const std::string& func_name) {
+  if (c_res == nullptr) {
+    worker->SetWorkerError(func_name + " failed");
+    return;
+  }
+  std::string res = c_res;
+  free(c_res);
+  worker->SetResult(res);
+}
+
+Napi::Promise CreatePromiseAndCallback(Env env, Function& cb_out) {
+  Promise::Deferred deferred = Promise::Deferred::New(env);
+  cb_out = Function::New(env, [deferred](const CallbackInfo& args) {
+    if (!args[0].IsNull() && !args[0].IsUndefined()) {
+      deferred.Reject(args[0]);
+    } else {
+      deferred.Resolve(args[1]);
+    }
+  });
+  return deferred.Promise();
+}
+
+// Common result processors
+ResultAsyncWorker::ResultProcessor MigrateResultProcessor() {
+  return [](ResultAsyncWorker* worker, Napi::Env env) {
+    Napi::Array arr = Napi::Array::New(env, 2);
+    arr.Set(0u, ToChatCtrlBigInt(env, worker->GetCtrl()));
+    arr.Set(1u, Napi::String::New(env, worker->GetStringResult()));
+    worker->Callback().Call({env.Null(), arr});
+  };
+}
+
+// Refactored functions using common patterns
+
+Value ChatMigrateInit(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 3 || !args[0].IsString() || !args[1].IsString() || !args[2].IsString()) {
+    TypeError::New(env, "Expected three string arguments").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  std::string path = args[0].As<String>().Utf8Value();
+  std::string key = args[1].As<String>().Utf8Value();
+  std::string confirm = args[2].As<String>().Utf8Value();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [path, key, confirm](ResultAsyncWorker* worker) {
+    chat_ctrl ctrl = nullptr;
+    char* c_res = chat_migrate_init(path.c_str(), key.c_str(), confirm.c_str(), &ctrl);
+    worker->SetCtrl(reinterpret_cast<uintptr_t>(ctrl));
+    HandleCResult(worker, c_res, "chat_migrate_init");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn), MigrateResultProcessor());
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatCloseStore(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 1 || !args[0].IsBigInt()) {
+    TypeError::New(env, "Expected bigint (ctrl)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [ctrl](ResultAsyncWorker* worker) {
+    char* c_res = chat_close_store(ctrl);
+    HandleCResult(worker, c_res, "chat_close_store");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatSendCmd(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 2 || !args[0].IsBigInt() || !args[1].IsString()) {
+    TypeError::New(env, "Expected bigint (ctrl) and string (cmd)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+  std::string cmd = args[1].As<String>().Utf8Value();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [ctrl, cmd](ResultAsyncWorker* worker) {
+    char* c_res = chat_send_cmd(ctrl, cmd.c_str());
+    HandleCResult(worker, c_res, "chat_send_cmd");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatRecvMsgWait(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 2 || !args[0].IsBigInt() || !args[1].IsNumber()) {
+    TypeError::New(env, "Expected bigint (ctrl), number (wait)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+  int wait = static_cast<int>(args[1].As<Number>().Int32Value());
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [ctrl, wait](ResultAsyncWorker* worker) {
+    char* c_res = chat_recv_msg_wait(ctrl, wait);
+    HandleCResult(worker, c_res, "chat_recv_msg_wait");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatWriteFile(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 3 || !args[0].IsBigInt() || !args[1].IsString() || !args[2].IsArrayBuffer()) {
+    TypeError::New(env, "Expected bigint (ctrl), string (path), ArrayBuffer").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+  std::string path = args[1].As<String>().Utf8Value();
+  ArrayBuffer ab = args[2].As<ArrayBuffer>();
+  char* data = static_cast<char*>(ab.Data());
+  size_t len = ab.ByteLength();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [ctrl, path, ab, data, len](ResultAsyncWorker* worker) {
+    (void)ab; // to keep ArrayBuffer alive
+    char* c_res = chat_write_file(ctrl, path.c_str(), data, static_cast<int>(len));
+    HandleCResult(worker, c_res, "chat_write_file");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatReadFile(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 3 || !args[0].IsString() || !args[1].IsString() || !args[2].IsString()) {
+    TypeError::New(env, "Expected three strings (path, key, nonce)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  std::string path = args[0].As<String>().Utf8Value();
+  std::string key = args[1].As<String>().Utf8Value();
+  std::string nonce = args[2].As<String>().Utf8Value();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [path, key, nonce](BinaryAsyncWorker* worker) {
+    char* buf = chat_read_file(path.c_str(), key.c_str(), nonce.c_str());
+    if (buf == nullptr) {
+      worker->SetWorkerError("chat_read_file failed");
+      return;
+    }
+    char status = buf[0];
+    if (status == 1) {
+      std::string err = buf + 1;
+      free(buf);
+      worker->SetWorkerError(err);
+      return;
+    } else if (status == 0) {
+      uint32_t len = *(uint32_t*)(buf + 1);
+      worker->original_buf = buf;
+      worker->binary_len = len;
+    } else {
+      free(buf);
+      worker->SetWorkerError("Unexpected status from chat_read_file");
+      return;
+    }
+  };
+
+  BinaryAsyncWorker* worker = new BinaryAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatEncryptFile(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 3 || !args[0].IsBigInt() || !args[1].IsString() || !args[2].IsString()) {
+    TypeError::New(env, "Expected bigint (ctrl), two strings (fromPath, toPath)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  chat_ctrl ctrl = FromChatCtrlBigInt(args[0]);
+  std::string fromPath = args[1].As<String>().Utf8Value();
+  std::string toPath = args[2].As<String>().Utf8Value();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [ctrl, fromPath, toPath](ResultAsyncWorker* worker) {
+    char* c_res = chat_encrypt_file(ctrl, fromPath.c_str(), toPath.c_str());
+    HandleCResult(worker, c_res, "chat_encrypt_file");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Value ChatDecryptFile(const CallbackInfo& args) {
+  Env env = args.Env();
+  if (args.Length() < 4 || !args[0].IsString() || !args[1].IsString() || !args[2].IsString() || !args[3].IsString()) {
+    TypeError::New(env, "Expected four strings (fromPath, key, nonce, toPath)").ThrowAsJavaScriptException();
+    return env.Undefined();
+  }
+
+  std::string fromPath = args[0].As<String>().Utf8Value();
+  std::string key = args[1].As<String>().Utf8Value();
+  std::string nonce = args[2].As<String>().Utf8Value();
+  std::string toPath = args[3].As<String>().Utf8Value();
+
+  Function cb;
+  Promise promise = CreatePromiseAndCallback(env, cb);
+
+  auto execute_fn = [fromPath, key, nonce, toPath](ResultAsyncWorker* worker) {
+    char* c_res = chat_decrypt_file(fromPath.c_str(), key.c_str(), nonce.c_str(), toPath.c_str());
+    HandleCResult(worker, c_res, "chat_decrypt_file");
+  };
+
+  ResultAsyncWorker* worker = new ResultAsyncWorker(cb, std::move(execute_fn));
+  worker->Queue();
+
+  return promise;
+}
+
+Object Init(Env env, Object exports) {
+  haskell_init();
+  exports.Set("chat_migrate_init", Function::New(env, ChatMigrateInit));
+  exports.Set("chat_close_store", Function::New(env, ChatCloseStore));
+  exports.Set("chat_send_cmd", Function::New(env, ChatSendCmd));
+  exports.Set("chat_recv_msg_wait", Function::New(env, ChatRecvMsgWait));
+  exports.Set("chat_write_file", Function::New(env, ChatWriteFile));
+  exports.Set("chat_read_file", Function::New(env, ChatReadFile));
+  exports.Set("chat_encrypt_file", Function::New(env, ChatEncryptFile));
+  exports.Set("chat_decrypt_file", Function::New(env, ChatDecryptFile));
+  return exports;
+}
+
+NODE_API_MODULE(simplex, Init)
+
+}

package/cpp/simplex.h

@@ -0,0 +1,46 @@
+//
+//  simplex.h
+//  SimpleX
+//
+//  Created by Evgeny on 30/05/2022.
+//  Copyright © 2022 SimpleX Chat. All rights reserved.
+//
+
+#ifndef SimpleX_h
+#define SimpleX_h
+
+extern "C" void hs_init(int argc, char **argv[]);
+extern "C" void hs_init_with_rtsopts(int * argc, char **argv[]);
+
+typedef long* chat_ctrl;
+
+// the last parameter is used to return the pointer to chat controller
+extern "C" char *chat_migrate_init(const char *path, const char *key, const char *confirm, chat_ctrl *ctrl);
+extern "C" char *chat_close_store(chat_ctrl ctrl);
+extern "C" char *chat_reopen_store(chat_ctrl ctrl);
+extern "C" char *chat_send_cmd(chat_ctrl ctrl, const char *cmd);
+extern "C" char *chat_recv_msg_wait(chat_ctrl ctrl, const int wait);
+extern "C" char *chat_parse_markdown(const char *str);
+extern "C" char *chat_parse_server(const char *str);
+extern "C" char *chat_password_hash(const char *pwd, const char *salt);
+extern "C" char *chat_valid_name(const char *name);
+extern "C" int chat_json_length(const char *str);
+extern "C" char *chat_encrypt_media(chat_ctrl ctrl, const char *key, const char *frame, const int len);
+extern "C" char *chat_decrypt_media(const char *key, const char *frame, const int len);
+
+// chat_write_file returns null-terminated string with JSON of WriteFileResult
+extern "C" char *chat_write_file(chat_ctrl ctrl, const char *path, const char *data, const int len);
+
+// chat_read_file returns a buffer with:
+// result status (1 byte), then if
+//   status == 0 (success): buffer length (uint32, 4 bytes), buffer of specified length.
+//   status == 1 (error): null-terminated error message string.
+extern "C" char *chat_read_file(const char *path, const char *key, const char *nonce);
+
+// chat_encrypt_file returns null-terminated string with JSON of WriteFileResult
+extern "C" char *chat_encrypt_file(chat_ctrl ctrl, const char *fromPath, const char *toPath);
+
+// chat_decrypt_file returns null-terminated string with the error message
+extern "C" char *chat_decrypt_file(const char *fromPath, const char *key, const char *nonce, const char *toPath);
+
+#endif /* simplex_h */

package/docs/Namespace.api.md

@@ -0,0 +1,32 @@
+[**simplex-chat**](README.md)
+
+***
+
+[simplex-chat](README.md) / api
+
+# api
+
+An API to send chat commands and receive chat events to/from chat core.
+You need to use it in bot event handlers, and for any other use cases.
+
+## Enumerations
+
+- [ConnReqType](api.Enumeration.ConnReqType.md)
+
+## Classes
+
+- [ChatApi](api.Class.ChatApi.md)
+- [ChatCommandError](api.Class.ChatCommandError.md)
+
+## Interfaces
+
+- [BotAddressSettings](api.Interface.BotAddressSettings.md)
+
+## Type Aliases
+
+- [EventSubscriberFunc](api.TypeAlias.EventSubscriberFunc.md)
+- [EventSubscribers](api.TypeAlias.EventSubscribers.md)
+
+## Variables
+
+- [defaultBotAddressSettings](api.Variable.defaultBotAddressSettings.md)

package/docs/Namespace.bot.md

@@ -0,0 +1,20 @@
+[**simplex-chat**](README.md)
+
+***
+
+[simplex-chat](README.md) / bot
+
+# bot
+
+A simple declarative API to run a chat-bot with a single function call.
+It automates creating and updating of the bot profile, address and bot commands shown in the app UI.
+
+## Interfaces
+
+- [BotConfig](bot.Interface.BotConfig.md)
+- [BotDbOpts](bot.Interface.BotDbOpts.md)
+- [BotOptions](bot.Interface.BotOptions.md)
+
+## Functions
+
+- [run](bot.Function.run.md)

package/docs/Namespace.core.md

@@ -0,0 +1,48 @@
+[**simplex-chat**](README.md)
+
+***
+
+[simplex-chat](README.md) / core
+
+# core
+
+A low level API to the core library - the same that is used in desktop clients.
+You are unlikely to ever need to use this module directly.
+
+## Namespaces
+
+- [DBMigrationError](core.Namespace.DBMigrationError.md)
+- [MigrationError](core.Namespace.MigrationError.md)
+- [MTRError](core.Namespace.MTRError.md)
+
+## Enumerations
+
+- [MigrationConfirmation](core.Enumeration.MigrationConfirmation.md)
+
+## Classes
+
+- [ChatAPIError](core.Class.ChatAPIError.md)
+- [ChatInitError](core.Class.ChatInitError.md)
+
+## Interfaces
+
+- [APIResult](core.Interface.APIResult.md)
+- [CryptoArgs](core.Interface.CryptoArgs.md)
+- [UpMigration](core.Interface.UpMigration.md)
+
+## Type Aliases
+
+- [DBMigrationError](core.TypeAlias.DBMigrationError.md)
+- [MigrationError](core.TypeAlias.MigrationError.md)
+- [MTRError](core.TypeAlias.MTRError.md)
+
+## Functions
+
+- [chatCloseStore](core.Function.chatCloseStore.md)
+- [chatDecryptFile](core.Function.chatDecryptFile.md)
+- [chatEncryptFile](core.Function.chatEncryptFile.md)
+- [chatMigrateInit](core.Function.chatMigrateInit.md)
+- [chatReadFile](core.Function.chatReadFile.md)
+- [chatRecvMsgWait](core.Function.chatRecvMsgWait.md)
+- [chatSendCmd](core.Function.chatSendCmd.md)
+- [chatWriteFile](core.Function.chatWriteFile.md)

package/docs/Namespace.util.md

@@ -0,0 +1,25 @@
+[**simplex-chat**](README.md)
+
+***
+
+[simplex-chat](README.md) / util
+
+# util
+
+Useful functions for chat events and types.
+
+## Interfaces
+
+- [BotCommand](util.Interface.BotCommand.md)
+
+## Functions
+
+- [botAddressSettings](util.Function.botAddressSettings.md)
+- [chatInfoName](util.Function.chatInfoName.md)
+- [chatInfoRef](util.Function.chatInfoRef.md)
+- [ciBotCommand](util.Function.ciBotCommand.md)
+- [ciContentText](util.Function.ciContentText.md)
+- [contactAddressStr](util.Function.contactAddressStr.md)
+- [fromLocalProfile](util.Function.fromLocalProfile.md)
+- [reactionText](util.Function.reactionText.md)
+- [senderName](util.Function.senderName.md)

package/docs/README.md

@@ -0,0 +1,12 @@
+**simplex-chat**
+
+***
+
+# simplex-chat
+
+## Namespaces
+
+- [api](Namespace.api.md)
+- [bot](Namespace.bot.md)
+- [core](Namespace.core.md)
+- [util](Namespace.util.md)