@i-santos/firestack 1.0.0

package/scripts/cli/internal-log-router.mjs

@@ -0,0 +1,116 @@
+import { createWriteStream, mkdirSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import readline from 'node:readline';
+
+function parseArgs(argv) {
+  const args = {
+    mode: 'compact',
+    infraLog: 'out/tests/infra/emulator.log',
+    suiteLog: 'out/tests/suite/output.log',
+    append: false,
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = argv[i];
+    if (token === '--mode') {
+      args.mode = String(argv[i + 1] ?? '').trim().toLowerCase();
+      i += 1;
+      continue;
+    }
+    if (token === '--infra-log') {
+      args.infraLog = String(argv[i + 1] ?? args.infraLog).trim() || args.infraLog;
+      i += 1;
+      continue;
+    }
+    if (token === '--suite-log') {
+      args.suiteLog = String(argv[i + 1] ?? args.suiteLog).trim() || args.suiteLog;
+      i += 1;
+      continue;
+    }
+    if (token === '--append') {
+      args.append = true;
+      continue;
+    }
+    if (token === '--reset') {
+      args.append = false;
+      continue;
+    }
+    throw new Error(`unknown argument: ${token}`);
+  }
+
+  if (!new Set(['compact', 'verbose', 'quiet']).has(args.mode)) {
+    throw new Error(`invalid --mode "${args.mode}" (expected compact|verbose|quiet)`);
+  }
+  return args;
+}
+
+function ensureParentDir(path) {
+  mkdirSync(dirname(resolve(path)), { recursive: true });
+}
+
+function stripAnsi(text) {
+  return text.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+}
+
+function isInfraLine(rawLine) {
+  const line = stripAnsi(rawLine).trimStart();
+  if (/^(i|✔|⚠)\s{2}(functions(?:\[[^\]]+\])?|hosting(?:\[[^\]]+\])?|firestore|auth|emulators|hub|logging|eventarc|tasks|extensions):/.test(line)) {
+    return true;
+  }
+  if (/^i\s{2}Running script:/.test(line)) {
+    return true;
+  }
+  if (/^⚠\s{2}Script exited unsuccessfully/.test(line)) {
+    return true;
+  }
+  if (/^Serving at port \d+/.test(line)) {
+    return true;
+  }
+  if (/^>\s+\{/.test(line) && line.includes('"firebase-log-type"')) {
+    return true;
+  }
+  return false;
+}
+
+function isInfraImportant(rawLine) {
+  const line = stripAnsi(rawLine).trimStart();
+  return line.startsWith('⚠') || line.startsWith('Error:') || line.includes(' exited unsuccessfully ');
+}
+
+function shouldWriteInfraToConsole(line, mode) {
+  if (mode === 'verbose') return true;
+  if (mode === 'quiet') return isInfraImportant(line);
+  return isInfraImportant(line);
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  ensureParentDir(args.infraLog);
+  ensureParentDir(args.suiteLog);
+
+  const fileMode = args.append ? 'a' : 'w';
+  const infraStream = createWriteStream(args.infraLog, { flags: fileMode });
+  const suiteStream = createWriteStream(args.suiteLog, { flags: fileMode });
+  const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+  input.on('line', (line) => {
+    const isInfra = isInfraLine(line);
+    if (isInfra) {
+      infraStream.write(`${line}\n`);
+      if (shouldWriteInfraToConsole(line, args.mode)) {
+        process.stdout.write(`${line}\n`);
+      }
+      return;
+    }
+
+    suiteStream.write(`${line}\n`);
+    process.stdout.write(`${line}\n`);
+  });
+
+  input.on('close', () => {
+    infraStream.end();
+    suiteStream.end();
+  });
+}
+
+main();

package/scripts/cli/internal-run-e2e-staging.mjs

@@ -0,0 +1,49 @@
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import {
+  buildRunId,
+  requireProject,
+  resolveStagingCredentials,
+  resolveSuite,
+  validateStagingBaseUrl,
+} from './internal-e2e-runner.mjs';
+
+const suite = resolveSuite(process.argv[2]);
+const runId = buildRunId(process.env.E2E_RUN_ID ?? `stg-${suite}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+const configuredProjectId = process.env.STAGING_PROJECT_ID?.trim();
+const currentProjectId = process.env.GCLOUD_PROJECT?.trim();
+if (!currentProjectId) {
+  throw new Error(
+    '[test:e2e:staging] missing GCLOUD_PROJECT. Set it explicitly or configure .firebaserc (default alias or FIREBASE_ALIAS).'
+  );
+}
+const projectId = configuredProjectId
+  ? requireProject(configuredProjectId, currentProjectId, '[test:e2e:staging]')
+  : currentProjectId;
+const baseUrl = process.env.E2E_BASE_URL ?? 'https://staging.presentgoal.com';
+validateStagingBaseUrl(baseUrl, '[test:e2e:staging]');
+
+const { emailVar, passwordVar, email, password, useFixedUser } = resolveStagingCredentials(suite);
+if (!useFixedUser) {
+  console.log('[test:e2e:staging] Running with ephemeral user (no fixed credentials provided).');
+  console.log(`[test:e2e:staging] To use fixed user set ${emailVar}/${passwordVar} or E2E_STAGING_EMAIL/E2E_STAGING_PASSWORD.`);
+}
+
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const e2eRunnerPath = join(currentDir, 'internal-run-e2e.mjs');
+
+const result = spawnSync('node', [e2eRunnerPath, suite], {
+  stdio: 'inherit',
+  env: {
+    ...process.env,
+    E2E_BASE_URL: baseUrl,
+    E2E_SUITE: suite,
+    E2E_CLEANUP: process.env.E2E_CLEANUP ?? 'false',
+    E2E_RUN_ID: runId,
+    GCLOUD_PROJECT: projectId,
+    ...(useFixedUser ? { E2E_EMAIL: email, E2E_PASSWORD: password } : {}),
+  },
+});
+
+process.exit(result.status ?? 1);

package/scripts/cli/internal-run-e2e.mjs

@@ -0,0 +1,153 @@
+import { existsSync } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
+import { buildPlaywrightFilterArgs, buildRunId, resolveSuite, validateExternalBaseUrl } from './internal-e2e-runner.mjs';
+
+const hasPlaywrightPkg = existsSync('node_modules/@playwright/test/package.json');
+const playwrightBin = process.platform === 'win32'
+  ? 'node_modules/.bin/playwright.cmd'
+  : 'node_modules/.bin/playwright';
+
+if (!hasPlaywrightPkg || !existsSync(playwrightBin)) {
+  console.log('[test:e2e] @playwright/test is not installed. Skipping E2E.');
+  console.log('[test:e2e] To enable: npm install -D @playwright/test && npx playwright install');
+  process.exit(0);
+}
+
+async function waitForUrl(url, timeoutMs = 40_000) {
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < timeoutMs) {
+    try {
+      const res = await fetch(url);
+      if (res.ok || res.status === 404) return;
+    } catch {
+      // retry
+    }
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, 350));
+  }
+  throw new Error(`Timeout waiting for app at ${url}`);
+}
+
+function detectViteUrlFromOutput(line) {
+  const clean = line.replace(/\x1B\[[0-9;]*[A-Za-z]/g, '');
+  const direct = clean.match(/(https?:\/\/127\.0\.0\.1:\d+)/);
+  if (direct) return direct[1];
+  const local = clean.match(/Local:\s+(https?:\/\/[^\s]+)/);
+  return local ? local[1] : null;
+}
+
+function startDevServer() {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let stdoutBuffer = '';
+    let stderrBuffer = '';
+    const devServer = spawn('npm', ['run', 'dev', '--', '--host', '127.0.0.1', '--port', '5173'], {
+      detached: process.platform !== 'win32',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        VITE_USE_FIREBASE_EMULATOR: process.env.VITE_USE_FIREBASE_EMULATOR ?? 'true',
+        VITE_FIREBASE_EMULATOR_HOST: process.env.VITE_FIREBASE_EMULATOR_HOST ?? '127.0.0.1',
+      },
+    });
+
+    const onData = (chunk) => {
+      const text = chunk.toString();
+      process.stdout.write(text);
+      if (settled) return;
+      stdoutBuffer = `${stdoutBuffer}${text}`.slice(-16_384);
+      const foundUrl = detectViteUrlFromOutput(stdoutBuffer);
+      if (foundUrl) {
+        settled = true;
+        resolve({ devServer, baseUrl: foundUrl });
+        return;
+      }
+      // Fallback: if Vite is ready but URL line is styled/fragmented unexpectedly,
+      // use the known host/port we launch with.
+      if (/VITE\s+v\d/i.test(stdoutBuffer) && /\bready in\b/i.test(stdoutBuffer)) {
+        settled = true;
+        resolve({ devServer, baseUrl: 'http://127.0.0.1:5173' });
+      }
+    };
+
+    const onError = (chunk) => {
+      const text = chunk.toString();
+      process.stderr.write(text);
+      stderrBuffer = `${stderrBuffer}${text}`.slice(-8_192);
+      if (!settled && /error/i.test(text)) {
+        settled = true;
+        reject(new Error(`[test:e2e] failed to start app: ${stderrBuffer.trim()}`));
+      }
+    };
+
+    devServer.stdout.on('data', onData);
+    devServer.stderr.on('data', onError);
+    devServer.on('exit', (code) => {
+      if (!settled) {
+        settled = true;
+        reject(new Error(`[test:e2e] dev server exited before startup (code=${code ?? 'null'})`));
+      }
+    });
+  });
+}
+
+function stopDevServer(devServer) {
+  if (!devServer || devServer.killed) return;
+  try {
+    if (process.platform !== 'win32' && typeof devServer.pid === 'number') {
+      process.kill(-devServer.pid, 'SIGTERM');
+      return;
+    }
+    devServer.kill('SIGTERM');
+  } catch {
+    // ignore teardown errors
+  }
+}
+
+async function main() {
+  const suite = resolveSuite(process.argv[2]);
+  const filterArgs = buildPlaywrightFilterArgs(suite);
+  const runId = buildRunId(process.env.E2E_RUN_ID);
+  const externalBaseUrl = process.env.E2E_BASE_URL?.trim();
+  validateExternalBaseUrl(externalBaseUrl, '[test:e2e]');
+  const shouldStartDevServer = !externalBaseUrl;
+  const projectId = process.env.GCLOUD_PROJECT?.trim();
+  let devServer = null;
+  let baseUrl = externalBaseUrl ?? '';
+
+  try {
+    if (shouldStartDevServer) {
+      console.log('[test:e2e] starting app with Vite (prefers 5173; auto-fallback enabled)...');
+      const started = await startDevServer();
+      devServer = started.devServer;
+      baseUrl = started.baseUrl;
+      await waitForUrl(baseUrl);
+    } else {
+      console.log(`[test:e2e] using existing app at ${baseUrl}`);
+    }
+
+    const cleanup = process.env.E2E_CLEANUP ?? (shouldStartDevServer ? 'true' : 'false');
+    const result = spawnSync(playwrightBin, ['test', '--project=chromium', ...filterArgs, 'tests/e2e'], {
+      stdio: 'inherit',
+      env: {
+        ...process.env,
+        E2E_SUITE: suite,
+        E2E_RUN_ID: runId,
+        E2E_CLEANUP: cleanup,
+        E2E_BASE_URL: baseUrl,
+        ...(projectId ? { GCLOUD_PROJECT: projectId } : {}),
+        FIREBASE_AUTH_EMULATOR_HOST: process.env.FIREBASE_AUTH_EMULATOR_HOST ?? '127.0.0.1:9099',
+        FIRESTORE_EMULATOR_HOST: process.env.FIRESTORE_EMULATOR_HOST ?? '127.0.0.1:8080',
+      },
+    });
+
+    process.exit(result.status ?? 1);
+  } finally {
+    stopDevServer(devServer);
+  }
+}
+
+main().catch((error) => {
+  console.error('[test:e2e] failed to run e2e:', error);
+  process.exit(1);
+});

package/scripts/cli/internal-run-functions-build.mjs

@@ -0,0 +1,91 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawnSync } from 'node:child_process';
+
+function readJsonStrict(path) {
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function normalizeRelativePath(value) {
+  if (typeof value !== 'string') return null;
+  const normalized = value.trim().replace(/\\/g, '/').replace(/^\.?\//, '');
+  if (!normalized || normalized.startsWith('/') || normalized.includes('..')) return null;
+  return normalized;
+}
+
+function resolveFirebaseConfigPath(cwd) {
+  const configured = process.env.FIRESTACK_FIREBASE_CONFIG_PATH?.trim();
+  if (configured) {
+    const candidate = resolve(cwd, configured);
+    if (!existsSync(candidate)) {
+      throw new Error(`[test:functions:build] firebase config not found: ${candidate}`);
+    }
+    return candidate;
+  }
+  const fallback = resolve(cwd, 'firebase.json');
+  return existsSync(fallback) ? fallback : null;
+}
+
+function discoverFunctionsPaths(cwd, firebaseConfigPath) {
+  const discovered = [];
+  const addCandidate = (candidate) => {
+    const normalized = normalizeRelativePath(candidate);
+    if (!normalized) return;
+    if (existsSync(resolve(cwd, normalized, 'package.json'))) {
+      discovered.push(normalized);
+    }
+  };
+
+  if (firebaseConfigPath) {
+    const firebaseJson = readJsonStrict(firebaseConfigPath);
+    const functionsConfig = firebaseJson?.functions;
+    if (typeof functionsConfig === 'string') {
+      addCandidate(functionsConfig);
+    } else if (Array.isArray(functionsConfig)) {
+      for (const entry of functionsConfig) {
+        if (typeof entry === 'string') addCandidate(entry);
+        else if (entry && typeof entry === 'object') addCandidate(entry.source);
+      }
+    } else if (functionsConfig && typeof functionsConfig === 'object') {
+      addCandidate(functionsConfig.source);
+    }
+  }
+
+  if (discovered.length === 0 && existsSync(resolve(cwd, 'functions', 'package.json'))) {
+    discovered.push('functions');
+  }
+
+  return [...new Set(discovered)];
+}
+
+function runBuild(cwd, modulePath) {
+  console.log(`[test:functions:build] building ${modulePath}`);
+  const result = spawnSync('npm', ['--prefix', modulePath, 'run', 'build'], {
+    cwd,
+    stdio: 'inherit',
+    env: process.env,
+  });
+  if (result.error) {
+    throw new Error(`[test:functions:build] failed to run npm build in ${modulePath}: ${result.error.message}`);
+  }
+  if ((result.status ?? 1) !== 0) {
+    process.exit(result.status ?? 1);
+  }
+}
+
+const cwd = process.cwd();
+const firebaseConfigPath = resolveFirebaseConfigPath(cwd);
+const functionPaths = discoverFunctionsPaths(cwd, firebaseConfigPath);
+
+if (functionPaths.length === 0) {
+  console.log('[test:functions:build] no functions modules found. skipping build step.');
+  process.exit(0);
+}
+
+for (const modulePath of functionPaths) {
+  runBuild(cwd, modulePath);
+}

package/scripts/cli/internal-run-integration-report.mjs

@@ -0,0 +1,132 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+const OUT_DIR = 'out/tests/integration';
+const SERIAL_XML = `${OUT_DIR}/serial.junit.xml`;
+const PARALLEL_XML = `${OUT_DIR}/parallel.junit.xml`;
+const COMBINED_XML = `${OUT_DIR}/junit.xml`;
+const SERIAL_MARKER_RE = /@test-mode\s+serial/i;
+
+function listIntegrationTests(dir = 'tests/integration') {
+  const entries = readdirSync(dir);
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stats = statSync(fullPath);
+    if (stats.isDirectory()) {
+      if (entry.startsWith('_')) continue;
+      files.push(...listIntegrationTests(fullPath));
+      continue;
+    }
+    if (entry.endsWith('.test.ts')) files.push(fullPath);
+  }
+  return files.sort();
+}
+
+function getTestExecutionMode(filePath) {
+  const source = readFileSync(filePath, 'utf8');
+  return SERIAL_MARKER_RE.test(source) ? 'serial' : 'concurrent';
+}
+
+function runNodeTest({ concurrency, destination, tests }) {
+  const args = [
+    '--test',
+    '--experimental-strip-types',
+    '--test-reporter=spec',
+    '--test-reporter=junit',
+    '--test-reporter-destination=stdout',
+    `--test-reporter-destination=${destination}`,
+    `--test-concurrency=${concurrency}`,
+    ...tests,
+  ];
+  return spawnSync('node', args, { stdio: 'inherit' });
+}
+
+function emptyJUnitXml() {
+  return '<?xml version="1.0" encoding="utf-8"?>\n<testsuites>\n</testsuites>\n';
+}
+
+function extractInnerTestSuites(xml) {
+  return xml
+    .replace(/^<\?xml[^>]*>\s*/m, '')
+    .replace(/^\s*<testsuites>\s*/m, '')
+    .replace(/\s*<\/testsuites>\s*$/m, '')
+    .trim();
+}
+
+function combineJunit(serialPath, parallelPath, outPath) {
+  const serialXml = readFileSync(serialPath, 'utf8');
+  const parallelXml = readFileSync(parallelPath, 'utf8');
+  const serialInner = extractInnerTestSuites(serialXml);
+  const parallelInner = extractInnerTestSuites(parallelXml);
+  const merged = ['<?xml version="1.0" encoding="utf-8"?>', '<testsuites>', serialInner, parallelInner, '</testsuites>', '']
+    .join('\n');
+  writeFileSync(outPath, merged, 'utf8');
+}
+
+function ensureJUnitFile(path) {
+  try {
+    readFileSync(path, 'utf8');
+  } catch {
+    writeFileSync(path, emptyJUnitXml(), 'utf8');
+  }
+}
+
+function getResultStatus(result) {
+  if (!result) return 1;
+  if (result.error) {
+    console.error(`[test:integration:report] failed to execute node test: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 1;
+}
+
+function main() {
+  mkdirSync(OUT_DIR, { recursive: true });
+  const allTests = listIntegrationTests();
+  const serialTests = [];
+  const parallelTests = [];
+  let serialStatus = 0;
+  let parallelStatus = 0;
+
+  for (const file of allTests) {
+    if (getTestExecutionMode(file) === 'serial') serialTests.push(file);
+    else parallelTests.push(file);
+  }
+
+  if (serialTests.length > 0) {
+    const serialResult = runNodeTest({
+      concurrency: 1,
+      destination: SERIAL_XML,
+      tests: serialTests,
+    });
+    ensureJUnitFile(SERIAL_XML);
+    serialStatus = getResultStatus(serialResult);
+  } else {
+    writeFileSync(SERIAL_XML, emptyJUnitXml(), 'utf8');
+  }
+
+  const requestedConcurrency = Number(process.env.TEST_CONCURRENCY ?? '');
+  const parallelConcurrency = Number.isFinite(requestedConcurrency) && requestedConcurrency > 0 ? requestedConcurrency : 8;
+
+  if (parallelTests.length > 0) {
+    const parallelResult = runNodeTest({
+      concurrency: parallelConcurrency,
+      destination: PARALLEL_XML,
+      tests: parallelTests,
+    });
+    ensureJUnitFile(PARALLEL_XML);
+    parallelStatus = getResultStatus(parallelResult);
+  } else {
+    writeFileSync(PARALLEL_XML, emptyJUnitXml(), 'utf8');
+  }
+
+  combineJunit(SERIAL_XML, PARALLEL_XML, COMBINED_XML);
+
+  if (serialStatus !== 0 || parallelStatus !== 0) {
+    process.exit(serialStatus !== 0 ? serialStatus : parallelStatus);
+  }
+}
+
+main();