ecopages 0.2.0-alpha.29 → 0.2.0-alpha.31

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+All notable changes to `ecopages` are documented here.
+
+> **Note:** Changelog tracking begins at version `0.2.0`. Changes prior to this release are not recorded here but are available in the git history.
+
+## [UNRELEASED] — TBD
+
+### Bug Fixes
+
+- Localized the Node CLI `tsx` runtime dependency so `ecopages` no longer requires a globally installed `tsx` binary.
+
+### Refactoring
+
+- Simplified CLI runtime startup and removed the thin-host bootstrap path; runtime selection now follows explicit `--runtime` overrides, package-manager hints, and Bun availability.

package/bin/cli.js

@@ -1,260 +1,224 @@
 #!/usr/bin/env node
-
-import { defineCommand, runMain } from 'citty';
-import { downloadTemplate } from 'giget';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { spawn } from 'node:child_process';
-import { join } from 'node:path';
-import { Logger } from '@ecopages/logger';
-import { createLaunchPlan, launchPlanRequiresExistingEntryFile } from './launch-plan.js';
-
-const logger = new Logger('[ecopages:cli]', { debug: process.env.ECOPAGES_LOGGER_DEBUG === 'true' });
-
-const pkg = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'));
-
+import { defineCommand, runMain } from "citty";
+import { downloadTemplate } from "giget";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { Logger } from "@ecopages/logger";
+import { createLaunchPlan, launchPlanRequiresExistingEntryFile } from "./launch-plan.js";
+const logger = new Logger("[ecopages:cli]", { debug: process.env.ECOPAGES_LOGGER_DEBUG === "true" });
+const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8"));
 function runLaunchPlan(launchPlan) {
-	if (Object.keys(launchPlan.envOverrides).length > 0) {
-		logger.debug(`Environment overrides: ${JSON.stringify(launchPlan.envOverrides)}`);
-	}
-
-	logger.debug(`Runtime: ${launchPlan.runtime}`);
-	logger.debug(`Running: ${launchPlan.command} ${launchPlan.commandArgs.join(' ')}`);
-
-	const child = spawn(launchPlan.command, launchPlan.commandArgs, {
-		stdio: 'inherit',
-		env: launchPlan.env,
-	});
-
-	child.on('error', (error) => {
-		if (error && error.code === 'ENOENT') {
-			const hint =
-				launchPlan.runtime === 'bun'
-					? 'Install Bun from https://bun.sh to continue.'
-					: 'Reinstall ecopages and its dependencies so the packaged tsx runtime is available for Node.js launches.';
-			logger.error(`Command not found: ${launchPlan.command}. ${hint}`);
-			process.exit(1);
-		}
-
-		logger.error(`Failed to run command: ${error.message}`);
-		process.exit(1);
-	});
-
-	child.on('exit', (code) => {
-		process.exit(code || 0);
-	});
+  if (Object.keys(launchPlan.envOverrides).length > 0) {
+    logger.debug(`Environment overrides: ${JSON.stringify(launchPlan.envOverrides)}`);
+  }
+  logger.debug(`Runtime: ${launchPlan.runtime}`);
+  logger.debug(`Running: ${launchPlan.command} ${launchPlan.commandArgs.join(" ")}`);
+  const child = spawn(launchPlan.command, launchPlan.commandArgs, {
+    stdio: "inherit",
+    env: launchPlan.env
+  });
+  child.on("error", (error) => {
+    if (error && error.code === "ENOENT") {
+      const hint = launchPlan.runtime === "bun" ? "Install Bun from https://bun.sh to continue." : "Reinstall ecopages and its dependencies so the packaged tsx runtime is available for Node.js launches.";
+      logger.error(`Command not found: ${launchPlan.command}. ${hint}`);
+      process.exit(1);
+    }
+    logger.error(`Failed to run command: ${error.message}`);
+    process.exit(1);
+  });
+  child.on("exit", (code) => {
+    process.exit(code || 0);
+  });
 }
-
-/**
- * Launch the entry file via the detected or forced runtime (bun or node).
- * Automatically detects eco.config.ts and applies preloads.
- * @param {string[]} args - Arguments to pass to the entry file
- * @param {object} options - CLI options (watch, hot, port, hostname, etc.)
- * @param {string} entryFile - Entry file to run
- */
-async function runEntryCommand(args, options = {}, entryFile = 'app.ts') {
-	let launchPlan;
-
-	try {
-		launchPlan = await createLaunchPlan(args, options, entryFile);
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		logger.error(message);
-		process.exit(1);
-	}
-
-	if (launchPlanRequiresExistingEntryFile(launchPlan) && !existsSync(entryFile)) {
-		logger.error(`Error: Entry file "${entryFile}" not found in the current directory.`);
-		process.exit(1);
-	}
-
-	runLaunchPlan(launchPlan);
+async function runEntryCommand(args, options = {}, entryFile = "app.ts") {
+  let launchPlan;
+  try {
+    launchPlan = await createLaunchPlan(args, options, entryFile);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(message);
+    process.exit(1);
+  }
+  if (launchPlanRequiresExistingEntryFile(launchPlan) && !existsSync(entryFile)) {
+    logger.error(`Error: Entry file "${entryFile}" not found in the current directory.`);
+    process.exit(1);
+  }
+  runLaunchPlan(launchPlan);
 }
-
-/** Shared server argument definitions for citty commands. */
 const serverArgs = {
-	entry: {
-		type: 'positional',
-		description: 'Entry file',
-		default: 'app.ts',
-	},
-	port: {
-		type: 'string',
-		alias: ['p'],
-		description: 'Override ECOPAGES_PORT',
-	},
-	hostname: {
-		type: 'string',
-		alias: ['n'],
-		description: 'Override ECOPAGES_HOSTNAME',
-	},
-	'base-url': {
-		type: 'string',
-		alias: ['b'],
-		description: 'Override ECOPAGES_BASE_URL',
-	},
-	debug: {
-		type: 'boolean',
-		alias: ['d'],
-		description: 'Enable debug logging (ECOPAGES_LOGGER_DEBUG=true)',
-	},
-	'react-fast-refresh': {
-		type: 'boolean',
-		alias: ['r'],
-		description: 'Enable React Fast Refresh for HMR',
-	},
-	runtime: {
-		type: 'string',
-		description: 'Force a specific runtime (bun or node)',
-	},
+  entry: {
+    type: "positional",
+    description: "Entry file",
+    default: "app.ts"
+  },
+  port: {
+    type: "string",
+    alias: ["p"],
+    description: "Override ECOPAGES_PORT"
+  },
+  hostname: {
+    type: "string",
+    alias: ["n"],
+    description: "Override ECOPAGES_HOSTNAME"
+  },
+  "base-url": {
+    type: "string",
+    alias: ["b"],
+    description: "Override ECOPAGES_BASE_URL"
+  },
+  debug: {
+    type: "boolean",
+    alias: ["d"],
+    description: "Enable debug logging (ECOPAGES_LOGGER_DEBUG=true)"
+  },
+  "react-fast-refresh": {
+    type: "boolean",
+    alias: ["r"],
+    description: "Enable React Fast Refresh for HMR"
+  },
+  runtime: {
+    type: "string",
+    description: "Force a specific runtime (bun or node)"
+  }
 };
-
 const initCommand = defineCommand({
-	meta: {
-		name: 'init',
-		description: 'Initialize a new project from a template',
-	},
-	args: {
-		dir: {
-			type: 'positional',
-			description: 'Target directory name',
-			required: true,
-		},
-		template: {
-			type: 'string',
-			description: 'Template name from ecopages/examples/',
-			default: 'starter-jsx',
-		},
-		repo: {
-			type: 'string',
-			description: 'GitHub repo (user/repo)',
-			default: 'ecopages/ecopages',
-		},
-	},
-	async run({ args }) {
-		const { dir, template, repo } = args;
-
-		if (existsSync(dir)) {
-			logger.error(`Target directory already exists: ${dir}`);
-			process.exit(1);
-		}
-
-		logger.info(`Creating target directory '${dir}'...`);
-
-		try {
-			await downloadTemplate(`github:${repo}/examples/${template}`, {
-				dir,
-				force: true,
-			});
-
-			const pkgPath = join(dir, 'package.json');
-			if (existsSync(pkgPath)) {
-				const projectPkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-				projectPkg.name = dir;
-				writeFileSync(pkgPath, JSON.stringify(projectPkg, null, 2) + '\n');
-				logger.info(`Renamed project to '${dir}'`);
-			}
-
-			logger.info('Project initialized! Run `bun install && bun dev` to start.');
-		} catch (err) {
-			logger.error(`Failed to fetch template: ${err.message}`);
-			process.exit(1);
-		}
-	},
+  meta: {
+    name: "init",
+    description: "Initialize a new project from a template"
+  },
+  args: {
+    dir: {
+      type: "positional",
+      description: "Target directory name",
+      required: true
+    },
+    template: {
+      type: "string",
+      description: "Template name from ecopages/examples/",
+      default: "starter-jsx"
+    },
+    repo: {
+      type: "string",
+      description: "GitHub repo (user/repo)",
+      default: "ecopages/ecopages"
+    }
+  },
+  async run({ args }) {
+    const { dir, template, repo } = args;
+    if (existsSync(dir)) {
+      logger.error(`Target directory already exists: ${dir}`);
+      process.exit(1);
+    }
+    logger.info(`Creating target directory '${dir}'...`);
+    try {
+      await downloadTemplate(`github:${repo}/examples/${template}`, {
+        dir,
+        force: true
+      });
+      const pkgPath = join(dir, "package.json");
+      if (existsSync(pkgPath)) {
+        const projectPkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+        projectPkg.name = dir;
+        writeFileSync(pkgPath, JSON.stringify(projectPkg, null, 2) + "\n");
+        logger.info(`Renamed project to '${dir}'`);
+      }
+      logger.info("Project initialized! Run `bun install && bun dev` to start.");
+    } catch (err) {
+      logger.error(`Failed to fetch template: ${err.message}`);
+      process.exit(1);
+    }
+  }
 });
-
 const devCommand = defineCommand({
-	meta: {
-		name: 'dev',
-		description: 'Start the development server',
-	},
-	args: serverArgs,
-	async run({ args }) {
-		await runEntryCommand(['--dev'], { ...args, nodeEnv: 'development' }, args.entry);
-	},
+  meta: {
+    name: "dev",
+    description: "Start the development server"
+  },
+  args: serverArgs,
+  async run({ args }) {
+    await runEntryCommand(["--dev"], { ...args, nodeEnv: "development" }, args.entry);
+  }
 });
-
 const devWatchCommand = defineCommand({
-	meta: {
-		name: 'dev:watch',
-		description: 'Start the development server with watch mode (restarts on file changes)',
-	},
-	args: serverArgs,
-	async run({ args }) {
-		await runEntryCommand(['--dev'], { ...args, watch: true, nodeEnv: 'development' }, args.entry);
-	},
+  meta: {
+    name: "dev:watch",
+    description: "Start the development server with watch mode (restarts on file changes)"
+  },
+  args: serverArgs,
+  async run({ args }) {
+    await runEntryCommand(["--dev"], { ...args, watch: true, nodeEnv: "development" }, args.entry);
+  }
 });
-
 const devHotCommand = defineCommand({
-	meta: {
-		name: 'dev:hot',
-		description: 'Start the development server with hot reload (HMR without restart)',
-	},
-	args: serverArgs,
-	async run({ args }) {
-		await runEntryCommand(['--dev'], { ...args, hot: true, nodeEnv: 'development' }, args.entry);
-	},
+  meta: {
+    name: "dev:hot",
+    description: "Start the development server with hot reload (HMR without restart)"
+  },
+  args: serverArgs,
+  async run({ args }) {
+    await runEntryCommand(["--dev"], { ...args, hot: true, nodeEnv: "development" }, args.entry);
+  }
 });
-
 const buildCommand = defineCommand({
-	meta: {
-		name: 'build',
-		description: 'Build the project for production',
-	},
-	args: {
-		entry: {
-			type: 'positional',
-			description: 'Entry file',
-			default: 'app.ts',
-		},
-		runtime: {
-			type: 'string',
-			description: 'Force a specific runtime (bun or node)',
-		},
-	},
-	async run({ args }) {
-		await runEntryCommand(['--build'], { nodeEnv: 'production', ...args }, args.entry);
-	},
+  meta: {
+    name: "build",
+    description: "Build the project for production"
+  },
+  args: {
+    entry: {
+      type: "positional",
+      description: "Entry file",
+      default: "app.ts"
+    },
+    runtime: {
+      type: "string",
+      description: "Force a specific runtime (bun or node)"
+    }
+  },
+  async run({ args }) {
+    await runEntryCommand(["--build"], { nodeEnv: "production", ...args }, args.entry);
+  }
 });
-
 const startCommand = defineCommand({
-	meta: {
-		name: 'start',
-		description: 'Start the production server',
-	},
-	args: serverArgs,
-	async run({ args }) {
-		await runEntryCommand([], { ...args, nodeEnv: 'production' }, args.entry);
-	},
+  meta: {
+    name: "start",
+    description: "Start the production server"
+  },
+  args: serverArgs,
+  async run({ args }) {
+    await runEntryCommand([], { ...args, nodeEnv: "production" }, args.entry);
+  }
 });
-
 const previewCommand = defineCommand({
-	meta: {
-		name: 'preview',
-		description: 'Preview the production build',
-	},
-	args: serverArgs,
-	async run({ args }) {
-		await runEntryCommand(['--preview'], { ...args, nodeEnv: 'production' }, args.entry);
-	},
+  meta: {
+    name: "preview",
+    description: "Preview the production build"
+  },
+  args: serverArgs,
+  async run({ args }) {
+    await runEntryCommand(["--preview"], { ...args, nodeEnv: "production" }, args.entry);
+  }
 });
-
-export const mainCommand = defineCommand({
-	meta: {
-		name: 'ecopages',
-		version: pkg.version,
-		description: 'Ecopages CLI utilities',
-	},
-	subCommands: {
-		init: initCommand,
-		dev: devCommand,
-		'dev:watch': devWatchCommand,
-		'dev:hot': devHotCommand,
-		build: buildCommand,
-		start: startCommand,
-		preview: previewCommand,
-	},
+const mainCommand = defineCommand({
+  meta: {
+    name: "ecopages",
+    version: pkg.version,
+    description: "Ecopages CLI utilities"
+  },
+  subCommands: {
+    init: initCommand,
+    dev: devCommand,
+    "dev:watch": devWatchCommand,
+    "dev:hot": devHotCommand,
+    build: buildCommand,
+    start: startCommand,
+    preview: previewCommand
+  }
 });
-
 if (!process.env.VITEST) {
-	runMain(mainCommand);
+  runMain(mainCommand);
 }
+export {
+  mainCommand
+};

package/bin/launch-plan.js

@@ -1,112 +1,96 @@
-import { existsSync } from 'node:fs';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
-
-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 } from "node:fs";
+import { createRequire } from "node:module";
+const require2 = createRequire(import.meta.url);
+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 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';
+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 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 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.js");
+  }
+  bunArgs.push(entryFile, ...args);
+  if (options.reactFastRefresh) {
+    bunArgs.push("--react-fast-refresh");
+  }
+  return bunArgs;
 }
-
-export function buildNodeArgs(args, options, entryFile, hasConfig) {
-	const nodeArgs = [];
-
-	if (hasConfig) {
-		nodeArgs.push('--import', './eco.config.ts');
-	}
-
-	nodeArgs.push(entryFile, ...args);
-
-	if (options.reactFastRefresh) {
-		nodeArgs.push('--react-fast-refresh');
-	}
-
-	return nodeArgs;
+function buildNodeArgs(args, options, entryFile, hasConfig) {
+  const nodeArgs = [];
+  if (hasConfig) {
+    nodeArgs.push("--import", "./eco.config.js");
+  }
+  nodeArgs.push(entryFile, ...args);
+  if (options.reactFastRefresh) {
+    nodeArgs.push("--react-fast-refresh");
+  }
+  return nodeArgs;
 }
-
-export function resolveTsxCliPath() {
-	try {
-		return require.resolve('tsx/cli');
-	} catch {
-		throw new Error(
-			'Unable to resolve the packaged tsx runtime required for Node.js launches. Reinstall ecopages and its dependencies, or use the Bun runtime instead.',
-		);
-	}
+function resolveTsxCliPath() {
+  try {
+    return require2.resolve("tsx/cli");
+  } catch {
+    throw new Error(
+      "Unable to resolve the packaged tsx runtime required for Node.js launches. Reinstall ecopages and its dependencies, or use the Bun runtime instead."
+    );
+  }
 }
-
-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') {
-		const tsxCliPath = resolveTsxCliPath();
-
-		return {
-			runtime,
-			executionStrategy: 'direct-runtime',
-			command: process.execPath,
-			commandArgs: [tsxCliPath, ...buildNodeArgs(args, options, entryFile, hasConfig)],
-			envOverrides,
-			env,
-		};
-	}
-
-	return {
-		runtime,
-		executionStrategy: 'direct-runtime',
-		command: 'bun',
-		commandArgs: buildBunArgs(args, options, entryFile, hasConfig),
-		envOverrides,
-		env,
-	};
+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") {
+    const tsxCliPath = resolveTsxCliPath();
+    return {
+      runtime,
+      executionStrategy: "direct-runtime",
+      command: process.execPath,
+      commandArgs: [tsxCliPath, ...buildNodeArgs(args, options, entryFile, hasConfig)],
+      envOverrides,
+      env
+    };
+  }
+  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 launchPlanRequiresExistingEntryFile(launchPlan) {
+  return launchPlan.executionStrategy !== "config-only-bootstrap";
 }
+export {
+  buildBunArgs,
+  buildEnvOverrides,
+  buildNodeArgs,
+  createLaunchPlan,
+  detectRuntime,
+  launchPlanRequiresExistingEntryFile,
+  resolveTsxCliPath
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ecopages",
-  "version": "0.2.0-alpha.29",
+  "version": "0.2.0-alpha.31",
   "description": "CLI utilities for Ecopages",
   "type": "module",
   "license": "MIT",
@@ -28,13 +28,8 @@
   "bin": {
     "ecopages": "bin/cli.js"
   },
-  "files": [
-    "bin/",
-    "css/",
-    "README.md"
-  ],
   "dependencies": {
-    "@ecopages/core": "workspace:*",
+    "@ecopages/core": "0.2.0-alpha.31",
     "@ecopages/logger": "^0.2.2",
     "citty": "^0.1.6",
     "giget": "^2.0.0",

package/bin/cli.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { runCommand } from 'citty';
-import { mainCommand } from './cli.js';
-import * as giget from 'giget';
-import * as fs from 'node:fs';
-import * as launchPlan from './launch-plan.js';
-
-vi.mock('giget', () => ({
-	downloadTemplate: vi.fn(),
-}));
-
-vi.mock('node:fs', async (importOriginal) => {
-	const actual = await importOriginal<typeof import('node:fs')>();
-	return {
-		...actual,
-		existsSync: vi.fn((path) => actual.existsSync(path)),
-		writeFileSync: vi.fn(),
-	};
-});
-
-vi.mock('./launch-plan.js', () => ({
-	createLaunchPlan: vi.fn(),
-	launchPlanRequiresExistingEntryFile: vi.fn(),
-}));
-
-vi.mock('node:child_process', () => ({
-	spawn: vi.fn().mockImplementation(() => ({
-		on: vi.fn(),
-	})),
-}));
-
-vi.mock('@ecopages/logger', () => ({
-	Logger: class {
-		info = vi.fn();
-		warn = vi.fn();
-		error = vi.fn();
-		debug = vi.fn();
-	},
-}));
-
-describe('CLI Commands', () => {
-	beforeEach(() => {
-		vi.clearAllMocks();
-
-		// Default mocks
-		vi.mocked(fs.existsSync).mockReturnValue(false); // pretend no existing dir
-		vi.mocked(launchPlan.createLaunchPlan).mockResolvedValue({
-			runtime: 'node',
-			command: 'node',
-			commandArgs: [],
-			envOverrides: {},
-			env: {},
-		} as any);
-		vi.mocked(launchPlan.launchPlanRequiresExistingEntryFile).mockReturnValue(false);
-	});
-
-	it('runs init command with default template and repo', async () => {
-		await runCommand(mainCommand, { rawArgs: ['init', 'my-new-project'] });
-		expect(giget.downloadTemplate).toHaveBeenCalledWith('github:ecopages/ecopages/examples/starter-jsx', {
-			dir: 'my-new-project',
-			force: true,
-		});
-	});
-
-	it('runs init command with custom template and repo', async () => {
-		await runCommand(mainCommand, {
-			rawArgs: ['init', 'my-dir', '--template', 'starter-lit', '--repo', 'custom/repo'],
-		});
-		expect(giget.downloadTemplate).toHaveBeenCalledWith('github:custom/repo/examples/starter-lit', {
-			dir: 'my-dir',
-			force: true,
-		});
-	});
-
-	it('runs dev command and passes defaults to launch plan', async () => {
-		await runCommand(mainCommand, { rawArgs: ['dev'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			['--dev'],
-			expect.objectContaining({ nodeEnv: 'development' }),
-			'app.ts',
-		);
-	});
-
-	it('runs dev:hot command', async () => {
-		await runCommand(mainCommand, { rawArgs: ['dev:hot'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			['--dev'],
-			expect.objectContaining({ hot: true, nodeEnv: 'development' }),
-			'app.ts',
-		);
-	});
-
-	it('runs dev:watch command', async () => {
-		await runCommand(mainCommand, { rawArgs: ['dev:watch'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			['--dev'],
-			expect.objectContaining({ watch: true, nodeEnv: 'development' }),
-			'app.ts',
-		);
-	});
-
-	it('runs build command with custom entry file', async () => {
-		await runCommand(mainCommand, { rawArgs: ['build', 'server.ts'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			['--build'],
-			expect.objectContaining({ nodeEnv: 'production' }),
-			'server.ts',
-		);
-	});
-
-	it('passes shared server options like port and hostname correctly', async () => {
-		await runCommand(mainCommand, { rawArgs: ['start', '-p', '4000', '--hostname', '0.0.0.0'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			[],
-			expect.objectContaining({
-				nodeEnv: 'production',
-				port: '4000',
-				hostname: '0.0.0.0',
-			}),
-			'app.ts',
-		);
-	});
-
-	it('allows overriding base url and debug options', async () => {
-		await runCommand(mainCommand, { rawArgs: ['preview', '--base-url', '/my-app/', '-d'] });
-		expect(launchPlan.createLaunchPlan).toHaveBeenCalledWith(
-			['--preview'],
-			expect.objectContaining({
-				nodeEnv: 'production',
-				'base-url': '/my-app/',
-				debug: true,
-			}),
-			'app.ts',
-		);
-	});
-});

package/bin/launch-plan.test.ts

@@ -1,161 +0,0 @@
-import fs from 'node:fs';
-import { createRequire } from 'node:module';
-import path from 'node:path';
-import { tmpdir } from 'node:os';
-import { afterEach, describe, expect, it } from 'vitest';
-import {
-	buildEnvOverrides,
-	buildBunArgs,
-	buildNodeArgs,
-	createLaunchPlan,
-	detectRuntime,
-	launchPlanRequiresExistingEntryFile,
-	resolveTsxCliPath,
-} from './launch-plan.js';
-
-const require = createRequire(import.meta.url);
-
-const originalUserAgent = process.env.npm_config_user_agent;
-const originalCwd = process.cwd();
-
-afterEach(() => {
-	if (originalUserAgent === undefined) {
-		delete process.env.npm_config_user_agent;
-	} else {
-		process.env.npm_config_user_agent = originalUserAgent;
-	}
-	process.chdir(originalCwd);
-});
-
-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',
-		);
-	}
-
-	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 returns node when Bun is not available', () => {
-		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');
-	});
-
-	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('buildNodeArgs imports eco.config.ts when present', () => {
-		expect(buildNodeArgs(['--dev'], {}, 'app.ts', true)).toEqual([
-			'--import',
-			'./eco.config.ts',
-			'app.ts',
-			'--dev',
-		]);
-	});
-
-	it('resolveTsxCliPath resolves the packaged tsx cli entry', () => {
-		expect(resolveTsxCliPath()).toBe(require.resolve('tsx/cli'));
-	});
-
-	it('createLaunchPlan uses the packaged tsx cli for node runtime', 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 plan = await createLaunchPlan(['--dev'], { runtime: 'node', nodeEnv: 'development' }, 'app.ts');
-
-			expect(plan).toMatchObject({
-				runtime: 'node',
-				executionStrategy: 'direct-runtime',
-				command: process.execPath,
-			});
-			expect(plan.commandArgs).toEqual([
-				require.resolve('tsx/cli'),
-				'--import',
-				'./eco.config.ts',
-				'app.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('launchPlanRequiresExistingEntryFile requires a concrete entry on every runtime path', 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 bunPlan = await createLaunchPlan(['--dev'], { nodeEnv: 'development' }, 'app.ts');
-			expect(launchPlanRequiresExistingEntryFile(bunPlan)).toBe(true);
-		} finally {
-			fs.rmSync(tempDir, { recursive: true, force: true });
-		}
-	});
-});