@shhhum/simplex-chat 0.0.0-stage → 7.1.0-beta.6.1

package/src/bot.ts

@@ -0,0 +1,221 @@
+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
+  queueSize?: number
+}
+
+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,
+  simplexDomain?: string | null,
+  dbOpts: BotDbOpts,
+  options: BotOptions,
+  onMessage?: (chatItem: T.AChatItem, content: T.MsgContent, chat: api.ChatApi) => 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, chat: api.ChatApi) => 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, simplexDomain, 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, dbOpts.queueSize)
+  const opts = fullOptions(options)
+  if (onMessage || Object.keys(onCommands).length > 0) subscribeChatItems(bot, onMessage, 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
+  }
+  const namedUser = await updateBotSimplexDomain(bot, user, simplexDomain, opts)
+  await updateBotUserProfile(bot, namedUser, 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 
+}
+
+export function subscribeChatItems(
+  bot: api.ChatApi,
+  onMessage: ((chatItem: T.AChatItem, content: T.MsgContent, chat: api.ChatApi) => void | Promise<void>) | undefined,
+  commands: {[K in string]?: ((chatItem: T.AChatItem, command: util.BotCommand, chat: api.ChatApi) => void | Promise<void>)}
+) {
+  bot.on("newChatItems", async ({chatItems}) => {
+    for (const ci of chatItems) {
+      const content = ci.chatItem.content
+      if (content.type !== "rcvMsgContent") continue
+      const cmd = util.ciBotCommand(ci.chatItem)
+      const cmdFunc = cmd && (commands[cmd.keyword] || commands[""])
+      try {
+        if (cmd && cmdFunc) await cmdFunc(ci, cmd, bot)
+        else if (onMessage) await onMessage(ci, content.msgContent, bot)
+      } catch (e) {
+        console.log(cmd && cmdFunc ? `${cmd.keyword} command processing error` : "message 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 updateBotSimplexDomain(bot: api.ChatApi, user: T.User, simplexDomain: string | null | undefined, opts: Required<BotOptions>): Promise<T.User> {
+  if (simplexDomain === undefined) return user
+  const domain = simplexDomain === null ? undefined : simplexDomain.toLowerCase()
+  if (user.profile.contactDomain?.domain === domain) return user
+  if (!opts.updateAddress) {
+    console.log("Bot SimpleX name changed")
+    return user
+  }
+  console.log("Bot SimpleX name changed, updating...")
+  try {
+    return await bot.apiSetUserDomain(user.userId, domain)
+  } catch (e) {
+    console.log("Error updating bot SimpleX name", e)
+    return user
+  }
+}
+
+async function updateBotUserProfile(bot: api.ChatApi, user: T.User, profile: T.Profile, opts: Required<BotOptions>): Promise<void> {
+  const {userId} = user
+  const {contactDomain, ...currentProfile} = util.fromLocalProfile(user.profile)
+  if (!equal(currentProfile, profile)) {
+    if (opts.updateProfile) {
+      console.log("Bot profile changed, updating...")
+      const summary = await bot.apiUpdateProfile(userId, {...profile, contactDomain})
+      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/cli.ts

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import {parseArgs} from "util"
+import type {Backend} from "./core"
+import {resolveAddonPath, resolveLibsDir} from "./libs"
+
+const USAGE = "usage: simplex-chat install [--backend sqlite|postgres]"
+const EXIT_INSTALL_FAILED = 1
+const EXIT_USAGE = 2
+
+export function parseInstallArgs(argv: string[]): Backend {
+  const {positionals, values: {backend = "sqlite"}} = parseArgs({args: argv, allowPositionals: true, options: {backend: {type: "string"}}})
+  if (positionals.length !== 1 || positionals[0] !== "install") throw new Error("expected command: install")
+  if (backend !== "sqlite" && backend !== "postgres") throw new Error(`invalid backend: ${backend}`)
+  return backend
+}
+
+export async function main(argv: string[]): Promise<number> {
+  if (argv.includes("-h") || argv.includes("--help")) {
+    console.log(USAGE)
+    return 0
+  }
+  let backend: Backend
+  try {
+    backend = parseInstallArgs(argv)
+  } catch (e) {
+    console.error(`${(e as Error).message}\n${USAGE}`)
+    return EXIT_USAGE
+  }
+  try {
+    const [dir, addon] = await Promise.all([resolveLibsDir(backend), resolveAddonPath()])
+    console.log(`libsimplex installed at: ${dir}`)
+    console.log(`Node.js add-on installed at: ${addon}`)
+    return 0
+  } catch (e) {
+    console.error(`install failed: ${(e as Error).message}`)
+    return EXIT_INSTALL_FAILED
+  }
+}
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then(code => { process.exitCode = code })
+}

package/src/core.ts

@@ -0,0 +1,240 @@
+import {ChatEvent, ChatResponse, T} from "@simplex-chat/types"
+import * as libs from "./libs"
+import * as simplex from "./simplex"
+
+export type Backend = "sqlite" | "postgres"
+
+let loading: {backend: Backend, promise: Promise<void>} | undefined
+
+/**
+ * Resolve (downloading on first use) and load libsimplex for the backend.
+ * One libsimplex per process: the Haskell runtime is initialized once, and another backend is rejected.
+ */
+export function loadLibrary(backend: Backend): Promise<void> {
+  if (loading) {
+    if (loading.backend === backend) return loading.promise
+    return Promise.reject(new Error(`libsimplex already loaded with backend=${loading.backend}; cannot switch to ${backend} in the same process`))
+  }
+  const promise = Promise.all([libs.resolveLibsDir(backend), libs.resolveAddonPath()])
+    .then(([dir, addon]) => simplex.load(addon, libs.libPath(dir)))
+  loading = {backend, promise}
+  // a failed download or load can be retried
+  promise.catch(() => { loading = undefined })
+  return promise
+}
+
+/**
+ * Initialize chat controller
+ * @param {number} [queueSize] - Size of internal queues, the core default is used when omitted.
+ */
+export async function chatMigrateInit(dbPath: string, dbKey: string, confirm: MigrationConfirmation, queueSize?: number): Promise<bigint> {
+  const [ctrl, res] = queueSize === undefined
+    ? await simplex.chat_migrate_init(dbPath, dbKey, confirm)
+    : await simplex.chat_migrate_init_queue(dbPath, dbKey, confirm, queueSize)
+  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 | Uint8Array): 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<Buffer> {
+  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.InvalidQueueSize
+  | DBMigrationError.ErrorNotADatabase // invalid/corrupt database file or incorrect encryption key
+  | DBMigrationError.ErrorMigration
+  | DBMigrationError.ErrorSQL
+
+export namespace DBMigrationError {
+  export type Tag = "invalidConfirmation" | "invalidQueueSize" | "errorNotADatabase" | "errorMigration" | "errorSQL"
+
+  interface Interface {
+    type: Tag
+  }
+
+  export interface InvalidConfirmation extends Interface {
+    type: "invalidConfirmation"
+  }
+
+  export interface InvalidQueueSize extends Interface {
+    type: "invalidQueueSize"
+  }
+
+  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"
+    dbMigrations: string[]
+  }
+
+  export interface MTREDifferent extends Interface {
+    type: "different"
+    downMigrations: string[]
+  }
+}

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"