@qpjoy/electron-tunnel 0.1.0

package/dist/mihomo/MihomoManager.js

@@ -0,0 +1,635 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MihomoManager = void 0;
+const events_1 = require("events");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const zlib_1 = require("zlib");
+const yaml_1 = require("yaml");
+const TunnelDatabase_1 = require("../db/TunnelDatabase");
+const defaults_1 = require("../defaults");
+const renderRuntimeConfig_1 = require("../config/renderRuntimeConfig");
+const MihomoApi_1 = require("./MihomoApi");
+function pathsFromOptions(options) {
+    const root = (0, path_1.join)(options.userDataPath, 'mihomo-tunnel');
+    return {
+        root,
+        db: (0, path_1.join)(root, 'tunnel.sqlite'),
+        profiles: (0, path_1.join)(root, 'profiles'),
+        runtime: (0, path_1.join)(root, 'runtime'),
+        config: (0, path_1.join)(root, 'runtime', 'config.yaml'),
+        core: (0, path_1.join)(root, 'bin', 'mihomo')
+    };
+}
+function platformArchKey() {
+    const arch = process.arch === 'x64' ? 'x64' : process.arch;
+    return `${process.platform}-${arch}`;
+}
+function isRootUser() {
+    return typeof process.getuid === 'function' && process.getuid() === 0;
+}
+function needsElevatedTun(settings) {
+    return settings.mode === 'system-tun'
+        && settings.tunInstalled
+        && !isRootUser()
+        && (process.platform === 'darwin' || process.platform === 'linux');
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return isRecord(error) && error.code === 'EPERM';
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function basicAuthHeader(username, password) {
+    return `Basic ${Buffer.from(`${username}:${password}`).toString('base64')}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function normalizeSubscriptionInput(input) {
+    const rawUrl = input.url?.trim();
+    if (!rawUrl) {
+        throw new Error('subscription url is required');
+    }
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        throw new Error('subscription url is invalid');
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+        throw new Error('subscription url must use http or https');
+    }
+    const username = input.username?.trim() || decodeURIComponent(parsed.username);
+    const password = input.password || decodeURIComponent(parsed.password);
+    parsed.username = '';
+    parsed.password = '';
+    const inferredName = input.name?.trim()
+        || parsed.pathname.split('/').filter(Boolean).at(-1)
+        || parsed.hostname
+        || 'remote file';
+    return {
+        name: inferredName,
+        url: parsed.toString(),
+        username,
+        password
+    };
+}
+function validateSubscriptionYaml(content) {
+    let parsed;
+    try {
+        parsed = (0, yaml_1.parse)(content);
+    }
+    catch {
+        throw new Error('subscription yaml is invalid');
+    }
+    if (!isRecord(parsed)) {
+        throw new Error('subscription yaml is invalid');
+    }
+    if (!Array.isArray(parsed.proxies)
+        && !Array.isArray(parsed['proxy-groups'])
+        && !isRecord(parsed['proxy-providers'])) {
+        throw new Error('subscription yaml has no proxy definitions');
+    }
+}
+function normalizePort(value, label) {
+    if (!Number.isInteger(value) || value < 1024 || value > 65535) {
+        throw new Error(`${label} must be an integer between 1024 and 65535`);
+    }
+    return value;
+}
+class MihomoManager extends events_1.EventEmitter {
+    options;
+    db;
+    api;
+    paths;
+    child = null;
+    elevatedPid = null;
+    operation = Promise.resolve();
+    constructor(options) {
+        super();
+        this.options = options;
+        this.paths = pathsFromOptions(options);
+        (0, fs_1.mkdirSync)(this.paths.profiles, { recursive: true });
+        (0, fs_1.mkdirSync)(this.paths.runtime, { recursive: true });
+        (0, fs_1.mkdirSync)((0, path_1.join)(this.paths.root, 'bin'), { recursive: true });
+        this.db = new TunnelDatabase_1.TunnelDatabase(this.paths.db, {
+            admin: options.adminPort,
+            controller: options.controllerPort,
+            mixed: options.mixedPort,
+            dns: options.dnsPort
+        });
+        this.api = new MihomoApi_1.MihomoApi(() => this.db.getSettings());
+    }
+    status() {
+        const settings = this.db.getSettings();
+        const corePath = settings.corePath ?? ((0, fs_1.existsSync)(this.paths.core) ? this.paths.core : null);
+        const running = this.isRunning();
+        return {
+            running,
+            pid: running ? this.child?.pid ?? this.elevatedPid : null,
+            mode: settings.mode,
+            tunInstalled: settings.tunInstalled,
+            ports: settings.ports,
+            activeSubscription: this.db.getActiveSubscription(),
+            corePath,
+            adminUrl: `http://127.0.0.1:${settings.ports.admin}`,
+            controllerUrl: `http://127.0.0.1:${settings.ports.controller}`
+        };
+    }
+    async snapshot() {
+        return {
+            status: this.status(),
+            subscriptions: this.listSubscriptions(),
+            rules: this.listRules(),
+            events: this.listEvents(),
+            traffic: await this.trafficSummary()
+        };
+    }
+    async trafficSummary() {
+        if (!this.isRunning()) {
+            return {
+                available: false,
+                connections: 0,
+                uploadTotal: 0,
+                downloadTotal: 0
+            };
+        }
+        try {
+            const response = await this.api.connections();
+            const data = response.data;
+            return {
+                available: response.ok,
+                connections: Array.isArray(data?.connections) ? data.connections.length : 0,
+                uploadTotal: Number(data?.uploadTotal ?? 0),
+                downloadTotal: Number(data?.downloadTotal ?? 0)
+            };
+        }
+        catch {
+            return {
+                available: false,
+                connections: 0,
+                uploadTotal: 0,
+                downloadTotal: 0
+            };
+        }
+    }
+    listSubscriptions() {
+        return this.db.listSubscriptions();
+    }
+    listRules() {
+        return this.db.listRules();
+    }
+    listEvents() {
+        return this.db.listEvents();
+    }
+    async createSubscription(input) {
+        const normalized = normalizeSubscriptionInput(input);
+        const content = await this.fetchSubscriptionContent(normalized);
+        const subscription = this.db.createSubscription(normalized);
+        try {
+            const localPath = this.localSubscriptionPath(subscription.id);
+            (0, fs_1.writeFileSync)(localPath, content, 'utf8');
+            const updated = this.db.updateSubscriptionContent(subscription.id, content, localPath);
+            this.log('info', `Subscription created: ${updated.name}`);
+            return updated;
+        }
+        catch (error) {
+            this.db.deleteSubscription(subscription.id);
+            throw error;
+        }
+    }
+    localSubscriptionPath(id) {
+        return (0, path_1.join)(this.paths.profiles, `subscription-${id}.yaml`);
+    }
+    async fetchSubscriptionContent(subscription) {
+        const headers = {};
+        if (subscription.username || subscription.password) {
+            headers.Authorization = basicAuthHeader(subscription.username ?? '', subscription.password ?? '');
+        }
+        this.log('info', `Fetching subscription: ${subscription.url}`);
+        const response = await fetch(subscription.url, { headers });
+        if (!response.ok) {
+            throw new Error(`subscription update failed: HTTP ${response.status}`);
+        }
+        const content = await response.text();
+        if (!content.trim()) {
+            throw new Error('subscription update failed: empty body');
+        }
+        validateSubscriptionYaml(content);
+        return content;
+    }
+    deleteSubscription(id) {
+        this.db.deleteSubscription(id);
+        this.log('info', `Subscription deleted: ${id}`);
+    }
+    setActiveSubscription(id) {
+        const subscription = this.db.setActiveSubscription(id);
+        this.log('info', `Active subscription switched: ${subscription.name}`);
+        return subscription;
+    }
+    setMode(mode) {
+        const current = this.db.getSettings().mode;
+        if (current === mode) {
+            return false;
+        }
+        this.db.updateSettings({ mode });
+        this.log('info', `Runtime mode switched: ${mode}`);
+        return true;
+    }
+    async setLocalPorts(ports) {
+        const mixed = ports.mixed === undefined ? undefined : normalizePort(ports.mixed, 'mixed port');
+        const dns = ports.dns === undefined ? undefined : normalizePort(ports.dns, 'dns port');
+        const before = this.db.getSettings().ports;
+        const after = this.db.updatePorts({ mixed, dns }).ports;
+        this.log('info', `Local ports updated: mixed ${before.mixed}->${after.mixed}, dns ${before.dns}->${after.dns}`);
+        await this.applyRuntimeConfigChange();
+    }
+    installTunFeature() {
+        this.db.updateSettings({ tunInstalled: true });
+        this.log('info', 'TUN feature enabled for generated runtime config');
+    }
+    uninstallTunFeature() {
+        const settings = this.db.getSettings();
+        this.db.updateSettings({
+            tunInstalled: false,
+            mode: settings.mode === 'system-tun' ? 'app-rule' : settings.mode
+        });
+        this.log('info', 'TUN feature disabled for generated runtime config');
+    }
+    installCoreFromPath(sourcePath) {
+        if (!(0, fs_1.existsSync)(sourcePath)) {
+            throw new Error(`Tunnel engine not found: ${sourcePath}`);
+        }
+        const target = (0, path_1.join)(this.paths.root, 'bin', (0, path_1.basename)(sourcePath));
+        (0, fs_1.copyFileSync)(sourcePath, target);
+        this.db.updateSettings({ corePath: target });
+        this.log('info', `Mihomo core installed: ${target}`);
+        return target;
+    }
+    setCorePath(corePath) {
+        const normalized = corePath.trim() || null;
+        this.db.updateSettings({ corePath: normalized });
+        this.log('info', `Mihomo core path set: ${normalized ?? 'bundled/default'}`);
+    }
+    async updateSubscription(id) {
+        const subscription = this.db.getSubscription(id);
+        if (!subscription) {
+            throw new Error(`subscription not found: ${id}`);
+        }
+        const content = await this.fetchSubscriptionContent(subscription);
+        const localPath = this.localSubscriptionPath(subscription.id);
+        (0, fs_1.writeFileSync)(localPath, content, 'utf8');
+        const updated = this.db.updateSubscriptionContent(subscription.id, content, localPath);
+        this.log('info', `Subscription updated: ${subscription.name}`);
+        return updated;
+    }
+    async updateActiveSubscription() {
+        const active = this.db.getActiveSubscription();
+        if (!active) {
+            throw new Error('no active subscription configured');
+        }
+        return this.updateSubscription(active.id);
+    }
+    addDomainRule(kind, domain, source = 'manual') {
+        const rule = this.db.upsertRule(kind, domain, source);
+        this.log('info', `Domain rule saved: ${kind} ${rule.domain}`);
+        return rule;
+    }
+    addPreset(preset) {
+        const domains = defaults_1.DOMAIN_PRESETS[preset];
+        const rules = domains.map((domain) => this.db.upsertRule('allow', domain, `preset:${preset}`));
+        this.log('info', `Preset allowlist added: ${preset}`);
+        return rules;
+    }
+    removeDomainRule(id) {
+        this.db.removeRule(id);
+        this.log('info', `Domain rule removed: ${id}`);
+    }
+    renderConfig() {
+        const settings = this.db.getSettings();
+        const active = this.db.getActiveSubscription();
+        if (!active?.content) {
+            throw new Error('active subscription has no downloaded content');
+        }
+        const rendered = (0, renderRuntimeConfig_1.renderRuntimeConfig)({
+            baseYaml: active.content,
+            settings,
+            rules: this.db.listRules()
+        });
+        (0, fs_1.writeFileSync)(this.paths.config, rendered.yaml, 'utf8');
+        this.log('info', `Runtime config rendered with policy ${rendered.proxyPolicyName}`);
+        return this.paths.config;
+    }
+    runExclusive(task) {
+        const next = this.operation.then(task, task);
+        this.operation = next.catch(() => undefined);
+        return next;
+    }
+    async start() {
+        await this.runExclusive(() => this.startUnlocked());
+    }
+    async startUnlocked() {
+        if (this.isRunning()) {
+            return;
+        }
+        const settings = this.db.getSettings();
+        const corePath = this.resolveCorePath();
+        if (!(0, fs_1.existsSync)(corePath)) {
+            throw new Error(`Tunnel engine is not installed: ${corePath}. Package the QPJoy tunnel engine resources with your Electron app.`);
+        }
+        const configPath = this.renderConfig();
+        if (needsElevatedTun(settings)) {
+            await this.startElevated(corePath, configPath);
+            return;
+        }
+        this.child = (0, child_process_1.spawn)(corePath, ['-d', this.paths.runtime, '-f', configPath], {
+            cwd: this.paths.runtime,
+            env: {
+                ...process.env,
+                NO_COLOR: '1'
+            }
+        });
+        this.child.stdout.on('data', (chunk) => this.log('info', chunk.toString().trim()));
+        this.child.stderr.on('data', (chunk) => this.log('warn', chunk.toString().trim()));
+        this.child.on('exit', (code, signal) => {
+            this.log(code === 0 ? 'info' : 'warn', `Mihomo exited code=${code ?? 'null'} signal=${signal ?? 'null'}`);
+            this.child = null;
+        });
+        this.log('info', `Mihomo started pid=${this.child.pid ?? 'unknown'}`);
+    }
+    resolveCorePath() {
+        const settings = this.db.getSettings();
+        if (settings.corePath && (0, fs_1.existsSync)(settings.corePath)) {
+            return settings.corePath;
+        }
+        if ((0, fs_1.existsSync)(this.paths.core)) {
+            return this.paths.core;
+        }
+        const bundled = this.findBundledCore();
+        if (bundled) {
+            this.installBundledCore(bundled);
+            return this.paths.core;
+        }
+        return settings.corePath || this.paths.core;
+    }
+    findBundledCore() {
+        const bundledEngineDir = this.options.bundledEngineDir ?? this.options.bundledCoreDir;
+        if (!bundledEngineDir) {
+            return null;
+        }
+        const key = platformArchKey();
+        const aliases = key.endsWith('-x64') ? [key, key.replace('-x64', '-amd64')] : [key];
+        const names = ['mihomo', 'mihomo.gz'];
+        const candidates = aliases.flatMap((alias) => names.map((name) => (0, path_1.join)(bundledEngineDir, alias, name)));
+        for (const candidate of candidates) {
+            if ((0, fs_1.existsSync)(candidate)) {
+                return candidate;
+            }
+        }
+        return null;
+    }
+    installBundledCore(sourcePath) {
+        (0, fs_1.mkdirSync)((0, path_1.join)(this.paths.root, 'bin'), { recursive: true });
+        if (sourcePath.endsWith('.gz')) {
+            (0, fs_1.writeFileSync)(this.paths.core, (0, zlib_1.gunzipSync)((0, fs_1.readFileSync)(sourcePath)));
+        }
+        else {
+            (0, fs_1.copyFileSync)(sourcePath, this.paths.core);
+        }
+        (0, fs_1.chmodSync)(this.paths.core, 0o755);
+        this.db.updateSettings({ corePath: this.paths.core });
+        this.log('info', `Bundled Mihomo core installed: ${this.paths.core}`);
+    }
+    runElevatedShell(command) {
+        const launcher = process.platform === 'darwin'
+            ? {
+                command: '/usr/bin/osascript',
+                args: ['-e', `do shell script ${JSON.stringify(command)} with administrator privileges`]
+            }
+            : {
+                command: (0, fs_1.existsSync)('/usr/bin/pkexec') ? '/usr/bin/pkexec' : '/bin/pkexec',
+                args: ['/bin/sh', '-lc', command]
+            };
+        if (!(0, fs_1.existsSync)(launcher.command)) {
+            throw new Error('TUN mode requires administrator privileges, but no supported privilege helper was found.');
+        }
+        return new Promise((resolve, reject) => {
+            const child = (0, child_process_1.spawn)(launcher.command, launcher.args);
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                stdout += chunk.toString();
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on('error', reject);
+            child.on('exit', (code) => {
+                if (code === 0) {
+                    resolve(stdout.trim());
+                    return;
+                }
+                reject(new Error(stderr.trim() || stdout.trim() || 'TUN mode requires administrator approval.'));
+            });
+        });
+    }
+    async startElevated(corePath, configPath) {
+        const logPath = (0, path_1.join)(this.paths.runtime, 'mihomo-elevated.log');
+        const command = [
+            ':',
+            '>',
+            shellQuote(logPath),
+            ';',
+            shellQuote(corePath),
+            '-d',
+            shellQuote(this.paths.runtime),
+            '-f',
+            shellQuote(configPath),
+            '>>',
+            shellQuote(logPath),
+            '2>&1',
+            '&',
+            'echo $!'
+        ].join(' ');
+        const output = await this.runElevatedShell(command);
+        const pid = Number(output.split(/\s+/).at(-1));
+        if (!Number.isInteger(pid) || pid <= 0) {
+            throw new Error(`Failed to start privileged tunnel engine: ${output || 'empty pid'}`);
+        }
+        this.child = null;
+        this.rememberElevatedPid(pid);
+        await delay(900);
+        if (!isProcessAlive(pid)) {
+            this.clearElevatedPid();
+            const details = this.readElevatedLogTail(logPath);
+            throw new Error(`Privileged mihomo exited immediately.${details ? ` ${details}` : ''}`);
+        }
+        this.log('info', `Mihomo started with administrator privileges pid=${pid}`);
+        this.log('info', `Privileged Mihomo log file: ${logPath}`);
+    }
+    readElevatedLogTail(logPath) {
+        try {
+            const lines = (0, fs_1.readFileSync)(logPath, 'utf8')
+                .trim()
+                .split('\n')
+                .slice(-12)
+                .join('\n');
+            return lines ? `Recent log:\n${lines}` : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    elevatedPidPath() {
+        return (0, path_1.join)(this.paths.runtime, 'mihomo-elevated.pid');
+    }
+    readElevatedPid() {
+        if (this.elevatedPid && isProcessAlive(this.elevatedPid)) {
+            return this.elevatedPid;
+        }
+        try {
+            const pid = Number((0, fs_1.readFileSync)(this.elevatedPidPath(), 'utf8').trim());
+            if (Number.isInteger(pid) && pid > 0 && isProcessAlive(pid)) {
+                this.elevatedPid = pid;
+                return pid;
+            }
+        }
+        catch {
+            // Missing or stale pid files are cleaned up by clearElevatedPid().
+        }
+        this.clearElevatedPid();
+        return null;
+    }
+    rememberElevatedPid(pid) {
+        this.elevatedPid = pid;
+        (0, fs_1.writeFileSync)(this.elevatedPidPath(), `${pid}\n`, 'utf8');
+    }
+    clearElevatedPid() {
+        this.elevatedPid = null;
+        try {
+            (0, fs_1.unlinkSync)(this.elevatedPidPath());
+        }
+        catch {
+            // It is fine when the pid file does not exist.
+        }
+    }
+    isRunning() {
+        if (this.child && !this.child.killed) {
+            return true;
+        }
+        if (this.readElevatedPid()) {
+            return true;
+        }
+        return false;
+    }
+    isElevatedRunning() {
+        return Boolean(this.readElevatedPid());
+    }
+    async reloadRuntimeConfig() {
+        const configPath = this.renderConfig();
+        const response = await this.api.reloadConfig(configPath);
+        if (response.ok) {
+            this.log('info', 'Runtime config hot reloaded');
+            return true;
+        }
+        this.log('warn', `Runtime config hot reload failed: HTTP ${response.status}`);
+        return false;
+    }
+    async stop() {
+        await this.runExclusive(() => this.stopUnlocked({ allowElevatedPrompt: true }));
+    }
+    async stopUnlocked(options = {}) {
+        const elevatedPid = this.readElevatedPid();
+        if (elevatedPid) {
+            const pid = elevatedPid;
+            if (!isProcessAlive(pid)) {
+                this.clearElevatedPid();
+                this.log('info', 'Privileged Mihomo was already stopped');
+                return;
+            }
+            if (!options.allowElevatedPrompt) {
+                this.log('info', 'Privileged Mihomo is still running; skipped elevated stop to avoid another administrator prompt');
+                return;
+            }
+            await this.runElevatedShell(`kill ${pid} 2>/dev/null || true`);
+            this.clearElevatedPid();
+            this.log('info', 'Privileged Mihomo stop requested');
+            return;
+        }
+        if (!this.child || this.child.killed) {
+            return;
+        }
+        this.child.kill('SIGTERM');
+        this.log('info', 'Mihomo stop requested');
+    }
+    async restart() {
+        await this.runExclusive(async () => {
+            if (this.isElevatedRunning()) {
+                const reloaded = await this.reloadRuntimeConfig();
+                if (reloaded) {
+                    return;
+                }
+                this.log('warn', 'Privileged Mihomo restart skipped because it would require another administrator prompt');
+                return;
+            }
+            await this.stopUnlocked();
+            await delay(400);
+            await this.startUnlocked();
+        });
+    }
+    async applyRuntimeConfigChange() {
+        await this.runExclusive(async () => {
+            if (!this.isRunning()) {
+                return;
+            }
+            const settings = this.db.getSettings();
+            if (needsElevatedTun(settings) && !this.isElevatedRunning()) {
+                await this.stopUnlocked();
+                await delay(400);
+                await this.startUnlocked();
+                return;
+            }
+            const reloaded = await this.reloadRuntimeConfig();
+            if (!reloaded && !this.isElevatedRunning()) {
+                await this.stopUnlocked();
+                await delay(400);
+                await this.startUnlocked();
+            }
+        });
+    }
+    async handleNetworkChanged(reason) {
+        this.log('info', `Network change detected: ${reason}`);
+        if (!this.isRunning()) {
+            return;
+        }
+        await this.applyRuntimeConfigChange();
+    }
+    close() {
+        if (this.child && !this.child.killed) {
+            this.child.kill('SIGTERM');
+            this.child = null;
+        }
+        this.db.close();
+    }
+    log(level, message) {
+        const clean = message.trim();
+        if (!clean) {
+            return;
+        }
+        this.db.addEvent(level, clean);
+        this.emit('event', { level, message: clean });
+    }
+}
+exports.MihomoManager = MihomoManager;

package/dist/security.d.ts

@@ -0,0 +1,3 @@
+export declare function hashPassword(password: string): string;
+export declare function verifyPassword(password: string, storedHash: string): boolean;
+export declare function createSessionToken(): string;

package/dist/security.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashPassword = hashPassword;
+exports.verifyPassword = verifyPassword;
+exports.createSessionToken = createSessionToken;
+const crypto_1 = require("crypto");
+const KEY_LENGTH = 32;
+function hashPassword(password) {
+    const salt = (0, crypto_1.randomBytes)(16).toString('hex');
+    const hash = (0, crypto_1.scryptSync)(password, salt, KEY_LENGTH).toString('hex');
+    return `scrypt:${salt}:${hash}`;
+}
+function verifyPassword(password, storedHash) {
+    const [method, salt, hash] = storedHash.split(':');
+    if (method !== 'scrypt' || !salt || !hash) {
+        return false;
+    }
+    const expected = Buffer.from(hash, 'hex');
+    const actual = (0, crypto_1.scryptSync)(password, salt, KEY_LENGTH);
+    return expected.length === actual.length && (0, crypto_1.timingSafeEqual)(expected, actual);
+}
+function createSessionToken() {
+    return (0, crypto_1.randomBytes)(32).toString('hex');
+}

package/dist/system/electronProxy.d.ts

@@ -0,0 +1,4 @@
+import type { Session } from 'electron';
+import type { RuntimeMode, TunnelPorts } from '../types';
+export declare function applyElectronProxy(session: Session, mode: RuntimeMode, ports: TunnelPorts): Promise<void>;
+export declare function proxyEnv(ports: TunnelPorts): NodeJS.ProcessEnv;

package/dist/system/electronProxy.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyElectronProxy = applyElectronProxy;
+exports.proxyEnv = proxyEnv;
+async function applyElectronProxy(session, mode, ports) {
+    if (mode === 'system-tun') {
+        await session.setProxy({ mode: 'direct' });
+        return;
+    }
+    const proxyRules = [
+        `http=127.0.0.1:${ports.mixed}`,
+        `https=127.0.0.1:${ports.mixed}`,
+        `socks5=127.0.0.1:${ports.mixed}`
+    ].join(';');
+    await session.setProxy({
+        mode: 'fixed_servers',
+        proxyRules,
+        proxyBypassRules: '<local>;localhost;127.0.0.1;::1'
+    });
+}
+function proxyEnv(ports) {
+    return {
+        http_proxy: `http://127.0.0.1:${ports.mixed}`,
+        https_proxy: `http://127.0.0.1:${ports.mixed}`,
+        HTTP_PROXY: `http://127.0.0.1:${ports.mixed}`,
+        HTTPS_PROXY: `http://127.0.0.1:${ports.mixed}`,
+        all_proxy: `socks5h://127.0.0.1:${ports.mixed}`,
+        ALL_PROXY: `socks5h://127.0.0.1:${ports.mixed}`
+    };
+}