@cloud-cli/px 4.4.0 → 4.4.1

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+import { help, init } from "@cloud-cli/cli";
+import { DomainAndTarget, DomainName, Proxy, WithOptionalProps } from "./types.js";
+declare const _default: {
+    add(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    remove(options: WithOptionalProps<DomainAndTarget>): Promise<boolean>;
+    update(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    list(filters: Partial<Proxy>): Promise<Proxy[]>;
+    get(options: DomainName): Promise<Proxy[]>;
+    domains(): Promise<string[]>;
+    reload(): Promise<void>;
+    [init](): Promise<import("@cloud-cli/proxy").ProxyServer>;
+    [help](): string;
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,45 @@
+import { help, init, logInfo } from "@cloud-cli/cli";
+import { ProxyManager } from "./proxy-manager.js";
+const manager = new ProxyManager();
+export default {
+    async add(options) {
+        return manager.addProxy(options);
+    },
+    async remove(options) {
+        return manager.removeProxy(options);
+    },
+    async update(options) {
+        return await manager.updateProxy(options);
+    },
+    list(filters) {
+        return manager.getProxyList(filters);
+    },
+    get(options) {
+        return manager.getProxyListForDomain(options);
+    },
+    domains() {
+        return manager.getDomainList();
+    },
+    async reload() {
+        logInfo("Reloading proxy server");
+        return await manager.reload();
+    },
+    async [init]() {
+        await manager.reload();
+        return manager.server;
+    },
+    [help]() {
+        return `Manages reverse proxy entries
+
+Available commands:
+  px.add --domain <domain> --target <url> [--cors] [--redirect] [--preserveHost] [--redirectUrl <url>] [--headers <headers>] [--authorization <value>] - Add an entry
+  px.remove --domain <domain> - Remove an entry
+  px.update --domain <domain> [proxy options] - Update an entry
+  px.list [--domain <domain>] [--target <url>] [proxy options] - List matching entries
+  px.get --domain <domain> - Get entries for a domain
+  px.domains - List configured domains
+  px.reload - Reload all proxy entries
+
+Proxy options: domain, target, cors, redirect, preserveHost, redirectUrl, headers, authorization`;
+    },
+};

package/dist/proxy-manager.d.ts

@@ -0,0 +1,14 @@
+import { ProxyServer } from '@cloud-cli/proxy';
+import type { DockerContainer, DomainAndTarget, DomainName, Proxy, WithOptionalProps } from './types.js';
+export declare class ProxyManager {
+    server: ProxyServer;
+    addProxy(properties: WithOptionalProps<Proxy>): Promise<Proxy>;
+    updateProxy(options: WithOptionalProps<Proxy>): Promise<Proxy>;
+    removeProxy(options: WithOptionalProps<DomainAndTarget>): Promise<boolean>;
+    getDomainList(): Promise<string[]>;
+    getProxyListWithContainers(): Promise<Proxy[]>;
+    getProxyList(filters?: Partial<Proxy>): Promise<Proxy[]>;
+    getProxyListForDomain(options: WithOptionalProps<DomainName>): Promise<Proxy[]>;
+    reload(): Promise<void>;
+    getRunningContainers(): Promise<DockerContainer[]>;
+}

package/dist/proxy-manager.js

@@ -0,0 +1,185 @@
+import { getStorage, getConfig } from '@cloud-cli/cli';
+import { ProxyEntry, ProxyServer, ProxySettings } from '@cloud-cli/proxy';
+import { exec } from '@cloud-cli/exec';
+const defaultOptions = {
+    httpPort: 80,
+    httpsPort: 443,
+    certsFolder: process.env.PX_CERTS_FOLDER || '/etc/letsencrypt/live',
+};
+const domainNotSpecifiedError = new Error('Domain not specified');
+const targetNotSpecifiedError = new Error('Target not specified');
+const moduleConfig = await getConfig('px', defaultOptions);
+const { set, get, has, remove, getAll } = getStorage('px');
+const settings = new ProxySettings({
+    certificatesFolder: moduleConfig.certsFolder,
+    certificateFile: 'fullchain.pem',
+    keyFile: 'privkey.pem',
+    httpPort: moduleConfig.httpPort,
+    httpsPort: moduleConfig.httpsPort,
+});
+const px = new ProxyServer(settings);
+const emptyProxy = {
+    domain: '',
+    target: '',
+    cors: false,
+    preserveHost: true,
+    redirect: false,
+    redirectUrl: '',
+    headers: '',
+    authorization: '',
+};
+const readDomain = (options) => {
+    options.domain = options.domain || options.host || options._[0];
+};
+const numberRe = /^[0-9]+$/;
+const readOption = value => {
+    switch (true) {
+        case value === 'true':
+            return true;
+        case value === 'false':
+            return false;
+        case numberRe.test(value):
+            return Number(value);
+        default:
+            return value;
+    }
+};
+function applyProperties(proxy, options) {
+    const properties = ['target', 'cors', 'redirect', 'redirectUrl', 'headers', 'authorization', 'preserveHost'];
+    for (const p of properties) {
+        if (p in options) {
+            proxy[p] = readOption(options[p]);
+        }
+    }
+}
+export class ProxyManager {
+    constructor() {
+        this.server = px;
+    }
+    async addProxy(properties) {
+        readDomain(properties);
+        if (!properties.domain) {
+            throw domainNotSpecifiedError;
+        }
+        if (!properties.target && !properties.redirectUrl) {
+            throw targetNotSpecifiedError;
+        }
+        const proxy = { ...emptyProxy, domain: properties.domain };
+        applyProperties(proxy, properties);
+        set(properties.domain, proxy);
+        await this.reload();
+        return proxy;
+    }
+    async updateProxy(options) {
+        readDomain(options);
+        const domain = options.domain;
+        let proxy = get(domain);
+        if (!domain) {
+            throw domainNotSpecifiedError;
+        }
+        if (!proxy) {
+            proxy = { ...emptyProxy, domain };
+        }
+        applyProperties(proxy, options);
+        set(proxy.domain, proxy);
+        await this.reload();
+        return proxy;
+    }
+    async removeProxy(options) {
+        readDomain(options);
+        const host = options.domain;
+        if (!host) {
+            throw domainNotSpecifiedError;
+        }
+        if (has(host)) {
+            remove(host);
+            await this.reload();
+            return true;
+        }
+        return false;
+    }
+    async getDomainList() {
+        const proxies = await this.getProxyList();
+        return proxies.map((proxy) => proxy.domain);
+    }
+    async getProxyListWithContainers() {
+        const staticRoutes = getAll();
+        const containers = (await this.getRunningContainers()).map(readProxyFromContainer);
+        const containerDomains = containers.map(c => c.domain.split('/')[0]);
+        const list = [
+            ...staticRoutes.filter(t => !containerDomains.includes(t.domain)),
+            ...containers,
+        ];
+        return list;
+    }
+    async getProxyList(filters = {}) {
+        const list = await this.getProxyListWithContainers();
+        const keys = Object.keys(filters);
+        if (!keys.length) {
+            return list;
+        }
+        return keys.reduce((list, key) => {
+            const filter = String(filters[key]).toLowerCase();
+            return list.filter((p) => String(p[key]).toLowerCase().includes(filter));
+        }, list);
+    }
+    async getProxyListForDomain(options) {
+        readDomain(options);
+        const all = await this.getProxyListWithContainers();
+        return all.filter((p) => p.domain.includes(options.domain));
+    }
+    async reload() {
+        const all = await this.getProxyListWithContainers();
+        px.reset();
+        for (const t of all) {
+            const [domain, path = ""] = t.domain.split("/");
+            px.add(new ProxyEntry({
+                domain,
+                path,
+                target: t.target,
+                redirectToHttps: t.redirect,
+                redirectToUrl: t.redirectUrl,
+                cors: t.cors,
+                headers: t.headers,
+                authorization: t.authorization,
+                preserveHost: t.preserveHost,
+            }));
+        }
+        px.start();
+    }
+    async getRunningContainers() {
+        const ps = await exec("docker", ["ps", "-aq"]);
+        const ids = ps.stdout.trim().split("\n");
+        const state = await exec("docker", ["inspect", ...ids]);
+        const json = JSON.parse(state.stdout);
+        return json
+            .map(readDockerContainer)
+            .filter(d => d.ports.length && d.labels.host);
+    }
+}
+function readProxyFromContainer(c) {
+    const domain = [c.labels.host, c.labels.path].filter(Boolean).join("/");
+    const proxyOverrides = get(domain) || {};
+    return {
+        ...emptyProxy,
+        ...proxyOverrides,
+        domain,
+        target: `http://localhost:${c.ports[0].host}`,
+    };
+}
+function readDockerContainer(d) {
+    const labels = Object.fromEntries(Object.entries(d.Config.Labels || {})
+        .filter(([key]) => key.startsWith("px:"))
+        .map(([key, value]) => [key.replace("px:", ""), value]));
+    return {
+        id: d.Id,
+        image: d.Image,
+        state: d.State.Status,
+        name: d.Name,
+        labels: labels,
+        ports: Object.entries(d.HostConfig.PortBindings || {}).map(([port, pb]) => ({
+            container: Number(port.replace(/\D+/, "")),
+            host: Number(pb[0].HostPort),
+        })),
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,33 @@
+interface OptionalProps {
+    host?: string;
+    _: string[];
+}
+export interface DomainName extends OptionalProps {
+    domain: string;
+}
+export interface DomainAndTarget extends DomainName {
+    target: string;
+}
+export interface Proxy {
+    domain: string;
+    target: string;
+    redirect: boolean;
+    preserveHost: boolean;
+    redirectUrl: string;
+    headers: string;
+    authorization: string;
+    cors: boolean;
+}
+export type WithOptionalProps<T extends object> = T & OptionalProps;
+export interface DockerContainer {
+    id: string;
+    image: string;
+    name: string;
+    state: string;
+    ports: Array<{
+        host: number;
+        container: number;
+    }>;
+    labels: Record<string, string>;
+}
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloud-cli/px",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "description": "Reverse Proxy",
   "main": "./dist/index.js",
   "type": "module",
@@ -8,7 +8,7 @@
   "prettier": "@cloud-cli/prettier-config",
   "scripts": {
     "test": "echo true",
-    "build": "rm -rf ./dist/* && npm update && tsc"
+    "build": "rm -rf ./dist/* && npx tsc"
   },
   "keywords": [
     "cloudy"