x3ui-api 1.0.6-3 → 1.0.7-1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "x3ui-api",
-  "version": "1.0.6-3",
+  "version": "1.0.7-1",
   "description": "API client for x3ui panel",
   "main": "src/index.js",
   "types": "src/index.d.ts",

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

@@ -0,0 +1,51 @@
+import X3UIClient, {ClientSettings, InboundConfig, DeepPartial} from "../../index";
+import RealityClientBuilder from "./RealityClientBuilder";
+
+export default class ClearBuilder {
+
+    constructor(client: X3UIClient, inbound?: DeepPartial<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 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?: DeepPartial<ClientSettings>): RealityClientBuilder;
+
+    /**
+     * 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')
+     */
+    getClientLinkByIndex(clientIndex?: number, host?: string): string;
+
+    /**
+     * Get connection link for a client
+     * @param email Email of the client
+     * @param host Optional host address (defaults to listenIP or 'localhost')
+     */
+    getClientLinkByEmail(email: string, host?: string): string;
+
+    /**
+     * Build the final inbound config
+     */
+    build(): Promise<InboundConfig>;
+}

package/src/protocols/vless/ClearBuilder.js

@@ -0,0 +1,150 @@
+const ClearClientBuilder = require("./ClearClientBuilder");
+
+module.exports = class ClearBuilder {
+    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 || {};
+
+        // 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;
+    }
+
+    setListenIP(ip) {
+        this.listenIP = ip;
+        return this;
+    }
+
+    setExpiryTime(timestamp) {
+        this.expiryTime = timestamp;
+        return this;
+    }
+
+    addClient(options = {}) {
+        const builder = new ClearClientBuilder(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);
+        this.clients.push(builder);
+        return builder;
+    }
+
+    getClientLinkByIndex(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);
+    }
+
+    getClientLinkByEmail(email, host) {
+        const client = this.clients.find(client => client.email === email);
+        if (!client) {
+            throw new Error('Client not found');
+        }
+        return client.getLink(host || this.listenIP || 'localhost', 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()));
+
+        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: 'none',
+                externalProxy: [],
+                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
+            }
+        };
+    }
+}
+
+module.exports.default = module.exports;

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

@@ -0,0 +1,11 @@
+import ClientBuilder from "../../core/ClientBuilder";
+
+export default class ClearClientBuilder 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/ClearClientBuilder.js

@@ -0,0 +1,20 @@
+const ClientBuilder = require('../../core/ClientBuilder');
+
+module.exports = class ClearClientBuilder extends ClientBuilder {
+    getLink(host, port) {
+        const id = this.id || crypto.randomUUID();
+
+        port = port || this.parent.port;
+        let protocol = this.parent.protocol || 'vless';
+
+        const params = new URLSearchParams({
+            security: this.parent.streamSettings?.security || 'none',
+            type: this.parent.streamSettings?.network || 'tcp',
+            encryption: this.parent.settings?.decryption || 'none'
+        });
+
+        return `${protocol}://${id}@${host}:${port}?${params.toString()}#${encodeURIComponent(this.email || 'default')}`;
+    }
+}
+
+module.exports.default = module.exports;

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

@@ -4,6 +4,8 @@ import RealityClientBuilder from "./RealityClientBuilder";
 declare const _default: {
     RealityBuilder: typeof RealityBuilder;
     RealityClientBuilder: typeof RealityClientBuilder;
+    ClearBuilder: typeof RealityBuilder;
+    ClearClientBuilder: typeof RealityClientBuilder;
 };
 
 export default _default;

package/src/protocols/vless/index.js

@@ -1,6 +1,8 @@
 module.exports = {
     RealityBuilder: require('./RealityBuilder'),
-    RealityClientBuilder: require('./RealityClientBuilder')
+    RealityClientBuilder: require('./RealityClientBuilder'),
+    ClearBuilder: require('./ClearBuilder'),
+    ClearClientBuilder: require('./ClearClientBuilder')
 }
 
 module.exports.default = module.exports