@qpjoy/electron-tunnel 0.1.3 → 0.1.4

package/dist/createElectronTunnel.js

@@ -7,6 +7,7 @@ const AdminServer_1 = require("./admin/AdminServer");
 const registerTunnelIpc_1 = require("./ipc/registerTunnelIpc");
 const MihomoManager_1 = require("./mihomo/MihomoManager");
 const electronProxy_1 = require("./system/electronProxy");
+const TUNNEL_PLUGIN_ID = 'qpjoy.electron-tunnel';
 function defaultBundledEngineDir() {
     const resourcesPath = process.resourcesPath ?? process.cwd();
     const packageDir = typeof __dirname === 'undefined' ? process.cwd() : __dirname;
@@ -38,6 +39,13 @@ function createElectronTunnel(host, options = {}) {
     (0, registerTunnelIpc_1.registerTunnelIpc)(host.ipcMain, manager, {
         afterSettingsChange: applyProxy
     });
+    // Self-register in the shared marketplace.db so the panel (when it shows
+    // up later) knows the tunnel is here. Best-effort; failure is silent —
+    // tunnel must keep working even if marketplace-db is missing.
+    registerSelfInMarketplaceDb(host.app, options).catch((err) => {
+        // eslint-disable-next-line no-console
+        console.warn('[electron-tunnel] marketplace-db self-register failed:', err);
+    });
     return {
         manager,
         admin,
@@ -49,3 +57,71 @@ function createElectronTunnel(host, options = {}) {
         }
     };
 }
+async function registerSelfInMarketplaceDb(app, options) {
+    // Late require so a missing peer dep doesn't break standalone use. Use a
+    // computed specifier + cast so tsc never tries to resolve types for it.
+    const specifier = '@qpjoy/marketplace-db';
+    let mod;
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-implied-eval, @typescript-eslint/no-var-requires
+        mod = require(specifier);
+    }
+    catch {
+        return; // package not installed alongside tunnel — fine.
+    }
+    const userDataPath = options.userDataPath ?? app.getPath('userData');
+    const dbPath = mod.resolveMarketplaceDbPath(userDataPath);
+    const packageJson = readNearbyJson('package.json');
+    const manifest = readNearbyJson('plugin.manifest.json', 'dist');
+    const db = mod.MarketplaceDB.open(dbPath);
+    try {
+        if (db.getInstalled(TUNNEL_PLUGIN_ID))
+            return; // host already registered us
+        const version = packageJson?.version ?? '0.0.0';
+        db.upsertInstalled({
+            id: TUNNEL_PLUGIN_ID,
+            npm: '@qpjoy/electron-tunnel',
+            version,
+            installPath: resolveTunnelPackageRoot(),
+            installSource: 'standalone',
+            manifest: {
+                id: TUNNEL_PLUGIN_ID,
+                name: 'QPJoy Tunnel',
+                version,
+                engines: { electronPlugin: '>=0.1.0', electron: '>=28' },
+                permissions: manifest?.permissions ?? [],
+                activationEvents: ['onStartup'],
+                contributes: { adminPanel: { url: 'http://127.0.0.1:23456', label: 'Tunnel' } }
+            },
+            // Standalone tunnel granted itself everything; the user implicitly
+            // accepted by choosing to install it directly (not via marketplace).
+            grantedPermissions: manifest?.permissions ?? [],
+            state: 'active',
+            errorMessage: null,
+            marketplaceEntryId: TUNNEL_PLUGIN_ID
+        });
+    }
+    finally {
+        db.close();
+    }
+}
+function readNearbyJson(name, sub) {
+    const packageDir = typeof __dirname === 'undefined' ? process.cwd() : __dirname;
+    const candidates = sub
+        ? [(0, path_1.resolve)(packageDir, sub, name), (0, path_1.resolve)(packageDir, '..', sub, name)]
+        : [(0, path_1.resolve)(packageDir, name), (0, path_1.resolve)(packageDir, '..', name)];
+    for (const p of candidates) {
+        try {
+            if ((0, fs_1.existsSync)(p))
+                return JSON.parse((0, fs_1.readFileSync)(p, 'utf8'));
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
+function resolveTunnelPackageRoot() {
+    const packageDir = typeof __dirname === 'undefined' ? process.cwd() : __dirname;
+    return (0, path_1.resolve)(packageDir, '..');
+}

package/dist/plugin.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Plugin adapter for @qpjoy/electron-plugin.
+ *
+ * The same package keeps working as a standalone npm dependency (use
+ * `createElectronTunnel(...)` directly). When loaded through the plugin
+ * host, this default export is what gets invoked instead — wrapping the
+ * exact same runtime behind the standard plugin contract.
+ *
+ * No new state is introduced here: the underlying MihomoManager owns its
+ * own SQLite + admin server, so this adapter is a ~30-line shim.
+ */
+import type { App, IpcMain, Session } from 'electron';
+/**
+ * Subset of the SDK types — re-declared structurally so this file does not
+ * take a build-time dependency on `@qpjoy/plugin-sdk`. (Tunnel still ships
+ * fine when installed without the plugin host present.)
+ */
+interface PluginHostBridge {
+    app: App;
+    ipcMain: IpcMain;
+    session: Session;
+}
+type ExposedApi = Record<string, (...args: any[]) => any>;
+interface PluginContextLike<S> {
+    host: PluginHostBridge;
+    settings: {
+        get(): S;
+    };
+    log: {
+        info(m: string, meta?: Record<string, unknown>): void;
+    };
+    expose(api: ExposedApi): void;
+}
+export interface TunnelPluginSettings {
+    adminPort?: number;
+    controllerPort?: number;
+    mixedPort?: number;
+    dnsPort?: number;
+    bundledEngineDir?: string;
+}
+declare const tunnelPlugin: {
+    activate(ctx: PluginContextLike<TunnelPluginSettings>): Promise<() => void>;
+};
+export default tunnelPlugin;

package/dist/plugin.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const createElectronTunnel_1 = require("./createElectronTunnel");
+const tunnelPlugin = {
+    async activate(ctx) {
+        const settings = ctx.settings.get() ?? {};
+        const handle = (0, createElectronTunnel_1.createElectronTunnel)({ app: ctx.host.app, ipcMain: ctx.host.ipcMain, session: ctx.host.session }, {
+            adminPort: settings.adminPort ?? 23456,
+            controllerPort: settings.controllerPort ?? 23457,
+            mixedPort: settings.mixedPort ?? 23458,
+            dnsPort: settings.dnsPort ?? 23459,
+            bundledEngineDir: settings.bundledEngineDir
+        });
+        // Expose an RPC surface so the host (and other plugins) can drive the
+        // tunnel without poking at internals. Anything not on this list is
+        // intentionally private — bump the surface explicitly when needed.
+        ctx.expose({
+            status: () => handle.status(),
+            snapshot: () => handle.manager.snapshot(),
+            applyProxy: () => handle.applyProxy(),
+            addDomainRule: async (kind, domain) => {
+                const rule = handle.manager.addDomainRule(kind, domain);
+                await handle.manager.applyRuntimeConfigChange();
+                return rule;
+            },
+            removeDomainRule: async (id) => {
+                handle.manager.removeDomainRule(id);
+                await handle.manager.applyRuntimeConfigChange();
+            },
+            addPreset: async (preset) => {
+                const rules = handle.manager.addPreset(preset);
+                await handle.manager.applyRuntimeConfigChange();
+                return rules;
+            },
+            removePreset: async (preset) => {
+                const count = handle.manager.removePreset(preset);
+                await handle.manager.applyRuntimeConfigChange();
+                return count;
+            },
+            onEvent: (listener) => {
+                handle.manager.on('event', listener);
+                return () => handle.manager.off('event', listener);
+            }
+        });
+        ctx.log.info('tunnel activated', {
+            ports: handle.status().ports,
+            mode: handle.status().mode
+        });
+        return () => handle.close();
+    }
+};
+exports.default = tunnelPlugin;

package/dist/plugin.manifest.json

@@ -0,0 +1,22 @@
+{
+  "id": "qpjoy.electron-tunnel",
+  "name": "QPJoy Tunnel",
+  "version": "0.1.3",
+  "author": "qpjoy",
+  "description": "Mihomo-based tunnel runtime with TUN / system-proxy / rule modes. Provides outbound networking for other plugins.",
+  "engines": { "electronPlugin": ">=0.1.0", "electron": ">=28" },
+  "permissions": [
+    "fs:userData",
+    "net:listen:23456",
+    "net:listen:23457",
+    "net:listen:23458",
+    "net:listen:23459",
+    "system:proxy",
+    "system:exec:mihomo",
+    "ui:adminPanel"
+  ],
+  "activationEvents": ["onStartup"],
+  "contributes": {
+    "adminPanel": { "url": "http://127.0.0.1:23456", "label": "Tunnel" }
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qpjoy/electron-tunnel",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "private": false,
   "description": "Reusable QPJoy tunnel runtime and CLI for Electron apps on macOS and Linux.",
   "license": "UNLICENSED",
@@ -12,6 +12,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./plugin": {
+      "types": "./dist/plugin.d.ts",
+      "default": "./dist/plugin.js"
+    },
     "./package.json": "./package.json"
   },
   "bin": {
@@ -23,11 +27,16 @@
     "dist",
     "resources/engine"
   ],
+  "qpjoyPlugin": {
+    "specVersion": 1,
+    "entry": "dist/plugin.js",
+    "manifest": "dist/plugin.manifest.json"
+  },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && node -e \"require('fs').copyFileSync('src/plugin.manifest.json','dist/plugin.manifest.json')\"",
     "prepack": "pnpm build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "lint": "tsc -p tsconfig.json --noEmit"
@@ -43,6 +52,9 @@
     "better-sqlite3": "^11.8.1",
     "yaml": "^2.7.0"
   },
+  "optionalDependencies": {
+    "@qpjoy/marketplace-db": ">=0.1.0"
+  },
   "peerDependencies": {
     "electron": ">=28"
   },