pockethost 1.0.0-rc.1 → 1.0.0

package/common.ts

@@ -0,0 +1 @@
+export * from './src/common'

package/core.ts

@@ -0,0 +1,2 @@
+export * from './src/common'
+export * from './src/core'

package/package.json

@@ -1,144 +1,56 @@
 {
   "name": "pockethost",
-  "version": "1.0.0-rc.1",
+  "version": "1.0.0",
   "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"
-    ]
-  },
+  "main": "./common.ts",
+  "module": "./common.ts",
   "type": "module",
+  "bin": {
+    "pockethost": "src/cli/index.ts"
+  },
   "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",
+    "chalk": "^5.3.0",
     "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",
+    "env-paths": "^3.0.0",
     "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",
+    "listr2": "^8.2.3",
     "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",
+    "pocketbase": "^0.21.3",
+    "rimraf": "^5.0.5",
+    "semver": "^7.6.2",
     "tmp": "^0.2.1",
-    "url-pattern": "^1.0.3",
-    "vhost": "^3.0.2",
-    "winston": "^3.11.0",
-    "winston-syslog": "^2.7.0"
+    "tsx": "^4.15.7",
+    "type-fest": "^4.6.0",
+    "typescript": "^5.4.5",
+    "url-pattern": "^1.0.3"
   },
   "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"
+    "@types/tmp": "^0.2.5"
   },
-  "packageManager": "pnpm@8.10.2"
-}
+  "scripts": {
+    "check-types": "tsc --noEmit ",
+    "lint": "prettier -c \"./**/*.{ts,js,cjs,svelte,json}\"",
+    "dev": "NODE_ENV=development tsx --watch ./src/cli/index.ts",
+    "start": "tsx ./src/cli/index.ts"
+  }
+}

package/readme.md

@@ -1,168 +1,58 @@
-# pockethost.io
+# PocketHost
 
-## Introduction
+PocketHost is the open source multi-tenant PocketBase server. PocketHost can run dozens, hundreds, even thousands of PocketBase instances on a single server or across a global cloud.
 
-PocketHost is the open source cloud hosting platform for PocketBase. https://pockethost.io is the flagship service running PocketHost, where you can host your PocketBase projects with zero setup. Create a project like you would in Firebase and Supabase and let PocketHost do the rest.
+Extend PocketHost with its Plugin ecosystem. Start with the bare-bones dev server and add plugins to grow your enterprise into a global cloud.
 
-Features:
+---
 
-- Create unlimited PocketBase instances
-- Each instance runs on a subdomain of `pockethost.io`
-- Run your instance in an ultra-beefy shared environment
+### Sponsored by https://pockethost.io. Instantly host your PocketBase projects.
 
-**Focus on your app**
+---
 
-Get a live PocketBase instance in 10 seconds with no backend setup:
+## Quickstart
 
-1. Create an account at pockethost.io
-2. Provision your first PocketBase instance
-3. Connect from anywhere
-
-```ts
-const client = new PocketBase(`https://harvest.pockethost.io`)
-```
-
-**Batteries Included**
-
-Here's all the Linux/devops stuff that PocketHost does for you:
-
-- Email and DKIM+SPF and more
-- DNS jargon: MX, TXT, CNAME
-- SSL cert provisioning and management
-- Storage
-- Volume mounts
-- Cloud computing or VPS deployment
-- CDN and static asset hosting
-- Amazon AWS
-- Lots more - scaling, firewalls, DDoS defense, user security, log rotation, patches, updates, build tools, CPU architectures, multitenancy, on and on
-
-PocketHost is free and open source project licensed under the MIT License.
-
-This monorepo contains the entire open source stack that powers pockethost.io. You can use it to run your own private or public multitenant platform.
-
-**Questions?**
-
-Head over to Discord and ask away.
-
-## Frontend only
-
-If you just want to work on the UI/frontend client apps, they are configured to connect to pockethost.io out of the box. This is the most convenient way to make UI modifications to the PocketHost project.
-
-```bash
-git clone git@github.com:benallfree/pockethost.git
-cd pockethost
-pnpm
-pnpm dev:lander            # Marketing/blog area
-pnpm dev:dashboard      # Dashboard/control panel
-```
-
-## All our base
-
-**Running in dev mode**
-
-Note for OS X users: if the `pocketbase` binaries do not run, it's probably your [security settings](https://support.apple.com/guide/mac-help/open-a-mac-app-from-an-unidentified-developer-mh40616/mac).
-
-**Prerequisites**
-
-Local PocketHost development relies on Caddy to create reverse proxies into the various services powering the PocketHost backend. We use `lvh.me` to work with subdomains that resolve to localhost.
-
-```bash
-brew install caddy
 ```
-
-Then:
-
-```bash
-git clone git@github.com:benallfree/pockethost.git
-cd pockethost
-pnpm
-cp .env-template .env
+npx pockethost serve
 ```
 
-`.env-template` is preconfigured to make all of PocketHost run locally using `lvh.me` as follows:
-
-```bash
-pnpm dev
-
-# marketing/blog
-open https://pockethost.lvh.me
-
-# dashboard
-open https://app.pockethost.lvh.me
-
-# mothership
-open https://pockethost-central.pockethost.lvh.me
-
-# sample edge server (ph1)
-open https://instance1.ph1.edge.pockethost.lvh.me
-
-# second edge server (ph2)
-open https://instance2.ph2.edge.pockethost.lvh.me
-```
-
-Additionally, the setup creates the following users and instances:
-
-**Admin**  
-https://pockethost-central.pockethost.lvh.me  
-login: `admin@pockethost.lvh.me`  
-password: `password`
-
-**User**  
-https://app.pockethost.lvh.me  
-login: `user@pockethost.lvh.me`  
-password: `password`
-
-The user `user@pockethost.lvh.me` owns `instance1` and `instance2`, each which is running in its own region on separate edge servers.
-
-That's it! You can control all this and much more from the `.env-template` file. It's fully documented, but here it is again just in case.
-
-## Public Variables (available to frontend and backend)
+## Configuration
 
-| Name                    | Default                     | Discussion                                                                                                                                                                                                                                         |
-| ----------------------- | --------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| PUBLIC_DEBUG            | `true`                      | The global debugging variable, used by both frontends and backend services.                                                                                                                                                                        |
-| PUBLIC_HTTP_PROTOCOL    | `https`                     | You can use `http` if you like, but there is really no reason to. Caddy automatically provisions SSL certificates even for local development, and Cloudflare (recommended for DNS and CDN) does too.                                               |
-| PUBLIC_APEX_DOMAIN      | `pockethost.lvh.me`         | The apex domain is the domain on which all other subdomains live. If you set up your own PocketHost-based service, you'll want to change this. If you're just focusing on contributing to the project (please do!), then you can leave this as-is. |
-| PUBLIC_APP_DOMAIN       | `app.<apex>`                | The fully qualified domain on which the dashboard/control panel lives (app). Probably no reason to alter this, as it defaults to `app` on the apex domain defined earlier.                                                                         |
-| PUBLIC_BLOG_DOMAIN      | `<apex>`                    | The marketing/blog site lives on `<apex>` itself.                                                                                                                                                                                                  |
-| PUBLIC_EDGE_APEX_DOMAIN | `<id>.edge.<apex>`          | Edge servers are the work horses of PocketHost. They receive incoming requests and route them to PocketBase instances. Each edge server needs a unique `<id>`, which are generally named after geographic regions such as `sfo-1`, `nyc-2`, etc.   |
-| PUBLIC_MOTHERSHIP_URL   | `pockethost-central.<apex>` | The mothership URL is configurable because there may be cases where you want to deploy the mothership to its own central region. It does not live on an edge node.                                                                                 |
+PocketHost supports configuration by environment variable. All PocketHost environment variables begin with `PH_`.
 
-## Mothership Variables (backend only)
+PocketHost will search the current directory for an `.env` when it loads. Anything in `.env` will be merged with and override any `<PH_HOME>/.env` that may exist.
 
-The Mothership is a set of backend services, including a central `pocketbase` instance, that is the source of truth for the state of PocketHost.
+Use `pockethost config` to set global defaults stored in `<PH_HOME>/.env`.
 
-| Name                      | Default                                | Discussion                                                                                                                                                               |
-| ------------------------- | -------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| MOTHERSHIP_MIGRATIONS_DIR | `<root>/src/mothership-app/migrations` | The directory where the Mothership migrations live. This is typically kept in revision control, so the default location is within the project directory structure.       |
-| MOTHERSHIP_HOOKS_DIR      | `<root>/src/mothership-app/pb_hooks`   | The directory where the Mothership `pb_hooks` live. This is typically kept in revision control, so the default location is within the project directory structure.       |
-| MOTHERSHIP_ADMIN_USERNAME | `admin@pockethost.lvh.me`              | This admin login is created the first time PocketHost runs.                                                                                                              |
-| MOTHERSHIP_ADMIN_PASSWORD | `password`                             |                                                                                                                                                                          |
-| DEMO_USER_USERNAME        | `user@pockethost.lvh.me`               | This login is created the first time PocketHost runs                                                                                                                     |
-| DEMO_USER_PASSWORD        | `password`                             |                                                                                                                                                                          |
-| MOTHERSHIP_PORT           | `8091`                                 | The port the Mothership service will listen on.                                                                                                                          |
-| MOTHERSHIP_SEMVER         | `(blank)`                              | The semver used to lock the Mothership to a specific `pocketbase` version range. The Mothership will never launch with a `pocketbase` binary version outside this range. |
-| MOTHERSHIP_PRIVATE_URL    | `http://mothership.pockdthost.lvh.me`  | This should be set to an intranet IP address in production settings.                                                                                                     |
+### Variables
 
-## Edge Variables (backend only)
+| Name           | Default                    | Discussion                                                                    |
+| -------------- | -------------------------- | ----------------------------------------------------------------------------- |
+| PH_HOME        | `~/.pockethost`            | PocketHost's home directory where it holds all data.                          |
+| PH_APEX_DOMAIN | `pockethost.lvh.me`        | The apex domain used for routing and determining instance names.              |
+| PH_PORT        | `3000`                     | The port PocketHost listens on                                                |
+| PH_DEBUG       | `NODE_ENV==='development'` | Debug mode                                                                    |
+| PH_PLUGINS     | (see below)                | A comma-separated list of Plugins to load                                     |
+| PH_DATA_DIR    | `~/.pockethost/data`       | The root directory for storing PocketHost data, including instance databases. |
+| PH_DEV         | `NODE_ENV==='development'` | Whether PocketHost is running in development mode.                            |
 
-An Edge node is the workhorse of PocketHost. Edge nodes manage `pocketbase` instances, spin them up, shut them down when idle, implement security, and afford regional access to instances. They communicate with the Mothership through `MOTHERSHIP_PRIVATE_URL`.
+### Default Plugins
 
-| Name                       | Default        | Discussion                                                                                                                                                                                 |
-| -------------------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| EDGE_DATA_ROOT             | `<root>/.data` | Where the edge node should store its pocketbase instance data                                                                                                                              |
-| EDGE_INSTANCE_MIN_IDLE_TTL | `5000`         | The minimum amount of time an instance must remain idle (no connections) before an edge node is allowed to shut it down to free up resources                                               |
-| EDGE_INSTANCE_POOL_SIZE    | `20`           | The maximum number of simultaneous instances the edge node will allow to run concurrently. If this limit is exceeded, connections to instances not yet running in the pool will be denied. |
-| \*\*IP_CIDR                | `(blank)`      | A comma-separated list of upstream proxy IP addresses or ranges PocketHost will respond to.                                                                                                |
+- `@pockethost/plugin-console-logger`
+- `@pockethost/plugin-launcher-spawn`
 
-\* Note: `PUBLIC_*` environment variables are visible to the frontend as well.
+## Plugins
 
-\*\* Note: [Cloudflare IP addresses](https://www.cloudflare.com/ips/) are currently: `173.245.48.0/20,103.21.244.0/22,103.22.200.0/22,103.31.4.0/22,141.101.64.0/18,108.162.192.0/18,190.93.240.0/20,188.114.96.0/20,197.234.240.0/22,198.41.128.0/17,162.158.0.0/15,104.16.0.0/13,104.24.0.0/14,172.64.0.0/13,131.0.72.0/22`. [Learn more about IP CIDR](https://developers.cloudflare.com/fundamentals/setup/allow-cloudflare-ip-addresses/).
+PocketHost uses a hook architecture and features many plugins. Some plugins have a CLI component, whereas others add purely programmatic support to alter how PocketHost works:
 
-## Security Variables (backend only)
+| name                   | description                                                                                                                            |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| plugin-ftp-server      | Used to provide secure FTPS access to PocketBase instance data. This FTP server can run along-side a PocketHost server.                |
+| plugin-launcher-docker | Launches PocketBase instances via Docker. This is useful for running untrusted PocketBase code and instances. pockethost.io uses this. |
+| plugin-launcher-spawn  | Launches PocketBase instances via `spawn()` on the local machine. PocketHost uses this by default.                                     |
+| plugin-waf             | A Web Application Firewall                                                                                                             |
+| plugin-waf-enforce-ssl | Enforce SSL at the WAF                                                                                                                 |
 
-| Name    | Default   | Discussion                                                                                  |
-| ------- | --------- | ------------------------------------------------------------------------------------------- |
-| IP_CIDR | `(blank)` | A comma-separated list of upstream proxy IP addresses or ranges PocketHost will respond to. |
+## Support
 
-Note: [Cloudflare IP addresses](https://www.cloudflare.com/ips/) are currently: `173.245.48.0/20,103.21.244.0/22,103.22.200.0/22,103.31.4.0/22,141.101.64.0/18,108.162.192.0/18,190.93.240.0/20,188.114.96.0/20,197.234.240.0/22,198.41.128.0/17,162.158.0.0/15,104.16.0.0/13,104.24.0.0/14,172.64.0.0/13,131.0.72.0/22`. [Learn more about IP CIDR](https://developers.cloudflare.com/fundamentals/setup/allow-cloudflare-ip-addresses/).
+PocketHost has a thriving [Discord community](https://discord.gg/nVTxCMEcGT).

package/src/cli/PluginCommand/index.ts

@@ -0,0 +1,104 @@
+import { Command } from 'commander'
+import { parse } from 'dotenv'
+import { existsSync, readFileSync, writeFileSync } from 'fs'
+import { error, info } from '..'
+import { PH_HOME, PH_PLUGINS, PH_PROJECT_DIR } from '../../constants'
+import { getCompatibleVersions, removePackage } from './util'
+
+const envFile = () => {
+  const envFile = PH_HOME(`.env`)
+  if (!existsSync(envFile)) {
+    writeFileSync(envFile, '')
+  }
+  return envFile
+}
+
+const _parse = () =>
+  parse(readFileSync(envFile(), { encoding: 'utf8' }).toString())
+
+export const PluginCommand = () => {
+  const cmd = new Command(`plugin`)
+    .description(`Manage PocketHost plugins`)
+    .addCommand(
+      new Command(`install`)
+        .alias(`i`)
+        .argument(`<name>`, `NPM registry plugin name`)
+        .description(`Install a plugin`)
+        .action(async (name: string) => {
+          try {
+            const pkg = JSON.parse(
+              readFileSync(PH_PROJECT_DIR(`package.json`), 'utf8').toString(),
+            )
+            const { version } = pkg
+            await getCompatibleVersions(`pockethost`, version, [name])
+
+            const values = _parse()
+            values[`PH_PLUGINS`] = [
+              ...(values[`PH_PLUGINS`]
+                ?.split(/,/)
+                .map((v) => v.trim())
+                .filter((v) => !!v) || []),
+              name,
+            ].join(`,`)
+            writeFileSync(
+              envFile(),
+              Object.entries(values)
+                .map(([k, v]) => `${k}=${v}`)
+                .join('\n'),
+            )
+            info(`Installed ${name}`)
+            info(`Written to ${envFile()}`)
+          } catch (e) {
+            error(`${e}`)
+          }
+        }),
+    )
+
+    .addCommand(
+      new Command(`remove`)
+        .alias(`rm`)
+        .alias(`uninstall`)
+        .alias(`delete`)
+        .argument(`<name>`, `Plugin name`)
+        .description(`Remove a plugin`)
+        .action(async (name) => {
+          try {
+            await removePackage(name)
+            const values = _parse()
+            values[`PH_PLUGINS`] = [
+              ...(values[`PH_PLUGINS`]
+                ?.split(/,/)
+                .map((v) => v.trim())
+                .filter((v) => v !== name) || []),
+            ].join(`,`)
+            writeFileSync(
+              envFile(),
+              Object.entries(values)
+                .map(([k, v]) => `${k}=${v}`)
+                .join('\n'),
+            )
+            info(`Removed ${name}`)
+            info(`Written to ${envFile()}`)
+          } catch (e) {
+            error(`${e}`)
+          }
+        }),
+    )
+    .addCommand(
+      new Command(`update`)
+        .alias(`up`)
+        .description(`Update all plugins`)
+        .action(async () => {
+          try {
+            const pkg = JSON.parse(
+              readFileSync(PH_PROJECT_DIR(`package.json`), 'utf8').toString(),
+            )
+            const { version } = pkg
+            await getCompatibleVersions(`pockethost`, version, PH_PLUGINS())
+          } catch (e) {
+            error(`${e}`)
+          }
+        }),
+    )
+  return cmd
+}

package/src/cli/PluginCommand/util.ts

@@ -0,0 +1,138 @@
+import { exec } from 'child_process'
+import fs from 'fs/promises'
+import { Listr, ListrTask } from 'listr2'
+import { createRequire } from 'module'
+import fetch from 'node-fetch'
+import semver from 'semver'
+import util from 'util'
+
+const execPromise = util.promisify(exec)
+const require = createRequire(import.meta.url)
+
+async function getPackageJson(packageName: string): Promise<any | null> {
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'))
+    return packageJson
+  } catch (error) {
+    return null
+  }
+}
+
+async function fetchPackageData(packageName: string): Promise<any | null> {
+  const npmRegistryUrl = `https://registry.npmjs.org/${packageName}`
+  try {
+    const response = await fetch(npmRegistryUrl)
+    return await response.json()
+  } catch (error) {
+    return null
+  }
+}
+
+async function installPackage(
+  packageName: string,
+  version: string,
+): Promise<void> {
+  try {
+    await execPromise(`npm install -g ${packageName}@${version}`)
+  } catch (e) {
+    throw new Error(`Error installing ${packageName}@${version}: ${e}`)
+  }
+}
+
+export async function removePackage(packageName: string): Promise<void> {
+  try {
+    await execPromise(`npm remove -g ${packageName}`)
+  } catch (e) {
+    throw new Error(`Error removing ${packageName}: ${e}`)
+  }
+}
+
+async function checkPackageCompatibility(
+  packageA: string,
+  versionA: string,
+  packageB: string,
+): Promise<string> {
+  const localPackageJson = await getPackageJson(packageB)
+
+  if (localPackageJson) {
+    const { version: localPackageBVersion, dependencies } = localPackageJson
+
+    if (dependencies && semver.satisfies(versionA, dependencies[packageA])) {
+      return `Local ${packageB}@${localPackageBVersion} is already compatible with ${packageA}@${versionA}`
+    }
+  }
+
+  const packageBData = await fetchPackageData(packageB)
+  if (!packageBData) {
+    throw new Error(`Error fetching data for ${packageB}`)
+  }
+
+  const versions = packageBData.versions
+  let latestCompatibleVersion: string | null = null
+
+  for (const version in versions) {
+    const dependencies = versions[version].dependencies
+    if (
+      dependencies &&
+      packageA in dependencies &&
+      semver.satisfies(versionA, dependencies[packageA])
+    ) {
+      if (
+        !latestCompatibleVersion ||
+        semver.gt(version, latestCompatibleVersion)
+      ) {
+        latestCompatibleVersion = version
+      }
+    }
+  }
+
+  if (latestCompatibleVersion) {
+    await installPackage(packageB, latestCompatibleVersion)
+    return `${packageB}@${latestCompatibleVersion} installed successfully`
+  } else {
+    throw new Error(
+      `No compatible version of ${packageB} found for ${packageA}@${versionA}`,
+    )
+  }
+}
+
+export async function getCompatibleVersions(
+  packageA: string,
+  versionA: string,
+  packagesB: string[],
+): Promise<void> {
+  const tasks = packagesB.map(
+    (packageB) =>
+      ({
+        title: `Checking ${packageB}...`,
+        task: async (_, task) => {
+          try {
+            const result = await checkPackageCompatibility(
+              packageA,
+              versionA,
+              packageB,
+            )
+            task.output = result
+          } catch (error) {
+            task.output = `${error}`
+            throw error
+          }
+        },
+      }) as ListrTask,
+  )
+
+  const listr = new Listr(tasks, {
+    concurrent: true,
+    rendererOptions: { collapseSubtasks: false },
+  })
+
+  await listr.run()
+}
+
+// Example usage
+// const packageA = 'express'
+// const versionA = '4.17.1'
+// const packagesB = ['some-package', 'another-package', 'yet-another-package']
+
+// getCompatibleVersions(packageA, versionA, packagesB)