@testspectra/cli 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,424 @@
+import fs from "fs";
+import path from "path";
+import { ConfigLoader } from "../config/loader.js";
+import { TypeGenerator } from "../types/generator.js";
+
+export async function initCommand(options: { force?: boolean }) {
+  const cwd = process.cwd();
+  const existingConfig = ConfigLoader.findConfigFile(cwd);
+
+  if (existingConfig && !options.force) {
+    console.log(`\x1b[33m[TestSpectra]\x1b[0m Config already exists at ${path.basename(existingConfig)}. Use --force to overwrite.`);
+    return;
+  }
+
+  // 1. Ensure directories exist
+  const dirs = [
+    "specs/TC-LOGIN-01",
+    "page-objects/LoginPage",
+    "actions/verifyOtp",
+    "steps/loginUser",
+    "fixtures",
+    "hooks/default",
+    ".testspectra",
+  ];
+  for (const d of dirs) {
+    const dirPath = path.join(cwd, d);
+    if (!fs.existsSync(dirPath)) {
+      fs.mkdirSync(dirPath, { recursive: true });
+    }
+  }
+
+  // 2. Create spectra.config.ts
+  const configContent = `import { defineConfig } from "@testspectra/cli";
+
+export default defineConfig({
+  webConfig: {
+    baseUrl: "https://the-internet.herokuapp.com",
+    maxConcurrentSessions: "1",
+    headlessMode: true,
+    implicitWait: "5000",
+    pageLoadTimeout: "30000",
+    scriptTimeout: "30000",
+    parallelizationMode: "testcase",
+  },
+  browsers: [
+    {
+      id: "chrome-desktop",
+      type: "chrome",
+      mobileEmulation: false,
+    },
+  ],
+  androidConfig: {
+    appiumServer: "http://127.0.0.1:4723",
+    platformName: "Android",
+    platformVersion: "13",
+    deviceName: "emulator-5554",
+    automationName: "UiAutomator2",
+    appPackage: "",
+    appActivity: "",
+    autoGrantPermissions: true,
+    noReset: false,
+    implicitWait: "10000",
+    parallelizationMode: "suite",
+  },
+  iosConfig: {
+    appiumServer: "http://127.0.0.1:4723",
+    platformName: "iOS",
+    platformVersion: "16.0",
+    deviceName: "iPhone 14",
+    automationName: "XCUITest",
+    bundleId: "",
+    udid: "auto",
+    xcodeOrgId: "",
+    xcodeSigningId: "iPhone Developer",
+    autoAcceptAlerts: true,
+    noReset: false,
+    implicitWait: "10000",
+    parallelizationMode: "suite",
+  },
+  loadConfig: {
+    virtualUsers: "10",
+    duration: "1m",
+  },
+  loadStages: [],
+  thresholds: [],
+  executionConfig: {
+    networkMonitoringEnabled: true,
+    fastResponseTime: "200",
+    normalResponseTime: "1000",
+    monitoredDomains: [],
+    environmentVariables: [],
+  },
+});
+`;
+  fs.writeFileSync(path.join(cwd, "spectra.config.ts"), configContent, "utf-8");
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Initialized spectra.config.ts with defineConfig`);
+
+  // 3. Create or update package.json with npm scripts & devDependencies
+  const packageJsonPath = path.join(cwd, "package.json");
+  let pkg: any = {
+    name: path.basename(cwd),
+    version: "1.0.0",
+    private: true,
+    type: "module",
+    scripts: {
+      dev: "spectra watch",
+      test: "spectra run",
+      "type-check": "tsc -b",
+    },
+    devDependencies: {
+      "@testspectra/cli": "workspace:*",
+      "@types/node": "^20.14.0",
+      "@wdio/globals": "^9.2.8",
+      "@wdio/mocha-framework": "^9.2.8",
+      "webdriverio": "^9.2.8",
+      "typescript": "^5.4.5",
+    },
+  };
+  if (fs.existsSync(packageJsonPath)) {
+    try {
+      const existing = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+      pkg = {
+        ...existing,
+        scripts: {
+          ...(existing.scripts || {}),
+          dev: existing.scripts?.dev || "spectra watch",
+          test: existing.scripts?.test || "spectra run",
+          "type-check": existing.scripts?.["type-check"] || "tsc -b",
+        },
+        devDependencies: {
+          ...(existing.devDependencies || {}),
+          "@testspectra/cli": existing.devDependencies?.["@testspectra/cli"] || "workspace:*",
+          "@types/node": existing.devDependencies?.["@types/node"] || "^20.14.0",
+          "@wdio/globals": existing.devDependencies?.["@wdio/globals"] || "^9.2.8",
+          "@wdio/mocha-framework": existing.devDependencies?.["@wdio/mocha-framework"] || "^9.2.8",
+          "webdriverio": existing.devDependencies?.["webdriverio"] || "^9.2.8",
+          "typescript": existing.devDependencies?.["typescript"] || "^5.4.5",
+        },
+      };
+    } catch {}
+  }
+  fs.writeFileSync(packageJsonPath, JSON.stringify(pkg, null, 2), "utf-8");
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Updated package.json (scripts & devDependencies)`);
+
+  // 3b. Create .gitignore
+  const gitignorePath = path.join(cwd, ".gitignore");
+  if (!fs.existsSync(gitignorePath) || options.force) {
+    const gitignoreContent = `node_modules/\ndist/\n.testspectra/\n*.tsbuildinfo\n`;
+    fs.writeFileSync(gitignorePath, gitignoreContent, "utf-8");
+    console.log(`\x1b[32m[TestSpectra]\x1b[0m Created .gitignore`);
+  }
+
+  // 4. Create platform tsconfigs with Solution-Style Project References
+  const tsconfigRoot = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      types: ["node", "@wdio/globals/types", "@wdio/mocha-framework"],
+      skipLibCheck: true,
+      strict: true,
+      noEmit: true,
+    },
+    files: ["spectra.config.ts"],
+    references: [
+      { path: "./tsconfig.web.json" },
+      { path: "./tsconfig.android.json" },
+      { path: "./tsconfig.ios.json" },
+    ],
+  };
+  fs.writeFileSync(path.join(cwd, "tsconfig.json"), JSON.stringify(tsconfigRoot, null, 2), "utf-8");
+
+  const tsconfigWeb = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      types: ["node", "@wdio/globals/types", "@wdio/mocha-framework"],
+      skipLibCheck: true,
+      strict: true,
+      composite: true,
+      emitDeclarationOnly: true,
+      outDir: "./.testspectra/.build/web",
+    },
+    include: [
+      "specs/**/web.test.ts",
+      "specs/**/common.test.ts",
+      "page-objects/**/web.ts",
+      "page-objects/**/common.ts",
+      "actions/**/web.action.ts",
+      "actions/**/common.action.ts",
+      "steps/**/web.step.ts",
+      "steps/**/common.step.ts",
+      "hooks/**/before.web.hook.ts",
+      "hooks/**/before.hook.ts",
+      ".testspectra/types/web.d.ts",
+      ".testspectra/types/common.d.ts",
+      ".testspectra/types/fixtures.d.ts",
+    ],
+  };
+  fs.writeFileSync(path.join(cwd, "tsconfig.web.json"), JSON.stringify(tsconfigWeb, null, 2), "utf-8");
+
+  const tsconfigAndroid = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      types: ["node", "@wdio/globals/types", "@wdio/mocha-framework"],
+      skipLibCheck: true,
+      strict: true,
+      composite: true,
+      emitDeclarationOnly: true,
+      outDir: "./.testspectra/.build/android",
+    },
+    include: [
+      "specs/**/android.test.ts",
+      "specs/**/mobile.test.ts",
+      "specs/**/common.test.ts",
+      "page-objects/**/android.ts",
+      "page-objects/**/mobile.ts",
+      "page-objects/**/common.ts",
+      "actions/**/android.action.ts",
+      "actions/**/mobile.action.ts",
+      "actions/**/common.action.ts",
+      "steps/**/android.step.ts",
+      "steps/**/mobile.step.ts",
+      "steps/**/common.step.ts",
+      "hooks/**/before.android.hook.ts",
+      "hooks/**/before.mobile.hook.ts",
+      "hooks/**/before.hook.ts",
+      ".testspectra/types/android.d.ts",
+      ".testspectra/types/mobile.d.ts",
+      ".testspectra/types/common.d.ts",
+      ".testspectra/types/fixtures.d.ts",
+    ],
+  };
+  fs.writeFileSync(path.join(cwd, "tsconfig.android.json"), JSON.stringify(tsconfigAndroid, null, 2), "utf-8");
+
+  const tsconfigIos = {
+    compilerOptions: {
+      target: "ES2022",
+      module: "NodeNext",
+      moduleResolution: "NodeNext",
+      types: ["node", "@wdio/globals/types", "@wdio/mocha-framework"],
+      skipLibCheck: true,
+      strict: true,
+      composite: true,
+      emitDeclarationOnly: true,
+      outDir: "./.testspectra/.build/ios",
+    },
+    include: [
+      "specs/**/ios.test.ts",
+      "specs/**/mobile.test.ts",
+      "specs/**/common.test.ts",
+      "page-objects/**/ios.ts",
+      "page-objects/**/mobile.ts",
+      "page-objects/**/common.ts",
+      "actions/**/ios.action.ts",
+      "actions/**/mobile.action.ts",
+      "actions/**/common.action.ts",
+      "steps/**/ios.step.ts",
+      "steps/**/mobile.step.ts",
+      "steps/**/common.step.ts",
+      "hooks/**/before.ios.hook.ts",
+      "hooks/**/before.mobile.hook.ts",
+      "hooks/**/before.hook.ts",
+      ".testspectra/types/ios.d.ts",
+      ".testspectra/types/mobile.d.ts",
+      ".testspectra/types/common.d.ts",
+      ".testspectra/types/fixtures.d.ts",
+    ],
+  };
+  fs.writeFileSync(path.join(cwd, "tsconfig.ios.json"), JSON.stringify(tsconfigIos, null, 2), "utf-8");
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Created platform-isolated tsconfigs with solution references`);
+
+  // 5. Scaffold Fixture File
+  const fixturePath = path.join(cwd, "fixtures", "userData.json");
+  if (!fs.existsSync(fixturePath) || options.force) {
+    fs.writeFileSync(fixturePath, JSON.stringify({ username: "tomsmith", role: "admin" }, null, 2), "utf-8");
+  }
+
+  // 6. Scaffold Page Objects (Clean zero-import methods with explicit ChainablePromiseElement types)
+  const poWeb = `export default class LoginPage {
+  static get usernameInput(): ChainablePromiseElement {
+    return $('#username');
+  }
+
+  static get passwordInput(): ChainablePromiseElement {
+    return $('#password');
+  }
+
+  static get submitButton(): ChainablePromiseElement {
+    return $('button[type="submit"]');
+  }
+
+  static async open() {
+    await browser.url('/login');
+  }
+
+  static async login(username: string, pass: string) {
+    await this.usernameInput.setValue(username);
+    await this.passwordInput.setValue(pass);
+    await this.submitButton.click();
+  }
+}
+`;
+  fs.writeFileSync(path.join(cwd, "page-objects/LoginPage/web.ts"), poWeb, "utf-8");
+
+  const poMobile = `export default class LoginPage {
+  static get usernameInput(): ChainablePromiseElement {
+    return $('~username_input');
+  }
+
+  static get passwordInput(): ChainablePromiseElement {
+    return $('~password_input');
+  }
+
+  static get submitButton(): ChainablePromiseElement {
+    return $('~login_button');
+  }
+
+  static async open() {
+    // Mobile app startup
+  }
+
+  static async login(username: string, pass: string) {
+    await this.usernameInput.setValue(username);
+    await this.passwordInput.setValue(pass);
+    await this.submitButton.click();
+  }
+}
+`;
+  fs.writeFileSync(path.join(cwd, "page-objects/LoginPage/mobile.ts"), poMobile, "utf-8");
+
+  // 7. Scaffold Actions (Zero triple-slash lines)
+  const actionWeb = `export default async function verifyOtp(otp: string): Promise<void> {
+  const otpInput = await $('#otp');
+  await otpInput.setValue(otp);
+  const verifyBtn = await $('#verify-btn');
+  await verifyBtn.click();
+}
+`;
+  fs.writeFileSync(path.join(cwd, "actions/verifyOtp/web.action.ts"), actionWeb, "utf-8");
+
+  const actionMobile = `export default async function verifyOtp(otp: string): Promise<void> {
+  const otpInput = await $('~otp_input');
+  await otpInput.setValue(otp);
+  const verifyBtn = await $('~verify_btn');
+  await verifyBtn.click();
+}
+`;
+  fs.writeFileSync(path.join(cwd, "actions/verifyOtp/mobile.action.ts"), actionMobile, "utf-8");
+
+  // 8. Scaffold Steps (Zero triple-slash lines)
+  const stepWeb = `export default async function loginUser(u: string, p: string): Promise<void> {
+  await LoginPage.open();
+  await LoginPage.login(u, p);
+}
+`;
+  fs.writeFileSync(path.join(cwd, "steps/loginUser/web.step.ts"), stepWeb, "utf-8");
+
+  const stepMobile = `export default async function loginUser(u: string, p: string): Promise<void> {
+  await LoginPage.open();
+  await LoginPage.login(u, p);
+}
+`;
+  fs.writeFileSync(path.join(cwd, "steps/loginUser/mobile.step.ts"), stepMobile, "utf-8");
+
+  // 9. Scaffold Hooks (Zero triple-slash lines)
+  const hookWeb = `export default async function (): Promise<void> {
+  await browser.maximizeWindow();
+}
+`;
+  fs.writeFileSync(path.join(cwd, "hooks/default/before.web.hook.ts"), hookWeb, "utf-8");
+
+  const hookAndroid = `export default async function (): Promise<void> {
+  // Setup Android Appium capabilities
+}
+`;
+  fs.writeFileSync(path.join(cwd, "hooks/default/before.android.hook.ts"), hookAndroid, "utf-8");
+
+  const hookIos = `export default async function (): Promise<void> {
+  // Setup iOS Appium capabilities
+}
+`;
+  fs.writeFileSync(path.join(cwd, "hooks/default/before.ios.hook.ts"), hookIos, "utf-8");
+
+  // 10. Scaffold Specs (Pure test scripts, ZERO triple-slash lines)
+  const specWeb = `it("should authenticate user using web locators and fixtures", async () => {
+  await browser.intercept("/api/status", "GET", Fixture.userData);
+  await LoginPage.open();
+  await LoginPage.login("tomsmith", "SuperSecretPassword!");
+
+  const flash = await $("#flash");
+  await expect(flash).toBeDisplayed();
+});
+`;
+  fs.writeFileSync(path.join(cwd, "specs/TC-LOGIN-01/web.test.ts"), specWeb, "utf-8");
+
+  const specAndroid = `it("should authenticate user on Android Appium device", async () => {
+  await LoginPage.open();
+  await LoginPage.login("tomsmith", "SuperSecretPassword!");
+
+  const welcome = await $("~welcome_text");
+  await expect(welcome).toBeDisplayed();
+});
+`;
+  fs.writeFileSync(path.join(cwd, "specs/TC-LOGIN-01/android.test.ts"), specAndroid, "utf-8");
+
+  const specIos = `it("should authenticate user on iOS Appium device", async () => {
+  await LoginPage.open();
+  await LoginPage.login("tomsmith", "SuperSecretPassword!");
+
+  const welcome = await $("~welcome_text");
+  await expect(welcome).toBeDisplayed();
+});
+`;
+  fs.writeFileSync(path.join(cwd, "specs/TC-LOGIN-01/ios.test.ts"), specIos, "utf-8");
+
+  // 11. Generate ambient declaration files
+  TypeGenerator.writeDeclarationFiles(cwd);
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Generated ambient multi-platform types in .testspectra/types/`);
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Project initialized successfully!`);
+}

package/src/commands/run.ts

@@ -0,0 +1,102 @@
+import fs from "fs";
+import path from "path";
+import { ConfigLoader } from "../config/loader.js";
+import { RustCoreBridge } from "../runner/bridge.js";
+import { Reporter } from "../runner/reporter.js";
+import { TypeGenerator } from "../types/generator.js";
+
+export interface RunCommandOptions {
+  target?: "web" | "android" | "ios" | "common";
+  device?: string;
+  headless?: boolean;
+  workdir?: string;
+  output?: string;
+}
+
+export async function runCommand(specPath?: string, options: RunCommandOptions = {}) {
+  const cwd = process.cwd();
+
+  // Ensure latest ambient types are up-to-date
+  TypeGenerator.writeDeclarationFiles(cwd);
+
+  const config = await ConfigLoader.loadConfig(cwd);
+
+  if (options.headless !== undefined) {
+    config.webConfig.headlessMode = options.headless;
+  }
+
+  const platform = options.target || "web";
+  const appDataPath = options.workdir ? path.resolve(options.workdir) : path.join(cwd, ".testspectra");
+
+  if (!fs.existsSync(appDataPath)) {
+    fs.mkdirSync(appDataPath, { recursive: true });
+  }
+
+  // Determine suite/test case name
+  let suiteName = "default";
+  let testCases: Array<{ id: string; title: string; executionOrder?: number }> = [];
+
+  if (specPath) {
+    const parsed = path.parse(specPath);
+    const baseName = parsed.name.replace(/\.(web|android|ios|common|test|spec)/g, "");
+    suiteName = baseName;
+    testCases.push({
+      id: baseName,
+      title: baseName,
+      executionOrder: 1,
+    });
+  } else {
+    // Scan specs/ directory (both entity folders specs/TC-001/web.test.ts and flat files)
+    const specsDir = path.join(cwd, "specs");
+    if (fs.existsSync(specsDir)) {
+      const entries = fs.readdirSync(specsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (entry.isDirectory()) {
+          testCases.push({ id: entry.name, title: entry.name });
+        } else if (entry.isFile() && (entry.name.endsWith(".test.ts") || entry.name.endsWith(".spec.ts"))) {
+          const id = entry.name.replace(/\.(web|android|ios|common|all|mobile|test|spec)\.ts$/g, "").replace(/\.test\.ts$/, "");
+          testCases.push({ id, title: id });
+        }
+      }
+    }
+  }
+
+  if (testCases.length === 0) {
+    testCases.push({
+      id: suiteName,
+      title: suiteName,
+      executionOrder: 1,
+    });
+  }
+
+  const outputJsonPath = options.output
+    ? path.resolve(options.output)
+    : path.join(appDataPath, "reports/result.json");
+
+  console.log(`\x1b[36m[TestSpectra]\x1b[0m Starting execution on target \x1b[1m${platform}\x1b[0m...`);
+  console.log(`\x1b[36m[TestSpectra]\x1b[0m Suite: ${suiteName} (${testCases.length} case(s))\n`);
+
+  const reporter = new Reporter();
+  try {
+    const result = await RustCoreBridge.run(
+      {
+        baseDir: cwd,
+        appDataPath,
+        platform,
+        suite: suiteName,
+        testCases,
+        config,
+        targetDevice: options.device,
+        outputJsonPath,
+      },
+      reporter
+    );
+
+    console.log(`\n\x1b[36m[TestSpectra]\x1b[0m Run finished: \x1b[1m${result.status.toUpperCase()}\x1b[0m in ${result.duration}`);
+    console.log(`\x1b[36m[TestSpectra]\x1b[0m Report saved to: ${outputJsonPath}`);
+  } catch (e) {
+    console.error(`\x1b[31m[TestSpectra] Execution error:\x1b[0m`, e);
+    process.exit(1);
+  }
+}

package/src/commands/watch.ts

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { TypeGenerator } from "../types/generator.js";
+
+export function watchCommand(options: { once?: boolean } = {}) {
+  const cwd = process.cwd();
+
+  // Run initial generation
+  TypeGenerator.writeDeclarationFiles(cwd);
+  console.log(`\x1b[32m[TestSpectra]\x1b[0m Generated ambient types in .testspectra/types/`);
+
+  if (options.once) {
+    return;
+  }
+
+  console.log(`\x1b[34m[TestSpectra]\x1b[0m Watching for changes in page-objects/, actions/, steps/, fixtures/...`);
+
+  const watchDirs = ["page-objects", "pageobjects", "actions", "steps", "fixtures"];
+  let debounceTimeout: NodeJS.Timeout | null = null;
+
+  for (const dir of watchDirs) {
+    const fullPath = path.join(cwd, dir);
+    if (fs.existsSync(fullPath)) {
+      fs.watch(fullPath, { recursive: true }, (_eventType, filename) => {
+        if (!filename || filename.startsWith(".")) return;
+        if (debounceTimeout) clearTimeout(debounceTimeout);
+        debounceTimeout = setTimeout(() => {
+          TypeGenerator.writeDeclarationFiles(cwd);
+          console.log(`\x1b[32m[TestSpectra]\x1b[0m Updated ambient declarations (.testspectra/types/) due to ${filename}`);
+        }, 150);
+      });
+    }
+  }
+}

package/src/config/loader.ts

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import { ConfigData, DEFAULT_CONFIG_DATA } from "./schema.js";
+
+export class ConfigLoader {
+  static readonly CONFIG_FILE_NAMES = [
+    "testspectra.config.ts",
+    "spectra.config.ts",
+    "testspectra.config.js",
+    "spectra.config.js",
+    "testspectra.config.json",
+    ".testspectrarc.json",
+  ];
+
+  static findConfigFile(cwd: string = process.cwd()): string | null {
+    for (const filename of this.CONFIG_FILE_NAMES) {
+      const fullPath = path.join(cwd, filename);
+      if (fs.existsSync(fullPath)) {
+        return fullPath;
+      }
+    }
+    return null;
+  }
+
+  static async loadConfig(cwd: string = process.cwd(), overrides?: Partial<ConfigData>): Promise<ConfigData> {
+    const configPath = this.findConfigFile(cwd);
+    let loaded: Partial<ConfigData> = {};
+
+    if (configPath) {
+      if (configPath.endsWith(".json")) {
+        try {
+          const raw = fs.readFileSync(configPath, "utf-8");
+          loaded = JSON.parse(raw);
+        } catch (e) {
+          console.warn(`[TestSpectra] Warning: Failed to parse ${configPath}:`, e);
+        }
+      } else if (configPath.endsWith(".ts") || configPath.endsWith(".js")) {
+        try {
+          const fileUrl = new URL(`file://${path.resolve(configPath)}`).href;
+          const mod = await import(fileUrl);
+          loaded = mod.default || mod.config || mod;
+        } catch (e) {
+          console.warn(`[TestSpectra] Warning: Failed to import ${configPath}:`, e);
+        }
+      }
+    }
+
+    return {
+      ...DEFAULT_CONFIG_DATA,
+      ...loaded,
+      ...overrides,
+      webConfig: {
+        ...DEFAULT_CONFIG_DATA.webConfig,
+        ...(loaded.webConfig || {}),
+        ...(overrides?.webConfig || {}),
+      },
+      androidConfig: {
+        ...DEFAULT_CONFIG_DATA.androidConfig,
+        ...(loaded.androidConfig || {}),
+        ...(overrides?.androidConfig || {}),
+      },
+      iosConfig: {
+        ...DEFAULT_CONFIG_DATA.iosConfig,
+        ...(loaded.iosConfig || {}),
+        ...(overrides?.iosConfig || {}),
+      },
+      executionConfig: {
+        networkMonitoringEnabled: overrides?.executionConfig?.networkMonitoringEnabled ?? loaded.executionConfig?.networkMonitoringEnabled ?? DEFAULT_CONFIG_DATA.executionConfig?.networkMonitoringEnabled ?? true,
+        fastResponseTime: overrides?.executionConfig?.fastResponseTime ?? loaded.executionConfig?.fastResponseTime ?? DEFAULT_CONFIG_DATA.executionConfig?.fastResponseTime ?? "200",
+        normalResponseTime: overrides?.executionConfig?.normalResponseTime ?? loaded.executionConfig?.normalResponseTime ?? DEFAULT_CONFIG_DATA.executionConfig?.normalResponseTime ?? "1000",
+        monitoredDomains: overrides?.executionConfig?.monitoredDomains ?? loaded.executionConfig?.monitoredDomains ?? DEFAULT_CONFIG_DATA.executionConfig?.monitoredDomains ?? [],
+        environmentVariables: overrides?.executionConfig?.environmentVariables ?? loaded.executionConfig?.environmentVariables ?? DEFAULT_CONFIG_DATA.executionConfig?.environmentVariables ?? [],
+      },
+    };
+  }
+
+  static saveConfig(cwd: string, config: ConfigData, filename = "testspectra.config.json"): string {
+    const target = path.join(cwd, filename);
+    fs.writeFileSync(target, JSON.stringify(config, null, 2), "utf-8");
+    return target;
+  }
+}