From 88d882d5ff3029262a64374a58ffd34db8cf48ac Mon Sep 17 00:00:00 2001 From: Juan Sugg Date: Wed, 11 Nov 2026 02:16:26 -0300 Subject: [PATCH] ci(memory-plugin): install host openclaw from node-tools lock The vendored memory-plugin host lane ran `npm install openclaw@` into a temp prefix, so every transitive dependency floated and the lane could hit ETARGET on freshly published packages, the flake class the node-tools lock already fixed for bootstrap. - Install the committed platform/node-tools manifest+lock with the same `npm ci` + transient-retry + `--version` smoke path bootstrap uses; the version now comes from the manifest, so `--package-spec` and the hardcoded pin in the workflow are gone. - Route node-tools lock/module changes to the memory_plugin CI lane and key the setup-node npm cache on the node-tools lock too. - Add a repo contract that scans workflow YAML and CI helper Python for resolving `npm install|i|add` (except --package-lock-only) and for `npx`/`npm exec` of openclaw/acpx. The strongclaw-hypermemory host check needs no change: it has no dependencies and uses a local plugin SDK stub, and `npm run` installs nothing. --- .github/ci/ci-gate-filters.yml | 3 + .../workflows/memory-plugin-verification.yml | 6 +- tests/scripts/memory_plugin_verification.py | 7 +- .../contracts/repo/test_node_tools_lock.py | 39 ++++ tests/suites/unit/ci/test_ci_gate_filters.py | 13 ++ .../ci/test_memory_plugin_verification.py | 122 +++++++++++-- .../helpers/_ci_workflows/memory_plugin.py | 43 ++--- tests/utils/helpers/ci_node_installs.py | 167 ++++++++++++++++++ tests/utils/helpers/ci_workflows.py | 4 +- 9 files changed, 361 insertions(+), 43 deletions(-) create mode 100644 tests/utils/helpers/ci_node_installs.py diff --git a/.github/ci/ci-gate-filters.yml b/.github/ci/ci-gate-filters.yml index 3b7cbe7c..70d395c8 100644 --- a/.github/ci/ci-gate-filters.yml +++ b/.github/ci/ci-gate-filters.yml @@ -111,6 +111,9 @@ harness: memory_plugin: - ".github/workflows/memory-plugin-verification.yml" + - "platform/node-tools/**" + - "src/clawops/assets/platform/node-tools/**" + - "src/clawops/strongclaw_node_tools.py" - "platform/plugins/memory-lancedb-pro/**" - "platform/plugins/strongclaw-hypermemory/**" - "src/clawops/assets/platform/plugins/memory-lancedb-pro/**" diff --git a/.github/workflows/memory-plugin-verification.yml b/.github/workflows/memory-plugin-verification.yml index 0b0352ee..999c966f 100644 --- a/.github/workflows/memory-plugin-verification.yml +++ b/.github/workflows/memory-plugin-verification.yml @@ -40,7 +40,9 @@ jobs: with: node-version: ${{ matrix.node-version }} cache: npm - cache-dependency-path: platform/plugins/memory-lancedb-pro/package-lock.json + cache-dependency-path: | + platform/node-tools/package-lock.json + platform/plugins/memory-lancedb-pro/package-lock.json - uses: actions/setup-python@ece7cb06caefa5fff74198d8649806c4678c61a1 # v6 with: python-version: "3.12" @@ -51,7 +53,7 @@ jobs: - run: uv sync --locked - run: PYTHONPATH=src uv run python -m clawops config --asset-root . memory --set-profile memory-lancedb-pro --output "$RUNNER_TEMP/openclaw.json" - run: python3 ./tests/scripts/memory_plugin_verification.py run-clawops-memory-migration --repo-root . --runner-temp "$RUNNER_TEMP" - - run: python3 ./tests/scripts/memory_plugin_verification.py run-vendored-host-checks --repo-root . --package-spec "openclaw@2026.3.13" + - run: python3 ./tests/scripts/memory_plugin_verification.py run-vendored-host-checks --repo-root . verify-hypermemory-qdrant: name: Run Hypermemory Qdrant Checks runs-on: ubuntu-latest diff --git a/tests/scripts/memory_plugin_verification.py b/tests/scripts/memory_plugin_verification.py index aa176534..1b68ddb4 100644 --- a/tests/scripts/memory_plugin_verification.py +++ b/tests/scripts/memory_plugin_verification.py @@ -15,7 +15,6 @@ from tests.utils.helpers._ci_workflows.common import CiWorkflowError # noqa: E402 from tests.utils.helpers._ci_workflows.memory_plugin import ( # noqa: E402 - DEFAULT_OPENCLAW_PACKAGE_SPEC, run_clawops_memory_migration, run_vendored_host_checks, wait_for_qdrant, @@ -32,7 +31,6 @@ def _parse_args(argv: list[str] | None = None) -> argparse.Namespace: help="Run vendored memory plugin host-functional checks.", ) vendored_parser.add_argument("--repo-root", type=Path, default=REPO_ROOT) - vendored_parser.add_argument("--package-spec", default=DEFAULT_OPENCLAW_PACKAGE_SPEC) migration_parser = subparsers.add_parser( "run-clawops-memory-migration", @@ -54,10 +52,7 @@ def main(argv: list[str] | None = None) -> int: args = _parse_args(argv) try: if args.command == "run-vendored-host-checks": - run_vendored_host_checks( - Path(args.repo_root).expanduser().resolve(), - package_spec=str(args.package_spec), - ) + run_vendored_host_checks(Path(args.repo_root).expanduser().resolve()) return 0 if args.command == "run-clawops-memory-migration": run_clawops_memory_migration( diff --git a/tests/suites/contracts/repo/test_node_tools_lock.py b/tests/suites/contracts/repo/test_node_tools_lock.py index f7aa309c..ad73b297 100644 --- a/tests/suites/contracts/repo/test_node_tools_lock.py +++ b/tests/suites/contracts/repo/test_node_tools_lock.py @@ -11,6 +11,10 @@ from clawops import platform_compat from clawops.strongclaw_node_tools import NODE_TOOLS_ASSET_DIR, load_node_tools_bundle +from tests.utils.helpers.ci_node_installs import ( + find_floating_node_commands, + find_floating_node_installs, +) from tests.utils.helpers.node_tools import find_version_mentions from tests.utils.helpers.repo import REPO_ROOT @@ -88,3 +92,38 @@ def test_node_tools_bundle_ships_in_package_data() -> None: package_data = pyproject["tool"]["setuptools"]["package-data"]["clawops.assets"] assert "platform/node-tools/*" in package_data + + +@pytest.mark.parametrize( + ("command", "floating"), + [ + ("npm install --prefix /tmp/x --no-fund openclaw@2026.3.13", True), + ("npm --prefix /tmp/x i -g acpx", True), + ("npm install --prefix --no-fund --no-audit ", True), + ("npx -y openclaw@2026.3.13 --version", True), + ("npm exec --package=acpx@0.3.0 -- acpx --help", True), + ("echo ready && npm add left-pad", True), + ("npm ci --omit=dev --no-audit --no-fund", False), + ("npm --prefix platform/plugins/strongclaw-hypermemory run test:openclaw-host", False), + ("npm install --package-lock-only --ignore-scripts", False), + ("npm run install-deps", False), + ("npx tsc --noEmit", False), + ("pnpm install openclaw", False), + ], +) +def test_floating_node_command_detector(command: str, floating: bool) -> None: + """The detector flags resolving installs and OpenClaw/ACPX npx runs, not locked commands.""" + assert bool(find_floating_node_commands(command)) is floating + + +def test_ci_never_installs_node_packages_outside_a_lock() -> None: + """CI installs OpenClaw/ACPX only via `npm ci` of a committed lock, never a floating install.""" + findings = [ + f"{finding.path}: {finding.command}" for finding in find_floating_node_installs(REPO_ROOT) + ] + + assert findings == [], ( + "install from platform/node-tools with `npm ci` " + "(tests/utils/helpers/_ci_workflows/memory_plugin.install_locked_node_tools): " + + ", ".join(findings) + ) diff --git a/tests/suites/unit/ci/test_ci_gate_filters.py b/tests/suites/unit/ci/test_ci_gate_filters.py index dc1e5a2c..d2653a11 100644 --- a/tests/suites/unit/ci/test_ci_gate_filters.py +++ b/tests/suites/unit/ci/test_ci_gate_filters.py @@ -80,6 +80,19 @@ def test_memory_plugin_package_change_routes_to_memory_compatibility_and_fresh_h assert selection.docs_parity_required is False +@pytest.mark.parametrize( + "changed_path", + [ + "platform/node-tools/package-lock.json", + "src/clawops/assets/platform/node-tools/package.json", + "src/clawops/strongclaw_node_tools.py", + ], +) +def test_node_tools_change_routes_to_memory_plugin_lane(changed_path: str) -> None: + """The memory-plugin lane installs OpenClaw from the node-tools lock, so bumps must run it.""" + assert _select(changed_path).memory_plugin is True + + def test_lockfile_change_routes_to_dependency_review_without_heavy_local_runtime() -> None: selection = _select("uv.lock") diff --git a/tests/suites/unit/ci/test_memory_plugin_verification.py b/tests/suites/unit/ci/test_memory_plugin_verification.py index 080797ca..79a72085 100644 --- a/tests/suites/unit/ci/test_memory_plugin_verification.py +++ b/tests/suites/unit/ci/test_memory_plugin_verification.py @@ -2,25 +2,58 @@ from __future__ import annotations +import shutil from pathlib import Path from typing import Any +import pytest + +from clawops.strongclaw_node_tools import ( + LOCK_FILE_NAME, + MANIFEST_FILE_NAME, + NODE_TOOLS_ASSET_DIR, + LocalPrefixWriter, + NodeToolsBundle, + NodeToolsError, + PrefixWriter, + load_node_tools_bundle, +) from tests.plugins.infrastructure.context import TestContext from tests.scripts import memory_plugin_verification as memory_plugin_script from tests.utils.helpers import ci_workflows from tests.utils.helpers._ci_workflows import memory_plugin as memory_plugin_helpers +from tests.utils.helpers._ci_workflows.common import CiWorkflowError +from tests.utils.helpers.repo import REPO_ROOT -def test_run_vendored_host_checks_installs_cli_and_clears_aws_env( +def _seed_node_tools_bundle(repo_root: Path) -> None: + """Copy the committed node-tools manifest and lock into a scratch repo root.""" + target_dir = repo_root / NODE_TOOLS_ASSET_DIR + target_dir.mkdir(parents=True) + for file_name in (MANIFEST_FILE_NAME, LOCK_FILE_NAME): + shutil.copyfile(REPO_ROOT / NODE_TOOLS_ASSET_DIR / file_name, target_dir / file_name) + + +def test_run_vendored_host_checks_installs_locked_cli_and_clears_aws_env( test_context: TestContext, tmp_path: Path, ) -> None: - """Vendored host checks should prefix PATH and clear ambient AWS variables.""" + """Host checks install the committed lock, prefix PATH, and clear ambient AWS variables.""" repo_root = tmp_path / "repo" plugin_dir = repo_root / "platform" / "plugins" / "memory-lancedb-pro" plugin_dir.mkdir(parents=True) + _seed_node_tools_bundle(repo_root) + staged: list[tuple[NodeToolsBundle, Path, PrefixWriter]] = [] + smoked: list[tuple[Path, NodeToolsBundle]] = [] seen_calls: list[tuple[list[str], Path | None, dict[str, str] | None]] = [] + def fake_stage(bundle: NodeToolsBundle, target_dir: Path, writer: PrefixWriter) -> None: + assert target_dir.is_dir() + staged.append((bundle, target_dir, writer)) + + def fake_smoke(bin_dir: Path, bundle: NodeToolsBundle) -> None: + smoked.append((bin_dir, bundle)) + def fake_run_checked( command: list[str], *, @@ -33,6 +66,8 @@ def fake_run_checked( seen_calls.append((command, cwd, env)) return None + test_context.patch.patch_object(memory_plugin_helpers, "stage_node_tools_tree", new=fake_stage) + test_context.patch.patch_object(memory_plugin_helpers, "smoke_test_node_tools", new=fake_smoke) test_context.patch.patch_object(memory_plugin_helpers, "run_checked", new=fake_run_checked) test_context.env.set("PATH", "/usr/bin") test_context.env.set("AWS_PROFILE", "default") @@ -40,17 +75,78 @@ def fake_run_checked( ci_workflows.run_vendored_host_checks(repo_root) - install_command, install_cwd, install_env = seen_calls[0] - assert install_command[:4] == ["npm", "install", "--prefix", install_command[3]] - assert install_cwd == repo_root.resolve() - assert install_env is None - - _, npm_ci_cwd, npm_ci_env = seen_calls[1] - assert npm_ci_cwd == plugin_dir.resolve() - assert npm_ci_env is not None - assert "AWS_PROFILE" not in npm_ci_env - assert "AWS_REGION" not in npm_ci_env - assert npm_ci_env["PATH"].startswith(str(Path(install_command[3]) / "node_modules" / ".bin")) + committed = load_node_tools_bundle(REPO_ROOT / NODE_TOOLS_ASSET_DIR) + [(bundle, tool_dir, writer)] = staged + assert bundle.digest == committed.digest + assert bundle.manifest_path == (repo_root / NODE_TOOLS_ASSET_DIR / MANIFEST_FILE_NAME).resolve() + assert isinstance(writer, LocalPrefixWriter) + bin_dir = tool_dir / "node_modules" / ".bin" + assert smoked == [(bin_dir, bundle)] + assert not tool_dir.exists() + + assert [(command, cwd) for command, cwd, _ in seen_calls] == [ + (["npm", "ci", "--no-fund", "--no-audit"], plugin_dir.resolve()), + (["npm", "run", "test:openclaw-host"], plugin_dir.resolve()), + ] + for _, _, env in seen_calls: + assert env is not None + assert "AWS_PROFILE" not in env + assert "AWS_REGION" not in env + assert env["PATH"] == f"{bin_dir}:/usr/bin" + + +def test_run_vendored_host_checks_reports_locked_install_failure( + test_context: TestContext, + tmp_path: Path, +) -> None: + """A failed locked install surfaces as a CI error and skips the plugin checks.""" + repo_root = tmp_path / "repo" + _seed_node_tools_bundle(repo_root) + tool_dirs: list[Path] = [] + seen_commands: list[list[str]] = [] + + def failing_stage(bundle: NodeToolsBundle, target_dir: Path, writer: PrefixWriter) -> None: + del bundle, writer + tool_dirs.append(target_dir) + raise NodeToolsError("npm ci failed in /tmp (ETARGET)") + + def fake_run_checked(command: list[str], **kwargs: Any) -> Any: + del kwargs + seen_commands.append(command) + return None + + test_context.patch.patch_object( + memory_plugin_helpers, "stage_node_tools_tree", new=failing_stage + ) + test_context.patch.patch_object(memory_plugin_helpers, "run_checked", new=fake_run_checked) + + with pytest.raises(CiWorkflowError, match=r"locked node-tools install failed: .*ETARGET"): + ci_workflows.run_vendored_host_checks(repo_root) + + assert seen_commands == [] + assert [tool_dir.exists() for tool_dir in tool_dirs] == [False] + + +def test_main_dispatches_run_vendored_host_checks( + test_context: TestContext, + tmp_path: Path, +) -> None: + """The CLI dispatches host checks with only the repo root; no package spec is accepted.""" + seen_roots: list[Path] = [] + test_context.patch.patch_object( + memory_plugin_script, "run_vendored_host_checks", new=seen_roots.append + ) + + exit_code = memory_plugin_script.main( + ["run-vendored-host-checks", "--repo-root", str(tmp_path / "repo")] + ) + + assert exit_code == 0 + assert seen_roots == [(tmp_path / "repo").resolve()] + with pytest.raises(SystemExit): + memory_plugin_script.main( + ["run-vendored-host-checks", "--package-spec", "openclaw@2026.3.13"] + ) def test_wait_for_qdrant_retries_until_ready(test_context: TestContext) -> None: diff --git a/tests/utils/helpers/_ci_workflows/memory_plugin.py b/tests/utils/helpers/_ci_workflows/memory_plugin.py index 1f9ab3ca..e2e1e7f1 100644 --- a/tests/utils/helpers/_ci_workflows/memory_plugin.py +++ b/tests/utils/helpers/_ci_workflows/memory_plugin.py @@ -10,10 +10,16 @@ import urllib.request from pathlib import Path -from clawops.platform_compat import DEFAULT_OPENCLAW_VERSION +from clawops.strongclaw_node_tools import ( + LocalPrefixWriter, + NodeToolsError, + load_node_tools_bundle, + resolve_node_tools_dir, + smoke_test_node_tools, + stage_node_tools_tree, +) from tests.utils.helpers._ci_workflows.common import CiWorkflowError, run_checked -DEFAULT_OPENCLAW_PACKAGE_SPEC = f"openclaw@{DEFAULT_OPENCLAW_VERSION}" AWS_CREDENTIAL_ENV_VARS = ( "AWS_PROFILE", "AWS_ACCESS_KEY_ID", @@ -24,29 +30,26 @@ ) -def run_vendored_host_checks( - repo_root: Path, - *, - package_spec: str = DEFAULT_OPENCLAW_PACKAGE_SPEC, -) -> None: +def install_locked_node_tools(repo_root: Path, tool_dir: Path) -> Path: + """Install the committed OpenClaw/ACPX lock into *tool_dir* and return its bin directory.""" + try: + bundle = load_node_tools_bundle(resolve_node_tools_dir(repo_root)) + stage_node_tools_tree(bundle, tool_dir, LocalPrefixWriter()) + bin_dir = tool_dir / "node_modules" / ".bin" + smoke_test_node_tools(bin_dir, bundle) + except NodeToolsError as exc: + raise CiWorkflowError(f"locked node-tools install failed: {exc}") from exc + return bin_dir + + +def run_vendored_host_checks(repo_root: Path) -> None: """Run the vendored memory plugin host-functional verification.""" resolved_repo_root = repo_root.expanduser().resolve() tool_dir = Path(tempfile.mkdtemp(prefix="strongclaw-openclaw-cli.")) try: - run_checked( - [ - "npm", - "install", - "--prefix", - str(tool_dir), - "--no-fund", - "--no-audit", - package_spec, - ], - cwd=resolved_repo_root, - ) + bin_dir = install_locked_node_tools(resolved_repo_root, tool_dir) env = dict(os.environ) - env["PATH"] = f"{tool_dir / 'node_modules' / '.bin'}:{env.get('PATH', '')}" + env["PATH"] = f"{bin_dir}:{env.get('PATH', '')}" for key in AWS_CREDENTIAL_ENV_VARS: env.pop(key, None) plugin_dir = resolved_repo_root / "platform" / "plugins" / "memory-lancedb-pro" diff --git a/tests/utils/helpers/ci_node_installs.py b/tests/utils/helpers/ci_node_installs.py new file mode 100644 index 00000000..3319463d --- /dev/null +++ b/tests/utils/helpers/ci_node_installs.py @@ -0,0 +1,167 @@ +"""Detect CI commands that install OpenClaw/ACPX (or any npm tree) outside a committed lock.""" + +from __future__ import annotations + +import ast +import dataclasses +import re +import subprocess +from collections.abc import Iterator, Sequence +from pathlib import Path +from typing import Final, cast + +import yaml + +CI_WORKFLOW_PREFIX: Final[str] = ".github/" +CI_PYTHON_PREFIXES: Final[tuple[str, ...]] = ( + "tests/scripts/", + "tests/utils/helpers/_ci_workflows/", +) +_CI_YAML_SUFFIXES: Final[frozenset[str]] = frozenset({".yml", ".yaml"}) +# Every npm verb that resolves a dependency tree from the registry instead of a lockfile. +_NPM_RESOLVING_INSTALL_VERBS: Final[frozenset[str]] = frozenset( + { + "add", + "i", + "in", + "ins", + "inst", + "insta", + "instal", + "install", + "install-test", + "isnt", + "isnta", + "isntal", + "isntall", + "it", + } +) +_NPM_EXEC_VERBS: Final[frozenset[str]] = frozenset({"exec", "x"}) +_NPM_OPTIONS_WITH_VALUE: Final[frozenset[str]] = frozenset( + {"--cache", "--prefix", "--registry", "--userconfig", "--workspace", "-C", "-w"} +) +_NPM_LOCK_ONLY_FLAG: Final[str] = "--package-lock-only" +_NODE_TOOL_SPEC_PATTERN: Final[re.Pattern[str]] = re.compile(r"^(?:openclaw|acpx)(?:@|$)") +_NPM_COMMAND_PATTERN: Final[re.Pattern[str]] = re.compile( + r"(?" + + +@dataclasses.dataclass(frozen=True, slots=True) +class FloatingNodeInstall: + """One CI command that would resolve npm packages outside a committed lock.""" + + path: Path + command: str + + +def _npm_subcommand(arguments: Sequence[str]) -> tuple[int, str | None]: + """Return the index and name of the npm subcommand, skipping global options.""" + skip_value = False + for index, token in enumerate(arguments): + if skip_value: + skip_value = False + continue + if token in _NPM_OPTIONS_WITH_VALUE: + skip_value = True + continue + if not token.startswith("-"): + return index, token + return len(arguments), None + + +def _names_node_tool(arguments: Sequence[str]) -> bool: + """Return whether any argument is an OpenClaw/ACPX package spec.""" + return any( + _NODE_TOOL_SPEC_PATTERN.match(token.removeprefix("--package=")) is not None + for token in arguments + ) + + +def _is_floating_node_command(executable: str, arguments: Sequence[str]) -> bool: + """Return whether one npm/npx invocation bypasses the committed lock.""" + if executable == "npx": + return _names_node_tool(arguments) + index, subcommand = _npm_subcommand(arguments) + if subcommand in _NPM_RESOLVING_INSTALL_VERBS: + return _NPM_LOCK_ONLY_FLAG not in arguments + if subcommand in _NPM_EXEC_VERBS: + return _names_node_tool(arguments[index + 1 :]) + return False + + +def find_floating_node_commands(text: str) -> list[str]: + """Return every npm/npx command in shell-like *text* that resolves outside a lock. + + Any resolving `npm install` is reported, not only ones that name OpenClaw/ACPX: CI often + passes the spec through a variable, so the package cannot be identified from the text. + """ + commands: list[str] = [] + for match in _NPM_COMMAND_PATTERN.finditer(text): + arguments = [token.strip("\"'") for token in match.group(2).split()] + if _is_floating_node_command(match.group(1), arguments): + commands.append(match.group(0).strip()) + return commands + + +def _yaml_strings(node: object) -> Iterator[str]: + """Yield every string value in a loaded YAML document.""" + if isinstance(node, str): + yield node + elif isinstance(node, dict): + for value in cast(dict[object, object], node).values(): + yield from _yaml_strings(value) + elif isinstance(node, list): + for item in cast(list[object], node): + yield from _yaml_strings(item) + + +def _python_command_texts(source: str, *, filename: str) -> Iterator[str]: + """Yield string literals and argv-style list/tuple literals rendered as shell text.""" + for node in ast.walk(ast.parse(source, filename=filename)): + if isinstance(node, ast.Constant) and isinstance(node.value, str): + yield node.value + elif isinstance(node, (ast.List, ast.Tuple)): + yield " ".join( + ( + element.value + if isinstance(element, ast.Constant) and isinstance(element.value, str) + else _ARGV_EXPRESSION_PLACEHOLDER + ) + for element in node.elts + ) + + +def _tracked_ci_files(repo_root: Path) -> list[Path]: + """Return repo-relative tracked files under the CI workflow and CI helper prefixes.""" + result = subprocess.run( + ["git", "-C", str(repo_root), "ls-files", "-z", "--"] + + [CI_WORKFLOW_PREFIX, *CI_PYTHON_PREFIXES], + check=True, + capture_output=True, + ) + return [Path(raw.decode("utf-8")) for raw in result.stdout.split(b"\0") if raw] + + +def _command_texts(relative: Path, text: str) -> Iterator[str]: + """Yield the shell-like texts one CI file can execute.""" + posix = relative.as_posix() + if posix.startswith(CI_WORKFLOW_PREFIX) and relative.suffix in _CI_YAML_SUFFIXES: + yield from _yaml_strings(yaml.safe_load(text)) + elif posix.startswith(CI_PYTHON_PREFIXES) and relative.suffix == ".py": + yield from _python_command_texts(text, filename=posix) + + +def find_floating_node_installs(repo_root: Path) -> list[FloatingNodeInstall]: + """Return lock-bypassing npm/npx commands in CI workflows and their Python helpers.""" + findings: dict[FloatingNodeInstall, None] = {} + for relative in _tracked_ci_files(repo_root): + path = repo_root / relative + if not path.is_file(): + continue + for candidate in _command_texts(relative, path.read_text(encoding="utf-8")): + for command in find_floating_node_commands(candidate): + findings[FloatingNodeInstall(path=relative, command=command)] = None + return list(findings) diff --git a/tests/utils/helpers/ci_workflows.py b/tests/utils/helpers/ci_workflows.py index 2573659b..3036e83f 100644 --- a/tests/utils/helpers/ci_workflows.py +++ b/tests/utils/helpers/ci_workflows.py @@ -11,7 +11,7 @@ ) from tests.utils.helpers._ci_workflows.memory_plugin import ( AWS_CREDENTIAL_ENV_VARS, - DEFAULT_OPENCLAW_PACKAGE_SPEC, + install_locked_node_tools, run_clawops_memory_migration, run_vendored_host_checks, wait_for_qdrant, @@ -40,7 +40,6 @@ __all__ = [ "AWS_CREDENTIAL_ENV_VARS", "CiWorkflowError", - "DEFAULT_OPENCLAW_PACKAGE_SPEC", "SetupSmokePaths", "append_coverage_summary", "assert_hypermemory_config", @@ -48,6 +47,7 @@ "assert_openclaw_profiles_render", "clean_artifact_directories", "enforce_coverage_thresholds", + "install_locked_node_tools", "install_gitleaks", "install_syft", "prepare_setup_smoke",