ikanban 0.4.2 → 0.4.4

package/README.md

@@ -32,8 +32,11 @@ No CI is needed.
 (`trivy fs --scanners misconfig`) and on each `--image` (`trivy image`). `dastscan` runs the
 [OWASP ZAP](https://www.zaproxy.org/docs/docker/baseline-scan/) baseline scan in Docker: it reads
 the site's responses and does not attack. It scans only a URL the team registered in iKASecure →
-Infrastructure, so it always needs `--team` and a key. Findings show on the Infrastructure tab. A
-missing Trivy or Docker is reported as SKIPPED with the install command, never as a pass.
+Infrastructure, so it always needs `--team` and a key. Findings show on the Infrastructure tab.
+Without a `trivy` command, `infrascan` runs Trivy's official container (`aquasec/trivy:0.76.0`)
+when Docker is running: the repository is mounted read-only, and the Docker socket only for an
+image that exists on this machine alone. The report names the Trivy that ran. With neither Trivy
+nor Docker, the scan is reported as SKIPPED with both fixes, never as a pass.
 
 `infrascan` starts with an inventory of each `--path` (repeat it when infrastructure lives in
 another folder or repository): what it found, what Trivy scanned, and what it could not scan and
@@ -47,6 +50,14 @@ over 500 findings files the 500 worst and counts as incomplete. Trivy runs from
 its own config and ignore file, so a repository's `trivy.yaml` or `.trivyignore` changes nothing, and
 only valid image names from compose files are scanned.
 
+## Dependencies without a lockfile
+
+`npm audit` needs a lockfile. When a folder has none and npm cannot resolve its tree (ERESOLVE, a
+peer conflict), `secscan` writes a lockfile for a copy of `package.json` in its scan folder
+(`npm install --package-lock-only --ignore-scripts --legacy-peer-deps`, without the folder's
+`.npmrc`) and audits that copy. Nothing is written into the repository. If npm still cannot
+resolve the tree, the folder is SKIPPED with the fix: commit a `package-lock.json`.
+
 ## Scan files
 
 Every scanner keeps its raw tool output and its report in `.iKanban/scans/<scanner>-<time>/` in
@@ -57,13 +68,14 @@ own `.gitignore`, so nothing in it is committed. Delete old runs whenever you li
 
 Every scanner takes `--task IKA-123` (or `IKANBAN_TASK`) and `--task-team` (default `--team`). The
 run then shows in that task's Pipelines view: running, then passed, failed or skipped with a
-one-line summary, and the masked report as its log. A plan without Pipelines never fails the scan.
+one-line summary, and the masked report as its log. While the scan runs, the stage log gets one
+line as each step starts and ends. A plan without Pipelines never fails the scan.
 
 ## What you need
 
 - Node.js 18 or newer.
 - Python 3.9 or newer. The scanners are Python; `ikanban` finds `python3`, `python` or `py -3`.
-- `infrascan`: Trivy (macOS `brew install trivy`; other systems: a release binary). `dastscan`: Docker.
+- `infrascan`: Trivy (macOS `brew install trivy`; other systems: a release binary), or Docker running. `dastscan`: Docker.
 
 ## Free and paid
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ikanban",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "description": "iKanban CLI: AI and security scans of your own repo, with results filed into iKanban",
   "bin": { "ikanban": "bin/ikanban.js" },
   "files": ["bin", "lib", "hooks", "scanners", "README.md", "LICENSE.md"],

package/scanners/ikanban-aiscan.py

@@ -57,7 +57,7 @@ PROMPTFOO_VERSION = "0.123.1"
 # so this string is the release identity. Bump it when publishing a release —
 # a customer pinning a version is pinning this value, and re-uploading different
 # bytes under a version someone already fetched defeats the sha256 they pinned.
-AISCAN_VERSION = "0.5.1"
+AISCAN_VERSION = "0.6.1"
 
 # The ten categories, their labels, and their plugins -- the forward map, copied
 # from promptfoo's OWASP_LLM_TOP_10_MAPPING (src/redteam/constants/frameworks.ts).
@@ -356,9 +356,15 @@ def build_config(target, spec, plugins, num_tests, base_url, token, workspace_id
     }
 
 
-def run_promptfoo(args, cwd, allow_remote):
+def run_promptfoo(args, cwd, allow_remote, openai=None):
     cmd = ["npx", "-y", f"promptfoo@{PROMPTFOO_VERSION}"] + args
     env = dict(os.environ)
+    # G22: openai_env's names; None removes a name from promptfoo's environment.
+    for name, value in (openai or {}).items():
+        if value is None:
+            env.pop(name, None)
+        else:
+            env[name] = value
     if not allow_remote:
         # Pinned here rather than left to the caller's shell. promptfoo decides
         # remote-vs-local by looking for OPENAI_API_KEY (shouldGenerateRemote in
@@ -403,7 +409,7 @@ def config_secrets(node) -> set:
     return {x for x in out if len(x) >= 8}
 
 
-def scan_category(label, target, cfg, workdir, allow_remote):
+def scan_category(label, target, cfg, workdir, allow_remote, openai=None):
     """generate + eval one category. Returns (findings, plugins_that_ran, errors).
 
     Plan 11 H12-T10 review: promptfoo's config and cases hold the iKanban token, so they live
@@ -412,12 +418,12 @@ def scan_category(label, target, cfg, workdir, allow_remote):
     replaced, are copied into the scan's work folder."""
     private = Path(tempfile.mkdtemp(prefix="ikanban-aiscan-"))  # mkdtemp creates it 0700
     try:
-        return _scan_category(label, target, cfg, workdir, allow_remote, private)
+        return _scan_category(label, target, cfg, workdir, allow_remote, private, openai)
     finally:
         shutil.rmtree(private, ignore_errors=True)
 
 
-def _scan_category(label, target, cfg, workdir, allow_remote, private):
+def _scan_category(label, target, cfg, workdir, allow_remote, private, openai=None):
     cfg_path = private / "config.yaml"
     cases_path = private / "cases.yaml"
     out_path = private / "results.json"
@@ -428,7 +434,7 @@ def _scan_category(label, target, cfg, workdir, allow_remote, private):
     cfg_path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
 
     if not run_promptfoo(
-        ["redteam", "generate", "-c", str(cfg_path), "-o", str(cases_path)], private, allow_remote
+        ["redteam", "generate", "-c", str(cfg_path), "-o", str(cases_path)], private, allow_remote, openai
     ):
         return None
     if not cases_path.exists():
@@ -438,7 +444,7 @@ def _scan_category(label, target, cfg, workdir, allow_remote, private):
     # tests failed, i.e. attacks got through, i.e. exactly the findings we came
     # for. The results file decides, not the exit code.
     run_promptfoo(
-        ["redteam", "eval", "-c", str(cases_path), "-o", str(out_path), "--no-cache"], private, allow_remote
+        ["redteam", "eval", "-c", str(cases_path), "-o", str(out_path), "--no-cache"], private, allow_remote, openai
     )
     if not out_path.exists():
         log("  promptfoo wrote no results file — the run genuinely failed")
@@ -446,7 +452,9 @@ def _scan_category(label, target, cfg, workdir, allow_remote, private):
 
     raw = out_path.read_text(encoding="utf-8")
     redacted = raw
-    for secret in sorted(config_secrets(cfg), key=len, reverse=True):
+    # G22: the iKanban key promptfoo sends to the relay is hidden like the config's own.
+    relay_key = (openai or {}).get("OPENAI_API_KEY")
+    for secret in sorted(config_secrets(cfg) | ({relay_key} if relay_key else set()), key=len, reverse=True):
         redacted = redacted.replace(secret, "[hidden]")
     write_private(workdir / f"results-{re.sub(r'[^A-Za-z0-9_-]+', '_', label)}.json", redacted)
     doc = json.loads(raw)
@@ -701,6 +709,43 @@ def publish(findings, run_id, base_url, token, team_id, coverage, plugin_results
         return False, 0, 0
 
 
+# G22 (owner): the attacks are made with the team's OpenAI key kept in iKanban. The key
+# stays on the server: promptfoo's OpenAI base URL is iKanban's relay, which adds the key and
+# forwards only the OpenAI calls promptfoo makes. promptfoo 0.123.1 reads OPENAI_API_HOST
+# first, then OPENAI_API_BASE_URL, then OPENAI_BASE_URL (OpenAiGenericProvider.getApiUrl).
+NO_OPENAI_KEY = ("AI endpoints skipped: no OpenAI key. Add the team's OpenAI key in iKanban "
+                 "(Settings → AI Provider Keys), or set OPENAI_API_KEY in the shell that runs the scan.")
+NO_AI_PLAN = "AI endpoints skipped: the team's plan has no AI findings (Pro+)."
+
+
+def openai_env(environ, base_url, token, team):
+    """(promptfoo env changes, None) to scan, or (None, the SKIPPED line). A shell key wins."""
+    if environ.get("OPENAI_API_KEY"):
+        return {}, None
+    if not (token and team):
+        return None, NO_OPENAI_KEY
+    relay = f"{ikanban_api(base_url)}/api/teams/{urllib.parse.quote(team, safe='')}/security/ai-relay"
+    req = urllib.request.Request(relay, headers={"Authorization": f"Bearer {token}"})
+    try:
+        with _OPENER.open(req, timeout=30) as resp:
+            body = json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        if exc.code == 402:
+            return None, NO_AI_PLAN
+        return None, f"AI endpoints skipped: iKanban answered {exc.code} for the team's OpenAI key."
+    except (urllib.error.URLError, ValueError) as exc:
+        return None, f"AI endpoints skipped: could not reach iKanban for the team's OpenAI key ({type(exc).__name__})."
+    if not body.get("data", body).get("openai_key"):
+        return None, NO_OPENAI_KEY
+    return {
+        "OPENAI_API_HOST": None,
+        "OPENAI_API_BASE_URL": f"{relay}/v1",
+        "OPENAI_BASE_URL": f"{relay}/v1",
+        # The iKanban key, sent only to the relay above (iKanban's API, T3).
+        "OPENAI_API_KEY": token,
+    }, None
+
+
 # ── Scan work folder (plan 11 H12-T10, owner): raw tool output and the report live under
 # <repo>/.iKanban/scans/<scanner>-<UTC time>/, never the system temp folder. The scans folder
 # holds its own .gitignore ("*"), so nothing in it is committed and no repo .gitignore is edited.
@@ -788,6 +833,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -828,6 +885,11 @@ class Pipeline:
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
                                        "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
 
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
+
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
         detail = LAST_RUN["detail"] or ("the scan stopped with an error" if code == 2 else "")
@@ -854,6 +916,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -890,7 +954,8 @@ def main(argv=None):
     ap.add_argument("--allow-remote-generation", action="store_true",
                     help="Let promptfoo generate attacks on its hosted service. Off by default: "
                          "it needs an email registered with promptfoo, and it sends the purpose "
-                         "string off this machine. Local generation needs OPENAI_API_KEY instead.")
+                         "string off this machine. Local generation uses OPENAI_API_KEY from the shell, "
+                         "else the team's OpenAI key in iKanban through its relay.")
     ap.add_argument("--dry-run", action="store_true", help="Print the payload, POST nothing")
     ap.add_argument("--allow-outside-cwd", action="store_true",
                     help="Permit --config, --html and --out to point outside the working "
@@ -961,6 +1026,15 @@ def main(argv=None):
         log(f"error: unknown collection {args.plugins!r}")
         return 2
 
+    openai = None
+    if not args.allow_remote_generation:
+        openai, why = openai_env(os.environ, args.base_url, args.token, args.team)
+        if openai is None:
+            log(why)
+            progress(why)
+            LAST_RUN.update(report=f"# AI endpoint scan — {args.target}\n\n{why}", detail=why[:300], skipped=True)
+            return 0
+
     # MEASURED 2026-09-20, promptfoo 0.123.1: of the MCP plugin set, only `rbac`
     # generates locally. `mcp` itself, `bfla` and `bola` all require promptfoo's
     # hosted generator and produce zero tests without it -- so a local-only MCP
@@ -992,12 +1066,16 @@ def main(argv=None):
             skipped.append(label)
             per_category.append({"category": label, "asked": 0, "ran": 0, "skipped": []})
             log(f"{label}: SKIPPED — promptfoo ships no plugins for this category")
+            progress(f"{label} SKIPPED · no plugins for this category")
             continue
         log(f"{label}: generating and running {args.num_tests} tests per plugin…")
+        # Pipelines get fixed status lines only; log() also carries promptfoo's raw output.
+        progress(f"{label} started · {len(plugins)} plugins, {args.num_tests} tests each")
         cfg = build_config(args.target, spec, plugins, args.num_tests,
                            args.base_url, args.token, args.workspace_id)
-        got = scan_category(label, args.target, cfg, workdir, args.allow_remote_generation)
+        got = scan_category(label, args.target, cfg, workdir, args.allow_remote_generation, openai)
         if got is None:
+            progress(f"{label} finished · did not run")
             failed.append(label)
             per_category.append(
                 {"category": label, "asked": len(plugins), "ran": 0, "skipped": sorted(plugins)}
@@ -1041,6 +1119,8 @@ def main(argv=None):
             scanned += 1
         log(f"  {len(category_findings)} finding(s)"
             + (f", {cat_errors} error(s)" if cat_errors else ""))
+        progress(f"{label} finished · {len(category_findings)} findings"
+                 + (f", {cat_errors} errors" if cat_errors else ""))
         findings.extend(category_findings)
 
     log("")

package/scanners/ikanban-dastscan.py

@@ -42,7 +42,7 @@ import urllib.request
 from datetime import datetime, timezone
 from pathlib import Path
 
-DASTSCAN_VERSION = "1.1.1"
+DASTSCAN_VERSION = "1.2.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
@@ -313,6 +313,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -353,6 +365,11 @@ class Pipeline:
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
                                        "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
 
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
+
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
         detail = LAST_RUN["detail"] or ("the scan stopped with an error" if code == 2 else "")
@@ -379,6 +396,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -445,8 +464,12 @@ def main(argv=None):
         return 2
 
     work = scan_work_dir("dastscan", Path.cwd(), args.work_dir)
+    progress(f"dastscan {DASTSCAN_VERSION} · ZAP baseline on {url}: spider {args.minutes} min, "
+             f"at most {args.max_minutes} min …")
     report, skipped_why = run_zap(url, args.minutes, args.max_minutes, work)
     findings = parse_zap(report) if report is not None else []
+    progress(f"ZAP baseline on {url} … " + (f"done, {len(findings)} alerts" if report is not None
+                                             else "SKIPPED (the reason is in the report)"))
     ran = [f"zap-baseline.py -t {url} -m {args.minutes}"] if report is not None else []
     md, counts, total = build_report(url, findings, [skipped_why] if skipped_why else [], ran)
     LAST_RUN.update(report=md, detail=summary_detail(counts, total, [] if ran else [skipped_why]),

package/scanners/ikanban-infrascan.py

@@ -37,6 +37,7 @@ Helpers below are copied from ikanban-secscan.py (the scanners ship as single fi
 from __future__ import annotations
 
 import argparse
+import functools
 import hashlib
 import json
 import os
@@ -51,15 +52,20 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 
-INFRASCAN_VERSION = "1.1.1"
+INFRASCAN_VERSION = "1.2.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
 # Trivy's severities; UNKNOWN (no score yet) is filed as low.
 TRIVY_SEVERITY = {"CRITICAL": "critical", "HIGH": "high", "MEDIUM": "medium", "LOW": "low", "UNKNOWN": "low"}
 
-TRIVY_INSTALL = ("Trivy is not installed — macOS: `brew install trivy`; Linux and Windows: a release "
-                 "binary from https://github.com/aquasecurity/trivy/releases, or `docker run aquasec/trivy`")
+TRIVY_INSTALL = ("Trivy is not installed and Docker is not running — install Trivy (macOS: `brew install trivy`; "
+                 "Linux and Windows: a release binary from https://github.com/aquasecurity/trivy/releases), "
+                 "or start Docker and the scan runs Trivy's official container")
+# Plan 11 H12-T14 (G13): without a trivy binary, Trivy runs from its official image. Pinned to a
+# released tag (hub.docker.com aquasec/trivy tags: 0.76.0); the DB is cached in a named volume.
+TRIVY_IMAGE = "aquasec/trivy:0.76.0"
+TRIVY_CACHE = "ikanban-trivy-cache:/root/.cache/trivy"
 
 CATEGORY = {"iac": "A05 — Security Misconfiguration",
             "container": "A06 — Vulnerable and Outdated Components"}
@@ -123,14 +129,42 @@ def run(cmd, cwd=None, timeout=900):
         return False, "", f"timed out after {timeout}s"
 
 
-def trivy_json(args: list, target: str, out: Path) -> tuple[dict | None, str]:
+@functools.lru_cache(maxsize=1)
+def trivy_mode() -> str:
+    """'binary' (trivy on PATH), 'container' (Docker answers) or '' (neither)."""
+    if shutil.which("trivy"):
+        return "binary"
+    if shutil.which("docker") and run(["docker", "info"], timeout=30)[0]:
+        return "container"
+    return ""
+
+
+def trivy_label() -> str:
+    return f"trivy (container {TRIVY_IMAGE})" if trivy_mode() == "container" else "trivy"
+
+
+def trivy_cmd(work: Path, ro_mounts: tuple = (), socket: bool = False) -> list:
+    """The command that starts Trivy. As a container it sees only the work folder (read-write),
+    the paths in ro_mounts (read-only, at their own absolute paths) and a cache volume; the
+    Docker socket only when asked (a local image), since the socket gives full control of Docker."""
+    if trivy_mode() == "binary":
+        return ["trivy"]
+    cmd = ["docker", "run", "--rm", "-w", str(work), "-v", f"{work}:{work}", "-v", TRIVY_CACHE]
+    for p in ro_mounts:
+        cmd += ["-v", f"{p}:{p}:ro"]
+    if socket:
+        cmd += ["-v", "/var/run/docker.sock:/var/run/docker.sock"]
+    return [*cmd, TRIVY_IMAGE]
+
+
+def trivy_json(args: list, target: str, out: Path, ro_mounts: tuple = (), socket: bool = False) -> tuple[dict | None, str]:
     """Run `trivy SUBCOMMAND [ARGS] -- TARGET` with --format json into `out`; (report, "") or
     (None, why skipped). Plan 11 H12-T10 review: trivy runs from the scan's work folder with a
     scanner-owned --config and --ignorefile (both default to files in the working folder,
     trivy.dev CLI reference: `-c, --config ... (default "trivy.yaml")`, `--ignorefile ...
     (default ".trivyignore")`), so a repository's trivy.yaml or .trivyignore changes nothing.
     The target comes after `--`, so a name starting with '-' can never be read as a flag."""
-    if not shutil.which("trivy"):
+    if not trivy_mode():
         return None, TRIVY_INSTALL
     work = out.parent
     conf, ignore = work / "trivy-config.yaml", work / "trivyignore"
@@ -138,7 +172,7 @@ def trivy_json(args: list, target: str, out: Path) -> tuple[dict | None, str]:
         write_private(conf, "{}\n")
     if not ignore.exists():
         write_private(ignore, "")
-    ok, _o, err = run(["trivy", *args[:1], "--config", str(conf), "--ignorefile", str(ignore),
+    ok, _o, err = run([*trivy_cmd(work, ro_mounts, socket), *args[:1], "--config", str(conf), "--ignorefile", str(ignore),
                        "--format", "json", "--output", str(out), *args[1:], "--", target], cwd=work)
     if not ok or not out.exists():
         return None, f"trivy {args[0]} failed: {(err or '').strip()[-300:] or 'no output'}"
@@ -196,11 +230,11 @@ def scan_iac(root: Path, scope: str, inv: dict, work: Path) -> Section:
     # the absolute and the ** form are both passed. A miss only means a vendored folder is read too.
     skip = [x for d in SKIP_DIRS for x in ("--skip-dirs", f"{root.resolve()}/{d}", "--skip-dirs", f"**/{d}")]
     report, why = trivy_json(["fs", "--scanners", "misconfig", *skip], str(root.resolve()),
-                             work / f"trivy-iac-{slug(scope)}.json")
+                             work / f"trivy-iac-{slug(scope)}.json", ro_mounts=(root.resolve(),))
     if report is None:
         sec.skipped.append(why)
         return sec
-    sec.ran.append(f"trivy fs --scanners misconfig {root.name}")
+    sec.ran.append(f"{trivy_label()} fs --scanners misconfig {root.name}")
     sec.findings = parse_misconfigurations(report)
     for f in sec.findings:  # paths relative to the repository, like secscan
         f.location = f.location.removeprefix(str(root) + os.sep).removeprefix(str(root.resolve()) + os.sep)
@@ -213,11 +247,19 @@ def scan_image(image: str, work: Path) -> Section:
     if not valid_image_ref(image):
         sec.skipped.append(f"`{image[:80]}` is not a valid image name; not scanned")
         return sec
-    report, why = trivy_json(["image"], image, work / f"trivy-image-{slug(image)}.json")
+    out = work / f"trivy-image-{slug(image)}.json"
+    if trivy_mode() == "container":
+        # A registry image is pulled inside Trivy, with no Docker socket. Only an image that exists
+        # just on this machine (built locally, e.g. by compose) is read through the socket.
+        report, why = trivy_json(["image", "--image-src", "remote"], image, out)
+        if report is None and run(["docker", "image", "inspect", "--", image], timeout=30)[0]:
+            report, why = trivy_json(["image", "--image-src", "docker"], image, out, socket=True)
+    else:
+        report, why = trivy_json(["image"], image, out)
     if report is None:
         sec.skipped.append(why)
         return sec
-    sec.ran.append(f"trivy image {image}")
+    sec.ran.append(f"{trivy_label()} image {image}")
     sec.findings = parse_vulnerabilities(report, image)
     sec.complete = True
     return sec
@@ -625,6 +667,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -665,6 +719,11 @@ class Pipeline:
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
                                        "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
 
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
+
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
         detail = LAST_RUN["detail"] or ("the scan stopped with an error" if code == 2 else "")
@@ -691,6 +750,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -740,6 +801,7 @@ def main(argv=None):
         print("error: nothing to scan: drop --no-iac or add --image", file=sys.stderr)
         return 2
     work = scan_work_dir("infrascan", root, args.work_dir)
+    progress(f"infrascan {INFRASCAN_VERSION} · {trivy_label() if trivy_mode() else 'no Trivy and no Docker'}")
     sections, images, unresolved = [], list(args.image), []
     INVENTORY.clear()
     for r in roots:
@@ -750,12 +812,20 @@ def main(argv=None):
             images += [i for i in found if i not in images]
             unresolved += skipped_vars
         if not args.no_iac:
+            progress(f"trivy fs (IaC) in {r.name}/ …")
             sec = scan_iac(r, scan_scope(r), inv, work)
+            progress(f"trivy fs (IaC) in {r.name}/ … " + (f"done, {len(sec.findings)} findings" if sec.complete
+                                                            else "SKIPPED (the reason is in the report)"))
             sections.append(sec)
             INVENTORY.append((sec.scope, inventory_rows(inv, sec.complete, "; ".join(sec.skipped), rejected)))
         else:
             INVENTORY.append((scan_scope(r), inventory_rows(inv, False, "--no-iac", rejected)))
-    sections += [scan_image(i, work) for i in images]
+    for i in images:
+        progress(f"trivy image {i} …")
+        sec = scan_image(i, work)
+        progress(f"trivy image {i} … " + (f"done, {len(sec.findings)} critical/high" if sec.complete
+                                          else "SKIPPED (the reason is in the report)"))
+        sections.append(sec)
     if unresolved:
         sections.append(Section("Compose images not scanned", "container", "compose",
                                 skipped=[f"`{i}` uses a ${{VARIABLE}}; pass the real name with --image" for i in unresolved]))

package/scanners/ikanban-secscan.py

@@ -53,6 +53,7 @@ import shutil
 import stat
 import subprocess
 import sys
+import tempfile
 import urllib.error
 import urllib.parse
 import urllib.request
@@ -64,7 +65,7 @@ from pathlib import Path
 # that npm no longer hosts the package. Starting at 1.0.0 rather than continuing
 # the npm package's 0.1.x line: that counter belonged to the wrapper, not to
 # this file, and reusing it would suggest a continuity that does not exist.
-SECSCAN_VERSION = "1.5.1"
+SECSCAN_VERSION = "1.6.0"
 
 SEVERITIES = ["critical", "high", "medium", "low", "info"]
 SEVERITY_RANK = {s: i for i, s in enumerate(SEVERITIES)}
@@ -222,7 +223,7 @@ def iter_files(root: Path):
 
 
 # ── 1. Dependency audits ─────────────────────────────────────────────────────
-def audit_dependencies(root: Path) -> Section:
+def audit_dependencies(root: Path, work: Path | None = None) -> Section:
     sec = Section("Dependency vulnerabilities")
 
     if (root / "Cargo.lock").exists():
@@ -245,9 +246,18 @@ def audit_dependencies(root: Path) -> Section:
             sec.ran.append("pnpm audit")
             sec.findings += _parse_npm_audit(out)
             _note_unanswered(sec, "pnpm audit", out, err)
+        elif shutil.which("npm") and not _has_npm_lock(root) and _non_registry(root):
+            # Without a lockfile npm resolves the tree itself, and a git, file, link or URL
+            # dependency makes it fetch or read from outside the registry. Never do that here.
+            sec.skipped.append("npm audit: its package.json names non-registry dependencies; "
+                               "commit a package-lock.json to audit it")
         elif shutil.which("npm"):
             ok, out, err = run(["npm", "audit", "--json"], cwd=root)
-            sec.ran.append("npm audit")
+            tool = "npm audit"
+            if not audit_answered(out) and work is not None and not _has_npm_lock(root):
+                out, err = npm_audit_scratch(root, work)
+                tool = "npm audit (no lockfile in the repository: one resolved with --legacy-peer-deps in the scan folder)"
+            sec.ran.append(tool)
             sec.findings += _parse_npm_audit(out)
             _note_unanswered(sec, "npm audit", out, err)
         else:
@@ -269,6 +279,69 @@ def audit_dependencies(root: Path) -> Section:
     return sec
 
 
+# A registry semver range or a dist-tag: no ":" (git+, github:, file:, link:, workspace:, npm:,
+# URLs), no "/" (user/repo, paths), no tarball name. An override may also be "$name": the spec of
+# a direct dependency of that name, which is checked itself.
+_REGISTRY_SPEC = re.compile(r"^[A-Za-z0-9.\-+^~<>=| *]*$")
+_TARBALL = re.compile(r"\.(tgz|tar|tar\.gz)$", re.IGNORECASE)
+
+
+def non_registry_specs(pkg: dict) -> list:
+    """Every dependency spec in package.json that is not a registry range or dist-tag."""
+    bad = []
+    direct = {n for k in ("dependencies", "devDependencies", "optionalDependencies", "peerDependencies")
+              if isinstance(pkg.get(k), dict) for n in pkg[k]}
+
+    def walk(name, spec, override=False):
+        if isinstance(spec, dict):
+            for k, v in spec.items():
+                walk(k, v, override)
+        elif override and isinstance(spec, str) and spec.startswith("$") and spec[1:] in direct:
+            return
+        elif not isinstance(spec, str) or not _REGISTRY_SPEC.match(spec) or _TARBALL.search(spec):
+            bad.append(f"{name}: {spec!r}"[:120])
+
+    if pkg.get("workspaces"):
+        bad.append("workspaces")  # npm resolves local folders outside the checked lists
+    for key in ("dependencies", "devDependencies", "optionalDependencies", "peerDependencies", "overrides"):
+        section = pkg.get(key) or {}
+        if not isinstance(section, dict):
+            bad.append(key)
+            continue
+        for name, spec in section.items():
+            walk(name, spec, key == "overrides")
+    return bad
+
+
+def _has_npm_lock(root: Path) -> bool:
+    return any((root / f).exists() for f in ("package-lock.json", "npm-shrinkwrap.json"))
+
+
+def _non_registry(root: Path) -> bool:
+    try:
+        pkg = json.loads((root / "package.json").read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return True  # unreadable: npm would fail too; never guess
+    return not isinstance(pkg, dict) or bool(non_registry_specs(pkg))
+
+
+def npm_audit_scratch(root: Path, work: Path):
+    """Plan 11 H12-T14 (G14): npm audit needs a lockfile. Without one npm builds the tree
+    itself, and a peer conflict stops it (ERESOLVE: Juice Shop's frontend). So write a
+    lockfile for a copy of package.json alone in the scan folder, then audit that copy.
+    No .npmrc (it may say package-lock=false), no node_modules, no install scripts."""
+    scratch = Path(tempfile.mkdtemp(prefix="npm-lock-", dir=work))
+    write_private(scratch / "package.json", (root / "package.json").read_text(encoding="utf-8"))
+    ok, out, err = run(["npm", "install", "--package-lock-only", "--ignore-scripts",
+                        "--legacy-peer-deps", "--no-audit"], cwd=scratch, timeout=600)
+    if not ok:
+        why = (err or out or "no output").strip().splitlines()
+        return "", (f"npm cannot resolve the dependency tree, even with --legacy-peer-deps "
+                    f"({why[0][:120] if why else ''}). Fix: commit a package-lock.json for {root.name}/")
+    ok, out, err = run(["npm", "audit", "--json"], cwd=scratch)
+    return out, err
+
+
 def audit_answered(out: str) -> bool:
     """Plan 11 H3: did the auditor return a result? Not JSON, or npm's {"error": …}
     (no lockfile, no network), is no answer, so it must not read as "nothing found"."""
@@ -948,6 +1021,18 @@ def log_chunks(text: str) -> list:
         chunks.append(cur)
     return chunks
 
+# The running Pipeline (set by run_main with --task). Owner: Pipelines showed nothing while a
+# scan ran, so each step also sends one line as it starts and ends; the full report follows at the end.
+# Progress lines are fixed status text: never raw tool output or an error body (it can carry
+# secrets or text an attacker wrote). Those stay on local stderr and in the masked report.
+PIPE = None
+
+
+def progress(text: str) -> None:
+    if PIPE:
+        PIPE.log(text)
+
+
 
 class Pipeline:
     def __init__(self, stage, task, team, base_url, token):
@@ -988,6 +1073,11 @@ class Pipeline:
         self._post("pipeline-events", {"task": self.task, "stage": self.stage, "status": "running",
                                        "run": PIPE_RUN, "source": "laptop", "actor": f"ikanban-{self.stage}"})
 
+    def log(self, line):
+        """One progress line, sent as it happens (masked like the report). A failure only turns Pipelines off."""
+        self._post("pipeline-logs", {"task": self.task, "run": PIPE_RUN, "stage": self.stage,
+                                     "text": mask_report(line.rstrip("\n"))[:PIPE_CHUNK - 1] + "\n"})
+
     def finish(self, code):
         status = "failed" if code else ("skipped" if LAST_RUN["skipped"] else "passed")
         detail = LAST_RUN["detail"] or ("the scan stopped with an error" if code == 2 else "")
@@ -1014,6 +1104,8 @@ def run_main(stage, main_fn, argv=None):
     known, _ = pre.parse_known_args(raw)
     pl = Pipeline(stage, known.task, known.task_team or known.team, known.base_url, known.token)
     pl.start()
+    global PIPE
+    PIPE = pl if pl.on else None
     try:
         code = main_fn(argv)
     except SystemExit as e:
@@ -1080,17 +1172,28 @@ def main(argv=None):
     except ValueError as e:
         print(f"error: {e}", file=sys.stderr)
         return 2
+    work = scan_work_dir("secscan", root, args.work_dir)
+    progress(f"secscan {SECSCAN_VERSION} · {root.name}")
+
+    def step(label, fn, *a):
+        progress(f"{label} …")
+        sec = fn(*a)
+        note = f"{len(sec.findings)} findings" if sec.ran else "SKIPPED"
+        progress(f"{label} … {note}" + (f" ({'; '.join(sec.ran)})" if sec.ran else "")
+                 + (f"; {len(sec.skipped)} skipped" if sec.skipped else ""))
+        return sec
+
     app_sections = []
     for path, name in app_maps:
-        sec = audit_dependencies(path)
-        sec.name = f"Dependency vulnerabilities — {path.relative_to(root) or '.'} ({name})"
+        rel = path.relative_to(root) or "."
+        sec = step(f"dependency audit in {rel}/", audit_dependencies, path, work)
+        sec.name = f"Dependency vulnerabilities — {rel} ({name})"
         app_sections.append((name, sec))
 
-    sections = [audit_dependencies(root), *(s for _, s in app_sections),
-                scan_secrets(root), scan_permissions(root)]
+    sections = [step("dependency audit in ./", audit_dependencies, root, work), *(s for _, s in app_sections),
+                step("committed secrets", scan_secrets, root), step("risky file permissions", scan_permissions, root)]
     md, counts, total = build_report(root, sections)
     LAST_RUN.update(report=md, detail=summary_detail(counts, total, []), skipped=False)
-    work = scan_work_dir("secscan", root, args.work_dir)
     write_private(work / "report.md", md)
 
     if args.out: