everything-dev/dist/services/ops.cjs

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

const require_services_registry_fastkv = require('./registry/fastkv.cjs');
const require_load = require('./resolution/load.cjs');
const require_services_registry_fingerprint = require('./registry/fingerprint.cjs');
const require_services_version_status = require('./version/status.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('./dev/logs.cjs');
const require_kill = require('./processes/kill.cjs');
const require_status = require('./status.cjs');
let node_path = require("node:path");
let effect = require("effect");

//#region src/services/ops.ts
var OpsService = class OpsService extends effect.Context.Service()("bos/OpsService") {
	static Live = effect.Layer.succeed(OpsService, OpsService.of({
		status: (session) => effect.Effect.tryPromise({
			try: async () => {
				const configPath = require_load.findConfigPath();
				if (!configPath) return {
					status: "error",
					packages: [],
					envFile: "missing",
					error: `${require_load.MISSING_CONFIG_MESSAGE} in current directory`
				};
				const projectDir = (0, node_path.resolve)((0, node_path.dirname)(configPath));
				return {
					...await require_status.getStatus(projectDir),
					deployedVersion: await deployedVersionStatus(session)
				};
			},
			catch: (error) => ({
				status: "error",
				packages: [],
				envFile: "missing",
				error: error instanceof Error ? error.message : "Unknown error"
			})
		}),
		logs: (input, configDir) => effect.Effect.tryPromise({
			try: async () => {
				const text = await require_logs.readDevLatestLog(configDir, { tail: input.tail });
				const service = input.service;
				const lines = text.split("\n").filter((line) => line.length > 0).filter((line) => {
					if (!service) return true;
					const match = /\] \[([^\]]+)\] \[(?:OUT|ERR)\] /.exec(line);
					return match?.[1] === service || match?.[1] === `plugin:${service}`;
				});
				return {
					logFile: require_logs.resolveDevLatestFile(configDir),
					lines
				};
			},
			catch: (error) => ({
				logFile: "unknown",
				lines: [error instanceof Error ? `Failed to read logs: ${error.message}` : "Failed to read logs"]
			})
		}),
		kill: (input) => effect.Effect.tryPromise({
			try: async () => {
				const configPath = require_load.findConfigPath();
				const targetConfigDir = input.all ? void 0 : input.configDir ?? (configPath ? (0, node_path.resolve)((0, node_path.dirname)(configPath)) : void 0);
				const targets = targetConfigDir ? require_registry.readRegistry().filter((entry) => entry.configDir === targetConfigDir) : require_registry.readRegistry();
				const killed = [];
				const skipped = [];
				for (const entry of targets) {
					const wasAlive = require_registry.isPidAlive(entry.pid);
					if (wasAlive) await effect.Effect.runPromise(require_kill.killProcessGroupEscalating(entry.pid, {
						terminateMs: 5e3,
						signal: input.signal === "SIGKILL" ? "SIGKILL" : "SIGTERM"
					}));
					const reapedChildren = [];
					for (const childPid of entry.childPids ?? []) if (require_registry.isPidAlive(childPid)) {
						require_kill.reapGroup(childPid);
						reapedChildren.push(childPid);
					}
					const ports = Object.values(entry.ports ?? {}).filter((port) => Number.isFinite(port) && port > 0);
					const stillBound = [];
					for (const port of ports) {
						let bindable = false;
						for (let attempt = 0; attempt < 4; attempt++) {
							bindable = await effect.Effect.runPromise(require_ports.probePortBindable(port));
							if (bindable) break;
							await new Promise((resolve) => setTimeout(resolve, 500));
						}
						if (!bindable) stillBound.push(port);
					}
					if (stillBound.length > 0) {
						const owner = await effect.Effect.runPromise(require_port_ownership.ownerOfPort(stillBound[0]));
						skipped.push({
							pid: entry.pid,
							reason: `ports still bound after kill: ${stillBound.join(", ")}${owner ? ` — held by pid ${owner.pid} (${owner.command})` : " — owner unknown"}`
						});
						continue;
					}
					require_registry.unregisterPid(entry.pid);
					killed.push({
						pid: entry.pid,
						configDir: entry.configDir
					});
					if (!wasAlive && reapedChildren.length > 0) skipped.push({
						pid: entry.pid,
						reason: `process already exited; reaped orphaned children ${reapedChildren.join(", ")}`
					});
				}
				return {
					status: "killed",
					killed,
					skipped
				};
			},
			catch: (error) => ({
				status: "error",
				killed: [],
				skipped: [],
				error: error instanceof Error ? error.message : "Unknown error"
			})
		})
	}));
};
async function deployedVersionStatus(session) {
	const config = session?.config;
	if (!config?.account || !config.domain) return void 0;
	const { account, domain } = config;
	let publishedFingerprint;
	try {
		const published = await require_services_registry_fastkv.fetchBosConfigFromFastKv(`bos://${account}/${domain}`);
		publishedFingerprint = require_services_registry_fingerprint.pointerFingerprint(published);
	} catch {
		return;
	}
	const hostUrl = session?.runtime?.host?.url;
	if (!hostUrl) return require_services_version_status.computeDeployedVersionStatus({
		publishedFingerprint,
		servedFingerprint: null
	});
	try {
		const response = await fetch(new URL("/.well-known/version", hostUrl));
		if (!response.ok) return require_services_version_status.computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: null,
			servedError: `version endpoint returned ${response.status}`
		});
		const body = await response.json();
		return require_services_version_status.computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: body.fingerprint ?? null
		});
	} catch (error) {
		return require_services_version_status.computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: null,
			servedError: error instanceof Error ? error.message : String(error)
		});
	}
}

//#endregion
exports.OpsService = OpsService;
//# sourceMappingURL=ops.cjs.map