ecopages 0.2.0-alpha.47 → 0.2.0-alpha.49

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 Node entry bridge dependencies are available.";
+      const hint = launchPlan.runtime === "bun" ? "Install Bun from https://bun.sh to continue." : "Reinstall Node.js or run with --runtime bun if this app requires Bun.";
       logger.error(`Command not found: ${launchPlan.command}. ${hint}`);
       process.exit(1);
     }

package/bin/launch-plan.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { parseEnv } from "node:util";
-import { buildNodeEntryBridge } from "./node-entry-bridge.js";
+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) {
@@ -54,15 +55,14 @@ function buildBunArgs(args, options, entryFile, hasConfig) {
   }
   return bunArgs;
 }
-async function createLaunchPlan(args, options = {}, entryFile = "app.ts") {
+function createLaunchPlan(args, options = {}, entryFile = "app.ts") {
   const { envOverrides, env } = buildLaunchEnv(options);
   const runtime = detectRuntime(options);
   if (runtime === "node") {
-    const nodeEntryBridge = await buildNodeEntryBridge(entryFile);
     return {
       runtime,
       command: process.execPath,
-      commandArgs: [nodeEntryBridge, ...args],
+      commandArgs: ["--import", nodeRequirePreload, "--import", tsxLoader, entryFile, ...args],
       envOverrides,
       env
     };

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,6 +1,6 @@
 {
   "name": "ecopages",
-  "version": "0.2.0-alpha.47",
+  "version": "0.2.0-alpha.49",
   "description": "CLI utilities for Ecopages",
   "type": "module",
   "engines": {
@@ -32,10 +32,10 @@
     "ecopages": "bin/cli.js"
   },
   "dependencies": {
-    "@ecopages/core": "0.2.0-alpha.47",
+    "@ecopages/core": "0.2.0-alpha.49",
     "@ecopages/logger": "^0.2.3",
-    "esbuild": "^0.28.0",
-    "giget": "^2.0.0"
+    "giget": "^2.0.0",
+    "tsx": "^4.22.3"
   },
   "peerDependencies": {
     "bun-types": "*",

package/bin/node-entry-bridge.js

@@ -1,203 +0,0 @@
-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 readPackageManifest(packageDir) {
-  const packageJsonPath = path.join(packageDir, "package.json");
-  try {
-    return JSON.parse(readFileSync(packageJsonPath, "utf8"));
-  } catch {
-    return void 0;
-  }
-}
-function isPackageExportedSubpath(specifier, resolvedPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (specifier === packageName) {
-    return false;
-  }
-  const packageRoot = findPackageRoot(resolvedPath);
-  const manifest = readPackageManifest(packageRoot);
-  if (!manifest?.exports || typeof manifest.exports !== "object" || Array.isArray(manifest.exports)) {
-    return false;
-  }
-  const subpath = `.${specifier.slice(packageName.length)}`;
-  return subpath in manifest.exports;
-}
-function getNodeExternalSpecifier(specifier, resolvedPath) {
-  const packageName = getPackageNameFromSpecifier(specifier);
-  if (specifier === packageName) {
-    return specifier;
-  }
-  if (path.extname(specifier)) {
-    return specifier;
-  }
-  if (isPackageExportedSubpath(specifier, resolvedPath)) {
-    return specifier;
-  }
-  const resolvedExtension = path.extname(resolvedPath);
-  if (![".js", ".mjs", ".cjs", ".json"].includes(resolvedExtension)) {
-    return specifier;
-  }
-  const packageRoot = findPackageRoot(resolvedPath);
-  const requestedSubpath = specifier.slice(packageName.length + 1);
-  const resolvedSubpath = path.relative(packageRoot, resolvedPath);
-  if (resolvedSubpath === `${requestedSubpath}${resolvedExtension}`) {
-    return `${specifier}${resolvedExtension}`;
-  }
-  return specifier;
-}
-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: getNodeExternalSpecifier(args.path, resolvedPath),
-              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",
-    banner: {
-      js: 'import { createRequire as __ecopagesCreateRequire } from "node:module"; const require = __ecopagesCreateRequire(import.meta.url);'
-    },
-    logLevel: "silent",
-    plugins: [
-      createNodeEntryBridgePlugin({
-        rootDir,
-        entryFile: absoluteEntryFile,
-        runtimeNodeModulesDir: path.join(outdir, "node_modules")
-      })
-    ]
-  });
-  return outfile;
-}
-export {
-  buildNodeEntryBridge
-};