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

package/src/libs.ts

@@ -0,0 +1,202 @@
+import * as crypto from "crypto"
+import * as fs from "fs"
+import * as http from "http"
+import * as https from "https"
+import * as os from "os"
+import * as path from "path"
+import {pipeline} from "stream/promises"
+import extract = require("extract-zip")
+import type {Backend} from "./core"
+import {ADDON_RELEASE, LIBS_RELEASE, SHA256} from "./release"
+
+const GITHUB_REPO = "simplex-chat/simplex-chat-libs"
+const REQUEST_TIMEOUT_MS = 60_000
+export const MAX_REDIRECTS = 5
+const PLATFORMS: {[platform: string]: {name: string, lib: string} | undefined} = {
+  linux: {name: "linux", lib: "libsimplex.so"},
+  darwin: {name: "macos", lib: "libsimplex.dylib"},
+  win32: {name: "windows", lib: "libsimplex.dll"},
+}
+const ARCHS: {[arch: string]: string | undefined} = {x64: "x86_64", arm64: "aarch64"}
+const SUPPORTED = ["linux-x86_64", "linux-aarch64", "macos-x86_64", "macos-aarch64", "windows-x86_64"]
+
+function unsupported(platform: string, arch: string): Error {
+  return new Error(`Unsupported platform: ${platform}/${arch}; supported: ${SUPPORTED.join(", ")}`)
+}
+
+export function platformTag(platform: string, arch: string): string {
+  const tag = `${PLATFORMS[platform]?.name}-${ARCHS[arch]}`
+  if (!SUPPORTED.includes(tag)) throw unsupported(platform, arch)
+  return tag
+}
+
+function libName(platform: string = process.platform, arch: string = process.arch): string {
+  const lib = PLATFORMS[platform]?.lib
+  if (!lib) throw unsupported(platform, arch)
+  return lib
+}
+
+export function cacheRoot(platform: string, env: NodeJS.ProcessEnv, home: string = os.homedir()): string {
+  if (platform === "darwin") return path.join(home, "Library", "Caches", "simplex-chat")
+  if (platform === "win32") {
+    if (!env.LOCALAPPDATA) throw new Error("LOCALAPPDATA is not set")
+    return path.join(env.LOCALAPPDATA, "simplex-chat")
+  }
+  return path.join(env.XDG_CACHE_HOME || path.join(home, ".cache"), "simplex-chat")
+}
+
+export function libsAsset(backend: Backend, tag: string): string {
+  const suffix = backend === "postgres" ? "-postgres" : ""
+  return `simplex-chat-libs-${tag}${suffix}.zip`
+}
+
+export function addonAsset(tag: string): string {
+  return `simplex-chat-nodejs-${tag}.node`
+}
+
+export function releaseUrl(release: string, asset: string): string {
+  return `https://github.com/${GITHUB_REPO}/releases/download/${release}/${asset}`
+}
+
+function pinnedSha256(asset: string): string {
+  const sha256 = SHA256[asset]
+  if (!sha256) throw new Error(`no SHA-256 is pinned for ${asset}`)
+  return sha256
+}
+
+export function libPath(dir: string): string {
+  return path.join(dir, libName())
+}
+
+export async function resolveLibsDir(
+  backend: Backend,
+  env: NodeJS.ProcessEnv = process.env,
+  platform: string = process.platform,
+  arch: string = process.arch
+): Promise<string> {
+  const lib = libName(platform, arch)
+  if (env.SIMPLEX_LIBS_DIR) {
+    const dir = path.resolve(env.SIMPLEX_LIBS_DIR)
+    if (!fs.existsSync(path.join(dir, lib))) throw new Error(`SIMPLEX_LIBS_DIR has no ${lib}: ${dir}`)
+    return dir
+  }
+  const tag = platformTag(platform, arch)
+  if (backend === "postgres" && tag !== "linux-x86_64") {
+    throw new Error(`postgres backend is only supported on linux-x86_64; current platform is ${tag}`)
+  }
+  const target = path.resolve(cacheRoot(platform, env), LIBS_RELEASE, backend)
+  if (!fs.existsSync(path.join(target, lib))) {
+    const asset = libsAsset(backend, tag)
+    await installLibs(releaseUrl(LIBS_RELEASE, asset), pinnedSha256(asset), target, lib)
+  }
+  return target
+}
+
+export async function resolveAddonPath(
+  env: NodeJS.ProcessEnv = process.env,
+  platform: string = process.platform,
+  arch: string = process.arch
+): Promise<string> {
+  if (env.SIMPLEX_ADDON_PATH) {
+    const file = path.resolve(env.SIMPLEX_ADDON_PATH)
+    if (!fs.existsSync(file)) throw new Error(`SIMPLEX_ADDON_PATH does not exist: ${file}`)
+    return file
+  }
+  if (!ADDON_RELEASE) throw new Error("no prebuilt Node.js add-on is pinned in this version; set SIMPLEX_ADDON_PATH")
+  const asset = addonAsset(platformTag(platform, arch))
+  const target = path.resolve(cacheRoot(platform, env), ADDON_RELEASE, asset)
+  if (!fs.existsSync(target)) await installAddon(releaseUrl(ADDON_RELEASE, asset), pinnedSha256(asset), target)
+  return target
+}
+
+export function installLibs(url: string, sha256: string, target: string, lib: string, timeoutMs: number = REQUEST_TIMEOUT_MS): Promise<void> {
+  return inTempDir(target, async tmp => {
+    console.error(`Downloading libsimplex from ${url} ...`)
+    const zipPath = path.join(tmp, "libs.zip")
+    await download(url, zipPath, timeoutMs)
+    await verifySha256(zipPath, sha256, url)
+    await extract(zipPath, {dir: tmp})
+    const extracted = path.join(tmp, "libs")
+    if (!fs.existsSync(path.join(extracted, lib))) throw new Error(`libs/${lib} missing from ${url}`)
+    await renameInto(extracted, target, path.join(target, lib))
+  })
+}
+
+export function installAddon(url: string, sha256: string, target: string, timeoutMs: number = REQUEST_TIMEOUT_MS): Promise<void> {
+  return inTempDir(target, async tmp => {
+    console.error(`Downloading the Node.js add-on from ${url} ...`)
+    const file = path.join(tmp, path.basename(target))
+    await download(url, file, timeoutMs)
+    await verifySha256(file, sha256, url)
+    await renameInto(file, target, target)
+  })
+}
+
+async function verifySha256(file: string, expected: string, url: string): Promise<void> {
+  const hash = crypto.createHash("sha256")
+  for await (const chunk of fs.createReadStream(file)) hash.update(chunk)
+  const actual = hash.digest("hex")
+  if (actual !== expected) throw new Error(`SHA-256 of ${url} is ${actual}, expected ${expected}`)
+}
+
+// The temp dir is next to the target, so the final rename stays on one filesystem.
+async function inTempDir(target: string, install: (tmp: string) => Promise<void>): Promise<void> {
+  const parent = path.dirname(target)
+  await fs.promises.mkdir(parent, {recursive: true})
+  const tmp = await fs.promises.mkdtemp(path.join(parent, ".download-"))
+  try {
+    await install(tmp)
+  } finally {
+    await fs.promises.rm(tmp, {recursive: true, force: true})
+  }
+}
+
+async function renameInto(from: string, target: string, installed: string): Promise<void> {
+  try {
+    await fs.promises.rename(from, target)
+  } catch (e) {
+    // Another process installed the same version first; its files are identical.
+    // Windows reports renaming onto an existing directory or a loaded file as EPERM.
+    const code = (e as NodeJS.ErrnoException).code
+    const lost = (code === "EEXIST" || code === "ENOTEMPTY" || code === "EPERM") && fs.existsSync(target)
+    if (!lost) throw e
+    if (!fs.existsSync(installed)) {
+      throw new Error(`another process partially populated ${target} but ${path.basename(installed)} is missing; remove it manually and retry`)
+    }
+  }
+}
+
+function download(url: string, dest: string, timeoutMs: number, redirects = 0): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const get = url.startsWith("https:") ? https.get : http.get
+    // Once a response arrives, request errors are ignored: a download settles via pipeline, which
+    // waits for the file to close, so tmp cleanup cannot fail with EBUSY on Windows.
+    let res: http.IncomingMessage | undefined
+    const req = get(url, {headers: {"User-Agent": "simplex-chat-nodejs"}, timeout: timeoutMs}, response => {
+      res = response
+      const status = response.statusCode ?? 0
+      const location = response.headers.location
+      if (status >= 300 && status < 400 && location) {
+        response.resume()
+        if (redirects >= MAX_REDIRECTS) return reject(new Error(`too many redirects downloading ${url}`))
+        let next: URL
+        try {
+          next = new URL(location, url)
+        } catch (e) {
+          return reject(e)
+        }
+        if (next.protocol !== new URL(url).protocol) return reject(new Error(`redirect from ${url} to ${next} changes protocol`))
+        download(next.toString(), dest, timeoutMs, redirects + 1).then(resolve, reject)
+        return
+      }
+      if (status !== 200) {
+        response.resume()
+        return reject(new Error(`HTTP ${status} downloading ${url}`))
+      }
+      pipeline(response, fs.createWriteStream(dest)).then(resolve, reject)
+    })
+    const abort = (err: Error) => (res ? res.destroy(err) : req.destroy(err))
+    req.on("timeout", () => abort(new Error(`timeout downloading ${url}`)))
+    req.on("error", e => { if (!res) reject(e) })
+  })
+}

package/src/release.ts

@@ -0,0 +1,19 @@
+// Written by scripts/ci/packages_release.py from the simplex-chat-libs releases.
+
+export const LIBS_RELEASE = "core-7.1.0.11"
+
+export const ADDON_RELEASE: string | undefined = "nodejs-addon-308c0960c707"
+
+export const SHA256: {readonly [asset: string]: string} = {
+  "simplex-chat-libs-linux-aarch64.zip": "d66aa1b30b9fa20225dad8ef75a9c605961e1c0adde2ba0283e2fcac4e15d260",
+  "simplex-chat-libs-linux-x86_64-postgres.zip": "925b3166f969b12082ff8ee659e5f2a9933fe40120deb80c9aa3002a5ba6c803",
+  "simplex-chat-libs-linux-x86_64.zip": "dabad0824e8813ea4a084fbf37e1ba4cf6dcea9cd8ccadc521fec200f246208a",
+  "simplex-chat-libs-macos-aarch64.zip": "aa74608b149fff7508a47eaac4284dcc6d189c6ed8b7c18428df9158bc176a61",
+  "simplex-chat-libs-macos-x86_64.zip": "a0e21457e1077be7f71b46c1c27452945b2cee2b6c50efb0004412ce5b7042ec",
+  "simplex-chat-libs-windows-x86_64.zip": "c01dad574daa101a1cbfd31ddbf2b3d0d986a4a42f97d789d2f878b2050b2b4b",
+  "simplex-chat-nodejs-linux-aarch64.node": "3636a82c56c48229e0326fa03d6ceb5c16dd3afbcc1e86337783dc53a7328d67",
+  "simplex-chat-nodejs-linux-x86_64.node": "55f3479b03fdb57591179ed730da744f1aa362e7529df55221b60028415746e9",
+  "simplex-chat-nodejs-macos-aarch64.node": "17da0ed991bcc60f3a0329ba4ce8af902a02cb3dfd7ab7b84718449cc857c857",
+  "simplex-chat-nodejs-macos-x86_64.node": "6218210db6caf520ecb7b5066babfce1e51ad2082f7ba6043aa26510418c1aea",
+  "simplex-chat-nodejs-windows-x86_64.node": "03aaee6f19b216c660f492e064a02a2820c41cd4b58b2a7b7561ac97b982f90d",
+}

package/src/simplex.d.ts

@@ -0,0 +1,12 @@
+// These functions are defined in CPP add-on ../cpp/simplex.cc
+
+export function load(addonPath: string, libPath: string): void
+export function chat_migrate_init(dbPath: string, dbKey: string, confirm: string): Promise<[bigint, string]>
+export function chat_migrate_init_queue(dbPath: string, dbKey: string, confirm: string, queueSize: number): 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 | Uint8Array): Promise<string>
+export function chat_read_file(path: string, key: string, nonce: string): Promise<Buffer>
+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,22 @@
+// The add-on is downloaded from the libsimplex release, so it is loaded at runtime by core.loadLibrary.
+const NOT_LOADED = "libsimplex is not loaded, call core.loadLibrary(backend) first"
+const BINDINGS = ["chat_migrate_init", "chat_migrate_init_queue", "chat_close_store", "chat_send_cmd", "chat_recv_msg_wait",
+  "chat_write_file", "chat_read_file", "chat_encrypt_file", "chat_decrypt_file"]
+
+let addon
+
+exports.load = (addonPath, libPath) => {
+  if (!addon) {
+    const addonModule = {exports: {}}
+    process.dlopen(addonModule, addonPath)
+    addon = addonModule.exports
+  }
+  addon.load(libPath)
+}
+
+for (const name of BINDINGS) {
+  exports[name] = (...args) => {
+    if (!addon) throw new Error(NOT_LOADED)
+    return addon[name](...args)
+  }
+}

package/src/util.ts

@@ -0,0 +1,92 @@
+import {T} from "@simplex-chat/types"
+import {BotAddressSettings} from "./api"
+
+export function chatInfoRef(cInfo: T.ChatInfo): T.ChatRef | undefined {
+  switch (cInfo.type) {
+    case T.ChatType.Direct: return {chatType: T.ChatType.Direct, chatId: cInfo.contact.contactId}
+    case T.ChatType.Group: {
+      const chatScope: T.GroupChatScope | undefined =
+        cInfo.groupChatScope?.type == "memberSupport"
+        ? {type: "memberSupport", groupMemberId_: cInfo.groupChatScope.groupMember_?.groupMemberId}
+        : undefined
+      return {chatType: T.ChatType.Group, chatId: cInfo.groupInfo.groupId, chatScope}
+    }
+    default: return undefined
+  }
+}
+
+export function chatInfoName(cInfo: T.ChatInfo): string {
+  switch (cInfo.type) {
+    case "direct": return `@${cInfo.contact.profile.displayName}`
+    case "group": {
+      const scope = cInfo.groupChatScope
+      const scopeName = scope?.type === "memberSupport"
+                        ? `(support${scope.groupMember_ ? ` ${scope.groupMember_.memberProfile.displayName}` : ""})`
+                        : ""
+      return `#${cInfo.groupInfo.groupProfile.displayName}${scopeName}`
+    }
+    case "local": return "private notes"
+    case "contactRequest": return `request from @${cInfo.contactRequest.profile.displayName}`
+    case "contactConnection": {
+      const alias = cInfo.contactConnection.localAlias
+      return `pending connection${alias ? ` (@${alias})` : ""}`
+    }
+  }
+}
+
+export function senderName(cInfo: T.ChatInfo, chatDir: T.CIDirection) {
+  const sender = chatDir.type === "groupRcv"
+                  ? ` @${chatDir.groupMember.memberProfile.displayName}`
+                  : ""
+  return chatInfoName(cInfo) + sender
+}
+
+export function contactAddressStr(link: T.CreatedConnLink): string {
+  return link.connShortLink || link.connFullLink
+}
+
+export function botAddressSettings({addressSettings}: T.UserContactLink): BotAddressSettings {
+  return {
+    autoAccept: addressSettings.autoAccept ? true : false,
+    welcomeMessage: addressSettings.autoReply,
+    businessAddress: addressSettings.businessAddress
+  }
+}
+
+export function fromLocalProfile({displayName, fullName, shortDescr, image, contactLink, preferences, peerType, contactDomain}: T.LocalProfile): T.Profile {
+  const profile = {displayName, fullName, shortDescr, image, contactLink, preferences, peerType, contactDomain: contactDomain && {domain: contactDomain.domain}}
+  for (const key in profile) {
+    if (typeof (profile as any)[key] === "undefined") delete (profile as any)[key]
+  }
+  return profile
+}
+
+export function ciContentText({content}: T.ChatItem): string | undefined {
+  switch (content.type) {
+    case "sndMsgContent": return content.msgContent.text;
+    case "rcvMsgContent": return content.msgContent.text;
+    default: return undefined;
+  }
+}
+
+export interface BotCommand {
+  keyword: string
+  params: string
+}
+
+// returns command (without /) and trimmed parameters
+export function ciBotCommand(chatItem: T.ChatItem): BotCommand | undefined {
+  const msg = ciContentText(chatItem)?.trim()
+  if (msg) {
+    const r = msg.match(/^\/([^\s]+)([\s\S]*)/)
+    if (r && r.length >= 3) {
+      return {keyword: r[1], params: r[2].trim()}
+    }
+  }
+  return undefined
+}
+
+export function reactionText(reaction: T.ACIReaction): string {
+  const r = reaction.chatReaction
+  return r.reaction.type === "emoji" ? r.reaction.emoji : r.reaction.tag
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "include": ["src"],
+  "compilerOptions": {
+    "declaration": true,
+    "forceConsistentCasingInFileNames": true,
+    "lib": ["ES2018"],
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noEmitOnError": true,
+    "outDir": "dist",
+    "sourceMap": true,
+    "strict": true,
+    "strictNullChecks": true,
+    "target": "ES2018",
+    "types": ["node"]
+  }
+}