turtb 0.5.0

package/lib/utils/toVersionCount.js

@@ -0,0 +1,5 @@
+/**
+ * @param {Array.<number>} versionArrayCounts
+ * @return number
+ */
+export const toVersionCount = versionArrayCounts => versionArrayCounts.reduce((acc, value) => acc * value, 1)

package/lib/utils/webSocketMuxFactory.js

@@ -0,0 +1,123 @@
+/* global location, WebSocket */
+import { TurtleBranchMultiplexer } from '../turtle/connections/TurtleBranchMultiplexer.js'
+import { logError, logInfo, logWarn } from './logger.js'
+
+/**
+ * @typedef {import('../turtle/connections/TurtleDB.js').TurtleDB} TurtleDB
+ * @typedef {import('./Recaller.js').Recaller} Recaller
+ * @typedef {import('../turtle/connections/TurtleDB.js').TurtleBranchStatus} TurtleBranchStatus
+ */
+
+const allServiceWorkers = new Set()
+
+/**
+ * @param {TurtleDB} turtleDB
+ * @param {(tbMux: TurtleBranchMultiplexer) => void} callback
+ * @param {Recaller} [recaller=turtleDB.recaller]
+ */
+export async function webSocketMuxFactory (turtleDB, callback, recaller = turtleDB.recaller) {
+  try {
+    const serviceWorkerRegistration = await navigator.serviceWorker.register(
+      '/service-worker.js',
+      { type: 'module', scope: '/' }
+    )
+    logInfo(() => console.log(' ^^^^^^^ register complete', serviceWorkerRegistration))
+    serviceWorkerRegistration.addEventListener('updatefound', () => {
+      logInfo(() => console.log(' ^^^^^^^ service-worker update found'))
+    })
+    try {
+      logInfo(() => console.log(' ^^^^^^^ serviceWorkerRegistration.update()'))
+      await serviceWorkerRegistration.update()
+    } catch (err) {
+      logInfo(() => console.log(' ^^^^^^^ serviceWorkerRegistration.update() failed', err))
+    }
+    logInfo(() => console.log(' ^^^^^^^ serviceWorkerRegistration.update() complete'))
+    const { serviceWorker } = navigator
+    if (!serviceWorker || allServiceWorkers.has(serviceWorker)) throw new Error('no serviceWorker')
+    const { active } = await serviceWorker.ready
+    allServiceWorkers.add(serviceWorker)
+    const tbMux = new TurtleBranchMultiplexer('serviceWorker', false, turtleDB, recaller)
+    const tbMuxBinding = async (/** @type {TurtleBranchStatus} */ status) => {
+      logInfo(() => console.log(' ^^^^^^^ tbMuxBinding about to get next'))
+      const updater = await tbMux.getTurtleBranchUpdater(tbMux.name, status.publicKey, status.turtleBranch)
+      logInfo(() => console.log('updater about to await settle', updater.name))
+      await updater.settle
+      logInfo(() => console.log('updater settled'))
+    }
+    turtleDB.bind(tbMuxBinding)
+    serviceWorker.onmessage = event => {
+      tbMux.incomingBranch.append(new Uint8Array(event.data))
+    }
+    serviceWorker.startMessages()
+    callback?.(tbMux)
+    for await (const u8aTurtle of tbMux.outgoingBranch.u8aTurtleGenerator()) {
+      active.postMessage(u8aTurtle.uint8Array.buffer)
+    }
+  } catch (error) {
+    logError(() => console.error(error))
+  }
+
+  logWarn(() => console.warn(' ^^^^^^^ unable to connect through service-worker, trying direct websocket connection'))
+
+  withoutServiceWorker(turtleDB, callback)
+}
+
+export async function withoutServiceWorker (turtleDB, callback) {
+  const url = `wss://${location.host}`
+  let t = 100
+  let connectionCount = 0
+  while (true) {
+    logInfo(() => console.log(' ^^^^^^^ creating new websocket and mux'))
+    const tbMux = new TurtleBranchMultiplexer(`backup_websocket_#${connectionCount}`, false, turtleDB)
+    for (const publicKey of turtleDB.getPublicKeys()) {
+      await tbMux.getTurtleBranchUpdater(tbMux.name, publicKey)
+    }
+    const tbMuxBinding = async (/** @type {TurtleBranchStatus} */ status) => {
+      // logInfo(() => console.log(' ^^^^^^^ tbMuxBinding about to get next', { publicKey }))
+      const updater = await tbMux.getTurtleBranchUpdater(tbMux.name, status.publicKey, status.turtleBranch)
+      logInfo(() => console.log('updater about to await settle', updater.name))
+      await updater.settle
+      logInfo(() => console.log('updater settled'))
+    }
+    turtleDB.bind(tbMuxBinding)
+    let connectionIndex
+    try {
+      connectionIndex = ++connectionCount
+      const ws = new WebSocket(url)
+      callback?.(tbMux)
+      ws.binaryType = 'arraybuffer'
+      ws.onopen = async () => {
+        logInfo(() => console.log(' ^^^^^^^ onopen, connectionIndex:', connectionIndex))
+        ;(async () => {
+          try {
+            for await (const u8aTurtle of tbMux.outgoingBranch.u8aTurtleGenerator()) {
+              if (ws.readyState !== ws.OPEN) break
+              ws.send(u8aTurtle.uint8Array)
+            }
+          } catch (error) {
+            logError(() => console.error(error))
+          }
+        })()
+        t = 100
+      }
+      ws.onmessage = event => {
+        if (event.data.byteLength) tbMux.incomingBranch.append(new Uint8Array(event.data))
+        else logInfo(() => console.log(`-- keep-alive @ ${(new Date()).toISOString()}`))
+      }
+      await new Promise((resolve, reject) => {
+        ws.onclose = resolve
+        ws.onerror = reject
+      })
+    } catch (error) {
+      logError(() => console.error(error))
+    }
+    tbMux.stop()
+    callback?.() // delete old tbMux
+    turtleDB.unbind(tbMuxBinding)
+    t = Math.min(t, 2 * 60 * 1000) // 2 minutes max (unjittered)
+    t = t * (1 + Math.random()) // exponential backoff and some jitter
+    logInfo(() => console.log(` ^^^^^^^ waiting ${(t / 1000).toFixed(2)} s`))
+    await new Promise(resolve => setTimeout(resolve, t))
+    logInfo(() => console.log(' ^^^^^^^ reconnecting...', { connectionIndex }))
+  }
+}

package/lib/utils/zabacaba.js

@@ -0,0 +1,25 @@
+/**
+ * --------------------------------------------------------------------------
+ * zabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabada
+ *
+ *                                                                 |
+ *                                 |                               |
+ *                 |               |               |               |
+ *         |       |       |       |       |       |       |       |       |
+ *     |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |   |
+ *   | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
+ *  |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+ * zabacabadabacabaeabacabadabacabafabacabadabacabaeabacabadabacabagabacabada
+ * --------------------------------------------------------------------------
+ * like the "ruler function" (abacaba) but with numbers for binary-tree-like jumping
+ * @param {number} i
+ * @returns {number}
+ */
+
+export function zabacaba (i) {
+  if (i === 0) return 0
+  if (i === 1) return 1
+  const j = ~(i - 1)
+  const b = Math.clz32(j & -j) // 31 - b is right zeros
+  return 32 - b
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "turtb",
+  "version": "0.5.0",
+  "description": "binary for turtledb projects",
+  "repository": "git@github.com:dtudury/turtb.git",
+  "author": "David Tudury <david.tudury@gmail.com>",
+  "license": "AGPL-3.0-only",
+  "bin": "./bin/turtb.js",
+  "type": "module",
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.958.0",
+    "@gerhobbelt/gitignore-parser": "^0.2.0-9",
+    "@parcel/watcher": "^2.5.1",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "express": "^5.2.1",
+    "mkcert": "^3.2.0",
+    "readline-sync": "^1.4.10",
+    "ws": "^8.18.3"
+  },
+  "scripts": {
+    "start": "./bin/turtb.js --env-file .env"
+  }
+}

package/src/ArchiveUpdater.js

@@ -0,0 +1,99 @@
+import { join } from 'path'
+import { AbstractUpdater } from '../lib/turtle/connections/AbstractUpdater.js'
+import { getExistenceLength } from './getExistenceLength.js'
+import { access, mkdir, readFile, writeFile } from 'fs/promises'
+import { verifyCommitU8a } from '../lib/turtle/Signer.js'
+
+/**
+ * @typedef {import('@aws-sdk/client-s3').S3Client} S3Client
+ * @typedef {import('../lib/utils/Recaller.js').Recaller} Recaller
+ */
+
+export class ArchiveUpdater extends AbstractUpdater {
+  #length
+  #lengthPromise
+  #getPromises = []
+
+  /**
+   * @param {string} name
+   * @param {string} publicKey
+   * @param {Recaller} recaller
+   * @param {string} path
+   */
+  constructor (name, publicKey, recaller, path) {
+    super(name, publicKey, false, recaller)
+    this.path = path
+  }
+
+  indexToPath (index) {
+    if (index === undefined) return join(this.path, this.publicKey)
+    return join(this.path, this.publicKey, index.toString().padStart(6, '0'))
+  }
+
+  async setUint8ArraysLength (length) {
+    const conflictMessage = `Attempt to setUint8ArrayLength(${length}) of "${this.name}" (conflict at ${length.toString().padStart(6, '0')}). Backup and delete archive/${this.publicKey} to resolve.`
+    throw new Error(conflictMessage)
+  }
+
+  /**
+   * @returns {Promise.<number>}
+   */
+  async getUint8ArraysLength () {
+    if (this.#length !== undefined) return this.#length
+    const getExists = async index => {
+      try {
+        await access(this.indexToPath(index))
+        return true
+      } catch {
+        return false
+      }
+    }
+    if (!this.#lengthPromise) {
+      const path = join(this.path, this.publicKey)
+      this.#lengthPromise = (async () => {
+        if (!(await getExists())) {
+          await mkdir(path, { recursive: true })
+        }
+        this.#length = await getExistenceLength(getExists)
+        return this.#length
+      })()
+    }
+    return this.#lengthPromise
+  }
+
+  /**
+   * @param {number} index
+   * @returns {Promise.<Uint8Array>}
+   */
+  async getUint8Array (index) {
+    await this.getUint8ArraysLength()
+    if (index >= this.#length) return
+    for (let i = index; i < this.#length; ++i) {
+      if (this.#getPromises[i]) break
+      this.#getPromises[i] = readFile(this.indexToPath(i))
+    }
+    return this.#getPromises[index]
+  }
+
+  /**
+   * @param {Uint8Array} uint8Array
+   * @returns {Promise.<number>}
+   */
+  async pushUint8Array (uint8Array) {
+    await this.getUint8ArraysLength()
+    if (!this.#getPromises[this.#length]) {
+      this.#getPromises[this.#length] = (async () => {
+        let previousUint8Array
+        if (this.#length > 0) {
+          previousUint8Array = await this.getUint8Array(this.#length - 1)
+        }
+        const verified = await verifyCommitU8a(this.publicKey, uint8Array, previousUint8Array)
+        if (!verified) throw new Error('bad signature')
+        await writeFile(this.indexToPath(this.#length), uint8Array, 'binary')
+        ++this.#length
+        return uint8Array
+      })()
+    }
+    return this.#getPromises[this.#length]
+  }
+}

package/src/S3Updater.js

@@ -0,0 +1,99 @@
+import { GetObjectCommand, ListObjectsV2Command, PutObjectCommand } from '@aws-sdk/client-s3'
+import { AbstractUpdater } from '../lib/turtle/connections/AbstractUpdater.js'
+import { verifyCommitU8a } from '../lib/turtle/Signer.js'
+import { getExistenceLength } from './getExistenceLength.js'
+
+/**
+ * @typedef {import('@aws-sdk/client-s3').S3Client} S3Client
+ * @typedef {import('../lib/utils/Recaller.js').Recaller} Recaller
+ */
+
+export class S3Updater extends AbstractUpdater {
+  #length
+  #lengthPromise
+  #getPromises = []
+  /**
+   * @param {string} name
+   * @param {string} publicKey
+   * @param {Recaller} recaller
+   * @param {S3Client} s3Client
+   * @param {string} bucket
+   */
+  constructor (name, publicKey, recaller, s3Client, bucket) {
+    super(name, publicKey, true, recaller)
+    this.s3Client = s3Client
+    this.bucket = bucket
+    this.indexToKey = (publicKey, index) => `${publicKey}/${index.toString().padStart(6, '0')}`
+  }
+
+  /**
+   * @returns {Promise.<number>}
+   */
+  async getUint8ArraysLength () {
+    if (this.#length !== undefined) return this.#length
+    const getExists = async index => {
+      const listObjectsV2Response = await this.s3Client.send(new ListObjectsV2Command({
+        ...(index ? { StartAfter: this.indexToKey(this.publicKey, index - 1) } : {}),
+        MaxKeys: 1,
+        Bucket: this.bucket,
+        Prefix: this.publicKey
+      }))
+      return !!listObjectsV2Response.KeyCount
+    }
+    if (this.#lengthPromise === undefined) {
+      this.#lengthPromise = getExistenceLength(getExists)
+      this.#lengthPromise.then(length => { this.#length = length })
+    }
+    return this.#lengthPromise
+  }
+
+  /**
+   * @param {number} index
+   * @returns {Promise.<Uint8Array>}
+   */
+  async getUint8Array (index) {
+    await this.getUint8ArraysLength()
+    if (index >= this.#length) return
+    for (let i = index; i < this.#length; ++i) {
+      if (this.#getPromises[i]) break
+      let resolve, reject
+      this.#getPromises[i] = new Promise((...args) => { [resolve, reject] = args })
+      try {
+        const object = await this.s3Client.send(new GetObjectCommand({
+          Bucket: this.bucket,
+          Key: this.indexToKey(this.publicKey, i)
+        }))
+        object.Body.transformToByteArray().then(resolve)
+      } catch (error) { reject(error) }
+    }
+    return this.#getPromises[index]
+  }
+
+  /**
+   * @param {Uint8Array} uint8Array
+   * @returns {Promise.<number>}
+   */
+  async pushUint8Array (uint8Array) {
+    await this.getUint8ArraysLength()
+    if (!this.#getPromises[this.#length]) {
+      let resolve, reject
+      this.#getPromises[this.#length] = new Promise((...args) => { [resolve, reject] = args })
+      let previousUint8Array
+      if (this.#length > 0) {
+        previousUint8Array = await this.getUint8Array(this.#length - 1)
+      }
+      const verified = await verifyCommitU8a(this.publicKey, uint8Array, previousUint8Array)
+      if (!verified) throw new Error('bad signature')
+      try {
+        await this.s3Client.send(new PutObjectCommand({
+          Bucket: this.bucket,
+          Body: uint8Array,
+          Key: this.indexToKey(this.publicKey, this.#length)
+        }))
+        ++this.#length
+        resolve(uint8Array)
+      } catch (error) { reject(error) }
+    }
+    return this.#getPromises[this.#length]
+  }
+}

package/src/archiveSync.js

@@ -0,0 +1,28 @@
+import { TurtleBranchUpdater } from '../lib/turtle/connections/TurtleBranchUpdater.js'
+import { ArchiveUpdater } from './ArchiveUpdater.js'
+
+/**
+ * @typedef {import('../lib/turtle/connections/TurtleDB.js').TurtleBranchStatus} TurtleBranchStatus
+ * @typedef {import('../lib/turtle/connections/TurtleDB.js').TurtleDB} TurtleDB
+ * @typedef {import('../lib/utils/Recaller.js').Recaller} Recaller
+ */
+
+/**
+ * @param {TurtleDB} turtleDB
+ * @param {Recaller} recaller
+ * @param {string} path
+ */
+export async function archiveSync (turtleDB, recaller, path) {
+  const tbMuxBinding = async (/** @type {TurtleBranchStatus} */ status) => {
+    const turtleBranch = status.turtleBranch
+    const name = turtleBranch.name
+    const publicKey = status.publicKey
+    const archiveUpdater = new ArchiveUpdater(`to_archive_#${name}`, publicKey, recaller, path)
+    const tbUpdater = new TurtleBranchUpdater(`from_archive_#${name}`, turtleBranch, publicKey, true, recaller)
+    archiveUpdater.connect(tbUpdater)
+    archiveUpdater.start()
+    tbUpdater.start()
+    if (!status.bindings.has(tbMuxBinding)) await tbUpdater.settle
+  }
+  turtleDB.bind(tbMuxBinding)
+}

package/src/fileSync.js

@@ -0,0 +1,155 @@
+import { join } from 'path'
+import { compile } from '@gerhobbelt/gitignore-parser'
+import { linesToString } from '../lib/utils/fileTransformer.js'
+import { logInfo } from '../lib/utils/logger.js'
+import { THROW } from '../lib/turtle/TurtleDictionary.js'
+import { equalFileObjects, proxyFolder, UPDATES_HANDLER } from './proxyFolder.js'
+
+/**
+ * @typedef {import('../lib/turtle/connections/TurtleDB.js').TurtleDB} TurtleDB
+ * @typedef {import('../lib/turtle/Signer.js').Signer} Signer
+ * @typedef {import('../lib/turtle/Workspace.js').Workspace} Workspace
+ */
+
+const gitFilteredFilenames = (filesObject = {}, turtleDBFolder, gitignoreContent) => {
+  gitignoreContent = linesToString(gitignoreContent || filesObject['.gitignore'] || ['.env', '.DS_Store'])
+  const gitignore = compile(gitignoreContent)
+  const filteredKeys = Object.keys(filesObject).filter(filename => {
+    return gitignore.accepts(filename) && !filename.startsWith(turtleDBFolder + '/')
+  })
+  // console.log(filteredKeys, turtleDBFolder)
+  return filteredKeys.sort()
+}
+
+const replicateFiles = (a, b, turtleDBFolder, applyGitFilter) => {
+  const aFilenames = applyGitFilter ? gitFilteredFilenames(a, turtleDBFolder) : Object.keys(a)
+  let bFilenames = applyGitFilter ? gitFilteredFilenames(b, turtleDBFolder) : Object.keys(b)
+  let touched = false
+  aFilenames.forEach(key => {
+    if (!equalFileObjects(b[key], a[key], key)) {
+      // console.log(b[key], a[key])
+      console.log(`setting b[${key}], replace:${!!b[key]}`)
+      b[key] = a[key]
+      touched = true
+    }
+  })
+  bFilenames = applyGitFilter ? gitFilteredFilenames(b, turtleDBFolder) : Object.keys(b) // after possible .gitignore update
+  bFilenames.forEach(key => {
+    if (!aFilenames.includes(key)) {
+      console.log(`deleting b[${key}]`)
+      delete b[key]
+      touched = true
+    }
+  })
+  return touched
+}
+
+const syncModule = (turtleBranch, moduleFolder, folderFilesObject, turtleDBFolder) => {
+  // return
+  const setModuleFiles = moduleFilesObject => {
+    const folderFilesObjectCopy = {}
+    Object.keys(folderFilesObject)
+      .filter(filename => !filename.startsWith(moduleFolder))
+      .forEach(filename => {
+        folderFilesObjectCopy[filename] = folderFilesObject[filename]
+      })
+    Object.keys(moduleFilesObject).forEach(filename => {
+      folderFilesObjectCopy[join(moduleFolder, filename)] = moduleFilesObject[filename]
+    })
+    replicateFiles(folderFilesObjectCopy, folderFilesObject, turtleDBFolder, false)
+  }
+  const turtleWatcher = async () => {
+    const moduleFilesObject = turtleBranch.lookup('document', 'value')
+    if (!moduleFilesObject || typeof moduleFilesObject !== 'object') throw new Error(`value described in synced folder ${moduleFolder} is not a module object`)
+    setModuleFiles(moduleFilesObject)
+  }
+  turtleBranch.recaller.watch(`fileSync"${turtleBranch.name}"`, turtleWatcher)
+  return () => {
+    turtleBranch.recaller.unwatch(turtleWatcher)
+  }
+}
+
+/**
+ * @param {string} name
+ * @param {TurtleDB} turtleDB
+ * @param {Signer} signer
+ * @param {string} folder
+ * @param {string} resolve
+ * @param {string} turtleDBFolder
+ * @returns {Promise<Workspace>}
+ */
+export async function fileSync (name, turtleDB, signer, folder = '.', resolve = THROW, turtleDBFolder = '.turtleDB') {
+  const workspace = await turtleDB.makeWorkspace(signer, name)
+  const workspaceFilesObject = workspace.lookup('document', 'value') || {}
+  const folderFilesObject = proxyFolder(folder, turtleDB.recaller)
+
+  // initialize between folder and workspace
+  if (gitFilteredFilenames(folderFilesObject).length) {
+    if (Object.keys(workspaceFilesObject).length) {
+      // clobber for now
+      logInfo(() => console.log('clobber filesystem files for now'))
+      replicateFiles(workspaceFilesObject, folderFilesObject, turtleDBFolder, true)
+    } else {
+      logInfo(() => console.log('empty workspace, replicating files to workspace'))
+      replicateFiles(folderFilesObject, workspaceFilesObject, turtleDBFolder, true)
+      await workspace.commit(workspaceFilesObject, 'initial commit of local tracked files')
+    }
+  } else {
+    if (Object.keys(workspaceFilesObject).length) {
+      replicateFiles(workspaceFilesObject, folderFilesObject, turtleDBFolder, true)
+    } else {
+      throw new Error('TODO: handle first time user')
+    }
+  }
+
+  const syncModulesBySymlink = {}
+  const addSymlink = symlink => {
+    if (!syncModulesBySymlink[symlink]) {
+      let unsync = async () => {
+        unsync = null
+      }
+      (async () => {
+        const publicKey = symlink.match(/\/([0-9a-z]{40,50})$/)?.[1]
+        const turtleBranch = await turtleDB.summonBoundTurtleBranch(publicKey)
+        unsync &&= await syncModule(turtleBranch, symlink, folderFilesObject, turtleDBFolder) // &&= in case it got cancelled before the summon completed
+      })()
+      syncModulesBySymlink[symlink] = { count: 0, unsync }
+    }
+    ++syncModulesBySymlink[symlink].count
+  }
+  const removeSymlink = symlink => {
+    if (!syncModulesBySymlink[symlink]) throw new Error(`unexpected old symlink "${symlink}" not being tracked`)
+    const { count, unsync } = syncModulesBySymlink[symlink] || {}
+    if (count > 0) {
+      --syncModulesBySymlink[symlink].count
+    } else {
+      unsync?.()
+      delete syncModulesBySymlink[symlink]
+    }
+  }
+  const folderUpdatesHandler = async (changes) => {
+    const changesFilenames = gitFilteredFilenames(changes, turtleDBFolder, folderFilesObject['.gitignore'])
+    if (!changesFilenames.length) return
+    changesFilenames.forEach((filename) => {
+      const { oldValue, newValue } = changes[filename]
+      if (!equalFileObjects(oldValue, workspaceFilesObject[filename], filename)) throw new Error(`old file value mismatch "${filename}" (TODO: handle collision case)`) // TODO: handle collision case
+      workspaceFilesObject[filename] = newValue
+      const oldSymlink = oldValue?.symlink
+      const newSymlink = newValue?.symlink
+      if (oldSymlink === newSymlink) return
+      if (oldSymlink) removeSymlink(oldSymlink)
+      if (newSymlink) addSymlink(newSymlink)
+    })
+    await workspace.commit(workspaceFilesObject, 'changes from filesystem')
+  }
+
+  // setup symlinks
+  gitFilteredFilenames(folderFilesObject).forEach(filename => {
+    const symlink = folderFilesObject[filename].symlink
+    if (symlink) addSymlink(symlink)
+  })
+
+  folderFilesObject[UPDATES_HANDLER] = folderUpdatesHandler
+
+  return workspace
+}

package/src/getExistenceLength.js

@@ -0,0 +1,19 @@
+export async function getExistenceLength (getExists) {
+  let lengthGuess = 0
+  if (await getExists(0)) {
+    let p = 0
+    while (await getExists(2 ** p)) ++p
+    if (p < 2) {
+      lengthGuess = 2 ** p
+    } else {
+      lengthGuess = 2 ** (p - 1)
+      let direction = 1
+      for (let q = p - 2; q >= 0; --q) {
+        lengthGuess += direction * 2 ** q
+        direction = await getExists(lengthGuess) ? 1 : -1
+      }
+      if (direction === 1) ++lengthGuess
+    }
+  }
+  return lengthGuess
+}

package/src/manageCert.js

@@ -0,0 +1,36 @@
+import { dirname } from 'path'
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { createCA, createCert } from 'mkcert'
+import { logError } from '../lib/utils/logger.js'
+
+export async function manageCert (fullcertpath) {
+  try {
+    mkdirSync(dirname(fullcertpath), { recursive: true })
+    if (existsSync(fullcertpath)) {
+      return JSON.parse(
+        readFileSync(fullcertpath, {
+          encoding: 'utf8'
+        })
+      )
+    }
+  } catch (error) {
+    logError(() => console.error(error))
+  }
+  const ca = await createCA({
+    organization: 'TURTLES, Turtles, turtles, etc.',
+    countryCode: 'US',
+    state: 'California',
+    locality: 'Danville',
+    validity: 365
+  })
+  const { key, cert } = await createCert({
+    ca: {
+      key: ca.key,
+      cert: ca.cert
+    },
+    domains: ['127.0.0.1', 'localhost'],
+    validity: 365
+  })
+  writeFileSync(fullcertpath, JSON.stringify({ key, cert }, null, 4))
+  return { key, cert }
+}