pockethost 1.0.0-rc.1

package/dist/mothership-app/migrations/1706060446_updated_instances.js

@@ -0,0 +1,44 @@
+/// <reference path="../pb_data/types.d.ts" />
+migrate((db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("etae8tuiaxl6xfv")
+
+  // update
+  collection.schema.addField(new SchemaField({
+    "system": false,
+    "id": "5oz9huwg",
+    "name": "cname",
+    "type": "text",
+    "required": false,
+    "presentable": false,
+    "unique": false,
+    "options": {
+      "min": null,
+      "max": null,
+      "pattern": "^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,24}$"
+    }
+  }))
+
+  return dao.saveCollection(collection)
+}, (db) => {
+  const dao = new Dao(db)
+  const collection = dao.findCollectionByNameOrId("etae8tuiaxl6xfv")
+
+  // update
+  collection.schema.addField(new SchemaField({
+    "system": false,
+    "id": "5oz9huwg",
+    "name": "cname",
+    "type": "text",
+    "required": false,
+    "presentable": false,
+    "unique": false,
+    "options": {
+      "min": null,
+      "max": null,
+      "pattern": "^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\\.)+[a-zA-Z]{2,6}$"
+    }
+  }))
+
+  return dao.saveCollection(collection)
+})

package/dist/mothership-app/pb_hooks/src/instances-create.pb.js

@@ -0,0 +1,65 @@
+/*
+{
+  "subdomain": "foo"
+}
+*/
+routerAdd(
+  'POST',
+  '/api/instance',
+  (c) => {
+    const dao = $app.dao()
+    const { audit, mkLog } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+
+    const log = mkLog(`POST:instance`)
+
+    const authRecord = /** @type {models.Record} */ (c.get('authRecord')) // empty if not authenticated as regular auth record
+    log(`***authRecord`, JSON.stringify(authRecord))
+
+    if (!authRecord) {
+      throw new Error(`Expected authRecord here`)
+    }
+
+    log(`***TOP OF POST`)
+    let data = /** @type{ {subdomain?: string} } */ (
+      new DynamicModel({
+        subdomain: '',
+      })
+    )
+
+    log(`***before bind`)
+
+    c.bind(data)
+
+    log(`***after bind`)
+
+    // This is necessary for destructuring to work correctly
+    data = JSON.parse(JSON.stringify(data))
+
+    const { subdomain } = data
+
+    log(`***vars`, JSON.stringify({ subdomain }))
+
+    if (!subdomain) {
+      throw new BadRequestError(
+        `Subdomain is required when creating an instance.`,
+      )
+    }
+
+    const { versions } = require(`${__hooks}/versions.js`)
+
+    const collection = dao.findCollectionByNameOrId('instances')
+    const record = new Record(collection)
+    record.set('uid', authRecord.getId())
+    record.set('subdomain', subdomain)
+    record.set('status', 'idle')
+    record.set('version', versions[0])
+    record.set('syncAdmin', true)
+    record.set('notifyMaintenanceMode', true)
+
+    const form = new RecordUpsertForm($app, record)
+    form.submit()
+
+    return c.json(200, { instance: record })
+  },
+  $apis.requireRecordAuth(),
+)

package/dist/mothership-app/pb_hooks/src/instances-delete.pb.js

@@ -0,0 +1,69 @@
+/*
+{
+  "id": "kz4ngg77eaw1ho0",
+  "fields": {
+    "maintenance": true
+    "name": '',
+    "version": ''
+  }
+}
+*/
+routerAdd(
+  'DELETE',
+  '/api/instance/:id',
+  (c) => {
+    const dao = $app.dao()
+    const { audit, mkLog } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+
+    const log = mkLog(`DELETE:instance`)
+
+    log(`TOP OF DELETE`)
+    let data = new DynamicModel({
+      id: '',
+    })
+
+    c.bind(data)
+    log(`After bind`)
+
+    // This is necessary for destructuring to work correctly
+    data = JSON.parse(JSON.stringify(data))
+
+    const id = c.pathParam('id')
+
+    log(
+      `vars`,
+      JSON.stringify({
+        id,
+      }),
+    )
+
+    const authRecord = /** @type {models.Record} */ (c.get('authRecord')) // empty if not authenticated as regular auth record
+    log(`authRecord`, JSON.stringify(authRecord))
+
+    if (!authRecord) {
+      throw new BadRequestError(`Expected authRecord here`)
+    }
+
+    const record = dao.findRecordById('instances', id)
+    if (!record) {
+      throw new BadRequestError(`Instance ${id} not found.`)
+    }
+    if (record.get('uid') !== authRecord.id) {
+      throw new BadRequestError(`Not authorized`)
+    }
+
+    if (record.getString('status').toLowerCase() !== 'idle') {
+      throw new BadRequestError(`Instance must be shut down first.`)
+    }
+
+    const path = [$os.getenv('DATA_ROOT'), id].join('/')
+    log(`path ${path}`)
+    const res = $os.removeAll(path)
+    log(`res`, res)
+
+    dao.deleteRecord(record)
+
+    return c.json(200, { status: 'ok' })
+  },
+  $apis.requireRecordAuth(),
+)

package/dist/mothership-app/pb_hooks/src/instances-migrate-versions.pb.js

@@ -0,0 +1,33 @@
+/** Migrate version numbers */
+onAfterBootstrap((e) => {
+  const dao = $app.dao()
+  const { audit, mkLog } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+
+  const log = mkLog(`bootstrap`)
+
+  const records = dao.findRecordsByFilter(`instances`, '1=1')
+  const { versions } = require(`${__hooks}/versions.js`)
+  const unrecognized = []
+  records.forEach((record) => {
+    const v = record.get('version').trim()
+    if (versions.includes(v)) return
+    const newVersion = (() => {
+      if (v.startsWith(`~`)) {
+        const [major, minor] = v.slice(1).split('.')
+        const newVersion = [major, minor, '*'].join('.')
+        return newVersion
+      } else {
+        if (v === `^0` || v === `0` || v === '1') {
+          return versions[0]
+        }
+      }
+    })()
+    if (versions.includes(newVersion)) {
+      record.set(`version`, newVersion)
+      dao.saveRecord(record)
+    } else {
+      unrecognized.push(v)
+    }
+  })
+  log({ unrecognized })
+})

package/dist/mothership-app/pb_hooks/src/instances-notify-discord-after-create.pb.js

@@ -0,0 +1,31 @@
+/// <reference path="../types/types.d.ts" />
+
+onModelAfterCreate((e) => {
+  const dao = e.dao || $app.dao()
+  const { audit, mkLog } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+
+  const log = mkLog(`instances:create:discord:notify`)
+
+  const webhookUrl = $os.getenv('DISCORD_POCKETSTREAM_URL')
+  if (!webhookUrl) {
+    return
+  }
+  const version = e.model.get('version')
+
+  try {
+    const res = $http.send({
+      url: webhookUrl,
+      method: 'POST',
+      body: JSON.stringify({
+        content: `Someone just created an app running PocketBase v${version}`,
+      }),
+      headers: { 'content-type': 'application/json' },
+      timeout: 5, // in seconds
+    })
+  } catch (e) {
+    audit(`ERROR`, `Instance creation discord notify failed with ${e}`, {
+      log,
+      dao,
+    })
+  }
+}, 'instances')

package/dist/mothership-app/pb_hooks/src/instances-notify-on-maintenance-mode.pb.js

@@ -0,0 +1,52 @@
+onModelAfterUpdate((e) => {
+  const dao = e.dao || $app.dao()
+
+  const newModel = /** @type {models.Record} */ (e.model)
+  const oldModel = newModel.originalCopy()
+
+  const { mkLog, enqueueNotification, audit } = /** @type {Lib} */ (
+    require(`${__hooks}/lib.js`)
+  )
+
+  const log = mkLog(`maintenance-mode`)
+
+  try {
+    // Bail out if we aren't in maintenance mode
+    const isMaintenance = newModel.get('maintenance')
+    // log({ isMaintenance })
+    if (!isMaintenance) return
+
+    // Bail out if the maintenance mode flag has not changed
+    if (isMaintenance === oldModel.get(`maintenance`)) return
+
+    log(`switched`)
+    const uid = newModel.get(`uid`)
+    const user = dao.findRecordById('users', uid)
+
+    // Bail out if the user has notifications disabled globally or for the instance
+    const shouldNotify =
+      user.getBool(`notifyMaintenanceMode`) &&
+      newModel.getBool(`notifyMaintenanceMode`)
+    log({ shouldNotify })
+    if (!shouldNotify) return
+
+    // Send the email warning about maintenance mode
+    const instanceId = newModel.getId()
+    const subdomain = newModel.getString(`subdomain`)
+    const address = user.getString(`email`)
+    log({ instanceId, subdomain, address })
+    enqueueNotification(`email`, `maintenance-mode`, uid, {
+      log,
+      dao,
+      message_template_vars: {
+        subdomain,
+        instanceId,
+      },
+    })
+  } catch (e) {
+    audit('ERROR', `Failed to enqueue template with ${e}`, {
+      log,
+      dao,
+    })
+  }
+}, 'instances')

package/dist/mothership-app/pb_hooks/src/instances-reset-idle.pb.js

@@ -0,0 +1,7 @@
+/// <reference path="../types/types.d.ts" />
+
+/** Reset instance status to idle on start */
+onAfterBootstrap((e) => {
+  const dao = $app.dao()
+  dao.db().newQuery(`update instances set status='idle'`).execute()
+})

package/dist/mothership-app/pb_hooks/src/instances-update.pb.js

@@ -0,0 +1,121 @@
+/// <reference path="../types/types.d.ts" />
+
+/*
+{
+  "id": "kz4ngg77eaw1ho0",
+  "fields": {
+    "maintenance": true
+    "name": '',
+    "version": ''
+  }
+}
+*/
+routerAdd(
+  'PUT',
+  '/api/instance/:id',
+  (c) => {
+    const dao = $app.dao()
+    const { mkLog, audit, removeEmptyKeys } = /** @type {Lib} */ (
+      require(`${__hooks}/lib.js`)
+    )
+    const log = mkLog(`PUT:instance`)
+
+    log(`TOP OF PUT`)
+
+    let data =
+      /**
+       * @type {{
+       *   id: string
+       *   fields: {
+       *     subdomain: string | null
+       *     maintenance: boolean | null
+       *     version: string | null
+       *     secrets: StringKvLookup | null
+       *     syncAdmin: boolean | null
+       *     dev: boolean | null
+       *     cname: string | null
+       *     notifyMaintenanceMode: boolean | null
+       *   }
+       * }} }
+       */
+      (
+        new DynamicModel({
+          id: '',
+          fields: {
+            subdomain: null,
+            maintenance: null,
+            version: null,
+            secrets: null,
+            syncAdmin: null,
+            dev: null,
+            cname: null,
+            notifyMaintenanceMode: null,
+          },
+        })
+      )
+
+    c.bind(data)
+    log(`After bind`)
+
+    // This is necessary for destructuring to work correctly
+    data = JSON.parse(JSON.stringify(data))
+
+    const id = c.pathParam('id')
+    const {
+      fields: {
+        subdomain,
+        maintenance,
+        version,
+        secrets,
+        syncAdmin,
+        dev,
+        cname,
+        notifyMaintenanceMode,
+      },
+    } = data
+
+    log(
+      `vars`,
+      JSON.stringify({
+        id,
+        subdomain,
+        maintenance,
+        version,
+        secrets,
+        syncAdmin,
+        dev,
+        cname,
+        notifyMaintenanceMode,
+      }),
+    )
+
+    const record = dao.findRecordById('instances', id)
+    const authRecord = /** @type {models.Record} */ (c.get('authRecord')) // empty if not authenticated as regular auth record
+    log(`authRecord`, JSON.stringify(authRecord))
+
+    if (!authRecord) {
+      throw new Error(`Expected authRecord here`)
+    }
+    if (record.get('uid') !== authRecord.id) {
+      throw new BadRequestError(`Not authorized`)
+    }
+
+    const sanitized = removeEmptyKeys({
+      subdomain,
+      version,
+      maintenance,
+      secrets,
+      syncAdmin,
+      dev,
+      cname,
+      notifyMaintenanceMode,
+    })
+
+    const form = new RecordUpsertForm($app, record)
+    form.loadData(sanitized)
+    form.submit()
+
+    return c.json(200, { status: 'ok' })
+  },
+  $apis.requireRecordAuth(),
+)

package/dist/mothership-app/pb_hooks/src/instances-validate-before-create.pb.js

@@ -0,0 +1,16 @@
+/// <reference path="../types/types.d.ts" />
+
+/** Validate instance version */
+onModelBeforeCreate((e) => {
+  const dao = e.dao || $app.dao()
+  const { versions } = require(`${__hooks}/versions.js`)
+
+  const version = e.model.get('version')
+  if (!versions.includes(version)) {
+    throw new BadRequestError(
+      `Invalid version ${version}. Version must be one of: ${versions.join(
+        ', ',
+      )}`,
+    )
+  }
+}, 'instances')

package/dist/mothership-app/pb_hooks/src/instances-validate-before-update.pb.js

@@ -0,0 +1,43 @@
+/// <reference path="../types/types.d.ts" />
+
+/** Validate instance version */
+onModelBeforeUpdate((e) => {
+  const dao = e.dao || $app.dao()
+  const { versions } = require(`${__hooks}/versions.js`)
+
+  const version = e.model.get('version')
+  if (!versions.includes(version)) {
+    throw new BadRequestError(
+      `Invalid version ${version}. Version must be one of: ${versions.join(
+        ', ',
+      )}`,
+    )
+  }
+
+  const id = e.model.getId()
+  const cname = e.model.get('cname')
+  if (cname.length > 0) {
+    const result = new DynamicModel({
+      id: '',
+    })
+
+    const inUse = (() => {
+      try {
+        dao
+          .db()
+          .newQuery(
+            `select id from instances where cname='${cname}' and id <> '${id}'`,
+          )
+          .one(result)
+      } catch (e) {
+        console.log(`*** cname OK ${cname}`)
+        return false
+      }
+      return true
+    })()
+
+    if (inUse) {
+      throw new BadRequestError(`Custom domain already in use.`)
+    }
+  }
+}, 'instances')

package/dist/mothership-app/pb_hooks/src/lib.js

@@ -0,0 +1,171 @@
+/** @type {Lib['audit']} */
+const audit = (event, note, { log, dao, extra = {} }) => {
+  log(`AUDIT:${event}: ${note}`, extra)
+  dao.saveRecord(
+    new Record(dao.findCollectionByNameOrId('audit'), {
+      event,
+      note,
+      ...extra,
+    }),
+  )
+}
+
+/** @type {Lib['mkLog']} */
+const mkLog =
+  (namespace) =>
+  /**
+   * @param {...any} s
+   * @returns
+   */
+  (...s) =>
+    console.log(
+      `[${namespace}]`,
+      ...s.map((p) => {
+        if (typeof p === 'object') return JSON.stringify(p, null, 2)
+        return p
+      }),
+    )
+
+/**
+ * @param {...any} args
+ * @returns
+ */
+const dbg = (...args) => console.log(args)
+
+/**
+ * @param {string} template
+ * @param {{ [_: string]: string }} dict
+ * @returns
+ */
+function interpolateString(template, dict) {
+  return template.replace(/\{\$(\w+)\}/g, (match, key) => {
+    dbg({ match, key })
+    const lowerKey = key.toLowerCase()
+    return dict.hasOwnProperty(lowerKey) ? dict[lowerKey] || '' : match
+  })
+}
+
+/** @type {Lib['enqueueNotification']} */
+const enqueueNotification = (
+  channel,
+  template,
+  user_id,
+  { log, dao, message_template_vars = {} },
+) => {
+  log({ channel, template, user_id })
+  const emailTemplate = dao.findFirstRecordByData(
+    'message_templates',
+    `slug`,
+    template,
+  )
+  log(`got email template`, emailTemplate)
+  if (!emailTemplate) throw new Error(`Template ${template} not found`)
+  const emailNotification = new Record(
+    dao.findCollectionByNameOrId('notifications'),
+    {
+      user: user_id,
+      channel,
+      message_template: emailTemplate.getId(),
+      message_template_vars,
+    },
+  )
+  log(`built notification record`, emailNotification)
+  dao.saveRecord(emailNotification)
+}
+
+/** @type {Lib['processNotification']} */
+const processNotification = (notificationRec, { log, dao, test = false }) => {
+  log({ notificationRec })
+
+  const channel = notificationRec.getString(`channel`)
+  dao.expandRecord(notificationRec, ['message_template', 'user'], null)
+
+  const messageTemplateRec = notificationRec.expandedOne('message_template')
+  if (!messageTemplateRec) {
+    throw new Error(`Missing message template`)
+  }
+  const userRec = notificationRec.expandedOne('user')
+  if (!userRec) {
+    throw new Error(`Missing user record`)
+  }
+  const vars = JSON.parse(notificationRec.getString(`message_template_vars`))
+  const to = userRec.email()
+  const subject = interpolateString(
+    messageTemplateRec.getString(`subject`),
+    vars,
+  )
+  const html = interpolateString(
+    messageTemplateRec.getString(`body_html`),
+    vars,
+  )
+
+  log({ channel, messageTemplateRec, userRec, vars, to, subject, html })
+  switch (channel) {
+    case `email`:
+      /** @type {Partial<mailer.Message_In>} */
+      const msgArgs = {
+        from: {
+          address: $app.settings().meta.senderAddress,
+          name: $app.settings().meta.senderName,
+        },
+        to: [{ address: to }],
+        bcc: [{ address: `pockethost+notifications@benallfree.com` }],
+        subject,
+        html,
+      }
+      if (test) {
+        msgArgs.to = [{ address: `ben@benallfree.com` }]
+        msgArgs.subject = `***TEST ${to} *** ${msgArgs.subject}`
+      }
+      log({ msgArgs })
+      // @ts-ignore
+      const msg = new MailerMessage(msgArgs)
+      $app.newMailClient().send(msg)
+      log(`email sent`)
+      break
+
+    case `lemonbot`:
+      const res = $http.send({
+        url: test
+          ? `https://discord.com/api/webhooks/1194056858516869213/pwT-ymSxiPmLN5-M2a7FsesvrbtdmwUsKXWIKqebROJEfyP0E3-aSseUjDg4ojBkWV4D` // Test channel
+          : `https://discord.com/api/webhooks/1193619183594901575/JVDfdUz2HPEUk-nG1RfI3BK2Czyx5vw1YmeH7cNfgvXbHNGPH0oJncOYqxMA_u5b2u57`, // Stream channel
+        method: 'POST',
+        body: JSON.stringify({
+          content: subject,
+        }),
+        headers: { 'content-type': 'application/json' },
+        timeout: 5, // in seconds
+      })
+      log(`discord sent`)
+      break
+    default:
+      throw new Error(`Unsupported channel: ${channel}`)
+  }
+  if (!test) {
+    notificationRec.set(`delivered`, new DateTime())
+    dao.saveRecord(notificationRec)
+  }
+}
+
+/**
+ * @template T
+ * @param {T} obj
+ * @returns T
+ */
+function removeEmptyKeys(obj) {
+  const sanitized = Object.entries(obj).reduce((acc, [key, value]) => {
+    if (value !== null && value !== undefined) {
+      acc[key] = value
+    }
+    return acc
+  }, /** @type {T} */ ({}))
+  return sanitized
+}
+
+module.exports = {
+  audit,
+  processNotification,
+  mkLog,
+  enqueueNotification,
+  removeEmptyKeys,
+}