application.ts

import * as path from 'node:path';

import { parsePublishableKey } from '@clerk/shared/keys';
import { clerkSetup } from '@clerk/testing/playwright';

import { awaitableTreekill, createLogger, fs, getPort, run, waitForIdleProcess, waitForServer } from '../scripts';
import type { ApplicationConfig } from './applicationConfig.js';
import type { EnvironmentConfig } from './environment.js';

export type Application = ReturnType<typeof application>;

/**
 * Resolves the server URL for a dev/serve process, ensuring the runtime port
 * is always reflected in the URL. Uses the URL constructor to detect whether
 * an explicit port is present (avoiding false positives from the scheme colon).
 */
export const resolveServerUrl = (
  optsServerUrl: string | undefined,
  fallbackServerUrl: string | undefined,
  port: number,
): string => {
  if (optsServerUrl) {
    try {
      const parsed = new URL(optsServerUrl);
      if (!parsed.port) {
        parsed.port = String(port);
      }
      return parsed.origin;
    } catch {
      // Bare host (e.g. "localhost"), not a full URL
      return `${optsServerUrl}:${port}`;
    }
  }
  return fallbackServerUrl || `http://localhost:${port}`;
};

export const createAppRuntimeEnv = (env?: EnvironmentConfig): Record<string, string> => {
  if (!env?.publicVariables || !env?.privateVariables) {
    return {};
  }

  const runtimeEnv: Record<string, string> = {};
  // Private variables intentionally win when the same runtime key exists in both maps.
  for (const [key, value] of [...env.publicVariables, ...env.privateVariables]) {
    if (value === undefined || value === null) {
      continue;
    }

    runtimeEnv[key] = String(value);
  }

  return runtimeEnv;
};

export const application = (
  config: ApplicationConfig,
  appDirPath: string,
  appDirName: string,
  serverUrl: string | undefined,
) => {
  const { name, scripts, envWriter, copyKeylessToEnv } = config;
  const logger = createLogger({ prefix: `${appDirName}` });
  const state = { completedSetup: false, serverUrl: '', env: {} as EnvironmentConfig, lastDevPort: 0 };
  const cleanupFns: { (): unknown }[] = [];
  const now = Date.now();
  const stdoutFilePath = path.resolve(appDirPath, `e2e.${now}.log`);
  const stderrFilePath = path.resolve(appDirPath, `e2e.${now}.err.log`);
  let buildOutput = '';
  let serveOutput = '';

  const self = {
    name,
    scripts,
    appDir: appDirPath,
    get serverUrl() {
      return state.serverUrl;
    },
    get env() {
      return state.env;
    },
    withEnv: async (env: EnvironmentConfig) => {
      state.env = env;
      return envWriter(appDirPath, env);
    },
    keylessToEnv: async () => {
      return copyKeylessToEnv(appDirPath);
    },
    setup: async (opts?: { strategy?: 'ci' | 'i' | 'copy'; force?: boolean }) => {
      const { force } = opts || {};
      const nodeModulesExist = await fs.pathExists(path.resolve(appDirPath, 'node_modules'));
      if (force || !nodeModulesExist) {
        const log = logger.child({ prefix: 'setup' }).info;
        // Use pkglab add to install packages from the local registry,
        // unless E2E_SDK_SOURCE=latest which installs from npm instead
        const pkglabDeps = config.pkglabDependencies;
        if (pkglabDeps.length > 0 && process.env.E2E_SDK_SOURCE !== 'latest') {
          await run(`pkglab add ${pkglabDeps.join(' ')}`, { cwd: appDirPath, log });
        } else {
          await run(scripts.setup, { cwd: appDirPath, log });
        }
        state.completedSetup = true;
        // Print all Clerk package versions (direct and transitive)
        const clerkPackagesLog = logger.child({ prefix: 'clerk-packages' }).info;
        clerkPackagesLog('Installed @clerk/* packages:');
        await run('pnpm list @clerk/* --depth 100', { cwd: appDirPath, log: clerkPackagesLog });
      }
    },
    dev: async (opts: { port?: number; manualStart?: boolean; detached?: boolean; serverUrl?: string } = {}) => {
      const log = logger.child({ prefix: 'dev' }).info;
      const port = opts.port || (await getPort());
      const runtimeServerUrl = resolveServerUrl(opts.serverUrl, serverUrl, port);
      log(`Will try to serve app at ${runtimeServerUrl}`);
      if (opts.manualStart) {
        // for debugging, you can start the dev server manually by cd'ing into the temp dir
        // and running the corresponding dev command
        // this allows the test to run as normally, while setup is controlled by you,
        // so you can inspect the running up outside the PW lifecycle
        state.serverUrl = runtimeServerUrl;
        return { port, serverUrl: runtimeServerUrl };
      }

      const proc = run(scripts.dev, {
        cwd: appDirPath,
        env: { ...createAppRuntimeEnv(state.env), PORT: port.toString() },
        detached: opts.detached,
        stdout: opts.detached ? fs.openSync(stdoutFilePath, 'a') : undefined,
        stderr: opts.detached ? fs.openSync(stderrFilePath, 'a') : undefined,
        log: opts.detached ? undefined : log,
      });

      const shouldExit = () => !!proc.exitCode && proc.exitCode !== 0;
      await waitForServer(runtimeServerUrl, { log, maxAttempts: Infinity, shouldExit });
      log(`Server started at ${runtimeServerUrl}, pid: ${proc.pid}`);
      cleanupFns.push(() => awaitableTreekill(proc.pid, 'SIGKILL'));
      state.serverUrl = runtimeServerUrl;

      // Setup Clerk testing tokens after the server is running
      if (state.env) {
        try {
          const publishableKey = state.env.publicVariables.get('CLERK_PUBLISHABLE_KEY');
          const secretKey = state.env.privateVariables.get('CLERK_SECRET_KEY');
          const apiUrl = state.env.privateVariables.get('CLERK_API_URL');

          if (publishableKey && secretKey) {
            const { instanceType, frontendApi: frontendApiUrl } = parsePublishableKey(publishableKey);

            if (instanceType !== 'development') {
              log('Skipping clerkSetup for non-development instance');
            } else {
              await clerkSetup({
                publishableKey,
                frontendApiUrl,
                secretKey,
                // @ts-expect-error apiUrl is not a typed option for clerkSetup, but it is accepted at runtime.
                apiUrl,
                dotenv: false,
              });
              log('Clerk testing tokens setup complete');
            }
          }
        } catch (error) {
          logger.warn('Failed to setup Clerk testing tokens:', error);
        }
      }

      state.lastDevPort = port;
      return { port, serverUrl: runtimeServerUrl, pid: proc.pid };
    },
    restart: async () => {
      const log = logger.child({ prefix: 'restart' }).info;
      log('Restarting dev server...');
      await self.stop();
      return self.dev({ port: state.lastDevPort });
    },
    build: async () => {
      const log = logger.child({ prefix: 'build' }).info;
      await run(scripts.build, {
        cwd: appDirPath,
        env: createAppRuntimeEnv(state.env),
        log: (msg: string) => {
          buildOutput += `\n${msg}`;
          log(msg);
        },
      });
    },
    get buildOutput() {
      return buildOutput;
    },
    get serveOutput() {
      return serveOutput;
    },
    serve: async (opts: { port?: number; manualStart?: boolean; detached?: boolean; serverUrl?: string } = {}) => {
      const log = logger.child({ prefix: 'serve' }).info;
      const port = opts.port || (await getPort());
      const runtimeServerUrl = resolveServerUrl(opts.serverUrl, serverUrl, port);
      log(`Will try to serve app at ${runtimeServerUrl}`);

      if (opts.manualStart) {
        state.serverUrl = runtimeServerUrl;
        return { port, serverUrl: runtimeServerUrl };
      }

      // Read .env file and pass as process env vars since production servers
      // may not auto-load .env files (e.g., react-router-serve)
      const envFromFile: Record<string, string> = {};
      const envFilePath = path.resolve(appDirPath, '.env');
      if (fs.existsSync(envFilePath)) {
        const envContent = fs.readFileSync(envFilePath, 'utf-8');
        for (const line of envContent.split('\n')) {
          const trimmed = line.trim();
          if (trimmed && !trimmed.startsWith('#')) {
            const eqIdx = trimmed.indexOf('=');
            if (eqIdx > 0) {
              envFromFile[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
            }
          }
        }
      }

      const proc = run(scripts.serve, {
        cwd: appDirPath,
        env: { ...envFromFile, ...createAppRuntimeEnv(state.env), PORT: port.toString() },
        detached: opts.detached,
        stdout: opts.detached ? fs.openSync(stdoutFilePath, 'a') : undefined,
        stderr: opts.detached ? fs.openSync(stderrFilePath, 'a') : undefined,
        log: opts.detached
          ? undefined
          : (msg: string) => {
              serveOutput += `\n${msg}`;
              log(msg);
            },
      });

      if (opts.detached) {
        const shouldExit = () => !!proc.exitCode && proc.exitCode !== 0;
        await waitForServer(runtimeServerUrl, { log, maxAttempts: Infinity, shouldExit });
      } else {
        await waitForIdleProcess(proc);
      }

      log(`Server started at ${runtimeServerUrl}, pid: ${proc.pid}`);
      cleanupFns.push(() => awaitableTreekill(proc.pid, 'SIGKILL'));
      state.serverUrl = runtimeServerUrl;
      return { port, serverUrl: runtimeServerUrl, pid: proc.pid };
    },
    stop: async () => {
      logger.info('Stopping...');
      await Promise.all(cleanupFns.map(fn => fn()));
      cleanupFns.splice(0, cleanupFns.length);
      state.serverUrl = '';
      return new Promise(res => setTimeout(res, 2000));
    },
    teardown: async () => {
      logger.info('Tearing down...');
      await self.stop();
      try {
        fs.rmSync(appDirPath, { recursive: true, force: true });
      } catch (e) {
        console.log(e);
      }
    },
  };
  return self;
};