@qpjoy/electron-tunnel 0.1.0

package/dist/createElectronTunnel.d.ts

@@ -0,0 +1,21 @@
+import type { App, IpcMain, Session } from 'electron';
+import { AdminServer } from './admin/AdminServer';
+import { MihomoManager } from './mihomo/MihomoManager';
+import type { TunnelManagerOptions, TunnelStatus } from './types';
+export interface CreateElectronTunnelHost {
+    app: App;
+    ipcMain: IpcMain;
+    session: Session;
+}
+export interface CreateElectronTunnelOptions extends Partial<Omit<TunnelManagerOptions, 'userDataPath'>> {
+    userDataPath?: string;
+    startAdminServer?: boolean;
+}
+export interface ElectronTunnelHandle {
+    manager: MihomoManager;
+    admin: AdminServer;
+    applyProxy: () => Promise<void>;
+    status: () => TunnelStatus;
+    close: () => void;
+}
+export declare function createElectronTunnel(host: CreateElectronTunnelHost, options?: CreateElectronTunnelOptions): ElectronTunnelHandle;

package/dist/createElectronTunnel.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createElectronTunnel = createElectronTunnel;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const AdminServer_1 = require("./admin/AdminServer");
+const registerTunnelIpc_1 = require("./ipc/registerTunnelIpc");
+const MihomoManager_1 = require("./mihomo/MihomoManager");
+const electronProxy_1 = require("./system/electronProxy");
+function defaultBundledEngineDir() {
+    const resourcesPath = process.resourcesPath ?? process.cwd();
+    const packageDir = typeof __dirname === 'undefined' ? process.cwd() : __dirname;
+    const candidates = [
+        (0, path_1.join)(resourcesPath, 'qpjoy-tunnel-engine'),
+        (0, path_1.join)(resourcesPath, 'mihomo'),
+        (0, path_1.resolve)(packageDir, '../resources/engine'),
+        (0, path_1.resolve)(process.cwd(), 'resources/qpjoy-tunnel-engine'),
+        (0, path_1.resolve)(process.cwd(), 'resources/mihomo')
+    ];
+    return candidates.find((candidate) => (0, fs_1.existsSync)(candidate)) ?? candidates[0];
+}
+function createElectronTunnel(host, options = {}) {
+    const manager = new MihomoManager_1.MihomoManager({
+        ...options,
+        userDataPath: options.userDataPath ?? host.app.getPath('userData'),
+        bundledEngineDir: options.bundledEngineDir ?? defaultBundledEngineDir()
+    });
+    const admin = new AdminServer_1.AdminServer(manager);
+    async function applyProxy() {
+        const status = manager.status();
+        await (0, electronProxy_1.applyElectronProxy)(host.session, status.mode, status.ports);
+    }
+    if (options.startAdminServer !== false) {
+        admin.start();
+    }
+    (0, registerTunnelIpc_1.registerTunnelIpc)(host.ipcMain, manager, {
+        afterSettingsChange: applyProxy
+    });
+    return {
+        manager,
+        admin,
+        applyProxy,
+        status: () => manager.status(),
+        close: () => {
+            admin.stop();
+            manager.close();
+        }
+    };
+}

package/dist/db/TunnelDatabase.d.ts

@@ -0,0 +1,23 @@
+import type { DomainRule, DomainRuleKind, EventRecord, RuntimeSettings, SubscriptionInput, SubscriptionRecord, TunnelPorts } from '../types';
+export declare class TunnelDatabase {
+    private readonly db;
+    constructor(dbPath: string, ports?: Partial<TunnelPorts>);
+    close(): void;
+    getSettings(): RuntimeSettings;
+    updateSettings(patch: Partial<Pick<RuntimeSettings, 'mode' | 'corePath' | 'tunInstalled' | 'activeSubscriptionId'>>): RuntimeSettings;
+    updatePorts(patch: Partial<Pick<TunnelPorts, 'mixed' | 'dns'>>): RuntimeSettings;
+    updateAdminPassword(username: string, password: string): RuntimeSettings;
+    listSubscriptions(): SubscriptionRecord[];
+    getSubscription(id: number): SubscriptionRecord | null;
+    getActiveSubscription(): SubscriptionRecord | null;
+    createSubscription(input: SubscriptionInput): SubscriptionRecord;
+    deleteSubscription(id: number): void;
+    setActiveSubscription(id: number): SubscriptionRecord;
+    updateSubscriptionContent(id: number, content: string, localPath: string): SubscriptionRecord;
+    listRules(): DomainRule[];
+    upsertRule(kind: DomainRuleKind, domain: string, source?: string): DomainRule;
+    removeRule(id: number): void;
+    addEvent(level: EventRecord['level'], message: string): void;
+    listEvents(limit?: number): EventRecord[];
+    private ensureDefaultSettings;
+}

package/dist/db/TunnelDatabase.js

@@ -0,0 +1,296 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TunnelDatabase = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const defaults_1 = require("../defaults");
+const security_1 = require("../security");
+const schema_1 = require("./schema");
+function nowIso() {
+    return new Date().toISOString();
+}
+function toBool(value) {
+    return Number(value) === 1;
+}
+function mergePorts(ports) {
+    return {
+        admin: ports.admin ?? defaults_1.DEFAULT_PORTS.admin,
+        controller: ports.controller ?? defaults_1.DEFAULT_PORTS.controller,
+        mixed: ports.mixed ?? defaults_1.DEFAULT_PORTS.mixed,
+        dns: ports.dns ?? defaults_1.DEFAULT_PORTS.dns
+    };
+}
+function mapSettings(row) {
+    return {
+        id: Number(row.id),
+        mode: String(row.mode),
+        ports: {
+            admin: Number(row.admin_port),
+            controller: Number(row.controller_port),
+            mixed: Number(row.mixed_port),
+            dns: Number(row.dns_port)
+        },
+        adminUser: String(row.admin_user),
+        adminPasswordHash: String(row.admin_password_hash),
+        controllerSecret: String(row.controller_secret),
+        corePath: row.core_path ? String(row.core_path) : null,
+        tunInstalled: toBool(row.tun_installed),
+        activeSubscriptionId: row.active_subscription_id ? Number(row.active_subscription_id) : null,
+        updatedAt: String(row.updated_at)
+    };
+}
+function mapSubscription(row) {
+    return {
+        id: Number(row.id),
+        name: String(row.name),
+        url: String(row.url),
+        username: String(row.username ?? ''),
+        password: String(row.password ?? ''),
+        localPath: row.local_path ? String(row.local_path) : null,
+        content: row.content ? String(row.content) : null,
+        active: toBool(row.active),
+        lastUpdatedAt: row.last_updated_at ? String(row.last_updated_at) : null,
+        createdAt: String(row.created_at),
+        updatedAt: String(row.updated_at)
+    };
+}
+function mapRule(row) {
+    return {
+        id: Number(row.id),
+        kind: String(row.kind),
+        domain: String(row.domain),
+        source: String(row.source),
+        enabled: toBool(row.enabled),
+        createdAt: String(row.created_at)
+    };
+}
+class TunnelDatabase {
+    db;
+    constructor(dbPath, ports = {}) {
+        (0, fs_1.mkdirSync)((0, path_1.dirname)(dbPath), { recursive: true });
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.db.exec(schema_1.SCHEMA_SQL);
+        this.ensureDefaultSettings(mergePorts(ports));
+    }
+    close() {
+        this.db.close();
+    }
+    getSettings() {
+        const row = this.db.prepare('SELECT * FROM runtime_settings WHERE id = 1').get();
+        if (!row) {
+            throw new Error('runtime settings row is missing');
+        }
+        return mapSettings(row);
+    }
+    updateSettings(patch) {
+        const current = this.getSettings();
+        const next = {
+            mode: patch.mode ?? current.mode,
+            corePath: patch.corePath === undefined ? current.corePath : patch.corePath,
+            tunInstalled: patch.tunInstalled === undefined ? current.tunInstalled : patch.tunInstalled,
+            activeSubscriptionId: patch.activeSubscriptionId === undefined ? current.activeSubscriptionId : patch.activeSubscriptionId,
+            updatedAt: nowIso()
+        };
+        this.db.prepare(`
+      UPDATE runtime_settings
+      SET mode = @mode,
+          core_path = @corePath,
+          tun_installed = @tunInstalled,
+          active_subscription_id = @activeSubscriptionId,
+          updated_at = @updatedAt
+      WHERE id = 1
+    `).run({
+            ...next,
+            tunInstalled: next.tunInstalled ? 1 : 0
+        });
+        return this.getSettings();
+    }
+    updatePorts(patch) {
+        const current = this.getSettings();
+        const mixedPort = patch.mixed ?? current.ports.mixed;
+        const dnsPort = patch.dns ?? current.ports.dns;
+        this.db.prepare(`
+      UPDATE runtime_settings
+      SET mixed_port = @mixedPort,
+          dns_port = @dnsPort,
+          updated_at = @updatedAt
+      WHERE id = 1
+    `).run({
+            mixedPort,
+            dnsPort,
+            updatedAt: nowIso()
+        });
+        return this.getSettings();
+    }
+    updateAdminPassword(username, password) {
+        this.db.prepare(`
+      UPDATE runtime_settings
+      SET admin_user = @username,
+          admin_password_hash = @passwordHash,
+          updated_at = @updatedAt
+      WHERE id = 1
+    `).run({
+            username,
+            passwordHash: (0, security_1.hashPassword)(password),
+            updatedAt: nowIso()
+        });
+        return this.getSettings();
+    }
+    listSubscriptions() {
+        const rows = this.db.prepare('SELECT * FROM subscriptions ORDER BY active DESC, updated_at DESC').all();
+        return rows.map(mapSubscription);
+    }
+    getSubscription(id) {
+        const row = this.db.prepare('SELECT * FROM subscriptions WHERE id = ?').get(id);
+        return row ? mapSubscription(row) : null;
+    }
+    getActiveSubscription() {
+        const row = this.db.prepare('SELECT * FROM subscriptions WHERE active = 1 ORDER BY updated_at DESC LIMIT 1').get();
+        return row ? mapSubscription(row) : null;
+    }
+    createSubscription(input) {
+        const stamp = nowIso();
+        const result = this.db.prepare(`
+      INSERT INTO subscriptions (name, url, username, password, created_at, updated_at)
+      VALUES (@name, @url, @username, @password, @createdAt, @updatedAt)
+    `).run({
+            name: input.name,
+            url: input.url,
+            username: input.username ?? '',
+            password: input.password ?? '',
+            createdAt: stamp,
+            updatedAt: stamp
+        });
+        const created = this.getSubscription(Number(result.lastInsertRowid));
+        if (!created) {
+            throw new Error('failed to create subscription');
+        }
+        if (this.listSubscriptions().length === 1) {
+            this.setActiveSubscription(created.id);
+        }
+        return this.getSubscription(created.id) ?? created;
+    }
+    deleteSubscription(id) {
+        this.db.prepare('DELETE FROM subscriptions WHERE id = ?').run(id);
+        const active = this.getActiveSubscription();
+        if (!active) {
+            this.updateSettings({ activeSubscriptionId: null });
+        }
+    }
+    setActiveSubscription(id) {
+        const subscription = this.getSubscription(id);
+        if (!subscription) {
+            throw new Error(`subscription not found: ${id}`);
+        }
+        const tx = this.db.transaction(() => {
+            this.db.prepare('UPDATE subscriptions SET active = 0').run();
+            this.db.prepare('UPDATE subscriptions SET active = 1, updated_at = ? WHERE id = ?').run(nowIso(), id);
+            this.updateSettings({ activeSubscriptionId: id });
+        });
+        tx();
+        const active = this.getSubscription(id);
+        if (!active) {
+            throw new Error(`subscription not found after activation: ${id}`);
+        }
+        return active;
+    }
+    updateSubscriptionContent(id, content, localPath) {
+        this.db.prepare(`
+      UPDATE subscriptions
+      SET content = @content,
+          local_path = @localPath,
+          last_updated_at = @lastUpdatedAt,
+          updated_at = @updatedAt
+      WHERE id = @id
+    `).run({
+            id,
+            content,
+            localPath,
+            lastUpdatedAt: nowIso(),
+            updatedAt: nowIso()
+        });
+        const subscription = this.getSubscription(id);
+        if (!subscription) {
+            throw new Error(`subscription not found: ${id}`);
+        }
+        return subscription;
+    }
+    listRules() {
+        const rows = this.db.prepare('SELECT * FROM domain_rules ORDER BY kind ASC, source ASC, domain ASC').all();
+        return rows.map(mapRule);
+    }
+    upsertRule(kind, domain, source = 'manual') {
+        const normalized = domain.trim().toLowerCase().replace(/^\.+/, '');
+        if (!normalized) {
+            throw new Error('domain is required');
+        }
+        const createdAt = nowIso();
+        this.db.prepare(`
+      INSERT INTO domain_rules (kind, domain, source, enabled, created_at)
+      VALUES (@kind, @domain, @source, 1, @createdAt)
+      ON CONFLICT(kind, domain) DO UPDATE SET
+        source = excluded.source,
+        enabled = 1
+    `).run({ kind, domain: normalized, source, createdAt });
+        const row = this.db.prepare('SELECT * FROM domain_rules WHERE kind = ? AND domain = ?').get(kind, normalized);
+        if (!row) {
+            throw new Error(`failed to upsert rule: ${normalized}`);
+        }
+        return mapRule(row);
+    }
+    removeRule(id) {
+        this.db.prepare('DELETE FROM domain_rules WHERE id = ?').run(id);
+    }
+    addEvent(level, message) {
+        this.db.prepare(`
+      INSERT INTO events (level, message, created_at)
+      VALUES (?, ?, ?)
+    `).run(level, message, nowIso());
+    }
+    listEvents(limit = 200) {
+        const rows = this.db.prepare(`
+      SELECT * FROM events
+      ORDER BY id DESC
+      LIMIT ?
+    `).all(limit);
+        return rows.map((row) => ({
+            id: Number(row.id),
+            level: String(row.level),
+            message: String(row.message),
+            createdAt: String(row.created_at)
+        }));
+    }
+    ensureDefaultSettings(ports) {
+        const row = this.db.prepare('SELECT id FROM runtime_settings WHERE id = 1').get();
+        if (row) {
+            return;
+        }
+        this.db.prepare(`
+      INSERT INTO runtime_settings (
+        id, mode, admin_port, controller_port, mixed_port, dns_port,
+        admin_user, admin_password_hash, controller_secret, tun_installed,
+        updated_at
+      )
+      VALUES (
+        1, @mode, @adminPort, @controllerPort, @mixedPort, @dnsPort,
+        @adminUser, @adminPasswordHash, @controllerSecret, 0,
+        @updatedAt
+      )
+    `).run({
+            mode: defaults_1.DEFAULT_MODE,
+            adminPort: ports.admin,
+            controllerPort: ports.controller,
+            mixedPort: ports.mixed,
+            dnsPort: ports.dns,
+            adminUser: defaults_1.DEFAULT_ADMIN_USER,
+            adminPasswordHash: (0, security_1.hashPassword)(defaults_1.DEFAULT_ADMIN_PASSWORD),
+            controllerSecret: (0, defaults_1.createControllerSecret)(),
+            updatedAt: nowIso()
+        });
+    }
+}
+exports.TunnelDatabase = TunnelDatabase;

package/dist/db/schema.d.ts

@@ -0,0 +1 @@
+export declare const SCHEMA_SQL = "\nPRAGMA journal_mode = WAL;\n\nCREATE TABLE IF NOT EXISTS runtime_settings (\n  id INTEGER PRIMARY KEY CHECK (id = 1),\n  mode TEXT NOT NULL,\n  admin_port INTEGER NOT NULL,\n  controller_port INTEGER NOT NULL,\n  mixed_port INTEGER NOT NULL,\n  dns_port INTEGER NOT NULL,\n  admin_user TEXT NOT NULL,\n  admin_password_hash TEXT NOT NULL,\n  controller_secret TEXT NOT NULL,\n  core_path TEXT,\n  tun_installed INTEGER NOT NULL DEFAULT 0,\n  active_subscription_id INTEGER,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS subscriptions (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  name TEXT NOT NULL,\n  url TEXT NOT NULL,\n  username TEXT NOT NULL DEFAULT '',\n  password TEXT NOT NULL DEFAULT '',\n  local_path TEXT,\n  content TEXT,\n  active INTEGER NOT NULL DEFAULT 0,\n  last_updated_at TEXT,\n  created_at TEXT NOT NULL,\n  updated_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS domain_rules (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  kind TEXT NOT NULL CHECK (kind IN ('allow', 'block')),\n  domain TEXT NOT NULL,\n  source TEXT NOT NULL DEFAULT 'manual',\n  enabled INTEGER NOT NULL DEFAULT 1,\n  created_at TEXT NOT NULL,\n  UNIQUE(kind, domain)\n);\n\nCREATE TABLE IF NOT EXISTS core_versions (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  version TEXT NOT NULL,\n  platform TEXT NOT NULL,\n  arch TEXT NOT NULL,\n  path TEXT NOT NULL,\n  active INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS traffic_snapshots (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  upload_bytes INTEGER NOT NULL DEFAULT 0,\n  download_bytes INTEGER NOT NULL DEFAULT 0,\n  created_at TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS events (\n  id INTEGER PRIMARY KEY AUTOINCREMENT,\n  level TEXT NOT NULL CHECK (level IN ('info', 'warn', 'error')),\n  message TEXT NOT NULL,\n  created_at TEXT NOT NULL\n);\n";

package/dist/db/schema.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCHEMA_SQL = void 0;
+exports.SCHEMA_SQL = `
+PRAGMA journal_mode = WAL;
+
+CREATE TABLE IF NOT EXISTS runtime_settings (
+  id INTEGER PRIMARY KEY CHECK (id = 1),
+  mode TEXT NOT NULL,
+  admin_port INTEGER NOT NULL,
+  controller_port INTEGER NOT NULL,
+  mixed_port INTEGER NOT NULL,
+  dns_port INTEGER NOT NULL,
+  admin_user TEXT NOT NULL,
+  admin_password_hash TEXT NOT NULL,
+  controller_secret TEXT NOT NULL,
+  core_path TEXT,
+  tun_installed INTEGER NOT NULL DEFAULT 0,
+  active_subscription_id INTEGER,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS subscriptions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL,
+  url TEXT NOT NULL,
+  username TEXT NOT NULL DEFAULT '',
+  password TEXT NOT NULL DEFAULT '',
+  local_path TEXT,
+  content TEXT,
+  active INTEGER NOT NULL DEFAULT 0,
+  last_updated_at TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS domain_rules (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  kind TEXT NOT NULL CHECK (kind IN ('allow', 'block')),
+  domain TEXT NOT NULL,
+  source TEXT NOT NULL DEFAULT 'manual',
+  enabled INTEGER NOT NULL DEFAULT 1,
+  created_at TEXT NOT NULL,
+  UNIQUE(kind, domain)
+);
+
+CREATE TABLE IF NOT EXISTS core_versions (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  version TEXT NOT NULL,
+  platform TEXT NOT NULL,
+  arch TEXT NOT NULL,
+  path TEXT NOT NULL,
+  active INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS traffic_snapshots (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  upload_bytes INTEGER NOT NULL DEFAULT 0,
+  download_bytes INTEGER NOT NULL DEFAULT 0,
+  created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  level TEXT NOT NULL CHECK (level IN ('info', 'warn', 'error')),
+  message TEXT NOT NULL,
+  created_at TEXT NOT NULL
+);
+`;

package/dist/defaults.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeMode, TunnelPorts } from './types';
+export declare const DEFAULT_PORTS: TunnelPorts;
+export declare const DEFAULT_MODE: RuntimeMode;
+export declare const DEFAULT_ADMIN_USER = "admin";
+export declare const DEFAULT_ADMIN_PASSWORD = "admin";
+export declare function createControllerSecret(): string;
+export declare const GEOX_URL: {
+    geoip: string;
+    geosite: string;
+    mmdb: string;
+};
+export declare const DOMAIN_PRESETS: {
+    readonly google: readonly ["google.com", "googleapis.com", "gstatic.com", "googleusercontent.com", "googlevideo.com", "ggpht.com", "gmail.com", "googlemail.com", "google-analytics.com", "googletagmanager.com", "googlesyndication.com", "doubleclick.net", "blogger.com", "chrome.com", "chromium.org"];
+    readonly youtube: readonly ["youtube.com", "youtu.be", "ytimg.com", "youtubei.googleapis.com", "youtube-nocookie.com", "googlevideo.com", "yt3.ggpht.com"];
+    readonly x: readonly ["x.com", "twitter.com", "t.co", "twimg.com", "tweetdeck.com", "ads-twitter.com", "pscp.tv", "periscope.tv"];
+    readonly telegram: readonly ["telegram.org", "telegram.me", "t.me", "tdesktop.com", "telegra.ph", "tdlib.org"];
+};
+export type DomainPresetId = keyof typeof DOMAIN_PRESETS;

package/dist/defaults.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_PRESETS = exports.GEOX_URL = exports.DEFAULT_ADMIN_PASSWORD = exports.DEFAULT_ADMIN_USER = exports.DEFAULT_MODE = exports.DEFAULT_PORTS = void 0;
+exports.createControllerSecret = createControllerSecret;
+const crypto_1 = require("crypto");
+exports.DEFAULT_PORTS = {
+    admin: 23456,
+    controller: 23457,
+    mixed: 23458,
+    dns: 23459
+};
+exports.DEFAULT_MODE = 'app-rule';
+exports.DEFAULT_ADMIN_USER = 'admin';
+exports.DEFAULT_ADMIN_PASSWORD = 'admin';
+function createControllerSecret() {
+    return (0, crypto_1.randomBytes)(24).toString('hex');
+}
+exports.GEOX_URL = {
+    geoip: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geoip.dat',
+    geosite: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/geosite.dat',
+    mmdb: 'https://testingcf.jsdelivr.net/gh/MetaCubeX/meta-rules-dat@release/country.mmdb'
+};
+exports.DOMAIN_PRESETS = {
+    google: [
+        'google.com',
+        'googleapis.com',
+        'gstatic.com',
+        'googleusercontent.com',
+        'googlevideo.com',
+        'ggpht.com',
+        'gmail.com',
+        'googlemail.com',
+        'google-analytics.com',
+        'googletagmanager.com',
+        'googlesyndication.com',
+        'doubleclick.net',
+        'blogger.com',
+        'chrome.com',
+        'chromium.org'
+    ],
+    youtube: [
+        'youtube.com',
+        'youtu.be',
+        'ytimg.com',
+        'youtubei.googleapis.com',
+        'youtube-nocookie.com',
+        'googlevideo.com',
+        'yt3.ggpht.com'
+    ],
+    x: [
+        'x.com',
+        'twitter.com',
+        't.co',
+        'twimg.com',
+        'tweetdeck.com',
+        'ads-twitter.com',
+        'pscp.tv',
+        'periscope.tv'
+    ],
+    telegram: [
+        'telegram.org',
+        'telegram.me',
+        't.me',
+        'tdesktop.com',
+        'telegra.ph',
+        'tdlib.org'
+    ]
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { AdminServer } from './admin/AdminServer';
+export { createElectronTunnel } from './createElectronTunnel';
+export { renderRuntimeConfig } from './config/renderRuntimeConfig';
+export { TunnelDatabase } from './db/TunnelDatabase';
+export { registerTunnelIpc } from './ipc/registerTunnelIpc';
+export { MihomoApi, MihomoApi as TunnelApi } from './mihomo/MihomoApi';
+export { MihomoManager, MihomoManager as TunnelManager } from './mihomo/MihomoManager';
+export { applyElectronProxy, proxyEnv } from './system/electronProxy';
+export { DEFAULT_PORTS, DOMAIN_PRESETS } from './defaults';
+export type { CreateElectronTunnelHost, CreateElectronTunnelOptions, ElectronTunnelHandle } from './createElectronTunnel';
+export type * from './types';

package/dist/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_PRESETS = exports.DEFAULT_PORTS = exports.proxyEnv = exports.applyElectronProxy = exports.TunnelManager = exports.MihomoManager = exports.TunnelApi = exports.MihomoApi = exports.registerTunnelIpc = exports.TunnelDatabase = exports.renderRuntimeConfig = exports.createElectronTunnel = exports.AdminServer = void 0;
+var AdminServer_1 = require("./admin/AdminServer");
+Object.defineProperty(exports, "AdminServer", { enumerable: true, get: function () { return AdminServer_1.AdminServer; } });
+var createElectronTunnel_1 = require("./createElectronTunnel");
+Object.defineProperty(exports, "createElectronTunnel", { enumerable: true, get: function () { return createElectronTunnel_1.createElectronTunnel; } });
+var renderRuntimeConfig_1 = require("./config/renderRuntimeConfig");
+Object.defineProperty(exports, "renderRuntimeConfig", { enumerable: true, get: function () { return renderRuntimeConfig_1.renderRuntimeConfig; } });
+var TunnelDatabase_1 = require("./db/TunnelDatabase");
+Object.defineProperty(exports, "TunnelDatabase", { enumerable: true, get: function () { return TunnelDatabase_1.TunnelDatabase; } });
+var registerTunnelIpc_1 = require("./ipc/registerTunnelIpc");
+Object.defineProperty(exports, "registerTunnelIpc", { enumerable: true, get: function () { return registerTunnelIpc_1.registerTunnelIpc; } });
+var MihomoApi_1 = require("./mihomo/MihomoApi");
+Object.defineProperty(exports, "MihomoApi", { enumerable: true, get: function () { return MihomoApi_1.MihomoApi; } });
+Object.defineProperty(exports, "TunnelApi", { enumerable: true, get: function () { return MihomoApi_1.MihomoApi; } });
+var MihomoManager_1 = require("./mihomo/MihomoManager");
+Object.defineProperty(exports, "MihomoManager", { enumerable: true, get: function () { return MihomoManager_1.MihomoManager; } });
+Object.defineProperty(exports, "TunnelManager", { enumerable: true, get: function () { return MihomoManager_1.MihomoManager; } });
+var electronProxy_1 = require("./system/electronProxy");
+Object.defineProperty(exports, "applyElectronProxy", { enumerable: true, get: function () { return electronProxy_1.applyElectronProxy; } });
+Object.defineProperty(exports, "proxyEnv", { enumerable: true, get: function () { return electronProxy_1.proxyEnv; } });
+var defaults_1 = require("./defaults");
+Object.defineProperty(exports, "DEFAULT_PORTS", { enumerable: true, get: function () { return defaults_1.DEFAULT_PORTS; } });
+Object.defineProperty(exports, "DOMAIN_PRESETS", { enumerable: true, get: function () { return defaults_1.DOMAIN_PRESETS; } });

package/dist/ipc/registerTunnelIpc.d.ts

@@ -0,0 +1,7 @@
+import type { IpcMain } from 'electron';
+import type { MihomoManager } from '../mihomo/MihomoManager';
+interface RegisterTunnelIpcOptions {
+    afterSettingsChange?: () => Promise<void> | void;
+}
+export declare function registerTunnelIpc(ipcMain: IpcMain, manager: MihomoManager, options?: RegisterTunnelIpcOptions): void;
+export {};

package/dist/ipc/registerTunnelIpc.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerTunnelIpc = registerTunnelIpc;
+async function changed(options) {
+    await options?.afterSettingsChange?.();
+}
+function registerTunnelIpc(ipcMain, manager, options) {
+    ipcMain.handle('tunnel:snapshot', () => manager.snapshot());
+    ipcMain.handle('tunnel:create-subscription', (_event, input) => manager.createSubscription(input));
+    ipcMain.handle('tunnel:delete-subscription', async (_event, id) => {
+        manager.deleteSubscription(id);
+        await manager.applyRuntimeConfigChange();
+    });
+    ipcMain.handle('tunnel:set-active-subscription', async (_event, id) => {
+        const subscription = manager.setActiveSubscription(id);
+        await manager.applyRuntimeConfigChange();
+        return subscription;
+    });
+    ipcMain.handle('tunnel:update-subscription', async (_event, id) => {
+        const subscription = await manager.updateSubscription(id);
+        if (subscription.active) {
+            await manager.applyRuntimeConfigChange();
+        }
+        return subscription;
+    });
+    ipcMain.handle('tunnel:update-active-subscription', async () => {
+        const subscription = await manager.updateActiveSubscription();
+        await manager.applyRuntimeConfigChange();
+        return subscription;
+    });
+    ipcMain.handle('tunnel:set-mode', async (_event, mode) => {
+        const changedMode = manager.setMode(mode);
+        if (changedMode) {
+            await manager.applyRuntimeConfigChange();
+        }
+        await changed(options);
+    });
+    ipcMain.handle('tunnel:set-core-path', (_event, corePath) => manager.setCorePath(corePath));
+    ipcMain.handle('tunnel:set-local-ports', async (_event, ports) => {
+        await manager.setLocalPorts(ports);
+        await changed(options);
+    });
+    ipcMain.handle('tunnel:install-tun', async () => {
+        manager.installTunFeature();
+        await manager.applyRuntimeConfigChange();
+        await changed(options);
+    });
+    ipcMain.handle('tunnel:uninstall-tun', async () => {
+        manager.uninstallTunFeature();
+        await manager.applyRuntimeConfigChange();
+        await changed(options);
+    });
+    ipcMain.handle('tunnel:start', () => manager.start());
+    ipcMain.handle('tunnel:stop', () => manager.stop());
+    ipcMain.handle('tunnel:restart', () => manager.restart());
+    ipcMain.handle('tunnel:add-rule', async (_event, input) => {
+        const rule = manager.addDomainRule(input.kind, input.domain);
+        await manager.applyRuntimeConfigChange();
+        return rule;
+    });
+    ipcMain.handle('tunnel:remove-rule', async (_event, id) => {
+        manager.removeDomainRule(id);
+        await manager.applyRuntimeConfigChange();
+    });
+    ipcMain.handle('tunnel:add-preset', async (_event, preset) => {
+        const rules = manager.addPreset(preset);
+        await manager.applyRuntimeConfigChange();
+        return rules;
+    });
+}