ecopages 0.2.0-alpha.9 → 0.2.0-beta.0

package/bin/launch-plan.js

@@ -1,142 +1,84 @@
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const NODE_THIN_HOST_PATH = fileURLToPath(new URL('./node-thin-host.js', import.meta.url));
-const DEFAULT_INTERNAL_WORK_DIR = '.eco';
-
-export function buildEnvOverrides(options) {
-	const env = {};
-	if (options.port) env.ECOPAGES_PORT = String(options.port);
-	if (options.hostname) env.ECOPAGES_HOSTNAME = options.hostname;
-	if (options.baseUrl) env.ECOPAGES_BASE_URL = options.baseUrl;
-	if (options.debug) env.ECOPAGES_LOGGER_DEBUG = 'true';
-	if (options.nodeEnv) env.NODE_ENV = options.nodeEnv;
-	return env;
+import { existsSync, readFileSync } from "node:fs";
+import { parseEnv } from "node:util";
+const nodeRequirePreload = import.meta.resolve("./node-require-preload.js");
+const tsxLoader = import.meta.resolve("tsx/esm");
+function getEnvFilePaths(nodeEnv) {
+  const envFiles = [".env", ".env.local"];
+  if (nodeEnv) {
+    envFiles.push(`.env.${nodeEnv}`, `.env.${nodeEnv}.local`);
+  }
+  return envFiles.filter((envFile) => existsSync(envFile));
 }
-
-export function detectRuntime(options = {}) {
-	if (options.runtime === 'bun' || options.runtime === 'node' || options.runtime === 'node-experimental') {
-		return options.runtime;
-	}
-
-	const userAgent = process.env.npm_config_user_agent || '';
-
-	if (userAgent.startsWith('bun/')) {
-		return 'bun';
-	}
-
-	if (typeof Bun !== 'undefined') {
-		return 'bun';
-	}
-
-	return 'node';
+function buildEnvOverrides(options) {
+  const env = {};
+  if (options.port) env.ECOPAGES_PORT = String(options.port);
+  if (options.hostname) env.ECOPAGES_HOSTNAME = options.hostname;
+  if (options.baseUrl) env.ECOPAGES_BASE_URL = options.baseUrl;
+  if (options.debug) env.ECOPAGES_LOGGER_DEBUG = "true";
+  if (options.nodeEnv) env.NODE_ENV = options.nodeEnv;
+  return env;
 }
-
-export function buildBunArgs(args, options, entryFile, hasConfig) {
-	const bunArgs = [];
-
-	if (options.watch) bunArgs.push('--watch');
-	if (options.hot) bunArgs.push('--hot');
-
-	bunArgs.push('run');
-
-	if (hasConfig) {
-		bunArgs.push('--preload', 'eco.config.ts');
-	}
-
-	bunArgs.push(entryFile, ...args);
-
-	if (options.reactFastRefresh) {
-		bunArgs.push('--react-fast-refresh');
-	}
-
-	return bunArgs;
+function buildLaunchEnv(options) {
+  const envOverrides = buildEnvOverrides(options);
+  const envFileValues = getEnvFilePaths(options.nodeEnv).reduce((env, envFile) => {
+    return { ...env, ...parseEnv(readFileSync(envFile, "utf8")) };
+  }, {});
+  return {
+    envOverrides,
+    env: { ...envFileValues, ...process.env, ...envOverrides }
+  };
 }
-
-export function buildNodeArgs(args, options, entryFile) {
-	const nodeArgs = [];
-
-	if (options.watch) nodeArgs.push('--watch');
-
-	nodeArgs.push(NODE_THIN_HOST_PATH, entryFile, ...args);
-
-	if (options.reactFastRefresh) {
-		nodeArgs.push('--react-fast-refresh');
-	}
-
-	return nodeArgs;
+function detectRuntime(options = {}) {
+  if (options.runtime === "bun" || options.runtime === "node") {
+    return options.runtime;
+  }
+  const userAgent = process.env.npm_config_user_agent || "";
+  if (userAgent.startsWith("bun/")) {
+    return "bun";
+  }
+  if (typeof Bun !== "undefined") {
+    return "bun";
+  }
+  return "node";
 }
-
-export function resolveNodeRuntimeManifestPath(projectDir = process.cwd()) {
-	return path.join(path.resolve(projectDir), DEFAULT_INTERNAL_WORK_DIR, 'runtime', 'node-runtime-manifest.json');
+function buildBunArgs(args, options, entryFile, hasConfig) {
+  const bunArgs = [];
+  if (options.watch) bunArgs.push("--watch");
+  if (options.hot) bunArgs.push("--hot");
+  bunArgs.push("run");
+  if (hasConfig) {
+    bunArgs.push("--preload", `./eco.config.${"ts"}`);
+  }
+  bunArgs.push(entryFile, ...args);
+  if (options.reactFastRefresh) {
+    bunArgs.push("--react-fast-refresh");
+  }
+  return bunArgs;
 }
-
-export async function createNodeRuntimeManifestFile(
-	entryFile,
-	options = {
-		cwd: process.cwd(),
-		env: process.env,
-	},
-) {
-	const projectDir = path.resolve(options.cwd ?? process.cwd());
-	const configPath = path.join(projectDir, 'eco.config.ts');
-	const manifestFilePath = options.manifestFilePath ?? resolveNodeRuntimeManifestPath(projectDir);
-
-	if (!existsSync(configPath)) {
-		throw new Error('The Node thin-host runtime requires eco.config.ts in the current project root.');
-	}
-
-	const manifest = {
-		runtime: 'node',
-		appRootDir: projectDir,
-		sourceRootDir: path.join(projectDir, 'src'),
-		distDir: path.join(projectDir, 'dist'),
-		workDir: path.join(projectDir, DEFAULT_INTERNAL_WORK_DIR),
-		modulePaths: {
-			config: configPath,
-			entry: path.resolve(projectDir, entryFile),
-		},
-	};
-
-	mkdirSync(path.dirname(manifestFilePath), { recursive: true });
-	writeFileSync(manifestFilePath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
-
-	return manifestFilePath;
-}
-
-export async function createLaunchPlan(args, options = {}, entryFile = 'app.ts') {
-	const hasConfig = existsSync('eco.config.ts');
-	const envOverrides = buildEnvOverrides(options);
-	const runtime = detectRuntime(options);
-	const env = { ...process.env, ...envOverrides };
-
-	if (runtime === 'node' || runtime === 'node-experimental') {
-		const manifestFilePath = await createNodeRuntimeManifestFile(entryFile, { env });
-
-		return {
-			runtime,
-			executionStrategy: 'node-thin-host',
-			command: 'node',
-			commandArgs: buildNodeArgs(args, options, entryFile),
-			envOverrides,
-			env: {
-				...env,
-				ECOPAGES_NODE_RUNTIME_MANIFEST_PATH: manifestFilePath,
-			},
-		};
-	}
-
-	return {
-		runtime,
-		executionStrategy: 'direct-runtime',
-		command: 'bun',
-		commandArgs: buildBunArgs(args, options, entryFile, hasConfig),
-		envOverrides,
-		env,
-	};
-}
-
-export function launchPlanRequiresExistingEntryFile(launchPlan) {
-	return launchPlan.executionStrategy !== 'config-only-bootstrap';
+function createLaunchPlan(args, options = {}, entryFile = "app.ts") {
+  const { envOverrides, env } = buildLaunchEnv(options);
+  const runtime = detectRuntime(options);
+  if (runtime === "node") {
+    return {
+      runtime,
+      command: process.execPath,
+      commandArgs: ["--import", nodeRequirePreload, "--import", tsxLoader, entryFile, ...args],
+      envOverrides,
+      env
+    };
+  }
+  return {
+    runtime,
+    command: "bun",
+    commandArgs: buildBunArgs(args, options, entryFile, existsSync("eco.config.ts")),
+    envOverrides,
+    env
+  };
 }
+export {
+  buildBunArgs,
+  buildEnvOverrides,
+  buildLaunchEnv,
+  createLaunchPlan,
+  detectRuntime
+};

package/bin/node-require-preload.js

@@ -0,0 +1,3 @@
+import path from "node:path";
+import { createRequire } from "node:module";
+globalThis.require = createRequire(path.join(process.cwd(), "package.json"));

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "ecopages",
-  "version": "0.2.0-alpha.9",
+  "version": "0.2.0-beta.0",
   "description": "CLI utilities for Ecopages",
   "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "license": "MIT",
   "author": "Ecopages Team",
   "repository": {
@@ -28,17 +31,11 @@
   "bin": {
     "ecopages": "bin/cli.js"
   },
-  "files": [
-    "bin/",
-    "css/",
-    "README.md"
-  ],
   "dependencies": {
-    "@ecopages/core": "workspace:*",
-    "esbuild": "^0.27.3",
-    "commander": "^12.1.0",
-    "tiged": "^2.12.7",
-    "@ecopages/logger": "^0.2.2"
+    "@ecopages/core": "0.2.0-beta.0",
+    "@ecopages/logger": "^0.2.3",
+    "giget": "^2.0.0",
+    "tsx": "^4.22.3"
   },
   "peerDependencies": {
     "bun-types": "*",

package/bin/launch-plan.test.ts

@@ -1,316 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { afterEach, describe, expect, it } from 'vitest';
-import {
-	buildEnvOverrides,
-	buildNodeArgs,
-	buildBunArgs,
-	createNodeRuntimeManifestFile,
-	createLaunchPlan,
-	detectRuntime,
-	launchPlanRequiresExistingEntryFile,
-	resolveNodeRuntimeManifestPath,
-} from './launch-plan.js';
-
-const originalUserAgent = process.env.npm_config_user_agent;
-
-afterEach(() => {
-	if (originalUserAgent === undefined) {
-		delete process.env.npm_config_user_agent;
-	} else {
-		process.env.npm_config_user_agent = originalUserAgent;
-	}
-	process.chdir('/Users/andeeplus/github/ecopages');
-});
-
-describe('launch-plan', () => {
-	function writeExperimentalRuntimeConfig(tempDir) {
-		fs.writeFileSync(
-			path.join(tempDir, 'eco.config.ts'),
-			[
-				'const rootDir = process.cwd();',
-				'export default {',
-				'\trootDir,',
-				'\tloaders: new Map(),',
-				'\tabsolutePaths: {',
-				'\t\tconfig: `${rootDir}/eco.config.ts`,',
-				'\t\tsrcDir: `${rootDir}/src`,',
-				'\t\tdistDir: `${rootDir}/dist`,',
-				'\t\tworkDir: `${rootDir}/.eco`,',
-				'\t},',
-				'\truntime: {},',
-				'};',
-			].join('\n'),
-			'utf8',
-		);
-	}
-
-	function writeImportMetaRuntimeConfig(tempDir) {
-		fs.writeFileSync(
-			path.join(tempDir, 'eco.config.ts'),
-			[
-				"import path from 'node:path';",
-				'export default {',
-				'\trootDir: import.meta.dirname,',
-				'\tloaders: new Map(),',
-				'\tabsolutePaths: {',
-				"\t\tconfig: path.join(import.meta.dirname, 'eco.config.ts'),",
-				"\t\tsrcDir: path.join(import.meta.dirname, 'src'),",
-				"\t\tdistDir: path.join(import.meta.dirname, 'dist'),",
-				"\t\tworkDir: path.join(import.meta.dirname, '.eco'),",
-				'\t},',
-				'\truntime: {},',
-				'};',
-			].join('\n'),
-			'utf8',
-		);
-	}
-
-	it('buildEnvOverrides maps CLI options onto environment variables', () => {
-		expect(
-			buildEnvOverrides({
-				port: 4173,
-				hostname: '127.0.0.1',
-				baseUrl: 'https://example.test',
-				debug: true,
-				nodeEnv: 'production',
-			}),
-		).toEqual({
-			ECOPAGES_PORT: '4173',
-			ECOPAGES_HOSTNAME: '127.0.0.1',
-			ECOPAGES_BASE_URL: 'https://example.test',
-			ECOPAGES_LOGGER_DEBUG: 'true',
-			NODE_ENV: 'production',
-		});
-	});
-
-	it('detectRuntime defaults to node unless bun is explicit', () => {
-		process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
-		expect(detectRuntime()).toBe('node');
-		expect(detectRuntime({ runtime: 'bun' })).toBe('bun');
-		expect(detectRuntime({ runtime: 'node' })).toBe('node');
-		expect(detectRuntime({ runtime: 'node-experimental' })).toBe('node-experimental');
-	});
-
-	it('buildNodeArgs preserves watch mode and fast refresh flags', () => {
-		expect(buildNodeArgs(['--dev'], { watch: true, reactFastRefresh: true }, 'app.ts')).toEqual([
-			'--watch',
-			expect.stringMatching(/node-thin-host\.js$/),
-			'app.ts',
-			'--dev',
-			'--react-fast-refresh',
-		]);
-	});
-
-	it('buildNodeArgs routes stable Node through the thin launcher', () => {
-		expect(buildNodeArgs(['--dev'], { watch: true }, 'app.ts')).toEqual([
-			'--watch',
-			expect.stringMatching(/node-thin-host\.js$/),
-			'app.ts',
-			'--dev',
-		]);
-	});
-
-	it('buildBunArgs preloads eco.config.ts when present', () => {
-		expect(buildBunArgs(['--dev'], { hot: true }, 'app.ts', true)).toEqual([
-			'--hot',
-			'run',
-			'--preload',
-			'eco.config.ts',
-			'app.ts',
-			'--dev',
-		]);
-	});
-
-	it('createLaunchPlan routes node app launches through the thin host', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			fs.writeFileSync(
-				path.join(tempDir, 'app.ts'),
-				[
-					"import { EcopagesApp } from '@ecopages/core';",
-					"import appConfig from './eco.config';",
-					'const app = new EcopagesApp({ appConfig });',
-					'await app.start();',
-				].join('\n'),
-				'utf8',
-			);
-			const plan = await createLaunchPlan(['--dev'], { watch: true, nodeEnv: 'development' }, 'app.ts');
-
-			expect(plan).toMatchObject({
-				runtime: 'node',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
-				envOverrides: { NODE_ENV: 'development' },
-			});
-			expect(plan.commandArgs).toEqual([
-				'--watch',
-				expect.stringMatching(/node-thin-host\.js$/),
-				'app.ts',
-				'--dev',
-			]);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createLaunchPlan preserves direct node entrypoints on the thin-host path', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
-			process.chdir(tempDir);
-			fs.writeFileSync(path.join(tempDir, 'server.ts'), 'await Promise.resolve();', 'utf8');
-			writeExperimentalRuntimeConfig(tempDir);
-
-			const plan = await createLaunchPlan(['--dev'], { watch: true }, 'server.ts');
-
-			expect(plan).toMatchObject({
-				runtime: 'node',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
-			});
-			expect(plan.commandArgs).toEqual([
-				'--watch',
-				expect.stringMatching(/node-thin-host\.js$/),
-				'server.ts',
-				'--dev',
-			]);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createLaunchPlan uses bun direct runtime and preloads eco.config.ts', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			fs.writeFileSync(path.join(tempDir, 'app.ts'), 'await Promise.resolve();', 'utf8');
-			writeExperimentalRuntimeConfig(tempDir);
-
-			const plan = await createLaunchPlan(['--preview'], { runtime: 'bun' }, 'app.ts');
-
-			expect(plan).toMatchObject({
-				runtime: 'bun',
-				executionStrategy: 'direct-runtime',
-				command: 'bun',
-			});
-			expect(plan.commandArgs).toEqual(['run', '--preload', 'eco.config.ts', 'app.ts', '--preview']);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createNodeRuntimeManifestFile writes the core-owned manifest under .eco/runtime', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			const manifestFilePath = await createNodeRuntimeManifestFile('app.ts');
-			const manifest = JSON.parse(fs.readFileSync(manifestFilePath, 'utf8'));
-			const resolvedTempDir = fs.realpathSync(tempDir);
-
-			expect(manifestFilePath).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(manifest).toMatchObject({
-				runtime: 'node',
-				appRootDir: resolvedTempDir,
-				sourceRootDir: path.join(resolvedTempDir, 'src'),
-				distDir: path.join(resolvedTempDir, 'dist'),
-				workDir: path.join(resolvedTempDir, '.eco'),
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createNodeRuntimeManifestFile does not evaluate eco.config.ts while writing the manifest', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeImportMetaRuntimeConfig(tempDir);
-			const manifestFilePath = await createNodeRuntimeManifestFile('app.ts');
-			const manifest = JSON.parse(fs.readFileSync(manifestFilePath, 'utf8'));
-			const resolvedTempDir = fs.realpathSync(tempDir);
-
-			expect(manifestFilePath).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(manifest).toMatchObject({
-				appRootDir: resolvedTempDir,
-				sourceRootDir: path.join(resolvedTempDir, 'src'),
-				distDir: path.join(resolvedTempDir, 'dist'),
-				workDir: path.join(resolvedTempDir, '.eco'),
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('createLaunchPlan routes node-experimental through the thin host launcher', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.chdir(tempDir);
-			writeExperimentalRuntimeConfig(tempDir);
-			const resolvedTempDir = fs.realpathSync(tempDir);
-			const plan = await createLaunchPlan(
-				['--dev'],
-				{ runtime: 'node-experimental', nodeEnv: 'development' },
-				'app.ts',
-			);
-
-			expect(plan).toMatchObject({
-				runtime: 'node-experimental',
-				executionStrategy: 'node-thin-host',
-				command: 'node',
-				envOverrides: { NODE_ENV: 'development' },
-			});
-			expect(plan.commandArgs).toEqual([expect.stringMatching(/node-thin-host\.js$/), 'app.ts', '--dev']);
-			expect(plan.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH).toBe(resolveNodeRuntimeManifestPath(resolvedTempDir));
-			expect(JSON.parse(fs.readFileSync(plan.env.ECOPAGES_NODE_RUNTIME_MANIFEST_PATH, 'utf8'))).toMatchObject({
-				runtime: 'node',
-				modulePaths: {
-					config: path.join(resolvedTempDir, 'eco.config.ts'),
-					entry: path.join(resolvedTempDir, 'app.ts'),
-				},
-			});
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-
-	it('launchPlanRequiresExistingEntryFile requires a concrete entry on every runtime path', async () => {
-		const tempDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-cli-launch-plan-'));
-		try {
-			process.env.npm_config_user_agent = 'pnpm/10.0.0 npm/? node/v24.0.0 darwin arm64';
-			process.chdir(tempDir);
-			fs.writeFileSync(path.join(tempDir, 'app.ts'), 'await Promise.resolve();', 'utf8');
-			writeExperimentalRuntimeConfig(tempDir);
-
-			const nodePlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'app.ts');
-			expect(nodePlan.executionStrategy).toBe('node-thin-host');
-			expect(launchPlanRequiresExistingEntryFile(nodePlan)).toBe(true);
-
-			fs.writeFileSync(path.join(tempDir, 'server.ts'), 'await Promise.resolve();', 'utf8');
-			const directNodePlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'server.ts');
-			expect(directNodePlan.executionStrategy).toBe('node-thin-host');
-			expect(launchPlanRequiresExistingEntryFile(directNodePlan)).toBe(true);
-
-			const bunPlan = await createLaunchPlan(['--dev'], { runtime: 'bun' }, 'app.ts');
-			expect(launchPlanRequiresExistingEntryFile(bunPlan)).toBe(true);
-
-			const experimentalNodePlan = await createLaunchPlan(['--dev'], { runtime: 'node-experimental' }, 'app.ts');
-			expect(launchPlanRequiresExistingEntryFile(experimentalNodePlan)).toBe(true);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-});