stacktrace-cli 0.5.3__py3-none-any.whl → 0.6.1__py3-none-any.whl

stacktrace_cli/__init__.py

@@ -2,7 +2,7 @@
 
 import logging as _logging
 
-__version__ = "0.5.3"
+__version__ = "0.6.1"
 
 # Only the daemon attaches a handler (ADR-0048). Without this one, a WARNING
 # logged in any other process would reach Python's last-resort handler and

stacktrace_cli/analysis.py

@@ -348,32 +348,6 @@ def _acquire(
     )
 
 
-def _correlated(
-    *,
-    agent_kinds: tuple[str, ...],
-    window_start: datetime,
-    bom_paths: tuple[Path, ...],
-    project_map: tuple[str, ...],
-    root: Path | None,
-    session_ids: tuple[str, ...],
-    attach_advisories: Any,
-    build_all: Any = None,
-) -> Acquired:
-    """Everything up to the judging, shared by both entry points."""
-    return _acquire(
-        _collected(
-            agent_kinds=agent_kinds,
-            window_start=window_start,
-            root=root,
-            session_ids=session_ids,
-        ),
-        bom_paths=bom_paths,
-        project_map=project_map,
-        attach_advisories=attach_advisories,
-        build_all=build_all,
-    )
-
-
 def _reaches(detection: Any, window_start: datetime, window_end: datetime) -> bool:
     """Whether this finding's own span overlaps the window.
 
@@ -482,6 +456,7 @@ def analyse_progressively(
     history: DriftHistory | None = None,
     reasoning: bool = False,
     budget: int = DEFAULT_BUDGET,
+    exclude_from_reasoning: frozenset[tuple[str, str]] = frozenset(),
 ) -> Iterator[Analysis]:
     """The same pipeline, delivered in instalments.
 
@@ -634,12 +609,20 @@ def analyse_progressively(
     if not reasoning or not ordered:
         return
 
-    # One more instalment, one run, one budget. Everything above has already
-    # been published, so the page is complete and readable while this is in
-    # flight — on a large window it is several hundred sequential requests and
-    # holding the first paint behind it is what made the page look hung.
+    excluded_count = 0
+    if exclude_from_reasoning:
+        kept = tuple(
+            s
+            for s in view.sessions
+            if (s.session.session_id, s.session.agent_kind) not in exclude_from_reasoning
+        )
+        excluded_count = len(view.sessions) - len(kept)
+        reasoning_view = replace(view, sessions=kept) if excluded_count else view
+    else:
+        reasoning_view = view
+
     judged = run_detector(
-        view,
+        reasoning_view,
         reasoning=True,
         budget=budget,
         cache=cache,
@@ -647,4 +630,23 @@ def analyse_progressively(
         jev_key=jev_key,
         history=history,
     )
+
+    if excluded_count:
+        extra_detections = tuple(
+            d
+            for d in accumulated.detections
+            if (d.session.session_id, d.session.agent_kind) in exclude_from_reasoning
+        )
+        extra_unknowns = tuple(
+            u
+            for u in accumulated.unknowns
+            if (u.session.session_id, u.session.agent_kind) in exclude_from_reasoning
+        )
+        judged = replace(
+            judged,
+            detections=judged.detections + extra_detections,
+            unknowns=judged.unknowns + extra_unknowns,
+            sessions=judged.sessions + excluded_count,
+        )
+
     yield _stage(judged, tuple(ordered))

stacktrace_cli/cli.py

@@ -539,6 +539,11 @@ def monitor(
     Loopback only, and free to leave open: a pass is skipped when nothing has
     changed, advisory lookups are asked once per component, and the two stages
     that need no model are the only ones that run.
+
+    The Inventory and Vulnerabilities tabs list every component your agents can
+    load. To check them for known vulnerabilities, the package names of
+    installed components -- not only the ones a session used -- are sent to
+    osv.dev. Skills and plugins with no package are never sent.
     """
     analyzer = resolve_analyzer(analyzer, reasoning)
     try:

stacktrace_cli/cloud/__init__.py

@@ -12,6 +12,16 @@ CLI and runs this:
       uv tool install stacktrace-cli
     stacktrace-cloud-setup
 
+Or, equivalently, one hosted line that wraps exactly those two steps (see
+`stacktrace-site`'s `public/remote-install.sh`). Download before running rather
+than piping directly into `sh`: without `pipefail` (the default in the `sh`
+that a setup-script box runs), a failed `curl` still lets `sh` read an empty
+script and exit 0, so a broken download would otherwise snapshot an
+environment with neither the CLI nor the boot hook and report success:
+
+    curl -fsSL https://stacktrace.ai/remote-install.sh -o /tmp/remote-install.sh \
+      && sh /tmp/remote-install.sh
+
 Both variables matter: setup runs as root, and `uv tool install`'s root
 defaults put the tool's environment under `/root/.local/share/uv/tools` and the
 linked executable under `/root/.local/bin` — both inside `/root`, which a later

stacktrace_cli/cloud/setup.sh

@@ -10,7 +10,10 @@
 #      every home so it fires whichever user the session runs as.
 #   2. The asset identity, in every home's ~/.config/stacktrace/asset-id, so
 #      `stacktrace remote sync` resolves it at the persisted rung (ADR-0065)
-#      instead of minting a fresh asset per session.
+#      instead of minting a fresh asset per session. Beside it,
+#      asset-display-prefix makes the fleet label `cloud (<id>)` rather than
+#      the image's hostname (`vm`), which is the same on every box. Label
+#      only: the key above is what identifies the asset.
 #
 # The telemetry install id is deliberately NOT seeded here. Seeding it would
 # make `read_install_id()` non-None before any event runs, so the one-time
@@ -59,7 +62,7 @@ while [ $# -gt 0 ]; do
     # the loop spins forever — a malformed invocation would hang setup.
     --asset-id) [ $# -ge 2 ] || { echo "✗ --asset-id needs a value" >&2; exit 2; }; ASSET_ID="$2"; shift 2 ;;
     --root) [ $# -ge 2 ] || { echo "✗ --root needs a value" >&2; exit 2; }; ROOT="$2"; shift 2 ;;
-    -h|--help) sed -n '2,49p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
+    -h|--help) sed -n '2,52p' "$0" | sed 's/^# \{0,1\}//'; exit 0 ;;
     *) echo "✗ unknown argument: $1" >&2; exit 2 ;;
   esac
 done
@@ -78,6 +81,7 @@ _uuid() {
   fi
 }
 
+DISPLAY_PREFIX="cloud"
 [ -n "$ASSET_ID" ] || ASSET_ID="cloud-$(_uuid)"
 # remote/identity.py:_is_identifier rejects whitespace, non-printable
 # characters, and anything over 255 characters. A value this accepts but the
@@ -146,8 +150,12 @@ fi
 
 # Streams redirected because own_std_streams only re-points fd 1/2 on log
 # rollover; without this the daemon inherits the hook's pipe to Claude Code.
+# --no-reasoning is explicit, not just `run`'s own default (ADR-0081): this
+# hook never provisions TYPESAFE_API_KEY itself, but a cloud VM's ambient
+# environment is not something this script controls or can audit ahead of
+# time, and this surface has nobody present to notice if that changed.
 if ! stacktrace daemon status 2>/dev/null | grep -q '^running: yes'; then
-  setsid nohup stacktrace daemon run </dev/null >>"$STATE/daemon.log" 2>&1 &
+  setsid nohup stacktrace daemon run --no-reasoning </dev/null >>"$STATE/daemon.log" 2>&1 &
 fi
 exit 0
 BOOTSCRIPT
@@ -176,6 +184,11 @@ for home in "${ROOT}"/root "${ROOT}"/home/*; do
   fi
   chmod 600 "$cfg/asset-id" 2>/dev/null || true
 
+  if ! printf '%s\n' "$DISPLAY_PREFIX" > "$cfg/asset-display-prefix" 2>/dev/null; then
+    echo "✗ cannot write $cfg/asset-display-prefix — not seeding $home" >&2; failed=1; continue
+  fi
+  chmod 600 "$cfg/asset-display-prefix" 2>/dev/null || true
+
   # Register the SessionStart hook, merging so any existing settings survive.
   # The hook is the point of seeding a home — a home whose registration fails
   # (an unwritable path, or a settings.json that is valid JSON of an unexpected
@@ -248,7 +261,7 @@ PY
   for d in "$home/.config" "$cfg" "$home/.claude"; do
     [ -e "$d" ] && chown --reference="$home" "$d" 2>/dev/null || true
   done
-  chown --reference="$home" "$cfg/asset-id" \
+  chown --reference="$home" "$cfg/asset-id" "$cfg/asset-display-prefix" \
     "$home/.claude/settings.json" 2>/dev/null || true
 
   echo "✓ seeded $home"

stacktrace_cli/correlate/acquire.py

@@ -316,10 +316,32 @@ class Built:
     document: dict[str, Any]
 
 
+#: What an advisory answer is about: one component at one version. The
+#: `openaca:identity` this codebase assigns does not encode a version, so it is
+#: paired with the version the component declares. Keyed by identity alone, one
+#: scan kept one version per identity and handed its advisories to every
+#: version of that component in the run.
+AdvisoryKey = tuple[str, "str | None"]
+
+
+def advisory_key(component: dict[str, Any]) -> AdvisoryKey | None:
+    """A raw BOM component's `(identity, version)`, or None with no identity.
+
+    Read off the document, where `Component` reads the same two fields through
+    OpenACA's projection; `test_advisory_keys_read_the_same_off_both` holds the
+    two equal, since a key that differed would match nothing and read clean.
+    """
+    identity = _identity_of(component)
+    if identity is None:
+        return None
+    version = component.get("version")
+    return identity, version if isinstance(version, str) else None
+
+
 def advisories_for(
-    documents: Sequence[dict[str, Any]], identities: AbstractSet[str]
-) -> dict[str, tuple[Advisory, ...]] | None:
-    """Advisories for these identities alone, keyed by `openaca:identity`.
+    documents: Sequence[dict[str, Any]], keys: AbstractSet[AdvisoryKey]
+) -> dict[AdvisoryKey, tuple[Advisory, ...]] | None:
+    """Advisories for these components alone, keyed by `(identity, version)`.
 
     **Asked after correlation, not during acquisition.** Advisory matching costs
     a network round trip to osv.dev per package coordinate, and acquisition does
@@ -332,61 +354,62 @@ def advisories_for(
     there: one scan, over the union of what ran. Same measurement, 0.66s to
     0.14s, and osv.dev learns only about components this machine actually used.
 
-    Keyed by identity rather than `bom-ref` because a ref is local to one
-    document while an identity is the coordinate OSV matched — which is what lets
-    one scan answer for every composition in the run.
+    Keyed by `(identity, version)` rather than `bom-ref` because a ref is local
+    to one document while the pair is what OSV matched — which is what lets one
+    scan answer for every composition in the run, and each version for itself.
 
     Returns None when the scan could not run. None is not an empty result: a
     composition that was never checked must not read as one with nothing found.
     """
-    if not identities:
+    if not keys:
         # Nothing ran that could carry an advisory. That is a checked result with
         # nothing in it, not a failure to look, so it is `{}` rather than None.
         return {}
-    merged = _merge_for_scan(documents, identities)
+    merged, key_by_ref = _merge_for_scan(documents, keys)
     if not merged["components"]:
         return {}
     with tempfile.TemporaryDirectory() as scratch:
         path = Path(scratch) / "invoked.cdx.json"
         path.write_text(json.dumps(merged), encoding="utf-8")
-        return _scan(path, _identity_by_ref(merged))
+        return _scan(path, key_by_ref)
 
 
 def _merge_for_scan(
-    documents: Sequence[dict[str, Any]], identities: AbstractSet[str]
-) -> dict[str, Any]:
-    """One document holding each invoked component once, and nothing else.
-
-    Deduplicated on identity: the same component appears in every composition
-    built, and scanning it once per appearance is what this function exists to
-    avoid. `dependencies` is dropped rather than filtered — it describes
+    documents: Sequence[dict[str, Any]], keys: AbstractSet[AdvisoryKey]
+) -> tuple[dict[str, Any], dict[str, AdvisoryKey]]:
+    """One document holding each wanted component once, and which key each ref is.
+
+    Deduplicated on `(identity, version)`: the same component appears in every
+    composition built, and scanning it once per appearance is what this
+    function exists to avoid -- while two versions of one identity are two
+    components, each scanned for itself. `dependencies` is dropped rather than filtered — it describes
     installation structure that advisory matching does not read, and a pruned
     graph would be a second, worse description of one already recorded in the
     compositions themselves.
 
-    **Every kept component's `bom-ref` is rewritten to its identity.** The
-    CycloneDX spec scopes `bom-ref` uniqueness to a single document, never
-    across documents, so two source BOMs are free to reuse the same local ref
-    for two different components. Carrying an original ref forward into the
-    merged document could then collide, and `_identity_by_ref` would collapse
-    the collision onto whichever identity it saw last — misattributing that
-    ref's advisories to the wrong component. Identity is already this dict's
-    own key, so it is already unique across every document being merged.
+    **Every kept component's `bom-ref` is rewritten, and the new ref maps back
+    to its key.** The CycloneDX spec scopes `bom-ref` uniqueness to a single
+    document, never across documents, so two source BOMs are free to reuse the
+    same local ref for two different components. Carrying an original ref
+    forward into the merged document could then collide and misattribute that
+    ref's advisories to the wrong component. A ref minted here per kept key is
+    unique across every document being merged by construction.
     """
     base = documents[0] if documents else {}
-    kept: dict[str, dict[str, Any]] = {}
+    kept: dict[AdvisoryKey, dict[str, Any]] = {}
     for document in documents:
         for component in document.get("components") or []:
-            identity = _identity_of(component)
-            if identity is not None and identity in identities and identity not in kept:
-                kept[identity] = {**component, "bom-ref": identity}
-    return {
+            key = advisory_key(component)
+            if key is not None and key in keys and key not in kept:
+                kept[key] = {**component, "bom-ref": f"scan-{len(kept)}"}
+    merged = {
         "bomFormat": base.get("bomFormat", "CycloneDX"),
         "specVersion": base.get("specVersion", "1.6"),
         "version": base.get("version", 1),
         "metadata": base.get("metadata", {}),
         "components": list(kept.values()),
     }
+    return merged, {component["bom-ref"]: key for key, component in kept.items()}
 
 
 def _identity_of(component: dict[str, Any]) -> str | None:
@@ -397,40 +420,10 @@ def _identity_of(component: dict[str, Any]) -> str | None:
     return None
 
 
-def identity_versions(
-    documents: Sequence[dict[str, Any]], identities: AbstractSet[str]
-) -> dict[str, str | None]:
-    """Each wanted identity's own declared version, the first time it is found.
-
-    The identity this codebase assigns does not encode a version — that is
-    what lets one scan answer for a component across every composition it
-    appears in — so a cache keyed on identity alone cannot tell an upgrade
-    from no change at all. Pairing identity with this lets a long-lived
-    lookup cache do that.
-    """
-    versions: dict[str, str | None] = {}
-    for document in documents:
-        for component in document.get("components") or []:
-            identity = _identity_of(component)
-            if identity is None or identity not in identities or identity in versions:
-                continue
-            version = component.get("version")
-            versions[identity] = version if isinstance(version, str) else None
-    return versions
-
-
-def _identity_by_ref(document: dict[str, Any]) -> dict[str, str]:
-    return {
-        str(component["bom-ref"]): identity
-        for component in document.get("components") or []
-        if component.get("bom-ref") and (identity := _identity_of(component))
-    }
-
-
 def _scan(
-    bom_path: Path, identity_by_ref: dict[str, str]
-) -> dict[str, tuple[Advisory, ...]] | None:
-    """Run `openaca scan bom` and re-key its findings from refs onto identities.
+    bom_path: Path, key_by_ref: dict[str, AdvisoryKey]
+) -> dict[AdvisoryKey, tuple[Advisory, ...]] | None:
+    """Run `openaca scan bom` and re-key its findings from refs onto keys.
 
     `scan bom` is used rather than `scan endpoint` because it is a pure function
     of a document we already hold, so nothing can drift between the composition
@@ -483,7 +476,7 @@ def _scan(
     if not isinstance(findings, list):
         return None
 
-    matched: dict[str, list[Advisory]] = {}
+    matched: dict[AdvisoryKey, list[Advisory]] = {}
     for finding in findings:
         if not isinstance(finding, dict):
             return None
@@ -505,13 +498,13 @@ def _scan(
             return None
         if not all(_text_or_absent(value) for value in (fixed_in, source, severity, title)):
             return None
-        identity = identity_by_ref.get(ref)
-        if identity is None:
+        key = key_by_ref.get(ref)
+        if key is None:
             # Not malformed: we sent the components, and a ref we do not hold is
             # a finding about something outside this scan rather than a response
             # we cannot read.
             continue
-        matched.setdefault(identity, []).append(
+        matched.setdefault(key, []).append(
             Advisory(
                 id=identifier,
                 severity=severity or "UNKNOWN",
@@ -520,7 +513,7 @@ def _scan(
                 source=source,
             )
         )
-    return {identity: tuple(items) for identity, items in matched.items()}
+    return {key: tuple(items) for key, items in matched.items()}
 
 
 def _text_or_absent(value: object) -> bool:

stacktrace_cli/correlate/composition.py

@@ -152,10 +152,10 @@ def composition_from_bom(
     generated_at: datetime,
     generated_at_is_observed: bool,
     #: Keyed by **bom-ref**, matching `Composition.advisories`. Note that
-    #: `acquire.advisories_for` returns an *identity*-keyed map — one scan can
-    #: answer for every composition that way — so a caller re-keys before
-    #: arriving here, as `_attach_advisories` does. Passing the identity-keyed
-    #: map straight through would silently match nothing.
+    #: `acquire.advisories_for` returns an `(identity, version)`-keyed map — one
+    #: scan can answer for every composition that way — so a caller re-keys
+    #: before arriving here, as `_attach_advisories` does. Passing that map
+    #: straight through would silently match nothing.
     advisories: dict[str, tuple[Advisory, ...]] | None = None,
 ) -> Composition:
     """Project a CycloneDX Agent BOM into a composition, or reject it."""

stacktrace_cli/correlate/observed.py

@@ -1381,9 +1381,13 @@ _SEPARATORS = ("&&", "||", ";", "|", "\n")
 _WORD_START_BEFORE_COMMENT = frozenset(" \t\n;&|<>()")
 
 
-def _split_on_separators(command: str) -> list[str]:
+def _split_on_separators(command: str) -> list[tuple[str, str | None]]:
     """The commands in a shell line, split only where the shell would split it.
 
+    Returns ``(segment_text, preceding_operator)`` pairs.  The first segment's
+    operator is ``None``; every later segment carries the ``&&``, ``||``, ``;``,
+    ``|`` or ``\\n`` that separated it from the one before it.
+
     A control operator is an operator **only unquoted and unescaped** — that is
     the shell's own grammar, and it is verified against `bash` itself in
     `tests/test_shell_separators_match_the_shell.py` rather than asserted here.
@@ -1420,10 +1424,11 @@ def _split_on_separators(command: str) -> list[str]:
     left in, `shlex` hands the caller a bare newline where the next word should
     be, and `git \\<newline> push` loses its subcommand to it.
     """
-    parts: list[str] = []
+    parts: list[tuple[str, str | None]] = []
     current: list[str] = []
     index = 0
     quote: str | None = None
+    preceding_op: str | None = None
     #: Whether a `#` here would open a comment. True at the start of the string
     #: and after anything that ends a word; false after any character a word is
     #: made of, quotes included -- `echo "a"#b` prints `a#b`.
@@ -1475,11 +1480,20 @@ def _split_on_separators(command: str) -> list[str]:
             index += 1
             at_word_start = char in _WORD_START_BEFORE_COMMENT
             continue
-        parts.append("".join(current))
+        segment_text = "".join(current)
+        if segment_text.strip():
+            parts.append((segment_text, preceding_op))
+            preceding_op = separator
+        else:
+            # Two separators with nothing between them (e.g. "&&\n"):
+            # keep the conditional operator over a plain terminator so
+            # the next real segment inherits the right dependency.
+            if separator in ("&&", "||") or preceding_op is None:
+                preceding_op = separator
         current = []
         index += len(separator)
         at_word_start = True
-    parts.append("".join(current))
+    parts.append(("".join(current), preceding_op))
     return parts
 
 
@@ -1521,7 +1535,7 @@ def _segments_of(text: str, depth: int) -> tuple[tuple[str, tuple[str, ...]], ..
     `command_segments` would run the masks a second time on their own output.
     """
     found: list[tuple[str, tuple[str, ...]]] = []
-    for part in _split_on_separators(text):
+    for part, _op in _split_on_separators(text):
         # Comments are gone: `_split_on_separators` discards one at the word
         # start that opens it, which is the only place the shell begins one.
         # This used to skip a segment *beginning* with `#`, which caught the
@@ -1567,6 +1581,48 @@ def _segments_of(text: str, depth: int) -> tuple[tuple[str, tuple[str, ...]], ..
     return tuple(found)
 
 
+def command_segments_with_ops(
+    command: object, depth: int = 0
+) -> tuple[tuple[str, tuple[str, ...], str | None], ...]:
+    """Like `command_segments`, but each entry also carries the shell operator
+    that preceded it (``None`` for the first segment, then ``&&``, ``||``,
+    ``;``, ``|`` or ``\\n``).
+
+    Only `_resolve_rm_targets` in the deterministic detector needs the operator
+    context — to decide whether an inline ``cd`` reliably changed the directory
+    and whether an ``rm`` segment is unconditionally reachable.  Every other
+    caller uses the plain `command_segments`, which discards the operator.
+    """
+    if not isinstance(command, str) or not command:
+        return ()
+    text = _readable_commands(command, depth)
+    found: list[tuple[str, tuple[str, ...], str | None]] = []
+    for part, preceding_op in _split_on_separators(text):
+        part = part.strip()
+        if not part:
+            continue
+        try:
+            tokens = shlex.split(part)
+        except ValueError:
+            continue
+        while tokens and (_ASSIGNMENT.match(tokens[0]) or tokens[0] in _NOT_A_BINARY):
+            if tokens.pop(0) == "time":
+                while tokens and tokens[0] in _TIME_OPTIONS:
+                    tokens.pop(0)
+        if not tokens:
+            continue
+        head = tokens[0].rsplit("/", 1)[-1]
+        if not head or all(char in _OPERATOR_CHARS for char in head):
+            continue
+        arguments = tuple(tokens[1:])
+        found.append((head, arguments, preceding_op))
+        if head in _SHELLS and depth < _MAX_SHELL_DEPTH:
+            body = _shell_command_body(arguments)
+            if body is not None:
+                found.extend(command_segments_with_ops(body, depth + 1))
+    return tuple(found)
+
+
 def redirect_targets(command: object) -> tuple[str, ...]:
     """Files a shell command redirects its output into.
 
@@ -1604,7 +1660,7 @@ def redirect_targets(command: object) -> tuple[str, ...]:
     # body, an arithmetic comparison, a `case` frame or the body of a function
     # nothing called is not a redirection, and each was named as a file before
     # its mask existed.
-    for part in _split_on_separators(_readable_commands(command, 0)):
+    for part, _op in _split_on_separators(_readable_commands(command, 0)):
         part = part.strip()
         if not part:
             continue