everything-dev/dist/services/dev/session.cjs

A consolidated product package for building Module Federation apps with oRPC APIs.

const require_process_env = require('../../env/process-env.cjs');
const require_service_descriptor = require('./service-descriptor.cjs');
const require_project_env = require('../../env/project-env.cjs');
const require_registry = require('../processes/registry.cjs');
const require_ports = require('../../infra/ports.cjs');
const require_port_ownership = require('../../infra/port-ownership.cjs');
const require_logs = require('./logs.cjs');
const require_orchestrator = require('./orchestrator.cjs');
const require_kill = require('../processes/kill.cjs');
const require_render = require('./render.cjs');
let effect = require("effect");

//#region src/services/dev/session.ts
const adoptOrphanedChildren = (configDir) => {
	try {
		const entries = require_registry.readRegistry().filter((entry) => entry.pid > 1 && entry.configDir === configDir && !require_registry.isPidAlive(entry.pid));
		if (entries.length === 0) return;
		const reaped = [];
		for (const entry of entries) for (const childPid of entry.childPids ?? []) {
			if (childPid === process.pid) continue;
			if (require_registry.isPidAlive(childPid)) {
				require_kill.reapGroup(childPid);
				reaped.push(childPid);
			}
		}
		if (reaped.length > 0) console.error(`[Dev] Reaped ${reaped.length} orphaned child process(es) from dead session(s): ${reaped.join(", ")}`);
		const deadPids = new Set(entries.map((entry) => entry.pid));
		require_registry.writeRegistry(require_registry.readRegistry().filter((entry) => !deadPids.has(entry.pid)));
	} catch {}
};
const isInteractiveSupported = () => {
	return process.stdin.isTTY === true && process.stdout.isTTY === true;
};
const STARTUP_ORDER = [
	"ui",
	"auth",
	"api",
	"plugin",
	"host-build",
	"host"
];
const sortByOrder = (packages) => {
	return [...packages].sort((a, b) => {
		const aIdx = a.startsWith("plugin:") ? STARTUP_ORDER.indexOf("plugin") : STARTUP_ORDER.indexOf(a);
		const bIdx = b.startsWith("plugin:") ? STARTUP_ORDER.indexOf("plugin") : STARTUP_ORDER.indexOf(b);
		if (aIdx === -1 && bIdx === -1) return 0;
		if (aIdx === -1) return 1;
		if (bIdx === -1) return -1;
		return aIdx - bIdx;
	});
};
const runDevSession = (configDir, orchestrator, onSessionReady, deps = {}) => effect.Effect.gen(function* () {
	adoptOrphanedChildren(configDir);
	const services = yield* require_service_descriptor.ServiceDescriptorMap;
	const runtimeConfig = yield* require_service_descriptor.DevRuntimeConfig;
	const renderer = yield* require_render.DevRenderer;
	const orderedPackages = sortByOrder(orchestrator.packages);
	const initialProcesses = require_orchestrator.getProcessStates(orderedPackages, services, orchestrator.port);
	if (require_logs.isDebug(require_process_env.getProcessEnv("DEBUG"))) {
		yield* effect.Effect.logError(`[DEBUG session] orchestrator.packages: ${orchestrator.packages.join(", ")}`);
		yield* effect.Effect.logError(`[DEBUG session] orderedPackages: ${orderedPackages.join(", ")}`);
		yield* effect.Effect.logError(`[DEBUG session] services keys: ${[...services.keys()].join(", ")}`);
		yield* effect.Effect.logError(`[DEBUG session] initialProcesses: ${initialProcesses.map((p) => `${p.name}=${p.source}`).join(", ")}`);
	}
	const logger = yield* effect.Effect.promise(() => require_logs.createDevLogger(configDir, orchestrator.description));
	const exit = deps.exit ?? ((code) => process.exit(code));
	const reap = deps.reap ?? require_kill.reapGroup;
	const forceTimeoutMs = deps.forceTimeoutMs ?? 5e3;
	const ppidNow = deps.ppid ?? (() => process.ppid);
	const shutdown = yield* effect.Deferred.make();
	const effectContext = yield* effect.Effect.context();
	const isWorkspaceChild = require_process_env.getProcessEnv("BOS_WORKSPACE_CHILD") === "1";
	let ownedPorts = [];
	if (!isWorkspaceChild) {
		const regPorts = {};
		const addPort = (key, value) => {
			if (value != null) regPorts[key] = value;
		};
		addPort("host", runtimeConfig.host.port);
		addPort("api", runtimeConfig.api.port);
		addPort("ui", runtimeConfig.ui.port);
		addPort("auth", runtimeConfig.auth?.port);
		if (runtimeConfig.plugins) for (const [id, plugin] of Object.entries(runtimeConfig.plugins)) {
			if (!require_service_descriptor.isAuthMirrorPluginEntry(runtimeConfig.auth, id, plugin)) addPort(`plugin:${id}`, plugin.port);
			addPort(`plugin-ui:${id}`, plugin.ui?.port);
		}
		require_registry.registerStandalone({
			pid: process.pid,
			configDir,
			ports: regPorts,
			startedAt: yield* effect.Clock.currentTimeMillis,
			description: orchestrator.description
		});
		ownedPorts = Object.values(regPorts);
	}
	let view = null;
	let shouldExportLogs = false;
	const logLevel = require_logs.resolveLogLevel();
	const allLogs = [];
	const spawned = [];
	const pipeline = require_logs.createLogPipeline({
		level: logLevel,
		sinks: {
			display: (event) => {
				view?.addLog(event.source, event.line, event.level === "error");
			},
			file: (event) => {
				if (orchestrator.noLogs) return;
				logger.write(event);
			},
			export: (event) => {
				allLogs.push(event);
			}
		}
	});
	const useInteractive = isInteractiveSupported() && orchestrator.interactive !== false;
	const restoreView = () => {
		if (useInteractive) view?.unmount();
	};
	let handleRef = null;
	view = renderer.create(initialProcesses, orchestrator.description, orchestrator.env, () => handleRef?.shutdown("graceful"), () => {
		shouldExportLogs = true;
		handleRef?.shutdown("graceful");
	}, {
		interactive: useInteractive,
		onForceExit: () => handleRef?.shutdown("force")
	});
	const force = () => {
		require_orchestrator.markForceExitInFlight();
		try {
			restoreView();
		} catch {}
		try {
			pipeline.flush();
		} catch {}
		console.log("\n[Dev] Force exit");
		for (const handle of spawned) {
			if (handle.pid === void 0) continue;
			try {
				reap(handle.pid);
			} catch {}
		}
		if (!isWorkspaceChild) try {
			require_registry.unregisterPid(process.pid);
		} catch {}
		effect.Effect.runPromiseWith(effectContext)(effect.Deferred.succeed(shutdown, void 0));
		exit(0);
	};
	let gracefulCount = 0;
	let forceTimer = null;
	const armForce = () => {
		if (forceTimer) clearTimeout(forceTimer);
		forceTimer = setTimeout(force, forceTimeoutMs);
		forceTimer.unref?.();
	};
	const disarmForce = () => {
		if (forceTimer) clearTimeout(forceTimer);
		forceTimer = null;
	};
	const sessionHandle = { shutdown: (mode) => {
		if (mode === "force") {
			force();
			return;
		}
		gracefulCount++;
		if (gracefulCount > 1) {
			force();
			return;
		}
		restoreView();
		console.log("\n[Dev] Shutting down...");
		armForce();
		effect.Effect.runPromiseWith(effectContext)(effect.Deferred.succeed(shutdown, void 0));
	} };
	handleRef = sessionHandle;
	yield* effect.Effect.addFinalizer(() => effect.Effect.sync(disarmForce));
	yield* effect.Effect.addFinalizer(() => effect.Effect.gen(function* () {
		armForce();
		yield* effect.Effect.forEach(spawned, (h) => h.kill.pipe(effect.Effect.ignore), { concurrency: "unbounded" });
		yield* effect.Effect.sleep("200 millis");
		for (const port of ownedPorts) if (!(yield* require_ports.probePortBindable(port))) {
			const owner = yield* require_port_ownership.ownerOfPort(port);
			yield* effect.Effect.logError(`[Dev] Port ${port} still bound after teardown${owner ? ` — pid ${owner.pid} (${owner.command})` : " — owner unknown (lsof unavailable)"}`);
		}
		if (!isWorkspaceChild) yield* effect.Effect.sync(() => {
			try {
				require_registry.unregisterPid(process.pid);
			} catch {}
		});
		pipeline.flush();
		view?.unmount();
		if (shouldExportLogs) {
			const now = yield* effect.Clock.currentTimeMillis;
			const startedMs = allLogs[0]?.timestamp || now;
			yield* effect.Effect.log("");
			yield* effect.Effect.log("═".repeat(70));
			yield* effect.Effect.log(`  SESSION LOGS: ${orchestrator.description}`);
			yield* effect.Effect.log(`  Started: ${effect.DateTime.formatIso(effect.DateTime.makeUnsafe(startedMs))}`);
			yield* effect.Effect.log(`  Filtered entries: ${allLogs.length} (level: ${logLevel})`);
			yield* effect.Effect.log("═".repeat(70));
			yield* effect.Effect.log("");
			for (const event of allLogs) yield* effect.Effect.log(require_logs.formatLogLine(event));
			yield* effect.Effect.log("");
			yield* effect.Effect.log("═".repeat(70));
			yield* effect.Effect.log(`  Full logs saved to: ${logger.logFile}`);
			yield* effect.Effect.log("═".repeat(70));
			yield* effect.Effect.log("");
		}
	}));
	const callbacks = {
		onStatus: (name, status, message) => {
			if (status === "error") pipeline.flushSource(name);
			view?.updateProcess(name, status, message);
		},
		onLog: (name, line, isError) => {
			pipeline.ingest({
				source: name,
				line,
				isError
			});
		}
	};
	yield* effect.Effect.forkScoped(effect.Effect.gen(function* () {
		const initialPpid = ppidNow();
		while (true) {
			yield* effect.Effect.sleep("200 millis");
			if (ppidNow() === initialPpid) continue;
			console.error("\n[Dev] Parent process died — force exiting (orphaned service tree)");
			force();
		}
	}));
	onSessionReady?.(sessionHandle);
	const startProcess = (pkg) => {
		const portOverride = pkg === "host" ? orchestrator.port : void 0;
		return require_orchestrator.makeDevProcess(pkg, callbacks, portOverride).pipe(effect.Effect.tap((handle) => effect.Effect.sync(() => spawned.push(handle))), effect.Effect.flatMap((handle) => effect.Effect.acquireRelease(effect.Effect.succeed(handle), () => handle.kill.pipe(effect.Effect.ignore))), effect.Effect.tapError((err) => effect.Effect.sync(() => {
			callbacks.onLog(pkg, `Failed to start: ${String(err)}`, true);
			callbacks.onStatus(pkg, "error");
		})), effect.Effect.orElseSucceed(() => ({
			name: pkg,
			pid: void 0,
			kill: effect.Effect.void,
			waitForReady: effect.Effect.void,
			waitForExit: effect.Effect.never
		})));
	};
	const startGroup = (packages) => effect.Effect.forEach(packages, startProcess, { concurrency: "unbounded" });
	const awaitReady = (pkg, handle) => handle.waitForReady.pipe(effect.Effect.timeout("120 seconds"), effect.Effect.catch((err) => effect.Effect.sync(() => {
		callbacks.onLog(pkg, `Timed out or failed: ${err instanceof Error ? err.message : String(err)}`, true);
	})));
	const nonHostPackages = orderedPackages.filter((pkg) => pkg !== "host");
	const hostPackages = orderedPackages.filter((pkg) => pkg === "host");
	const startupPhase = effect.Effect.gen(function* () {
		const nonHostHandles = yield* startGroup(nonHostPackages);
		yield* effect.Effect.forEach(nonHostHandles.map((handle, index) => ({
			handle,
			pkg: nonHostPackages[index] ?? handle.name
		})), ({ handle, pkg }) => awaitReady(pkg, handle), { concurrency: "unbounded" });
		const hostHandles = yield* startGroup(hostPackages);
		yield* effect.Effect.forEach(hostHandles.map((handle, index) => ({
			handle,
			pkg: hostPackages[index] ?? handle.name
		})), ({ handle, pkg }) => awaitReady(pkg, handle), { concurrency: "unbounded" });
		return {
			nonHostHandles,
			hostHandles
		};
	});
	const startup = yield* effect.Effect.raceFirst(startupPhase, effect.Deferred.await(shutdown).pipe(effect.Effect.as(null)));
	if (startup === null) return;
	const childPids = [...startup.nonHostHandles, ...startup.hostHandles].map((handle) => Number(handle.pid)).filter((pid) => Number.isFinite(pid) && pid > 1 && pid !== process.pid);
	if (!isWorkspaceChild && childPids.length > 0) yield* effect.Effect.sync(() => {
		try {
			require_registry.updateChildPids(process.pid, childPids);
		} catch {}
	});
	yield* effect.Deferred.await(shutdown);
});
const runApp = (configDir, data, rendererLayer) => {
	let handle = null;
	const trigger = (mode) => {
		if (handle) {
			handle.shutdown(mode);
			return;
		}
		process.exit(0);
	};
	process.on("SIGINT", () => trigger("graceful"));
	process.on("SIGTERM", () => trigger("graceful"));
	const program = effect.Effect.scoped(runDevSession(configDir, data.orchestrator, (sessionHandle) => {
		handle = sessionHandle;
	})).pipe(effect.Effect.provide(effect.Layer.mergeAll(require_service_descriptor.ServiceDescriptorMapLive(data.services), require_service_descriptor.DevRuntimeConfigLive(data.runtimeConfig), require_service_descriptor.DevGeneratedEnvLive(data.envGenerated), require_project_env.ShellEnvLive(data.shellEnv), rendererLayer)), effect.Effect.catchDefect((defect) => effect.Effect.logError("[Dev] Unhandled defect in orchestrator:", defect).pipe(effect.Effect.andThen(effect.Effect.die(defect)))));
	effect.Effect.runPromiseExit(program).then((exit) => {
		process.exit(effect.Exit.isSuccess(exit) ? 0 : 1);
	}).catch((error) => {
		console.error("[Dev] Failed to observe application exit:", error);
		process.exit(1);
	});
};
const devApp = runApp;

//#endregion
exports.devApp = devApp;
exports.runDevSession = runDevSession;
//# sourceMappingURL=session.cjs.map