env-runner 0.0.0 → 0.1.1

package/dist/runners/bun-process/runner.mjs

@@ -0,0 +1,138 @@
+import "../../_chunks/libs/std-env.mjs";
+import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { existsSync } from "node:fs";
+import { execSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { homedir } from "node:os";
+//#region src/runners/bun-process/runner.ts
+let _defaultEntry;
+let _bunPath;
+const _isBun = typeof Bun !== "undefined";
+function resolveBunPath() {
+	if (_bunPath) return _bunPath;
+	const candidates = [join(homedir(), ".bun", "bin", "bun")];
+	for (const p of candidates) if (existsSync(p)) return _bunPath = p;
+	try {
+		const resolved = execSync("which bun", { encoding: "utf8" }).trim();
+		if (resolved) return _bunPath = resolved;
+	} catch {}
+	return _bunPath = "bun";
+}
+var BunProcessEnvRunner = class extends BaseEnvRunner {
+	#process;
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/bun-process/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+		this.#initProcess(opts.execArgv);
+	}
+	sendMessage(message) {
+		if (!this.#process) throw new Error("Bun env process should be initialized before sending messages.");
+		this.#process.send(message);
+	}
+	_hasRuntime() {
+		return Boolean(this.#process);
+	}
+	_runtimeType() {
+		return "process";
+	}
+	async _closeRuntime() {
+		if (!this.#process) return;
+		if (this.#process._exitCode == null) await this._requestGracefulShutdown(() => {
+			try {
+				this.#process.send({ event: "shutdown" });
+			} catch {}
+		}, (resolve) => {
+			this.#process?.exited.then(() => resolve());
+		}, () => this.#process?._exitCode != null);
+		this.#process.removeAllListeners?.();
+		try {
+			this.#process.kill();
+		} catch {}
+		this.#process = void 0;
+	}
+	#initProcess(execArgv) {
+		if (!existsSync(this._workerEntry)) {
+			this.close(`process entry not found in "${this._workerEntry}".`);
+			return;
+		}
+		const env = {
+			...process.env,
+			ENV_RUNNER_NAME: this._name,
+			ENV_RUNNER_DATA: JSON.stringify(this._data || {})
+		};
+		if (_isBun) this.#initBunProcess(execArgv, env);
+		else this.#initNodeProcess(execArgv, env);
+	}
+	#initBunProcess(execArgv, env) {
+		const proc = Bun.spawn({
+			cmd: [
+				resolveBunPath(),
+				...execArgv || [],
+				this._workerEntry
+			],
+			env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			],
+			ipc: (message) => {
+				this._handleMessage(message);
+			}
+		});
+		const child = {
+			pid: proc.pid,
+			kill: () => proc.kill(),
+			send: (message) => proc.send(message),
+			exited: proc.exited,
+			_exitCode: void 0
+		};
+		proc.exited.then((code) => {
+			child._exitCode = code;
+			this.close(`process exited with code ${code}`);
+		});
+		this.#process = child;
+	}
+	#initNodeProcess(execArgv, env) {
+		const child = spawn(resolveBunPath(), [...execArgv || [], this._workerEntry], {
+			env,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe",
+				"ipc"
+			]
+		});
+		const exited = new Promise((resolve) => {
+			child.once("exit", (code) => resolve(code ?? 1));
+		});
+		const handle = {
+			pid: child.pid,
+			kill: () => child.kill(),
+			send: (message) => child.send(message),
+			exited,
+			_exitCode: void 0,
+			removeAllListeners: () => child.removeAllListeners()
+		};
+		child.once("exit", (code) => {
+			handle._exitCode = code;
+			this.close(`process exited with code ${code}`);
+		});
+		child.on("error", (error) => {
+			if (!this.closed) {
+				console.error(`Process error:`, error);
+				this.close(error);
+			}
+		});
+		child.on("message", (message) => {
+			this._handleMessage(message);
+		});
+		this.#process = handle;
+	}
+};
+//#endregion
+export { BunProcessEnvRunner };

package/dist/runners/bun-process/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/bun-process/worker.mjs

@@ -0,0 +1,34 @@
+import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { serve } from "srvx";
+//#region src/runners/bun-process/worker.ts
+const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const server = serve({
+	port: 0,
+	hostname: "127.0.0.1",
+	silent: true,
+	fetch: entry.fetch,
+	middleware: entry.middleware,
+	plugins: entry.plugins,
+	gracefulShutdown: false
+});
+await server.ready();
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+process.send({ address: parseServerAddress(server) });
+process.on("message", (message) => {
+	if (message?.event === "shutdown") {
+		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			process.send({ event: "exit" });
+		});
+		return;
+	}
+	if (message?.type === "ping") {
+		process.send({
+			type: "pong",
+			data: message.data
+		});
+		return;
+	}
+	entry.ipc?.onMessage?.(message);
+});
+//#endregion
+export {};

package/dist/runners/deno-process/runner.d.mts

@@ -0,0 +1,3 @@
+import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { t as DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
+export { DenoProcessEnvRunner, EnvRunnerData as DenoProcessEnvRunnerData };

package/dist/runners/deno-process/runner.mjs

@@ -0,0 +1,4 @@
+import "../../_chunks/libs/std-env.mjs";
+import "../../_chunks/base-runner.mjs";
+import { t as DenoProcessEnvRunner } from "../../_chunks/runner.mjs";
+export { DenoProcessEnvRunner };

package/dist/runners/deno-process/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/deno-process/worker.mjs

@@ -0,0 +1,34 @@
+import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { serve } from "srvx";
+//#region src/runners/deno-process/worker.ts
+const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const server = serve({
+	port: 0,
+	hostname: "127.0.0.1",
+	silent: true,
+	fetch: entry.fetch,
+	middleware: entry.middleware,
+	plugins: entry.plugins,
+	gracefulShutdown: false
+});
+await server.ready();
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+process.send({ address: parseServerAddress(server) });
+process.on("message", (message) => {
+	if (message?.event === "shutdown") {
+		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			process.send({ event: "exit" });
+		});
+		return;
+	}
+	if (message?.type === "ping") {
+		process.send({
+			type: "pong",
+			data: message.data
+		});
+		return;
+	}
+	entry.ipc?.onMessage?.(message);
+});
+//#endregion
+export {};

package/dist/runners/miniflare/runner.d.mts

@@ -0,0 +1,3 @@
+import { n as EnvRunnerData } from "../../_chunks/base-runner.mjs";
+import { n as MiniflareEnvRunnerOptions, t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
+export { MiniflareEnvRunner, EnvRunnerData as MiniflareEnvRunnerData, MiniflareEnvRunnerOptions };

package/dist/runners/miniflare/runner.mjs

@@ -0,0 +1,4 @@
+import "../../_chunks/libs/std-env.mjs";
+import "../../_chunks/base-runner.mjs";
+import { t as MiniflareEnvRunner } from "../../_chunks/runner2.mjs";
+export { MiniflareEnvRunner };

package/dist/runners/node-process/runner.d.mts

@@ -0,0 +1,19 @@
+import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+
+//#region src/runners/node-process/runner.d.ts
+declare class NodeProcessEnvRunner extends BaseEnvRunner {
+  #private;
+  constructor(opts: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+    execArgv?: string[];
+  });
+  sendMessage(message: unknown): void;
+  protected _hasRuntime(): boolean;
+  protected _runtimeType(): string;
+  protected _closeRuntime(): Promise<void>;
+}
+//#endregion
+export { NodeProcessEnvRunner, type EnvRunnerData as ProcessEnvRunnerData };

package/dist/runners/node-process/runner.mjs

@@ -0,0 +1,73 @@
+import "../../_chunks/libs/std-env.mjs";
+import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { existsSync } from "node:fs";
+import { fork } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region src/runners/node-process/runner.ts
+let _defaultEntry;
+var NodeProcessEnvRunner = class extends BaseEnvRunner {
+	#process;
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/node-process/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+		this.#initProcess(opts.execArgv);
+	}
+	sendMessage(message) {
+		if (!this.#process) throw new Error("Node env process should be initialized before sending messages.");
+		this.#process.send(message);
+	}
+	_hasRuntime() {
+		return Boolean(this.#process);
+	}
+	_runtimeType() {
+		return "process";
+	}
+	async _closeRuntime() {
+		if (!this.#process) return;
+		await this._requestGracefulShutdown(() => this.#process.send({ event: "shutdown" }), (resolve) => {
+			this.#process?.on("message", (message) => {
+				if (message.event === "exit") resolve();
+			});
+		}, () => this.#process?._exitCode != null);
+		this.#process.removeAllListeners();
+		this.#process.kill();
+		this.#process = void 0;
+	}
+	#initProcess(execArgv) {
+		if (!existsSync(this._workerEntry)) {
+			this.close(`process entry not found in "${this._workerEntry}".`);
+			return;
+		}
+		const child = fork(this._workerEntry, [], {
+			env: {
+				...process.env,
+				ENV_RUNNER_NAME: this._name,
+				ENV_RUNNER_DATA: JSON.stringify(this._data || {})
+			},
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe",
+				"ipc"
+			],
+			execArgv: execArgv || []
+		});
+		child.once("exit", (code) => {
+			child._exitCode = code;
+			this.close(`process exited with code ${code}`);
+		});
+		child.once("error", (error) => {
+			console.error(`Process error:`, error);
+			this.close(error);
+		});
+		child.on("message", (message) => {
+			this._handleMessage(message);
+		});
+		this.#process = child;
+	}
+};
+//#endregion
+export { NodeProcessEnvRunner };

package/dist/runners/node-process/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/node-process/worker.mjs

@@ -0,0 +1,34 @@
+import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { serve } from "srvx";
+//#region src/runners/node-process/worker.ts
+const entry = await resolveEntry(JSON.parse(process.env.ENV_RUNNER_DATA || "{}").entry);
+const server = serve({
+	port: 0,
+	hostname: "127.0.0.1",
+	silent: true,
+	fetch: entry.fetch,
+	middleware: entry.middleware,
+	plugins: entry.plugins,
+	gracefulShutdown: false
+});
+await server.ready();
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => process.send(message) });
+process.send({ address: parseServerAddress(server) });
+process.on("message", (message) => {
+	if (message?.event === "shutdown") {
+		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			process.send({ event: "exit" });
+		});
+		return;
+	}
+	if (message?.type === "ping") {
+		process.send({
+			type: "pong",
+			data: message.data
+		});
+		return;
+	}
+	entry.ipc?.onMessage?.(message);
+});
+//#endregion
+export {};

package/dist/runners/node-worker/runner.d.mts

@@ -0,0 +1,18 @@
+import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+
+//#region src/runners/node-worker/runner.d.ts
+declare class NodeWorkerEnvRunner extends BaseEnvRunner {
+  #private;
+  constructor(opts: {
+    name: string;
+    workerEntry?: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  sendMessage(message: unknown): void;
+  protected _hasRuntime(): boolean;
+  protected _runtimeType(): string;
+  protected _closeRuntime(): Promise<void>;
+}
+//#endregion
+export { type EnvRunnerData, NodeWorkerEnvRunner };

package/dist/runners/node-worker/runner.mjs

@@ -0,0 +1,68 @@
+import "../../_chunks/libs/std-env.mjs";
+import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+//#region src/runners/node-worker/runner.ts
+let _defaultEntry;
+var NodeWorkerEnvRunner = class extends BaseEnvRunner {
+	#worker;
+	constructor(opts) {
+		_defaultEntry ||= fileURLToPath(import.meta.resolve("env-runner/runners/node-worker/worker"));
+		super({
+			...opts,
+			workerEntry: opts.workerEntry || _defaultEntry
+		});
+		this.#initWorker();
+	}
+	sendMessage(message) {
+		if (!this.#worker) throw new Error("Node env worker should be initialized before sending messages.");
+		this.#worker.postMessage(message);
+	}
+	_hasRuntime() {
+		return Boolean(this.#worker);
+	}
+	_runtimeType() {
+		return "worker";
+	}
+	async _closeRuntime() {
+		if (!this.#worker) return;
+		await this._requestGracefulShutdown(() => this.#worker.postMessage({ event: "shutdown" }), (resolve) => {
+			this.#worker?.on("message", (message) => {
+				if (message.event === "exit") resolve();
+			});
+		}, () => Boolean(this.#worker?._exitCode));
+		this.#worker.removeAllListeners();
+		await this.#worker.terminate().catch((error) => {
+			console.error(error);
+		});
+		this.#worker = void 0;
+	}
+	#initWorker() {
+		if (!existsSync(this._workerEntry)) {
+			this.close(`worker entry not found in "${this._workerEntry}".`);
+			return;
+		}
+		const worker = new Worker(this._workerEntry, {
+			env: { ...process.env },
+			workerData: {
+				name: this._name,
+				...this._data
+			}
+		});
+		worker.once("exit", (code) => {
+			worker._exitCode = code;
+			this.close(`worker exited with code ${code}`);
+		});
+		worker.once("error", (error) => {
+			console.error(`Worker error:`, error);
+			this.close(error);
+		});
+		worker.on("message", (message) => {
+			this._handleMessage(message);
+		});
+		this.#worker = worker;
+	}
+};
+//#endregion
+export { NodeWorkerEnvRunner };

package/dist/runners/node-worker/worker.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/runners/node-worker/worker.mjs

@@ -0,0 +1,35 @@
+import { n as resolveEntry, t as parseServerAddress } from "../../_chunks/worker-utils.mjs";
+import { parentPort, workerData } from "node:worker_threads";
+import { serve } from "srvx";
+//#region src/runners/node-worker/worker.ts
+const entry = await resolveEntry((workerData || {}).entry);
+const server = serve({
+	port: 0,
+	hostname: "127.0.0.1",
+	silent: true,
+	fetch: entry.fetch,
+	middleware: entry.middleware,
+	plugins: entry.plugins,
+	gracefulShutdown: false
+});
+await server.ready();
+if (entry.ipc) await entry.ipc.onOpen?.({ sendMessage: (message) => parentPort?.postMessage(message) });
+parentPort?.postMessage({ address: parseServerAddress(server) });
+parentPort?.on("message", (message) => {
+	if (message?.event === "shutdown") {
+		Promise.resolve(entry.ipc?.onClose?.()).then(() => server.close()).then(() => {
+			parentPort?.postMessage({ event: "exit" });
+		});
+		return;
+	}
+	if (message?.type === "ping") {
+		parentPort?.postMessage({
+			type: "pong",
+			data: message.data
+		});
+		return;
+	}
+	entry.ipc?.onMessage?.(message);
+});
+//#endregion
+export {};

package/dist/runners/self/runner.d.mts

@@ -0,0 +1,18 @@
+import { d as WorkerHooks, n as EnvRunnerData, t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+
+//#region src/runners/self/runner.d.ts
+declare class SelfEnvRunner extends BaseEnvRunner {
+  #private;
+  constructor(opts: {
+    name: string;
+    hooks?: WorkerHooks;
+    data?: EnvRunnerData;
+  });
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  sendMessage(message: unknown): void;
+  protected _hasRuntime(): boolean;
+  protected _runtimeType(): string;
+  protected _closeRuntime(): Promise<void>;
+}
+//#endregion
+export { SelfEnvRunner, type EnvRunnerData as SelfEnvRunnerData };

package/dist/runners/self/runner.mjs

@@ -0,0 +1,66 @@
+import "../../_chunks/libs/std-env.mjs";
+import { t as BaseEnvRunner } from "../../_chunks/base-runner.mjs";
+import { n as resolveEntry } from "../../_chunks/worker-utils.mjs";
+//#region src/runners/self/runner.ts
+var SelfEnvRunner = class extends BaseEnvRunner {
+	#active = false;
+	#entry;
+	constructor(opts) {
+		super({
+			...opts,
+			workerEntry: ""
+		});
+		this.#init();
+	}
+	async fetch(input, init) {
+		if (!this.#entry || this.closed) return new Response("self env runner is unavailable", { status: 503 });
+		const request = input instanceof Request ? input : new Request(input, init);
+		return this.#entry.fetch(request);
+	}
+	sendMessage(message) {
+		if (!this.#active) throw new Error("Self env runner should be initialized before sending messages.");
+		if (message?.type === "ping") {
+			queueMicrotask(() => this._handleMessage({
+				type: "pong",
+				data: message.data
+			}));
+			return;
+		}
+		this.#entry?.ipc?.onMessage?.(message);
+	}
+	_hasRuntime() {
+		return this.#active;
+	}
+	_runtimeType() {
+		return "self";
+	}
+	async _closeRuntime() {
+		if (!this.#active) return;
+		this.#active = false;
+		await this.#entry?.ipc?.onClose?.();
+		this.#entry = void 0;
+	}
+	#init() {
+		const entryPath = this._data?.entry;
+		if (!entryPath) {
+			this.close("self runner requires data.entry");
+			return;
+		}
+		this.#active = true;
+		resolveEntry(entryPath).then(async (entry) => {
+			this.#entry = entry;
+			await entry.ipc?.onOpen?.({ sendMessage: (message) => {
+				queueMicrotask(() => this._handleMessage(message));
+			} });
+			this._handleMessage({ address: {
+				host: "127.0.0.1",
+				port: 0
+			} });
+		}).catch((error) => {
+			console.error("Self runner entry error:", error);
+			this.close(error);
+		});
+	}
+};
+//#endregion
+export { SelfEnvRunner };

package/package.json

@@ -1,4 +1,67 @@
 {
   "name": "env-runner",
-  "version": "0.0.0"
+  "version": "0.1.1",
+  "description": "Generic environment runner for JavaScript runtimes.",
+  "license": "MIT",
+  "repository": "unjs/env-runner",
+  "bin": {
+    "env-runner": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./runners/node-worker": "./dist/runners/node-worker/runner.mjs",
+    "./runners/node-worker/worker": "./dist/runners/node-worker/worker.mjs",
+    "./runners/node-process": "./dist/runners/node-process/runner.mjs",
+    "./runners/node-process/worker": "./dist/runners/node-process/worker.mjs",
+    "./runners/bun-process": "./dist/runners/bun-process/runner.mjs",
+    "./runners/bun-process/worker": "./dist/runners/bun-process/worker.mjs",
+    "./runners/deno-process": "./dist/runners/deno-process/runner.mjs",
+    "./runners/deno-process/worker": "./dist/runners/deno-process/worker.mjs",
+    "./runners/self": "./dist/runners/self/runner.mjs",
+    "./runners/miniflare": "./dist/runners/miniflare/runner.mjs"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "fmt": "automd && oxlint . --fix && oxfmt .",
+    "lint": "oxlint . && oxfmt --check .",
+    "prepack": "pnpm build",
+    "env-runner": "node ./src/cli.ts",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm typecheck && vitest run --coverage",
+    "typecheck": "tsgo --noEmit --skipLibCheck"
+  },
+  "dependencies": {
+    "httpxy": "^0.3.1",
+    "srvx": "^0.11.9"
+  },
+  "devDependencies": {
+    "@types/node": "latest",
+    "@typescript/native-preview": "latest",
+    "@vitest/coverage-v8": "latest",
+    "automd": "latest",
+    "changelogen": "latest",
+    "env-runner-fixture": "link:.",
+    "miniflare": "^4.20260301.1",
+    "obuild": "latest",
+    "oxfmt": "latest",
+    "oxlint": "latest",
+    "std-env": "4.0.0-rc.1",
+    "typescript": "latest",
+    "vitest": "latest"
+  },
+  "peerDependencies": {
+    "miniflare": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "miniflare": {
+      "optional": true
+    }
+  },
+  "packageManager": "pnpm@10.29.3"
 }