pockethost 1.0.0-rc.1

package/dist/index.mjs

@@ -0,0 +1,3156 @@
+// src/shared/CleanupManager.ts
+import { reduce, values } from "@s-libs/micro-dash";
+import { nanoid } from "nanoid";
+
+// src/shared/Logger.ts
+import chalk from "chalk";
+import stringify from "json-stringify-safe";
+
+// src/util/mergeConfig.ts
+function mergeConfig(defaultConfig, ...partialConfigs) {
+  const result = { ...defaultConfig };
+  for (const partialConfig of partialConfigs) {
+    for (const key in partialConfig) {
+      if (Object.prototype.hasOwnProperty.call(partialConfig, key)) {
+        const value = partialConfig[key];
+        if (value !== void 0) {
+          result[key] = value;
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/shared/mkSingleton.ts
+function mkSingleton(factory) {
+  let instance;
+  return (config) => {
+    if (instance && config) {
+      console.error(new Error().stack);
+      throw new Error("Attempted to initialize service twice.");
+    }
+    if (!instance && !config) {
+      console.error(new Error().stack);
+      throw new Error("Attempted to use service before initialization.");
+    }
+    if (!instance) {
+      instance = factory(config);
+    }
+    return instance;
+  };
+}
+
+// src/shared/Logger.ts
+var isLevelLte = (a, b) => {
+  return LogLevels[a] <= LogLevels[b];
+};
+var isLevelGt = (a, b) => {
+  return LogLevels[a] > LogLevels[b];
+};
+var isLevelGte = (a, b) => {
+  return LogLevels[a] >= LogLevels[b];
+};
+var LogLevelConsoleMap = {
+  ["trace" /* Trace */]: console.trace,
+  ["raw" /* Raw */]: console.log,
+  ["debug" /* Debug */]: console.debug,
+  ["info" /* Info */]: console.info,
+  ["warn" /* Warn */]: console.warn,
+  ["error" /* Error */]: console.error,
+  ["abort" /* Abort */]: console.error
+};
+var LogLevels = {
+  ["trace" /* Trace */]: 0,
+  ["raw" /* Raw */]: 1,
+  ["debug" /* Debug */]: 2,
+  ["info" /* Info */]: 3,
+  ["warn" /* Warn */]: 4,
+  ["error" /* Error */]: 5,
+  ["abort" /* Abort */]: 6
+};
+var createLogger = (config) => {
+  const _config = mergeConfig(
+    {
+      level: "debug" /* Debug */,
+      pfx: [""]
+    },
+    config
+  );
+  const { pfx } = _config;
+  const setLevel = (level) => {
+    _config.level = level;
+  };
+  const _pfx = (s) => [(/* @__PURE__ */ new Date()).toISOString(), s, ...pfx].filter((v) => !!v).map((p) => `[${p}]`).join(" ");
+  const _log = (levelIn, ...args) => {
+    if (isLevelGte(levelIn, _config.level)) {
+      const pfx2 = args.shift();
+      while (args.length > 0) {
+        let arg = args.shift();
+        const t = typeof arg;
+        if (arg instanceof Error) {
+          args.unshift(...[arg.name, arg.message.toString()]);
+          if (isLevelLte(levelIn, "debug" /* Debug */) && arg.stack) {
+            args.unshift(...arg.stack.split(/\n/));
+          }
+          continue;
+        }
+        if (t === "string" && !!arg.match(/\n/)) {
+          args.unshift(...arg.split(/\n/));
+          continue;
+        }
+        if (t === "object") {
+          args.unshift(...stringify(arg, null, 2).split(/\n/));
+          continue;
+        }
+        if (t === "function") {
+          arg = `<<function ${stringify(arg.toString())}>>`;
+        }
+        LogLevelConsoleMap[levelIn](...[pfx2, arg]);
+      }
+    }
+  };
+  const raw = (...args) => {
+    _log("raw" /* Raw */, _pfx("RAW"), ...args);
+  };
+  const trace = (...args) => {
+    _log("trace" /* Trace */, _pfx(`TRACE`), ...args);
+  };
+  const dbg = (...args) => {
+    _log("debug" /* Debug */, _pfx(chalk.blueBright("DBG")), ...args);
+  };
+  const info = (...args) => {
+    _log(
+      "info" /* Info */,
+      _pfx(
+        isLevelGt("info" /* Info */, _config.level) ? chalk.gray(`INFO`) : ""
+      ),
+      ...args
+    );
+  };
+  const warn = (...args) => {
+    _log(
+      "warn" /* Warn */,
+      _pfx(chalk.yellow(chalk.cyanBright("WARN"))),
+      ...args
+    );
+  };
+  const error = (...args) => {
+    _log("error" /* Error */, ...[_pfx(chalk.bgRed(`ERROR`)), ...args]);
+  };
+  const criticalError = (...args) => {
+    _log("error" /* Error */, ...[_pfx(chalk.bgRed(`ERROR`)), ...args]);
+    new Error().stack?.split(/\n/).forEach((line) => {
+      _log("debug" /* Debug */, _pfx(chalk.bgRed(`ERROR`)), line);
+    });
+  };
+  const abort = (...args) => {
+    _log("abort" /* Abort */, true, ...[_pfx(chalk.bgRed(`ABORT`)), ...args]);
+    throw new Error(`Fatal error: ${stringify(args)}`);
+  };
+  const create = (s, configOverride) => createLogger({
+    ..._config,
+    ...configOverride,
+    pfx: [..._config.pfx, s]
+  });
+  const breadcrumb = (s) => {
+    pfx.push(s);
+    return api;
+  };
+  const child = (extra) => create(stringify(extra));
+  const api = {
+    raw,
+    dbg,
+    warn,
+    info,
+    error,
+    criticalError,
+    create,
+    child,
+    trace,
+    debug: dbg,
+    breadcrumb,
+    abort,
+    shutdown() {
+      dbg(`Logger shutting down`);
+    },
+    setLevel
+  };
+  return api;
+};
+var LoggerService = mkSingleton(
+  (config = {}) => createLogger(config)
+);
+
+// src/shared/CleanupManager.ts
+var CLEANUP_DEFAULT_PRIORITY = 10;
+var CLEANUP_PRIORITY_LAST = 1e3;
+var createCleanupManager = (slug) => {
+  const _slug = slug || nanoid();
+  const { error, warn, dbg } = LoggerService().create(`cleanupManager:${_slug}`);
+  let i = 0;
+  const cleanups = {};
+  const add = (cb, priority = CLEANUP_DEFAULT_PRIORITY) => {
+    const idx = i++;
+    const cleanup = async () => {
+      await cb();
+      delete cleanups[idx];
+    };
+    cleanups[idx] = { cleanup, priority };
+    return cleanup;
+  };
+  let _shutdownP = void 0;
+  const shutdown = () => {
+    if (_shutdownP)
+      return _shutdownP;
+    const _cleanupFuncs = values(cleanups).sort((a, b) => a.priority - b.priority).map((v) => v.cleanup);
+    _shutdownP = reduce(
+      _cleanupFuncs,
+      (c, v) => {
+        return c.then(() => v());
+      },
+      Promise.resolve()
+    ).catch((e) => {
+      error(
+        `Cleanup functions are failing. This should never happen, check all cleanup functions to make sure they are trapping their exceptions.`
+      );
+      throw e;
+    });
+    return _shutdownP;
+  };
+  return { add, shutdown };
+};
+
+// src/shared/TimerManager.ts
+import { forEach, values as values2 } from "@s-libs/micro-dash";
+var createTimerManager = (config) => {
+  const { dbg, error } = LoggerService().create(`timerManager`);
+  let i = 0;
+  const cleanups = {};
+  let isShutDown = false;
+  const add = (cb, ms) => {
+    if (isShutDown)
+      throw new Error(`Already shut down`);
+    const idx = i++;
+    const tid = setTimeout(async () => {
+      cancel();
+      try {
+        await cb();
+      } catch (e) {
+        error(e);
+      }
+    }, ms);
+    const cancel = () => {
+      clearTimeout(tid);
+      delete cleanups[idx];
+    };
+    cleanups[idx] = cancel;
+    return cancel;
+  };
+  const shutdown = () => {
+    isShutDown = true;
+    dbg(`Canceling  ${values2(cleanups.length).length} timers`);
+    forEach(cleanups, (c) => c());
+    dbg(`done`, cleanups);
+  };
+  const repeat = (cb, ms, initial = true) => {
+    let _unsub = void 0;
+    const _again = async () => {
+      const shouldRepeat = await cb();
+      if (shouldRepeat && !isShutDown)
+        _unsub = add(_again, ms);
+    };
+    add(_again, initial ? 0 : ms);
+    return () => {
+      _unsub?.();
+      _unsub = void 0;
+    };
+  };
+  return { add, shutdown, repeat };
+};
+
+// src/shared/assert.ts
+function assert(v, msg) {
+  if (!v) {
+    throw new Error(msg || `Assertion failure`);
+  }
+}
+
+// src/shared/asyncExecutionGuard.ts
+import { uniqueId } from "@s-libs/micro-dash";
+import Bottleneck from "bottleneck";
+var limiters = {};
+var serialAsyncExecutionGuard = (cb, lane) => {
+  const uuid = uniqueId();
+  const _lane = lane || (() => uuid);
+  const wrapper = (...args) => {
+    const { dbg } = LoggerService().create("serialAsyncExecutionGuard");
+    const key = _lane(...args);
+    if (!limiters[key]) {
+      dbg(`New serial limiter with key ${key}`);
+      limiters[key] = new Bottleneck({ maxConcurrent: 1 });
+    }
+    const limiter = limiters[key];
+    return limiter.schedule(() => cb(...args));
+  };
+  return wrapper;
+};
+var singletons = {};
+var singletonAsyncExecutionGuard = (cb, key) => {
+  const uuid = uniqueId();
+  const keyFactory = key || (() => uuid);
+  const wrapper = (...args) => {
+    const { dbg } = LoggerService().create(`singletonAsyncExecutionGuard`);
+    const key2 = keyFactory(...args);
+    if (singletons[key2]) {
+      return singletons[key2];
+    }
+    dbg(`New singleton guard with key ${key2}`);
+    singletons[key2] = cb(...args);
+    return singletons[key2];
+  };
+  return wrapper;
+};
+
+// src/shared/events.ts
+import { values as values3 } from "@s-libs/micro-dash";
+
+// src/shared/ioc.ts
+var IoCManager = class {
+  services = /* @__PURE__ */ new Map();
+  register(key, instance) {
+    if (this.services.has(key)) {
+      throw new Error(`Service with key '${key}' already registered.`);
+    }
+    this.services.set(key, instance);
+  }
+  service(key) {
+    const service = this.services.get(key);
+    if (!service) {
+      throw new Error(`No service registered with key '${key}'.`);
+    }
+    return service;
+  }
+};
+
+// src/shared/newId.ts
+import { customAlphabet } from "nanoid";
+var nanoid2 = customAlphabet("abcdefghijklmnopqrstuvwxyz");
+
+// src/shared/pocketbase-client-helpers/RestHelper.ts
+import Ajv2 from "ajv";
+import { ClientResponseError } from "pocketbase";
+
+// src/shared/schema/Instance.ts
+var INSTANCE_COLLECTION = "instances";
+
+// src/shared/schema/Rest/index.ts
+import Ajv from "ajv";
+
+// src/shared/schema/Rest/GetUserTokenInfo.ts
+var GetUserTokenPayloadSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" }
+  },
+  required: ["id"],
+  additionalProperties: false
+};
+
+// src/shared/schema/Rest/UpdateInstance.ts
+var SECRET_KEY_REGEX = /^[A-Z][A-Z0-9_]*$/;
+var UpdateInstancePayloadSchema = {
+  type: "object",
+  properties: {
+    id: { type: "string" },
+    fields: {
+      type: "object",
+      properties: {
+        syncAdmin: { type: "boolean", nullable: true },
+        subdomain: { type: "string", nullable: true },
+        maintenance: { type: "boolean", nullable: true },
+        version: {
+          type: "string",
+          nullable: true
+        },
+        secrets: {
+          type: "object",
+          nullable: true,
+          patternProperties: {
+            [SECRET_KEY_REGEX.source]: {
+              anyOf: [{ type: "string" }]
+            }
+          },
+          required: []
+        },
+        dev: { type: "boolean", nullable: true },
+        cname: { type: "string", nullable: true },
+        notifyMaintenanceMode: { type: "boolean", nullable: true }
+      }
+    }
+  },
+  required: ["id", "fields"],
+  additionalProperties: false
+};
+
+// src/shared/schema/Rest/index.ts
+var ajv = new Ajv();
+
+// src/shared/pocketbase-client-helpers/RestHelper.ts
+var createRestHelper = (config) => {
+  const _logger = LoggerService().create(`RestHelper`);
+  const { client } = config;
+  const mkRest = (cmd, method, schema) => {
+    const validator = new Ajv2().compile(schema);
+    return async (payload) => {
+      const _restCallLogger = _logger.create(cmd);
+      const { dbg, error } = _restCallLogger;
+      dbg(`Executing REST call`);
+      if (!validator(payload)) {
+        throw new Error(`Invalid REST payload: ${validator.errors}`);
+      }
+      const _payload = { ...payload };
+      const url = `/api/${cmd}${method === "POST" /* Post */ ? "" : "/:id"}`.replace(/:([a-zA-Z]+)/g, (_2, key) => {
+        if (!(key in _payload)) {
+          throw new Error(`Payload must include '${key}`);
+        }
+        const value = _payload[key];
+        delete _payload[key];
+        return encodeURIComponent(value.toString());
+      });
+      const options = {
+        method
+      };
+      if (method !== "GET" /* Get */) {
+        options.body = _payload;
+      }
+      dbg({ url, options });
+      try {
+        const res = await client.send(url, options);
+        dbg(res);
+        return res;
+      } catch (e) {
+        if (e instanceof ClientResponseError) {
+          error(`REST error: ${e.originalError}`);
+          throw e.originalError;
+        }
+        error(`REST error: ${e}`);
+        throw e;
+      }
+    };
+  };
+  return { mkRest };
+};
+
+// src/util/Settings.ts
+import { boolean as castToBoolean } from "boolean";
+import { existsSync, mkdirSync } from "fs";
+var mkMaker = (caster) => (_default, config) => (name) => {
+  return {
+    get() {
+      const v = process.env[name];
+      if (typeof v === `undefined`) {
+        if (typeof _default === `undefined`)
+          throw new Error(`${name} must be defined`);
+        this.set(_default);
+        return this.get();
+      }
+      try {
+        return caster.stringToType(v, config);
+      } catch (e) {
+        throw new Error(`${name}: ${e}`);
+      }
+    },
+    set(v) {
+      try {
+        process.env[name] = caster.typeToString(v, config);
+      } catch (e) {
+        throw new Error(`${name}: ${e}`);
+      }
+    }
+  };
+};
+var mkBoolean = mkMaker({
+  stringToType: (v) => castToBoolean(v),
+  typeToString: (v) => `${v}`
+});
+var mkNumber = mkMaker({
+  stringToType: (s) => parseInt(s, 10),
+  typeToString: (v) => v.toString()
+});
+var mkPath = mkMaker({
+  stringToType: (v, options) => {
+    const { create = false, required = true } = options || {};
+    if (create) {
+      mkdirSync(v, { recursive: true });
+    }
+    if (required && !existsSync(v)) {
+      throw new Error(`${v} must exist.`);
+    }
+    return v;
+  },
+  typeToString: (v, options) => {
+    const { create = false, required = true } = options || {};
+    if (create) {
+      mkdirSync(v, { recursive: true });
+    }
+    if (required && !existsSync(v)) {
+      throw new Error(`${v} must exist.`);
+    }
+    return v;
+  }
+});
+var mkString = mkMaker({
+  typeToString: (v) => v,
+  stringToType: (v) => v
+});
+var mkCsvString = mkMaker({
+  typeToString: (v) => v.join(","),
+  stringToType: (s) => s.split(/,/).map((s2) => s2.trim()).filter((v) => !!v)
+});
+var SettingsService = (config) => {
+  const singleton = mkSingleton((config2) => {
+    const lookup = {};
+    for (const key in config2) {
+      const handler = config2[key](key);
+      Object.defineProperty(lookup, key, {
+        get: () => handler.get(),
+        set: (value) => handler.set(value),
+        enumerable: true
+      });
+      handler.get();
+    }
+    return lookup;
+  });
+  return singleton(config);
+};
+
+// src/constants.ts
+import { forEach as forEach2 } from "@s-libs/micro-dash";
+import dotenv from "dotenv";
+import { findUpSync } from "find-up";
+import { dirname, join, resolve } from "path";
+var loadedEnvs = dotenv.config({ path: `.env` });
+var _PH_HOME = process.env.PH_HOME || join(process.env.HOME || resolve(`~`), `.pockethost`);
+var _PH_PROJECT_ROOT = dirname(findUpSync("package.json"));
+var _IS_DEV = process.env.NODE_ENV === "development";
+console.log({ _PH_HOME, _PH_PROJECT_ROOT });
+var SETTINGS = {
+  UPGRADE_MODE: mkBoolean(false),
+  PH_HOME: mkPath(_PH_HOME),
+  PH_VERSIONS: mkPath(join(_PH_HOME, `versions.js`), { required: false }),
+  PH_PROJECT_ROOT: mkPath(_PH_PROJECT_ROOT),
+  DEBUG: mkBoolean(_IS_DEV),
+  HTTP_PROTOCOL: mkString("https:"),
+  APP_URL: mkString(`https://app.pockethost.io`),
+  BLOG_URL: mkString(`https://pockethost.io`),
+  APEX_DOMAIN: mkString(`pockethost.io`),
+  IPCIDR_LIST: mkCsvString([`127.0.0.1/32`]),
+  DAEMON_PORT: mkNumber(3e3),
+  DAEMON_PB_IDLE_TTL: mkNumber(1e3 * 60 * 5),
+  // 5 minutes
+  MOTHERSHIP_URL: mkString(`https://pockethost-central.pockethost.io`),
+  MOTHERSHIP_NAME: mkString(`pockethost-central`),
+  MOTHERSHIP_INTERNAL_HOST: mkString(`localhost`),
+  MOTHERSHIP_ADMIN_USERNAME: mkString(),
+  MOTHERSHIP_ADMIN_PASSWORD: mkString(),
+  MOTHERSHIP_MIGRATIONS_DIR: mkPath(
+    join(_PH_PROJECT_ROOT, "src", "mothership-app", "migrations")
+  ),
+  MOTHERSHIP_HOOKS_DIR: mkPath(
+    join(_PH_PROJECT_ROOT, "src", "mothership-app", `pb_hooks`, `src`)
+  ),
+  MOTHERSHIP_APP_DIR: mkPath(
+    join(_PH_PROJECT_ROOT, "src", "mothership-app", `ph_app`),
+    {
+      required: false
+    }
+  ),
+  MOTHERSHIP_SEMVER: mkString(""),
+  MOTHERSHIP_PORT: mkNumber(8091),
+  INITIAL_PORT_POOL_SIZE: mkNumber(20),
+  DATA_ROOT: mkPath(join(_PH_HOME, "data")),
+  NODE_ENV: mkString(`production`),
+  IS_DEV: mkBoolean(_IS_DEV),
+  TRACE: mkBoolean(false),
+  PH_BIN_CACHE: mkPath(join(_PH_HOME, ".pbincache"), { create: true }),
+  PH_FTP_PORT: mkNumber(21),
+  SSL_KEY: mkPath(join(_PH_PROJECT_ROOT, `ssl`, `localhost.key`)),
+  SSL_CERT: mkPath(join(_PH_PROJECT_ROOT, `ssl`, `localhost.crt`)),
+  PH_FTP_PASV_IP: mkString(`0.0.0.0`),
+  PH_FTP_PASV_PORT_MIN: mkNumber(1e4),
+  PH_FTP_PASV_PORT_MAX: mkNumber(2e4),
+  EDGE_APEX_DOMAIN: mkString(`pockethost.lvh.me`),
+  EDGE_MAX_ACTIVE_INSTANCES: mkNumber(20),
+  INSTANCE_APP_HOOKS_DIR: mkPath(
+    join(_PH_PROJECT_ROOT, `src`, `instance-app`, `pb_hooks`),
+    { create: true }
+  ),
+  INSTANCE_APP_MIGRATIONS_DIR: mkPath(
+    join(_PH_PROJECT_ROOT, `src`, `instance-app`, `migrations`),
+    { create: true }
+  ),
+  DISCORD_POCKETSTREAM_URL: mkString(""),
+  TEST_EMAIL: mkString(),
+  LS_WEBHOOK_SECRET: mkString(""),
+  SYSLOGD_PORT: mkNumber(6514),
+  DISCORD_HEALTH_CHANNEL_URL: mkString(""),
+  DOCKER_CONTAINER_HOST: mkString(`host.docker.internal`)
+};
+(() => {
+  let passed = true;
+  forEach2(loadedEnvs.parsed, (v, k) => {
+    if (!(k in SETTINGS)) {
+      passed = false;
+      console.error(`.env key ${k} is not a known setting.`);
+    }
+  });
+  if (!passed) {
+  }
+})();
+var DefaultSettingsService = mkSingleton(
+  (settings2) => {
+    const _settings = SettingsService(settings2);
+    ioc.register("settings", _settings);
+    logConstants();
+    return _settings;
+  }
+);
+var ioc = new IoCManager();
+var settings = () => ioc.service("settings");
+var UPGRADE_MODE = () => settings().UPGRADE_MODE;
+var PH_VERSIONS = () => settings().PH_VERSIONS;
+var DEBUG = () => settings().DEBUG;
+var APP_URL = () => settings().APP_URL;
+var BLOG_URL = () => settings().BLOG_URL;
+var APEX_DOMAIN = () => settings().APEX_DOMAIN;
+var IPCIDR_LIST = () => settings().IPCIDR_LIST;
+var DAEMON_PORT = () => settings().DAEMON_PORT;
+var DAEMON_PB_IDLE_TTL = () => settings().DAEMON_PB_IDLE_TTL;
+var MOTHERSHIP_URL = () => settings().MOTHERSHIP_URL;
+var MOTHERSHIP_INTERNAL_HOST = () => settings().MOTHERSHIP_INTERNAL_HOST;
+var MOTHERSHIP_NAME = () => settings().MOTHERSHIP_NAME;
+var MOTHERSHIP_ADMIN_USERNAME = () => settings().MOTHERSHIP_ADMIN_USERNAME;
+var MOTHERSHIP_ADMIN_PASSWORD = () => settings().MOTHERSHIP_ADMIN_PASSWORD;
+var MOTHERSHIP_MIGRATIONS_DIR = () => settings().MOTHERSHIP_MIGRATIONS_DIR;
+var MOTHERSHIP_HOOKS_DIR = () => settings().MOTHERSHIP_HOOKS_DIR;
+var MOTHERSHIP_APP_DIR = () => settings().MOTHERSHIP_APP_DIR;
+var MOTHERSHIP_SEMVER = () => settings().MOTHERSHIP_SEMVER;
+var MOTHERSHIP_PORT = () => settings().MOTHERSHIP_PORT;
+var INITIAL_PORT_POOL_SIZE = () => settings().INITIAL_PORT_POOL_SIZE;
+var DATA_ROOT = () => settings().DATA_ROOT;
+var IS_DEV = () => settings().IS_DEV;
+var PH_BIN_CACHE = () => settings().PH_BIN_CACHE;
+var PH_FTP_PORT = () => settings().PH_FTP_PORT;
+var SSL_KEY = () => settings().SSL_KEY;
+var SSL_CERT = () => settings().SSL_CERT;
+var PH_FTP_PASV_IP = () => settings().PH_FTP_PASV_IP;
+var PH_FTP_PASV_PORT_MIN = () => settings().PH_FTP_PASV_PORT_MIN;
+var PH_FTP_PASV_PORT_MAX = () => settings().PH_FTP_PASV_PORT_MAX;
+var EDGE_APEX_DOMAIN = () => settings().EDGE_APEX_DOMAIN;
+var INSTANCE_APP_HOOK_DIR = () => settings().INSTANCE_APP_HOOKS_DIR;
+var INSTANCE_APP_MIGRATIONS_DIR = () => settings().INSTANCE_APP_MIGRATIONS_DIR;
+var TEST_EMAIL = () => settings().TEST_EMAIL;
+var LS_WEBHOOK_SECRET = () => settings().LS_WEBHOOK_SECRET;
+var SYSLOGD_PORT = () => settings().SYSLOGD_PORT;
+var DISCORD_HEALTH_CHANNEL_URL = () => settings().DISCORD_HEALTH_CHANNEL_URL;
+var DOCKER_CONTAINER_HOST = () => settings().DOCKER_CONTAINER_HOST;
+var MOTHERSHIP_DATA_ROOT = () => INSTANCE_DATA_ROOT(MOTHERSHIP_NAME());
+var MOTHERSHIP_DATA_DB = () => join(MOTHERSHIP_DATA_ROOT(), `pb_data`, `data.db`);
+var MOTHERSHIP_INTERNAL_URL = (path = "") => `http://${MOTHERSHIP_INTERNAL_HOST()}:${MOTHERSHIP_PORT()}${path}`;
+var INSTANCE_DATA_ROOT = (id) => join(DATA_ROOT(), id);
+var mkContainerHomePath = (...path) => join(`/home/pockethost`, ...path.filter((v) => !!v));
+var mkAppUrl = (path = "") => `${APP_URL()}${path}`;
+var mkBlogUrl = (path = "") => `${BLOG_URL()}${path}`;
+var mkDocUrl = (path = "") => mkBlogUrl(join("/docs", path));
+var mkEdgeSubdomain = (subdomain) => `${settings().HTTP_PROTOCOL}//${subdomain}.${settings().EDGE_APEX_DOMAIN}`;
+var mkEdgeUrl = (subdomain, path = "") => `${mkEdgeSubdomain(subdomain)}${path}`;
+var mkInstanceDataPath = (instanceId, ...path) => join(settings().DATA_ROOT, instanceId, ...path);
+var logConstants = () => {
+  forEach2(settings(), (v, k) => {
+    console.log(`${k}: ${v}`);
+  });
+};
+
+// src/cli/index.ts
+import { program as program2 } from "commander";
+
+// package.json
+var package_default = {
+  name: "pockethost",
+  version: "1.0.0-rc.1",
+  author: {
+    name: "Ben Allfree",
+    url: "https://github.com/benallfree"
+  },
+  license: "MIT",
+  main: "dist/index.mjs",
+  scripts: {
+    "check:types": "concurrently 'pnpm:check:types:*'",
+    "check:types:dashboard": "cd frontends/dashboard && pnpm check:types",
+    "check:types:pockethost": "tsc --noEmit --skipLibCheck",
+    lint: 'prettier -c "./**/*.{ts,js,cjs,svelte,json}"',
+    "lint:fix": 'prettier -w "./**/*.{ts,js,cjs,svelte,json}"',
+    "download-versions": "tsx ./src/cli/download.ts",
+    build: "concurrently 'pnpm:build:*'",
+    "build-cli": "tsx build.ts",
+    "build-frontends": "concurrently 'pnpm:build:frontend:*'",
+    "build:frontend:dashboard": "cd frontends/dashboard && pnpm build",
+    "build:docker": "cd src/services/PocketBaseService && docker build . -t pockethost-instance",
+    "build:frontend:lander": "cd frontends/lander && pnpm build",
+    "build:frontend:superadmin": "cd frontends/superadmin && pnpm build",
+    dev: "NODE_ENV=development concurrently 'pnpm:dev:*'",
+    "dev-cli": "nodemon --signal SIGTERM dist/index.mjs",
+    "dev:lander": "cd frontends/lander && pnpm start",
+    "dev:dashboard": "cd frontends/dashboard && pnpm dev",
+    "dev:superadmin": "cd frontends/superadmin && pnpm dev",
+    "prod:proxy": "dotenv tsx ./src/cli/proxy/server.ts",
+    "prod:edge:daemon": "tsx src/cli/edge-daemon.ts",
+    "prod:edge:ftp": "tsx src/cli/edge-ftp.ts",
+    "prod:edge:health": "tsx src/cli/edge-health.ts",
+    "prod:edge:syslog": "tsx src/cli/edge-syslogd.ts",
+    "prod:mothership": "tsx src/cli/mothership.ts",
+    plop: "plop",
+    nofile: "cat /proc/sys/fs/file-nr",
+    mail: "tsx ./src/cli/sendmail.ts",
+    watch: "node build.cjs"
+  },
+  prettier: {
+    semi: false,
+    useTabs: false,
+    singleQuote: true,
+    trailingComma: "all",
+    plugins: [
+      "./node_modules/prettier-plugin-organize-imports/index.js",
+      "./node_modules/prettier-plugin-svelte/plugin.js",
+      "./node_modules/prettier-plugin-jsdoc/dist/index.js"
+    ]
+  },
+  type: "module",
+  dependencies: {
+    "@s-libs/micro-dash": "^16.1.0",
+    "@types/node-os-utils": "^1.3.4",
+    "@types/winston-syslog": "^2.4.3",
+    ajv: "^8.12.0",
+    boolean: "^3.2.0",
+    bottleneck: "^2.19.5",
+    commander: "^11.1.0",
+    cors: "^2.8.5",
+    decompress: "^4.2.1",
+    "decompress-unzip": "https://github.com/pockethost/decompress-unzip.git#6ef397b9a2df11d39c7b26ce779e123833844751",
+    dockerode: "^3.3.5",
+    dotenv: "^16.3.1",
+    "event-source-polyfill": "^1.0.31",
+    eventsource: "^2.0.2",
+    "exit-hook": "^4.0.0",
+    express: "^4.18.2",
+    "express-async-errors": "^3.1.1",
+    "find-up": "^6.3.0",
+    "ftp-srv": "github:pockethost/ftp-srv#0fc708bae0d5d7a55ce948767f082d6fcfb2af59",
+    "get-port": "^6.1.2",
+    glob: "^10.3.10",
+    "http-proxy": "^1.18.1",
+    "http-proxy-middleware": "^2.0.6",
+    "ip-cidr": "^3.1.0",
+    "json-stringify-safe": "^5.0.1",
+    knex: "^2.5.1",
+    memorystream: "^0.3.1",
+    nanoid: "^5.0.2",
+    "node-fetch": "^3.3.2",
+    "node-os-utils": "^1.3.7",
+    pocketbase: "^0.20.1",
+    semver: "^7.5.4",
+    sqlite3: "^5.1.6",
+    "syslog-parse": "^2.0.0",
+    tail: "^2.2.6",
+    tmp: "^0.2.1",
+    "url-pattern": "^1.0.3",
+    vhost: "^3.0.2",
+    winston: "^3.11.0",
+    "winston-syslog": "^2.7.0"
+  },
+  devDependencies: {
+    "@swc/cli": "^0.1.62",
+    "@swc/core": "^1.3.95",
+    "@types/bootstrap": "^5.2.8",
+    "@types/copyfiles": "^2.4.4",
+    "@types/cors": "^2.8.17",
+    "@types/d3-scale": "^4.0.6",
+    "@types/d3-scale-chromatic": "^3.0.1",
+    "@types/decompress": "^4.2.6",
+    "@types/dockerode": "^3.3.21",
+    "@types/eventsource": "^1.1.14",
+    "@types/express": "^4.17.21",
+    "@types/http-proxy": "^1.17.13",
+    "@types/js-cookie": "^3.0.5",
+    "@types/json-stringify-safe": "^5.0.2",
+    "@types/marked": "^4.3.2",
+    "@types/memorystream": "^0.3.3",
+    "@types/ncp": "^2.0.8",
+    "@types/node": "^20.8.10",
+    "@types/semver": "^7.5.4",
+    "@types/tail": "^2.2.2",
+    "@types/tmp": "^0.2.5",
+    "@types/unzipper": "^0.10.8",
+    "@types/vhost": "^3.0.9",
+    chalk: "^5.3.0",
+    "chokidar-cli": "^3.0.0",
+    concurrently: "^8.2.2",
+    copyfiles: "^2.4.1",
+    "date-fns": "^2.30.0",
+    "dotenv-cli": "^7.3.0",
+    esbuild: "^0.20.0",
+    "esbuild-node-externals": "^1.13.0",
+    "js-yaml": "^4.1.0",
+    ncp: "^2.0.0",
+    nodemon: "^3.0.3",
+    ora: "^7.0.1",
+    plop: "^4.0.0",
+    "postinstall-postinstall": "^2.1.0",
+    prettier: "^3.0.3",
+    "prettier-plugin-jsdoc": "^1.3.0",
+    "prettier-plugin-organize-imports": "^3.2.3",
+    "prettier-plugin-svelte": "^3.0.3",
+    rizzdown: "^0.0.6",
+    svelte: "^4.2.2",
+    tslib: "^2.6.2",
+    tsx: "^3.14.0",
+    "type-fest": "^4.6.0",
+    typescript: "^5.2.2"
+  },
+  packageManager: "pnpm@8.10.2"
+};
+
+// src/util/PromiseAllocator.ts
+function PromiseAllocator(initialPoolSize, initializer) {
+  const available = [];
+  const free = (item) => {
+    available.push(item);
+  };
+  for (let i = 0; i < initialPoolSize; i++) {
+    initializer().then((item) => {
+      available.push(item);
+    });
+  }
+  const alloc = async () => {
+    if (available.length > 0) {
+      const item = available.pop();
+      if (item) {
+        return [item, () => free(item)];
+      }
+    }
+    const newItem = await initializer();
+    return [newItem, () => free(newItem)];
+  };
+  return {
+    alloc,
+    free
+  };
+}
+
+// src/util/SyslogLogger.ts
+import * as winston from "winston";
+import "winston-syslog";
+function SyslogLogger(instanceId, target) {
+  const syslogTransport = new winston.transports.Syslog({
+    host: `localhost`,
+    port: SYSLOGD_PORT(),
+    app_name: instanceId
+  });
+  const logger = winston.createLogger({
+    format: winston.format.printf((info) => {
+      return info.message;
+    }),
+    transports: [syslogTransport]
+  });
+  const { error, warn } = LoggerService().create("SyslogLogger").breadcrumb(instanceId).breadcrumb(target);
+  const api = {
+    info: (msg) => {
+      logger.info(msg);
+    },
+    error: (msg) => {
+      logger.error(msg);
+    },
+    shutdown: () => {
+      syslogTransport.close?.();
+      logger.close();
+    }
+  };
+  return api;
+}
+
+// src/util/downloadAndExtract.ts
+import decompress from "decompress";
+import decompressUnzip from "decompress-unzip";
+import { chmodSync, createWriteStream } from "fs";
+import fetch from "node-fetch";
+import { dirname as dirname2 } from "path";
+var downloadFile = async (url, path) => {
+  const { body } = await fetch(url);
+  assert(body, `Body is null`);
+  const fileStream = createWriteStream(path);
+  await new Promise((resolve3, reject) => {
+    body.pipe(fileStream);
+    body.on("error", reject);
+    fileStream.on("finish", resolve3);
+  });
+};
+var _unsafe_downloadAndExtract = async (url, binPath, logger) => {
+  const { dbg, info, error } = logger.create("downloadAndExtract");
+  dbg(`Fetching ${url}`);
+  const res = await fetch(url);
+  const { body } = res;
+  if (!body) {
+    throw new Error(`Body expected for ${url}`);
+  }
+  const versionPath = dirname2(binPath);
+  const zipPath = `${versionPath}.zip`;
+  dbg(`Downloading ${url} to ${zipPath}`);
+  await downloadFile(url, zipPath);
+  dbg(`Extracting ${zipPath} to ${versionPath}`);
+  await decompress(zipPath, versionPath, { plugins: [decompressUnzip()] });
+  chmodSync(binPath, 509);
+};
+var downloadAndExtract = singletonAsyncExecutionGuard(
+  _unsafe_downloadAndExtract,
+  (url) => url
+);
+
+// src/util/env.ts
+import { boolean } from "boolean";
+
+// src/util/exit.ts
+import exitHook, { asyncExitHook as _, gracefulExit as __ } from "exit-hook";
+var asyncExitHook = (cb) => _(cb, { wait: 5e3 });
+var gracefulExit = async (signal) => {
+  __(signal);
+  await new Promise((resolve3) => {
+    process.on("exit", resolve3);
+  });
+};
+
+// src/util/internal.ts
+var mkInternalAddress = (port) => `127.0.0.1:${port}`;
+var mkInternalUrl = (port) => `http://${mkInternalAddress(port)}`;
+
+// src/util/now.ts
+var now = () => +/* @__PURE__ */ new Date();
+
+// src/util/process.ts
+["unhandledRejection", "uncaughtException"].forEach((type) => {
+  process.on(type, (e) => {
+    console.error(`${e}`);
+    const debug = (() => {
+      try {
+        return ioc.service("settings").DEBUG;
+      } catch {
+        return true;
+      }
+    })();
+    if (debug) {
+      console.error(e.stack);
+      gracefulExit();
+    }
+  });
+});
+
+// src/util/smartFetch.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import fetch2 from "node-fetch";
+import { dirname as dirname3 } from "path";
+var smartFetch = async (url, path) => {
+  const { dbg } = LoggerService().create(`smartFetch`);
+  const data = await (async () => {
+    try {
+      const res = await fetch2(url);
+      if (res.status !== 200) {
+        throw new Error(`API appears to be down`);
+      }
+      const data2 = await res.json();
+      return data2;
+    } catch (e) {
+      dbg(`Caught error on fetch: ${e}`);
+      if (!existsSync2(path)) {
+        throw new Error(`API down and no cache`);
+      }
+      dbg(`Using data from cache`);
+      return JSON.parse(readFileSync(path).toString());
+    }
+  })();
+  mkdirSync2(dirname3(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(data));
+  return data;
+};
+
+// src/util/tryFetch.ts
+import fetch3 from "node-fetch";
+var TRYFETCH_RETRY_MS = 50;
+var tryFetch = async (url, config) => {
+  const { preflight, retryMs } = {
+    preflight: async () => true,
+    retryMs: TRYFETCH_RETRY_MS,
+    ...config
+  };
+  const logger = LoggerService().create(`tryFetch`).breadcrumb(url);
+  const { dbg } = logger;
+  return new Promise((resolve3, reject) => {
+    const again = () => setTimeout(_real_tryFetch, retryMs);
+    const _real_tryFetch = async () => {
+      if (preflight) {
+        try {
+          dbg(`Preflight: CHECK`);
+          const shouldFetch = await preflight();
+          if (!shouldFetch) {
+            dbg(`Preflight: NOT READY`);
+            again();
+            return;
+          }
+          dbg(`Preflight: READY`);
+        } catch (e) {
+          dbg(`Preflight: ABORT`);
+          reject(e);
+          return;
+        }
+      }
+      try {
+        dbg(`Fetch: START`);
+        const res = await fetch3(url, { signal: AbortSignal.timeout(500) });
+        dbg(`Fetch: SUCCESS`);
+        resolve3(res);
+      } catch (e) {
+        dbg(`Fetch: ERROR: trying again in ${retryMs}ms | ${e}`);
+        again();
+      }
+    };
+    _real_tryFetch();
+  });
+};
+
+// src/services/FtpService/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { FtpSrv } from "ftp-srv";
+import pocketbaseEs from "pocketbase";
+
+// src/services/FtpService/PhFs.ts
+import { compact, map } from "@s-libs/micro-dash";
+import {
+  constants,
+  createReadStream,
+  createWriteStream as createWriteStream2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync3
+} from "fs";
+import { customAlphabet as customAlphabet2 } from "nanoid";
+import { isAbsolute, join as join2, normalize, resolve as resolve2, sep } from "path";
+
+// src/services/FtpService/fs-async.ts
+import fs from "fs";
+import { promisify } from "util";
+var stat = promisify(fs.stat);
+var readdir = promisify(fs.readdir);
+var access = promisify(fs.access);
+var unlink = promisify(fs.unlink);
+var rmdir = promisify(fs.rmdir);
+var mkdir = promisify(fs.mkdir);
+var rename = promisify(fs.rename);
+var chmod = promisify(fs.chmod);
+
+// src/services/FtpService/PhFs.ts
+var nanoid3 = customAlphabet2(`abcdefghijklmnop`);
+var UNIX_SEP_REGEX = /\//g;
+var WIN_SEP_REGEX = /\\/g;
+var PhFs = class {
+  log;
+  connection;
+  cwd;
+  _root;
+  client;
+  constructor(connection, client, logger) {
+    const cwd = `/`;
+    const root = DATA_ROOT();
+    this.connection = connection;
+    this.client = client;
+    this.log = logger.create(`PhFs`);
+    this.cwd = normalize((cwd || "/").replace(WIN_SEP_REGEX, "/"));
+    this._root = resolve2(root || process.cwd());
+  }
+  get root() {
+    return this._root;
+  }
+  async _resolvePath(path = ".") {
+    const { dbg } = this.log.create(`_resolvePath`);
+    const resolvedPath = path.replace(WIN_SEP_REGEX, "/");
+    const joinedPath = isAbsolute(resolvedPath) ? normalize(resolvedPath) : join2("/", this.cwd, resolvedPath);
+    const [empty, subdomain, rootFolderName, ...pathFromRootFolder] = joinedPath.split("/");
+    dbg({
+      joinedPath,
+      subdomain,
+      rootFolderName,
+      restOfPath: pathFromRootFolder
+    });
+    if (rootFolderName) {
+      if (!isInstanceRootFolder(rootFolderName)) {
+        throw new Error(`Accessing ${rootFolderName} is not allowed.`);
+      }
+    }
+    const fsPathParts = [this._root];
+    const instance = await (async () => {
+      if (subdomain) {
+        const instance2 = await this.client.collection(`instances`).getFirstListItem(`subdomain='${subdomain}'`);
+        if (!instance2) {
+          throw new Error(`${subdomain} not found.`);
+        }
+        fsPathParts.push(instance2.id);
+        if (rootFolderName) {
+          dbg({ rootFolderName, instance: instance2 });
+          if (MAINTENANCE_ONLY_FOLDER_NAMES.includes(
+            rootFolderName
+          ) && !instance2.maintenance) {
+            throw new Error(
+              `Instance must be in maintenance mode to access ${rootFolderName}`
+            );
+          }
+          fsPathParts.push(rootFolderName);
+          const rootFolderFsPath = resolve2(
+            join2(...fsPathParts).replace(UNIX_SEP_REGEX, sep).replace(WIN_SEP_REGEX, sep)
+          );
+          if (!existsSync3(rootFolderFsPath)) {
+            mkdirSync3(rootFolderFsPath);
+          }
+        }
+        if (resolvedPath.length > 0)
+          fsPathParts.push(...pathFromRootFolder);
+        return instance2;
+      }
+    })();
+    const fsPath = resolve2(
+      join2(...fsPathParts).replace(UNIX_SEP_REGEX, sep).replace(WIN_SEP_REGEX, sep)
+    );
+    const clientPath = joinedPath.replace(WIN_SEP_REGEX, "/");
+    dbg({
+      clientPath,
+      fsPath,
+      subdomain,
+      rootFolderName,
+      restOfPath: pathFromRootFolder,
+      instance
+    });
+    return {
+      clientPath,
+      fsPath,
+      subdomain,
+      rootFolderName,
+      pathFromRootFolder,
+      instance
+    };
+  }
+  currentDirectory() {
+    return this.cwd;
+  }
+  async chdir(path = ".") {
+    const { fsPath, clientPath } = await this._resolvePath(path);
+    return stat(fsPath).then((stat2) => {
+      if (!stat2.isDirectory())
+        throw new Error("Not a valid directory");
+    }).then(() => {
+      this.cwd = clientPath;
+      return this.currentDirectory();
+    });
+  }
+  async list(path = ".") {
+    const { dbg, error } = this.log.create(`list`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(path);
+    const { fsPath, subdomain, rootFolderName, instance } = await this._resolvePath(path);
+    if (subdomain === "") {
+      const instances = await this.client.collection(`instances`).getFullList();
+      return instances.map((i) => {
+        return {
+          isDirectory: () => true,
+          mode: 493,
+          size: 0,
+          mtime: Date.parse(i.updated),
+          name: i.subdomain
+        };
+      });
+    }
+    if (!instance) {
+      throw new Error(
+        `Something as gone wrong. An instance without a subdomain is not possible.`
+      );
+    }
+    if (!rootFolderName) {
+      return INSTANCE_ROOT_FOLDER_NAMES.map((name) => ({
+        isDirectory: () => true,
+        mode: 493,
+        size: 0,
+        mtime: Date.parse(instance.updated),
+        name
+      }));
+    }
+    return readdir(fsPath).then((fileNames) => {
+      return Promise.all(
+        map(fileNames, (fileName) => {
+          const filePath = join2(fsPath, fileName);
+          return access(filePath, constants.F_OK).then(() => {
+            return stat(filePath).then((stat2) => {
+              const _stat = stat2;
+              _stat.name = fileName;
+              return _stat;
+            });
+          }).catch(() => null);
+        })
+      );
+    }).then(compact);
+  }
+  async get(fileName) {
+    const { fsPath, subdomain, instance, rootFolderName, pathFromRootFolder } = await this._resolvePath(fileName);
+    const { dbg, error } = this.log.create(`get`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(fileName).breadcrumb(fsPath);
+    dbg(`get`);
+    if (!subdomain) {
+      return {
+        isDirectory: () => true,
+        mode: 493,
+        size: 0,
+        mtime: +/* @__PURE__ */ new Date(),
+        name: "/"
+      };
+    }
+    if (!instance) {
+      throw new Error(`Expected instance here`);
+    }
+    if (!rootFolderName) {
+      return {
+        isDirectory: () => true,
+        mode: 493,
+        size: 0,
+        mtime: Date.parse(instance.updated),
+        name: subdomain
+      };
+    }
+    if (!pathFromRootFolder) {
+      return {
+        isDirectory: () => true,
+        mode: 493,
+        size: 0,
+        mtime: Date.parse(instance.updated),
+        name: rootFolderName
+      };
+    }
+    return stat(fsPath).then((stat2) => {
+      const _stat = stat2;
+      _stat.name = fileName;
+      return _stat;
+    });
+  }
+  async write(fileName, options) {
+    const { dbg, error } = this.log.create(`write`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(fileName);
+    dbg(`write`);
+    const { fsPath, clientPath, rootFolderName, pathFromRootFolder, instance } = await this._resolvePath(fileName);
+    assert(instance, `Instance expected here`);
+    const { append, start } = options || {};
+    if (pathFromRootFolder.length === 0) {
+      throw new Error(`write not allowed at this level`);
+    }
+    const stream = createWriteStream2(fsPath, {
+      flags: !append ? "w+" : "a+",
+      start
+    });
+    stream.once("error", (e) => {
+      error(`write(${fileName}) error`);
+      error(e);
+      unlink(fsPath);
+    });
+    stream.once("close", async () => {
+      dbg(`write(${fileName}) closing`);
+      stream.end();
+      await this.restartInstanceGuard(rootFolderName, instance);
+    });
+    return {
+      stream,
+      clientPath
+    };
+  }
+  async read(fileName, options) {
+    const { dbg, error } = this.log.create(`read`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(fileName);
+    dbg(`read`);
+    const { fsPath, clientPath, pathFromRootFolder } = await this._resolvePath(fileName);
+    const { start } = options || {};
+    if (pathFromRootFolder.length === 0) {
+      throw new Error(`read not allowed at this level`);
+    }
+    return stat(fsPath).then((stat2) => {
+      if (stat2.isDirectory())
+        throw new Error("Cannot read a directory");
+    }).then(() => {
+      const stream = createReadStream(fsPath, { flags: "r", start });
+      return {
+        stream,
+        clientPath
+      };
+    });
+  }
+  async delete(path) {
+    const { dbg, error } = this.log.create(`delete`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(path);
+    dbg(`delete`);
+    const { fsPath, clientPath, pathFromRootFolder, rootFolderName, instance } = await this._resolvePath(path);
+    assert(instance, `Instance expected here`);
+    if (pathFromRootFolder.length === 0) {
+      throw new Error(`delete not allowed at this level`);
+    }
+    return stat(fsPath).then((stat2) => {
+      const _cleanup = () => this.restartInstanceGuard(rootFolderName, instance);
+      if (stat2.isDirectory())
+        return rmdir(fsPath).then(_cleanup);
+      else
+        return unlink(fsPath).then(_cleanup);
+    });
+  }
+  async mkdir(path) {
+    const { dbg, error } = this.log.create(`mkdir`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(path);
+    dbg(`mkdir`);
+    const { fsPath, clientPath, pathFromRootFolder } = await this._resolvePath(path);
+    if (pathFromRootFolder.length === 0) {
+      throw new Error(`mkdir not allowed at this level`);
+    }
+    return mkdir(fsPath, { recursive: true }).then(() => fsPath);
+  }
+  async rename(from, to) {
+    const { dbg, error } = this.log.create(`rename`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(from).breadcrumb(to);
+    dbg(`rename`);
+    const {
+      fsPath: fromPath,
+      pathFromRootFolder: fromPathFromRootFolder,
+      rootFolderName: fromRootFolderName,
+      instance
+    } = await this._resolvePath(from);
+    const {
+      fsPath: toPath,
+      pathFromRootFolder: toPathFromRootFolder,
+      rootFolderName: toRootFolderName
+    } = await this._resolvePath(to);
+    assert(instance, `Instance expected here`);
+    if (fromPathFromRootFolder.length === 0) {
+      throw new Error(`rename not allowed at this level`);
+    }
+    if (toPathFromRootFolder.length === 0) {
+      throw new Error(`rename not allowed at this level`);
+    }
+    return rename(fromPath, toPath).then(
+      () => Promise.all([
+        this.restartInstanceGuard(fromRootFolderName, instance),
+        this.restartInstanceGuard(toRootFolderName, instance)
+      ])
+    );
+  }
+  async chmod(path, mode) {
+    const { dbg, error } = this.log.create(`chmod`).breadcrumb(`cwd:${this.cwd}`).breadcrumb(path).breadcrumb(mode.toString());
+    dbg(`chmod`);
+    const { fsPath, clientPath, pathFromRootFolder } = await this._resolvePath(path);
+    if (pathFromRootFolder.length === 0) {
+      throw new Error(`chmod not allowed at this level`);
+    }
+    return;
+    return chmod(fsPath, mode);
+  }
+  getUniqueName() {
+    return nanoid3(30);
+  }
+  async restartInstanceGuard(rootFolderName, instance) {
+  }
+};
+
+// src/services/FtpService/index.ts
+var MAINTENANCE_ONLY_FOLDER_NAMES = ["pb_data" /* PbData */];
+var INSTANCE_ROOT_FOLDER_NAMES = [
+  "pb_data" /* PbData */,
+  "pb_public" /* PbPublic */,
+  "pb_migrations" /* PbMigrations */,
+  "pb_hooks" /* PbHooks */
+];
+function isInstanceRootFolder(name) {
+  return INSTANCE_ROOT_FOLDER_NAMES.includes(name);
+}
+var ftpService = mkSingleton((config = {}) => {
+  const { mothershipUrl } = mergeConfig(
+    {
+      mothershipUrl: MOTHERSHIP_INTERNAL_URL()
+    },
+    config
+  );
+  const tls = {
+    key: readFileSync2(SSL_KEY()),
+    cert: readFileSync2(SSL_CERT())
+  };
+  const _ftpServiceLogger = LoggerService().create("FtpService");
+  const { dbg, info } = _ftpServiceLogger;
+  const ftpServer = new FtpSrv({
+    url: "ftp://0.0.0.0:" + PH_FTP_PORT(),
+    anonymous: false,
+    log: _ftpServiceLogger.create(`ftpServer`),
+    tls,
+    pasv_url: PH_FTP_PASV_IP(),
+    pasv_max: PH_FTP_PASV_PORT_MAX(),
+    pasv_min: PH_FTP_PASV_PORT_MIN()
+  });
+  ftpServer.on(
+    "login",
+    async ({ connection, username, password }, resolve3, reject) => {
+      dbg(`Got a connection`);
+      dbg(`Finding ${mothershipUrl}`);
+      const client = new pocketbaseEs(mothershipUrl);
+      try {
+        await client.collection("users").authWithPassword(username, password);
+        dbg(`Logged in`);
+        const fs4 = new PhFs(connection, client, _ftpServiceLogger);
+        resolve3({ fs: fs4 });
+      } catch (e) {
+        reject(new Error(`Invalid username or password`));
+        return;
+      }
+    }
+  );
+  ftpServer.listen().then(() => {
+    dbg("Ftp server started...");
+  });
+  exitHook(() => {
+    dbg(`Closing FTP server`);
+    ftpServer.close();
+  });
+  return {};
+});
+
+// src/services/InstanceLoggerService/index.ts
+import * as fs2 from "fs";
+import { Tail } from "tail";
+import * as winston2 from "winston";
+var loggers = {};
+function InstanceLogger(instanceId, target, options = {}) {
+  const { dbg, info } = LoggerService().create(instanceId).breadcrumb(target);
+  const { ttl } = mergeConfig({ ttl: 0 }, options);
+  dbg({ ttl });
+  const loggerKey = `${instanceId}_${target}`;
+  if (loggers[loggerKey]) {
+    dbg(`Logger exists, using cache`);
+    return loggers[loggerKey];
+  }
+  const logDirectory = mkInstanceDataPath(instanceId, `logs`);
+  if (!fs2.existsSync(logDirectory)) {
+    dbg(`Creating ${logDirectory}`);
+    fs2.mkdirSync(logDirectory, { recursive: true });
+  }
+  const logFile = mkInstanceDataPath(instanceId, `logs`, `${target}.log`);
+  const cm = createCleanupManager();
+  const fileTransport = new winston2.transports.File({
+    filename: logFile,
+    maxsize: 100 * 1024 * 1024,
+    // 100MB
+    maxFiles: 10,
+    tailable: true,
+    zippedArchive: true
+  });
+  const logger = winston2.createLogger({
+    format: winston2.format.combine(
+      winston2.format.timestamp(),
+      winston2.format.json(),
+      winston2.format.printf((info2) => {
+        return JSON.stringify({
+          stream: info2.level === "info" ? "stdout" : "stderr",
+          time: info2.timestamp,
+          message: info2.message
+        });
+      })
+    ),
+    transports: [fileTransport]
+  });
+  cm.add(() => {
+    dbg(`Deleting and closing`);
+    delete loggers[loggerKey];
+    fileTransport.close?.();
+    logger.close();
+  });
+  const { error, warn } = LoggerService().create("InstanceLogger").breadcrumb(instanceId).breadcrumb(target);
+  const resetTtl = /* @__PURE__ */ (() => {
+    let tid;
+    return () => {
+      if (!ttl)
+        return;
+      clearTimeout(tid);
+      tid = setTimeout(() => {
+        dbg(`Logger timeout`);
+        api.shutdown();
+      }, ttl);
+    };
+  })();
+  const api = {
+    info: (msg) => {
+      resetTtl();
+      dbg(`info: `, msg);
+      logger.info(msg);
+    },
+    error: (msg) => {
+      resetTtl();
+      dbg(`error: `, msg);
+      logger.error(msg);
+    },
+    tail: (linesBack, data) => {
+      if (ttl) {
+        throw new Error(`Cannot tail with ttl active`);
+      }
+      const logFile2 = mkInstanceDataPath(instanceId, `logs`, `${target}.log`);
+      let tid;
+      cm.add(() => clearTimeout(tid));
+      const check = () => {
+        try {
+          const tail = new Tail(logFile2, { nLines: linesBack });
+          tail.on("line", (line) => {
+            try {
+              const entry = JSON.parse(line);
+              data(entry);
+            } catch (e) {
+              data({
+                level: "info",
+                message: line,
+                time: (/* @__PURE__ */ new Date()).toISOString()
+              });
+            }
+          });
+          tail.on("error", (e) => {
+            error(`Caught a tail error ${e}`);
+          });
+          cm.add(() => tail.unwatch());
+        } catch (e) {
+          warn(e);
+          tid = setTimeout(check, 1e3);
+        }
+      };
+      check();
+      const unsub = asyncExitHook(() => cm.shutdown());
+      return () => {
+        cm.shutdown();
+        unsub();
+      };
+    },
+    shutdown: () => cm.shutdown()
+  };
+  loggers[loggerKey] = api;
+  return api;
+}
+
+// src/services/InstanceService/index.ts
+import { flatten, map as map2, values as values4 } from "@s-libs/micro-dash";
+import Bottleneck2 from "bottleneck";
+import { globSync } from "glob";
+import stringify2 from "json-stringify-safe";
+import { basename, join as join3 } from "path";
+var instanceService = mkSingleton(
+  async (config) => {
+    const { instanceApiTimeoutMs, instanceApiCheckIntervalMs } = config;
+    const instanceServiceLogger = LoggerService().create("InstanceService");
+    const { dbg, raw, error, warn } = instanceServiceLogger;
+    const { client } = await MothershipAdminClientService();
+    const pbService = await PocketbaseService();
+    const instanceApis = {};
+    const getInstanceApi = (instance) => {
+      const _logger = instanceServiceLogger.create(`getInstanceApi`);
+      const { id, subdomain, version: version2 } = instance;
+      _logger.breadcrumb(`${subdomain}:${id}:${version2}`);
+      const { dbg: dbg2, trace } = _logger;
+      return new Promise((resolve3, reject) => {
+        let maxTries = instanceApiTimeoutMs / instanceApiCheckIntervalMs;
+        const retry = (interval = instanceApiCheckIntervalMs) => {
+          maxTries--;
+          if (maxTries <= 0) {
+            reject(new Error(`Timeout obtaining instance API.`));
+            return;
+          }
+          dbg2(`${maxTries} tries remaining. Retrying in ${interval}ms`);
+          setTimeout(_check, interval);
+        };
+        const _check = () => {
+          dbg2(`Checking for existing instance API`);
+          const instanceApi = instanceApis[id];
+          if (!instanceApi) {
+            dbg2(`No API found, creating`);
+            createInstanceApi(instance);
+            retry(0);
+            return;
+          }
+          try {
+            if (instanceApi.status() === "healthy" /* Healthy */) {
+              dbg2(`API found and healthy, returning`);
+              resolve3(instanceApi);
+              return;
+            }
+          } catch (e) {
+            dbg2(`Instance is in an error state, returning error`);
+            reject(e);
+            return;
+          }
+          dbg2(`API found but not healthy, waiting`);
+          retry();
+        };
+        _check();
+      });
+    };
+    const createInstanceApi = (instance) => {
+      const { id, subdomain, version: version2 } = instance;
+      const systemInstanceLogger = instanceServiceLogger.create(
+        `${subdomain}:${id}:${version2}`
+      );
+      const { dbg: dbg2, warn: warn2, error: error2, info } = systemInstanceLogger;
+      if (instanceApis[id]) {
+        throw new Error(
+          `Attempted to create an instance API when one is already available for ${id}`
+        );
+      }
+      const shutdownManager = createCleanupManager();
+      shutdownManager.add(async () => {
+        dbg2(`Deleting from cache`);
+        delete instanceApis[id];
+        dbg2(`There are ${values4(instanceApis).length} still in cache`);
+      }, CLEANUP_PRIORITY_LAST);
+      shutdownManager.add(async () => {
+        dbg2(`Shutting down`);
+        status = "shutdown" /* ShuttingDown */;
+      });
+      info(`Starting`);
+      let status = "starting" /* Starting */;
+      let internalUrl = "";
+      let startRequest = () => {
+        throw new Error(`Not ready yet`);
+      };
+      let _shutdownReason;
+      const api = {
+        status: () => {
+          if (_shutdownReason)
+            throw _shutdownReason;
+          return status;
+        },
+        internalUrl: () => {
+          if (status !== "healthy" /* Healthy */) {
+            throw new Error(
+              `Attempt to access instance URL when instance is not in a healthy state.`
+            );
+          }
+          return internalUrl;
+        },
+        startRequest: () => {
+          if (status !== "healthy" /* Healthy */) {
+            throw new Error(
+              `Attempt to start an instance request when instance is not in a healthy state.`
+            );
+          }
+          return startRequest();
+        },
+        shutdown: async (reason) => {
+          dbg2(`Shutting down`);
+          if (reason) {
+            _shutdownReason = reason;
+            error2(`Panic shutdown for ${reason}`);
+          } else {
+            dbg2(`Graceful shutdown`);
+          }
+          if (status === "shutdown" /* ShuttingDown */) {
+            warn2(`Already shutting down`);
+            return;
+          }
+          return shutdownManager.shutdown();
+        }
+      };
+      const _safeShutdown = async (reason) => {
+        if (status === "shutdown" /* ShuttingDown */ && reason) {
+          warn2(`Already shutting down, ${reason} will not be reported.`);
+          return;
+        }
+        return api.shutdown(reason);
+      };
+      instanceApis[id] = api;
+      const healthyGuard = () => {
+        if (status !== "shutdown" /* ShuttingDown */)
+          return;
+        throw new Error(
+          `HealthyGuard detected instance is shutting down. Aborting further initialization.`
+        );
+      };
+      const clientLimiter = new Bottleneck2({ maxConcurrent: 1 });
+      const updateInstanceStatus = clientLimiter.wrap(
+        client.updateInstanceStatus
+      );
+      const updateInstance = clientLimiter.wrap(client.updateInstance);
+      (async () => {
+        const { version: version3 } = instance;
+        dbg2(`Obtaining port`);
+        const [newPort, releasePort] = await PortService().alloc();
+        shutdownManager.add(() => {
+          dbg2(`Releasing port`);
+          releasePort();
+        }, CLEANUP_PRIORITY_LAST);
+        systemInstanceLogger.breadcrumb(`port:${newPort}`);
+        dbg2(`Found port`);
+        healthyGuard();
+        const userInstanceLogger = InstanceLogger(instance.id, `exec`);
+        dbg2(`Starting instance`);
+        dbg2(`Set instance status: starting`);
+        healthyGuard();
+        await updateInstanceStatus(instance.id, "starting" /* Starting */);
+        shutdownManager.add(async () => {
+          dbg2(`Set instance status: idle`);
+          await updateInstanceStatus(id, "idle" /* Idle */).catch(error2);
+        });
+        healthyGuard();
+        const spawnArgs = {
+          subdomain: instance.subdomain,
+          instanceId: instance.id,
+          port: newPort,
+          dev: instance.dev,
+          extraBinds: flatten([
+            globSync(join3(INSTANCE_APP_MIGRATIONS_DIR(), "*.js")).map(
+              (file) => `${file}:${mkContainerHomePath(
+                `pb_migrations/${basename(file)}`
+              )}:ro`
+            ),
+            globSync(join3(INSTANCE_APP_HOOK_DIR(), "*.js")).map(
+              (file) => `${file}:${mkContainerHomePath(
+                `pb_hooks/${basename(file)}`
+              )}:ro`
+            )
+          ]),
+          env: {
+            ...instance.secrets,
+            PH_APP_NAME: instance.subdomain,
+            PH_INSTANCE_URL: mkEdgeUrl(instance.subdomain)
+          },
+          version: version3
+        };
+        if (instance.syncAdmin) {
+          const id2 = instance.uid;
+          dbg2(`Fetching token info for uid ${id2}`);
+          const { email, tokenKey, passwordHash } = await client.getUserTokenInfo({ id: id2 });
+          dbg2(`Token info is`, { email, tokenKey, passwordHash });
+          spawnArgs.env.ADMIN_SYNC = stringify2({
+            id: id2,
+            email,
+            tokenKey,
+            passwordHash
+          });
+        }
+        const childProcess = await (async () => {
+          try {
+            const cp = await pbService.spawn(spawnArgs);
+            return cp;
+          } catch (e) {
+            warn2(`Error spawning: ${e}`);
+            userInstanceLogger.error(`Error spawning: ${e}`);
+            if (UPGRADE_MODE()) {
+            } else {
+              await updateInstance(instance.id, {
+                maintenance: true
+              });
+            }
+            throw new Error(
+              `Could not launch container. Instance has been placed in maintenance mode. Please review your instance logs at https://app.pockethost.io/app/instances/${instance.id} or contact support at https://pockethost.io/support`
+            );
+          }
+        })();
+        const { exitCode } = childProcess;
+        exitCode.then((code) => {
+          info(`Processes exited with ${code}.`);
+          if (code !== 0 && !UPGRADE_MODE()) {
+            shutdownManager.add(async () => {
+              userInstanceLogger.error(
+                `Putting instance in maintenance mode because it shut down with return code ${code}. `
+              );
+              error2(
+                `Putting instance in maintenance mode because it shut down with return code ${code}. `
+              );
+              await updateInstance(instance.id, {
+                maintenance: true
+              });
+            });
+          }
+          setImmediate(() => {
+            _safeShutdown().catch(error2);
+          });
+        });
+        shutdownManager.add(async () => {
+          dbg2(`killing ${id}`);
+          await childProcess.kill().catch(error2);
+          dbg2(`killed ${id}`);
+        });
+        const tm = createTimerManager({});
+        shutdownManager.add(() => tm.shutdown());
+        let openRequestCount = 0;
+        let lastRequest = now();
+        internalUrl = mkInternalUrl(newPort);
+        const RECHECK_TTL = 1e3;
+        startRequest = () => {
+          lastRequest = now();
+          openRequestCount++;
+          const id2 = openRequestCount;
+          dbg2(`started new request`);
+          return () => {
+            openRequestCount--;
+            dbg2(`ended request (${openRequestCount} still open)`);
+          };
+        };
+        {
+          tm.repeat(async () => {
+            dbg2(`idle check: ${openRequestCount} open requests`);
+            if (openRequestCount === 0 && lastRequest + DAEMON_PB_IDLE_TTL() < now()) {
+              info(`idle for ${DAEMON_PB_IDLE_TTL()}, shutting down`);
+              healthyGuard();
+              await _safeShutdown().catch(error2);
+              return false;
+            } else {
+              dbg2(`${openRequestCount} requests remain open`);
+            }
+            return true;
+          }, RECHECK_TTL);
+        }
+        dbg2(`${internalUrl} is running`);
+        status = "healthy" /* Healthy */;
+        healthyGuard();
+        await updateInstanceStatus(instance.id, "running" /* Running */);
+      })().catch((e) => {
+        warn2(
+          `Instance failed to start with ${e}`,
+          e.originalError?.message
+        );
+        _safeShutdown(e).catch(error2);
+      });
+      return api;
+    };
+    const getInstance = async (host) => {
+      {
+        dbg(`Trying to get instance by host: ${host}`);
+        const instance = await client.getInstanceByCname(host).catch((e) => {
+          if (e.status !== 404) {
+            throw new Error(
+              `Unexpected response ${JSON.stringify(e)} from mothership`
+            );
+          }
+        });
+        if (instance) {
+          dbg(`${host} is a cname`);
+          if (!instance.cname_active) {
+            throw new Error(
+              `CNAME not active for this instance. See dashboard.`
+            );
+          }
+          return instance;
+        }
+      }
+      const idOrSubdomain = host.replace(`.${EDGE_APEX_DOMAIN()}`, "");
+      {
+        dbg(`Trying to get instance by ID: ${idOrSubdomain}`);
+        const instance = await client.getInstanceById(idOrSubdomain).catch((e) => {
+          if (e.status !== 404) {
+            throw new Error(
+              `Unexpected response ${JSON.stringify(e)} from mothership`
+            );
+          }
+        });
+        if (instance) {
+          dbg(`${idOrSubdomain} is an instance ID`);
+          return instance;
+        }
+      }
+      {
+        dbg(`Trying to get instance by subdomain: ${idOrSubdomain}`);
+        const instance = await client.getInstanceBySubdomain(idOrSubdomain).catch((e) => {
+          if (e.status !== 404) {
+            throw new Error(
+              `Unexpected response ${JSON.stringify(e)} from mothership`
+            );
+          }
+        });
+        if (instance) {
+          dbg(`${idOrSubdomain} is a subdomain`);
+          return instance;
+        }
+      }
+      dbg(`${idOrSubdomain} is neither an cname nor a subdomain`);
+    };
+    (await proxyService()).use(async (req, res, next) => {
+      const logger = LoggerService().create(`InstanceRequest`);
+      const { dbg: dbg2 } = logger;
+      const { host, proxy: proxy2 } = res.locals;
+      const instance = await getInstance(host);
+      if (!instance) {
+        res.status(404).end(`${host} not found`);
+        return;
+      }
+      const owner = instance.expand.uid;
+      if (!owner) {
+        throw new Error(`Instance owner is invalid`);
+      }
+      dbg2(`Checking for maintenance mode`);
+      if (instance.maintenance) {
+        throw new Error(
+          `This instance is in Maintenance Mode. See ${mkDocUrl(
+            `usage/maintenance`
+          )} for more information.`
+        );
+      }
+      dbg2(`Checking for verified account`);
+      if (!owner.verified) {
+        throw new Error(`Log in at ${mkAppUrl()} to verify your account.`);
+      }
+      const api = await getInstanceApi(instance);
+      const endRequest = api.startRequest();
+      res.on("close", endRequest);
+      if (req.closed) {
+        throw new Error(`Request already closed.`);
+      }
+      dbg2(
+        `Forwarding proxy request for ${req.url} to instance ${api.internalUrl()}`
+      );
+      proxy2.web(req, res, { target: api.internalUrl() });
+    });
+    asyncExitHook(async () => {
+      dbg(`Shutting down instance manager`);
+      const p = Promise.all(map2(instanceApis, (api) => api.shutdown()));
+      await p;
+    });
+    return {};
+  }
+);
+
+// src/services/MothershipAdminClientService/createAdminPbClient.ts
+import { default as PocketBase } from "pocketbase";
+
+// src/services/MothershipAdminClientService/InstanceMIxin.ts
+var createInstanceMixin = (context) => {
+  const { logger } = context;
+  const { dbg, raw } = logger.create("InstanceMixin");
+  const { client } = context;
+  const createInstance = (payload) => {
+    return client.collection(INSTANCE_COLLECTION).create(payload);
+  };
+  const getInstanceBySubdomain = (subdomain) => client.collection(INSTANCE_COLLECTION).getFirstListItem(`subdomain = '${subdomain}'`, { expand: "uid" });
+  const getInstanceByCname = (host) => client.collection(INSTANCE_COLLECTION).getFirstListItem(`cname = '${host}'`, {
+    expand: "uid"
+  });
+  const getInstanceById = async (instanceId) => client.collection(INSTANCE_COLLECTION).getOne(instanceId, { expand: "uid" });
+  const updateInstance = async (instanceId, fields) => {
+    await client.collection(INSTANCE_COLLECTION).update(instanceId, fields);
+  };
+  const updateInstanceStatus = async (instanceId, status) => {
+    await updateInstance(instanceId, { status });
+  };
+  const getInstance = async (instanceId) => {
+    return client.collection(INSTANCE_COLLECTION).getOne(instanceId, { expand: "uid" });
+  };
+  const getInstances = async () => {
+    return client.collection(INSTANCE_COLLECTION).getFullList();
+  };
+  return {
+    getInstanceById,
+    getInstances,
+    updateInstance,
+    updateInstanceStatus,
+    getInstanceBySubdomain,
+    getInstanceByCname,
+    getInstance,
+    createInstance
+  };
+};
+
+// src/services/MothershipAdminClientService/createAdminPbClient.ts
+var createAdminPbClient = (url) => {
+  const _clientLogger = LoggerService().create("PbClient");
+  const { info } = _clientLogger;
+  info(`Initializing client: ${url}`);
+  const client = new PocketBase(url);
+  client.autoCancellation(false);
+  const adminAuthViaEmail = (email, password) => client.admins.authWithPassword(email, password);
+  const createFirstAdmin = (email, password) => client.admins.create({ email, password, passwordConfirm: password }).catch((res) => {
+    console.log({ email, password });
+    console.log(JSON.stringify(res, null, 2));
+    return res;
+  });
+  const context = { client, logger: _clientLogger };
+  const instanceApi = createInstanceMixin(context);
+  const restHelper = createRestHelper({ client });
+  const { mkRest } = restHelper;
+  const getUserTokenInfo = mkRest(
+    "userToken" /* UserToken */,
+    "GET" /* Get */,
+    GetUserTokenPayloadSchema
+  );
+  const api = {
+    client,
+    url,
+    createFirstAdmin,
+    adminAuthViaEmail,
+    getUserTokenInfo,
+    ...instanceApi
+  };
+  return api;
+};
+
+// src/services/MothershipAdminClientService/index.ts
+var MothershipAdminClientService = mkSingleton(
+  async (cfg = {}) => {
+    const { url, username, password } = mergeConfig(
+      {
+        url: MOTHERSHIP_URL(),
+        username: MOTHERSHIP_ADMIN_USERNAME(),
+        password: MOTHERSHIP_ADMIN_PASSWORD()
+      },
+      cfg
+    );
+    const _clientLogger = LoggerService().create(`client singleton`);
+    const { dbg, error } = _clientLogger;
+    const client = createAdminPbClient(url);
+    while (true) {
+      try {
+        await client.adminAuthViaEmail(username, password);
+        dbg(`Logged in as admin`);
+        break;
+      } catch (e) {
+        dbg(`Creating first admin account`);
+        try {
+          await client.createFirstAdmin(username, password);
+          await client.adminAuthViaEmail(username, password);
+          dbg(`Logged in`);
+        } catch (e2) {
+          error(`CANNOT AUTHENTICATE TO ${url}`);
+        }
+      }
+    }
+    return {
+      client
+    };
+  }
+);
+
+// src/services/PocketBaseService/index.ts
+import { map as map3 } from "@s-libs/micro-dash";
+import Docker from "dockerode";
+import { existsSync as existsSync6 } from "fs";
+import MemoryStream from "memorystream";
+import { gte } from "semver";
+
+// src/services/PocketbaseReleaseVersionService/index.ts
+import { keys } from "@s-libs/micro-dash";
+import { chmodSync as chmodSync2, existsSync as existsSync5 } from "fs";
+import { glob } from "glob";
+import { basename as basename2, join as join4 } from "path";
+import { maxSatisfying, rsort } from "semver";
+var PocketbaseReleaseVersionService = mkSingleton(
+  async (config = {}) => {
+    const _serviceLogger = LoggerService().create(
+      "PocketbaseReleaseVersionService"
+    );
+    const { dbg, error, warn, abort } = _serviceLogger;
+    dbg(`Initializing`);
+    const { cachePath, checkIntervalMs } = mergeConfig(
+      {
+        cachePath: PH_BIN_CACHE(),
+        checkIntervalMs: 1e3 * 5 * 60
+      },
+      config
+    );
+    const binPaths = {};
+    let maxVersion = "";
+    const tm = createTimerManager();
+    const check = async () => {
+      const versions = await glob(join4(cachePath, `v*/`));
+      versions.forEach((path) => {
+        const version2 = basename2(path);
+        const sanitizedTagName = version2.slice(1);
+        dbg(`Found a version ${sanitizedTagName}`);
+        const binPath = join4(path, `pocketbase`);
+        dbg(`Checking ${binPath}`);
+        if (existsSync5(binPath)) {
+          chmodSync2(binPath, 509);
+        }
+        binPaths[sanitizedTagName] = binPath;
+      });
+      maxVersion = `~${rsort(keys(binPaths))[0]}`;
+      dbg({ maxVersion });
+      return true;
+    };
+    await check().catch(error);
+    tm.repeat(check, checkIntervalMs, false);
+    const getLatestVersion = () => maxVersion;
+    const getVersion = (semVer = maxVersion) => {
+      const version2 = maxSatisfying(keys(binPaths), semVer);
+      if (!version2)
+        throw new Error(
+          `No version satisfies ${semVer} (${keys(binPaths).join(", ")})`
+        );
+      const binPath = binPaths[version2];
+      if (!binPath)
+        throw new Error(`binPath for ${version2} not found`);
+      return {
+        version: version2,
+        binPath
+      };
+    };
+    return {
+      getLatestVersion,
+      getVersion
+    };
+  }
+);
+
+// src/services/PocketBaseService/index.ts
+var INSTANCE_IMAGE_NAME = `pockethost-instance`;
+var createPocketbaseService = async (config) => {
+  const _serviceLogger = LoggerService().create("PocketbaseService");
+  const { dbg, error, warn, abort } = _serviceLogger;
+  const { getLatestVersion, getVersion } = await PocketbaseReleaseVersionService();
+  const maxVersion = getLatestVersion();
+  const _spawn = async (cfg) => {
+    const cm = createCleanupManager();
+    const logger = LoggerService().create("spawn");
+    const { dbg: dbg2, warn: warn2, error: error2 } = logger;
+    const port = cfg.port || await (async () => {
+      const [defaultPort, freeDefaultPort] = await PortService().alloc();
+      cm.add(freeDefaultPort);
+      return defaultPort;
+    })();
+    const _cfg = {
+      version: maxVersion,
+      port,
+      extraBinds: [],
+      env: {},
+      stderr: new MemoryStream(),
+      stdout: new MemoryStream(),
+      dev: false,
+      ...cfg
+    };
+    const {
+      version: version2,
+      subdomain,
+      instanceId,
+      extraBinds,
+      env,
+      stderr,
+      stdout,
+      dev
+    } = _cfg;
+    logger.breadcrumb(subdomain).breadcrumb(instanceId);
+    const iLogger = SyslogLogger(instanceId, "exec");
+    const _version = version2 || maxVersion;
+    const realVersion = await getVersion(_version);
+    const binPath = realVersion.binPath;
+    if (!existsSync6(binPath)) {
+      throw new Error(
+        `PocketBase binary (${binPath}) not found. Contact pockethost.io.`
+      );
+    }
+    const docker = new Docker();
+    iLogger.info(`Starting instance`);
+    const _stdoutData = (data) => {
+      dbg2(data.toString());
+    };
+    stdout.on("data", _stdoutData);
+    const _stdErrData = (data) => {
+      dbg2(data.toString());
+    };
+    stderr.on("data", _stdErrData);
+    const Binds = [
+      `${mkInstanceDataPath(instanceId)}:${mkContainerHomePath()}`,
+      `${binPath}:${mkContainerHomePath(`pocketbase`)}:ro`
+    ];
+    if (extraBinds.length > 0) {
+      Binds.push(...extraBinds);
+    }
+    const createOptions = {
+      Image: INSTANCE_IMAGE_NAME,
+      Env: map3(
+        {
+          ...env,
+          DEV: dev && gte(realVersion.version, `0.20.1`),
+          PH_APEX_DOMAIN: APEX_DOMAIN()
+        },
+        (v, k) => `${k}=${v}`
+      ),
+      name: `${subdomain}-${+/* @__PURE__ */ new Date()}`,
+      HostConfig: {
+        AutoRemove: true,
+        PortBindings: {
+          "8090/tcp": [{ HostPort: `${port}` }]
+        },
+        Binds,
+        Ulimits: [
+          {
+            Name: "nofile",
+            Soft: 1024,
+            Hard: 4096
+          }
+        ],
+        LogConfig: {
+          Type: "syslog",
+          Config: {
+            "syslog-address": `udp://${DOCKER_CONTAINER_HOST()}:${SYSLOGD_PORT()}`,
+            tag: instanceId
+          }
+        }
+      },
+      Tty: false,
+      ExposedPorts: {
+        [`8090/tcp`]: {}
+      }
+      // User: 'pockethost',
+    };
+    createOptions.Cmd = ["node", `index.mjs`];
+    createOptions.WorkingDir = `/bootstrap`;
+    createOptions.Cmd = ["./pocketbase", `serve`, `--http`, `0.0.0.0:8090`];
+    if (dev) {
+      createOptions.Cmd.push(`--dev`);
+    }
+    createOptions.WorkingDir = `/home/pockethost`;
+    logger.info(`Spawning ${instanceId}`);
+    dbg2({ createOptions });
+    let container = void 0;
+    let started = false;
+    let stopped = false;
+    const exitCode = new Promise(async (resolveExit) => {
+      new Promise((resolveContainer, rejectContainer) => {
+        docker.run(
+          INSTANCE_IMAGE_NAME,
+          [""],
+          // Supplied by createOptions
+          [stdout, stderr],
+          createOptions,
+          (err, data) => {
+            const { StatusCode } = data || {};
+            dbg2({ err, data });
+            container = void 0;
+            stopped = true;
+            unsub();
+            if (StatusCode > 0 && StatusCode < 125 || err) {
+              iLogger.error(
+                `Unexpected stop with code ${StatusCode} and error ${err}`
+              );
+              error2(
+                `${instanceId} stopped unexpectedly with code ${StatusCode} and error ${err}`
+              );
+              resolveExit(StatusCode || 999);
+              rejectContainer();
+            } else {
+              resolveExit(0);
+            }
+          }
+        ).on("container", (container2) => {
+          dbg2(`Got container`, container2);
+          started = true;
+          resolveContainer(container2);
+        });
+      }).then((_c) => {
+        dbg2(`Container has been assigned`);
+        container = _c;
+      }).catch(() => {
+        dbg2(`Container will not be assigned`);
+        iLogger.error(`Could not start container`);
+        error2(`${instanceId} could not start container`);
+      });
+    });
+    exitCode.then((code) => {
+      iLogger.info(`Process exited with code ${code}`);
+    });
+    const url = mkInternalUrl(port);
+    logger.breadcrumb(url);
+    dbg2(`Making exit hook for ${url}`);
+    const unsub = asyncExitHook(async () => {
+      dbg2(`Exiting process ${instanceId}`);
+      await api.kill();
+      dbg2(`Process ${instanceId} exited`);
+    });
+    await tryFetch(`${url}/api/health`, {
+      preflight: async () => {
+        dbg2({ stopped, started, container: !!container });
+        if (stopped)
+          throw new Error(`Container stopped`);
+        return started && !!container;
+      }
+    });
+    const api = {
+      url,
+      exitCode,
+      kill: async () => {
+        dbg2(`Killing`);
+        unsub();
+        if (!container) {
+          dbg2(`Already exited`);
+          return;
+        }
+        iLogger.info(`Stopping instance`);
+        dbg2(`Stopping instance`);
+        await container.stop({ signal: `SIGKILL` }).catch(error2);
+        dbg2(`Instance stopped`);
+        const code = await exitCode;
+        dbg2(`Instance exited with ${code}`);
+        iLogger.info(`Instance stopped`);
+        stderr.off("data", _stdErrData);
+        stdout.off("data", _stdoutData);
+        container = void 0;
+        await cm.shutdown();
+      }
+    };
+    return api;
+  };
+  return {
+    spawn: _spawn
+  };
+};
+var PocketbaseService = mkSingleton(createPocketbaseService);
+
+// src/services/PocketbaseReleaseDownloadService/index.ts
+import { keys as keys2 } from "@s-libs/micro-dash";
+import Bottleneck3 from "bottleneck";
+import { chmodSync as chmodSync3, existsSync as existsSync7, writeFileSync as writeFileSync2 } from "fs";
+import { join as join5 } from "path";
+import { rsort as rsort2 } from "semver";
+
+// src/services/PocketbaseReleaseDownloadService/expandAndSortSemVers.ts
+function compareSemVer(a, b) {
+  let splitA = a.split(".").map((x) => x === "*" ? Number.MAX_SAFE_INTEGER : parseInt(x));
+  let splitB = b.split(".").map((x) => x === "*" ? Number.MAX_SAFE_INTEGER : parseInt(x));
+  for (let i = 0; i < 3; i++) {
+    if (splitA[i] !== splitB[i]) {
+      return splitB[i] - splitA[i];
+    }
+  }
+  return 0;
+}
+function expandAndSortSemVers(semvers) {
+  let expandedVersions = /* @__PURE__ */ new Set();
+  const addWildcards = (version2) => {
+    const parts = version2.split(".");
+    if (parts.length === 3) {
+      if (parts[0] !== "0")
+        expandedVersions.add(`${parts[0]}.*.*`);
+      expandedVersions.add(`${parts[0]}.${parts[1]}.*`);
+      if (parts[0] === "0" && parts[1] !== "0")
+        expandedVersions.add(`0.${parts[1]}.*`);
+    }
+  };
+  semvers.forEach((version2) => {
+    expandedVersions.add(version2);
+    addWildcards(version2);
+  });
+  return Array.from(expandedVersions).sort(compareSemVer);
+}
+
+// src/services/PocketbaseReleaseDownloadService/index.ts
+var PocketbaseReleaseDownloadService = mkSingleton(
+  (config = {}) => {
+    const { binCachePath, versionsCachePath, onlyOne } = mergeConfig(
+      {
+        binCachePath: PH_BIN_CACHE(),
+        versionsCachePath: PH_VERSIONS(),
+        onlyOne: false
+      },
+      config
+    );
+    const _serviceLogger = LoggerService().create(
+      "PocketbaseReleaseDownloadService"
+    );
+    const { dbg, info, error, warn, abort } = _serviceLogger;
+    dbg(`Initializing`);
+    const osName = "linux";
+    const cpuArchitecture = process.arch === "x64" ? "amd64" : process.arch;
+    dbg({ osName, cpuArchitecture });
+    const binPaths = {};
+    let maxVersion = "";
+    const check = async () => {
+      info(`Fetching info for PocketBase releases...`);
+      let releases = await smartFetch(
+        `https://api.github.com/repos/pocketbase/pocketbase/releases?per_page=100`,
+        join5(binCachePath, `releases.json`)
+      );
+      const filteredReleases = releases.filter((release) => !release.prerelease).map((release) => {
+        const { tag_name, assets } = release;
+        const sanitizedTagName = tag_name.slice(1);
+        const path = join5(binCachePath, tag_name);
+        const url = assets.find((v) => {
+          return v.name.includes(osName) && v.name.includes(cpuArchitecture);
+        })?.browser_download_url;
+        return { url, sanitizedTagName, path };
+      }).filter(
+        (release) => !!release.url
+      );
+      if (filteredReleases.length === 0)
+        return;
+      const limiter = new Bottleneck3({ maxConcurrent: 5 });
+      const promises = (onlyOne ? [filteredReleases[0]] : filteredReleases).map(
+        (release) => limiter.schedule(async () => {
+          const { url, sanitizedTagName, path } = release;
+          const binPath = join5(path, `pocketbase`);
+          info(`Checking ${binPath}`);
+          if (existsSync7(binPath)) {
+            chmodSync3(binPath, 509);
+          } else {
+            info(`Downloading ${url}...`);
+            await downloadAndExtract(url, binPath, _serviceLogger);
+          }
+          binPaths[sanitizedTagName] = binPath;
+        })
+      );
+      await Promise.all(promises);
+      console.log(`***keys`, keys2(binPaths));
+      const sortedSemVers = expandAndSortSemVers(keys2(binPaths));
+      writeFileSync2(
+        versionsCachePath,
+        `module.exports = ${JSON.stringify({ versions: sortedSemVers })}`
+      );
+      info(`Saved to ${versionsCachePath}`, sortedSemVers);
+      if (keys2(binPaths).length === 0) {
+        throw new Error(
+          `No version found, probably mismatched architecture and OS (${osName}/${cpuArchitecture})`
+        );
+      }
+      maxVersion = `~${rsort2(keys2(binPaths))[0]}`;
+      info(`Highest PocketBase version is ${maxVersion}`);
+    };
+    return {
+      check
+    };
+  }
+);
+
+// src/services/PortService.ts
+import getPort from "get-port";
+var PortService = mkSingleton((config = {}) => {
+  const { maxPorts } = mergeConfig(
+    { maxPorts: INITIAL_PORT_POOL_SIZE() },
+    config
+  );
+  return PromiseAllocator(maxPorts, getPort);
+});
+
+// src/services/ProxyService.ts
+import cors from "cors";
+import express from "express";
+import "express-async-errors";
+import { default as httpProxy } from "http-proxy";
+var proxyService = mkSingleton(async (config) => {
+  const _proxyLogger = LoggerService().create("ProxyService");
+  const { dbg, error, info, trace, warn } = _proxyLogger;
+  const { coreInternalUrl } = config;
+  const proxy2 = httpProxy.createProxyServer({});
+  proxy2.on("error", (err, req, res, target) => {
+    warn(`Proxy error ${err} on ${req.url} (${req.headers.host})`);
+  });
+  const server = express();
+  server.use(cors());
+  server.get("/_api/health", (req, res, next) => {
+    res.json({ status: "ok" });
+    res.end;
+  });
+  server.use((req, res, next) => {
+    const host = req.headers.host;
+    if (!host) {
+      throw new Error(`Host not found`);
+    }
+    res.locals.host = host;
+    next();
+  });
+  server.use((req, res, next) => {
+    res.locals.coreInternalUrl = coreInternalUrl;
+    next();
+  });
+  server.use((req, res, next) => {
+    const url = new URL(`http://${req.headers.host}${req.url}`);
+    const country = req.headers["cf-ipcountry"] || "<ct>";
+    const ip = req.headers["x-forwarded-for"] || "<ip>";
+    const method = req.method || "<m>";
+    const sig = [
+      method.padStart(10),
+      country.padStart(5),
+      ip.padEnd(45),
+      url.toString()
+    ].join(" ");
+    info(`Incoming request ${sig}`);
+    res.locals.sig = sig;
+    next();
+  });
+  server.use((req, res, next) => {
+    res.locals.proxy = proxy2;
+    next();
+  });
+  server.listen(DAEMON_PORT(), () => {
+    info(`daemon listening on port ${DAEMON_PORT()}`);
+  });
+  asyncExitHook(async () => {
+    info(`Shutting down proxy server`);
+  });
+  const use = server.use.bind(server);
+  return { use };
+});
+
+// src/services/RealtimeLog.ts
+import { text } from "node:stream/consumers";
+import pocketbaseEs2 from "pocketbase";
+var mkEvent = (name, data) => {
+  return `event: ${name}
+data: ${JSON.stringify(data)}
+
+`;
+};
+var realtimeLog = mkSingleton(async (config) => {
+  ;
+  (await proxyService()).use("/logs", async (req, res, next) => {
+    const logger = LoggerService().create(`RealtimeLogger`);
+    const { dbg, error, trace } = logger;
+    dbg(`Got a logging request`);
+    const { coreInternalUrl } = res.locals;
+    dbg(`Got a log request`);
+    const parsed = new URL(req.url, `https://${req.headers.host}`);
+    const json = await text(req);
+    dbg(`JSON payload is`, json);
+    const payload = JSON.parse(json);
+    dbg(`Parsed payload is`, parsed);
+    const { instanceId, auth, n: nInitialRecords } = payload;
+    if (!instanceId) {
+      throw new Error(`instanceId query param required in ${req.url}`);
+    }
+    if (!auth) {
+      throw new Error(`Expected 'auth' query param, but found ${req.url}`);
+    }
+    const client = new pocketbaseEs2(coreInternalUrl);
+    client.authStore.loadFromCookie(auth);
+    dbg(`Cookie here is`, client.authStore.isValid);
+    await client.collection("users").authRefresh();
+    if (!client.authStore.isValid) {
+      throw new Error(`Cookie is invalid her`);
+    }
+    const user = client.authStore.model;
+    if (!user) {
+      throw new Error(`Valid user expected here`);
+    }
+    dbg(`Cookie auth passed)`);
+    dbg(`Got a log request for instance ID ${instanceId}`);
+    const instance = await client.collection("instances").getOne(instanceId);
+    if (!instance) {
+      throw new Error(`instanceId ${instanceId} not found for user ${user.id}`);
+    }
+    dbg(`Instance is `, instance);
+    const instanceLogger = InstanceLogger(instanceId, `exec`);
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream; charset=UTF-8",
+      Connection: "keep-alive",
+      "Cache-Control": "no-store"
+    });
+    const unsub = instanceLogger.tail(100, (entry) => {
+      const evt = mkEvent(`log`, entry);
+      res.write(evt);
+    });
+    res.on("close", () => {
+      unsub();
+      instanceLogger.shutdown();
+    });
+  });
+  return {};
+});
+
+// src/services/SqliteService/index.ts
+import knex from "knex";
+var SqliteService = mkSingleton((config) => {
+  const { dbg, trace } = LoggerService().create(`sqliteService`);
+  const connections = {};
+  const cm = createCleanupManager();
+  const _unsafe_getDatabase = async (filename) => {
+    const _dbLogger = LoggerService().create(`SqliteService`);
+    _dbLogger.breadcrumb(filename);
+    const { dbg: dbg2, error, abort } = _dbLogger;
+    trace(`Fetching database`, connections);
+    if (!connections[filename]) {
+      dbg2(`Not yet opened`);
+      const api = await (async () => {
+        dbg2(`Opening ${filename}`);
+        const db = knex({
+          client: "sqlite3",
+          // or 'better-sqlite3'
+          connection: {
+            filename
+          }
+        });
+        cm.add(() => {
+          dbg2(`Closing connection`);
+          db.destroy();
+        });
+        return db;
+      })().catch(error);
+      if (!api) {
+        throw new Error(`Unable to connect to SQLite`);
+      }
+      connections[filename] = api;
+    }
+    return connections[filename];
+  };
+  const getDatabase = serialAsyncExecutionGuard(
+    _unsafe_getDatabase,
+    (fileName) => fileName
+  );
+  const shutdown = async () => {
+    dbg(`Shutting down sqlite service`);
+    await cm.shutdown();
+  };
+  return {
+    getDatabase,
+    shutdown
+  };
+});
+
+// src/cli/commands/DownloadCommand/index.ts
+import { Command } from "commander";
+var DownloadCommand = () => {
+  const cmd = new Command(`download`).description(`Download all PocketBase versions`).action(async (options) => {
+    const logger = LoggerService().create(`DownloadCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    const { check } = PocketbaseReleaseDownloadService({});
+    await check();
+  });
+  return cmd;
+};
+
+// src/cli/commands/EdgeDaemonServeCommand/index.ts
+import { Command as Command2 } from "commander";
+
+// src/cli/commands/EdgeDaemonServeCommand/serve.ts
+async function serve(info) {
+  tryFetch(`${MOTHERSHIP_INTERNAL_URL(`/api/health`)}`, {});
+  const udService = await PocketbaseReleaseVersionService({
+    cachePath: PH_BIN_CACHE(),
+    checkIntervalMs: 1e3 * 5 * 60
+  });
+  await PortService({});
+  await PocketbaseService({});
+  info(`Serving`);
+  await MothershipAdminClientService({
+    url: MOTHERSHIP_INTERNAL_URL(),
+    username: MOTHERSHIP_ADMIN_USERNAME(),
+    password: MOTHERSHIP_ADMIN_PASSWORD()
+  });
+  await proxyService({
+    coreInternalUrl: MOTHERSHIP_INTERNAL_URL()
+  });
+  await SqliteService({});
+  await realtimeLog({});
+  await instanceService({
+    instanceApiCheckIntervalMs: 50,
+    instanceApiTimeoutMs: 5e3
+  });
+  const errorHandler = (err, req, res, next) => {
+    res.status(500).send(err.toString());
+  };
+  (await proxyService()).use(errorHandler);
+}
+
+// src/cli/commands/EdgeDaemonServeCommand/index.ts
+var EdgeDaemonServeCommand = () => {
+  const cmd = new Command2(`edge:daemon:serve`).description(`Run an edge daemon server`).action(async (options) => {
+    const logger = LoggerService().create(`EdgeDaemonServeCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    await serve(info);
+    info(`Hooking into process exit event`);
+  });
+  return cmd;
+};
+
+// src/cli/commands/EdgeFtpServeCommand/index.ts
+import { Command as Command3 } from "commander";
+var EdgeFtpServeCommand = () => {
+  const cmd = new Command3(`edge:ftp:serve`).description(`Run an edge FTP server`).action(async (options) => {
+    const logger = LoggerService().create(`EdgeFtpServeCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    tryFetch(`${MOTHERSHIP_INTERNAL_URL(`/api/health`)}`, {});
+    await ftpService({
+      mothershipUrl: MOTHERSHIP_INTERNAL_URL()
+    });
+  });
+  return cmd;
+};
+
+// src/cli/commands/EdgeSyslogCommand/index.ts
+import { Command as Command4 } from "commander";
+import * as dgram from "dgram";
+import parse from "syslog-parse";
+var EdgeSyslogServeCommand = () => {
+  const cmd = new Command4(`edge:syslog:serve`).description(`Run an edge syslog server`).action(async (options) => {
+    const logger = LoggerService().create(`EdgeSyslogServeCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    const PORT = SYSLOGD_PORT();
+    const HOST = "0.0.0.0";
+    const server = dgram.createSocket("udp4");
+    server.on("error", (err) => {
+      console.log(`Server error:
+${err.stack}`);
+      server.close();
+    });
+    server.on("message", (msg, rinfo) => {
+      const raw = msg.toString();
+      const parsed = parse(raw);
+      if (!parsed) {
+        return;
+      }
+      dbg(parsed);
+      const { process: instanceId, severity, message } = parsed;
+      const logger2 = InstanceLogger(instanceId, `exec`, { ttl: 5e3 });
+      if (severity === "info") {
+        logger2.info(message);
+      } else {
+        logger2.error(message);
+      }
+    });
+    server.on("listening", () => {
+      const address = server.address();
+      console.log(`Server listening ${address.address}:${address.port}`);
+    });
+    server.bind(PORT, HOST);
+  });
+  return cmd;
+};
+
+// src/cli/commands/HealthCommand/index.ts
+import { Command as Command5 } from "commander";
+
+// src/cli/commands/HealthCommand/checkHealth.ts
+import Bottleneck4 from "bottleneck";
+import { execSync } from "child_process";
+import fetch4 from "node-fetch";
+import { default as osu } from "node-os-utils";
+import { freemem } from "os";
+var checkHealth = async () => {
+  const { cpu, drive, openfiles, proc } = osu;
+  const DISCORD_URL = DISCORD_HEALTH_CHANNEL_URL();
+  const { dbg, error, info, warn } = LoggerService().create("edge-health.ts");
+  info(`Starting`);
+  const _exec = (cmd) => execSync(cmd, { shell: "/bin/bash", maxBuffer: 1024 * 1024 * 10 }).toString().split(`
+`);
+  const openFiles = _exec(`lsof -n | awk '$4 ~ /^[0-9]/ {print}'`);
+  const [freeSpace] = _exec(`df -h / | awk 'NR==2{print $4}'`);
+  const SAMPLE = {
+    Command: '"docker-entrypoint.s\u2026"',
+    CreatedAt: "2024-01-23 04:36:09 +0000 UTC",
+    ID: "6e0921e84391",
+    Image: "pockethost-instance",
+    Labels: "",
+    LocalVolumes: "0",
+    Mounts: "/home/pocketho\u2026,/home/pocketho\u2026,/home/pocketho\u2026,/home/pocketho\u2026,/home/pocketho\u2026",
+    Names: "kekbase-1705984569777",
+    Networks: "bridge",
+    Ports: "0.0.0.0:44447->8090/tcp, :::44447->8090/tcp",
+    RunningFor: "7 hours ago",
+    Size: "0B (virtual 146MB)",
+    State: "running",
+    Status: "Up 7 hours"
+  };
+  const containers = _exec(`docker ps --format '{{json .}}'`).filter((line) => line.trim()).map((line) => {
+    dbg(line);
+    return line;
+  }).map((line) => JSON.parse(line)).map((rec) => {
+    const name = rec.Names.replace(/-\d+/, "");
+    const port = parseInt(rec.Ports.match(/:(\d+)/)?.[1] || "0", 10);
+    const mem = rec.Size.match(/(\d+MB)/)?.[1] || "0MB";
+    const created = new Date(rec.CreatedAt);
+    return {
+      name,
+      priority: 0,
+      emoji: ":octopus:",
+      port,
+      isHealthy: false,
+      url: `http://localhost:${port}/api/health`,
+      ago: rec.RunningFor,
+      mem,
+      created
+    };
+  });
+  function getFreeMemoryInGB() {
+    const freeMemoryBytes = freemem();
+    const freeMemoryGB = freeMemoryBytes / Math.pow(1024, 3);
+    return freeMemoryGB.toFixed(2);
+  }
+  function splitIntoChunks(lines, maxChars = 2e3) {
+    const chunks = [];
+    let currentChunk = "";
+    lines.forEach((line) => {
+      if (currentChunk.length + line.length + 1 > maxChars) {
+        chunks.push(currentChunk);
+        currentChunk = "";
+      }
+      currentChunk += line + "\n";
+    });
+    if (currentChunk) {
+      chunks.push(currentChunk);
+    }
+    return chunks;
+  }
+  const limiter = new Bottleneck4({ maxConcurrent: 1 });
+  const send = (lines) => Promise.all(
+    splitIntoChunks(lines).map(
+      (content) => limiter.schedule(
+        () => fetch4(DISCORD_URL, {
+          method: "POST",
+          body: JSON.stringify({
+            content
+          }),
+          headers: { "content-type": "application/json" }
+        })
+      )
+    )
+  );
+  const driveInfo = await drive.info(`/`);
+  await send([
+    `===================`,
+    `Server: SFO-1`,
+    `${/* @__PURE__ */ new Date()}`,
+    `CPUs: ${cpu.count()}`,
+    `CPU Usage: ${await cpu.usage()}%`,
+    `Free RAM: ${getFreeMemoryInGB()}GB`,
+    `Free disk: ${driveInfo.freeGb}GB`,
+    `Open files: ${openFiles.length}`,
+    `Containers: ${containers.length}`
+  ]);
+  const checks = [
+    {
+      name: `edge proxy`,
+      priority: 10,
+      emoji: `:park:`,
+      isHealthy: false,
+      url: `https://proxy.pockethost.io/_api/health`
+    },
+    {
+      name: `edge daemon`,
+      priority: 8,
+      emoji: `:imp:`,
+      isHealthy: false,
+      url: `http://localhost:${DAEMON_PORT()}/_api/health`
+    },
+    {
+      name: `mothership`,
+      priority: 9,
+      emoji: `:flying_saucer:`,
+      isHealthy: false,
+      url: `http://localhost:${MOTHERSHIP_PORT()}/api/health`
+    },
+    ...containers
+  ];
+  await Promise.all(
+    checks.map(async (check) => {
+      const { url } = check;
+      dbg({ container: check });
+      try {
+        const res = await fetch4(url);
+        dbg({ url, status: res.status });
+        check.isHealthy = res.status === 200;
+        return true;
+      } catch (e) {
+        dbg(`${url}: ${e}`);
+        check.isHealthy = false;
+      }
+    })
+  );
+  dbg({ checks });
+  await send([
+    `---health checks---`,
+    ...checks.sort((a, b) => {
+      if (a.priority > b.priority)
+        return -1;
+      if (a.priority < b.priority)
+        return 1;
+      const now2 = /* @__PURE__ */ new Date();
+      const res = +(b.created || now2) - +(a.created || now2);
+      if (res)
+        return res;
+      return a.name.localeCompare(b.name);
+    }).map(({ name, isHealthy, emoji, mem, ago }) => {
+      const isInstance = !!mem;
+      if (isInstance) {
+        return `${isHealthy ? ":white_check_mark:" : ":face_vomiting: "} \`${name.padStart(30)} ${(mem || "").padStart(10)} ${(ago || "").padStart(20)}\``;
+      } else {
+        return `${isHealthy ? ":white_check_mark:" : ":face_vomiting: "}  ${name}`;
+      }
+    })
+  ]);
+};
+
+// src/cli/commands/HealthCommand/index.ts
+var HealthCommand = () => {
+  const cmd = new Command5(`health`).description(`Perform a health check on the PocketHost system`).action(async (options) => {
+    const logger = LoggerService().create(`HealthCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    await checkHealth();
+  });
+  return cmd;
+};
+
+// src/cli/commands/MothershipCommand/index.ts
+import { Command as Command6 } from "commander";
+var MothershipCommand = () => {
+  const cmd = new Command6(`mothership`).description(`Run the PocketHost mothership`).action(async (options) => {
+    const logger = LoggerService().create(`Mothership`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    const udService = await PocketbaseReleaseVersionService({
+      cachePath: PH_BIN_CACHE(),
+      checkIntervalMs: 1e3 * 5 * 60
+    });
+    await PortService({});
+    const pbService = await PocketbaseService({});
+    info(`Serving`);
+    const { url, exitCode } = await pbService.spawn({
+      version: MOTHERSHIP_SEMVER(),
+      subdomain: MOTHERSHIP_NAME(),
+      instanceId: MOTHERSHIP_NAME(),
+      port: MOTHERSHIP_PORT(),
+      dev: DEBUG(),
+      env: {
+        DATA_ROOT: mkContainerHomePath(`data`),
+        LS_WEBHOOK_SECRET: LS_WEBHOOK_SECRET()
+      },
+      extraBinds: [
+        `${DATA_ROOT()}:${mkContainerHomePath(`data`)}`,
+        `${MOTHERSHIP_HOOKS_DIR()}:${mkContainerHomePath(`pb_hooks`)}`,
+        `${PH_VERSIONS()}:${mkContainerHomePath(`pb_hooks`, `versions.js`)}`,
+        `${MOTHERSHIP_MIGRATIONS_DIR()}:${mkContainerHomePath(
+          `pb_migrations`
+        )}`,
+        `${MOTHERSHIP_APP_DIR()}:${mkContainerHomePath(`ph_app`)}`
+      ]
+    });
+    info(`Mothership URL for this session is ${url}`);
+    exitCode.then((c) => {
+      gracefulExit(c);
+    });
+  });
+  return cmd;
+};
+
+// src/cli/commands/ProxyCommand/index.ts
+import { Command as Command7 } from "commander";
+
+// src/cli/commands/ProxyCommand/proxy/server.ts
+import { forEach as forEach3 } from "@s-libs/micro-dash";
+import cors2 from "cors";
+import express2 from "express";
+import "express-async-errors";
+import fs3 from "fs";
+import http from "http";
+import https from "https";
+import { createProxyMiddleware as createProxyMiddleware2 } from "http-proxy-middleware";
+
+// src/cli/commands/ProxyCommand/proxy/cidr.ts
+import IPCIDR from "ip-cidr";
+var createIpWhitelistMiddleware = (blockedCIDRs) => {
+  const blockedCIDRObjects = blockedCIDRs.map((cidr) => new IPCIDR(cidr));
+  return (req, res, next) => {
+    const ip = req.ip;
+    if (blockedCIDRObjects.some((cidr) => cidr.contains(ip))) {
+      next();
+    } else {
+      res.status(403).send("Nope");
+    }
+  };
+};
+
+// src/cli/commands/ProxyCommand/proxy/createVhostProxyMiddleware.ts
+import { createProxyMiddleware } from "http-proxy-middleware";
+import vhost from "vhost";
+function createVhostProxyMiddleware(host, target, ws = false) {
+  console.log(`Creating ${host}->${target}`);
+  const handler = createProxyMiddleware({ target, ws, changeOrigin: ws });
+  return vhost(host, (_req, res, next) => {
+    const req = _req;
+    const method = req.method;
+    const fullUrl = req.protocol + "://" + req.get("host") + req.originalUrl;
+    console.log(`${method} ${fullUrl} -> ${target}`);
+    return handler(req, res, next);
+  });
+}
+
+// src/cli/commands/ProxyCommand/proxy/server.ts
+var proxy = async () => {
+  const PROD_ROUTES = {
+    "pockethost-central.pockethost.io": `http://localhost:${MOTHERSHIP_PORT()}`
+  };
+  const DEV_ROUTES = {
+    "mail.pockethost.lvh.me": `http://localhost:${1080}`,
+    "pockethost-central.pockethost.lvh.me": `http://localhost:${MOTHERSHIP_PORT()}`,
+    "app.pockethost.lvh.me": `http://localhost:${5174}`,
+    "superadmin.pockethost.lvh.me": `http://localhost:${5175}`,
+    "pockethost.lvh.me": `http://localhost:${8080}`
+  };
+  const hostnameRoutes = IS_DEV() ? DEV_ROUTES : PROD_ROUTES;
+  const app = express2();
+  app.use(cors2());
+  app.use(createIpWhitelistMiddleware(IPCIDR_LIST()));
+  forEach3(hostnameRoutes, (target, host) => {
+    app.use(createVhostProxyMiddleware(host, target, IS_DEV()));
+  });
+  app.get(`/_api/health`, (req, res, next) => {
+    res.json({ status: "ok" });
+    res.end();
+  });
+  const handler = createProxyMiddleware2({
+    target: `http://localhost:${DAEMON_PORT()}`
+  });
+  app.all(`*`, (req, res, next) => {
+    const method = req.method;
+    const fullUrl = req.protocol + "://" + req.get("host") + req.originalUrl;
+    console.log(
+      `${method} ${fullUrl} -> ${`http://localhost:${DAEMON_PORT()}`}`
+    );
+    handler(req, res, next);
+  });
+  const errorHandler = (err, req, res, next) => {
+    res.status(500).send(err.toString());
+  };
+  app.use(errorHandler);
+  if (IS_DEV()) {
+    http.createServer(app).listen(80, () => {
+      console.log("HTTP server running on port 80");
+    });
+  } else {
+    const httpsOptions = {
+      key: fs3.readFileSync(
+        "/home/pockethost/pockethost/ssl/cloudflare-privkey.pem"
+      ),
+      cert: fs3.readFileSync(
+        "/home/pockethost/pockethost/ssl/cloudflare-origin.pem"
+      )
+    };
+    https.createServer(httpsOptions, app).listen(443, () => {
+      console.log("HTTPS server running on port 443");
+    });
+  }
+};
+
+// src/cli/commands/ProxyCommand/index.ts
+var ProxyCommand = () => {
+  const cmd = new Command7(`proxy`).description(`Run the root PocketHost proxy`).action(async (options) => {
+    const logger = LoggerService().create(`ProxyCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    await proxy();
+  });
+  return cmd;
+};
+
+// src/cli/commands/SendMailCommand/index.ts
+import { Command as Command8 } from "commander";
+
+// src/cli/commands/SendMailCommand/sendmail.ts
+import { map as map4 } from "@s-libs/micro-dash";
+import Bottleneck5 from "bottleneck";
+import { InvalidArgumentError, program } from "commander";
+import PocketBase2 from "pocketbase";
+var TBL_SENT_MESSAGES = `sent_messages`;
+var sendMail = async () => {
+  const { dbg, info } = LoggerService().create(`mail.ts`);
+  function myParseInt(value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+      throw new InvalidArgumentError("Not a number.");
+    }
+    return parsedValue;
+  }
+  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;
+    });
+  }
+  program.argument(`<messageId>`, `ID of the message to send`).option("--limit <number>", `Max messages to send`, myParseInt, 1).option("--confirm", `Really send messages`, false).action(async (messageId, { limit, confirm }) => {
+    dbg({ messageId, confirm, limit });
+    const { getDatabase } = SqliteService({});
+    const db = await getDatabase(MOTHERSHIP_DATA_DB());
+    info(MOTHERSHIP_URL());
+    const client = new PocketBase2(MOTHERSHIP_INTERNAL_URL());
+    await client.admins.authWithPassword(
+      MOTHERSHIP_ADMIN_USERNAME(),
+      MOTHERSHIP_ADMIN_PASSWORD()
+    );
+    const message = await client.collection(`campaign_messages`).getOne(messageId, { expand: "campaign" });
+    const { campaign } = message.expand || {};
+    dbg({ messageId, limit, message, campaign });
+    const vars = {
+      messageId
+    };
+    await Promise.all(
+      map4(campaign.vars, async (sql2, k) => {
+        const res = await db.raw(sql2);
+        const [{ value }] = res;
+        vars[k.toLocaleLowerCase()] = value;
+      })
+    );
+    dbg({ vars });
+    const subject = interpolateString(message.subject, vars);
+    const body = interpolateString(message.body, vars);
+    const sql = `SELECT u.*
+    FROM (${campaign.usersQuery}) u
+    LEFT JOIN sent_messages sm ON u.id = sm.user AND sm.campaign_message = '${messageId}'
+    WHERE sm.id IS NULL;
+     `;
+    dbg(sql);
+    const users = (await db.raw(sql)).slice(0, limit);
+    const limiter = new Bottleneck5({ maxConcurrent: 1, minTime: 100 });
+    await Promise.all(
+      users.map((user) => {
+        return limiter.schedule(async () => {
+          if (!confirm) {
+            const old = user.email;
+            user.email = TEST_EMAIL();
+            info(`Sending to ${user.email} masking ${old}`);
+          } else {
+            info(`Sending to ${user.email}`);
+          }
+          await client.send(`/api/mail`, {
+            method: "POST",
+            body: {
+              to: user.email,
+              subject,
+              body: `${body}<hr/>I only send PocketHost annoucements. But I get it. <a href="https://pockethost-central.pockethost.io/api/unsubscribe?e=${user.id}">[[unsub]]</a>`
+            }
+          });
+          info(`Sent`);
+          if (confirm) {
+            await client.collection(TBL_SENT_MESSAGES).create({
+              user: user.id,
+              message: messageId,
+              campaign_message: messageId
+            });
+          }
+        });
+      })
+    );
+    SqliteService().shutdown();
+  });
+  program.parseAsync();
+};
+
+// src/cli/commands/SendMailCommand/index.ts
+var SendMailCommand = () => {
+  const cmd = new Command8(`mail:send`).description(`Send a PocketHost bulk mail`).action(async (options) => {
+    const logger = LoggerService().create(`SendMailCommand`);
+    const { dbg, error, info, warn } = logger;
+    info(`Starting`);
+    await sendMail();
+  });
+  return cmd;
+};
+
+// src/cli/index.ts
+var { version } = package_default;
+DefaultSettingsService(SETTINGS);
+LoggerService({});
+var main = async () => {
+  program2.name("pockethost").description("Multitenant PocketBase hosting").version(version);
+  program2.addCommand(EdgeFtpServeCommand()).addCommand(MothershipCommand()).addCommand(EdgeSyslogServeCommand()).addCommand(EdgeDaemonServeCommand()).addCommand(DownloadCommand()).addCommand(HealthCommand()).addCommand(ProxyCommand()).addCommand(SendMailCommand());
+  await program2.parseAsync();
+};
+main();
+export {
+  main
+};