simplex-chat 0.3.0 → 6.5.0-beta.10

package/src/bot.ts

@@ -0,0 +1,214 @@
+import {T} from "@simplex-chat/types"
+import * as api from "./api"
+import * as core from "./core"
+import * as util from "./util"
+import equal = require("fast-deep-equal")
+
+export type BotDbOpts = api.DbConfig & {
+  confirmMigrations?: core.MigrationConfirmation
+}
+
+export interface BotOptions {
+  createAddress?: boolean
+  updateAddress?: boolean
+  updateProfile?: boolean
+  addressSettings?: api.BotAddressSettings
+  allowFiles?: boolean
+  commands?: T.ChatBotCommand[] // commands to show in client UI
+  useBotProfile?: boolean // create profile not marked as a bot, with default preferences  
+  logContacts?: boolean
+  logNetwork?: boolean
+}
+
+const defaultOpts: Required<BotOptions> = {
+  createAddress: true,
+  updateAddress: true,
+  updateProfile: true,
+  addressSettings: api.defaultBotAddressSettings,
+  allowFiles: false,
+  commands: [],
+  useBotProfile: true,
+  logContacts: true,
+  logNetwork: false
+}
+
+export interface BotConfig {
+  profile: T.Profile,
+  dbOpts: BotDbOpts,
+  options: BotOptions,
+  onMessage?: (chatItem: T.AChatItem, content: T.MsgContent) => void | Promise<void>,
+  // command handlers can be different from commands to be shown in client UI
+  onCommands?: {[K in string]?: ((chatItem: T.AChatItem, command: util.BotCommand) => void | Promise<void>)},
+  // If you use `onMessage` and to subscribe "newChatItems" event, exclude content messages from processing
+  // If you use `onCommands` and to subscribe "newChatItems" event, exclude commands from processing
+  events?: api.EventSubscribers
+}
+
+export async function run({profile, dbOpts, options = defaultOpts, onMessage, onCommands = {}, events = {}}: BotConfig): Promise<[api.ChatApi, T.User, T.UserContactLink | undefined]> {
+  const bot = await api.ChatApi.init(dbOpts, dbOpts.confirmMigrations || core.MigrationConfirmation.YesUp)
+  const opts = fullOptions(options)
+  if (onMessage) subscribeMessages(bot, onMessage)
+  if (Object.keys(onCommands).length > 0) subscribeCommands(bot, onCommands)
+  if (Object.keys(events).length > 0) bot.on(events)
+  subscribeLogEvents(bot, opts)
+  const botProfile = mkBotProfile(profile, opts)
+  const user = await createBotUser(bot, botProfile)
+  await bot.startChat()
+  const address = await createOrUpdateAddress(bot, user, opts)
+  if (address) {
+    const addressLink = util.contactAddressStr(address.connLinkContact)
+    console.log(`Bot address: ${addressLink}`)
+    if (opts.useBotProfile) botProfile.contactLink = addressLink
+  }
+  await updateBotUserProfile(bot, user, botProfile, opts)  
+  return [bot, user, address]
+}
+
+function fullOptions(options: BotOptions): Required<BotOptions> {
+  const opts =  {
+    createAddress: options.createAddress ?? defaultOpts.createAddress,
+    updateAddress: options.updateAddress ?? defaultOpts.updateAddress,
+    updateProfile: options.updateProfile ?? defaultOpts.updateProfile,
+    addressSettings: options.addressSettings ?? defaultOpts.addressSettings,
+    allowFiles: options.allowFiles ?? defaultOpts.allowFiles,
+    commands: options.commands ?? defaultOpts.commands,
+    useBotProfile: options.useBotProfile ?? defaultOpts.useBotProfile,
+    logContacts: options.logContacts ?? defaultOpts.logContacts,
+    logNetwork: options.logNetwork ?? defaultOpts.logNetwork
+  }
+  const welcomeMessage = opts.addressSettings.welcomeMessage ?? defaultOpts.addressSettings.welcomeMessage
+  opts.addressSettings = {
+    autoAccept: opts.addressSettings.autoAccept ?? defaultOpts.addressSettings.autoAccept,
+    welcomeMessage: typeof welcomeMessage === "string" ? {type: "text", text: welcomeMessage} : welcomeMessage,
+    businessAddress: opts.addressSettings.businessAddress ?? defaultOpts.addressSettings.businessAddress
+  }
+  return opts
+}
+
+function mkBotProfile(profile: T.Profile, opts: Required<BotOptions>): T.Profile {
+  if (opts.useBotProfile) {
+    const prefs = profile.preferences || {}
+    if (prefs.files || prefs.calls || prefs.voice || prefs.commands) {
+      console.log("Option useBotProfile is enabled and profile preferences used for files, calls, voice or commands, exiting")
+      process.exit()
+    }
+    prefs.files = {allow: opts.allowFiles ? T.FeatureAllowed.Yes : T.FeatureAllowed.No}
+    prefs.calls = {allow: T.FeatureAllowed.No}
+    prefs.voice = {allow: T.FeatureAllowed.No}
+    prefs.commands = opts.commands
+    profile.preferences = prefs
+    profile.peerType = T.ChatPeerType.Bot
+  } else if (opts.commands.length > 0) {
+      console.log("Option useBotProfile is disabled and commands are passed, exiting")
+      process.exit()
+  }
+  return profile 
+}
+
+function subscribeMessages(bot: api.ChatApi, onMessage: (chatItem: T.AChatItem, content: T.MsgContent) => void | Promise<void>) {
+  bot.on("newChatItems", async ({chatItems}) => {
+    for (const ci of chatItems) {
+      if (ci.chatItem.content.type === "rcvMsgContent") {
+        try {
+          const p = onMessage(ci, ci.chatItem.content.msgContent)
+          if (p instanceof Promise) await p
+        } catch (e) {
+          console.log("message processing error", e)
+        }
+      }
+    }
+  })
+}
+
+function subscribeCommands(bot: api.ChatApi, commands: {[K in string]?: ((chatItem: T.AChatItem, command: util.BotCommand) => void | Promise<void>)}) {
+  bot.on("newChatItems", async (evt) => {
+    for (const ci of evt.chatItems) {
+      const cmd = util.ciBotCommand(ci.chatItem)
+      if (cmd) {
+        const cmdFunc = commands[cmd.keyword] || commands[""]
+        if (cmdFunc) {
+          try {
+            const p = cmdFunc(ci, cmd)
+            if (p instanceof Promise) await p
+          } catch(e) {
+            console.log(`${cmd} command processing error`, e)
+          }
+        }
+      }
+    }
+  })    
+}
+
+function subscribeLogEvents(bot: api.ChatApi, opts: Required<BotOptions>) {
+  if (opts.logContacts) {
+    bot.on({
+      "contactConnected": ({contact}) => console.log(`${contact.profile.displayName} connected`),
+      "contactDeletedByContact": ({contact}) => console.log(`${contact.profile.displayName} deleted connection with bot`)
+    })      
+  }
+  if (opts.logNetwork) {
+    bot.on({
+      "hostConnected": ({transportHost}) => console.log(`connected server ${transportHost}`),
+      "hostDisconnected": ({transportHost}) => console.log(`diconnected server ${transportHost}`),
+      "subscriptionStatus": ({subscriptionStatus, connections}) => console.log(`${connections.length} subscription(s) ${subscriptionStatus.type}`)
+    })          
+  }
+}
+
+async function createBotUser(bot: api.ChatApi, profile: T.Profile): Promise<T.User> {
+  let user = await bot.apiGetActiveUser()
+  if (!user) {
+    console.log("No active user in database, creating...")
+    user = await bot.apiCreateActiveUser(profile)
+  }
+  console.log("Bot user: ", user.profile.displayName)
+  return user    
+}
+    
+async function createOrUpdateAddress(bot: api.ChatApi, user: T.User, opts: Required<BotOptions>): Promise<T.UserContactLink | undefined> {
+  const {userId} = user
+  let address = await bot.apiGetUserAddress(userId)
+  if (!address) {
+    if (opts.createAddress) {
+      console.log("Bot has no address, creating...")
+      await bot.apiCreateUserAddress(userId)
+      address = await bot.apiGetUserAddress(userId)
+      if (!address) {
+        console.log("Failed reading created user address, exiting")
+        process.exit()
+      }
+    } else {
+      console.log("Warning: bot has no address")
+      return
+    }
+  }
+  
+  const addressSettings = opts.addressSettings || defaultOpts.addressSettings
+  if (!equal(util.botAddressSettings(address), addressSettings)) {
+    if (opts.updateAddress) {
+      console.log("Bot address settings changed, updating...")
+      await bot.apiSetAddressSettings(userId, addressSettings)
+    } else {
+      console.log("Bot address settings changed")
+    }
+  }
+  
+  return address    
+}
+
+async function updateBotUserProfile(bot: api.ChatApi, user: T.User, profile: T.Profile, opts: Required<BotOptions>): Promise<void> {
+  const {userId} = user
+  if (!equal(util.fromLocalProfile(user.profile), profile)) {
+    if (opts.updateProfile) {
+      console.log("Bot profile changed, updating...")
+      const summary = await bot.apiUpdateProfile(userId, profile)
+      console.log(
+        summary
+        ? `Bot profile updated: ${summary.updateSuccesses} updated contact(s), ${summary.updateFailures} failed contact update(s).`
+        : "Unexpected: profile did not change!"
+      )
+    } else {
+      console.log("Bot profile changed")
+    }
+  }  
+}

package/src/core.ts

@@ -0,0 +1,210 @@
+import {ChatEvent, ChatResponse, T} from "@simplex-chat/types"
+import * as simplex from "./simplex"
+
+/**
+ * Initialize chat controller
+ */
+export async function chatMigrateInit(dbPath: string, dbKey: string, confirm: MigrationConfirmation): Promise<bigint> {
+  const [ctrl, res] = await simplex.chat_migrate_init(dbPath, dbKey, confirm)
+  const json = JSON.parse(res)
+  if (json.type === 'ok') return ctrl
+  throw new ChatInitError("Database or migration error (see dbMigrationError property)", json as DBMigrationError)
+}
+
+/**
+ * Close chat store
+ */
+export async function chatCloseStore(ctrl: bigint): Promise<void> {
+  const res = await simplex.chat_close_store(ctrl)
+  if (res !== "") throw new Error(res)
+}
+
+/**
+ * Send chat command as string
+ */
+export async function chatSendCmd(ctrl: bigint, cmd: string): Promise<ChatResponse> {
+  const res = await simplex.chat_send_cmd(ctrl, cmd)
+  const json = JSON.parse(res) as APIResult<ChatResponse>
+  // console.log(cmd.slice(0, 16), json.result?.type || json.error)
+  if (typeof json.result === 'object') return json.result
+  if (typeof json.error === 'object') throw new ChatAPIError("Chat command error (see chatError property)", json.error as T.ChatError)
+  throw new ChatAPIError("Invalid chat command result")
+}
+
+/**
+ * Receive chat event
+ */
+export async function chatRecvMsgWait(ctrl: bigint, wait: number): Promise<ChatEvent | undefined> {
+  const res = await simplex.chat_recv_msg_wait(ctrl, wait)
+  if (res === "") return undefined
+  const json = JSON.parse(res) as APIResult<ChatEvent>
+  // if (json.result) console.log("event", json.result.type)
+  if (typeof json.result === 'object') return json.result
+  if (typeof json.error === 'object') throw new ChatAPIError("Chat event error (see chatError property)", json.error as T.ChatError)
+  throw new ChatAPIError("Invalid chat event")  
+}
+
+/**
+ * Write buffer to encrypted file
+ */
+export async function chatWriteFile(ctrl: bigint, path: string, buffer: ArrayBuffer): Promise<CryptoArgs> {
+  const res = await simplex.chat_write_file(ctrl, path, buffer)
+  return cryptoArgsResult(res)
+}
+
+/**
+ * Read buffer from encrypted file
+ */
+export async function chatReadFile(path: string, {fileKey, fileNonce}: CryptoArgs): Promise<ArrayBuffer> {
+  return await simplex.chat_read_file(path, fileKey, fileNonce)
+}
+
+/**
+ * Encrypt file
+ */
+export async function chatEncryptFile(ctrl: bigint, fromPath: string, toPath: string): Promise<CryptoArgs> {
+  const res = await simplex.chat_encrypt_file(ctrl, fromPath, toPath)
+  return cryptoArgsResult(res)
+}
+
+/**
+ * Decrypt file
+ */
+export async function chatDecryptFile(fromPath: string, {fileKey, fileNonce}: CryptoArgs, toPath: string): Promise<void> {
+  const res = await simplex.chat_decrypt_file(fromPath, fileKey, fileNonce, toPath)
+  if (res !== "") throw new Error(res)
+}
+
+function cryptoArgsResult(res: string): CryptoArgs {
+  const json = JSON.parse(res)
+  switch (json.type) {
+    case "result": return json.cryptoArgs as CryptoArgs
+    case "error": throw Error(json.writeError)
+    default: throw Error("unexpected chat_write_file result: " + res)
+  }  
+}
+
+export interface APIResult<R> {
+  result?: R
+  error?: T.ChatError
+}
+
+export class ChatAPIError extends Error {
+  constructor(public message: string, public chatError: T.ChatError | undefined = undefined) {
+    super(message)
+  }
+}
+
+/**
+ * Migration confirmation mode
+ */
+export enum MigrationConfirmation {
+  YesUp = "yesUp",
+  YesUpDown = "yesUpDown",
+  Console = "console",
+  Error = "error"
+}
+
+/**
+ * File encryption key and nonce
+ */
+export interface CryptoArgs {
+  fileKey: string
+  fileNonce: string
+}
+
+export class ChatInitError extends Error {
+  constructor(public message: string, public dbMigrationError: DBMigrationError) {
+    super(message)
+  }
+}
+
+export type DBMigrationError = 
+  | DBMigrationError.InvalidConfirmation
+  | DBMigrationError.ErrorNotADatabase // invalid/corrupt database file or incorrect encryption key
+  | DBMigrationError.ErrorMigration
+  | DBMigrationError.ErrorSQL
+
+export namespace DBMigrationError {
+  export type Tag = "invalidConfirmation" | "errorNotADatabase" | "errorMigration" | "errorSQL"
+
+  interface Interface {
+    type: Tag
+  }
+
+  export interface InvalidConfirmation extends Interface {
+    type: "invalidConfirmation"
+  }
+
+  export interface ErrorNotADatabase extends Interface {
+    type: "errorNotADatabase"
+    dbFile: string
+  }
+
+  export interface ErrorMigration extends Interface {
+    type: "errorMigration"
+    dbFile: string
+    migrationError: MigrationError
+  }
+
+  export interface ErrorSQL extends Interface {
+    type: "errorSQL"
+    dbFile: string
+    migrationSQLError: string
+  }
+}
+
+export type MigrationError =
+  | MigrationError.MEUpgrade
+  | MigrationError.MEDowngrade
+  | MigrationError.MigrationError
+
+export namespace MigrationError {
+  export type Tag = "upgrade" | "downgrade" | "migrationError"
+
+  interface Interface {
+    type: Tag
+  }
+
+  export interface MEUpgrade extends Interface {
+    type: "upgrade"
+    upMigrations: UpMigration
+  }
+
+  export interface MEDowngrade extends Interface {
+    type: "downgrade"
+    downMigrations: string[]
+  }
+
+  export interface MigrationError extends Interface {
+    type: "migrationError"
+    mtrError: MTRError
+  }  
+}
+
+export interface UpMigration {
+  upName: string
+  withDown: boolean
+}
+
+export type MTRError =
+  | MTRError.MTRENoDown
+  | MTRError.MTREDifferent
+
+export namespace MTRError {
+  export type Tag = "noDown" | "different"
+
+  interface Interface {
+    type: Tag
+  }
+
+  export interface MTRENoDown extends Interface {
+    type: "noDown"
+    upMigrations: UpMigration
+  }
+
+  export interface MTREDifferent extends Interface {
+    type: "different"
+    downMigrations: string[]
+  }
+}

package/src/download-libs.js

@@ -0,0 +1,239 @@
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const extract = require('extract-zip');
+
+const GITHUB_REPO = 'simplex-chat/simplex-chat-libs';
+const RELEASE_TAG = 'v6.5.0-beta.10';
+const BACKEND = (process.env.SIMPLEX_BACKEND || process.env.npm_config_simplex_backend || 'sqlite').toLowerCase();
+
+if (BACKEND !== 'sqlite' && BACKEND !== 'postgres') {
+  console.error(`✗ Invalid SIMPLEX_BACKEND: "${BACKEND}". Must be "sqlite" or "postgres".`);
+  process.exit(1);
+}
+
+if (BACKEND === 'postgres' && (process.platform !== 'linux' || process.arch !== 'x64')) {
+  console.error(`✗ SIMPLEX_BACKEND=postgres is only supported on Linux x86_64.`);
+  process.exit(1);
+}
+
+const ROOT_DIR = process.cwd(); // Root of the package being installed
+const LIBS_DIR = path.join(ROOT_DIR, 'libs')
+const INSTALLED_FILE = path.join(LIBS_DIR, 'installed.txt');
+
+// Detect platform and architecture
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  let platformName;
+  let archName;
+
+  if (platform === 'linux') {
+    platformName = 'linux';
+  } else if (platform === 'darwin') {
+    platformName = 'macos';
+  } else if (platform === 'win32') {
+    platformName = 'windows';
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  if (arch === 'x64') {
+    archName = 'x86_64';
+  } else if (arch === 'arm64') {
+    archName = 'aarch64';
+  } else {
+    throw new Error(`Unsupported architecture: ${arch}`);
+  }
+
+  return { platformName, archName };
+}
+
+// Cleanup on libs version mismatch
+function cleanLibsDirectory() {
+  if (fs.existsSync(LIBS_DIR)) {
+    console.log('Cleaning old libraries...');
+    fs.rmSync(LIBS_DIR, { recursive: true, force: true });
+    fs.mkdirSync(LIBS_DIR, { recursive: true });
+    console.log('✓ Old libraries removed');
+  }
+}
+
+// Check if libraries are already installed with the correct version
+function isAlreadyInstalled() {
+  if (!fs.existsSync(INSTALLED_FILE)) {
+    return false;
+  }
+
+  try {
+    const installedVersion = fs.readFileSync(INSTALLED_FILE, 'utf-8').trim();
+    const expectedVersion = `${RELEASE_TAG}:${BACKEND}`;
+    if (installedVersion === expectedVersion) {
+      console.log(`✓ Libraries version ${RELEASE_TAG}:${BACKEND} already installed`);
+      return true;
+    } else {
+      console.log(`Version mismatch: installed ${installedVersion}, need ${expectedVersion}`);
+      cleanLibsDirectory();
+      return false;
+    }
+  } catch (err) {
+    console.warn(`Could not read installed.txt: ${err.message}`);
+    return false;
+  }
+}
+
+async function install() {
+  try {
+    // Check if already installed
+    if (isAlreadyInstalled()) {
+      return;
+    }
+
+    const { platformName, archName } = getPlatformInfo();
+    const repoName = GITHUB_REPO.split('/')[1];
+    const backendSuffix = BACKEND === 'postgres' ? '-postgres' : '';
+    const zipFilename = `${repoName}-${platformName}-${archName}${backendSuffix}.zip`;
+    const ZIP_URL = `https://github.com/${GITHUB_REPO}/releases/download/${RELEASE_TAG}/${zipFilename}`;
+    const ZIP_PATH = path.join(ROOT_DIR, zipFilename);
+    const TEMP_EXTRACT_DIR = path.join(ROOT_DIR, '.temp-extract');
+
+    console.log(`Detected: ${platformName} ${archName}`);
+    console.log(`Backend: ${BACKEND}`);
+    console.log(`Downloading: ${zipFilename}`);
+
+    // Create libs directory
+    if (!fs.existsSync(LIBS_DIR)) {
+      fs.mkdirSync(LIBS_DIR, { recursive: true });
+    }
+
+    // Download zip with error handling
+    await downloadFile(ZIP_URL, ZIP_PATH);
+
+    // Extract to temporary directory
+    console.log('Extracting to temporary directory...');
+    if (!fs.existsSync(TEMP_EXTRACT_DIR)) {
+      fs.mkdirSync(TEMP_EXTRACT_DIR, { recursive: true });
+    }
+    await extract(ZIP_PATH, { dir: TEMP_EXTRACT_DIR });
+
+    // Move libs folder contents to final location
+    console.log('Moving libraries to libs/...');
+    const libsSourcePath = path.join(TEMP_EXTRACT_DIR, 'libs');
+
+    if (fs.existsSync(libsSourcePath)) {
+      // Copy all files from libs folder to LIBS_DIR
+      const files = fs.readdirSync(libsSourcePath);
+      files.forEach(file => {
+        const src = path.join(libsSourcePath, file);
+        const dest = path.join(LIBS_DIR, file);
+
+        if (fs.statSync(src).isDirectory()) {
+          copyDirSync(src, dest);
+        } else {
+          fs.copyFileSync(src, dest);
+        }
+      });
+    } else {
+      throw new Error('libs folder not found in zip archive');
+    }
+
+    // Write installed.txt with version
+    fs.writeFileSync(INSTALLED_FILE, `${RELEASE_TAG}:${BACKEND}`, 'utf-8');
+    console.log(`✓ Wrote version ${RELEASE_TAG}:${BACKEND} to installed.txt`);
+
+    // Cleanup
+    fs.rmSync(TEMP_EXTRACT_DIR, { recursive: true, force: true });
+    fs.unlinkSync(ZIP_PATH);
+    console.log('✓ Installation complete');
+  } catch (err) {
+    console.error('✗ Failed:', err.message);
+    process.exit(1);
+  }
+}
+
+// Helper function to recursively copy directories
+function copyDirSync(src, dest) {
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true });
+  }
+  const files = fs.readdirSync(src);
+  files.forEach(file => {
+    const srcFile = path.join(src, file);
+    const destFile = path.join(dest, file);
+    if (fs.statSync(srcFile).isDirectory()) {
+      copyDirSync(srcFile, destFile);
+    } else {
+      fs.copyFileSync(srcFile, destFile);
+    }
+  });
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+
+    https.get(url, { headers: { 'User-Agent': 'Node.js' } }, (response) => {
+      // Handle redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.destroy();
+        fs.unlink(dest, () => {});
+        return downloadFile(response.headers.location, dest)
+          .then(resolve)
+          .catch(reject);
+      }
+
+      // Handle 404
+      if (response.statusCode === 404) {
+        file.destroy();
+        fs.unlink(dest, () => {});
+        reject(new Error(
+          `Release artifact not found (404). Check:\n` +
+          `  - Repository exists: ${url.split('/releases')[0]}\n` +
+          `  - Release tag exists: ${RELEASE_TAG}\n` +
+          `  - Artifact filename is correct`
+        ));
+        return;
+      }
+
+      // Handle 403
+      if (response.statusCode === 403) {
+        file.destroy();
+        fs.unlink(dest, () => {});
+        reject(new Error(
+          `Access denied (403). The repository may be private.\n` +
+          `Set GITHUB_TOKEN environment variable for private repos.`
+        ));
+        return;
+      }
+
+      // Handle other HTTP errors
+      if (response.statusCode < 200 || response.statusCode >= 300) {
+        file.destroy();
+        fs.unlink(dest, () => {});
+        reject(new Error(
+          `HTTP ${response.statusCode}: Failed to download from ${url}`
+        ));
+        return;
+      }
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        fs.unlink(dest, () => {});
+        reject(new Error(`File write error: ${err.message}`));
+      });
+    }).on('error', (err) => {
+      file.destroy();
+      fs.unlink(dest, () => {});
+      reject(new Error(`Download error: ${err.message}`));
+    });
+  });
+}
+
+install();

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * 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.
+ */
+export * as bot from "./bot"
+
+/**
+ * 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.
+ */
+export * as api from "./api"
+
+/**
+ * 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.
+ */
+export * as core from "./core"
+
+/**
+ * Useful functions for chat events and types.
+ */
+export * as util from "./util"

package/src/simplex.d.ts

@@ -0,0 +1,10 @@
+// These functions are defined in CPP add-on ../cpp/simplex.cc
+
+export function chat_migrate_init(dbPath: string, dbKey: string, confirm: string): Promise<[bigint, string]>
+export function chat_close_store(ctrl: bigint): Promise<string>
+export function chat_send_cmd(ctrl: bigint, cmd: string): Promise<string>
+export function chat_recv_msg_wait(ctrl: bigint, wait: number): Promise<string>
+export function chat_write_file(ctrl: bigint, path: string, buffer: ArrayBuffer): Promise<string>
+export function chat_read_file(path: string, key: string, nonce: string): Promise<ArrayBuffer>
+export function chat_encrypt_file(ctrl: bigint, fromPath: string, toPath: string): Promise<string>
+export function chat_decrypt_file(fromPath: string, key: string, nonce: string, toPath: string): Promise<string>

package/src/simplex.js

@@ -0,0 +1 @@
+module.exports = require("../build/Release/simplex")