refactor: replace stdio discovery with file-based manifest output

- Remove XML-style stdio discovery mode
- Add FUNCTIONS_MANIFEST_OUTPUT_PATH environment variable support
- Write manifest directly to specified file path when env var is set
- Update tests to use file-based discovery instead of stdio parsing
- Simplify error handling with direct stderr output

Author: taeold

scripts/bin-test/test.ts

@@ -1,6 +1,8 @@
 import * as subprocess from "child_process";
 import * as path from "path";
 import { promisify } from "util";
+import * as fs from "fs/promises";
+import * as os from "os";
 
 import { expect } from "chai";
 import * as yaml from "js-yaml";
@@ -185,15 +187,16 @@ async function runHttpDiscovery(modulePath: string): Promise<DiscoveryResult> {
   }
 }
 
-async function runStdioDiscovery(modulePath: string): Promise<DiscoveryResult> {
+async function runFileDiscovery(modulePath: string): Promise<DiscoveryResult> {
+  const outputPath = path.join(os.tmpdir(), `firebase-functions-test-${Date.now()}.json`);
+  
   return new Promise((resolve, reject) => {
     const proc = subprocess.spawn("npx", ["firebase-functions"], {
       cwd: path.resolve(modulePath),
       env: {
         PATH: process.env.PATH,
         GCLOUD_PROJECT: "test-project",
-        FUNCTIONS_CONTROL_API: "true",
-        FUNCTIONS_DISCOVERY_MODE: "stdio",
+        FUNCTIONS_MANIFEST_OUTPUT_PATH: outputPath,
       },
     });
 
@@ -205,31 +208,26 @@ async function runStdioDiscovery(modulePath: string): Promise<DiscoveryResult> {
 
     const timeoutId = setTimeout(() => {
       proc.kill(9);
-      reject(new Error(`Stdio discovery timed out after ${TIMEOUT_M}ms`));
+      resolve({ success: false, error: `File discovery timed out after ${TIMEOUT_M}ms` });
     }, TIMEOUT_M);
 
-    proc.on("close", () => {
+    proc.on("close", async (code) => {
       clearTimeout(timeoutId);
-      const manifestMatch = stderr.match(
-        /<FIREBASE_FUNCTIONS_MANIFEST>\n([\s\S]+?)\n<\/FIREBASE_FUNCTIONS_MANIFEST>/
-      );
-      if (manifestMatch) {
-        const base64 = manifestMatch[1];
-        const manifestJson = Buffer.from(base64, "base64").toString("utf8");
-        const manifest = JSON.parse(manifestJson) as Record<string, unknown>;
-        resolve({ success: true, manifest });
-        return;
-      }
-
-      const errorMatch = stderr.match(
-        /<FIREBASE_FUNCTIONS_MANIFEST_ERROR>\n([\s\S]+?)\n<\/FIREBASE_FUNCTIONS_MANIFEST_ERROR>/
-      );
-      if (errorMatch) {
-        resolve({ success: false, error: errorMatch[1] });
-        return;
+      
+      if (code === 0) {
+        try {
+          const manifestJson = await fs.readFile(outputPath, "utf8");
+          const manifest = JSON.parse(manifestJson) as Record<string, unknown>;
+          await fs.unlink(outputPath).catch(() => {});
+          resolve({ success: true, manifest });
+        } catch (e) {
+          resolve({ success: false, error: `Failed to read manifest file: ${e}` });
+        }
+      } else {
+        const errorLines = stderr.split('\n').filter(line => line.trim());
+        const errorMessage = errorLines.join(' ') || "No error message found";
+        resolve({ success: false, error: errorMessage });
       }
-
-      resolve({ success: false, error: "No manifest or error found" });
     });
 
     proc.on("error", (err) => {
@@ -245,7 +243,7 @@ describe("functions.yaml", function () {
 
   const discoveryMethods = [
     { name: "http", fn: runHttpDiscovery },
-    { name: "stdio", fn: runStdioDiscovery },
+    { name: "file", fn: runFileDiscovery },
   ];
 
   function runDiscoveryTests(

src/bin/firebase-functions.ts

@@ -24,6 +24,7 @@
 
 import * as http from "http";
 import * as express from "express";
+import * as fs from "fs/promises";
 import { loadStack } from "../runtime/loader";
 import { stackToWire } from "../runtime/manifest";
 
@@ -49,37 +50,33 @@ if (args.length > 1) {
   functionsDir = args[0];
 }
 
-const MANIFEST_START_TAG = "<FIREBASE_FUNCTIONS_MANIFEST>";
-const MANIFEST_END_TAG = "</FIREBASE_FUNCTIONS_MANIFEST>";
-const MANIFEST_ERROR_START_TAG = "<FIREBASE_FUNCTIONS_MANIFEST_ERROR>";
-const MANIFEST_ERROR_END_TAG = "</FIREBASE_FUNCTIONS_MANIFEST_ERROR>";
-
-async function runStdioDiscovery() {
-  try {
-    const stack = await loadStack(functionsDir);
-    const wireFormat = stackToWire(stack);
-    const manifestJson = JSON.stringify(wireFormat);
-    const base64 = Buffer.from(manifestJson).toString("base64");
-    process.stderr.write(`${MANIFEST_START_TAG}\n${base64}\n${MANIFEST_END_TAG}\n`);
-    process.exitCode = 0;
-  } catch (e) {
-    const message = `Failed to generate manifest from function source: ${
-      e instanceof Error ? e.message : String(e)
-    }`;
-    process.stderr.write(`${MANIFEST_ERROR_START_TAG}\n${message}\n${MANIFEST_ERROR_END_TAG}\n`);
-  }
-}
-
 function handleQuitquitquit(req: express.Request, res: express.Response, server: http.Server) {
   res.send("ok");
   server.close();
 }
 
-if (
-  process.env.FUNCTIONS_CONTROL_API === "true" &&
-  process.env.FUNCTIONS_DISCOVERY_MODE === "stdio"
-) {
-  void runStdioDiscovery();
+if (process.env.FUNCTIONS_MANIFEST_OUTPUT_PATH) {
+  void (async () => {
+    try {
+      const stack = await loadStack(functionsDir);
+      const wireFormat = stackToWire(stack);
+      await fs.writeFile(
+        process.env.FUNCTIONS_MANIFEST_OUTPUT_PATH,
+        JSON.stringify(wireFormat, null, 2)
+      );
+      process.exit(0);
+    } catch (e) {
+      console.error(
+        `Failed to generate manifest from function source: ${
+          e instanceof Error ? e.message : String(e)
+        }`
+      );
+      if (e instanceof Error && e.stack) {
+        console.error(e.stack);
+      }
+      process.exit(1);
+    }
+  })();
 } else {
   let server: http.Server = undefined;
   const app = express();