x3ui-api 1.0.3 → 1.0.5

package/src/protocols/vless/RealityBuilder.js

@@ -0,0 +1,223 @@
+const crypto = require("crypto");
+const RealityClientBuilder = require("./RealityClientBuilder");
+
+module.exports = class RealityBuilder {
+    constructor(client, options = {}) {
+        this.client = client;
+        // Initialize from InboundConfig
+        this.id = options.id || undefined;
+        this.port = options.port || 0;
+        this.remark = options.remark || '';
+        this.listenIP = options.listen || '';
+        this.expiryTime = options.expiryTime || 0;
+        this.enable = true;
+
+        // Initialize from StreamSettings and RealitySettings
+        const streamSettings = typeof options.streamSettings === 'string'
+            ? JSON.parse(options.streamSettings)
+            : options.streamSettings || {};
+
+        const realitySettings = streamSettings?.realitySettings || {};
+
+        this.dest = realitySettings.dest || 'yahoo.com:443';
+        this.serverNames = realitySettings.serverNames || ['yahoo.com', 'www.yahoo.com'];
+        this.privateKey = realitySettings.privateKey || '';
+        this.publicKey = realitySettings.settings?.publicKey || '';
+        this.shortIds = realitySettings.shortIds;
+        this.fingerprint = realitySettings.settings?.fingerprint || 'chrome';
+
+        // Initialize clients
+        this.clients = [];
+        const settings = typeof options.settings === 'string'
+            ? JSON.parse(options.settings)
+            : options.settings;
+
+        if (settings?.clients) {
+            settings.clients.forEach(client => {
+                this.addClient(client);
+            });
+        }
+    }
+
+    setPort(port) {
+        this.port = port;
+        return this;
+    }
+
+    setRemark(remark) {
+        this.remark = remark;
+        return this;
+    }
+
+    setDest(dest) {
+        this.dest = dest;
+        return this;
+    }
+
+    setServerNames(names) {
+        this.serverNames = names;
+        return this;
+    }
+
+    setKeyPair(privateKey, publicKey) {
+        this.privateKey = privateKey;
+        this.publicKey = publicKey;
+        return this;
+    }
+
+    setShortIds(ids) {
+        this.shortIds = ids;
+        return this;
+    }
+
+    setFingerprint(fingerprint) {
+        this.fingerprint = fingerprint;
+        return this;
+    }
+
+    setListenIP(ip) {
+        this.listenIP = ip;
+        return this;
+    }
+
+    setExpiryTime(timestamp) {
+        this.expiryTime = timestamp;
+        return this;
+    }
+
+    addClient(options = {}) {
+        const builder = new RealityClientBuilder(this);
+        if (options.id) builder.setId(options.id);
+        if (options.email) builder.setEmail(options.email);
+        if (options.totalGB) builder.setTotalGB(options.totalGB);
+        if (options.expiryTime) builder.setExpiryTime(options.expiryTime);
+        if (options.tgId) builder.setTgId(options.tgId);
+        builder.parent.streamSettings = {
+            realitySettings: {
+                serverNames: this.serverNames,
+                settings: {
+                    fingerprint: this.fingerprint,
+                    publicKey: this.publicKey,
+                    spiderX: '/'
+                },
+                shortIds: this.shortIds
+            }
+        };
+        this.clients.push(builder);
+        return builder;
+    }
+
+    getClientLink(clientIndex = 0, host) {
+        if (clientIndex < 0 || clientIndex >= this.clients.length) {
+            throw new Error('Invalid client index');
+        }
+        const client = this.clients[clientIndex];
+        return client.getLink(host || this.listenIP || 'localhost', this.port);
+    }
+
+    generateRandomPort() {
+        return Math.floor(Math.random() * (65535 - 1024) + 1024);
+    }
+
+    generateShortId() {
+        const length = Math.floor(Math.random() * 7) * 2 + 2; // Random length between 2 and 16
+        return crypto.randomBytes(Math.ceil(length / 2))
+            .toString('hex')
+            .slice(0, length);
+    }
+
+    async build() {
+        if (!this.remark) {
+            throw new Error('Remark is required');
+        }
+
+        // If no port specified, find unused one
+        if (!this.port) {
+            const inbounds = await this.client.getInbounds();
+            const usedPorts = new Set(inbounds.map(i => i.port));
+            let port;
+            do {
+                port = this.generateRandomPort();
+            } while (usedPorts.has(port));
+            this.port = port;
+        }
+
+        // If no keypair provided, generate one
+        if (!this.privateKey || !this.publicKey) {
+            const cert = await this.client.getNewX25519Cert();
+            this.privateKey = cert.privateKey;
+            this.publicKey = cert.publicKey;
+        }
+
+        // If no shortIds provided, generate random ones
+        if (!this.shortIds) {
+            this.shortIds = Array.from({ length: 8 }, () => this.generateShortId());
+        }
+
+        // If no clients added, create one default client
+        if (this.clients.length === 0) {
+            this.addClient();
+        }
+
+        // Build all clients
+        const clientConfigs = await Promise.all(this.clients.map(builder => builder.build()));
+
+        return {
+            id: this.id,
+            up: 0,
+            down: 0,
+            total: 0,
+            remark: this.remark,
+            enable: true,
+            expiryTime: this.expiryTime,
+            listen: this.listenIP,
+            port: this.port,
+            protocol: 'vless',
+            settings: {
+                clients: clientConfigs,
+                decryption: 'none',
+                fallbacks: []
+            },
+            streamSettings: {
+                network: 'tcp',
+                security: 'reality',
+                externalProxy: [],
+                realitySettings: {
+                    show: false,
+                    xver: 0,
+                    dest: this.dest,
+                    serverNames: this.serverNames,
+                    privateKey: this.privateKey,
+                    minClient: '',
+                    maxClient: '',
+                    maxTimediff: 0,
+                    shortIds: this.shortIds,
+                    settings: {
+                        publicKey: this.publicKey,
+                        fingerprint: this.fingerprint,
+                        serverName: '',
+                        spiderX: '/'
+                    }
+                },
+                tcpSettings: {
+                    acceptProxyProtocol: false,
+                    header: {
+                        type: 'none'
+                    }
+                }
+            },
+            tag: `inbound-${this.port}`,
+            sniffing: {
+                enabled: false,
+                destOverride: ['http', 'tls', 'quic', 'fakedns'],
+                metadataOnly: false,
+                routeOnly: false
+            },
+            allocate: {
+                strategy: 'always',
+                refresh: 5,
+                concurrency: 3
+            }
+        };
+    }
+}

package/src/protocols/vless/RealityClientBuilder.d.ts

@@ -0,0 +1,11 @@
+import ClientBuilder from "../../core/ClientBuilder";
+
+export default class RealityClientBuilder extends ClientBuilder {
+
+    /**
+     * Generate connection link for this client
+     * @param host Host address
+     * @param port Optional port number, defaults to parent's port
+     */
+    getLink(host: string, port?: number): string;
+}

package/src/protocols/vless/RealityClientBuilder.js

@@ -0,0 +1,25 @@
+const ClientBuilder = require('../../core/ClientBuilder');
+
+module.exports = class RealityClientBuilder extends ClientBuilder {
+    getLink(host, port) {
+        const id = this.id || crypto.randomUUID();
+        const settings = this.parent.streamSettings?.realitySettings;
+        if (!settings) throw new Error('Reality settings not found');
+
+        port = port || this.parent.port;
+        let protocol = this.parent.protocol || 'vless';
+
+        const params = new URLSearchParams({
+            security: this.parent.streamSettings?.security || 'reality',
+            sni: settings.serverNames[0],
+            fp: settings.settings.fingerprint,
+            pbk: settings.settings.publicKey,
+            sid: settings.shortIds[0],
+            spx: settings.settings.spiderX || '/',
+            type: this.parent.streamSettings?.network || 'tcp',
+            encryption: this.parent.settings?.decryption || 'none'
+        });
+
+        return `${protocol}://${id}@${host}:${port}?${params.toString()}#${encodeURIComponent(this.email || 'default')}`;
+    }
+}

package/src/protocols/vless/index.d.ts

@@ -0,0 +1,9 @@
+import RealityBuilder from "./RealityBuilder";
+import RealityClientBuilder from "./RealityClientBuilder";
+
+declare const _default: {
+    RealityBuilder: typeof RealityBuilder;
+    RealityClientBuilder: typeof RealityClientBuilder;
+};
+
+export default _default;

package/src/protocols/vless/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    RealityBuilder: require('./RealityBuilder'),
+    RealityClientBuilder: require('./RealityClientBuilder')
+}

package/src/protocols/vmess/VmessBuilder.d.ts

@@ -0,0 +1,77 @@
+import X3UIClient, {ClientSettings, InboundConfig} from "../../index";
+import VmessClientBuilder from "./VmessClientBuilder";
+
+/**
+ * Builder for Vmess inbound configurations
+ */
+export default class VmessBuilder {
+
+    constructor(client: X3UIClient, inbound?: Partial<InboundConfig>);
+
+    /**
+     * Set the port for the inbound. If not provided, will auto-generate unused port
+     */
+    setPort(port: number): this;
+
+    /**
+     * Set the remark/name for the inbound
+     */
+    setRemark(remark: string): this;
+
+    /**
+     * Set the network type (e.g. "httpupgrade", "tcp", "ws")
+     */
+    setNetwork(network: string): this;
+
+    /**
+     * Set security type (e.g. "none", "tls")
+     */
+    setSecurity(security: string): this;
+
+    /**
+     * Set HTTP upgrade path
+     */
+    setHttpUpgradePath(path: string): this;
+
+    /**
+     * Set HTTP upgrade host
+     */
+    setHttpUpgradeHost(host: string): this;
+
+    /**
+     * Configure sniffing settings
+     */
+    setSniffing(enabled: boolean, destOverride?: string[], metadataOnly?: boolean, routeOnly?: boolean): this;
+
+    /**
+     * Set listen IP address. Defaults to empty string
+     */
+    setListenIP(ip: string): this;
+
+    /**
+     * Set inbound expiry time. Defaults to 0 (no expiry)
+     */
+    setExpiryTime(timestamp: number): this;
+
+    /**
+     * Add a new client to the inbound
+     */
+    addClient(options?: Partial<ClientSettings>): VmessClientBuilder;
+
+    /**
+     * Get connection link for a client
+     * @param clientIndex Index of the client (defaults to 0)
+     * @param host Optional host address (defaults to listenIP or 'localhost')
+     */
+    getClientLink(clientIndex?: number, host?: string): string;
+
+    /**
+     * Generate a random port number
+     */
+    generateRandomPort(): number;
+
+    /**
+     * Build the final inbound config
+     */
+    build(): Promise<InboundConfig>;
+}

package/src/protocols/vmess/VmessBuilder.js

@@ -0,0 +1,189 @@
+const VmessClientBuilder = require('./VmessClientBuilder');
+
+module.exports = class VmessBuilder {
+    constructor(client, options = {}) {
+        this.client = client;
+        // Initialize from InboundConfig
+        this.id = options.id || undefined;
+        this.port = options.port || 0;
+        this.remark = options.remark || '';
+        this.listenIP = options.listen || '';
+        this.expiryTime = options.expiryTime || 0;
+        this.enable = true;
+        this.up = options.up || 0;
+        this.down = options.down || 0;
+        this.total = options.total || 0;
+
+        // Initialize from StreamSettings
+        const streamSettings = typeof options.streamSettings === 'string'
+            ? JSON.parse(options.streamSettings)
+            : options.streamSettings || {};
+
+        this.network = streamSettings.network || 'httpupgrade';
+        this.security = streamSettings.security || 'none';
+
+        // Initialize httpupgrade settings
+        this.httpupgradeSettings = streamSettings.httpupgradeSettings || {
+            acceptProxyProtocol: false,
+            path: '/',
+            host: '',
+            headers: {}
+        };
+
+        // Initialize sniffing
+        this.sniffing = options.sniffing || {
+            enabled: false,
+            destOverride: ['http', 'tls', 'quic', 'fakedns'],
+            metadataOnly: false,
+            routeOnly: false
+        };
+
+        // Initialize allocate
+        this.allocate = options.allocate || {
+            strategy: 'always',
+            refresh: 5,
+            concurrency: 3
+        };
+
+        // Initialize clients
+        this.clients = [];
+        const settings = typeof options.settings === 'string'
+            ? JSON.parse(options.settings)
+            : options.settings;
+
+        if (settings?.clients) {
+            settings.clients.forEach(client => {
+                this.addClient(client);
+            });
+        }
+    }
+
+    setPort(port) {
+        this.port = port;
+        return this;
+    }
+
+    setRemark(remark) {
+        this.remark = remark;
+        return this;
+    }
+
+    setNetwork(network) {
+        this.network = network;
+        return this;
+    }
+
+    setSecurity(security) {
+        this.security = security;
+        return this;
+    }
+
+    setHttpUpgradePath(path) {
+        this.httpupgradeSettings.path = path;
+        return this;
+    }
+
+    setHttpUpgradeHost(host) {
+        this.httpupgradeSettings.host = host;
+        return this;
+    }
+
+    setSniffing(enabled, destOverride = ['http', 'tls', 'quic', 'fakedns'], metadataOnly = false, routeOnly = false) {
+        this.sniffing = {
+            enabled,
+            destOverride,
+            metadataOnly,
+            routeOnly
+        };
+        return this;
+    }
+
+    setListenIP(ip) {
+        this.listenIP = ip;
+        return this;
+    }
+
+    setExpiryTime(timestamp) {
+        this.expiryTime = timestamp;
+        return this;
+    }
+
+    addClient(options = {}) {
+        const builder = new VmessClientBuilder(this);
+        if (options.id) builder.setId(options.id);
+        if (options.email) builder.setEmail(options.email);
+        if (options.totalGB) builder.setTotalGB(options.totalGB);
+        if (options.expiryTime) builder.setExpiryTime(options.expiryTime);
+        if (options.tgId) builder.setTgId(options.tgId);
+        if (options.security) builder.setSecurity(options.security);
+        if (options.limitIp) builder.setLimitIp(options.limitIp);
+
+        this.clients.push(builder);
+        return builder;
+    }
+
+    getClientLink(clientIndex = 0, host, port) {
+        if (clientIndex < 0 || clientIndex >= this.clients.length) {
+            throw new Error('Invalid client index');
+        }
+        const client = this.clients[clientIndex];
+        return client.getLink(host || this.listenIP || 'localhost', port || this.port);
+    }
+
+    generateRandomPort() {
+        return Math.floor(Math.random() * (65535 - 1024) + 1024);
+    }
+
+    async build() {
+        if (!this.remark) {
+            throw new Error('Remark is required');
+        }
+
+        // If no port specified, find unused one
+        if (!this.port) {
+            const inbounds = await this.client.getInbounds();
+            const usedPorts = new Set(inbounds.map(i => i.port));
+            let port;
+            do {
+                port = this.generateRandomPort();
+            } while (usedPorts.has(port));
+            this.port = port;
+        }
+
+        // If no clients added, create one default client
+        if (this.clients.length === 0) {
+            this.addClient();
+        }
+
+        // Build all clients
+        const clientConfigs = await Promise.all(this.clients.map(builder => builder.build()));
+
+        // Create tag for inbound
+        const tag = `inbound-${this.port}`;
+
+        // Build the complete inbound configuration
+        return {
+            up: this.up,
+            down: this.down,
+            total: this.total,
+            remark: this.remark,
+            enable: this.enable,
+            expiryTime: this.expiryTime,
+            listen: this.listenIP,
+            port: this.port,
+            protocol: 'vmess',
+            settings: {
+                clients: clientConfigs
+            },
+            streamSettings: {
+                network: this.network,
+                security: this.security,
+                externalProxy: [],
+                httpupgradeSettings: this.httpupgradeSettings
+            },
+            tag,
+            sniffing: this.sniffing,
+            allocate: this.allocate
+        };
+    }
+}

package/src/protocols/vmess/VmessClientBuilder.d.ts

@@ -0,0 +1,13 @@
+import ClientBuilder from "../../core/ClientBuilder";
+
+/**
+ * Builder for Vmess client configurations
+ */
+export default class VmessClientBuilder extends ClientBuilder {
+    /**
+     * Generate connection link for this client
+     * @param host Host address
+     * @param port Optional port number, defaults to parent's port
+     */
+    getLink(host: string, port?: number): string;
+}

package/src/protocols/vmess/VmessClientBuilder.js

@@ -0,0 +1,92 @@
+const crypto = require("crypto");
+module.exports = class VmessClientBuilder {
+    constructor(parent) {
+        this.parent = parent;
+        this.id = '';
+        this.email = '';
+        this.limitIp = 0;
+        this.totalGB = 0;
+        this.expiryTime = 0;
+        this.enable = true;
+        this.tgId = '';
+        this.subId = '';
+        this.reset = 0;
+        this.security = 'auto';
+    }
+
+    setId(id) {
+        this.id = id;
+        return this;
+    }
+
+    setEmail(email) {
+        this.email = email;
+        return this;
+    }
+
+    setTotalGB(gb) {
+        this.totalGB = gb;
+        return this;
+    }
+
+    setExpiryTime(timestamp) {
+        this.expiryTime = timestamp;
+        return this;
+    }
+
+    setTgId(id) {
+        this.tgId = id;
+        return this;
+    }
+
+    setSecurity(security) {
+        this.security = security;
+        return this;
+    }
+
+    setLimitIp(limit) {
+        this.limitIp = limit;
+        return this;
+    }
+
+    build() {
+        return {
+            id: this.id || crypto.randomUUID(),
+            email: this.email || Math.random().toString(36).substring(2, 10),
+            enable: this.enable,
+            expiryTime: this.expiryTime,
+            limitIp: this.limitIp,
+            reset: this.reset,
+            security: this.security,
+            subId: this.subId || Math.random().toString(36).substring(2, 18),
+            tgId: this.tgId,
+            totalGB: this.totalGB
+        };
+    }
+
+    getLink(host, port) {
+        const id = this.id || crypto.randomUUID();
+        const email = this.email || Math.random().toString(36).substring(2, 10);
+
+        // Create vmess config object
+        const vmessConfig = {
+            v: '2',
+            ps: email,
+            add: host,
+            port: port,
+            id: id,
+            aid: 0,
+            net: this.parent.network,
+            type: 'none',
+            host: this.parent.httpupgradeSettings.host,
+            path: this.parent.httpupgradeSettings.path,
+            tls: this.parent.security === 'tls' ? 'tls' : 'none',
+            sni: this.parent.httpupgradeSettings.host,
+            alpn: ''
+        };
+
+        // Convert to base64
+        const vmessLink = 'vmess://' + Buffer.from(JSON.stringify(vmessConfig)).toString('base64');
+        return vmessLink;
+    }
+}

package/src/protocols/vmess/index.d.ts

@@ -0,0 +1,9 @@
+import VmessBuilder from "./VmessBuilder";
+import VmessClientBuilder from "./VmessClientBuilder";
+
+declare const _default: {
+    VmessBuilder: typeof VmessBuilder;
+    VmessClientBuilder: typeof VmessClientBuilder;
+};
+
+export default _default;

package/src/protocols/vmess/index.js

@@ -0,0 +1,4 @@
+module.exports = {
+    VmessBuilder: require('./VmessBuilder'),
+    VmessClientBuilder: require('./VmessClientBuilder')
+}