@cordy/electro 1.2.16 → 1.2.18

package/dist/index.d.mts

@@ -774,6 +774,7 @@ declare class Runtime {
   private readonly windowManager;
   private readonly viewManager;
   private readonly eventBridge;
+  private readonly ipcBridge;
   constructor(config?: RuntimeConfig);
   register(features: FeatureConfig<any> | FeatureConfig<any>[]): void;
   start(): Promise<void>;

package/dist/index.mjs

@@ -864,6 +864,92 @@ var FeatureManager = class {
 	}
 };
 
+//#endregion
+//#region src/core/ipc/bridge.ts
+/**
+* Registers invoke handlers for exposed service methods and enforces
+* per-view feature access at runtime.
+*/
+var IpcBridge = class {
+	viewFeatures = /* @__PURE__ */ new Map();
+	ipcMainOverride;
+	ipcMain = null;
+	registeredChannels = /* @__PURE__ */ new Set();
+	constructor(featureManager, viewManager, viewRegistry, options = {}) {
+		this.featureManager = featureManager;
+		this.viewManager = viewManager;
+		this.ipcMainOverride = options.ipcMain ?? null;
+		for (const entry of viewRegistry) {
+			if (!entry.hasRenderer) continue;
+			this.viewFeatures.set(entry.id, new Set(entry.features ?? []));
+		}
+	}
+	async start() {
+		if (this.ipcMain) return;
+		const ipcMain = this.ipcMainOverride ?? await this.resolveIpcMain();
+		if (!ipcMain) return;
+		this.ipcMain = ipcMain;
+		this.registerHandlers();
+	}
+	stop() {
+		if (!this.ipcMain) return;
+		for (const channel of this.registeredChannels) this.ipcMain.removeHandler(channel);
+		this.registeredChannels.clear();
+		this.ipcMain = null;
+	}
+	async resolveIpcMain() {
+		if (!process.versions.electron) return null;
+		try {
+			const candidate = (await import("electron")).ipcMain;
+			if (!candidate) return null;
+			if (typeof candidate.handle !== "function") return null;
+			if (typeof candidate.removeHandler !== "function") return null;
+			return candidate;
+		} catch {
+			return null;
+		}
+	}
+	registerHandlers() {
+		if (!this.ipcMain) return;
+		for (const feature of this.featureManager.list()) for (const service of feature.config.services ?? []) {
+			if (service.scope !== ServiceScope.EXPOSED) continue;
+			const api = (feature.serviceManager?.get(service.id))?.api;
+			if (!api || typeof api !== "object") continue;
+			for (const [method, target] of Object.entries(api)) {
+				if (typeof target !== "function") continue;
+				const channel = `${feature.id}:${service.id}:${method}`;
+				if (this.registeredChannels.has(channel)) continue;
+				this.ipcMain.handle(channel, async (event, ...args) => {
+					return this.invoke(event, feature.id, service.id, method, args);
+				});
+				this.registeredChannels.add(channel);
+			}
+		}
+	}
+	async invoke(event, featureId, serviceId, method, args) {
+		this.assertAccess(event.sender.id, featureId, serviceId, method);
+		const channel = `${featureId}:${serviceId}:${method}`;
+		const resolved = this.featureManager.get(featureId)?.serviceManager?.get(serviceId);
+		if (!resolved || resolved.scope !== ServiceScope.EXPOSED) throw new Error(`No handler registered for '${channel}'`);
+		const fn = resolved.api?.[method];
+		if (typeof fn !== "function") throw new Error(`No handler registered for '${channel}'`);
+		return await Promise.resolve(fn(...args));
+	}
+	assertAccess(senderWebContentsId, featureId, serviceId, method) {
+		const viewId = this.resolveSenderViewId(senderWebContentsId);
+		if (!viewId) throw new Error(`Access denied for '${featureId}:${serviceId}:${method}': unknown renderer sender`);
+		if (!this.viewFeatures.get(viewId)?.has(featureId)) throw new Error(`Access denied for '${featureId}:${serviceId}:${method}' from view '${viewId}'`);
+	}
+	resolveSenderViewId(senderWebContentsId) {
+		for (const viewId of this.viewFeatures.keys()) {
+			const view = this.viewManager.get(viewId)?.view();
+			if (!view || view.webContents.isDestroyed()) continue;
+			if (view.webContents.id === senderWebContentsId) return viewId;
+		}
+		return null;
+	}
+};
+
 //#endregion
 //#region src/core/logger/console-handler.ts
 const dim = "\x1B[90m";
@@ -1012,8 +1098,8 @@ var View = class {
 	}
 };
 const PRELOAD_EXTENSIONS = [
-	"mjs",
 	"cjs",
+	"mjs",
 	"js"
 ];
 function resolveDefaultPreloadPath(viewId) {
@@ -1068,6 +1154,7 @@ var Runtime = class {
 	windowManager;
 	viewManager;
 	eventBridge = null;
+	ipcBridge = null;
 	constructor(config) {
 		this.state = new StateMachine({
 			transitions: RUNTIME_TRANSITIONS,
@@ -1084,7 +1171,10 @@ var Runtime = class {
 		this.viewManager = new ViewManager();
 		const viewRegistry = typeof __ELECTRO_VIEW_REGISTRY__ !== "undefined" ? __ELECTRO_VIEW_REGISTRY__ : [];
 		for (const entry of viewRegistry) this.viewManager.register(new View(entry));
-		if (viewRegistry.some((v) => v.features && v.features.length > 0)) this.eventBridge = new EventBridge(this.eventBus, this.viewManager, viewRegistry);
+		if (viewRegistry.some((v) => v.features && v.features.length > 0)) {
+			this.eventBridge = new EventBridge(this.eventBus, this.viewManager, viewRegistry);
+			this.ipcBridge = new IpcBridge(this.featureManager, this.viewManager, viewRegistry);
+		}
 		this.featureManager.setWindowManager(this.windowManager);
 		this.featureManager.setViewManager(this.viewManager);
 		if (config?.features) this.featureManager.register(config.features);
@@ -1098,8 +1188,10 @@ var Runtime = class {
 		try {
 			this.eventBridge?.start();
 			await this.featureManager.bootstrap();
+			await this.ipcBridge?.start();
 			this.state.transition(RuntimeState.RUNNING);
 		} catch (err) {
+			this.ipcBridge?.stop();
 			this.eventBridge?.stop();
 			this.state.transition(RuntimeState.FAILED);
 			throw err;
@@ -1108,6 +1200,7 @@ var Runtime = class {
 	async shutdown() {
 		this.state.assertState(RuntimeState.RUNNING);
 		this.state.transition(RuntimeState.STOPPING);
+		this.ipcBridge?.stop();
 		this.eventBridge?.stop();
 		await this.featureManager.shutdown();
 		this.viewManager.destroyAll();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cordy/electro",
-    "version": "1.2.16",
+    "version": "1.2.18",
     "description": "Electron framework — feature-first runtime, codegen, and Vite-based build system",
     "license": "MIT",
     "type": "module",