simplex-chat 0.2.1 → 6.5.0-beta.10

package/README.md

@@ -1,42 +1,129 @@
-# SimpleX Chat JavaScript client
+# SimpleX Chat Node.js library
 
-This is a TypeScript library that defines WebSocket API client for [SimpleX Chat terminal CLI](https://github.com/simplex-chat/simplex-chat/blob/stable/docs/CLI.md) that should be run as a WebSockets server on any port:
+This library replaced now deprecated [SimpleX Chat WebRTC TypeScript client](https://www.npmjs.com/package/@simplex-chat/webrtc-client).
 
-```bash
-simplex-chat -p 5225
+## Use cases
+
+- chat bots: you can implement any logic of connecting with and communicating with SimpleX Chat users. Using chat groups a chat bot can connect SimpleX Chat users with each other.
+- control of the equipment: e.g. servers or home automation. SimpleX Chat provides secure and authorised connections, so this is more secure than using rest APIs.
+- any scenarios of scripted message sending.
+- chat and chat-based interfaces.
+
+Please share your use cases and implementations.
+
+## Quick start: a simple bot
+
+```
+npm i simplex-chat@6.5.0-beta.10
 ```
 
-Client API provides types and functions to:
+Simple bot that replies with squares of numbers you send to it:
 
-- create and change user profile (although, in most cases you can do it manually, via SimpleX Chat terminal app).
-- create and accept invitations or connect with the contacts.
-- create and manage long-term user address, accepting connection requests automatically.
-- create, join and manage group.
-- send and receive files.
+```javascript
+(async () => {
+  const {bot} = await import("simplex-chat")
+  // if you are running from this GitHub repo:
+  // const {bot} = await import("../dist/index.js")
+  const [chat, _user, _address] = await bot.run({
+    profile: {displayName: "Squaring bot example", fullName: ""},
+    dbOpts: {type: "sqlite", filePrefix: "./squaring_bot"},
+    options: {
+      addressSettings: {welcomeMessage: "Send a number, I will square it.",
+    },
+    onMessage: async (ci, content) => {
+      const n = +content.text
+      const reply = typeof n === "number" && !isNaN(n)
+                    ? `${n} * ${n} = ${n * n}`
+                    : `this is not a number`
+      await chat.apiSendTextReply(ci, reply)
+    }
+  })
+})()
+```
 
-## Use cases
+If you installed this package as dependency, you can run this example with:
 
-- chat bots: you can implement any logic of connecting with and communicating with SimpleX Chat users. Using chat groups a chat bot can connect SimleX Chat users with each other.
-- control of the equipment: e.g. servers or home automation. SimpleX Chat provides secure and authorised connections, so this is more secure than using rest APIs.
+```sh
+node ./node_modules/simplex-chat/examples/squaring-bot-readme.js
+```
 
-Please share your use cases and implementations.
+If you run it on Mac, the first time it will take 20-30 seconds for MacOS to verify the library.
 
-## Quick start
+If you cloned this repository, you can:
 
 ```
-npm i simplex-chat
+cd ./packages/simplex-chat-nodejs
+npm install
 npm run build
+node ./examples/squaring-bot-readme.js
 ```
 
-See the example of a simple chat bot in [squaring-bot.js](./examples/squaring-bot.js):
+There is an example with more options in [./examples/squaring-bot.ts](./examples/squaring-bot.ts).
+
+You can run it with: `npx ts-node ./examples/squaring-bot.ts`
+
+## PostgreSQL backend
 
-- start `simplex-chat` as a server on port 5225: `simplex-chat -p 5225 -d test_db`
-- run chatbot: `node examples/squaring-bot`
-- connect to chatbot via SimpleX Chat client using the address of the chat bot
+By default, the package uses SQLite. To use PostgreSQL instead:
+
+```bash
+npm install simplex-chat --simplex_backend=postgres
+```
+
+Or persist the setting in `.npmrc`:
+
+```ini
+simplex_backend=postgres
+```
+
+### Prerequisites (PostgreSQL)
+
+- `libpq5` must be installed on the host system (`apt install libpq5` on Debian/Ubuntu)
+- PostgreSQL backend is only available for Linux x86_64
+- A PostgreSQL server accessible via connection string
+
+### Passing PostgreSQL connection
+
+The `DbConfig` type is a discriminated union — pick the variant that matches
+the backend you installed:
+
+```ts
+// SQLite (default)
+dbOpts: {type: "sqlite", filePrefix: "./data/bot"}
+// optional: encryptionKey: "<sqlcipher-key>"
+
+// PostgreSQL
+dbOpts: {
+  type: "postgres",
+  connectionString: "postgres://user:pass@host/db",
+  // schemaPrefix: "bot",  // optional — defaults to "simplex_v1"
+}
+```
 
 ## Documentation
 
-Please refer to the available client API in [client.ts](./src/client.ts).
+The library docs are [here](./docs/README.md).
+
+Library provides these modules:
+- [bot](./docs/Namespace.bot.md): 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.
+- [api](./docs/Namespace.api.md): 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.
+- [core](./docs/Namespace.core.md): 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.
+- [util](./docs/Namespace.util.md): useful functions for chat events and types.
+
+
+This library uses [@simplex-chat/types](https://www.npmjs.com/package/@simplex-chat/types) package with auto-generated [bot API types](../../bots/api/README.md).
+
+## Supported chat functions
+
+Library provides types and functions to:
+
+- create and change user profile (although, in most cases you can do it manually, via SimpleX Chat terminal app).
+- create and accept invitations or connect with the contacts.
+- create and manage long-term user address, accepting connection requests automatically.
+- send, receive, delete and update messages, and add message reactions.
+- create, join and manage group.
+- send and receive files.
+- etc.
 
 ## License
 

package/binding.gyp

@@ -0,0 +1,50 @@
+{
+  "targets": [
+    {
+      "target_name": "simplex",
+      "sources": [ "cpp/simplex.cc" ],
+      "include_dirs": [
+        "<!@(node -p \"require('node-addon-api').include\")"
+      ],
+      "dependencies": [
+        "<!(node -p \"require('node-addon-api').gyp\")"
+      ],
+      "cflags!": [ "-fno-exceptions" ],
+      "cflags_cc!": [ "-fno-exceptions" ],
+      "defines": [ "NAPI_DISABLE_CPP_EXCEPTIONS" ],
+      "conditions": [
+        ["OS=='mac'", {
+          "libraries": [
+            "-L<(module_root_dir)/libs",
+            "-lsimplex"
+          ],
+          "xcode_settings": {
+            "OTHER_LDFLAGS": [
+              "-Wl,-rpath,@loader_path/../../libs"
+            ]
+          }
+        }],
+        ["OS=='linux'", {
+          "libraries": [
+            "-L<(module_root_dir)/libs",
+            "-lsimplex"
+          ],
+          "ldflags": [
+            "-Wl,-rpath,'$$ORIGIN'/../../libs"
+          ]
+        }],
+        ["OS=='win'", {
+          "libraries": [
+            "<(module_root_dir)/libs/libsimplex.lib"
+          ],
+          "copies": [{
+            "destination": "<(PRODUCT_DIR)",
+            "files": [
+              "<(module_root_dir)/libs/*"
+            ]
+          }]
+        }]
+      ]
+    }
+  ]
+}

package/cpp/simplex.cc

@@ -0,0 +1,426 @@
+#include <napi.h>
+#include <sstream>
+#include <string>
+#include <functional>
+#include <cstdlib>
+#include "simplex.h"
+
+namespace simplex {
+
+using namespace Napi;
+
+void haskell_init() {
+#ifdef _WIN32
+  // non-moving GC is broken on windows with GHC 9.4-9.6.3
+  int argc = 5;
+  const char *argv[] = {
+      "simplex",
+      "+RTS",  // requires `hs_init_with_rtsopts`
+      "-A64m", // chunk size for new allocations
+      "-H64m", // initial heap size
+      "--install-signal-handlers=no",
+      nullptr};
+#else
+  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};
+#endif
+  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 */