ecopages 0.2.0-alpha.42 → 0.2.0-alpha.44

package/bin/cli.js

@@ -169,7 +169,7 @@ function runLaunchPlan(launchPlan) {
   });
   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.";
+      const hint = launchPlan.runtime === "bun" ? "Install Bun from https://bun.sh to continue." : "Reinstall ecopages and its dependencies so the Node entry bridge dependencies are available.";
       logger.error(`Command not found: ${launchPlan.command}. ${hint}`);
       process.exit(1);
     }
@@ -182,6 +182,10 @@ function runLaunchPlan(launchPlan) {
 }
 async function runEntryCommand(args, options = {}, entryFile = "app.ts") {
   let launchPlan;
+  if (!existsSync(entryFile)) {
+    logger.error(`Error: Entry file "${entryFile}" not found in the current directory.`);
+    process.exit(1);
+  }
   try {
     launchPlan = await createLaunchPlan(args, options, entryFile);
   } catch (error) {
@@ -189,10 +193,6 @@ async function runEntryCommand(args, options = {}, entryFile = "app.ts") {
     logger.error(message);
     process.exit(1);
   }
-  if (!existsSync(entryFile)) {
-    logger.error(`Error: Entry file "${entryFile}" not found in the current directory.`);
-    process.exit(1);
-  }
   runLaunchPlan(launchPlan);
 }
 async function runInitCommand(rawArgs) {

package/bin/launch-plan.js

@@ -1,12 +1,12 @@
-import { existsSync } from "node:fs";
-import { createRequire } from "node:module";
-const require2 = createRequire(import.meta.url);
-function buildNodeEnvFileArgs(nodeEnv) {
+import { existsSync, readFileSync } from "node:fs";
+import { parseEnv } from "node:util";
+import { buildNodeEntryBridge } from "./node-entry-bridge.js";
+function getEnvFilePaths(nodeEnv) {
   const envFiles = [".env", ".env.local"];
   if (nodeEnv) {
     envFiles.push(`.env.${nodeEnv}`, `.env.${nodeEnv}.local`);
   }
-  return envFiles.filter((envFile) => existsSync(envFile)).map((envFile) => `--env-file=${envFile}`);
+  return envFiles.filter((envFile) => existsSync(envFile));
 }
 function buildEnvOverrides(options) {
   const env = {};
@@ -17,6 +17,16 @@ function buildEnvOverrides(options) {
   if (options.nodeEnv) env.NODE_ENV = options.nodeEnv;
   return env;
 }
+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 }
+  };
+}
 function detectRuntime(options = {}) {
   if (options.runtime === "bun" || options.runtime === "node") {
     return options.runtime;
@@ -36,7 +46,7 @@ function buildBunArgs(args, options, entryFile, hasConfig) {
   if (options.hot) bunArgs.push("--hot");
   bunArgs.push("run");
   if (hasConfig) {
-    bunArgs.push("--preload", "./eco.config.js");
+    bunArgs.push("--preload", `./eco.config.${"ts"}`);
   }
   bunArgs.push(entryFile, ...args);
   if (options.reactFastRefresh) {
@@ -44,26 +54,15 @@ function buildBunArgs(args, options, entryFile, hasConfig) {
   }
   return bunArgs;
 }
-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."
-    );
-  }
-}
 async function createLaunchPlan(args, options = {}, entryFile = "app.ts") {
-  const envOverrides = buildEnvOverrides(options);
+  const { envOverrides, env } = buildLaunchEnv(options);
   const runtime = detectRuntime(options);
-  const env = { ...process.env, ...envOverrides };
   if (runtime === "node") {
-    const tsxCliPath = resolveTsxCliPath();
-    const nodeArgs = [entryFile, ...args];
+    const nodeEntryBridge = await buildNodeEntryBridge(entryFile);
     return {
       runtime,
       command: process.execPath,
-      commandArgs: [...buildNodeEnvFileArgs(options.nodeEnv), tsxCliPath, ...nodeArgs],
+      commandArgs: [nodeEntryBridge, ...args],
       envOverrides,
       env
     };
@@ -79,7 +78,7 @@ async function createLaunchPlan(args, options = {}, entryFile = "app.ts") {
 export {
   buildBunArgs,
   buildEnvOverrides,
+  buildLaunchEnv,
   createLaunchPlan,
-  detectRuntime,
-  resolveTsxCliPath
+  detectRuntime
 };

package/bin/node-entry-bridge.js

@@ -0,0 +1,156 @@
+import { lstatSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, unlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { build } from "esbuild";
+function getLoader(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".jsx") return "jsx";
+  if (extension === ".json") return "json";
+  return extension === ".ts" || extension === ".mts" || extension === ".cts" ? "ts" : "js";
+}
+function shouldRewriteSource(filePath, rootDir) {
+  const normalizedPath = path.resolve(filePath);
+  const normalizedRootDir = path.resolve(rootDir);
+  return normalizedPath === normalizedRootDir || normalizedPath.startsWith(`${normalizedRootDir}${path.sep}`);
+}
+function rewriteImportMeta(contents, filePath, entryFile) {
+  const normalizedPath = path.resolve(filePath);
+  const normalizedEntryFile = path.resolve(entryFile);
+  return contents.replaceAll("import.meta.env", "process.env").replaceAll("import.meta.main", normalizedPath === normalizedEntryFile ? "true" : "false").replaceAll("import.meta.url", JSON.stringify(pathToFileURL(filePath).href)).replaceAll("import.meta.dirname", JSON.stringify(path.dirname(filePath))).replaceAll("import.meta.filename", JSON.stringify(filePath)).replaceAll("import.meta.dir", JSON.stringify(path.dirname(filePath))).replaceAll("import.meta.path", JSON.stringify(filePath));
+}
+function getPackageNameFromSpecifier(specifier) {
+  if (specifier.startsWith("@")) {
+    const [scope, name] = specifier.split("/");
+    return `${scope}/${name}`;
+  }
+  return specifier.split("/")[0] ?? specifier;
+}
+function findPackageRoot(resolvedPath) {
+  let currentPath = path.dirname(resolvedPath);
+  while (true) {
+    const packageJsonPath = path.join(currentPath, "package.json");
+    try {
+      lstatSync(packageJsonPath);
+      return currentPath;
+    } catch {
+    }
+    const parentPath = path.dirname(currentPath);
+    if (parentPath === currentPath) {
+      throw new Error(`Could not find package root for resolved dependency path: ${resolvedPath}`);
+    }
+    currentPath = parentPath;
+  }
+}
+function linkPointsToPackage(linkPath, packageRoot) {
+  try {
+    return realpathSync(linkPath) === realpathSync(packageRoot);
+  } catch {
+    return false;
+  }
+}
+function removeRuntimePackageLink(linkPath) {
+  try {
+    const stats = lstatSync(linkPath);
+    if (stats.isSymbolicLink()) {
+      unlinkSync(linkPath);
+      return;
+    }
+  } catch {
+    return;
+  }
+  rmSync(linkPath, { recursive: true, force: true });
+}
+function ensureRuntimePackageLink(nodeModulesDir, specifier, resolvedPath) {
+  const packageName = getPackageNameFromSpecifier(specifier);
+  const packageRoot = findPackageRoot(resolvedPath);
+  const linkPath = path.join(nodeModulesDir, packageName);
+  mkdirSync(path.dirname(linkPath), { recursive: true });
+  try {
+    lstatSync(linkPath);
+    if (linkPointsToPackage(linkPath, packageRoot)) {
+      return;
+    }
+    removeRuntimePackageLink(linkPath);
+  } catch {
+  }
+  symlinkSync(packageRoot, linkPath, "dir");
+}
+function createNodeEntryBridgePlugin({ rootDir, entryFile, runtimeNodeModulesDir }) {
+  return {
+    name: "ecopages-node-entry-bridge",
+    setup(buildContext) {
+      buildContext.onResolve({ filter: /^[@A-Za-z0-9][^:]*$/ }, (args) => {
+        try {
+          const resolvedPath = createRequire(path.join(args.resolveDir || rootDir, "package.json")).resolve(
+            args.path
+          );
+          if (!args.path.startsWith("@ecopages/")) {
+            ensureRuntimePackageLink(runtimeNodeModulesDir, args.path, resolvedPath);
+          }
+          if (resolvedPath.endsWith(".node")) {
+            return {
+              path: args.path,
+              external: true
+            };
+          }
+          if (!args.path.startsWith("@ecopages/")) {
+            return {
+              path: args.path,
+              external: true
+            };
+          }
+        } catch {
+          return void 0;
+        }
+        return void 0;
+      });
+      buildContext.onResolve({ filter: /\.node$/ }, (args) => ({
+        path: path.isAbsolute(args.path) ? args.path : path.resolve(args.resolveDir, args.path),
+        external: true
+      }));
+      buildContext.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+        if (!shouldRewriteSource(args.path, rootDir)) {
+          return void 0;
+        }
+        const contents = rewriteImportMeta(readFileSync(args.path, "utf8"), args.path, entryFile);
+        return {
+          contents,
+          loader: getLoader(args.path),
+          resolveDir: path.dirname(args.path)
+        };
+      });
+    }
+  };
+}
+async function buildNodeEntryBridge(entryFile, options = {}) {
+  const rootDir = path.resolve(options.rootDir ?? process.cwd());
+  const absoluteEntryFile = path.resolve(rootDir, entryFile);
+  const outdir = path.resolve(rootDir, ".eco", "node-entry");
+  const outfile = path.join(outdir, "app-entry.mjs");
+  rmSync(outdir, { recursive: true, force: true });
+  mkdirSync(outdir, { recursive: true });
+  await build({
+    absWorkingDir: rootDir,
+    entryPoints: [absoluteEntryFile],
+    outfile,
+    bundle: true,
+    format: "esm",
+    platform: "node",
+    target: "es2022",
+    sourcemap: "linked",
+    logLevel: "silent",
+    plugins: [
+      createNodeEntryBridgePlugin({
+        rootDir,
+        entryFile: absoluteEntryFile,
+        runtimeNodeModulesDir: path.join(outdir, "node_modules")
+      })
+    ]
+  });
+  return outfile;
+}
+export {
+  buildNodeEntryBridge
+};

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "ecopages",
-  "version": "0.2.0-alpha.42",
+  "version": "0.2.0-alpha.44",
   "description": "CLI utilities for Ecopages",
   "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
   "license": "MIT",
   "author": "Ecopages Team",
   "repository": {
@@ -29,10 +32,10 @@
     "ecopages": "bin/cli.js"
   },
   "dependencies": {
-    "@ecopages/core": "0.2.0-alpha.42",
+    "@ecopages/core": "0.2.0-alpha.44",
     "@ecopages/logger": "^0.2.3",
-    "giget": "^2.0.0",
-    "tsx": "^4.22.0"
+    "esbuild": "^0.28.0",
+    "giget": "^2.0.0"
   },
   "peerDependencies": {
     "bun-types": "*",