@akterjs/cli 0.0.0-stage → 0.1.1

package/dist/bench/bench.service.mjs

@@ -0,0 +1,301 @@
+import { C as isReadonlyArrayEmpty, T as join, j as map, r as contains, y as head } from "../Array-B4kuTQeW.mjs";
+import { P as currentTimeMillis } from "../HttpClientResponse-D5ZKICVV.mjs";
+import { n as log, t as error } from "../Console-BKHUkH6a.mjs";
+import { At as provideContext, B as flatMap, Dt as orElseSucceed, Et as orDie, K as forEach, Q as fromOption, R as filterOrFail, T as context, Tt as option, U as fn, Vn as effect, X as forkScoped, Xt as succeed, _r as succeed$1, a as all, aa as Service, dt as map$1, et as gen, hr as make, o as andThen, on as timeoutOrElse, sn as transposeOption, sr as _await, tn as tap, z as findFirst } from "../Effect-CKFpqbmw.mjs";
+import { t as FileSystem } from "../FileSystem-4pPcEb_i.mjs";
+import { S as none, _ as isSome, f as getOrElse, h as isNone, u as fromNullishOr, w as some, x as match } from "../Option-DkxSnBhp.mjs";
+import { t as Path } from "../Path-Djdv_eF5.mjs";
+import { g as take, l as offer, v as unbounded } from "../Queue-CO5UQ6os.mjs";
+import { F as String, I as Struct, S as Literals, X as Unknown, an as optionalKey, cr as getSomes, or as fromEntries, pt as fromJsonString, st as encodeEffect, tt as decodeEffect } from "../Schema-MiKt5K1v.mjs";
+import { i as value } from "../Redacted-RkJrG5Me.mjs";
+import { K as splitLines, O as mapEffect, Q as tick, W as runForEach, c as drop, i as decodeText, l as empty, nt as unwrap, r as concat, u as encodeText, v as fromEffect } from "../Stream-bK9QIETN.mjs";
+import { i as sha256, t as Digest } from "../Digest-CBd3uv5B.mjs";
+import { a as ChildProcessSpawner, n as make$1 } from "../ChildProcess-BCIwxPGc.mjs";
+import { BenchSamples, benchReport, reportLines } from "./bench-report.pure.mjs";
+import { benchRunner } from "./bench-runner.pure.mjs";
+import { Credentials } from "../credentials/credentials.service.mjs";
+import { t as CloudClient } from "../cloud-client.adapter-DOVMoYAj.mjs";
+import { devRunner } from "../dev-runner.pure.mjs";
+import { millisOf } from "../history-since.pure.mjs";
+import { RunnerExitedError } from "../runner-exited.errors.mjs";
+// src/bench/bench.service.ts
+const anyPort = 0;
+const exitedCleanly = 0;
+const usageError = 2;
+const fewestWorkers = 1;
+const loopbackHosts = [
+	"localhost",
+	"127.0.0.1",
+	"[::1]"
+];
+/**
+* How often the runner gets the Cloud session's current token. The session refreshes within 30 s of its one-minute
+* expiry, so a check more often than that hands the runner the new token before the old one lapses.
+*/
+const tokenCheck = "10 seconds";
+const devUrlLine = /akter dev: (?<url>http:\/\/127\.0\.0\.1:\d+),/u;
+const jsonText = encodeEffect(fromJsonString(Unknown));
+const samplesOf = decodeEffect(fromJsonString(BenchSamples));
+const unknown = "unknown";
+const packages = [
+	"@akterjs/cli",
+	"@akterjs/client",
+	"@akterjs/effect",
+	"effect"
+];
+const lockfiles = [
+	"pnpm-lock.yaml",
+	"bun.lock",
+	"package-lock.json"
+];
+const Manifest = fromJsonString(Struct({ version: String }));
+const gitLines = fn("gitLines")(function* gitLines(args) {
+	const spawner = yield* ChildProcessSpawner;
+	const lines = yield* option(spawner.lines(make$1("git", args)));
+	return getOrElse(lines, () => []);
+});
+const nearest = fn("nearest")(function* nearest(directory, names) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const candidates = map(names, (name) => path.join(directory, name));
+	const found = yield* findFirst(candidates, (candidate) => orElseSucceed(fileSystem.exists(candidate), () => false));
+	const parent = path.dirname(directory);
+	if (isSome(found) || parent === directory) return found;
+	return yield* nearest(parent, names);
+});
+const versionOf = fn("versionOf")(function* versionOf(name) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const manifestPath = yield* nearest(path.resolve("."), [path.join("node_modules", name, "package.json")]);
+	const manifest = yield* flatMap(fromOption(manifestPath), (found) => flatMap(fileSystem.readFileString(found), decodeEffect(Manifest))).pipe(option);
+	return [name, match(manifest, {
+		onNone: () => unknown,
+		onSome: ({ version }) => version
+	})];
+});
+const lockfilePin = fn("lockfilePin")(function* lockfilePin() {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const lockfile = yield* nearest(path.resolve("."), lockfiles);
+	if (isNone(lockfile)) return {
+		lockfile: "no lockfile",
+		lockfileSha256: unknown
+	};
+	const bytes = yield* fileSystem.readFile(lockfile.value);
+	const lockfileSha256 = yield* Digest.use((digest) => digest.digestHex(sha256, bytes));
+	return {
+		lockfile: path.relative(path.resolve("."), lockfile.value),
+		lockfileSha256
+	};
+});
+const worktreeOf = (changed) => {
+	if (isReadonlyArrayEmpty(changed)) return "clean";
+	return `${changed.length} uncommitted changes`;
+};
+const benchEnvironment = gen(function* benchEnvironment() {
+	const versions = yield* forEach(packages, versionOf);
+	const commit = yield* map$1(gitLines(["rev-parse", "HEAD"]), head);
+	const changed = yield* gitLines(["status", "--porcelain"]);
+	const lockfile = yield* lockfilePin();
+	return {
+		pins: {
+			commit: getOrElse(commit, () => unknown),
+			...lockfile,
+			worktree: worktreeOf(changed)
+		},
+		versions: fromEntries(versions)
+	};
+});
+const usage = fn("usage")(function* usage(message) {
+	yield* error(`akter bench: ${message}`);
+	return yield* RunnerExitedError.make({ code: usageError });
+});
+const devUrlOf = (lines) => flatMap(take(lines), (line) => match(fromNullishOr(devUrlLine.exec(line)?.groups?.url), {
+	onNone: () => andThen(error(line), devUrlOf(lines)),
+	onSome: succeed
+}));
+const devSource = devRunner({
+	allowedHosts: "[]",
+	directory: "process.argv[2]",
+	entry: "process.argv[3]",
+	environment: "null",
+	inspectorPort: anyPort,
+	port: anyPort
+});
+const writeRunner = fn("writeRunner")(function* writeRunner(name, source) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const runner = path.resolve("node_modules", ".akter", name);
+	yield* fileSystem.makeDirectory(path.dirname(runner), { recursive: true });
+	yield* fileSystem.writeFileString(runner, source);
+	return runner;
+});
+const startDev = fn("startDev")(function* startDev(entry, directory) {
+	const spawner = yield* ChildProcessSpawner;
+	const path = yield* Path;
+	const runner = yield* writeRunner("bench-dev.mjs", devSource);
+	const app = yield* path.toFileUrl(path.resolve(entry));
+	const handle = yield* spawner.spawn(make$1(globalThis.process.execPath, [
+		runner,
+		directory,
+		app.href
+	]));
+	const output = splitLines(decodeText(handle.all));
+	const lines = yield* unbounded();
+	yield* forkScoped(runForEach(output, (line) => offer(lines, line)));
+	return yield* devUrlOf(lines).pipe(timeoutOrElse({
+		duration: "60 seconds",
+		orElse: () => usage("akter dev didn't print its URL within 60 seconds.")
+	}));
+});
+/**
+* Signs in with the CLI's credential (AKTER_API_KEY or akter login) and returns how to read the session's current
+* bearer header, so a run longer than the one-minute token keeps signing its steps.
+*/
+const cloudAuthorization = fn("cloudAuthorization")(function* cloudAuthorization() {
+	const credentials = yield* Credentials;
+	const url = yield* credentials.url(none());
+	const credential = yield* credentials.credentialFor(url);
+	const cloud = yield* CloudClient.use((factory) => factory.connect({
+		apiKey: credential.secret,
+		url
+	}));
+	const current = map$1(cloud.bearer, (token) => `Bearer ${value(token)}`);
+	yield* cloud.signIn;
+	return some(orDie(current));
+});
+const givenTarget = fn("givenTarget")(function* givenTarget(url) {
+	const host = fromNullishOr(globalThis.URL.parse(url)?.hostname);
+	if (isNone(host)) return yield* usage(`--url ${url} is not a URL.`);
+	if (contains(loopbackHosts, host.value)) return {
+		connection: {
+			authorization: none(),
+			kind: "local",
+			url
+		},
+		target: `akter dev at ${url}`
+	};
+	return {
+		connection: {
+			authorization: yield* cloudAuthorization(),
+			kind: "cloud",
+			url
+		},
+		target: `the Akter Cloud app at ${url}`
+	};
+});
+const comparedTarget = (system, url) => match(url, {
+	onNone: () => usage(`--system ${system} needs --url, where the workload reaches it.`),
+	onSome: (given) => succeed({
+		connection: {
+			authorization: none(),
+			kind: "comparison",
+			url: given
+		},
+		target: `${system} at ${given}, for comparison`
+	})
+});
+const targetOf = fn("targetOf")(function* targetOf(options, scratch) {
+	const path = yield* Path;
+	if (isSome(options.system)) return yield* comparedTarget(options.system.value, options.url);
+	if (isSome(options.url)) return yield* givenTarget(options.url.value);
+	const url = yield* startDev(options.entry, path.join(scratch, "data"));
+	return {
+		connection: {
+			authorization: none(),
+			kind: "local",
+			url
+		},
+		target: `akter dev at ${url}, started by akter bench on an empty folder`
+	};
+});
+const RunnerLine = Struct({
+	authorization: optionalKey(String),
+	kind: optionalKey(Literals([
+		"cloud",
+		"comparison",
+		"local"
+	])),
+	url: optionalKey(String)
+});
+const encodeLine = encodeEffect(fromJsonString(RunnerLine));
+const lineOf = (line) => map$1(orDie(encodeLine(line)), (json) => `${json}\n`);
+const sentFirst = 1;
+const runnerInput = ({ authorization, kind, url }) => {
+	const first = flatMap(transposeOption(authorization), (header) => lineOf({
+		kind,
+		url,
+		...getSomes({ authorization: header })
+	}));
+	const refreshed = match(authorization, {
+		onNone: () => empty,
+		onSome: (current) => tick(tokenCheck).pipe(drop(sentFirst), mapEffect(() => flatMap(current, (header) => lineOf({ authorization: header }))))
+	});
+	return concat(fromEffect(first), refreshed);
+};
+const runRunner = fn("runRunner")(function* runRunner(config, connection) {
+	const spawner = yield* ChildProcessSpawner;
+	const runner = yield* writeRunner("bench.mjs", benchRunner);
+	const input = unwrap(map$1(_await(connection), runnerInput));
+	const io = {
+		stderr: "inherit",
+		stdin: encodeText(input),
+		stdout: "inherit"
+	};
+	const command = make$1(globalThis.process.execPath, [runner, config], io);
+	return yield* spawner.exitCode(command).pipe(filterOrFail((code) => code === exitedCleanly, (code) => RunnerExitedError.make({ code })));
+});
+const sampled = fn("sampled")(function* sampled(options, timing, scratch) {
+	const fileSystem = yield* FileSystem;
+	const path = yield* Path;
+	const now = yield* currentTimeMillis;
+	const workload = yield* path.toFileUrl(path.resolve(options.workload));
+	const config = {
+		concurrency: options.concurrency,
+		durationMillis: timing.durationMillis,
+		id: `bench-${now}`,
+		out: path.join(scratch, "samples.json"),
+		stepTimeoutMillis: timing.stepTimeoutMillis,
+		workload: workload.href
+	};
+	const connection = yield* make();
+	const [targeted] = yield* all([tap(targetOf(options, scratch), (started) => succeed$1(connection, started.connection)), flatMap(jsonText(config), (json) => runRunner(json, connection))], { concurrency: 2 });
+	const run = yield* flatMap(fileSystem.readFileString(config.out), samplesOf);
+	return {
+		kind: targeted.connection.kind,
+		run,
+		target: targeted.target
+	};
+});
+const printed = (report, json) => {
+	if (json) return flatMap(jsonText(report), log);
+	return log(join(reportLines(report), "\n"));
+};
+const runBench = fn("runBench")(function* runBench(options) {
+	const durationMillis = getOrElse(millisOf(options.duration), () => anyPort);
+	const stepTimeoutMillis = getOrElse(millisOf(options.stepTimeout), () => anyPort);
+	if (durationMillis <= anyPort || stepTimeoutMillis <= anyPort || options.concurrency < fewestWorkers) return yield* usage("--duration and --step-timeout take a whole number and a unit, like 30s or 5m, and --concurrency at least 1.");
+	const scratch = yield* (yield* FileSystem).makeTempDirectoryScoped({ prefix: "akter-bench-" });
+	const [{ kind, run, target }, environment] = yield* all([sampled(options, {
+		durationMillis,
+		stepTimeoutMillis
+	}, scratch), benchEnvironment], { concurrency: 2 });
+	const report = benchReport({
+		environment,
+		run,
+		settings: {
+			concurrency: options.concurrency,
+			durationMillis,
+			kind,
+			target
+		}
+	});
+	return yield* printed(report, options.json);
+});
+var Bench = class extends Service()("@akterjs/cli/bench/bench.service/Bench", { make: gen(function* makeBench() {
+	const context$1 = yield* context();
+	return { run: (options) => provideContext(runBench(options), context$1) };
+}) }) {
+	static layer = effect(this, this.make);
+};
+export { Bench };