pockethost 1.5.0 → 1.6.1

package/src/common/plugin/filter.ts

@@ -2,13 +2,18 @@ import { Command } from 'commander'
 import { Request, Response } from 'express'
 import { DEBUG } from '../debug'
 import { InstanceFields, InstanceId } from '../schema'
+import { UserId } from '../schema/BaseFields'
 
 export enum CoreFilters {
+  Settings = 'core_settings',
   CliCommands = 'core_cli_commands',
   ServeSlugs = 'core_serve_slugs',
   SpawnConfig = 'core_spawn_config',
+  AuthenticateUser = 'core_authenticate_user',
   GetInstanceByRequestInfo = 'core_get_instance_by_request_info',
   GetInstanceById = 'core_get_instance_by_id',
+  GetOneInstanceByExactCriteria = 'core_get_one_instance_by_exact_criteria',
+  GetAllInstancesByExactCriteria = 'core_get_all_instances_by_exact_criteria',
   InstanceConfig = 'core_instance_config',
   ErrorSpawningInstanceMessage = 'core_error_spawning_instance_message',
   FailedToLaunchInstanceMessage = 'core_failed_to_launch_instance_message',
@@ -17,6 +22,7 @@ export enum CoreFilters {
   GetOrProvisionInstanceUrl = 'core_get_or_provision_instance_url',
   PocketBaseLaunchHandler = 'core_pocket_base_launch_handler',
   NewInstanceRecord = 'core_new_instance_record',
+  IsInstanceRunning = 'core_is_instance_running',
 }
 
 export type FilterHandler<TCarry, TContext> = (
@@ -31,14 +37,23 @@ const filters: {
   [key: string]: FilterEntry<any>[]
 } = {}
 
-async function registerFilter<TCarry, TContext extends {} = {}>(
+function registerFilter<TCarry, TContext extends {} = {}>(
   filter: string,
   handler: FilterHandler<TCarry, TContext>,
   priority = 10,
-) {
+): () => void {
   if (!(filter in filters)) filters[filter] = []
   filters[filter]!.push({ priority, handler })
   filters[filter]!.sort((a, b) => a.priority - b.priority)
+
+  return () => {
+    const index = filters[filter]!.findIndex(
+      (entry) => entry.handler === handler,
+    )
+    if (index !== -1) {
+      filters[filter]!.splice(index, 1)
+    }
+  }
 }
 
 async function filter<TCarry, TContext extends {} = {}>(
@@ -53,7 +68,14 @@ async function filter<TCarry, TContext extends {} = {}>(
   if (!filter) return initialValue
   return filter.reduce(
     (carry, entry) =>
-      carry.then((carryRes) => entry.handler(carryRes, context)),
+      carry
+        .then((carryRes) => entry.handler(carryRes, context))
+        .then((carryRes) => {
+          if (DEBUG()) {
+            console.log(`f:${filterName}`, carryRes, context)
+          }
+          return carryRes
+        }),
     Promise.resolve(initialValue),
   ) as TCarry
 }
@@ -64,8 +86,15 @@ function createCustomFilterWithContext<TCarry, TContext extends {} = {}>(
   return [
     async (initialValue: TCarry, context: TContext) =>
       filter<TCarry, TContext>(filterName, initialValue, context),
-    async (handler: FilterHandler<TCarry, TContext>, priority = 10) =>
-      registerFilter<TCarry, TContext>(filterName, handler, priority),
+    async <TExtraCarry = unknown>(
+      handler: FilterHandler<TCarry & TExtraCarry, TContext>,
+      priority = 10,
+    ) =>
+      registerFilter<TCarry & TExtraCarry, TContext>(
+        filterName,
+        handler,
+        priority,
+      ),
   ] as const
 }
 
@@ -73,11 +102,24 @@ function createCustomFilter<TCarry>(filterName: string) {
   return [
     async (initialValue: TCarry) =>
       filter<TCarry>(filterName, initialValue, {}),
-    async (handler: FilterHandler<TCarry, {}>, priority = 10) =>
-      registerFilter<TCarry, {}>(filterName, handler, priority),
+    async <TExtraCarry = unknown>(
+      handler: FilterHandler<TCarry & TExtraCarry, {}>,
+      priority = 10,
+    ) =>
+      registerFilter<TCarry & TExtraCarry, {}>(filterName, handler, priority),
   ] as const
 }
 
+export const [doSettingsFilter, onSettingsFilter] = createCustomFilter<{
+  [_: string]: any
+}>(CoreFilters.Settings)
+
+export const [doAuthenticateUserFilter, onAuthenticateUserFilter] =
+  createCustomFilterWithContext<
+    UserId | undefined,
+    { username: string; password: string }
+  >(CoreFilters.AuthenticateUser)
+
 export const [
   doGetInstanceByRequestInfoFilter,
   onGetInstanceByRequestInfoFilter,
@@ -92,6 +134,22 @@ export const [doGetInstanceByIdFilter, onGetInstanceByIdFilter] =
     { instanceId: InstanceId }
   >(CoreFilters.GetInstanceById)
 
+export const [
+  doGetOneInstanceByExactCriteriaFilter,
+  onGetOneInstanceByExactCriteriaFilter,
+] = createCustomFilterWithContext<
+  InstanceFields | undefined,
+  Partial<InstanceFields & { [_: string]: string | number }>
+>(CoreFilters.GetOneInstanceByExactCriteria)
+
+export const [
+  doGetAllInstancesByExactCriteriaFilter,
+  onGetAllInstancesByExactCriteriaFilter,
+] = createCustomFilterWithContext<
+  InstanceFields[],
+  Partial<InstanceFields & { [_: string]: string | number }>
+>(CoreFilters.GetAllInstancesByExactCriteria)
+
 export const [doCliCommandsFilter, onCliCommandsFilter] = createCustomFilter<
   Command[]
 >(CoreFilters.CliCommands)
@@ -106,12 +164,8 @@ export const [
   doGetOrProvisionInstanceUrlFilter,
   onGetOrProvisionInstanceUrlFilter,
 ] = createCustomFilterWithContext<
-  string,
+  string | undefined,
   {
-    req: Request
-    res: Response
-    host: string
-    subdomain: string
     instance: InstanceFields
   }
 >(CoreFilters.GetOrProvisionInstanceUrl)
@@ -136,3 +190,8 @@ export type InstanceConfig = {
 }
 export const [doInstanceConfigFilter, onInstanceConfigFilter] =
   createCustomFilter<InstanceConfig>(CoreFilters.InstanceConfig)
+
+export const [doIsInstanceRunningFilter, onIsInstanceRunningFilter] =
+  createCustomFilterWithContext<boolean, { instance: InstanceFields }>(
+    CoreFilters.IsInstanceRunning,
+  )

package/src/common/schema/BaseFields.ts

@@ -0,0 +1,10 @@
+export type RecordId = string
+export type UserId = RecordId
+export type IsoDate = string
+export type BaseFields = {
+  id: RecordId
+  created: IsoDate
+  updated: IsoDate
+}
+
+export type AnyField = { [_: string]: string | number }

package/src/common/schema/Instance.ts

@@ -1,4 +1,6 @@
 import { doNewInstanceRecordFilter } from '../plugin'
+import { IsoDate } from './BaseFields'
+import { newId, pocketNow } from './util'
 
 export type VersionId = string
 
@@ -21,16 +23,24 @@ export type InstanceSecretCollection = {
 }
 
 export type InstanceFields = {
+  id: string
   subdomain: string
   version: VersionId
   secrets: InstanceSecretCollection
   dev: boolean // Should instance run in --dev mode
+  created: IsoDate
+  updated: IsoDate
 }
 
-export const mkInstance = (subdomain: string) =>
-  doNewInstanceRecordFilter({
+export const mkInstance = (subdomain: string, id = newId()) => {
+  const now = pocketNow()
+  return doNewInstanceRecordFilter({
+    id,
     subdomain,
     version: '*',
     secrets: {},
     dev: false,
+    created: now,
+    updated: now,
   })
+}

package/src/common/schema/util.ts

@@ -1 +1,7 @@
-export const pocketNow = () => new Date().toISOString()
+import { customAlphabet } from 'nanoid'
+import { IsoDate } from './BaseFields'
+
+export const newId = customAlphabet('1234567890abcdefghijklmnopqrstuvwxyz', 10)
+export const pocketNow = () => toPocketDate(new Date())
+export const toPocketDate = (date: Date) => date.toISOString()
+export const fromPocketDate = (iso: IsoDate) => new Date(iso)

package/src/constants.ts

@@ -4,10 +4,9 @@ import { dirname, join } from 'path'
 import { cwd } from 'process'
 import { fileURLToPath } from 'url'
 import { mkBoolean, mkCsvString, mkNumber, mkPath, mkString } from '../core'
-import { InstanceId } from './common'
+import { InstanceFields, InstanceId } from './common'
 import { DEBUG, IS_DEV } from './common/debug'
 import { Settings } from './core/Settings'
-import { logSettings } from './core/logSettings'
 
 const __dirname = dirname(fileURLToPath(import.meta.url))
 
@@ -17,11 +16,7 @@ config({ path: [join(_PH_HOME, '.env'), join(cwd(), `.env`)] })
 
 export const _PH_PROJECT_DIR = join(__dirname, '..')
 export const _APEX_DOMAIN = process.env.APEX_DOMAIN || 'pockethost.lvh.me'
-export const _HTTP_PROTOCOL = process.env.HTTP_PROTOCOL || `https:`
 
-export function isSettingKey(key: string): key is keyof typeof settings {
-  return key in settings
-}
 export const settings = Settings({
   PH_PLUGINS: mkCsvString([
     `@pockethost/plugin-console-logger`,
@@ -32,6 +27,7 @@ export const settings = Settings({
   PH_HOME: mkPath(_PH_HOME),
   PH_PROJECT_DIR: mkPath(_PH_PROJECT_DIR),
 
+  PH_INTERNAL_HOST: mkString('localhost'),
   PH_APEX_DOMAIN: mkString(_APEX_DOMAIN),
 
   PH_PORT: mkNumber(3000),
@@ -39,6 +35,7 @@ export const settings = Settings({
   PH_DATA_DIR: mkPath(join(_PH_HOME, 'data'), { create: true }),
   PH_DEV: mkBoolean(IS_DEV()),
   PH_DEBUG: mkBoolean(DEBUG()),
+  PH_INTERNAL_APP_SECRET: mkString(''),
 })
 
 /** Accessors */
@@ -57,7 +54,17 @@ export const DATA_DIR = (...paths: string[]) =>
 export const NODE_ENV = () => process.env.NODE_ENV
 export const INSTANCE_DATA_DIR = (id: InstanceId, ...paths: string[]) =>
   join(DATA_DIR(), id, ...paths)
-
-if (DEBUG()) {
-  logSettings(settings)
+export const INTERNAL_HOST = () => settings.PH_INTERNAL_HOST
+export const INTERNAL_APP_SECRET = () => settings.PH_INTERNAL_APP_SECRET
+export const INTERNAL_APP_URL = (...paths: string[]) =>
+  `${HTTP_PROTOCOL()}//${INTERNAL_HOST()}:${PORT()}/${INTERNAL_APP_PREFIX}/${join(
+    ...paths,
+  )}`
+export const INTERNAL_APP_PREFIX = `_internal`
+export const INTERNAL_APP_AUTH_HEADER = `x-pockethost-authorization`
+export const HTTP_PROTOCOL = () => (PORT() === 443 ? 'https:' : 'http:')
+export const PUBLIC_INSTANCE_URL = ({ subdomain }: Partial<InstanceFields>) => {
+  const url = new URL(`${HTTP_PROTOCOL()}//${subdomain}.${APEX_DOMAIN()}`)
+  url.port = `${PORT() === 80 || PORT() == 443 ? '' : PORT()}`
+  return url
 }

package/src/core/config.ts

@@ -0,0 +1,108 @@
+import { forEach, keys, omit, uniq } from '@s-libs/micro-dash'
+import { parse } from 'dotenv'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { info } from '../cli'
+import { PH_HOME, settings } from '../constants'
+
+const envFile = () => {
+  const envFile = PH_HOME(`.env`)
+  if (!existsSync(envFile)) {
+    writeFileSync(envFile, '')
+  }
+  return envFile
+}
+
+export const setConfig = (name: string, value: string) => {
+  if (value === '=') throw new Error(`Invalid value ${value}`)
+
+  const values = _parse()
+  values[name] = value
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  process.env[name] = value
+  info(`Set ${name}=${value}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const unsetConfig = (name: string) => {
+  const values = _parse()
+  delete values[name]
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Unset ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const listConfig = () => {
+  const values = _parse()
+
+  if (keys(values).length > 0) {
+    info()
+    info(`Config values from ${envFile()}:`)
+    forEach(values, (v, k) => {
+      info(`\t${k}=${v}`)
+    })
+    info()
+  } else {
+    info(`No config values found in ${envFile()}`)
+  }
+
+  const defaults = omit(settings, keys(values) as any)
+  if (keys(defaults).length > 0) {
+    info(`Default values:`)
+    forEach(settings, (v, k) => {
+      if (k in values) return
+      info(`\t${k}=${v}`)
+    })
+  } else {
+    info(`No default values because all values are defined in ${envFile()}`)
+  }
+}
+
+export const appendConfig = (name: string, value: string) => {
+  const values = _parse()
+  values[name] = uniq([
+    ...(values[name]
+      ?.split(/,/)
+      .map((v) => v.trim())
+      .filter((v) => !!v) || []),
+    value,
+  ]).join(`,`)
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Added ${value} to ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const filterConfig = (name: string, value: string) => {
+  const values = _parse()
+  values[name] = uniq([
+    ...(values[name]
+      ?.split(/,/)
+      .map((v) => v.trim())
+      .filter((v) => v !== value) || []),
+  ]).join(`,`)
+  writeFileSync(
+    envFile(),
+    Object.entries(values)
+      .map(([k, v]) => `${k}=${v}`)
+      .join('\n'),
+  )
+  info(`Filtered ${value} from ${name}`)
+  info(`Written to ${envFile()}`)
+}
+
+export const _parse = () =>
+  parse(readFileSync(envFile(), { encoding: 'utf8' }).toString())

package/src/core/index.ts

@@ -1,8 +1,8 @@
 export * from '../constants'
 export * from './Settings'
 export * from './asyncExecutionGuard'
+export * from './config'
 export * from './exit'
 export * from './internal'
-export * from './logSettings'
 export * from './smartFetch'
 export * from './tryFetch'

package/src/core/tryFetch.ts

@@ -1,4 +1,4 @@
-import fetch, { Response } from 'node-fetch'
+import fetch, { RequestInit, Response } from 'node-fetch'
 import { LoggerService } from '../common'
 
 export const TRYFETCH_RETRY_MS = 50
@@ -6,7 +6,7 @@ export const TRYFETCH_RETRY_MS = 50
 export type TryFetchConfig = {
   preflight: () => Promise<boolean>
   retryMs: number
-}
+} & RequestInit
 
 /**
  * @param url The URL to fetch
@@ -53,7 +53,10 @@ export const tryFetch = async (
       }
       try {
         dbg(`Fetch: START`)
-        const res = await fetch(url, { signal: AbortSignal.timeout(500) })
+        const res = await fetch(url, {
+          ...config,
+          signal: AbortSignal.timeout(500),
+        })
         dbg(`Fetch: SUCCESS`)
         resolve(res)
       } catch (e) {

package/src/plugin.ts

@@ -1,14 +1,19 @@
+import { forEach } from '@s-libs/micro-dash'
 import { produce } from 'immer'
 import {
   PocketHostPlugin,
+  doSettingsFilter,
   namespace,
+  newId,
+  onAfterPluginsLoadedAction,
   onInstanceConfigFilter,
   onInstanceLogAction,
   onServeAction,
   onServeSlugsFilter,
 } from '../common'
-import { dbg } from './cli'
-import { PH_PROJECT_DIR } from './constants'
+import { dbg, info } from './cli'
+import { INTERNAL_APP_SECRET, PH_PROJECT_DIR, settings } from './constants'
+import { setConfig } from './core/config'
 import { serve } from './server'
 
 export const pockethost: PocketHostPlugin = async ({}) => {
@@ -33,4 +38,17 @@ export const pockethost: PocketHostPlugin = async ({}) => {
   onServeSlugsFilter(async (slugs) => {
     return [...slugs, `pockethost`]
   })
+
+  onAfterPluginsLoadedAction(async () => {
+    const allSettings = await doSettingsFilter(settings)
+    forEach(allSettings, (v, k) => {
+      dbg(`${k}: ${v}`)
+    })
+  }, 99)
+
+  onAfterPluginsLoadedAction(async () => {
+    if (INTERNAL_APP_SECRET()) return
+    info(`Generating internal app secret...`)
+    setConfig(`PH_INTERNAL_APP_SECRET`, newId(30))
+  })
 }

package/src/server.ts

@@ -12,7 +12,14 @@ import {
   doRequestErrorAction,
   doRequestErrorMessageFilter,
 } from '../common'
-import { APEX_DOMAIN, PORT, asyncExitHook } from '../core'
+import {
+  APEX_DOMAIN,
+  INTERNAL_APP_AUTH_HEADER,
+  INTERNAL_APP_PREFIX,
+  INTERNAL_APP_SECRET,
+  PORT,
+  asyncExitHook,
+} from '../core'
 
 export const serve = async () => {
   const _proxyLogger = LoggerService().create('ProxyService')
@@ -45,7 +52,25 @@ export const serve = async () => {
   }
   app.use(errorHandler)
 
-  doAppMountedAction({ app })
+  const internalApp = express()
+  internalApp.use((req, res, next) => {
+    dbg(`Got a request to internal app ${req.url}`)
+    next()
+  })
+  internalApp.use((req, res, next) => {
+    const authHeader = req.headers[INTERNAL_APP_AUTH_HEADER]
+    const internalAppSecret = INTERNAL_APP_SECRET()
+
+    if (authHeader !== internalAppSecret) {
+      res.status(403).send('Forbidden')
+      return
+    }
+
+    next()
+  })
+  app.use(`/${INTERNAL_APP_PREFIX}`, internalApp)
+
+  doAppMountedAction({ app, internalApp })
 
   app.all(`*`, async (req, res, next) => {
     const method = req.method
@@ -83,11 +108,7 @@ export const serve = async () => {
     })
 
     const url = await doGetOrProvisionInstanceUrlFilter('', {
-      req,
-      res,
       instance,
-      host,
-      subdomain,
     })
 
     dbg(`Forwarding request for ${req.url} to instance ${url}`)

package/src/core/logSettings.ts

@@ -1,7 +0,0 @@
-import { forEach } from '@s-libs/micro-dash'
-
-export const logSettings = (settings: { [_: string]: any }) => {
-  forEach(settings, (v, k) => {
-    console.log(`${k}: ${v}`)
-  })
-}

package/src/instance-app/types/all.d.ts

@@ -1,3 +0,0 @@
-/// <reference path="./lib.d.ts" />
-/// <reference path="./goja.d.ts" />
-/// <reference path="./types.d.ts" />

package/src/instance-app/types/goja.d.ts

@@ -1,58 +0,0 @@
-interface Require {
-  (id: string): any
-}
-declare var require: Require
-
-/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
-interface Console {
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert) */
-  assert(condition?: boolean, ...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear) */
-  clear(): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count) */
-  count(label?: string): void
-  /**
-   * [MDN
-   * Reference](https://developer.mozilla.org/docs/Web/API/console/countReset)
-   */
-  countReset(label?: string): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug) */
-  debug(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir) */
-  dir(item?: any, options?: any): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml) */
-  dirxml(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error) */
-  error(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group) */
-  group(...data: any[]): void
-  /**
-   * [MDN
-   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed)
-   */
-  groupCollapsed(...data: any[]): void
-  /**
-   * [MDN
-   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd)
-   */
-  groupEnd(): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info) */
-  info(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log) */
-  log(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table) */
-  table(tabularData?: any, properties?: string[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time) */
-  time(label?: string): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd) */
-  timeEnd(label?: string): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog) */
-  timeLog(label?: string, ...data: any[]): void
-  timeStamp(label?: string): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace) */
-  trace(...data: any[]): void
-  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn) */
-  warn(...data: any[]): void
-}
-
-declare var console: Console

package/src/instance-app/types/lib.d.ts

@@ -1,5 +0,0 @@
-type Logger = (...args: any[]) => void
-
-interface Lib {
-  mkLog: (namespace: string) => Logger
-}