@cedarjs/cli 2.6.1-next.0 → 2.7.0-rc.107

package/dist/commands/build/buildHandler.js

@@ -10,9 +10,57 @@ import { generate } from "@cedarjs/internal/dist/generate/generate";
 import { loadAndValidateSdls } from "@cedarjs/internal/dist/validateSchema";
 import { detectPrerenderRoutes } from "@cedarjs/prerender/detection";
 import { timedTelemetry } from "@cedarjs/telemetry";
+import c from "../../lib/colors.js";
 import { generatePrismaCommand } from "../../lib/generatePrismaClient.js";
 import { getPaths, getConfig } from "../../lib/index.js";
 import { buildPackagesTask } from "./buildPackagesTask.js";
+function checkWorkspacePackageEntryPoints(cedarPaths) {
+  const packagesDir = cedarPaths.packages;
+  if (!packagesDir || !fs.existsSync(packagesDir)) {
+    return [];
+  }
+  const problems = [];
+  const packageDirs = fs.readdirSync(packagesDir, { withFileTypes: true });
+  for (const entry of packageDirs) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const pkgJsonPath = path.join(packagesDir, entry.name, "package.json");
+    if (!fs.existsSync(pkgJsonPath)) {
+      continue;
+    }
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+    const pkgName = pkgJson.name || entry.name;
+    const pkgDir = path.join(packagesDir, entry.name);
+    const entryFiles = /* @__PURE__ */ new Set();
+    if (pkgJson.main) {
+      entryFiles.add(path.normalize(pkgJson.main));
+    }
+    if (pkgJson.exports) {
+      const collectPaths = (obj) => {
+        if (typeof obj === "string") {
+          if (!obj.endsWith(".d.ts")) {
+            entryFiles.add(path.normalize(obj));
+          }
+        } else if (obj && typeof obj === "object") {
+          for (const [key, value] of Object.entries(obj)) {
+            if (key !== "types") {
+              collectPaths(value);
+            }
+          }
+        }
+      };
+      collectPaths(pkgJson.exports);
+    }
+    for (const entryFile of entryFiles) {
+      const resolvedPath = path.resolve(pkgDir, entryFile);
+      if (!fs.existsSync(resolvedPath)) {
+        problems.push({ pkgName, entryFile, pkgDir });
+      }
+    }
+  }
+  return problems;
+}
 const handler = async ({
   workspace = ["api", "web", "packages/*"],
   verbose = false,
@@ -56,6 +104,25 @@ const handler = async ({
       title: "Building Packages...",
       task: (_ctx, task) => buildPackagesTask(task, nonApiWebWorkspaces)
     },
+    (workspace.includes("web") || workspace.includes("api")) && {
+      title: "Checking workspace packages...",
+      task: () => {
+        const problems = checkWorkspacePackageEntryPoints(cedarPaths);
+        if (problems.length === 0) {
+          return;
+        }
+        const details = problems.map(
+          ({ pkgName, entryFile, pkgDir }) => `  \u2022 ${c.error(pkgName)}: missing "${entryFile}" (in ${pkgDir})`
+        ).join("\n");
+        throw new Error(
+          `The following workspace package entry points are missing:
+${details}
+
+This usually means the package has not been built yet.
+Run ` + c.info("yarn cedar build") + " (without specifying a workspace) to build everything,\nor build the package manually first, e.g. " + c.info(`yarn workspace ${problems[0].pkgName} build`)
+        );
+      }
+    },
     // If using GraphQL Fragments or Trusted Documents, then we need to use
     // codegen to generate the types needed for possible types and the trusted
     // document store hashes

package/dist/commands/build/buildPackagesTask.js

@@ -1,9 +1,8 @@
 import fs from "node:fs";
 import path from "node:path";
-import concurrently from "concurrently";
+import execa from "execa";
 import { importStatementPath } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
-import { exitWithError } from "../../lib/exit.js";
 import { getPaths } from "../../lib/index.js";
 async function buildPackagesTask(task, nonApiWebWorkspaces) {
   const cedarPaths = getPaths();
@@ -22,28 +21,30 @@ async function buildPackagesTask(task, nonApiWebWorkspaces) {
     task.skip("No packages to build at " + nonApiWebWorkspaces.join(", "));
     return;
   }
-  const { result } = concurrently(
+  return task.newListr(
     workspacePaths.map((workspacePath) => {
+      const name = workspacePath.split("/").at(-1);
       return {
-        command: `yarn build`,
-        name: workspacePath.split("/").at(-1),
-        cwd: workspacePath
+        title: name,
+        task: async () => {
+          try {
+            await execa("yarn", ["build"], { cwd: workspacePath });
+          } catch (e) {
+            errorTelemetry(
+              process.argv,
+              `Error building package "${name}": ${e.message}`
+            );
+            throw new Error(
+              `Building "${name}" failed
+
+${e.stderr || e.message}`
+            );
+          }
+        }
       };
     }),
-    {
-      prefix: "{name} |",
-      timestampFormat: "HH:mm:ss"
-    }
+    { concurrent: true, rendererOptions: { collapseSubtasks: false } }
   );
-  await result.catch((e) => {
-    if (e?.message) {
-      errorTelemetry(
-        process.argv,
-        `Error concurrently building sides: ${e.message}`
-      );
-      exitWithError(e);
-    }
-  });
 }
 export {
   buildPackagesTask

package/dist/commands/consoleHandler.js

@@ -24,10 +24,10 @@ const loadConsoleHistory = async (r) => {
   try {
     const history = await fs.promises.readFile(consoleHistoryFile, "utf8");
     history.split("\n").reverse().map((line) => r.history.push(line));
-  } catch (e) {
+  } catch {
   }
 };
-const handler = () => {
+const handler = (_options) => {
   recordTelemetryAttributes({
     command: "console"
   });
@@ -46,19 +46,20 @@ const handler = () => {
   });
   const r = repl.start();
   const defaultEval = r.eval;
-  r.eval = (cmd, context, filename, callback) => {
-    defaultEval(cmd, context, filename, async (err, result) => {
+  const asyncEval = (cmd, context, filename, callback) => {
+    defaultEval.call(r, cmd, context, filename, async (err, result) => {
       if (err) {
-        callback(err);
+        callback(err, null);
       } else {
         try {
           callback(null, await Promise.resolve(result));
-        } catch (err2) {
-          callback(err2);
+        } catch (error) {
+          callback(error, null);
         }
       }
     });
   };
+  r.eval = asyncEval;
   loadConsoleHistory(r);
   r.addListener("close", () => persistConsoleHistory(r));
   loadPrismaClient(r.context);

package/dist/commands/deploy/render.js

@@ -1,6 +1,6 @@
 import { terminalLink } from "termi-link";
 if (process.argv.slice(2).includes("api")) {
-  process.env.REDWOOD_DISABLE_TELEMETRY = 1;
+  process.env.REDWOOD_DISABLE_TELEMETRY = "1";
 }
 const command = "render <side>";
 const description = "Build, migrate, and serve command for Render deploy";

package/dist/commands/execHandler.js

@@ -10,18 +10,21 @@ import { runScriptFunction } from "../lib/exec.js";
 import { generatePrismaClient } from "../lib/generatePrismaClient.js";
 import { getPaths } from "../lib/index.js";
 const printAvailableScriptsToConsole = () => {
-  const scripts = findScripts(getPaths().scripts).reduce((acc, scriptPath) => {
-    const relativePath = path.relative(getPaths().scripts, scriptPath);
-    const ext = path.parse(relativePath).ext;
-    const pathNoExt = relativePath.slice(0, -ext.length);
-    acc[pathNoExt] ||= [];
-    acc[pathNoExt].push(relativePath);
-    return acc;
-  }, {});
+  const scripts = findScripts(getPaths().scripts).reduce(
+    (acc, scriptPath) => {
+      const relativePath = path.relative(getPaths().scripts, scriptPath);
+      const ext = path.parse(relativePath).ext;
+      const pathNoExt = relativePath.slice(0, -ext.length);
+      acc[pathNoExt] ||= [];
+      acc[pathNoExt].push(relativePath);
+      return acc;
+    },
+    {}
+  );
   console.log("Available scripts:");
-  Object.entries(scripts).forEach(([name, paths]) => {
-    if (paths.length > 1) {
-      paths.forEach((scriptPath) => {
+  Object.entries(scripts).forEach(([name, scriptPaths]) => {
+    if (scriptPaths.length > 1) {
+      scriptPaths.forEach((scriptPath) => {
         console.log(c.info(`- ${scriptPath}`));
       });
     } else {
@@ -54,7 +57,7 @@ No script called \`${name}\` in the ./scripts folder.
   const scriptTasks = [
     {
       title: "Generating Prisma client",
-      enabled: () => prisma,
+      enabled: () => Boolean(prisma),
       task: () => generatePrismaClient({
         force: false,
         verbose: !args.silent,
@@ -70,15 +73,15 @@ No script called \`${name}\` in the ./scripts folder.
             functionName: "default",
             args: { args: scriptArgs }
           });
-        } catch (e) {
-          console.error(c.error(`Error in script: ${e.message}`));
-          throw e;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          console.error(c.error(`Error in script: ${message}`));
+          throw error;
         }
       }
     }
   ];
   const tasks = new Listr(scriptTasks, {
-    rendererOptions: { collapseSubtasks: false },
     renderer: args.silent ? "silent" : "verbose"
   });
   await context.with(suppressTracing(context.active()), async () => {
@@ -93,9 +96,9 @@ function resolveScriptPath(name) {
   const extensions = [".js", ".jsx", ".ts", ".tsx"];
   const matches = [];
   for (const extension of extensions) {
-    const p = scriptPath + extension;
-    if (fs.existsSync(p)) {
-      matches.push(p);
+    const candidate = scriptPath + extension;
+    if (fs.existsSync(candidate)) {
+      matches.push(candidate);
     }
   }
   if (matches.length === 1) {

package/dist/commands/experimental.js

@@ -1,5 +1,5 @@
 import { terminalLink } from "termi-link";
-import detectRxVersion from "../middleware/detectProjectRxVersion.js";
+import { detectCedarVersion } from "../middleware/detectProjectCedarVersion.js";
 import * as experimentalInngest from "./experimental/setupInngest.js";
 import * as experimentalOpenTelemetry from "./experimental/setupOpentelemetry.js";
 import * as experimentalReactCompiler from "./experimental/setupReactCompiler.js";
@@ -8,7 +8,7 @@ import * as experimentalStreamingSsr from "./experimental/setupStreamingSsr.js";
 const command = "experimental <command>";
 const aliases = ["exp"];
 const description = "Run or setup experimental features";
-const builder = (yargs) => yargs.command(experimentalInngest).command(experimentalOpenTelemetry).command(experimentalReactCompiler).command(experimentalRsc).command(experimentalStreamingSsr).demandCommand().middleware(detectRxVersion).epilogue(
+const builder = (yargs) => yargs.command(experimentalInngest).command(experimentalOpenTelemetry).command(experimentalReactCompiler).command(experimentalRsc).command(experimentalStreamingSsr).demandCommand().middleware(detectCedarVersion).epilogue(
   `Also see the ${terminalLink(
     "CedarJS CLI Reference",
     "https://cedarjs.com/docs/cli-commands#experimental"

package/dist/commands/generate/dataMigration/dataMigration.js

@@ -1,12 +1,16 @@
-import fs from "node:fs";
 import path from "node:path";
 import { paramCase } from "change-case";
 import { Listr } from "listr2";
 import { terminalLink } from "termi-link";
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
+import { dbReexportsPrismaClient } from "@cedarjs/internal/dist/project";
 import { getDataMigrationsPath } from "@cedarjs/project-config";
 import c from "../../../lib/colors.js";
-import { getPaths, writeFilesTask } from "../../../lib/index.js";
+import {
+  generateTemplate,
+  getPaths,
+  writeFilesTask
+} from "../../../lib/index.js";
 import { prepareForRollback } from "../../../lib/rollback.js";
 import { validateName } from "../helpers.js";
 import { getYargsDefaults } from "../yargsCommandHelpers.js";
@@ -40,8 +44,12 @@ const files = async ({ name, typescript }) => {
     getPaths().api.prismaConfig
   );
   const outputPath = path.join(dataMigrationsPath, outputFilename);
+  const prismaImportSource = dbReexportsPrismaClient() ? "src/lib/db" : "@prisma/client";
   return {
-    [outputPath]: fs.readFileSync(TEMPLATE_PATHS[extension]).toString()
+    [outputPath]: await generateTemplate(TEMPLATE_PATHS[extension], {
+      name,
+      prismaImportSource
+    })
   };
 };
 const command = "data-migration <name>";

package/dist/commands/generate/dataMigration/templates/dataMigration.js.template

@@ -1,5 +1,5 @@
 /**
- * @typedef { import("@prisma/client").PrismaClient } PrismaClient
+ * @typedef { import("${prismaImportSource}").PrismaClient } PrismaClient
  * @param {{db: PrismaClient}} db
  */
 export default async ({ db }) => {

package/dist/commands/generate/dataMigration/templates/dataMigration.ts.template

@@ -1,4 +1,4 @@
-import type { PrismaClient } from '@prisma/client'
+import type { PrismaClient } from '${prismaImportSource}'
 
 export default async ({ db }: { db: PrismaClient }) => {
   // Migration here...

package/dist/commands/generate/script/scriptHandler.js

@@ -35,7 +35,10 @@ const files = async ({ name, typescript = false }) => {
     }
   };
 };
-const handler = async ({ force, ...args }) => {
+const handler = async ({
+  force,
+  ...args
+}) => {
   recordTelemetryAttributes({
     command: "generate script",
     force,
@@ -74,9 +77,10 @@ const handler = async ({ force, ...args }) => {
       prepareForRollback(tasks);
     }
     await tasks.run();
-  } catch (e) {
-    errorTelemetry(process.argv, e.message);
-    console.log(c.error(e.message));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    errorTelemetry(process.argv, message);
+    console.log(c.error(message));
     process.exit(1);
   }
 };

package/dist/commands/generate/service/serviceHandler.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import camelcase from "camelcase";
+import { dbReexportsPrismaClient } from "@cedarjs/internal/dist/project";
 import { pluralize, singularize } from "../../../lib/cedarPluralize.js";
 import { transformTSToJS } from "../../../lib/index.js";
 import { getSchema, verifyModelName } from "../../../lib/schemaHelpers.js";
@@ -222,6 +223,7 @@ const files = async ({
   const componentName = camelcase(pluralize(name));
   const model = name;
   const idName = await getIdName(model);
+  const prismaImportSource = dbReexportsPrismaClient() ? "src/lib/db" : "@prisma/client";
   const modelRelations = relations || relationsForModel(await getSchema(model));
   const serviceFile = await templateForFile({
     name,
@@ -230,7 +232,12 @@ const files = async ({
     generator: "service",
     outputPath: path.join(componentName, componentName + ".ts"),
     templatePath: "service.ts.template",
-    templateVars: { relations: modelRelations, idName, ...rest }
+    templateVars: {
+      relations: modelRelations,
+      idName,
+      prismaImportSource,
+      ...rest
+    }
   });
   const testFile = await templateForFile({
     name,
@@ -249,6 +256,7 @@ const files = async ({
       ),
       prismaModel: model,
       idName,
+      prismaImportSource,
       ...rest
     }
   });
@@ -265,6 +273,7 @@ const files = async ({
       prismaModel: model,
       idName,
       relations: modelRelations,
+      prismaImportSource,
       ...rest
     }
   });

package/dist/commands/generate/service/templates/scenarios.ts.template

@@ -1,6 +1,8 @@
-import type { Prisma, ${prismaModel} } from '@prisma/client'
+<% if (prismaImportSource === 'src/lib/db') { %>import type { ScenarioData } from '@cedarjs/testing/api'
 
-import type { ScenarioData } from '@cedarjs/testing/api'
+import type { Prisma, ${prismaModel} } from '${prismaImportSource}'<% } else { %>import type { Prisma, ${prismaModel} } from '${prismaImportSource}'
+
+import type { ScenarioData } from '@cedarjs/testing/api'<% } %>
 
 export const standard = defineScenario<Prisma.${prismaModel}CreateArgs>(${stringifiedScenario})
 

package/dist/commands/generate/service/templates/test.ts.template

@@ -31,7 +31,7 @@
     // Not all values can be represented as JSON, like function invocations
     return jsonString.replace(/"new Uint8Array\(([^)]+)\)"/g, 'new Uint8Array($1)')
   } %>
-<% if (prismaImport) { %>import { Prisma, ${prismaModel} } from '@prisma/client'<% } else { %>import type { ${prismaModel} } from '@prisma/client'<% } %>
+<% if (prismaImport) { %>import { Prisma, ${prismaModel} } from '${prismaImportSource}'<% } else { %>import type { ${prismaModel} } from '${prismaImportSource}'<% } %>
 
 import { ${pluralCamelName}<% if (crud) { %>,${singularCamelName}, create${singularPascalName}, update${singularPascalName}, delete${singularPascalName}<% } %> } from './${pluralCamelName}.js'
 import type { StandardScenario } from './${pluralCamelName}.scenarios.js'

package/dist/commands/info.js

@@ -28,7 +28,7 @@ const handler = async () => {
   const tomlContent = fs.readFileSync(configTomlPath, "utf8");
   console.log(
     output + `  ${path.basename(configTomlPath)}:
-` + tomlContent.split("\n").filter((line) => line.trim().length > 0).filter((line) => !/^#/.test(line)).map((line) => `    ${line}`).join("\n")
+` + tomlContent.split("\n").filter((line) => line.trim().length > 0).filter((line) => !line.startsWith("#")).map((line) => `    ${line}`).join("\n")
   );
 };
 export {

package/dist/commands/lint.js

@@ -29,7 +29,7 @@ function detectLegacyEslintConfig() {
       if (packageJson.eslint) {
         foundLegacyFiles.push("package.json (eslint field)");
       }
-    } catch (error) {
+    } catch {
     }
   }
   return foundLegacyFiles;
@@ -63,7 +63,8 @@ const description = "Lint your files";
 const builder = (yargs) => {
   yargs.positional("paths", {
     description: "Specify file(s) or directory(ies) to lint relative to project root",
-    type: "array"
+    type: "string",
+    array: true
   }).option("fix", {
     default: false,
     description: "Try to fix errors",
@@ -79,7 +80,11 @@ const builder = (yargs) => {
     )}`
   );
 };
-const handler = async ({ paths, fix, format }) => {
+const handler = async ({
+  paths = [],
+  fix = false,
+  format = "stylish"
+}) => {
   recordTelemetryAttributes({ command: "lint", fix, format });
   const config = getConfig();
   const legacyConfigFiles = detectLegacyEslintConfig();
@@ -98,13 +103,18 @@ const handler = async ({ paths, fix, format }) => {
         fs.existsSync(getPaths().api.src) && "api/src"
       );
     }
-    const result = await execa("yarn", args.filter(Boolean), {
+    const filteredArgs = args.filter((arg) => Boolean(arg));
+    const result = await execa("yarn", filteredArgs, {
       cwd: getPaths().base,
       stdio: "inherit"
     });
     process.exitCode = result.exitCode;
   } catch (error) {
-    process.exitCode = error.exitCode ?? 1;
+    if (error && typeof error === "object" && "exitCode" in error) {
+      process.exitCode = typeof error.exitCode === "number" ? error.exitCode : 1;
+      return;
+    }
+    process.exitCode = 1;
   }
 };
 export {

package/dist/commands/record/init.js

@@ -1,5 +1,5 @@
 import { recordTelemetryAttributes } from "@cedarjs/cli-helpers";
-const handler = async () => {
+const handler = async (_argv) => {
   recordTelemetryAttributes({
     command: "record"
   });

package/dist/commands/record.js

@@ -1,7 +1,8 @@
+import { terminalLink } from "termi-link";
 const command = "record <command>";
 const description = "Setup RedwoodRecord for your project. Caches a JSON version of your data model and adds api/src/models/index.js with some config.";
-import { terminalLink } from "termi-link";
-const builder = (yargs) => yargs.command({ command, description, handler }).demandCommand().epilogue(
+const builder = (yargs) => yargs.command(command, description, () => {
+}, handler).demandCommand().epilogue(
   `Also see the ${terminalLink(
     "RedwoodRecord Docs",
     "https://cedarjs.com/docs/redwoodrecord"
@@ -10,7 +11,7 @@ const builder = (yargs) => yargs.command({ command, description, handler }).dema
 );
 async function handler(argv) {
   const recordInit = await import("./record/init.js");
-  recordInit(argv);
+  return recordInit.handler(argv);
 }
 export {
   builder,

package/dist/commands/serve.js

@@ -27,11 +27,11 @@ const builder = async (yargs) => {
         socket: argv.socket
       });
       if (serverFileExists()) {
-        const { bothServerFileHandler } = await import("./serveBothHandler.js");
-        await bothServerFileHandler(argv);
+        const serveBothHandlers = await import("./serveBothHandler.js");
+        await serveBothHandlers.bothServerFileHandler(argv);
       } else if (rscEnabled || streamingEnabled) {
-        const { bothSsrRscServerHandler } = await import("./serveBothHandler.js");
-        await bothSsrRscServerHandler(argv, rscEnabled);
+        const serveBothHandlers = await import("./serveBothHandler.js");
+        await serveBothHandlers.bothSsrRscServerHandler(argv, rscEnabled);
       } else {
         if (!projectIsEsm()) {
           const { handler } = await import("@cedarjs/api-server/cjs/bothCliConfigHandler");
@@ -88,7 +88,7 @@ const builder = async (yargs) => {
       command: "serve"
     });
     const positionalArgs = argv._;
-    if (positionalArgs.includes("web") && !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
+    if (positionalArgs.includes("web") && !webSideIsBuilt(streamingEnabled || rscEnabled)) {
       console.error(
         c.error(
           "\n Please run `yarn cedar build web` before trying to serve web. \n"
@@ -119,15 +119,16 @@ const builder = async (yargs) => {
       if (!apiSideExists && !rscEnabled) {
         console.error(
           c.error(
-            "\n Unable to serve the both sides as no `api` folder exists. Please use `yarn cedar serve web` instead. \n"
+            "\nUnable to serve web and api as no `api` folder exists. Please use `yarn cedar serve web` instead. \n"
           )
         );
         process.exit(1);
       }
-      if (fs.existsSync(path.join(getPaths().api.base)) && !fs.existsSync(path.join(getPaths().api.dist)) || !fs.existsSync(path.join(getPaths().web.dist), "index.html")) {
+      const apiExistsButIsNotBuilt = apiSideExists && !fs.existsSync(getPaths().api.dist);
+      if (apiExistsButIsNotBuilt || !webSideIsBuilt(streamingEnabled || rscEnabled)) {
         console.error(
           c.error(
-            "\n Please run `yarn cedar build` before trying to serve your redwood app. \n"
+            "\nPlease run `yarn cedar build` before trying to serve your Cedar app.\n"
           )
         );
         process.exit(1);
@@ -143,6 +144,15 @@ const builder = async (yargs) => {
     )}`
   );
 };
+function webSideIsBuilt(isStreamingOrRSC) {
+  if (isStreamingOrRSC) {
+    return fs.existsSync(
+      path.join(getPaths().web.distBrowser, "client-build-manifest.json")
+    );
+  } else {
+    return fs.existsSync(path.join(getPaths().web.dist, "index.html"));
+  }
+}
 export {
   builder,
   command,

package/dist/commands/serveApiHandler.js

@@ -3,9 +3,10 @@ import { getPaths } from "@cedarjs/project-config";
 const apiServerFileHandler = async (argv) => {
   const args = ["node", "server.js", "--apiRootPath", argv.apiRootPath];
   if (argv.port) {
-    args.push("--apiPort", argv.port);
+    args.push("--apiPort", String(argv.port));
   }
-  await execa("yarn", args, {
+  const filteredArgs = args.filter((arg) => Boolean(arg));
+  await execa("yarn", filteredArgs, {
     cwd: getPaths().api.dist,
     stdio: "inherit"
   });

package/dist/commands/serveBothHandler.js

@@ -11,6 +11,10 @@ import {
 import { getConfig, getPaths } from "@cedarjs/project-config";
 import { errorTelemetry } from "@cedarjs/telemetry";
 import { exitWithError } from "../lib/exit.js";
+const hasStringMessage = (error) => {
+  const message = typeof error === "object" && error !== null ? Reflect.get(error, "message") : void 0;
+  return typeof error === "object" && error !== null && "message" in error && typeof message === "string";
+};
 const bothServerFileHandler = async (argv) => {
   if (getConfig().experimental?.rsc?.enabled || getConfig().experimental?.streamingSsr?.enabled) {
     logSkippingFastifyWebServer();
@@ -54,10 +58,11 @@ const bothServerFileHandler = async (argv) => {
     try {
       await result;
     } catch (error) {
-      if (typeof error?.message !== "undefined") {
+      const message = hasStringMessage(error) ? error.message : void 0;
+      if (typeof message !== "undefined") {
         errorTelemetry(
           process.argv,
-          `Error concurrently starting sides: ${error.message}`
+          `Error concurrently starting sides: ${message}`
         );
         exitWithError(error);
       }
@@ -74,6 +79,7 @@ const bothSsrRscServerHandler = async (argv, rscEnabled) => {
     cwd: getPaths().web.base,
     stdio: "inherit",
     env: rscEnabled ? {
+      ...process.env,
       // TODO (RSC): Is this how we want to do it? If so, we need to find a way
       // to merge this with users' NODE_OPTIONS
       NODE_OPTIONS: "--conditions react-server"

package/dist/commands/serveWebHandler.js

@@ -5,6 +5,7 @@ const webSsrServerHandler = async (rscEnabled) => {
     cwd: getPaths().web.base,
     stdio: "inherit",
     env: rscEnabled ? {
+      ...process.env,
       // TODO (RSC): Is this how we want to do it? If so, we need to find a way
       // to merge this with users' NODE_OPTIONS
       NODE_OPTIONS: "--conditions react-server"