stacktrace-cli 0.12.0__py3-none-any.whl → 0.14.0__py3-none-any.whl

stacktrace/__init__.py

@@ -2,7 +2,7 @@
 
 import logging as _logging
 
-__version__ = "0.12.0"
+__version__ = "0.14.0"
 
 # 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.py

@@ -17,7 +17,6 @@ from __future__ import annotations
 
 import re
 from datetime import UTC, datetime, timedelta
-from importlib.metadata import version
 from pathlib import Path
 from typing import Final
 
@@ -120,7 +119,7 @@ def _show_version(ctx: click.Context, param: click.Parameter, value: bool) -> No
         return
     # A build from a branch or PR reports its commit as a PEP 440 local label,
     # `0.4.0+86eef86`; a release install prints the bare version.
-    click.echo(f"stacktrace {version_label()} (openaca {version('openaca')})")
+    click.echo(f"stacktrace {version_label()}")
     ctx.exit()
 
 
@@ -195,11 +194,11 @@ class SectionedGroup(click.Group):
             raise
         except (click.exceptions.Exit, click.ClickException) as error:
             cause = error.__cause__
-            if cause is not None and ctx.invoked_subcommand not in UNCOUNTED:
+            if cause is not None and not _uncounted(ctx):
                 emit_error(cause, "cli")
             raise
         except Exception as error:
-            if ctx.invoked_subcommand not in UNCOUNTED:
+            if not _uncounted(ctx):
                 emit_error(error, "cli")
             raise
         _count_run(ctx)
@@ -232,9 +231,15 @@ class SectionedGroup(click.Group):
                 formatter.write_dl(rows)
 
 
+def _uncounted(ctx: click.Context) -> bool:
+    # An internal synchronous native hook is not a developer command and must
+    # never initialize an analytics client on the action path (ADR-0131).
+    return ctx.invoked_subcommand in UNCOUNTED or ctx.meta.get("internal_admission") is True
+
+
 def _count_run(ctx: click.Context) -> None:
     name = ctx.invoked_subcommand
-    if name not in UNCOUNTED:
+    if not _uncounted(ctx):
         emit("command_run", command=command_of(name))
 
 
@@ -245,7 +250,7 @@ def _count_run(ctx: click.Context) -> None:
     expose_value=False,
     is_eager=True,
     callback=_show_version,
-    help="Show the stacktrace and OpenACA versions (and build commit) and exit.",
+    help="Show the stacktrace version (and build commit) and exit.",
 )
 def main() -> None:
     """Stacktrace: agent composition analysis, detection and upload."""
@@ -431,8 +436,9 @@ def detect(
     One network call is made on every run, and it is not the detector's:
     correlation matches advisories by sending the package coordinates of the
     components a session invoked to osv.dev. Coordinates only, so this is not
-    an offline run, and without stage three it is the only thing that leaves
-    this machine.
+    an offline run, and without stage three it is the only thing detection
+    sends. Usage telemetry, on by default, is separate and carries no session
+    content (ADR-0039); `stacktrace telemetry show` prints all of it.
     """
     analyzer = resolve_analyzer(analyzer, reasoning)
     try:

stacktrace/cloud/__init__.py

@@ -1,38 +1,10 @@
-"""One entry point for a Claude Code cloud environment's setup script.
-
-A cloud environment's setup script runs once, as root, before the filesystem is
-snapshotted and reused by every later session. What a session needs that is not
-the CLI itself — the per-session boot hook, the asset identity, and how the hook
-updates the CLI to the latest release (ADR-0123) — has to be laid down there so
-it lands inside the snapshot.
-
-Rather than paste that into the setup-script box, a setup script installs the
-CLI and runs this:
-
-    UV_TOOL_DIR=/usr/local/share/uv-tools UV_TOOL_BIN_DIR=/usr/local/bin \
-      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
-non-root session user cannot traverse. `UV_TOOL_BIN_DIR` alone moves the
-symlink but not the environment it points into, so `command -v stacktrace` would
-find the binary while running it still fails; both must move.
-
-The work itself is `setup.sh`, shipped beside this module so it travels in the
-wheel. This shim only locates it and hands off, so the logic stays one auditable
-bash file rather than being reimplemented in Python.
+"""Prepare plugin-owned hooks and asset identity from a remote startup script.
+
+The shared installer calls `stacktrace-cloud-setup --user-profile` as the
+selected user. This prepares identity and update metadata without system
+writes. Legacy provisioning retains asset and update records for existing
+recipes. Agent installation belongs to the shared installer.
+SessionStart restores the daemon after process loss. See ADR-0143.
 """
 
 from __future__ import annotations
@@ -53,6 +25,11 @@ from pathlib import Path
 
 
 def main() -> None:
+    if "--user-profile" in sys.argv[1:]:
+        from stacktrace.cloud.profile import main as prepare_profile
+
+        prepare_profile(sys.argv[1:])
+        return
     script = Path(__file__).with_name("setup.sh")
     # execvp so the process *becomes* bash: its exit status is the setup
     # script's, which is what the environment reads to decide the session may

stacktrace/cloud/boot.py

@@ -0,0 +1,186 @@
+"""Recover the shared daemon on every host (ADR-0143). Remote recovery can
+update the client before startup (ADR-0123). The SessionStart adapter runs
+this worker detached with the state directory and installer update record.
+
+One worker at a time holds `boot.lock`, from its own `daemon status` check
+until the daemon it starts answers. So a worker never replaces the client's
+files while a daemon runs or is starting: a second hook's worker waits, checks
+again, and finds the daemon up.
+"""
+
+import fcntl
+import os
+import pwd
+import shlex
+import subprocess
+import sys
+import time
+from datetime import datetime, timezone
+
+STATE, UPDATE_ENV = "", ""
+#: How long an update may take before the installed client runs instead.
+UPDATE_SECONDS = 120
+#: How long the lock waits for the daemon this worker started to answer.
+START_SECONDS = 30
+
+
+def note(text):
+    with open(os.path.join(STATE, "update.log"), "a", encoding="utf-8") as log:
+        log.write(f"{datetime.now(timezone.utc):%Y-%m-%dT%H:%M:%SZ} {text}\n")  # noqa: UP017 - legacy wrapper uses system Python, including 3.10
+
+
+def running():
+    """What `daemon status` says: yes, no, unresponsive, or "" for no answer."""
+    try:
+        status = subprocess.run(
+            ["stacktrace", "daemon", "status"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+            check=False,
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return ""
+    for line in status.splitlines():
+        if line.startswith("running: "):
+            return line[len("running: ") :].strip()
+    return ""
+
+
+def recorded():
+    """The uv and the UV_* directories setup wrote, as `KEY=value` lines."""
+    try:
+        with open(UPDATE_ENV, encoding="utf-8") as stream:
+            lines = stream.read().splitlines()
+    except OSError:
+        return {}
+    values = {}
+    for line in lines:
+        words = shlex.split(line)
+        if words[:1] == ["export"]:
+            words = words[1:]
+        if len(words) == 1 and "=" in words[0]:
+            key, value = words[0].split("=", 1)
+            values[key] = value
+    return values
+
+
+def update():
+    """Upgrade the tool install setup recorded, as a user who can write it;
+    else say why not. No file: the client is pinned, or setup found no uv."""
+    values = recorded()
+    if not values:
+        return
+    uv = values.get("STACKTRACE_UV", "")
+    directories = [values[key] for key in ("UV_TOOL_DIR", "UV_TOOL_BIN_DIR") if values.get(key)]
+    if not (uv and os.access(uv, os.X_OK)) or not all(os.access(d, os.W_OK) for d in directories):
+        user = pwd.getpwuid(os.getuid()).pw_name
+        note(
+            f"not updating: {user} cannot run uv or write the install; "
+            "rebuild the environment to update the client"
+        )
+        return
+    environment = {**os.environ, **{k: v for k, v in values.items() if k.startswith("UV_")}}
+    with open(os.path.join(STATE, "update.log"), "a", encoding="utf-8") as log:
+        try:
+            subprocess.run(
+                [uv, "tool", "upgrade", "stacktrace-cli"],
+                env=environment,
+                stdin=subprocess.DEVNULL,
+                stdout=log,
+                stderr=subprocess.STDOUT,
+                timeout=UPDATE_SECONDS,
+                check=False,
+            )
+        except (OSError, subprocess.SubprocessError) as error:
+            note(f"update stopped: {type(error).__name__}; the installed client runs")
+
+
+def configure():
+    """Session credentials belong to this user; subscribers fail independently."""
+    commands = []
+    if os.environ.get("STACKTRACE_REMOTE_TOKEN"):
+        # Click reads credentials from the environment, not the process list.
+        commands.append(["stacktrace", "remote", "configure"])
+    webhook = os.environ.get("STACKTRACE_SLACK_WEBHOOK_URL")
+    if webhook:
+        commands.append(
+            [
+                "stacktrace",
+                "webhook",
+                "configure",
+                "--url",
+                webhook,
+                "--secret",
+                os.environ.get("STACKTRACE_WEBHOOK_SECRET", ""),
+            ]
+        )
+    for arguments in commands:
+        try:
+            result = subprocess.run(
+                arguments,
+                stdin=subprocess.DEVNULL,
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                timeout=30,
+                check=False,
+            )
+            if result.returncode:
+                note("session configuration failed; using saved configuration")
+        except (OSError, subprocess.SubprocessError):
+            note("session configuration unavailable; using saved configuration")
+
+
+def ensure_daemon():
+    lock = os.open(os.path.join(STATE, "boot.lock"), os.O_CREAT | os.O_RDWR, 0o600)
+    try:
+        fcntl.flock(lock, fcntl.LOCK_EX)
+        configure()
+        _ensure_daemon()
+    finally:
+        os.close(lock)
+
+
+def _ensure_daemon():
+    answer = running()
+    if answer == "yes":
+        return
+    # Only a status of no daemon lets the update run: `unresponsive` is a
+    # daemon holding its lock that has not answered yet, and an error or no
+    # answer says nothing. Either may be a live client.
+    if answer == "no":
+        if os.environ.get("CLAUDE_CODE_REMOTE") == "true":
+            update()
+    else:
+        note(f"not updating: daemon status said {answer or 'nothing'}, not that no daemon runs")
+    with open(os.path.join(STATE, "daemon.log"), "a", encoding="utf-8") as out:
+        subprocess.Popen(
+            ["stacktrace", "daemon", "start", "--no-reasoning"],
+            stdin=subprocess.DEVNULL,
+            stdout=out,
+            stderr=subprocess.STDOUT,
+            start_new_session=True,
+        )
+    deadline = time.monotonic() + START_SECONDS
+    while time.monotonic() < deadline and running() != "yes":
+        time.sleep(0.5)
+
+
+def main():
+    os.makedirs(STATE, mode=0o700, exist_ok=True)
+    os.chmod(STATE, 0o700)
+    ensure_daemon()
+    if len(sys.argv) > 3:
+        import json
+
+        from stacktrace.hooks.session import register
+
+        register(json.loads(sys.argv[3]))
+
+
+if __name__ == "__main__":
+    STATE, UPDATE_ENV = sys.argv[1], sys.argv[2]
+    try:
+        main()
+    except Exception:  # noqa: BLE001 - never expose native payloads or credentials
+        note("session bootstrap failed; inspect daemon status and rerun setup")

stacktrace/cloud/profile.py

@@ -0,0 +1,71 @@
+"""Prepare remote state as the selected user, without privileged system files."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import shlex
+import shutil
+import tempfile
+import uuid
+from collections.abc import Mapping
+from pathlib import Path
+
+from stacktrace.daemon.paths import RuntimePaths
+from stacktrace.private_state import ensure_private_directory
+
+
+def _write(path: Path, value: str) -> None:
+    descriptor, name = tempfile.mkstemp(dir=path.parent)
+    try:
+        with os.fdopen(descriptor, "w") as stream:
+            stream.write(value)
+        os.replace(name, path)
+    finally:
+        Path(name).unlink(missing_ok=True)
+
+
+def prepare(environment: Mapping[str, str]) -> None:
+    config = Path.home() / ".config" / "stacktrace"
+    ensure_private_directory(config)
+    identity = config / "asset-id"
+    imposed = environment.get("STACKTRACE_ASSET_EXTERNAL_ID", "")
+    if imposed and (
+        len(imposed) > 255 or not imposed.isprintable() or any(c.isspace() for c in imposed)
+    ):
+        raise ValueError(
+            "asset id must contain at most 255 printable characters without whitespace"
+        )
+    if imposed or not identity.exists():
+        _write(identity, (imposed or str(uuid.uuid4())) + "\n")
+    _write(config / "asset-display-prefix", "cloud\n")
+
+    state = RuntimePaths.from_environment().state.parent
+    ensure_private_directory(state)
+    uv = shutil.which("uv")
+    values = {}
+    if uv and environment.get("STACKTRACE_VERSION", "latest") in ("", "latest"):
+        values["STACKTRACE_UV"] = uv
+        for key in (
+            "UV_TOOL_DIR",
+            "UV_TOOL_BIN_DIR",
+            "UV_PYTHON_INSTALL_DIR",
+            "UV_PYTHON_PREFERENCE",
+        ):
+            if environment.get(key):
+                values[key] = environment[key]
+    # Keep an empty record for a pin. Removing it would enable the legacy fallback.
+    _write(
+        state / "install-update.env", "".join(f"{k}={shlex.quote(v)}\n" for k, v in values.items())
+    )
+
+
+def main(arguments: list[str]) -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--user-profile", action="store_true", required=True)
+    parser.add_argument("--asset-id")
+    options = parser.parse_args(arguments)
+    environment = dict(os.environ)
+    if options.asset_id is not None:
+        environment["STACKTRACE_ASSET_EXTERNAL_ID"] = options.asset_id
+    prepare(environment)