quoll-cli 0.2.0__py3-none-any.whl

quoll/languages/node/ci.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence
+
+from quoll.ci.steps import ROOT, Cache, Item, Step, step
+from quoll.languages.base import SCRIPT_PREFIX, CISteps, TestReports
+from quoll.platforms.github.actions import ACTIONS
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+    from quoll.languages.base import Detection
+
+_EXEC = {"npm": "npx", "pnpm": "pnpm exec", "yarn": "yarn", "yarn-classic": "yarn", "bun": "bunx"}
+
+# Files (and directories) quoll writes in a Node project, kept out of its formatter (as in .prettierignore).
+# The Helm chart's templates are YAML with Go templates in it: no YAML formatter can read them.
+QUOLL_FILES = ("compose.yaml", ".github/", ".gitlab-ci.yml", ".gitlab/", "chart/")
+_NOT_QUOLL_FILES = " ".join(f"'!{p}**'" if p.endswith("/") else f"'!{p}'" for p in QUOLL_FILES)
+
+# tool: (step name, command)
+_LINT = {
+    "eslint": ("ESLint", "eslint ."),
+    # quoll's files (compose.yaml, the pipelines) follow their own format, not the project's Prettier config.
+    "prettier": ("Prettier", f"prettier --check . {_NOT_QUOLL_FILES}"),
+    "biome": ("Biome", "biome ci ."),
+    "tsc": ("Type check", "tsc --noEmit"),
+}
+
+_COVERAGE_RUNNERS = ("vitest", "jest", "bun")
+_BUILD_OUTPUT = {"nextjs": [], "nuxt": [".output/"], "sveltekit": ["build/"]}
+_JEST_JUNIT = "/tmp/quoll-jest-junit"
+_JEST_JUNIT_INSTALL = f"npm install --no-save --no-package-lock --prefix {_JEST_JUNIT} jest-junit@16"
+
+LOCKFILES = {
+    "npm": "package-lock.json",
+    "pnpm": "pnpm-lock.yaml",
+    "yarn": "yarn.lock",
+    "yarn-classic": "yarn.lock",
+    "bun": "bun.lock",
+}
+
+# Package manager caches, kept in the project by container jobs: (directory, variable pointing the tool at it).
+_CACHE = {
+    "npm": (".npm", "npm_config_cache"),
+    "pnpm": (".pnpm-store", "npm_config_store_dir"),
+    "yarn": (".yarn/cache", "YARN_CACHE_FOLDER"),
+    "yarn-classic": (".yarn-cache", "YARN_CACHE_FOLDER"),
+}
+
+_AUDIT = {
+    "npm": "npm audit --omit=dev --audit-level=high",
+    "pnpm": "pnpm audit --prod --audit-level high",
+    "yarn": "yarn npm audit --environment production --severity high",
+    "yarn-classic": "yarn audit --groups dependencies --level high",
+    "bun": "bun audit --prod --audit-level=high",
+}
+
+
+def run_script(package_manager: str, script: str) -> str:
+    if package_manager.startswith("yarn"):
+        return f"yarn run {script}"
+    return f"{package_manager} run {script}"
+
+
+class NodeCI(CISteps):
+    # npm / pnpm / yarn / bun audit read the lockfile, installing nothing.
+    audit_uses_cache = False
+    version_key = "node-version"
+    codeql_language = "javascript-typescript"
+
+    def setup(self, cfg: CIConfig, version: Optional[str]) -> List[Item]:
+        pm = cfg.package_manager
+        pinned = cfg.package_manager_version
+        steps = []
+        if pm == "pnpm":
+            with_pnpm = {"version": pinned} if pinned else {}
+            if cfg.directory != ".":
+                with_pnpm["package_json_file"] = cfg.path("package.json")
+            steps.append(step("Set up pnpm", uses=ACTIONS["setup-pnpm"], with_=with_pnpm))
+        elif pm == "yarn":
+            # Yarn Berry is provided by corepack; it must be enabled before setup-node resolves the cache.
+            steps.append(step("Enable corepack", run="corepack enable"))
+        elif pm == "bun":
+            steps.append(
+                step("Set up Bun", uses=ACTIONS["setup-bun"], with_={"bun-version": pinned} if pinned else None)
+            )
+
+        with_: Dict[str, Any] = (
+            {"node-version": version} if version else {"node-version-file": cfg.path(cfg.version_file)}
+        )
+        if cfg.cache and pm != "bun":
+            with_["cache"] = "yarn" if pm.startswith("yarn") else pm
+            if cfg.directory != ".":
+                with_["cache-dependency-path"] = cfg.path(LOCKFILES[pm])
+        steps.append(step("Set up Node.js", uses=ACTIONS["setup-node"], with_=with_))
+        return steps
+
+    def image(self, cfg: CIConfig, version: str) -> str:
+        if cfg.package_manager == "bun":
+            return f"oven/bun:{cfg.package_manager_version or '1'}"
+        return f"node:{'lts' if version.startswith('lts') else version}"
+
+    def image_setup(self, cfg: CIConfig) -> List[Step]:
+        pm = cfg.package_manager
+        if pm not in ("pnpm", "yarn"):
+            return []
+        # Corepack provides the version pinned in package.json "packageManager"; Node 25+ no longer bundles it.
+        pinned = cfg.package_manager_version
+        run = "npm install --global corepack@latest\ncorepack enable"
+        if pinned:
+            run += f"\ncorepack install --global {pm}@{pinned}"
+        return [step(f"Set up {pm}", run=run, env={"COREPACK_ENABLE_DOWNLOAD_PROMPT": "0"})]
+
+    def cache(self, cfg: CIConfig) -> Optional[Cache]:
+        # Bun's cache holds unpacked sources that linters would scan: it installs fast enough without.
+        if not cfg.cache or cfg.package_manager not in _CACHE:
+            return None
+        directory, variable = _CACHE[cfg.package_manager]
+        env = {variable: f"{ROOT}/{directory}"}
+        if cfg.package_manager == "yarn":
+            env["YARN_ENABLE_GLOBAL_CACHE"] = "false"
+        return Cache("node", (directory,), key_files=(LOCKFILES[cfg.package_manager],), env=env)
+
+    def install(self, cfg: CIConfig, packages: Sequence[str] = ()) -> List[Item]:
+        return [step("Install dependencies", run=cfg.install)]
+
+    def exec(self, cfg: CIConfig, command: str) -> str:
+        return f"{_EXEC[cfg.package_manager]} {command}"
+
+    def lint(self, cfg: CIConfig, tools: List[str]) -> List[Item]:
+        steps = self.install(cfg)
+        for tool in tools:
+            if tool.startswith(SCRIPT_PREFIX):
+                script = tool[len(SCRIPT_PREFIX):]
+                steps.append(step(f"Run {script}", run=run_script(cfg.package_manager, script)))
+            else:
+                name, cmd = _LINT[tool]
+                steps.append(step(name, run=self.exec(cfg, cmd)))
+        return steps
+
+    def test(self, cfg: CIConfig) -> List[Item]:
+        t = cfg.test
+        coverage = t.coverage
+        setup: List[Item] = []
+        env: Dict[str, str] = {}
+        if t.runner == "jest":
+            cmd = self.exec(cfg, "jest --ci")
+            if coverage:
+                cmd += f""" --coverage --coverageThreshold='{{"global":{{"lines":{t.coverage_threshold}}}}}'"""
+                if t.reports:
+                    cmd += " --coverageReporters=text --coverageReporters=lcov --coverageReporters=cobertura"
+            if t.reports:
+                # Jest has no JUnit output of its own: jest-junit, installed outside the project.
+                setup.append(step("JUnit reporter for Jest", run=_JEST_JUNIT_INSTALL))
+                cmd += f" --reporters=default --reporters={_JEST_JUNIT}/node_modules/jest-junit"
+                env = {"JEST_JUNIT_OUTPUT_DIR": ".", "JEST_JUNIT_OUTPUT_NAME": "junit.xml"}
+        elif t.runner == "vitest":
+            cmd = self.exec(cfg, "vitest run")
+            if t.reports:
+                cmd += " --reporter=default --reporter=junit --outputFile.junit=junit.xml"
+            if coverage:
+                cmd += (
+                    " --coverage.enabled --coverage.reporter=text --coverage.reporter=lcov"
+                    + (" --coverage.reporter=cobertura" if t.reports else "")
+                    + f" --coverage.thresholds.lines={t.coverage_threshold}"
+                )
+        elif t.runner == "bun":
+            cmd = "bun test --coverage --coverage-reporter=lcov" if coverage else "bun test"
+            if t.reports:
+                cmd += " --reporter=junit --reporter-outfile=junit.xml"
+        else:
+            cmd = run_script(cfg.package_manager, t.runner[len(SCRIPT_PREFIX):])
+            coverage = False
+        name = "Tests" + (" with coverage" if coverage else "")
+        return [*self.install(cfg), *setup, step(name, run=cmd, env=env, secrets=t.env_secrets)]
+
+    def coverage_file(self, cfg: CIConfig) -> str:
+        return "coverage/lcov.info"
+
+    def reports(self, cfg: CIConfig) -> TestReports:
+        runner, coverage = cfg.test.runner, cfg.test.coverage
+        return TestReports(
+            junit="junit.xml" if runner in ("vitest", "bun", "jest") else "",
+            cobertura="coverage/cobertura-coverage.xml" if coverage and runner in ("vitest", "jest") else "",
+            # The "All files" row of the text coverage table.
+            coverage_regex=r"/All files\s*\|\s*(\d+(?:\.\d+)?)/" if coverage and runner in _COVERAGE_RUNNERS else "",
+        )
+
+    def audit(self, cfg: CIConfig) -> List[Item]:
+        return [step("Dependency vulnerability scan", run=_AUDIT[cfg.package_manager])]
+
+    def build(self, cfg: CIConfig) -> List[Item]:
+        return [*self.install(cfg), step("Build", run=cfg.build.command)]
+
+    def build_artifacts(self, det: Detection) -> List[str]:
+        # Vite, Angular, tsc, NestJS... build into dist/; Next.js' .next/ isn't something to ship as is.
+        return _BUILD_OUTPUT.get(det.framework or "", ["dist/"])
+
+    def dependabot_ecosystem(self, cfg: CIConfig) -> str:
+        return "bun" if cfg.package_manager == "bun" else "npm"

quoll/languages/node/detect.py

@@ -0,0 +1,164 @@
+from __future__ import annotations
+
+import re
+from typing import Dict, List
+
+from quoll.languages.base import SCRIPT_PREFIX, Detection
+from quoll.languages.node.ci import run_script
+from quoll.project import Project
+from quoll.services import detect_services
+
+# Used when the project doesn't say which version it targets.
+NODE_DEFAULT = "24"
+NODE_SUPPORTED = ("22", "24")
+PNPM_DEFAULT = "10"
+
+# Checked in order: the first lockfile found decides the package manager.
+_LOCKFILES = (
+    ("pnpm-lock.yaml", "pnpm"),
+    ("bun.lock", "bun"),
+    ("bun.lockb", "bun"),
+    ("yarn.lock", "yarn"),
+    ("package-lock.json", "npm"),
+)
+
+# (frozen install, plain install)
+_INSTALL = {
+    "npm": ("npm ci", "npm install"),
+    "pnpm": ("pnpm install --frozen-lockfile", "pnpm install"),
+    "yarn": ("yarn install --immutable", "yarn install"),
+    "yarn-classic": ("yarn install --frozen-lockfile", "yarn install"),
+    "bun": ("bun install --frozen-lockfile", "bun install"),
+}
+
+_NPM_PLACEHOLDER_TEST = "no test specified"
+
+# Client libraries revealing a backing service.
+_SERVICE_PACKAGES = {
+    "postgres": ("pg", "postgres", "pg-promise", "@vercel/postgres"),
+    "mysql": ("mysql2", "mysql"),
+    "redis": ("redis", "ioredis", "bullmq", "@upstash/redis"),
+    "mongodb": ("mongodb", "mongoose"),
+}
+# Prisma's datasource provider -> service.
+_PRISMA_PROVIDERS = {"postgresql": "pg", "mysql": "mysql2", "mongodb": "mongodb"}
+
+
+def detect(project: Project) -> Detection:
+    det = Detection()
+    pkg = package_json(project)
+    scripts = scripts_of(pkg)
+    deps = dependencies(pkg)
+
+    _package_manager(project, pkg.get("packageManager") or "", det)
+    det.install = _INSTALL[det.package_manager][0 if det.lockfile else 1]
+    if not det.lockfile:
+        det.cache = False
+        det.warnings.append(
+            "No lockfile found — CI installs will not be reproducible. "
+            "Commit your lockfile and run `quoll ci init` again."
+        )
+
+    _version(project, pkg, det)
+    det.lint_tools = _lint_tools(project, pkg, scripts, deps)
+    _test_runner(scripts, deps, det)
+    if "build" in scripts:
+        det.build_command = run_script(det.package_manager, "build")
+    det.services = detect_services([*deps, *_prisma_clients(project)], _SERVICE_PACKAGES)
+    return det
+
+
+def _prisma_clients(project: Project) -> List[str]:
+    """The client package matching prisma/schema.prisma's provider, so Prisma projects get their database."""
+    m = re.search(r'provider\s*=\s*"(\w+)"', project.read_text("prisma/schema.prisma").split("datasource", 1)[-1])
+    return [_PRISMA_PROVIDERS[m.group(1)]] if m and m.group(1) in _PRISMA_PROVIDERS else []
+
+
+def _package_manager(project: Project, declared: str, det: Detection) -> None:
+    for name, pm in _LOCKFILES:
+        if project.exists(name):
+            det.package_manager, det.lockfile = pm, name
+            break
+    else:
+        pm = declared.split("@")[0]
+        det.package_manager = pm if pm in ("pnpm", "yarn", "bun", "npm") else "npm"
+
+    if det.package_manager == "yarn":
+        major = re.match(r"yarn@(\d+)", declared)
+        classic = major.group(1) == "1" if major else not project.exists(".yarnrc.yml")
+        if classic:
+            det.package_manager = "yarn-classic"
+
+    if det.package_manager == "pnpm" and not declared.startswith("pnpm@"):
+        det.package_manager_version = PNPM_DEFAULT
+
+
+def _version(project: Project, pkg: dict, det: Detection) -> None:
+    for name in (".nvmrc", ".node-version"):
+        if project.exists(name):
+            det.version_file = name
+            raw = project.read_text(name).strip().lstrip("v")
+            det.version = raw.split(".")[0] if raw[:1].isdigit() else NODE_DEFAULT
+            break
+    else:
+        m = re.search(r"(\d+)", (pkg.get("engines") or {}).get("node", ""))
+        det.version = m.group(1) if m else NODE_DEFAULT
+    low = int(det.version) if det.version.isdigit() else 0
+    det.matrix_versions = [v for v in NODE_SUPPORTED if int(v) >= low] or [det.version]
+
+
+def _lint_tools(project: Project, pkg: dict, scripts: Dict[str, str], deps: dict) -> List[str]:
+    tools: List[str] = []
+    has_biome = "@biomejs/biome" in deps or project.glob_any("biome.json", "biome.jsonc")
+    if "lint" in scripts:
+        tools.append(f"{SCRIPT_PREFIX}lint")
+    elif has_biome:
+        tools.append("biome")
+    elif "eslint" in deps or project.glob_any("eslint.config.*", ".eslintrc*"):
+        tools.append("eslint")
+
+    if "format:check" in scripts:
+        tools.append(f"{SCRIPT_PREFIX}format:check")
+    elif not has_biome and (
+        "prettier" in deps or "prettier" in pkg or project.glob_any(".prettierrc*", "prettier.config.*")
+    ):
+        tools.append("prettier")
+
+    typecheck = next((s for s in ("typecheck", "type-check", "check-types") if s in scripts), None)
+    if typecheck:
+        tools.append(f"{SCRIPT_PREFIX}{typecheck}")
+    elif project.exists("tsconfig.json") and "typescript" in deps:
+        tools.append("tsc")
+    return tools
+
+
+def _test_runner(scripts: Dict[str, str], deps: dict, det: Detection) -> None:
+    test_script = scripts.get("test", "")
+    if "vitest" in deps:
+        det.test_runner = "vitest"
+        det.coverage = any(p in deps for p in ("@vitest/coverage-v8", "@vitest/coverage-istanbul"))
+        if not det.coverage:
+            det.warnings.append("vitest coverage needs @vitest/coverage-v8 — coverage is disabled until you add it.")
+    elif "jest" in deps:
+        det.test_runner = "jest"
+    elif det.package_manager == "bun" and (not test_script or "bun test" in test_script):
+        det.test_runner = "bun"
+    elif test_script and _NPM_PLACEHOLDER_TEST not in test_script:
+        det.test_runner = f"{SCRIPT_PREFIX}test"
+        det.coverage = False
+    else:
+        det.warnings.append("No test runner found (vitest, jest or a `test` script) — the test job is disabled.")
+
+
+def package_json(project: Project) -> dict:
+    pkg = project.read_json("package.json")
+    return pkg if isinstance(pkg, dict) else {}
+
+
+def dependencies(pkg: dict) -> Dict[str, str]:
+    """`dependencies` and `devDependencies`, merged."""
+    return {**(pkg.get("dependencies") or {}), **(pkg.get("devDependencies") or {})}
+
+
+def scripts_of(pkg: dict) -> Dict[str, str]:
+    return pkg.get("scripts") or {}

quoll/languages/node/docker.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from quoll.languages.base import Detection, DockerDefaults, DockerImage
+from quoll.languages.node.detect import dependencies, package_json, scripts_of
+from quoll.project import Project
+
+if TYPE_CHECKING:
+    from quoll.docker.config import DockerConfig
+
+PNPM_DEFAULT = "10"
+
+# (frozen install, plain install)
+_INSTALL = {
+    "npm": ("npm ci", "npm install"),
+    "pnpm": ("pnpm install --frozen-lockfile", "pnpm install"),
+    "yarn": ("yarn install --immutable", "yarn install"),
+    "yarn-classic": ("yarn install --frozen-lockfile", "yarn install"),
+    "bun": ("bun install --frozen-lockfile", "bun install"),
+}
+# Removes devDependencies after the build. Yarn Berry has no equivalent without a plugin.
+_PRUNE = {
+    "npm": "npm prune --omit=dev",
+    "pnpm": "pnpm prune --prod",
+    "yarn-classic": "yarn install --production --ignore-scripts --prefer-offline",
+    "bun": "rm -rf node_modules && bun install --production --ignore-scripts",
+}
+_CACHE = {
+    "npm": "/root/.npm",
+    "pnpm": "/root/.local/share/pnpm/store",
+    "yarn": "/root/.yarn/berry/cache",
+    "yarn-classic": "/usr/local/share/.cache/yarn",
+    "bun": "/root/.bun/install/cache",
+}
+_LOCKFILES = {
+    "npm": ("package-lock.json",),
+    "pnpm": ("pnpm-lock.yaml",),
+    "yarn": ("yarn.lock",),
+    "yarn-classic": ("yarn.lock",),
+    "bun": ("bun.lock", "bun.lockb"),
+}
+# Files and directories the install reads besides package.json and the lockfile.
+_INSTALL_FILES = (".npmrc", "pnpm-workspace.yaml", ".yarnrc.yml", ".yarnrc", "bunfig.toml")
+_INSTALL_DIRS = (".yarn/releases", ".yarn/plugins", ".yarn/patches", "patches")
+# A Vite project without one of these is a static single-page app.
+_SERVER_DEPS = {"express", "fastify", "koa", "hono", "@hono/node-server", "@nestjs/core", "next", "nuxt"}
+
+
+class NodeImage(DockerImage):
+    # Static sites: unknown paths fall back to index.html (single-page apps) or to 404.html.
+    spa = True
+
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        pkg = package_json(project)
+        deps = dependencies(pkg)
+        scripts = scripts_of(pkg)
+        if "vite" in deps and det.build_command and "start" not in scripts and not _SERVER_DEPS & deps.keys():
+            return DockerDefaults(port=8080, build_command=det.build_command, output_dir="dist", static=True)
+        command = _start_command(project, pkg, scripts)
+        warnings = [] if command else ["Couldn't infer how to start the app — set docker.command in quoll.toml."]
+        return DockerDefaults(port=3000, command=command, build_command=det.build_command, warnings=warnings)
+
+    def context(self, project: Project, cfg: DockerConfig) -> Dict[str, Any]:
+        pm = cfg.package_manager
+        lockfile = next((f for f in _LOCKFILES[pm] if project.exists(f)), "")
+        bun = pm == "bun"
+        return {
+            "build_image": "oven/bun:1" if bun else f"node:{cfg.version}-slim",
+            "runtime_image": "oven/bun:1-slim" if bun else f"node:{cfg.version}-slim",
+            "user": "bun" if bun else "node",
+            # Both images' user has uid and gid 1000.
+            "uid": "1000:1000",
+            "setup": _setup(project, cfg),
+            "install": _INSTALL[pm][0 if lockfile else 1],
+            "install_files": ["package.json", *([lockfile] if lockfile else []), *_present(project, _INSTALL_FILES)],
+            "install_dirs": _present(project, _INSTALL_DIRS),
+            "cache": _CACHE[pm],
+            "prune": _PRUNE.get(pm, ""),
+            "spa": self.spa,
+            "build_env": self.build_env(cfg),
+            "env": {"NODE_ENV": "production", "PORT": str(cfg.port), "HOST": "0.0.0.0", **self.env(cfg)},
+        }
+
+    def writable_paths(self, cfg: DockerConfig) -> Optional[List[str]]:
+        if not cfg.static:
+            return ["/tmp"]
+        # nginx's temporary files; with a proxy, the configuration its entrypoint writes from the template.
+        return ["/tmp", "/var/cache/nginx", *(["/etc/nginx/conf.d"] if cfg.proxy else [])]
+
+    def build_env(self, cfg: DockerConfig) -> Dict[str, str]:
+        """Environment of the build step."""
+        return {}
+
+    def env(self, cfg: DockerConfig) -> Dict[str, str]:
+        """Extra runtime environment variables."""
+        return {}
+
+    def dockerignore(self, cfg: DockerConfig) -> List[str]:
+        return [
+            "**/node_modules",
+            ".next",
+            ".nuxt",
+            ".output",
+            ".svelte-kit",
+            ".astro",
+            ".angular",
+            "dist",
+            "build",
+            "coverage",
+            "npm-debug.log*",
+            ".env",
+            ".env.*",
+            "!.env.example",
+        ]
+
+
+def _setup(project: Project, cfg: DockerConfig) -> str:
+    """Command installing the package manager in the build image."""
+    declared = str(package_json(project).get("packageManager", "")).split("+")[0]
+    if cfg.package_manager == "pnpm":
+        version = declared.split("@")[1] if declared.startswith("pnpm@") else cfg.package_manager_version
+        return f"npm install --global pnpm@{version or PNPM_DEFAULT}"
+    if cfg.package_manager == "yarn":
+        return "corepack enable"
+    return ""
+
+
+def _start_command(project: Project, pkg: dict, scripts: Dict[str, str]) -> str:
+    if scripts.get("start"):
+        return scripts["start"]
+    if pkg.get("main"):
+        return f"node {pkg['main']}"
+    for name in ("server.js", "index.js", "src/server.js", "src/index.js"):
+        if project.exists(name):
+            return f"node {name}"
+    return ""
+
+
+def _present(project: Project, names: tuple) -> List[str]:
+    return [n for n in names if project.exists(n)]

quoll/languages/node/frameworks/__init__.py

@@ -0,0 +1 @@
+"""Node.js frameworks."""

quoll/languages/node/frameworks/angular/__init__.py

@@ -0,0 +1,18 @@
+"""Angular: tests run once through the CLI (headless Chrome for Karma); opt out of CLI analytics."""
+
+from quoll.languages.base import Framework
+from quoll.languages.node.frameworks.angular.ci import AngularCI
+from quoll.languages.node.frameworks.angular.detect import detect
+from quoll.languages.node.frameworks.angular.docker import AngularImage
+from quoll.languages.node.frameworks.angular.starter import starter
+
+framework = Framework(
+    name="angular",
+    language="node",
+    detect=detect,
+    ci=AngularCI(),
+    # "angular" is the CLI's Vitest-based runner (Angular 21+), "angular-karma" the older Karma one.
+    test_runners=("angular", "angular-karma"),
+    docker=AngularImage(),
+    starters=(starter,),
+)

quoll/languages/node/frameworks/angular/ci.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List
+
+from quoll.ci.steps import Item, step
+from quoll.languages.base import FrameworkCI
+
+if TYPE_CHECKING:
+    from quoll.ci.config import CIConfig
+
+# Karma drives a real Chrome. Runners have one; Node images don't: install Chromium, through a launcher adding
+# --no-sandbox (container jobs run as root, where Chrome's sandbox can't start).
+_CHROME = """if [ -z "${CHROME_BIN:-}" ] && ! command -v google-chrome >/dev/null 2>&1; then
+  apt-get update -qq && apt-get install -y -qq --no-install-recommends chromium >/dev/null
+  printf '#!/bin/sh\\nexec chromium --no-sandbox "$@"\\n' > /usr/local/bin/chromium-ci
+  chmod +x /usr/local/bin/chromium-ci
+  echo "CHROME_BIN=/usr/local/bin/chromium-ci" >> "${GITHUB_ENV:-/dev/null}"
+fi"""
+
+
+class AngularCI(FrameworkCI):
+    def env(self, cfg: CIConfig) -> Dict[str, str]:
+        return {"NG_CLI_ANALYTICS": "false"}
+
+    def test(self, cfg: CIConfig) -> List[Item]:
+        ci = cfg.language.ci
+        cmd = ci.exec(cfg, "ng test --watch=false")
+        steps: List[Item] = list(ci.install(cfg))
+        if cfg.test.runner == "angular-karma":
+            cmd += " --browsers=ChromeHeadless"
+            steps.append(step("Chrome for Karma", run=_CHROME))
+            # Same shell on container platforms: the launcher installed above, if any.
+            cmd = f'if [ -x /usr/local/bin/chromium-ci ]; then export CHROME_BIN=/usr/local/bin/chromium-ci; fi\n{cmd}'
+        return [*steps, step("Tests", run=cmd, secrets=cfg.test.env_secrets)]

quoll/languages/node/frameworks/angular/detect.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection
+from quoll.languages.node.detect import dependencies, package_json, scripts_of
+from quoll.project import Project
+
+
+def detect(project: Project, det: Detection) -> bool:
+    pkg = package_json(project)
+    deps = dependencies(pkg)
+    if "@angular/core" not in deps:
+        return False
+    # `ng build` type-checks, and Angular's solution-style tsconfig.json makes plain tsc a no-op.
+    det.lint_tools = [t for t in det.lint_tools if t != "tsc"]
+    if "ng test" in scripts_of(pkg).get("test", ""):
+        det.test_runner = "angular-karma" if "karma" in deps else "angular"
+        # Coverage thresholds live in karma.conf.js / angular.json.
+        det.coverage = False
+        det.warnings = [w for w in det.warnings if "vitest coverage" not in w]
+    return True

quoll/languages/node/frameworks/angular/docker.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from quoll.languages.base import Detection, DockerDefaults
+from quoll.languages.node.detect import dependencies, package_json
+from quoll.languages.node.docker import NodeImage
+from quoll.project import Project
+
+
+class AngularImage(NodeImage):
+    def defaults(self, project: Project, det: Detection) -> DockerDefaults:
+        build = det.build_command or "npm run build"
+        output, application_builder, ssr = _build_target(project)
+        if ssr and "@angular/ssr" in dependencies(package_json(project)):
+            return DockerDefaults(port=4000, command=f"node {output}/server/server.mjs", build_command=build)
+        # The application builder writes the browser bundle to <outputPath>/browser.
+        site = f"{output}/browser" if application_builder else output
+        return DockerDefaults(port=8080, build_command=build, output_dir=site, static=True)
+
+
+def _build_target(project: Project):
+    """(outputPath, uses the application builder, has SSR) of the first project in angular.json."""
+    workspace = project.read_json("angular.json")
+    projects = workspace.get("projects", {}) if isinstance(workspace, dict) else {}
+    name, config = next(iter(projects.items()), (project.name, {}))
+    build = config.get("architect", {}).get("build", {})
+    options = build.get("options", {})
+    output = options.get("outputPath", f"dist/{name}")
+    if isinstance(output, dict):
+        output = output.get("base", f"dist/{name}")
+    application_builder = str(build.get("builder", ":application")).endswith(":application")
+    return output, application_builder, bool(options.get("ssr") or options.get("server"))