everything-dev/dist/commands/ops.mjs

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

import { fetchBosConfigFromFastKv } from "../fastkv.mjs";
import { MISSING_CONFIG_MESSAGE, findConfigPath } from "../config.mjs";
import { openResolution } from "../resolution/session.mjs";
import { pointerFingerprint } from "../fingerprint.mjs";
import { computeDeployedVersionStatus } from "../version-status.mjs";
import { BosDepsTag } from "./shared.mjs";
import { isPidAlive, pruneDeadEffect, readRegistry, unregisterPid } from "../process-registry.mjs";
import { probePortBindable } from "../app.mjs";
import { buildCiInfraPlan } from "../cli/infra.mjs";
import { ownerOfPort } from "../infra/port-ownership.mjs";
import { getStatus } from "../cli/status.mjs";
import { readDevLatestLog, resolveDevLatestFile } from "../dev-logs.mjs";
import { killProcessGroupEscalating, reapGroup } from "../process-kill.mjs";
import { dirname, resolve } from "node:path";
import { Context, Effect } from "effect";
import process from "node:process";

//#region src/commands/ops.ts
function registerOps(builder) {
	return {
		status: builder.status.handler(async ({ context }) => {
			try {
				const deps = Context.get(context["effect/context"], BosDepsTag);
				const configPath = findConfigPath();
				if (!configPath) return {
					status: "error",
					packages: [],
					envFile: "missing",
					error: `${MISSING_CONFIG_MESSAGE} in current directory`
				};
				const projectDir = resolve(dirname(configPath));
				return {
					...await getStatus(projectDir),
					deployedVersion: await deployedVersionStatus(deps)
				};
			} catch (error) {
				return {
					status: "error",
					packages: [],
					envFile: "missing",
					error: error instanceof Error ? error.message : "Unknown error"
				};
			}
		}),
		logs: builder.logs.handler(async ({ input, context }) => {
			try {
				const configDir = Context.get(context["effect/context"], BosDepsTag).session?.root ?? process.cwd();
				const text = await 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: resolveDevLatestFile(configDir),
					lines
				};
			} catch (error) {
				return {
					logFile: "unknown",
					lines: [error instanceof Error ? `Failed to read logs: ${error.message}` : "Failed to read logs"]
				};
			}
		}),
		ps: builder.ps.handler(async () => {
			try {
				return {
					status: "ok",
					entries: await Effect.runPromise(pruneDeadEffect(readRegistry()))
				};
			} catch (error) {
				return {
					status: "error",
					entries: [],
					error: error instanceof Error ? error.message : "Unknown error"
				};
			}
		}),
		kill: builder.kill.handler(async ({ input }) => {
			try {
				const configPath = findConfigPath();
				const targetConfigDir = input.all ? void 0 : input.configDir ?? (configPath ? resolve(dirname(configPath)) : void 0);
				const targets = targetConfigDir ? readRegistry().filter((entry) => entry.configDir === targetConfigDir) : readRegistry();
				const killed = [];
				const skipped = [];
				for (const entry of targets) {
					const wasAlive = isPidAlive(entry.pid);
					if (wasAlive) await Effect.runPromise(killProcessGroupEscalating(entry.pid, {
						terminateMs: 5e3,
						signal: input.signal === "SIGKILL" ? "SIGKILL" : "SIGTERM"
					}));
					const reapedChildren = [];
					for (const childPid of entry.childPids ?? []) if (isPidAlive(childPid)) {
						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.runPromise(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.runPromise(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;
					}
					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) {
				return {
					status: "error",
					killed: [],
					skipped: [],
					error: error instanceof Error ? error.message : "Unknown error"
				};
			}
		}),
		infraExport: builder.infraExport.handler(async ({ input, context }) => {
			const deps = Context.get(context["effect/context"], BosDepsTag);
			const configDir = input.configDir ?? deps.session?.root ?? process.cwd();
			const ci = deps.session?.runtime ? buildCiInfraPlan(deps.session.runtime) : null;
			if (!ci) {
				const refreshed = await openResolution({ cwd: configDir });
				if (!refreshed?.runtime) throw new Error("No resolved runtime config available for infra export");
				return buildCiInfraPlan(refreshed.runtime);
			}
			return {
				...ci,
				account: deps.session?.config?.account ?? ci.account,
				gateway: ci.gateway ?? deps.session?.config?.domain ?? deps.session?.config?.account ?? ci.account
			};
		})
	};
}
async function deployedVersionStatus(deps) {
	const config = deps.session?.config;
	if (!config?.account || !config.domain) return void 0;
	const { account, domain } = config;
	let publishedFingerprint;
	try {
		const published = await fetchBosConfigFromFastKv(`bos://${account}/${domain}`);
		publishedFingerprint = pointerFingerprint(published);
	} catch {
		return;
	}
	const hostUrl = deps.session?.runtime?.host?.url;
	if (!hostUrl) return computeDeployedVersionStatus({
		publishedFingerprint,
		servedFingerprint: null
	});
	try {
		const response = await fetch(new URL("/.well-known/version", hostUrl));
		if (!response.ok) return computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: null,
			servedError: `version endpoint returned ${response.status}`
		});
		const body = await response.json();
		return computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: body.fingerprint ?? null
		});
	} catch (error) {
		return computeDeployedVersionStatus({
			publishedFingerprint,
			servedFingerprint: null,
			servedError: error instanceof Error ? error.message : String(error)
		});
	}
}

//#endregion
export { registerOps };
//# sourceMappingURL=ops.mjs.map