@qpjoy/electron-tunnel 0.1.0

package/dist/mihomo/MihomoApi.d.ts

@@ -0,0 +1,11 @@
+import type { MihomoApiResponse, RuntimeSettings } from '../types';
+export declare class MihomoApi {
+    private readonly getSettings;
+    constructor(getSettings: () => RuntimeSettings);
+    request<T = unknown>(path: string, init?: RequestInit): Promise<MihomoApiResponse<T>>;
+    version(): Promise<MihomoApiResponse>;
+    proxies(): Promise<MihomoApiResponse>;
+    connections(): Promise<MihomoApiResponse>;
+    reloadConfig(configPath: string): Promise<MihomoApiResponse>;
+    selectProxy(groupName: string, proxyName: string): Promise<MihomoApiResponse>;
+}

package/dist/mihomo/MihomoApi.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MihomoApi = void 0;
+class MihomoApi {
+    getSettings;
+    constructor(getSettings) {
+        this.getSettings = getSettings;
+    }
+    async request(path, init = {}) {
+        const settings = this.getSettings();
+        const url = `http://127.0.0.1:${settings.ports.controller}${path}`;
+        const headers = new Headers(init.headers);
+        headers.set('Authorization', `Bearer ${settings.controllerSecret}`);
+        const response = await fetch(url, {
+            ...init,
+            headers
+        });
+        const contentType = response.headers.get('content-type') ?? '';
+        const data = contentType.includes('application/json')
+            ? await response.json()
+            : await response.text();
+        return {
+            ok: response.ok,
+            status: response.status,
+            data
+        };
+    }
+    version() {
+        return this.request('/version');
+    }
+    proxies() {
+        return this.request('/proxies');
+    }
+    connections() {
+        return this.request('/connections');
+    }
+    reloadConfig(configPath) {
+        return this.request('/configs?force=true', {
+            method: 'PUT',
+            body: JSON.stringify({ path: configPath }),
+            headers: {
+                'content-type': 'application/json'
+            }
+        });
+    }
+    async selectProxy(groupName, proxyName) {
+        return this.request(`/proxies/${encodeURIComponent(groupName)}`, {
+            method: 'PUT',
+            body: JSON.stringify({ name: proxyName }),
+            headers: {
+                'content-type': 'application/json'
+            }
+        });
+    }
+}
+exports.MihomoApi = MihomoApi;

package/dist/mihomo/MihomoManager.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from 'events';
+import { TunnelDatabase } from '../db/TunnelDatabase';
+import { type DomainPresetId } from '../defaults';
+import { MihomoApi } from './MihomoApi';
+import type { DomainRule, RuntimeMode, SubscriptionInput, SubscriptionRecord, TunnelManagerOptions, TunnelSnapshot, TunnelPorts, TunnelStatus } from '../types';
+interface ManagerPaths {
+    root: string;
+    db: string;
+    profiles: string;
+    runtime: string;
+    config: string;
+    core: string;
+}
+export declare class MihomoManager extends EventEmitter {
+    private readonly options;
+    readonly db: TunnelDatabase;
+    readonly api: MihomoApi;
+    readonly paths: ManagerPaths;
+    private child;
+    private elevatedPid;
+    private operation;
+    constructor(options: TunnelManagerOptions);
+    status(): TunnelStatus;
+    snapshot(): Promise<TunnelSnapshot>;
+    trafficSummary(): Promise<{
+        available: boolean;
+        connections: number;
+        uploadTotal: number;
+        downloadTotal: number;
+    }>;
+    listSubscriptions(): SubscriptionRecord[];
+    listRules(): DomainRule[];
+    listEvents(): import("../types").EventRecord[];
+    createSubscription(input: SubscriptionInput): Promise<SubscriptionRecord>;
+    private localSubscriptionPath;
+    private fetchSubscriptionContent;
+    deleteSubscription(id: number): void;
+    setActiveSubscription(id: number): SubscriptionRecord;
+    setMode(mode: RuntimeMode): boolean;
+    setLocalPorts(ports: Partial<Pick<TunnelPorts, 'mixed' | 'dns'>>): Promise<void>;
+    installTunFeature(): void;
+    uninstallTunFeature(): void;
+    installCoreFromPath(sourcePath: string): string;
+    setCorePath(corePath: string): void;
+    updateSubscription(id: number): Promise<SubscriptionRecord>;
+    updateActiveSubscription(): Promise<SubscriptionRecord>;
+    addDomainRule(kind: 'allow' | 'block', domain: string, source?: string): DomainRule;
+    addPreset(preset: DomainPresetId): DomainRule[];
+    removeDomainRule(id: number): void;
+    renderConfig(): string;
+    private runExclusive;
+    start(): Promise<void>;
+    private startUnlocked;
+    private resolveCorePath;
+    private findBundledCore;
+    private installBundledCore;
+    private runElevatedShell;
+    private startElevated;
+    private readElevatedLogTail;
+    private elevatedPidPath;
+    private readElevatedPid;
+    private rememberElevatedPid;
+    private clearElevatedPid;
+    private isRunning;
+    private isElevatedRunning;
+    private reloadRuntimeConfig;
+    stop(): Promise<void>;
+    private stopUnlocked;
+    restart(): Promise<void>;
+    applyRuntimeConfigChange(): Promise<void>;
+    handleNetworkChanged(reason: string): Promise<void>;
+    close(): void;
+    private log;
+}
+export {};