@tetherto/mdk-core 0.0.0 → 0.12.1

package/lib/worker-infra.js

@@ -0,0 +1,221 @@
+'use strict'
+
+const debug = require('debug')('mdk:worker-infra')
+const StoreFacility = require('@tetherto/hp-svc-facs-store')
+const LogsService = require('./services/logs.service')
+const LogHistoryService = require('./services/log-history.service')
+const SettingsService = require('./services/settings.service')
+const CommentsService = require('./services/comments.service')
+const AlertsService = require('./services/alerts.service')
+const StatsService = require('./services/stats.service')
+const SnapsService = require('./services/snaps.service')
+const ActionsService = require('./services/actions.service')
+const DeviceProvisioningService = require('./services/provisioning.service')
+const gLibStats = require('./stats')
+
+const THING_CONF_DEFAULTS = {
+  collectSnapsItvMs: 60000,
+  rotateLogsItvMs: 120000,
+  refreshLogsCacheItvMs: 60000,
+  statsRtdItvMs: 30000,
+  thingQueryConcurrency: 25,
+  storeSnapItvMs: 300000,
+  collectSnapTimeoutMs: 120000,
+  logKeepCount: 3
+}
+
+const TF_MS = { m: 60000, h: 3600000, D: 86400000 }
+
+function _timeframeIntervals () {
+  return gLibStats.defaults.timeframes.map(([tf]) => {
+    const n = parseInt(tf, 10)
+    const unit = tf.slice(String(n).length)
+    return [tf, n * (TF_MS[unit] || 60000)]
+  })
+}
+
+/**
+ * Builds the injectable service set for a runtime-hosted worker:
+ * store → provisioning (+ one-time seeding) → logs/settings/comments/
+ * alerts/stats/log-history/actions/snaps.
+ *
+ * Device access is late-bound: services capture deviceCall(), which routes
+ * through the accessor installed by bindRuntime(runtime) once the
+ * WorkerRuntime exists. Boot order is therefore
+ *   createWorkerInfra → new WorkerRuntime({ services }) → bindRuntime →
+ *   runtime.start → startTimers
+ * and teardown is stop({ runtime }).
+ *
+ * opts:
+ *   storeDir     (required) persistent store directory
+ *   deviceType   (required) e.g. miner-wm-m56s
+ *   deviceTags   provisioning tags, e.g. ['whatsminer']
+ *   specTags     alert/stat spec lookup tags, e.g. ['miner']
+ *   baseType     stats base type, e.g. 'miner'
+ *   alertsLib    worker alerts template ({ specs })
+ *   statsLib     worker stats template ({ conf, specs })
+ *   thingConf    cadence/behavior overrides merged over THING_CONF_DEFAULTS;
+ *                `allowedAddressCidrs` (e.g. ['10.0.0.0/8']) is the operator
+ *                allowlist for device addresses set by remote registerThing/
+ *                updateThing (default: any address except loopback,
+ *                link-local/metadata, unspecified, multicast)
+ *   provisioningConf  extra provisioning conf (pools, ...)
+ *   seedDevices  registerThing payloads applied once when the store is empty
+ *   writeActions whitelist entries [[action, votes], ...]
+ *   addlStats    extra stat cadences [[tf, itvMs], ...];
+ *                defaults to [['rtd', thingConf.statsRtdItvMs]]
+ */
+async function createWorkerInfra (opts) {
+  if (!opts || !opts.storeDir) throw new Error('ERR_STORE_DIR_REQUIRED')
+  if (!opts.deviceType) throw new Error('ERR_DEVICE_TYPE_REQUIRED')
+
+  const thingConf = { ...THING_CONF_DEFAULTS, ...opts.thingConf }
+
+  const store = new StoreFacility({}, { storeDir: opts.storeDir }, {})
+  await new Promise((resolve, reject) => store.start((err) => (err ? reject(err) : resolve())))
+
+  const db = await store.getBee({ name: 'main' }, { keyEncoding: 'utf-8' })
+  await db.ready()
+
+  let _getDeviceContext = null
+  function deviceCall (deviceId, fn) {
+    if (!_getDeviceContext) throw new Error('ERR_RUNTIME_NOT_BOUND')
+    const ctx = _getDeviceContext(deviceId)
+    if (!ctx) throw new Error(`ERR_DEVICE_UNAVAILABLE: ${deviceId}`)
+    return fn(ctx.device)
+  }
+
+  const logs = new LogsService({
+    store,
+    metaLogs: db.sub('meta_logs_00'),
+    conf: thingConf
+  })
+
+  const provisioning = new DeviceProvisioningService({
+    db: db.sub('things'),
+    logs,
+    deviceType: opts.deviceType,
+    deviceTags: opts.deviceTags || [],
+    conf: {
+      allowDuplicateIPs: thingConf.allowDuplicateIPs,
+      allowedAddressCidrs: thingConf.allowedAddressCidrs,
+      ...opts.provisioningConf
+    }
+  })
+  await provisioning.init()
+
+  let seeded = 0
+  if (!provisioning.listDeviceIds().length && Array.isArray(opts.seedDevices)) {
+    for (const seed of opts.seedDevices) {
+      // Seeds are operator config, not remote input: no address policy.
+      await provisioning.registerThing(seed, { trusted: true })
+      seeded++
+    }
+  }
+
+  const settings = new SettingsService({ settingsDb: db.sub('settings') })
+
+  const comments = new CommentsService({
+    loadThing: (req) => provisioning.loadThing(req),
+    saveThing: (dev) => provisioning.saveThing(dev),
+    checkThingExists: (req) => provisioning.checkThingExists(req),
+    generateId: () => provisioning.generateId(),
+    // Set once the transport forwards an authenticated identity as ctx.user.
+    requireAuthenticatedUser: thingConf.requireAuthenticatedCommentUser === true
+  })
+
+  const specTags = opts.specTags || []
+
+  // snaps ↔ alerts are mutually recursive (alerts persist what snaps collect,
+  // snaps evaluate alerts per snapshot) — resolved via this late binding.
+  let snaps = null
+
+  const alerts = new AlertsService({
+    logs,
+    lib: opts.alertsLib,
+    conf: { thing: thingConf },
+    specTags,
+    listDevices: () => (snaps ? snaps.listLast() : [])
+  })
+
+  const stats = new StatsService({
+    lib: opts.statsLib,
+    specTags,
+    baseType: opts.baseType,
+    listDeviceIds: () => provisioning.listDeviceIds(),
+    getDeviceMeta: (id) => provisioning.getDeviceMeta(id),
+    getLast: (id) => (snaps ? snaps.getLast(id) : undefined),
+    getRealtimeData: (id) => deviceCall(id, (device) => device.getRealtimeData()),
+    processAlerts: (dev) => alerts.processThingAlerts(dev),
+    logs,
+    conf: thingConf
+  })
+
+  const logHistory = new LogHistoryService({
+    logs,
+    getDeviceInfo: (id) => provisioning.getDevice(id),
+    statTimeframes: gLibStats.defaults.timeframes,
+    conf: thingConf
+  })
+
+  const actions = new ActionsService({
+    listDevices: () => provisioning.listDevices({ limit: 100000 }),
+    validateWriteAction: (dev, action, params) =>
+      deviceCall(dev.id, (device) => device.validateWriteAction(action, ...params))
+  })
+  if (Array.isArray(opts.writeActions)) actions.whitelistActions(opts.writeActions)
+
+  snaps = new SnapsService({
+    listDeviceIds: () => provisioning.listDeviceIds(),
+    getDeviceMeta: (id) => provisioning.getDeviceMeta(id),
+    collectSnap: (id) => deviceCall(id, (device) => device.getSnap()),
+    processAlerts: (dev) => alerts.processThingAlerts(dev),
+    saveAlerts: () => alerts.saveAlerts(),
+    logs,
+    conf: thingConf
+  })
+
+  const services = { logs, logHistory, settings, comments, alerts, stats, snaps, actions, provisioning }
+
+  const addlStats = opts.addlStats || [['rtd', thingConf.statsRtdItvMs]]
+  const timers = []
+
+  return {
+    store,
+    db,
+    services,
+    seeded,
+    thingConf,
+    deviceCall,
+    bindRuntime (runtime) {
+      _getDeviceContext = (deviceId) => runtime.getDeviceContext(deviceId)
+    },
+    startTimers () {
+      snaps.start()
+      timers.push(
+        setInterval(() => { logs.rotateLogs().catch((e) => debug('rotateLogs: %s', e.message)) }, thingConf.rotateLogsItvMs),
+        setInterval(() => { logs.refreshLogsCache().catch((e) => debug('refreshLogsCache: %s', e.message)) }, thingConf.refreshLogsCacheItvMs)
+      )
+      for (const [tf, itvMs] of addlStats) {
+        timers.push(setInterval(() => {
+          Promise.resolve(stats.buildStats(`stat-${tf}`)).catch((e) => debug('stat-%s: %s', tf, e.message))
+        }, itvMs))
+      }
+      for (const [tf, ms] of _timeframeIntervals()) {
+        timers.push(setInterval(() => {
+          Promise.resolve(stats.buildStats(`stat-${tf}`, new Date())).catch((e) => debug('stat-%s: %s', tf, e.message))
+        }, ms))
+      }
+      for (const timer of timers) timer.unref()
+    },
+    async stop ({ runtime } = {}) {
+      snaps.stop()
+      for (const timer of timers) clearInterval(timer)
+      timers.length = 0
+      if (runtime) await runtime.stop()
+      await new Promise((resolve) => store.stop(() => resolve()))
+    }
+  }
+}
+
+module.exports = { createWorkerInfra, THING_CONF_DEFAULTS }

package/package.json

@@ -1 +1,64 @@
-{"name":"@tetherto/mdk-core","version":"0.0.0"}
+{
+  "name": "@tetherto/mdk-core",
+  "version": "0.12.1",
+  "description": "MDK bootstrap utilities and worker-infra services — kernel/gateway lifecycle plus injectable log/comment/alert/stats/settings/provisioning services for runtime-hosted workers",
+  "main": "index.js",
+  "keywords": [
+    "tether",
+    "mdk"
+  ],
+  "author": "Tether",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "lint": "standard",
+    "lint:fix": "standard --fix",
+    "test": "npm run lint && npm run test:unit && npm run test:integration",
+    "test:unit": "NODE_ENV=test brittle tests/unit/**/*.js",
+    "test:integration": "NODE_ENV=test brittle 'tests/integration/**/*.test.js'",
+    "test:coverage": "NODE_ENV=test brittle --coverage 'tests/**/*.test.js'"
+  },
+  "dependencies": {
+    "@tetherto/mdk-gateway": "^0.12.1",
+    "@tetherto/mdk-kernel": "^0.12.1",
+    "@bitfinex/bfx-facs-http": "^1.1.3",
+    "@bitfinex/bfx-facs-interval": "^1.0.0",
+    "@bitfinex/bfx-facs-scheduler": "^1.0.0",
+    "@bitfinex/lib-js-util-base": "^2.1.0",
+    "@bitfinex/lib-js-util-promise": "^1.1.0",
+    "@tetherto/hp-svc-facs-store": "^1.0.0",
+    "@tetherto/svc-facs-action-approver": "^1.0.0",
+    "async": "3.2.6",
+    "debug": "4.4.1",
+    "mingo": "6.5.6",
+    "uuid": "14.0.0"
+  },
+  "devDependencies": {
+    "brittle": "3.18.0",
+    "hyperdht": "6.34.1",
+    "standard": "17.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tetherto/mdk.git",
+    "directory": "backend/core/mdk"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.js",
+    "services.js",
+    "worker.js",
+    "lib/",
+    "utils/",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./index.js",
+    "./lib/local-discovery": "./lib/local-discovery.js",
+    "./package.json": "./package.json"
+  }
+}

package/services.js

@@ -0,0 +1,246 @@
+const { execFileSync } = require('child_process')
+const path = require('path')
+const fs = require('fs')
+const initialize = require('./utils/initialize')
+const { buildComposeYaml } = require('./utils/compose-yaml')
+const { ensureConfigFromExamples, gatewayPackageDir } = require('./utils/service-bootstrap')
+
+// Every file startServices writes into the site dir carries this marker. A
+// file without it (or the legacy header) is the user's, and is never
+// overwritten unless config.overwrite is set.
+const GENERATED_MARKER = '@generated by @tetherto/mdk-core startServices'
+const LEGACY_MARKERS = ['Auto-generated by @tetherto/mdk']
+
+function _isGenerated (content) {
+  return content.includes(GENERATED_MARKER) || LEGACY_MARKERS.some((m) => content.includes(m))
+}
+
+/**
+ * Writes `content` (which must already contain GENERATED_MARKER) to `file`,
+ * refusing to replace an existing file that was not generated by us — or
+ * whose content is not byte-identical to what we would write (`same`).
+ */
+function writeGenerated (file, content, { overwrite = false, same = null } = {}) {
+  if (!overwrite && fs.existsSync(file)) {
+    const existing = fs.readFileSync(file, 'utf8')
+    if (!_isGenerated(existing) && existing !== same) {
+      throw new Error(
+        `ERR_MDK_GENERATED_FILE_CONFLICT: ${file} exists and was not generated by @tetherto/mdk-core; ` +
+        'move it away or pass overwrite: true'
+      )
+    }
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  fs.writeFileSync(file, content)
+}
+
+// Bind a published port to loopback unless the caller names a host.
+function _publishPort (port, host) {
+  return `${host || '127.0.0.1'}:${port}:${port}`
+}
+
+/**
+ * Generates (and optionally starts) a PM2 ecosystem or Docker compose stack
+ * in the current working directory.
+ *
+ * config: { runtime: 'pm2' | 'docker', repoRoot, services, env?, image?, shouldAutoStart?,
+ *           repoRoot  the MDK source checkout the services run from (required;
+ *                    never searched for). Config is seeded from its example
+ *                    files and it is passed to the processes as MDK_REPO_ROOT.
+ *           host?    Docker: interface published gateway ports bind to
+ *                    (default '127.0.0.1'; per-service `svc.host` wins),
+ *           overwrite?  replace site-dir files that were not generated by
+ *                    mdk-core (default false: refuse with ERR_MDK_GENERATED_FILE_CONFLICT) }
+ */
+// The checkout is always named by the caller — never found by walking up
+// from the working directory or this package.
+function _resolveRepoRoot (config) {
+  const root = config.repoRoot
+  if (typeof root !== 'string' || !root.trim()) {
+    throw new Error('ERR_MDK_REPO_ROOT_REQUIRED: startServices needs config.repoRoot — the MDK source checkout the services run from')
+  }
+  return path.resolve(root)
+}
+
+const startServices = async (config) => {
+  if (config.runtime === 'pm2') {
+    return startPm2(config)
+  }
+
+  if (config.runtime === 'docker') {
+    return startDocker(config)
+  }
+
+  throw new Error(`Unsupported runtime: ${config.runtime}`)
+}
+
+function _copyGenerated (src, dest, opts) {
+  const body = fs.readFileSync(src, 'utf8')
+  // The marker goes on line 1 (a comment before 'use strict' keeps the
+  // directive prologue intact). An unmarked copy identical to the source —
+  // what older versions wrote — still counts as ours.
+  writeGenerated(dest, `// ${GENERATED_MARKER} — do not edit; rewritten on every run\n${body}`, { ...opts, same: body })
+}
+
+function ensureMdkWorker (cwd = process.cwd(), opts = {}) {
+  const mdkDir = path.join(cwd, 'mdk')
+  const utilsDir = path.join(mdkDir, 'utils')
+
+  _copyGenerated(path.join(__dirname, 'worker.js'), path.join(mdkDir, 'worker.js'), opts)
+  _copyGenerated(
+    path.join(__dirname, 'utils', 'service-bootstrap.js'),
+    path.join(utilsDir, 'service-bootstrap.js'),
+    opts
+  )
+
+  // Leftovers of the old pm2 bootstrap — removed only when they are ours.
+  for (const legacy of [
+    path.join(mdkDir, 'pm2-bootstrap.js'),
+    path.join(utilsDir, 'pm2-bootstrap.js')
+  ]) {
+    if (fs.existsSync(legacy) && _isGenerated(fs.readFileSync(legacy, 'utf8'))) fs.unlinkSync(legacy)
+  }
+
+  return path.join(mdkDir, 'worker.js')
+}
+
+function startPm2 (config) {
+  const mdkEnv = config.env || 'development'
+  const repoRoot = _resolveRepoRoot(config)
+  const writeOpts = { overwrite: config.overwrite === true }
+
+  initialize({ sources: repoRoot })
+  ensureMdkWorker(process.cwd(), writeOpts)
+  ensureConfigFromExamples(path.join(gatewayPackageDir(), 'config'))
+
+  const workerScript = 'mdk/worker.js'
+  const sharedEnv = {
+    MDK_ENV: mdkEnv,
+    MDK_REPO_ROOT: repoRoot,
+    NODE_ENV: mdkEnv === 'production' ? 'production' : 'development'
+  }
+
+  const apps = config.services.map(svc => {
+    if (svc.kind === 'gateway') {
+      return {
+        name: `mdk-${svc.name}`,
+        script: workerScript,
+        cwd: process.cwd(),
+        exec_mode: 'fork',
+        instances: 1,
+        env: {
+          ...sharedEnv,
+          SERVICE: 'gateway',
+          PORT: String(svc.port)
+        }
+      }
+    }
+
+    return {
+      name: `mdk-${svc.name}`,
+      script: workerScript,
+      cwd: process.cwd(),
+      exec_mode: 'fork',
+      instances: 1,
+      env: {
+        ...sharedEnv,
+        SERVICE: 'worker',
+        WORKER: svc.worker,
+        TYPE: svc.type,
+        RACK: svc.rack
+      }
+    }
+  })
+
+  // PM2 only treats filenames containing .config.js (or .json/.yaml) as ecosystem files.
+  const file = path.join(process.cwd(), 'ecosystem.config.js')
+  const content = `// ${GENERATED_MARKER} — do not edit manually
+module.exports = ${JSON.stringify({ apps }, null, 2)}
+`
+
+  writeGenerated(file, content, writeOpts)
+  if (config.shouldAutoStart) {
+    execFileSync('pm2', ['start', file], { stdio: 'inherit' })
+  }
+}
+
+function startDocker (config) {
+  if (!config.image) {
+    throw new Error('Docker runtime requires "image"')
+  }
+
+  const mdkEnv = config.env || 'development'
+  const siteDir = process.cwd()
+  const repoRoot = _resolveRepoRoot(config)
+  const repoMount = path.relative(siteDir, repoRoot).split(path.sep).join('/') || '.'
+
+  const writeOpts = { overwrite: config.overwrite === true }
+
+  initialize({ sources: repoRoot })
+  ensureMdkWorker(siteDir, writeOpts)
+  ensureConfigFromExamples(path.join(gatewayPackageDir(), 'config'))
+
+  const siteMount = path.relative(repoRoot, siteDir).split(path.sep).join('/') || '.'
+  const workingDir = `/app/repo/${siteMount}`
+  const entrypoint = path.posix.join('/app/repo', siteMount, 'docker-entrypoint.sh')
+
+  const sharedEnv = {
+    MDK_ENV: mdkEnv,
+    MDK_REPO_ROOT: '/app/repo',
+    NODE_ENV: mdkEnv === 'production' ? 'production' : 'development'
+  }
+
+  const services = {}
+
+  for (const svc of config.services) {
+    const base = {
+      image: config.image,
+      working_dir: workingDir,
+      entrypoint: ['sh', entrypoint],
+      restart: 'unless-stopped',
+      volumes: [`${repoMount}:/app/repo:cached`],
+      environment: { ...sharedEnv }
+    }
+
+    if (svc.kind === 'gateway') {
+      services[svc.name] = {
+        ...base,
+        environment: {
+          ...base.environment,
+          SERVICE: 'gateway',
+          PORT: String(svc.port)
+        },
+        // Loopback unless an interface is explicitly configured.
+        ports: [_publishPort(svc.port, svc.host || config.host)]
+      }
+      continue
+    }
+
+    services[svc.name] = {
+      ...base,
+      environment: {
+        ...base.environment,
+        SERVICE: 'worker',
+        WORKER: svc.worker,
+        TYPE: svc.type,
+        RACK: svc.rack
+      }
+    }
+  }
+
+  const compose = {
+    version: '3.8',
+    services
+  }
+
+  const file = path.join(siteDir, 'docker-compose.generated.yml')
+  writeGenerated(file, `# ${GENERATED_MARKER} — do not edit manually\n${buildComposeYaml(compose)}`, writeOpts)
+
+  if (config.shouldAutoStart) {
+    execFileSync('docker', ['compose', '-f', file, 'up', '-d'], { stdio: 'inherit', cwd: siteDir })
+  }
+
+  return { file, repoRoot, siteDir }
+}
+
+module.exports = { startServices, GENERATED_MARKER }

package/utils/compose-yaml.js

@@ -0,0 +1,56 @@
+'use strict'
+
+function yamlScalar (value) {
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    return String(value)
+  }
+  const str = String(value)
+  if (/^[a-zA-Z0-9._/-]+$/.test(str)) return str
+  return JSON.stringify(str)
+}
+
+function yamlEnv (env) {
+  const lines = ['    environment:']
+  for (const [key, val] of Object.entries(env)) {
+    lines.push(`      ${key}: ${yamlScalar(val)}`)
+  }
+  return lines
+}
+
+function buildComposeYaml (compose) {
+  const lines = [`version: "${compose.version}"`, 'services:']
+
+  for (const [name, svc] of Object.entries(compose.services)) {
+    lines.push(`  ${name}:`)
+    lines.push(`    image: ${yamlScalar(svc.image)}`)
+    if (svc.working_dir) lines.push(`    working_dir: ${yamlScalar(svc.working_dir)}`)
+    if (svc.entrypoint) {
+      lines.push(`    entrypoint: [${svc.entrypoint.map((c) => JSON.stringify(c)).join(', ')}]`)
+    }
+    if (svc.command) {
+      const cmd = Array.isArray(svc.command) ? svc.command : [svc.command]
+      lines.push(`    command: [${cmd.map((c) => JSON.stringify(c)).join(', ')}]`)
+    }
+    if (svc.restart) lines.push(`    restart: ${yamlScalar(svc.restart)}`)
+    lines.push(...yamlEnv(svc.environment))
+    if (svc.ports?.length) {
+      lines.push('    ports:')
+      for (const port of svc.ports) lines.push(`      - "${port}"`)
+    }
+    if (svc.volumes?.length) {
+      lines.push('    volumes:')
+      for (const vol of svc.volumes) lines.push(`      - ${vol}`)
+    }
+  }
+
+  if (compose.volumes) {
+    lines.push('volumes:')
+    for (const volName of Object.keys(compose.volumes)) {
+      lines.push(`  ${volName}:`)
+    }
+  }
+
+  return lines.join('\n') + '\n'
+}
+
+module.exports = { buildComposeYaml }

package/utils/constants.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const MDK_ROOT = 'tmp'
+const MDK_STORE = 'store'
+const KERNEL_CLUSTER = 'cluster-0'
+const WRK_TYPES = {
+  Kernel: 'wrk-kernel',
+  GATEWAY: 'wrk-node-http'
+}
+const LIB_TYPES = {
+  Kernel: 'core/kernel',
+  GATEWAY: 'core/gateway',
+  AVALON: 'workers/miners/avalon',
+  BITDEER: 'workers/containers/bitdeer',
+  ANTSPACE: 'workers/containers/antspace',
+  ABB: 'workers/power-meter/abb',
+  SATEC: 'workers/power-meter/satec',
+  SCHNEIDER: 'workers/power-meter/schneider',
+  SENECA: 'workers/temperature',
+  OCEAN_POOL: 'workers/minerpools/ocean',
+  F2_POOL: 'workers/minerpools/f2pool'
+}
+
+module.exports = {
+  WRK_TYPES,
+  MDK_ROOT,
+  MDK_STORE,
+  KERNEL_CLUSTER,
+  LIB_TYPES
+}

package/utils/index.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const IntervalsFacility = require('@bitfinex/bfx-facs-interval')
+const StoreFacility = require('@tetherto/hp-svc-facs-store')
+const ActionApproverFacility = require('@tetherto/svc-facs-action-approver')
+
+const _startFacility = (facility) => {
+  return new Promise((resolve, reject) => {
+    facility.start((err) => (err ? reject(err) : resolve()))
+  })
+}
+
+const createFacs = async (storeDir, ctx = {}) => {
+  const facs = {}
+  facs.interval_0 = new IntervalsFacility(null, {}, ctx)
+  await _startFacility(facs.interval_0)
+
+  facs.store_s1 = new StoreFacility(null, { storeDir }, ctx)
+  await _startFacility(facs.store_s1)
+
+  facs.actionApprover_0 = new ActionApproverFacility(null, {}, ctx)
+  await _startFacility(facs.actionApprover_0)
+
+  return facs
+}
+
+module.exports = {
+  createFacs
+}