Refactor and improve external URL checks

- Move external URL checks to its own module under `tests/`. This
  separates them from integration test, addressing long runs and
  frequent failures that led to ignoring test results.
- Move `check-desktop-runtime-errors` to `tests/checks` to keep all
  test-related checks into one directory.
- Replace `ts-node` with `vite` for running
  `check-desktop-runtime-errors` to maintain a consistent execution
  environment across checks.
- Implement a timeout for each fetch call.
- Be nice to external sources, wait 5 seconds before sending another
  request to an URL under same domain. This solves rate-limiting issues.
- Instead of running test on every push/pull request, run them only
  weekly.
- Do not run tests on each commit/PR but only scheduled (weekly) to
  minimize noise.
- Fix URLs are not captured correctly inside backticks or parenthesis.

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/io.ts

@@ -0,0 +1,21 @@
+import { readdir, access } from 'fs/promises';
+import { constants } from 'fs';
+
+export async function exists(path: string): Promise<boolean> {
+  if (!path) { throw new Error('Missing path'); }
+  try {
+    await access(path, constants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function isDirMissingOrEmpty(dir: string): Promise<boolean> {
+  if (!dir) { throw new Error('Missing directory'); }
+  if (!await exists(dir)) {
+    return true;
+  }
+  const contents = await readdir(dir);
+  return contents.length === 0;
+}

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/log.ts

@@ -0,0 +1,68 @@
+export enum LogLevel {
+  Info,
+  Warn,
+  Error,
+}
+
+export function log(message: string, level = LogLevel.Info): void {
+  const timestamp = new Date().toISOString();
+  const config = LOG_LEVEL_CONFIG[level] || LOG_LEVEL_CONFIG[LogLevel.Info];
+  const logLevelText = `${getColorCode(config.color)}${LOG_LEVEL_LABELS[level]}${getColorCode(TextColor.Reset)}`;
+  const formattedMessage = `[${timestamp}][${logLevelText}] ${message}`;
+  config.method(formattedMessage);
+}
+
+export function die(message: string): never {
+  log(message, LogLevel.Error);
+  return process.exit(1);
+}
+
+enum TextColor {
+  Reset,
+  LightRed,
+  Yellow,
+  LightBlue,
+}
+
+function getColorCode(color: TextColor): string {
+  return COLOR_CODE_MAPPING[color];
+}
+
+const LOG_LEVEL_LABELS: {
+  readonly [K in LogLevel]: string;
+} = {
+  [LogLevel.Info]: 'INFO',
+  [LogLevel.Error]: 'ERROR',
+  [LogLevel.Warn]: 'WARN',
+};
+
+const COLOR_CODE_MAPPING: {
+  readonly [K in TextColor]: string;
+} = {
+  [TextColor.Reset]: '\x1b[0m',
+  [TextColor.LightRed]: '\x1b[91m',
+  [TextColor.Yellow]: '\x1b[33m',
+  [TextColor.LightBlue]: '\x1b[94m',
+};
+
+interface ColorLevelConfig {
+  readonly color: TextColor;
+  readonly method: (...data: unknown[]) => void;
+}
+
+const LOG_LEVEL_CONFIG: {
+  readonly [K in LogLevel]: ColorLevelConfig;
+} = {
+  [LogLevel.Info]: {
+    color: TextColor.LightBlue,
+    method: console.log,
+  },
+  [LogLevel.Warn]: {
+    color: TextColor.Yellow,
+    method: console.warn,
+  },
+  [LogLevel.Error]: {
+    color: TextColor.LightRed,
+    method: console.error,
+  },
+};

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/npm.ts

@@ -0,0 +1,127 @@
+import { join } from 'path';
+import { rm, readFile } from 'fs/promises';
+import { exists, isDirMissingOrEmpty } from './io';
+import { CommandResult, runCommand } from './run-command';
+import { LogLevel, die, log } from './log';
+import { sleep } from './sleep';
+import type { ExecOptions } from 'child_process';
+
+const NPM_INSTALL_MAX_RETRIES = 3;
+const NPM_INSTALL_RETRY_DELAY_MS = 5 /* seconds */ * 1000;
+
+export async function ensureNpmProjectDir(projectDir: string): Promise<void> {
+  if (!projectDir) { throw new Error('missing project directory'); }
+  if (!await exists(join(projectDir, 'package.json'))) {
+    die(`\`package.json\` not found in project directory: ${projectDir}`);
+  }
+}
+
+export async function npmInstall(projectDir: string): Promise<void> {
+  if (!projectDir) { throw new Error('missing project directory'); }
+  const npmModulesPath = join(projectDir, 'node_modules');
+  if (!await isDirMissingOrEmpty(npmModulesPath)) {
+    log(`Directory "${npmModulesPath}" exists and has content. Skipping \`npm install\`.`);
+    return;
+  }
+  log('Starting dependency installation...');
+  const { error } = await executeWithRetry('npm install --loglevel=error', {
+    cwd: projectDir,
+  }, NPM_INSTALL_MAX_RETRIES, NPM_INSTALL_RETRY_DELAY_MS);
+  if (error) {
+    die(error);
+  }
+  log('Installed dependencies...');
+}
+
+export async function npmBuild(
+  projectDir: string,
+  buildCommand: string,
+  distDir: string,
+  forceRebuild: boolean,
+): Promise<void> {
+  if (!projectDir) { throw new Error('missing project directory'); }
+  if (!buildCommand) { throw new Error('missing build command'); }
+  if (!distDir) { throw new Error('missing distribution directory'); }
+
+  const isMissingBuild = await isDirMissingOrEmpty(distDir);
+
+  if (!isMissingBuild && !forceRebuild) {
+    log(`Directory "${distDir}" exists and has content. Skipping build: '${buildCommand}'.`);
+    return;
+  }
+
+  if (forceRebuild) {
+    log(`Removing directory "${distDir}" for a clean build (triggered by \`--build\` flag).`);
+    await rm(distDir, { recursive: true, force: true });
+  }
+
+  log('Building project...');
+  const { error } = await runCommand(buildCommand, {
+    cwd: projectDir,
+  });
+  if (error) {
+    log(error, LogLevel.Warn); // Cannot disable Vue CLI errors, stderr contains false-positives.
+  }
+}
+
+const appNameCache = new Map<string, string>();
+
+export async function getAppName(projectDir: string): Promise<string> {
+  if (!projectDir) { throw new Error('missing project directory'); }
+  if (appNameCache.has(projectDir)) {
+    return appNameCache.get(projectDir);
+  }
+  const packageData = await readPackageJsonContents(projectDir);
+  try {
+    const packageJson = JSON.parse(packageData);
+    const name = packageJson.name as string;
+    if (!name) {
+      return die(`The \`package.json\` file doesn't specify a name: ${packageData}`);
+    }
+    appNameCache.set(projectDir, name);
+    return name;
+  } catch (error) {
+    return die(`Unable to parse \`package.json\`. Error: ${error}\nContent: ${packageData}`);
+  }
+}
+
+async function readPackageJsonContents(projectDir: string): Promise<string> {
+  if (!projectDir) { throw new Error('missing project directory'); }
+  const packagePath = join(projectDir, 'package.json');
+  if (!await exists(packagePath)) {
+    return die(`\`package.json\` file not found at ${packagePath}`);
+  }
+  try {
+    const packageData = await readFile(packagePath, 'utf8');
+    return packageData;
+  } catch (error) {
+    log(`Error reading \`package.json\` from ${packagePath}.`, LogLevel.Error);
+    return die(`Error detail: ${error}`);
+  }
+}
+
+async function executeWithRetry(
+  command: string,
+  options: ExecOptions,
+  maxRetries: number,
+  retryDelayInMs: number,
+  currentAttempt = 1,
+): Promise<CommandResult> {
+  const result = await runCommand(command, options);
+
+  if (!result.error || currentAttempt >= maxRetries) {
+    return result;
+  }
+
+  log(`Attempt ${currentAttempt} failed. Retrying in ${retryDelayInMs / 1000} seconds...`);
+  await sleep(retryDelayInMs);
+
+  const retryResult = await executeWithRetry(
+    command,
+    options,
+    maxRetries,
+    retryDelayInMs,
+    currentAttempt + 1,
+  );
+  return retryResult;
+}

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/platform.ts

@@ -0,0 +1,31 @@
+import { platform } from 'os';
+import { die } from './log';
+
+export enum SupportedPlatform {
+  macOS,
+  Windows,
+  Linux,
+}
+
+const NODE_PLATFORM_MAPPINGS: {
+  readonly [K in SupportedPlatform]: NodeJS.Platform;
+} = {
+  [SupportedPlatform.macOS]: 'darwin',
+  [SupportedPlatform.Linux]: 'linux',
+  [SupportedPlatform.Windows]: 'win32',
+};
+
+function findCurrentPlatform(): SupportedPlatform | undefined {
+  const nodePlatform = platform();
+
+  for (const key of Object.keys(NODE_PLATFORM_MAPPINGS)) {
+    const keyAsSupportedPlatform = parseInt(key, 10) as SupportedPlatform;
+    if (NODE_PLATFORM_MAPPINGS[keyAsSupportedPlatform] === nodePlatform) {
+      return keyAsSupportedPlatform;
+    }
+  }
+
+  return die(`Unsupported platform: ${nodePlatform}`);
+}
+
+export const CURRENT_PLATFORM: SupportedPlatform = findCurrentPlatform();

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/run-command.ts

@@ -0,0 +1,58 @@
+import { exec } from 'child_process';
+import { indentText } from './text';
+import type { ExecOptions, ExecException } from 'child_process';
+
+const TIMEOUT_IN_SECONDS = 180;
+const MAX_OUTPUT_BUFFER_SIZE = 1024 * 1024; // 1 MB
+
+export function runCommand(
+  command: string,
+  options?: ExecOptions,
+): Promise<CommandResult> {
+  return new Promise((resolve) => {
+    options = {
+      cwd: process.cwd(),
+      timeout: TIMEOUT_IN_SECONDS * 1000,
+      maxBuffer: MAX_OUTPUT_BUFFER_SIZE * 2,
+      ...(options ?? {}),
+    };
+
+    exec(command, options, (error, stdout, stderr) => {
+      let errorText: string | undefined;
+      if (error || stderr?.length > 0) {
+        errorText = formatError(command, error, stdout, stderr);
+      }
+      resolve({
+        stdout,
+        error: errorText,
+      });
+    });
+  });
+}
+
+export interface CommandResult {
+  readonly stdout: string;
+  readonly error?: string;
+}
+
+function formatError(
+  command: string,
+  error: ExecException | undefined,
+  stdout: string | undefined,
+  stderr: string | undefined,
+) {
+  const errorParts = [
+    'Error while running command.',
+    `Command:\n${indentText(command, 1)}`,
+  ];
+  if (error?.toString().trim()) {
+    errorParts.push(`Error:\n${indentText(error.toString(), 1)}`);
+  }
+  if (stderr?.trim()) {
+    errorParts.push(`stderr:\n${indentText(stderr, 1)}`);
+  }
+  if (stdout?.trim()) {
+    errorParts.push(`stdout:\n${indentText(stdout, 1)}`);
+  }
+  return errorParts.join('\n---\n');
+}

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/sleep.ts

@@ -0,0 +1,5 @@
+export function sleep(milliseconds: number) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}

tests/checks/desktop-runtime-errors/check-desktop-runtime-errors/utils/text.ts

@@ -0,0 +1,22 @@
+export function indentText(
+  text: string,
+  indentLevel = 1,
+): string {
+  validateText(text);
+  const indentation = '\t'.repeat(indentLevel);
+  return splitTextIntoLines(text)
+    .map((line) => (line ? `${indentation}${line}` : line))
+    .join('\n');
+}
+
+export function splitTextIntoLines(text: string): string[] {
+  validateText(text);
+  return text
+    .split(/[\r\n]+/);
+}
+
+function validateText(text: string): void {
+  if (typeof text !== 'string') {
+    throw new Error(`text is not a string. It is: ${typeof text}\n${text}`);
+  }
+}