Add some gross hacks to stop bundle.yaml from being wiped empty

Author: falahat

src/apphosting/localbuilds.ts

@@ -8,6 +8,7 @@ import { loadSecret } from "./secrets";
 import { confirm } from "../prompt";
 import { FirebaseError } from "../error";
 import * as experiments from "../experiments";
+import { logger } from "../logger";
 
 interface UniversalMakerOutput {
   command: string;
@@ -27,6 +28,28 @@ export function runUniversalMaker(projectRoot: string, framework?: string): AppH
     );
   }
 
+  const bundleYamlPath = path.join(projectRoot, ".apphosting", "bundle.yaml");
+  let cachedBundleContent: string | null = null;
+  
+  if (!fs.existsSync(path.dirname(bundleYamlPath))) {
+    fs.mkdirSync(path.dirname(bundleYamlPath), { recursive: true });
+  }
+
+  // Watch for the file being created by the Next.js adapter
+  const watcher = fs.watch(path.dirname(bundleYamlPath), (eventType, filename) => {
+    if (filename === "bundle.yaml") {
+      try {
+        if (fs.existsSync(bundleYamlPath)) {
+          const currentText = fs.readFileSync(bundleYamlPath, "utf-8");
+          if (currentText.trim().length > 0) {
+            cachedBundleContent = currentText;
+          }
+        }
+      } catch (e) {
+      }
+    }
+  });
+
   try {
     childProcess.spawnSync(
       process.env.UNIVERSAL_MAKER_BINARY,
@@ -41,6 +64,17 @@ export function runUniversalMaker(projectRoot: string, framework?: string): AppH
         stdio: "inherit",
       },
     );
+
+    // Close the background watcher safely
+    watcher.close();
+
+    // Restore safely if wiped out in the final seconds
+    if (cachedBundleContent && fs.existsSync(bundleYamlPath)) {
+      const lastText = fs.readFileSync(bundleYamlPath, "utf-8");
+      if (lastText.trim().length === 0) {
+        fs.writeFileSync(bundleYamlPath, cachedBundleContent, "utf-8");
+      }
+    }
   } catch (e) {
     if (e && typeof e === "object" && "code" in e && e.code === "EACCES") {
       throw new FirebaseError(
@@ -65,14 +99,28 @@ export function runUniversalMaker(projectRoot: string, framework?: string): AppH
     throw new FirebaseError(`Failed to parse build_output.json: ${(e as Error).message}`);
   }
 
+  let finalRunCommand = `${umOutput.command} ${umOutput.args.join(" ")}`;
+  if (fs.existsSync(bundleYamlPath)) {
+    try {
+      const bundleRaw = fs.readFileSync(bundleYamlPath, "utf-8");
+      // Safely parse the YAML string
+      const bundleData = require("yaml").parse(bundleRaw);
+      if (bundleData?.runConfig?.runCommand) {
+        finalRunCommand = bundleData.runConfig.runCommand;
+      }
+    } catch (e) {
+      // Fall back gracefully if parser fails
+    }
+  }
+
   return {
     metadata: {
       language: umOutput.language,
       runtime: umOutput.runtime,
       framework: framework || "nextjs",
     },
     runConfig: {
-      runCommand: `${umOutput.command} ${umOutput.args.join(" ")}`,
+      runCommand: finalRunCommand,
       environmentVariables: Object.entries(umOutput.envVars || {}).map(([k, v]) => ({
         variable: k,
         value: String(v),
@@ -167,6 +215,9 @@ export async function localBuild(
   try {
     if (experiments.isEnabled("universalMaker")) {
       apphostingBuildOutput = runUniversalMaker(projectRoot, framework);
+      logger.debug(
+        `[apphosting] Universal Maker build outputFiles include: ${JSON.stringify(apphostingBuildOutput.outputFiles?.serverApp?.include ?? [])}`,
+      );
     } else {
       apphostingBuildOutput = (await localAppHostingBuild(
         projectRoot,

src/deploy/apphosting/util.ts

@@ -27,47 +27,93 @@ export async function createLocalBuildTarArchive(
 ): Promise<string> {
   const tmpFile = tmp.fileSync({ prefix: `${config.backendId}-`, postfix: ".tar.gz" }).name;
 
-  const targetDir = targetSubDir ? path.join(rootDir, targetSubDir) : rootDir;
+  const isAppHostingDir =
+    targetSubDir === ".apphosting" ||
+    (!!targetSubDir && path.basename(targetSubDir) === ".apphosting");
+  const targetDir = targetSubDir
+    ? path.isAbsolute(targetSubDir)
+      ? targetSubDir
+      : path.join(rootDir, targetSubDir)
+    : rootDir;
   const ignore = ["firebase-debug.log", "firebase-debug.*.log", ".git"];
-  const rdrFiles = await fsAsync.readdirRecursive({
-    path: targetDir,
-    ignore: ignore,
-    isGitIgnore: true,
-  });
-  const allFiles: string[] = rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name));
 
-  if (targetSubDir) {
-    const defaultFiles = fs.readdirSync(rootDir).filter((file) => {
-      return APPHOSTING_YAML_FILE_REGEX.test(file);
+  let archiveCwd = rootDir;
+  let pathsToPack: string[];
+
+  if (isAppHostingDir) {
+    // create temporary directory to bundle things flattened
+    const tempDir = tmp.dirSync({ unsafeCleanup: true }).name;
+    fs.cpSync(targetDir, tempDir, { recursive: true });
+
+    const rootPackageJson = path.join(rootDir, "package.json");
+    if (fs.existsSync(rootPackageJson)) {
+      fs.copyFileSync(rootPackageJson, path.join(tempDir, "package.json"));
+    }
+    const rootFiles = fs.readdirSync(rootDir);
+    for (const file of rootFiles) {
+      if (APPHOSTING_YAML_FILE_REGEX.test(file)) {
+        fs.copyFileSync(path.join(rootDir, file), path.join(tempDir, file));
+      }
+    }
+    const rootNext = path.join(rootDir, ".next");
+    if (fs.existsSync(rootNext)) {
+      fs.cpSync(rootNext, path.join(tempDir, ".next"), { recursive: true });
+    }
+    const rootNodeModules = path.join(rootDir, "node_modules");
+    if (fs.existsSync(rootNodeModules)) {
+      fs.cpSync(rootNodeModules, path.join(tempDir, "node_modules"), { recursive: true });
+    }
+
+    const rdrFiles = await fsAsync.readdirRecursive({
+      path: tempDir,
+      ignore: ignore,
+      isGitIgnore: false,
+    });
+    pathsToPack = rdrFiles.map((rdrf) => path.relative(tempDir, rdrf.name));
+    archiveCwd = tempDir;
+  } else {
+    const rdrFiles = await fsAsync.readdirRecursive({
+      path: targetDir,
+      ignore: ignore,
+      isGitIgnore: !targetSubDir, // Disable gitignore if we are anchored to a build output subdirectory
     });
-    for (const file of defaultFiles) {
-      if (!allFiles.includes(file)) {
-        allFiles.push(file);
+    pathsToPack = rdrFiles.map((rdrf) => path.relative(rootDir, rdrf.name));
+
+    if (targetSubDir) {
+      const defaultFiles = fs.readdirSync(rootDir).filter((file) => {
+        return APPHOSTING_YAML_FILE_REGEX.test(file);
+      });
+      for (const file of defaultFiles) {
+        const relativePath = path.relative(rootDir, path.join(rootDir, file));
+        if (!pathsToPack.includes(relativePath)) {
+          pathsToPack.push(relativePath);
+        }
       }
     }
   }
 
-  // `tar` returns a `TypeError` if `allFiles` is empty. Let's check a feww things.
   try {
-    fs.statSync(rootDir);
+    fs.statSync(archiveCwd);
   } catch (err: unknown) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
-      throw new FirebaseError(`Could not read directory "${rootDir}"`);
+      throw new FirebaseError(`Could not read directory "${archiveCwd}"`);
     }
     throw err;
   }
-  if (!allFiles.length) {
-    throw new FirebaseError(`Cannot create a tar archive with 0 files from directory "${rootDir}"`);
+  if (!pathsToPack.length) {
+    throw new FirebaseError(
+      `Cannot create a tar archive with 0 files from directory "${archiveCwd}"`,
+    );
   }
 
   await tar.create(
     {
       gzip: true,
       file: tmpFile,
-      cwd: rootDir,
+      cwd: archiveCwd,
       portable: true,
     },
-    allFiles,
+    pathsToPack,
   );
   return tmpFile;
 }