src/scripts/ci-changed-scope.test.ts

// CI changed scope tests cover script detection of changed files and lanes.
import { execFileSync } from "node:child_process";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import { bundledPluginFile } from "openclaw/plugin-sdk/test-fixtures";
import { afterEach, describe, expect, it } from "vitest";
import { useAutoCleanupTempDirTracker } from "../../test/helpers/temp-dir.js";

const {
  detectChangedScope,
  detectInstallSmokeScope,
  detectNodeFastScope,
  listChangedPaths,
  parseArgs,
  shouldRunIosScreenshots,
  shouldRunNativeI18n,
  writeGitHubOutput,
} = await import("../../scripts/ci-changed-scope.mjs");

const markerPaths: string[] = [];
const tempDirs = useAutoCleanupTempDirTracker(afterEach);

afterEach(() => {
  for (const markerPath of markerPaths) {
    try {
      fs.unlinkSync(markerPath);
    } catch {}
  }
  markerPaths.length = 0;
});

function parseGitHubOutput(output: string): Record<string, string> {
  const parsed: Record<string, string> = {};
  for (const line of output.trim().split("\n")) {
    if (!line) {
      continue;
    }
    const separator = line.indexOf("=");
    parsed[line.slice(0, separator)] = line.slice(separator + 1);
  }
  return parsed;
}

function git(repoDir: string, args: string[]): string {
  return execFileSync("git", args, { cwd: repoDir, encoding: "utf8" }).trim();
}

function writeRepoFile(repoDir: string, filePath: string, contents: string): void {
  const absolutePath = path.join(repoDir, filePath);
  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
  fs.writeFileSync(absolutePath, contents, "utf8");
}

function createSyntheticMergeRepo(prefix: string): { repoDir: string; staleBase: string } {
  const repoDir = tempDirs.make(prefix);

  git(repoDir, ["init", "-b", "main"]);
  git(repoDir, ["config", "user.email", "ci@example.invalid"]);
  git(repoDir, ["config", "user.name", "CI"]);
  writeRepoFile(repoDir, "README.md", "base\n");
  git(repoDir, ["add", "."]);
  git(repoDir, ["commit", "-m", "base"]);
  const staleBase = git(repoDir, ["rev-parse", "HEAD"]);

  git(repoDir, ["switch", "-c", "feature"]);
  writeRepoFile(repoDir, "src/pr.ts", "export const pr = true;\n");
  git(repoDir, ["add", "."]);
  git(repoDir, ["commit", "-m", "feature"]);

  git(repoDir, ["switch", "main"]);
  writeRepoFile(repoDir, "src/main-only.ts", "export const mainOnly = true;\n");
  git(repoDir, ["add", "."]);
  git(repoDir, ["commit", "-m", "main only"]);
  git(repoDir, ["merge", "--no-ff", "feature", "-m", "synthetic merge"]);

  return { repoDir, staleBase };
}

describe("parseArgs", () => {
  it("parses CI diff refs", () => {
    expect(parseArgs(["--base", "origin/main", "--head", "HEAD"])).toEqual({
      base: "origin/main",
      head: "HEAD",
      mergeHeadFirstParent: false,
    });
  });

  it("rejects missing CI diff refs", () => {
    expect(() => parseArgs(["--base", "--head", "HEAD"])).toThrow("--base requires a value");
    expect(() => parseArgs(["--base", "-h", "--head", "HEAD"])).toThrow("--base requires a value");
    expect(() => parseArgs(["--head"])).toThrow("--head requires a value");
    expect(() => parseArgs(["--head", "-h"])).toThrow("--head requires a value");
    expect(() => parseArgs(["--base", ""])).toThrow("--base requires a value");
    expect(() => parseArgs([])).toThrow("--base is required");
    expect(() => parseArgs(["--head", "HEAD"])).toThrow("--base is required");
    expect(() => parseArgs(["--base", "HEAD", "--mystery"])).toThrow("Unknown argument: --mystery");
  });
});

describe("detectChangedScope", () => {
  const expectedNodeOnlyScope = {
    runNode: true,
    runMacos: false,
    runMacosNode: false,
    runIosBuild: false,
    runAndroid: false,
    runWindows: false,
    runSkillsPython: false,
    runChangedSmoke: false,
    runControlUiI18n: false,
    runUiTests: false,
  };

  const expectedNodeAndChangedSmokeScope = {
    runNode: true,
    runMacos: false,
    runMacosNode: false,
    runIosBuild: false,
    runAndroid: false,
    runWindows: false,
    runSkillsPython: false,
    runChangedSmoke: true,
    runControlUiI18n: false,
    runUiTests: false,
  };

  it("routes only native i18n-owned paths to the native inventory job", () => {
    for (const changedPath of [
      "apps/.i18n/native-source.json",
      "apps/android/app/src/main/java/ai/openclaw/app/MainActivity.kt",
      "apps/android/wear/src/main/java/ai/openclaw/wear/WearScreens.kt",
      "apps/ios/Sources/RootTabs.swift",
      "apps/macos/Sources/OpenClaw/Settings.swift",
      "apps/shared/OpenClawKit/Sources/OpenClawKit/Client.swift",
      "scripts/native-app-i18n.ts",
      "scripts/android-app-i18n.ts",
      "scripts/apple-app-i18n.ts",
      "test/scripts/native-app-i18n.test.ts",
      ".github/workflows/native-app-locale-refresh.yml",
      ".github/workflows/ci.yml",
    ]) {
      expect(shouldRunNativeI18n([changedPath]), changedPath).toBe(true);
    }

    expect(shouldRunNativeI18n(["src/config/defaults.ts"])).toBe(false);
    expect(shouldRunNativeI18n(["scripts/install.sh"])).toBe(false);
  });

  it("fails safe when no paths are provided", () => {
    expect(detectChangedScope([])).toEqual({
      runNode: true,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: true,
      runAndroid: true,
      runWindows: true,
      runSkillsPython: true,
      runChangedSmoke: true,
      runControlUiI18n: true,
      runUiTests: true,
    });
  });

  it("keeps all lanes off for docs-only changes", () => {
    expect(detectChangedScope(["docs/ci.md", "README.md"])).toEqual({
      runNode: false,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it("enables node lane for node-relevant files", () => {
    expect(detectChangedScope(["src/config/defaults.ts"])).toEqual(expectedNodeOnlyScope);
  });

  it("runs Android and Node CI for Android toolchain action changes", () => {
    expect(detectChangedScope([".github/actions/setup-android-toolchain/action.yml"])).toEqual({
      ...expectedNodeOnlyScope,
      runAndroid: true,
    });
  });

  it("keeps node lane off for native-only changes", () => {
    expect(detectChangedScope(["apps/macos/Sources/Foo.swift"])).toEqual({
      runNode: false,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
    expect(
      detectChangedScope(["apps/macos-mlx-tts/Sources/OpenClawMLXTTSHelper/main.swift"]),
    ).toEqual({
      runNode: false,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
    expect(detectChangedScope(["apps/ios/Sources/RootTabs.swift"])).toEqual({
      runNode: false,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: true,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
    expect(detectChangedScope(["apps/shared/OpenClawKit/Sources/Foo.swift"])).toEqual({
      runNode: false,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: true,
      runAndroid: true,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
    expect(detectChangedScope(["apps/swabble/Sources/SwabbleKit/WakeWordGate.swift"])).toEqual({
      runNode: false,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: true,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
    expect(detectChangedScope(["Swabble/Sources/SwabbleKit/WakeWordGate.swift"])).toEqual({
      runNode: false,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: true,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it("runs both Apple lanes for shared Swift tooling changes", () => {
    for (const toolingPath of [
      "config/swiftformat",
      "config/swiftlint.yml",
      "scripts/check-swift-tools.sh",
      "scripts/format-swift.sh",
      "scripts/install-swift-tools.sh",
      "scripts/install-xcodegen.sh",
      "scripts/lint-swift.sh",
      "scripts/prepare-apple-mermaid.mjs",
    ]) {
      expect(detectChangedScope([toolingPath])).toEqual({
        runNode: true,
        runMacos: true,
        runMacosNode: true,
        runIosBuild: true,
        runAndroid: false,
        runWindows: false,
        runSkillsPython: false,
        runChangedSmoke: false,
        runControlUiI18n: false,
        runUiTests: false,
      });
      expect(shouldRunIosScreenshots([toolingPath])).toBe(true);
    }
  });

  it("enables the iOS build lane for iOS build helper changes", () => {
    for (const helperPath of [
      "scripts/ios-team-id.sh",
      "scripts/ios-write-swift-filelist.mjs",
      "scripts/ios-write-swift-filelist.mts",
      "scripts/ios-version.ts",
      "scripts/lib/ios-version.ts",
      "scripts/lib/release-version.mjs",
      "scripts/lib/version-script-args.ts",
    ]) {
      expect(detectChangedScope([helperPath])).toEqual({
        runNode: true,
        runMacos: false,
        runMacosNode: false,
        runIosBuild: true,
        runAndroid: false,
        runWindows: false,
        runSkillsPython: false,
        runChangedSmoke: false,
        runControlUiI18n: false,
        runUiTests: false,
      });
    }
  });

  it("runs the iOS build but not macOS for generated protocol model-only changes", () => {
    expect(
      detectChangedScope(["apps/shared/OpenClawKit/Sources/OpenClawProtocol/GatewayModels.swift"]),
    ).toEqual({
      runNode: false,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: true,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it("enables node lane for non-native non-doc files by fallback", () => {
    expect(detectChangedScope(["README.md"])).toEqual({
      runNode: false,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });

    expect(detectChangedScope([".crabbox.yaml"])).toEqual(expectedNodeOnlyScope);
  });

  it("keeps windows lane off for non-runtime GitHub metadata files", () => {
    expect(detectChangedScope([".github/labeler.yml"])).toEqual(expectedNodeOnlyScope);
  });

  it("runs Python skill tests when skills change", () => {
    expect(detectChangedScope(["skills/skill-creator/scripts/test_quick_validate.py"])).toEqual({
      runNode: true,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: true,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it("runs Python skill tests when shared Python config changes", () => {
    expect(detectChangedScope(["skills/pyproject.toml"])).toEqual({
      runNode: true,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: true,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it("runs CI-owned platform lanes when the CI workflow changes", () => {
    expect(detectChangedScope([".github/workflows/ci.yml"])).toEqual({
      runNode: true,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: true,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: true,
    });
  });

  it.each([
    "scripts/codesign-mac-app.sh",
    "scripts/create-dmg.sh",
    "scripts/lib/plistbuddy.sh",
    "scripts/lib/swift-toolchain.sh",
    "scripts/notarize-mac-artifact.sh",
    "scripts/package-mac-app.sh",
    "scripts/package-mac-dist.sh",
    "scripts/build-and-run-mac.sh",
    "scripts/prepush-ci.sh",
    "scripts/stage-mac-node-worker.sh",
    "scripts/restart-mac.sh",
    "scripts/lib/mac-app-bundle.sh",
    "test/scripts/restart-mac.test.ts",
    "scripts/materialize-mac-node-worker.py",
    "scripts/swift-build-cache-metadata.py",
    "test/scripts/swift-build-cache-metadata.test.ts",
    "scripts/lib/mac-native-inventory.py",
    "scripts/lib/mac-bundle-mutation.py",
    "scripts/verify-mac-node-worker.mjs",
    "scripts/verify-mac-node-worker-fs.mjs",
    "scripts/lib/mac-node-worker-proof-state.mjs",
    "scripts/lib/mac-worker-portability.mjs",
    "test/helpers/mac-native.ts",
    "test/helpers/mac-signing.ts",
    "test/scripts/codesign-mac-app.test.ts",
    "test/scripts/create-dmg.test.ts",
    "test/scripts/notarize-mac-artifact.test.ts",
    "test/scripts/package-mac-app.test.ts",
    "test/scripts/package-mac-dist.test.ts",
    "test/scripts/mac-elevation-artifact.test-support.ts",
    "test/scripts/mac-native-fixtures.test-support.ts",
    "test/scripts/mac-node-worker-materialization.test-support.ts",
    "test/scripts/mac-node-worker.test.ts",
    "test/scripts/verify-mac-node-worker-fs.test.ts",
  ])("runs macOS CI for packaging owner %s", (changedPath) => {
    expect(detectChangedScope([changedPath])).toEqual({
      runNode: true,
      runMacos: true,
      runMacosNode: true,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: false,
      runUiTests: false,
    });
  });

  it.each<[string, boolean, boolean]>([
    ["extensions/memory-lancedb/index.test.ts", false, false],
    ["src/auto-reply/reply/streaming-directives.ts", false, false],
    ["src/process/exec.ts", true, false],
    ["src/process/exec.windows.test.ts", true, false],
    ["src/daemon/schtasks.ts", true, false],
    ["src/daemon/schtasks-exec.ts", true, false],
    ["src/daemon/schtasks.startup-fallback.test.ts", true, false],
    ["src/daemon/runtime-hints.windows-paths.test.ts", true, false],
    ["src/daemon/test-helpers/schtasks-fixtures.ts", true, false],
    ["src/shared/runtime-import.ts", true, false],
    ["src/shared/runtime-import.test.ts", true, false],
    ["scripts/npm-runner.mts", true, false],
    ["scripts/lib/format-generated-module.mts", true, false],
    ["test/scripts/format-generated-module.test.ts", true, false],
    [".github/workflows/openclaw-cross-os-release-checks-reusable.yml", true, false],
    [".github/workflows/windows-testbox-probe.yml", true, false],
    ["scripts/github/run-openclaw-cross-os-release-checks.sh", true, false],
    ["scripts/openclaw-cross-os-release-checks.ts", true, false],
    ["scripts/lib/cross-os-release-checks/runtime.ts", true, false],
    ["test/scripts/openclaw-cross-os-release-workflow.test.ts", true, false],
    ["scripts/install.ps1", true, true],
  ])(
    "runs Windows only for Windows-relevant changes (%s)",
    (changedPath, runWindows, runChangedSmoke) => {
      expect(detectChangedScope([changedPath])).toEqual({
        runNode: true,
        runMacos: false,
        runMacosNode: false,
        runIosBuild: false,
        runAndroid: false,
        runWindows,
        runSkillsPython: false,
        runChangedSmoke,
        runControlUiI18n: false,
        runUiTests: false,
      });
    },
  );

  it("runs changed-smoke for install and packaging surfaces", () => {
    expect(detectChangedScope(["scripts/install.sh"])).toEqual(expectedNodeAndChangedSmokeScope);
    expect(detectChangedScope(["scripts/install-cli.sh"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope([bundledPluginFile("matrix", "package.json")])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope([".github/workflows/install-smoke.yml"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/e2e/qr-import-docker.sh"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/e2e/gateway-network-docker.sh"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/e2e/Dockerfile"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/e2e/agents-delete-shared-workspace-docker.sh"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/e2e/plugin-update-unchanged-docker.sh"])).toEqual(
      expectedNodeOnlyScope,
    );
    expect(detectChangedScope(["scripts/postinstall-bundled-plugins.mjs"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["scripts/ci-changed-scope.mjs"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
  });

  it("runs changed-smoke for Docker-covered core runtime surfaces", () => {
    expect(detectChangedScope(["src/plugins/loader.ts"])).toEqual(expectedNodeAndChangedSmokeScope);
    expect(detectChangedScope(["src/plugin-sdk/provider-entry.ts"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["packages/gateway-protocol/src/schema/messages.ts"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["packages/gateway-client/src/client.ts"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope(["src/channels/plugins/catalog.ts"])).toEqual(
      expectedNodeAndChangedSmokeScope,
    );
    expect(detectChangedScope([bundledPluginFile("matrix", "index.ts")])).toEqual(
      expectedNodeOnlyScope,
    );
  });

  it("splits install smoke into fast and full scopes", () => {
    expect(detectInstallSmokeScope([])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: true,
    });
    expect(detectInstallSmokeScope(["docs/ci.md"])).toEqual({
      runFastInstallSmoke: false,
      runFullInstallSmoke: false,
    });
    expect(detectInstallSmokeScope(["scripts/install.sh"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: true,
    });
    expect(detectInstallSmokeScope(["scripts/install-cli.sh"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: true,
    });
    expect(detectInstallSmokeScope(["scripts/install.ps1"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: true,
    });
    expect(detectInstallSmokeScope(["Dockerfile"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: true,
    });
    expect(detectInstallSmokeScope([bundledPluginFile("matrix", "package.json")])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: false,
    });
    expect(detectInstallSmokeScope(["src/plugins/loader.ts"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: false,
    });
    expect(detectInstallSmokeScope(["packages/gateway-client/src/client.ts"])).toEqual({
      runFastInstallSmoke: true,
      runFullInstallSmoke: false,
    });
    expect(detectInstallSmokeScope([bundledPluginFile("matrix", "index.ts")])).toEqual({
      runFastInstallSmoke: false,
      runFullInstallSmoke: false,
    });
  });

  it("keeps changed-smoke off for runtime-surface tests", () => {
    expect(detectChangedScope(["src/plugins/loader.test.ts"])).toEqual(expectedNodeOnlyScope);
    expect(detectChangedScope([bundledPluginFile("matrix", "index.test.ts")])).toEqual(
      expectedNodeOnlyScope,
    );
  });

  it("runs control-ui locale check only for control-ui i18n surfaces", () => {
    const expected = {
      runNode: true,
      runMacos: false,
      runMacosNode: false,
      runIosBuild: false,
      runAndroid: false,
      runWindows: false,
      runSkillsPython: false,
      runChangedSmoke: false,
      runControlUiI18n: true,
      runUiTests: true,
    };
    expect(detectChangedScope(["ui/src/i18n/locales/en.ts"])).toEqual(expected);

    for (const scriptPath of [
      "scripts/control-ui-i18n.ts",
      "scripts/control-ui-i18n-verify.ts",
      "scripts/lib/control-ui-i18n-catalog.ts",
      "scripts/lib/control-ui-i18n-raw-copy.ts",
      "scripts/lib/control-ui-i18n-sync-plan.ts",
    ]) {
      expect(detectChangedScope([scriptPath])).toEqual({ ...expected, runUiTests: false });
    }
  });

  it.each([
    "ui/src/pages/chat/chat-realtime.test.ts",
    "ui/package.json",
    "test/vitest/vitest.shared.config.ts",
    "scripts/ensure-playwright-chromium.mts",
  ])("runs control-ui tests for %s", (changedPath) => {
    expect(detectChangedScope([changedPath]).runUiTests).toBe(true);
  });

  it("identifies plugin contract helper changes as fast Node-only CI scope", () => {
    const bundledCapabilityMetadataPath = [
      "src/plugins/contracts",
      "inventory/bundled-capability-metadata.ts",
    ].join("/");
    expect(
      detectNodeFastScope([
        bundledCapabilityMetadataPath,
        "src/plugins/contracts/registry.ts",
        "src/plugins/contracts/tts-contract-suites.ts",
        "scripts/test-projects.test-support.mts",
        "test/scripts/test-projects.test.ts",
      ]),
    ).toEqual({
      runFastOnly: true,
      runPluginContracts: true,
      runCiRouting: true,
    });
  });

  it("identifies CI routing changes as fast Node-only CI scope", () => {
    expect(
      detectNodeFastScope([
        "scripts/check-changed.mjs",
        "scripts/ci-changed-scope.mjs",
        "scripts/run-vitest.mts",
        "scripts/test-projects.test-support.mts",
        "scripts/lib/ci-docker-seed-plan.mts",
        "test/scripts/ci-docker-seed-plan.test.ts",
        "src/commands/status.scan-result.test.ts",
        "src/scripts/ci-changed-scope.control-ui.test.ts",
        "src/scripts/ci-changed-scope.native-i18n.test.ts",
        "src/scripts/ci-changed-scope.test.ts",
        "src/scripts/ci-changed-scope.windows.test.ts",
        "test/scripts/changed-lanes.test.ts",
        "test/scripts/run-vitest.test.ts",
        "test/scripts/test-projects.test.ts",
        "docs/ci.md",
      ]),
    ).toEqual({
      runFastOnly: true,
      runPluginContracts: false,
      runCiRouting: true,
    });
  });

  it("keeps CI workflow edits off fast-only scope so native lanes can run", () => {
    expect(detectNodeFastScope([".github/workflows/ci.yml"])).toEqual({
      runFastOnly: false,
      runPluginContracts: false,
      runCiRouting: false,
    });
  });

  it("keeps broad source changes on the full Node CI scope", () => {
    expect(
      detectNodeFastScope([
        "src/plugins/contracts/manifest-loader.ts",
        "src/plugins/contracts/registry.ts",
      ]),
    ).toEqual({
      runFastOnly: false,
      runPluginContracts: false,
      runCiRouting: false,
    });
  });

  it("treats base and head as literal git args", () => {
    const markerPath = path.join(
      os.tmpdir(),
      `openclaw-ci-changed-scope-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`,
    );
    markerPaths.push(markerPath);

    const injectedBase =
      process.platform === "win32"
        ? `HEAD & echo injected > "${markerPath}" & rem`
        : `HEAD; touch "${markerPath}" #`;

    let error: unknown;
    try {
      listChangedPaths(injectedBase, "HEAD");
    } catch (caught) {
      error = caught;
    }
    expect(error).toBeInstanceOf(Error);
    expect((error as Error).message).toContain(injectedBase);
    expect(fs.existsSync(markerPath)).toBe(false);
  });

  it("uses the merge commit first parent instead of a stale PR payload base", () => {
    const { repoDir, staleBase } = createSyntheticMergeRepo("openclaw-ci-scope-merge-");

    expect(
      execFileSync("git", ["diff", "--name-only", staleBase, "HEAD"], {
        cwd: repoDir,
        encoding: "utf8",
      })
        .trim()
        .split("\n")
        .toSorted(),
    ).toEqual(["src/main-only.ts", "src/pr.ts"]);

    expect(listChangedPaths(staleBase, "HEAD", repoDir, true)).toEqual(["src/pr.ts"]);
  });

  it("reports both sides of a rename so deleted paths force safe planning", () => {
    const repoDir = tempDirs.make("openclaw-ci-scope-rename-");
    git(repoDir, ["init", "-b", "main"]);
    git(repoDir, ["config", "user.email", "ci@example.invalid"]);
    git(repoDir, ["config", "user.name", "CI"]);
    writeRepoFile(repoDir, "src/old.ts", "export const value = 1;\n");
    git(repoDir, ["add", "."]);
    git(repoDir, ["commit", "-m", "base"]);
    const base = git(repoDir, ["rev-parse", "HEAD"]);
    fs.renameSync(path.join(repoDir, "src/old.ts"), path.join(repoDir, "src/new.ts"));
    git(repoDir, ["add", "-A"]);
    git(repoDir, ["commit", "-m", "rename"]);

    expect(listChangedPaths(base, "HEAD", repoDir)).toEqual(["src/new.ts", "src/old.ts"]);
  });

  it("preserves leading spaces and newlines in Git filename tokens", () => {
    if (process.platform === "win32") {
      return;
    }
    const repoDir = tempDirs.make("openclaw-ci-scope-raw-paths-");
    git(repoDir, ["init", "-b", "main"]);
    git(repoDir, ["config", "user.email", "ci@example.invalid"]);
    git(repoDir, ["config", "user.name", "CI"]);
    writeRepoFile(repoDir, "README.md", "base\n");
    git(repoDir, ["add", "."]);
    git(repoDir, ["commit", "-m", "base"]);
    const base = git(repoDir, ["rev-parse", "HEAD"]);
    const changedPaths = [" scripts/changed-lanes.mts", "scripts/changed\nlanes.mts"];
    for (const changedPath of changedPaths) {
      writeRepoFile(repoDir, changedPath, "export {};\n");
    }
    git(repoDir, ["add", "--", ...changedPaths]);
    git(repoDir, ["commit", "-m", "raw paths"]);

    expect(listChangedPaths(base, "HEAD", repoDir).toSorted()).toEqual(changedPaths.toSorted());
  });

  it("drops oversized changed-path payloads before workflow environment interpolation", () => {
    const outputPath = path.join(os.tmpdir(), `openclaw-ci-scope-output-${Date.now()}.txt`);
    markerPaths.push(outputPath);
    const changedPaths = Array.from(
      { length: 1_000 },
      (_, index) => `src/generated/${index}-${"x".repeat(100)}.ts`,
    );
    writeGitHubOutput(
      detectChangedScope(["docs/ci.md"]),
      outputPath,
      undefined,
      undefined,
      false,
      changedPaths,
    );

    expect(parseGitHubOutput(fs.readFileSync(outputPath, "utf8")).changed_paths_json).toBe("null");
  });

  it.each<[string, string, string, boolean, string[]?]>([
    ["missing base", "", "missing", true, ["--head", "HEAD"]],
    ["unknown option", "", "missing", true, ["--base", "HEAD", "--head", "HEAD", "--mystery"]],
    ["empty diff without a manifest", "", "missing", false],
    ["declared native test", "src/process/exec.windows.integration.test.ts", "valid", false],
    ["Mac fixture helper", "test/scripts/mac-script-fixture.test-support.ts", "valid", false],
    ["unrelated process test", "src/process/exec.test.ts", "valid", false],
    ["missing manifest", "src/process/exec.test.ts", "missing", true],
    ["invalid manifest", "src/process/exec.test.ts", "invalid", true],
    ["empty native inventory", "src/process/exec.test.ts", "empty", true],
  ])(
    "runs zero-install scope detection for %s",
    (_label, changedPath, manifest, failSafe, cliArgs) => {
      const repoDir = fs.realpathSync(tempDirs.make("openclaw-ci-scope-empty-"));
      const outputPath = path.join(repoDir, "github-output.txt");
      const scriptPath = path.join(repoDir, "scripts/ci-changed-scope.mjs");

      execFileSync("git", ["init", "-b", "main"], { cwd: repoDir });
      execFileSync("git", ["config", "user.email", "ci@example.invalid"], { cwd: repoDir });
      execFileSync("git", ["config", "user.name", "CI"], { cwd: repoDir });
      for (const sourcePath of [
        "scripts/ci-changed-scope.mjs",
        "scripts/lib/arg-utils.runtime.mjs",
        "scripts/lib/changed-path-facts.mjs",
        "scripts/lib/direct-run.mjs",
        "scripts/lib/merge-head-diff-base.mjs",
      ]) {
        writeRepoFile(repoDir, sourcePath, fs.readFileSync(path.resolve(sourcePath), "utf8"));
      }
      fs.writeFileSync(path.join(repoDir, "README.md"), "test\n", "utf8");
      execFileSync("git", ["add", "README.md"], { cwd: repoDir });
      execFileSync("git", ["commit", "-m", "test"], { cwd: repoDir });

      if (manifest !== "missing") {
        const contents =
          manifest === "valid"
            ? fs.readFileSync("package.json", "utf8")
            : manifest === "invalid"
              ? "{"
              : JSON.stringify({ scripts: { "test:windows:ci:1": "" } });
        writeRepoFile(repoDir, "package.json", contents);
      }
      if (changedPath) {
        writeRepoFile(repoDir, changedPath, "export {};\n");
        git(repoDir, ["add", changedPath]);
        git(repoDir, ["commit", "-m", "changed test"]);
      }
      const base = changedPath ? "HEAD^" : "HEAD";
      expect(fs.existsSync(path.join(repoDir, "node_modules"))).toBe(false);
      execFileSync(
        process.execPath,
        [scriptPath, ...(cliArgs ?? ["--base", base, "--head", "HEAD"])],
        {
          cwd: repoDir,
          env: { ...process.env, GITHUB_OUTPUT: outputPath },
        },
      );

      const output = parseGitHubOutput(fs.readFileSync(outputPath, "utf8"));
      expect(Object.keys(output).toSorted()).toEqual(
        "changed_paths_json run_android run_changed_smoke run_control_ui_i18n run_fast_install_smoke run_full_install_smoke run_ios_build run_ios_screenshots run_macos run_macos_node run_native_i18n run_node run_node_fast_ci_routing run_node_fast_only run_node_fast_plugin_contracts run_skills_python run_ui_tests run_windows strict_control_ui_i18n strict_native_i18n".split(
          " ",
        ),
      );
      expect(output.changed_paths_json).toBe(
        failSafe ? "null" : JSON.stringify(changedPath ? [changedPath] : []),
      );
      for (const [key, value] of Object.entries(output)) {
        if (key !== "changed_paths_json") {
          const selected =
            (failSafe && !key.startsWith("run_node_fast")) ||
            (key === "run_node" && Boolean(changedPath)) ||
            (key === "run_macos_node" &&
              changedPath === "test/scripts/mac-script-fixture.test-support.ts") ||
            (key === "run_windows" &&
              changedPath === "src/process/exec.windows.integration.test.ts");
          expect(value, key).toBe(String(selected));
        }
      }
    },
  );
});