Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
ci: check dependency licence compatibility (#4364)
Francesco Bonacci5b4501c9cd0d
diff --git a/.github/workflows/license-check.yml b/.github/workflows/license-check.ymlnew file mode 100644index 0000000000..ba502281af--- /dev/null+++ b/.github/workflows/license-check.yml@@ -0,0 +1,54 @@+name: "CI: License direction"++# Checks that MIT packages only depend on internal packages under permissive+# licences, and reports packages without a declared licence. Report-only+# (continue-on-error: true) while the existing cua-agent[omni] -> cua-som edge+# is reviewed; remove continue-on-error to make it blocking.+# See scripts/check-license-direction.py for the rules.++on:+ pull_request:+ paths:+ - "**/Cargo.toml"+ - "**/package.json"+ - "**/pyproject.toml"+ - "**/LICENSE*"+ - "scripts/check-license-direction.py"+ - ".github/workflows/license-check.yml"+ push:+ branches: [main]+ paths:+ - "**/Cargo.toml"+ - "**/package.json"+ - "**/pyproject.toml"+ - "**/LICENSE*"+ - "scripts/check-license-direction.py"+ - ".github/workflows/license-check.yml"++permissions:+ contents: read++jobs:+ check:+ name: Check dependency licence direction+ runs-on: ubuntu-latest+ steps:+ - name: Checkout repository+ uses: actions/checkout@34e114876b0b11c390a56381ad16ebd13914f8d5 # v4+ with:+ persist-credentials: false++ - name: Set up Python+ uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5+ with:+ python-version: "3.9"++ - name: Check licence direction+ id: check+ continue-on-error: true+ run: python3 scripts/check-license-direction.py++ - name: Flag violations+ if: steps.check.outcome == 'failure'+ run: |+ echo "::warning title=License direction::An MIT package depends on an internal package outside the licence allow-list. See the 'Check licence direction' step output."diff --git a/libs/cua-driver/rust/crates/cua-driver-contract/Cargo.toml b/libs/cua-driver/rust/crates/cua-driver-contract/Cargo.tomlindex d673387918..a41ae2a776 100644--- a/libs/cua-driver/rust/crates/cua-driver-contract/Cargo.toml+++ b/libs/cua-driver/rust/crates/cua-driver-contract/Cargo.toml@@ -2,6 +2,7 @@name = "cua-driver-contract"version.workspace = trueedition.workspace = true+license.workspace = truepublish = false[[bin]]diff --git a/libs/cua-driver/rust/crates/cua-driver-core/Cargo.toml b/libs/cua-driver/rust/crates/cua-driver-core/Cargo.tomlindex 32827d6448..db609d624a 100644--- a/libs/cua-driver/rust/crates/cua-driver-core/Cargo.toml+++ b/libs/cua-driver/rust/crates/cua-driver-core/Cargo.toml@@ -2,6 +2,7 @@name = "cua-driver-core"version.workspace = trueedition.workspace = true+license.workspace = truepublish = false[features]diff --git a/libs/cua-driver/rust/crates/cua-driver-uia/Cargo.toml b/libs/cua-driver/rust/crates/cua-driver-uia/Cargo.tomlindex e102db8c17..52abca90d1 100644--- a/libs/cua-driver/rust/crates/cua-driver-uia/Cargo.toml+++ b/libs/cua-driver/rust/crates/cua-driver-uia/Cargo.toml@@ -2,6 +2,7 @@name = "cua-driver-uia"version.workspace = trueedition.workspace = true+license.workspace = truedescription = "Windows uiAccess-elevated worker for cua-driver-rs (Calculator / UWP automation)"# Tiny uiAccess-marked binary that hosts the Windows tool registry over a nameddiff --git a/libs/cua-driver/rust/crates/cua-driver/Cargo.toml b/libs/cua-driver/rust/crates/cua-driver/Cargo.tomlindex 110ddf0373..88d8470194 100644--- a/libs/cua-driver/rust/crates/cua-driver/Cargo.toml+++ b/libs/cua-driver/rust/crates/cua-driver/Cargo.toml@@ -2,6 +2,7 @@name = "cua-driver"version.workspace = trueedition.workspace = true+license.workspace = truedescription = "Cross-platform background computer-use automation daemon (MCP server)"default-run = "cua-driver"diff --git a/libs/cua-driver/rust/crates/cursor-overlay/Cargo.toml b/libs/cua-driver/rust/crates/cursor-overlay/Cargo.tomlindex 1f86c01a87..47c775fd1f 100644--- a/libs/cua-driver/rust/crates/cursor-overlay/Cargo.toml+++ b/libs/cua-driver/rust/crates/cursor-overlay/Cargo.toml@@ -2,6 +2,7 @@name = "cursor-overlay"version.workspace = trueedition.workspace = true+license.workspace = true[features]default = []diff --git a/libs/cua-driver/rust/crates/pip-preview/Cargo.toml b/libs/cua-driver/rust/crates/pip-preview/Cargo.tomlindex 1c9f84b1ce..efa5f7b49d 100644--- a/libs/cua-driver/rust/crates/pip-preview/Cargo.toml+++ b/libs/cua-driver/rust/crates/pip-preview/Cargo.toml@@ -2,6 +2,7 @@name = "pip-preview"version.workspace = trueedition.workspace = true+license.workspace = true[dependencies]serde_json = { workspace = true }diff --git a/libs/cua-driver/rust/crates/platform-linux/Cargo.toml b/libs/cua-driver/rust/crates/platform-linux/Cargo.tomlindex b9d9805759..e953271c8b 100644--- a/libs/cua-driver/rust/crates/platform-linux/Cargo.toml+++ b/libs/cua-driver/rust/crates/platform-linux/Cargo.toml@@ -2,6 +2,7 @@name = "platform-linux"version.workspace = trueedition.workspace = true+license.workspace = true[dependencies]tokio = { workspace = true }diff --git a/libs/cua-driver/rust/crates/platform-macos/Cargo.toml b/libs/cua-driver/rust/crates/platform-macos/Cargo.tomlindex d7f4d4f7c3..8d429484aa 100644--- a/libs/cua-driver/rust/crates/platform-macos/Cargo.toml+++ b/libs/cua-driver/rust/crates/platform-macos/Cargo.toml@@ -2,6 +2,7 @@name = "platform-macos"version.workspace = trueedition.workspace = true+license.workspace = true[dependencies]tokio = { workspace = true }diff --git a/libs/cua-driver/rust/crates/platform-windows/Cargo.toml b/libs/cua-driver/rust/crates/platform-windows/Cargo.tomlindex 935d1dc93c..1d2a2ae148 100644--- a/libs/cua-driver/rust/crates/platform-windows/Cargo.toml+++ b/libs/cua-driver/rust/crates/platform-windows/Cargo.toml@@ -2,6 +2,7 @@name = "platform-windows"version.workspace = trueedition.workspace = true+license.workspace = true[dependencies]tokio = { workspace = true }diff --git a/libs/python/agent/pyproject.toml b/libs/python/agent/pyproject.tomlindex f73d91bb74..2ea25668b6 100644--- a/libs/python/agent/pyproject.toml+++ b/libs/python/agent/pyproject.toml@@ -7,6 +7,7 @@ name = "cua-agent"version = "0.8.4"description = "Cua (Computer Use) Agent for AI-driven computer interaction"readme = "README.md"+license = { text = "MIT" }authors = [{ name = "TryCua", email = "[email protected]" }]diff --git a/libs/python/bench-ui/pyproject.toml b/libs/python/bench-ui/pyproject.tomlindex f63f1bb96b..78758cef45 100644--- a/libs/python/bench-ui/pyproject.toml+++ b/libs/python/bench-ui/pyproject.toml@@ -7,6 +7,7 @@ name = "cua-bench-ui"version = "0.7.0"description = "Lightweight webUI window controller for Cua bench using pywebview"readme = "README.md"+license = { text = "MIT" }authors = [{ name = "TryCua", email = "[email protected]" }]diff --git a/libs/python/computer/pyproject.toml b/libs/python/computer/pyproject.tomlindex f32ba4d36b..78ab726fc2 100644--- a/libs/python/computer/pyproject.toml+++ b/libs/python/computer/pyproject.toml@@ -7,6 +7,7 @@ name = "cua-computer"version = "0.5.19"description = "Computer-Use Interface (CUI) framework powering Cua"readme = "README.md"+license = { text = "MIT" }authors = [{ name = "TryCua", email = "[email protected]" }]diff --git a/libs/python/core/pyproject.toml b/libs/python/core/pyproject.tomlindex 8b5b59f830..41cdb1a3f5 100644--- a/libs/python/core/pyproject.toml+++ b/libs/python/core/pyproject.toml@@ -7,6 +7,7 @@ name = "cua-core"version = "0.3.1"description = "Core functionality for Cua including telemetry and shared utilities"readme = "README.md"+license = { text = "MIT" }authors = [{ name = "TryCua", email = "[email protected]" }]diff --git a/libs/python/cua-sandbox-apps/pyproject.toml b/libs/python/cua-sandbox-apps/pyproject.tomlindex 5bbb91f69c..1af0270003 100644--- a/libs/python/cua-sandbox-apps/pyproject.toml+++ b/libs/python/cua-sandbox-apps/pyproject.toml@@ -5,6 +5,7 @@ description = "Universal app catalog and installer pipeline for CUA sandboxesrequires-python = ">=3.11,<3.14"authors = [{ name = "TryCua", email = "[email protected]" }]readme = "README.md"+license = "MIT"dependencies = ["claude-agent-sdk>=0.1.0",diff --git a/libs/python/mcp-server/pyproject.toml b/libs/python/mcp-server/pyproject.tomlindex 44cc7a6b94..3661d3f33d 100644--- a/libs/python/mcp-server/pyproject.toml+++ b/libs/python/mcp-server/pyproject.toml@@ -6,6 +6,7 @@ build-backend = "pdm.backend"name = "cua-mcp-server"description = "MCP Server for Computer-Use Agent (Cua)"readme = "README.md"+license = { text = "MIT" }requires-python = ">=3.12,<3.14"version = "0.1.16"authors = [diff --git a/scripts/check-license-direction.py b/scripts/check-license-direction.pynew file mode 100755index 0000000000..7ed3310508--- /dev/null+++ b/scripts/check-license-direction.py@@ -0,0 +1,904 @@+#!/usr/bin/env python3+"""Check that MIT packages only depend on permissively licensed internal packages.++The script discovers the packages in this monorepo (Cargo crates, npm packages,+and Python projects), reads each package's declared licence, and follows every+internal dependency edge: a Cargo path or workspace dependency, a pnpm+``workspace:`` (or ``file:``/``link:``) dependency, or a uv path or workspace+source. When an MIT package depends on an internal package whose licence is not+in the allow-list, the edge is reported as a violation.++A package's licence comes from its metadata (Cargo ``license``/``license-file``,+npm ``license``, pyproject ``project.license``). When no field is set, the+nearest LICENSE file up the tree is used and the package is reported as having+no declared licence.++Exit status: 0 when clean, 1 on violations. Packages without a declared licence+are warnings unless ``--strict`` is passed. Development-only edges (Cargo+dev-dependencies, npm devDependencies, dependency groups) are skipped unless+``--include-dev`` is passed, because they are not shipped with the package.++Python 3.9 compatible and standard library only.++Usage:+ python3 scripts/check-license-direction.py [--strict] [--include-dev] [--verbose]+"""++from __future__ import annotations++import argparse+import fnmatch+import json+import os+import re+import subprocess+import sys+from dataclasses import dataclass, field+from typing import Any, Dict, Iterable, List, Optional, Tuple++ALLOWED = {"MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC", "0BSD", "Unlicense"}++MANIFESTS = ("Cargo.toml", "package.json", "pyproject.toml")+SKIP_DIRS = {"node_modules", ".git", "target", ".venv", "venv", "__pycache__", "dist", "build"}+LICENSE_FILE_RE = re.compile(r"^(LICEN[CS]E|COPYING)([.-].*)?$", re.IGNORECASE)++# Well-known SPDX identifiers, keyed by lower case, so declared values can be+# normalised without guessing.+KNOWN_SPDX = [+ "0BSD",+ "AGPL-3.0",+ "AGPL-3.0-only",+ "AGPL-3.0-or-later",+ "Apache-2.0",+ "BSD-2-Clause",+ "BSD-3-Clause",+ "BSL-1.0",+ "BUSL-1.1",+ "CC0-1.0",+ "GPL-2.0-only",+ "GPL-2.0-or-later",+ "GPL-3.0-only",+ "GPL-3.0-or-later",+ "ISC",+ "LGPL-2.1-only",+ "LGPL-2.1-or-later",+ "LGPL-3.0-only",+ "LGPL-3.0-or-later",+ "MIT",+ "MPL-2.0",+ "Unlicense",+ "UNLICENSED",+ "Zlib",+]+SPDX_BY_LOWER = {s.lower(): s for s in KNOWN_SPDX}+ALIASES = {+ "mit license": "MIT",+ "the mit license": "MIT",+ "apache 2.0": "Apache-2.0",+ "apache-2": "Apache-2.0",+ "apache license 2.0": "Apache-2.0",+ "apache license, version 2.0": "Apache-2.0",+ "apache software license": "Apache-2.0",+ "bsd-3": "BSD-3-Clause",+ "bsd-2": "BSD-2-Clause",+}+++# --------------------------------------------------------------------------+# TOML: use tomllib (3.11+) when available, otherwise a small reader that+# covers the subset used by Cargo.toml and pyproject.toml files.+# --------------------------------------------------------------------------++try: # pragma: no cover - depends on interpreter version+ import tomllib as _tomllib # type: ignore[import-not-found]+except ImportError: # pragma: no cover+ _tomllib = None+++class _TomlReader:+ def __init__(self, text: str) -> None:+ self.s = text+ self.i = 0+ self.n = len(text)++ def error(self, msg: str) -> ValueError:+ line = self.s.count("\n", 0, self.i) + 1+ return ValueError("TOML parse error at line %d: %s" % (line, msg))++ def skip_ws(self, newlines: bool = False) -> None:+ while self.i < self.n:+ c = self.s[self.i]+ if c in " \t\r" or (newlines and c == "\n"):+ self.i += 1+ elif c == "#":+ while self.i < self.n and self.s[self.i] != "\n":+ self.i += 1+ else:+ break++ def parse(self) -> Dict[str, Any]:+ root: Dict[str, Any] = {}+ current = root+ while True:+ self.skip_ws(newlines=True)+ if self.i >= self.n:+ return root+ if self.s.startswith("[[", self.i):+ self.i += 2+ keys = self.key_path("]]")+ self.i += 2+ parent = self.descend(root, keys[:-1])+ arr = parent.setdefault(keys[-1], [])+ if not isinstance(arr, list):+ raise self.error("array of tables conflicts with key")+ current = {}+ arr.append(current)+ elif self.s[self.i] == "[":+ self.i += 1+ keys = self.key_path("]")+ self.i += 1+ current = self.descend(root, keys)+ else:+ keys = self.key_path("=")+ self.i += 1+ self.skip_ws()+ value = self.value()+ target = self.descend(current, keys[:-1])+ target[keys[-1]] = value+ self.skip_ws()+ if self.i < self.n and self.s[self.i] != "\n":+ raise self.error("expected end of line")++ def descend(self, table: Dict[str, Any], keys: List[str]) -> Dict[str, Any]:+ for k in keys:+ nxt = table.setdefault(k, {})+ if isinstance(nxt, list):+ nxt = nxt[-1]+ if not isinstance(nxt, dict):+ raise self.error("key %r is not a table" % k)+ table = nxt+ return table++ def key_path(self, terminator: str) -> List[str]:+ keys = []+ while True:+ self.skip_ws()+ c = self.s[self.i] if self.i < self.n else ""+ if c == '"':+ keys.append(self.basic_string())+ elif c == "'":+ keys.append(self.literal_string())+ else:+ m = re.compile(r"[A-Za-z0-9_-]+").match(self.s, self.i)+ if not m:+ raise self.error("invalid key")+ keys.append(m.group(0))+ self.i = m.end()+ self.skip_ws()+ if self.s.startswith(terminator, self.i):+ return keys+ if self.i < self.n and self.s[self.i] == ".":+ self.i += 1+ continue+ raise self.error("expected %r" % terminator)++ def basic_string(self) -> str:+ if self.s.startswith('"""', self.i):+ end = self.s.find('"""', self.i + 3)+ while end != -1 and self.s[end - 1] == "\\":+ end = self.s.find('"""', end + 1)+ if end == -1:+ raise self.error("unterminated string")+ raw = self.s[self.i + 3 : end]+ self.i = end + 3+ return self.unescape(raw.lstrip("\n"))+ self.i += 1+ out = []+ while self.i < self.n:+ c = self.s[self.i]+ if c == "\\":+ out.append(self.s[self.i : self.i + 2])+ self.i += 2+ continue+ if c == '"':+ self.i += 1+ return self.unescape("".join(out))+ if c == "\n":+ break+ out.append(c)+ self.i += 1+ raise self.error("unterminated string")++ @staticmethod+ def unescape(raw: str) -> str:+ try:+ return json.loads('"%s"' % raw.replace("\n", "\\n").replace("\t", "\\t"))+ except ValueError:+ return raw++ def literal_string(self) -> str:+ if self.s.startswith("'''", self.i):+ end = self.s.find("'''", self.i + 3)+ if end == -1:+ raise self.error("unterminated string")+ raw = self.s[self.i + 3 : end]+ self.i = end + 3+ return raw.lstrip("\n")+ end = self.s.find("'", self.i + 1)+ if end == -1:+ raise self.error("unterminated string")+ raw = self.s[self.i + 1 : end]+ self.i = end + 1+ return raw++ def value(self) -> Any:+ c = self.s[self.i] if self.i < self.n else ""+ if c == '"':+ return self.basic_string()+ if c == "'":+ return self.literal_string()+ if c == "[":+ self.i += 1+ items = []+ while True:+ self.skip_ws(newlines=True)+ if self.s[self.i] == "]":+ self.i += 1+ return items+ items.append(self.value())+ self.skip_ws(newlines=True)+ if self.s[self.i] == ",":+ self.i += 1+ if c == "{":+ self.i += 1+ table: Dict[str, Any] = {}+ while True:+ self.skip_ws()+ if self.s[self.i] == "}":+ self.i += 1+ return table+ keys = self.key_path("=")+ self.i += 1+ self.skip_ws()+ self.descend(table, keys[:-1])[keys[-1]] = self.value()+ self.skip_ws()+ if self.s[self.i] == ",":+ self.i += 1+ m = re.compile(r"[^\s,\]}#]+").match(self.s, self.i)+ if not m:+ raise self.error("invalid value")+ self.i = m.end()+ token = m.group(0)+ if token == "true":+ return True+ if token == "false":+ return False+ try:+ return int(token.replace("_", ""), 0)+ except ValueError:+ try:+ return float(token.replace("_", ""))+ except ValueError:+ return token # dates and times are kept as text+++def load_toml(path: str) -> Dict[str, Any]:+ with open(path, "rb") as fh:+ data = fh.read()+ if _tomllib is not None:+ return _tomllib.loads(data.decode("utf-8"))+ return _TomlReader(data.decode("utf-8")).parse()+++# --------------------------------------------------------------------------+# Licences+# --------------------------------------------------------------------------+++def detect_license_text(path: str) -> Optional[str]:+ """Return the SPDX identifier a licence file's text states, if recognisable."""+ try:+ with open(path, encoding="utf-8", errors="replace") as fh:+ text = " ".join(fh.read().split())+ except OSError:+ return None+ low = text.lower()+ if "gnu affero general public license" in low and "version 3" in low:+ return "AGPL-3.0"+ if "gnu lesser general public license" in low:+ return "LGPL-3.0" if "version 3" in low else "LGPL-2.1"+ if "gnu general public license" in low:+ return "GPL-3.0" if "version 3" in low else "GPL-2.0"+ if "mozilla public license version 2.0" in low:+ return "MPL-2.0"+ if "business source license" in low:+ return "BUSL-1.1"+ if "apache license" in low and "version 2.0" in low:+ return "Apache-2.0"+ if "permission is hereby granted, free of charge, to any person obtaining a copy" in low:+ return "MIT"+ if "this is free and unencumbered software released into the public domain" in low:+ return "Unlicense"+ if "permission to use, copy, modify, and/or distribute this software for any purpose" in low:+ return "ISC" if "provided that the above copyright notice" in low else "0BSD"+ if "redistribution and use in source and binary forms" in low:+ return "BSD-3-Clause" if "neither the name" in low else "BSD-2-Clause"+ return None+++def normalise_license(value: str) -> str:+ """Map a declared licence string to SPDX where the mapping is unambiguous."""+ v = value.strip()+ low = v.lower()+ if low in SPDX_BY_LOWER:+ return SPDX_BY_LOWER[low]+ if low in ALIASES:+ return ALIASES[low]++ def repl(m: "re.Match[str]") -> str:+ return SPDX_BY_LOWER.get(m.group(0).lower(), m.group(0))++ return re.sub(r"[A-Za-z0-9.+-]+", repl, v)+++def _tokens(expr: str) -> List[str]:+ return re.findall(r"\(|\)|[^\s()]+", expr)+++def _parse_or(toks: List[str], pos: int) -> Tuple[List[List[str]], int]:+ """Parse an SPDX expression into disjunctive normal form: [[ids ANDed], ...]."""+ left, pos = _parse_and(toks, pos)+ while pos < len(toks) and toks[pos].upper() == "OR":+ right, pos = _parse_and(toks, pos + 1)+ left = left + right+ return left, pos+++def _parse_and(toks: List[str], pos: int) -> Tuple[List[List[str]], int]:+ left, pos = _parse_atom(toks, pos)+ while pos < len(toks) and toks[pos].upper() == "AND":+ right, pos = _parse_atom(toks, pos + 1)+ left = [a + b for a in left for b in right]+ return left, pos+++def _parse_atom(toks: List[str], pos: int) -> Tuple[List[List[str]], int]:+ if pos >= len(toks):+ return [[]], pos+ if toks[pos] == "(":+ inner, pos = _parse_or(toks, pos + 1)+ if pos < len(toks) and toks[pos] == ")":+ pos += 1+ return inner, pos+ ident = toks[pos].rstrip("+")+ pos += 1+ if pos < len(toks) and toks[pos].upper() == "WITH":+ pos += 2 # a licence exception does not change the base licence+ return [[ident]], pos+++def license_options(expr: Optional[str]) -> List[List[str]]:+ if not expr:+ return []+ try:+ dnf, _ = _parse_or(_tokens(normalise_license(expr)), 0)+ except IndexError:+ return [[expr]]+ return [opt for opt in dnf if opt]+++def is_mit(expr: Optional[str]) -> bool:+ return any("MIT" in opt for opt in license_options(expr))+++def is_allowed(expr: Optional[str]) -> bool:+ return any(all(i in ALLOWED for i in opt) for opt in license_options(expr))+++# --------------------------------------------------------------------------+# Packages+# --------------------------------------------------------------------------+++@dataclass+class Package:+ ecosystem: str+ name: str+ directory: str # relative to the repository root, "." for the root+ manifest: Dict[str, Any]+ declared: Optional[str] = None+ declared_from: str = ""+ license: Optional[str] = None+ license_from: str = ""+ raw_deps: List[Tuple[str, str, Any]] = field(default_factory=list)++ @property+ def label(self) -> str:+ return "%s (%s)" % (self.name, self.directory)+++@dataclass+class Edge:+ source: Package+ target: Package+ kind: str+++class Repo:+ def __init__(self, root: str) -> None:+ self.root = os.path.abspath(root)+ self.files = self._list_files()+ self.dirs_with_license: Dict[str, str] = {}+ for rel in self.files:+ d, base = os.path.split(rel)+ if LICENSE_FILE_RE.match(base):+ self.dirs_with_license.setdefault(d or ".", rel)+ self.packages: List[Package] = []+ self.warnings: List[str] = []+ self.toml_cache: Dict[str, Optional[Dict[str, Any]]] = {}++ def _list_files(self) -> List[str]:+ try:+ out = subprocess.run(+ ["git", "ls-files", "-z", "--cached", "--others", "--exclude-standard"],+ cwd=self.root,+ check=True,+ stdout=subprocess.PIPE,+ stderr=subprocess.DEVNULL,+ ).stdout.decode("utf-8")+ files = [f for f in out.split("\0") if f]+ except (OSError, subprocess.CalledProcessError):+ files = []+ for dirpath, dirnames, filenames in os.walk(self.root):+ dirnames[:] = [d for d in dirnames if d not in SKIP_DIRS]+ for f in filenames:+ files.append(os.path.relpath(os.path.join(dirpath, f), self.root))+ return sorted(+ f.replace(os.sep, "/")+ for f in files+ if not SKIP_DIRS.intersection(f.split("/")[:-1])+ and os.path.exists(os.path.join(self.root, f))+ )++ def rel(self, path: str) -> str:+ r = os.path.relpath(os.path.normpath(path), self.root).replace(os.sep, "/")+ return "." if r == "" else r++ def abs(self, rel: str) -> str:+ return os.path.normpath(os.path.join(self.root, rel))++ def toml(self, rel_path: str) -> Optional[Dict[str, Any]]:+ if rel_path not in self.toml_cache:+ try:+ self.toml_cache[rel_path] = load_toml(self.abs(rel_path))+ except (OSError, ValueError) as exc:+ self.warnings.append("could not parse %s: %s" % (rel_path, exc))+ self.toml_cache[rel_path] = None+ return self.toml_cache[rel_path]++ def nearest_license_file(self, directory: str) -> Optional[str]:+ d = directory+ while True:+ if d in self.dirs_with_license:+ return self.dirs_with_license[d]+ if d == ".":+ return None+ d = os.path.dirname(d) or "."++ def ancestors_with(self, directory: str, filename: str) -> Iterable[str]:+ d = directory+ while True:+ parent = os.path.dirname(d) or "." if d != "." else None+ if parent is None:+ return+ rel = filename if parent == "." else parent + "/" + filename+ if rel in self.files:+ yield parent+ d = parent++ # ---- discovery ----------------------------------------------------++ def discover(self) -> None:+ for rel in self.files:+ base = rel.rsplit("/", 1)[-1]+ if base not in MANIFESTS:+ continue+ directory = os.path.dirname(rel) or "."+ if base == "Cargo.toml":+ self._add_cargo(rel, directory)+ elif base == "package.json":+ self._add_npm(rel, directory)+ else:+ self._add_python(rel, directory)+ for pkg in self.packages:+ if pkg.declared is None:+ lic = self.nearest_license_file(pkg.directory)+ if lic:+ pkg.license = detect_license_text(self.abs(lic))+ pkg.license_from = lic+ else:+ pkg.license = normalise_license(pkg.declared)+ pkg.license_from = pkg.declared_from+ own = self.dirs_with_license.get(pkg.directory)+ own_text = detect_license_text(self.abs(own)) if own else None+ if own_text and not any(+ i.split("-only")[0].split("-or-later")[0] == own_text+ for opt in license_options(pkg.license)+ for i in opt+ ):+ self.warnings.append(+ "%s %s declares %s but %s reads as %s"+ % (pkg.ecosystem, pkg.label, pkg.license, own, own_text)+ )++ def _add_cargo(self, rel: str, directory: str) -> None:+ data = self.toml(rel)+ if not data or "package" not in data:+ return+ pkg_table = data["package"]+ pkg = Package("cargo", str(pkg_table.get("name", directory)), directory, data)+ lic = pkg_table.get("license")+ lic_file = pkg_table.get("license-file")+ if isinstance(lic, dict) and lic.get("workspace"):+ ws = self._cargo_workspace(directory)+ if ws:+ ws_pkg = (self.toml(self._join(ws, "Cargo.toml")) or {}).get("workspace", {})+ lic = ws_pkg.get("package", {}).get("license")+ lic_file = lic_file or ws_pkg.get("package", {}).get("license-file")+ pkg.declared_from = "%s [workspace.package] license" % self._join(ws, "Cargo.toml")+ if isinstance(lic, str):+ pkg.declared = lic+ pkg.declared_from = pkg.declared_from or "%s license" % rel+ elif isinstance(lic_file, str):+ detected = detect_license_text(self.abs(self._join(directory, lic_file)))+ if detected:+ pkg.declared = detected+ pkg.declared_from = "%s license-file" % rel+ for kind, table in self._cargo_dep_tables(data):+ for name, spec in table.items():+ pkg.raw_deps.append((kind, name, spec))+ self.packages.append(pkg)++ @staticmethod+ def _cargo_dep_tables(data: Dict[str, Any]) -> Iterable[Tuple[str, Dict[str, Any]]]:+ kinds = (+ ("dependencies", "runtime"),+ ("build-dependencies", "build"),+ ("dev-dependencies", "dev"),+ )+ for key, kind in kinds:+ if isinstance(data.get(key), dict):+ yield kind, data[key]+ for target in (data.get("target") or {}).values():+ if isinstance(target, dict):+ for key, kind in kinds:+ if isinstance(target.get(key), dict):+ yield kind, target[key]++ def _cargo_workspace(self, directory: str) -> Optional[str]:+ own = self.toml(self._join(directory, "Cargo.toml")) or {}+ if "workspace" in own:+ return directory+ explicit = (own.get("package") or {}).get("workspace")+ if isinstance(explicit, str):+ return self.rel(self.abs(self._join(directory, explicit)))+ for parent in self.ancestors_with(directory, "Cargo.toml"):+ if "workspace" in (self.toml(self._join(parent, "Cargo.toml")) or {}):+ return parent+ return None++ def _add_npm(self, rel: str, directory: str) -> None:+ try:+ with open(self.abs(rel), encoding="utf-8") as fh:+ data = json.load(fh)+ except (OSError, ValueError) as exc:+ self.warnings.append("could not parse %s: %s" % (rel, exc))+ return+ if not isinstance(data, dict) or not data.get("name"):+ return+ pkg = Package("npm", str(data["name"]), directory, data)+ lic = data.get("license")+ if isinstance(lic, dict):+ lic = lic.get("type")+ if not lic and isinstance(data.get("licenses"), list):+ types = [+ x.get("type") for x in data["licenses"] if isinstance(x, dict) and x.get("type")+ ]+ lic = " OR ".join(types) if types else None+ if isinstance(lic, str) and lic:+ if lic.upper().startswith("SEE LICENSE IN "):+ detected = detect_license_text(self.abs(self._join(directory, lic[15:].strip())))+ lic = detected+ if lic:+ pkg.declared = lic+ pkg.declared_from = "%s license" % rel+ kinds = (+ ("dependencies", "runtime"),+ ("optionalDependencies", "optional"),+ ("peerDependencies", "peer"),+ ("devDependencies", "dev"),+ )+ for key, kind in kinds:+ for name, spec in (data.get(key) or {}).items():+ pkg.raw_deps.append((kind, name, spec))+ self.packages.append(pkg)++ def _add_python(self, rel: str, directory: str) -> None:+ data = self.toml(rel)+ if not data:+ return+ project = data.get("project") or {}+ poetry = ((data.get("tool") or {}).get("poetry")) or {}+ name = project.get("name") or poetry.get("name")+ if not name:+ return+ pkg = Package("python", str(name), directory, data)+ lic = project.get("license")+ if isinstance(lic, dict):+ if lic.get("text"):+ lic = str(lic["text"])+ elif lic.get("file"):+ lic = detect_license_text(self.abs(self._join(directory, str(lic["file"]))))+ else:+ lic = None+ if not lic and isinstance(poetry.get("license"), str):+ lic = poetry["license"]+ if isinstance(lic, str) and lic.strip():+ pkg.declared = lic.strip()+ pkg.declared_from = "%s project.license" % rel+ for req in project.get("dependencies") or []:+ pkg.raw_deps.append(("runtime", req, None))+ for extra, reqs in (project.get("optional-dependencies") or {}).items():+ for req in reqs or []:+ pkg.raw_deps.append(("optional[%s]" % extra, req, None))+ for group, reqs in (data.get("dependency-groups") or {}).items():+ for req in reqs or []:+ if isinstance(req, str):+ pkg.raw_deps.append(("dev[%s]" % group, req, None))+ for req in ((data.get("tool") or {}).get("uv") or {}).get("dev-dependencies") or []:+ pkg.raw_deps.append(("dev", req, None))+ self.packages.append(pkg)++ @staticmethod+ def _join(directory: str, rel: str) -> str:+ return rel if directory == "." else directory + "/" + rel++ # ---- edges ----------------------------------------------------------++ def edges(self) -> List[Edge]:+ by_dir = {(p.ecosystem, p.directory): p for p in self.packages}+ by_name: Dict[Tuple[str, str], Package] = {}+ for p in self.packages:+ key = (p.ecosystem, pep503(p.name) if p.ecosystem == "python" else p.name)+ by_name.setdefault(key, p)+ result: List[Edge] = []+ for pkg in self.packages:+ for kind, name, spec in pkg.raw_deps:+ target, where = None, None+ if pkg.ecosystem == "cargo":+ target, where = self._cargo_target(pkg, name, spec, by_dir)+ elif pkg.ecosystem == "npm":+ target, where = self._npm_target(pkg, name, spec, by_dir, by_name)+ else:+ target, where = self._python_target(pkg, name, by_dir, by_name)+ if where and target is None:+ self.warnings.append(+ "%s %s: internal dependency %r (%s) does not resolve to a package"+ % (pkg.ecosystem, pkg.label, name, where)+ )+ if target is not None and target is not pkg:+ result.append(Edge(pkg, target, kind))+ return result++ def _cargo_target(self, pkg, name, spec, by_dir):+ if not isinstance(spec, dict):+ return None, None+ base = pkg.directory+ if spec.get("workspace"):+ ws = self._cargo_workspace(pkg.directory)+ ws_deps = (+ ((self.toml(self._join(ws, "Cargo.toml")) or {}).get("workspace") or {}).get(+ "dependencies"+ )+ if ws+ else None+ )+ ws_spec = (ws_deps or {}).get(name)+ if not isinstance(ws_spec, dict) or "path" not in ws_spec:+ return None, None+ spec, base = ws_spec, ws+ if "path" not in spec:+ return None, None+ target_dir = self.rel(self.abs(self._join(base, str(spec["path"]))))+ return by_dir.get(("cargo", target_dir)), "path %s" % spec["path"]++ def _npm_target(self, pkg, name, spec, by_dir, by_name):+ if not isinstance(spec, str):+ return None, None+ if spec.startswith("workspace:"):+ alias = spec[len("workspace:") :]+ real = name+ if "@" in alias.lstrip("@") and not alias.startswith(("^", "~", "*")):+ real = alias.rsplit("@", 1)[0]+ return by_name.get(("npm", real)), spec+ for prefix in ("file:", "link:"):+ if spec.startswith(prefix):+ target_dir = self.rel(self.abs(self._join(pkg.directory, spec[len(prefix) :])))+ if not os.path.isdir(self.abs(target_dir)):+ return None, None # a tarball or an external path+ return by_dir.get(("npm", target_dir)), spec+ return None, None++ def _python_target(self, pkg, req, by_dir, by_name):+ m = re.match(r"\s*([A-Za-z0-9][A-Za-z0-9._-]*)", req)+ if not m:+ return None, None+ name = pep503(m.group(1))+ direct = re.search(r"@\s*file:(?://)?(\S+)", req)+ if direct:+ path = direct.group(1).replace("${PROJECT_ROOT}", self.abs(pkg.directory))+ target_dir = self.rel(+ path if os.path.isabs(path) else self.abs(self._join(pkg.directory, path))+ )+ return by_dir.get(("python", target_dir)), "file reference"+ for base, sources in self._uv_sources(pkg):+ src = sources.get(name)+ if isinstance(src, list):+ src = next((s for s in src if isinstance(s, dict)), None)+ if not isinstance(src, dict):+ continue+ if src.get("workspace"):+ return by_name.get(("python", name)), "uv workspace source"+ if "path" in src:+ target_dir = self.rel(self.abs(self._join(base, str(src["path"]))))+ return by_dir.get(("python", target_dir)), "uv path source %s" % src["path"]+ return None, None # git, url, or index source: external+ return None, None++ def _uv_sources(self, pkg: Package) -> Iterable[Tuple[str, Dict[str, Any]]]:+ """Yield (base directory, normalised uv sources) in precedence order."""++ def sources_of(data: Dict[str, Any]) -> Dict[str, Any]:+ raw = ((data.get("tool") or {}).get("uv") or {}).get("sources") or {}+ return {pep503(k): v for k, v in raw.items()}++ yield pkg.directory, sources_of(pkg.manifest)+ for parent in self.ancestors_with(pkg.directory, "pyproject.toml"):+ data = self.toml(self._join(parent, "pyproject.toml")) or {}+ ws = ((data.get("tool") or {}).get("uv") or {}).get("workspace")+ if not isinstance(ws, dict):+ continue+ member_rel = os.path.relpath(self.abs(pkg.directory), self.abs(parent)).replace(+ os.sep, "/"+ )+ members = ws.get("members") or []+ excluded = ws.get("exclude") or []+ if any(fnmatch.fnmatch(member_rel, g) for g in members) and not any(+ fnmatch.fnmatch(member_rel, g) for g in excluded+ ):+ yield parent, sources_of(data)+ return # uv uses the nearest workspace root only+++def pep503(name: str) -> str:+ return re.sub(r"[-_.]+", "-", name).lower()+++# --------------------------------------------------------------------------+# Reporting+# --------------------------------------------------------------------------+++def print_table(headers: List[str], rows: List[List[str]]) -> None:+ widths = [max(len(h), *(len(r[i]) for r in rows)) for i, h in enumerate(headers)]+ line = " ".join(h.ljust(w) for h, w in zip(headers, widths))+ print(line)+ print(" ".join("-" * w for w in widths))+ for r in rows:+ print(" ".join(c.ljust(w) for c, w in zip(r, widths)))+++def main(argv: Optional[List[str]] = None) -> int:+ default_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))+ parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])+ parser.add_argument(+ "--root", default=default_root, help="repository root (default: %(default)s)"+ )+ parser.add_argument(+ "--strict", action="store_true", help="fail when a package has no declared licence"+ )+ parser.add_argument(+ "--include-dev", action="store_true", help="also check development-only edges"+ )+ parser.add_argument(+ "--verbose", action="store_true", help="list every package and internal edge"+ )+ args = parser.parse_args(argv)++ repo = Repo(args.root)+ repo.discover()+ all_edges = repo.edges()+ edges = [e for e in all_edges if args.include_dev or not e.kind.startswith("dev")]++ counts: Dict[str, int] = {}+ for p in repo.packages:+ counts[p.ecosystem] = counts.get(p.ecosystem, 0) + 1+ print(+ "Found %d packages (%s) and %d internal dependency edges (%d checked%s)."+ % (+ len(repo.packages),+ ", ".join("%s: %d" % kv for kv in sorted(counts.items())),+ len(all_edges),+ len(edges),+ "" if args.include_dev else "; development-only edges skipped",+ )+ )++ if args.verbose:+ print("\nPackages:")+ print_table(+ ["Ecosystem", "Package", "Licence", "Source"],+ [+ [p.ecosystem, p.label, p.license or "unknown", p.license_from or "-"]+ for p in repo.packages+ ],+ )+ if all_edges:+ print("\nInternal edges:")+ print_table(+ ["Ecosystem", "Package", "Depends on", "Kind"],+ [[e.source.ecosystem, e.source.label, e.target.label, e.kind] for e in all_edges],+ )++ violations = [e for e in edges if is_mit(e.source.license) and not is_allowed(e.target.license)]+ undeclared = [p for p in repo.packages if p.declared is None]++ for w in repo.warnings:+ print("warning: %s" % w)++ if undeclared:+ label = "error" if args.strict else "warning"+ print(+ "\n%s: %d packages have no declared licence (falling back to the nearest LICENSE file):"+ % (label, len(undeclared))+ )+ print_table(+ ["Ecosystem", "Package", "Fallback licence", "From"],+ [+ [p.ecosystem, p.label, p.license or "unknown", p.license_from or "none"]+ for p in undeclared+ ],+ )++ if violations:+ print(+ "\nerror: %d MIT packages depend on internal packages outside the allow-list:"+ % len(violations)+ )+ print_table(+ ["Ecosystem", "Package", "Licence", "Depends on", "Licence", "Kind"],+ [+ [+ e.source.ecosystem,+ e.source.label,+ e.source.license or "unknown",+ e.target.label,+ e.target.license or "unknown",+ e.kind,+ ]+ for e in violations+ ],+ )+ print(+ "\nAllowed licences for dependencies of MIT packages: %s" % ", ".join(sorted(ALLOWED))+ )+ else:+ print("\nNo licence direction violations.")++ if violations or (args.strict and undeclared):+ return 1+ return 0+++if __name__ == "__main__":+ sys.exit(main())