agentpipe-scan 0.5.0__py3-none-any.whl

agentpipe/__init__.py

@@ -0,0 +1,11 @@
+"""agentpipe — scan agentic CI for untrusted-text -> agent -> secret chains."""
+# Single source of truth is pyproject; read from installed metadata so
+# `agentpipe --version` never drifts from the released package.
+try:
+    from importlib.metadata import PackageNotFoundError, version as _v
+    try:
+        __version__ = _v("agentpipe-scan")
+    except PackageNotFoundError:
+        __version__ = "0.0.0+source"
+except Exception:  # pragma: no cover
+    __version__ = "0.0.0+source"

agentpipe/cli.py

@@ -0,0 +1,164 @@
+"""agentpipe — untrusted GitHub text → CI agent → secret/write."""
+from __future__ import annotations
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__
+from . import prove, remote, local
+from .detect import scan_tree
+from .report import render
+
+
+def _resolve(target: str, token: str | None) -> tuple[Path, str] | None:
+    """Local path or remote repo → (root, label). Prints errors, None on fail."""
+    if remote.is_remote_target(target):
+        try:
+            root, ref = remote.fetch_repo(target, token=token)
+        except remote.RemoteError as e:
+            print(f"agentpipe: {e}", file=sys.stderr)
+            return None
+        print(f"agentpipe: remote scan {ref} — public files only", file=sys.stderr)
+        return root, target
+    root = Path(target)
+    if not root.exists():
+        print(f"agentpipe: {root} not found "
+              f"(for remote: agentpipe scan github.com/owner/repo)", file=sys.stderr)
+        return None
+    return root, target
+
+
+def _scan_one(root: Path) -> tuple[list, list[str]]:
+    errors: list[str] = []
+    findings = scan_tree(root, errors=errors)
+    for e in errors:
+        print(f"agentpipe: warning: {e}", file=sys.stderr)
+    return findings, errors
+
+
+def _fail_code(findings, fail_on: str) -> int:
+    highs = any(f.severity == "high" for f in findings)
+    meds = any(f.severity == "medium" for f in findings)
+    if fail_on == "high" and highs:
+        return 1
+    if fail_on == "medium" and (highs or meds):
+        return 1
+    return 0
+
+
+def _scan_org(target: str, token: str | None, max_repos: int,
+              json_out: bool) -> int:
+    org = remote.org_name(target)
+    try:
+        repos = remote.list_org_repos(org, token=token, max_repos=max_repos)
+    except remote.RemoteError as e:
+        print(f"agentpipe: {e}", file=sys.stderr)
+        return 2
+    print(f"agentpipe: org {org} — {len(repos)} public repos queued",
+          file=sys.stderr)
+    agg: dict[str, list] = {}
+    any_high = False
+    for full in repos:
+        try:
+            root, ref = remote.fetch_repo(f"github.com/{full}", token=token)
+        except remote.RemoteError as e:
+            print(f"agentpipe: {full}: {e}", file=sys.stderr)
+            continue
+        findings, _err = _scan_one(root)
+        agg[full] = findings
+        sev = [f for f in findings if f.severity]
+        if sev:
+            h = sum(1 for f in sev if f.severity == "high")
+            m = sum(1 for f in sev if f.severity == "medium")
+            any_high = any_high or h > 0
+            print(f"  {full}: {h} high {m} medium "
+                  f"({', '.join(sorted({f.id for f in sev}))})", file=sys.stderr)
+    if json_out:
+        print(json.dumps({r: [f.to_dict() for f in fs] for r, fs in agg.items()},
+                         indent=2))
+    else:
+        print(f"\n== {org} org scan ==")
+        for full, fs in agg.items():
+            sev = [f for f in fs if f.severity]
+            if not sev:
+                continue
+            print(f"\n### {full}")
+            print(render(sev + [f for f in fs if not f.severity]))
+    return 1 if any_high else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    p = argparse.ArgumentParser(
+        prog="agentpipe",
+        description="Find CI agents that eat untrusted GitHub events and hold keys.")
+    p.add_argument("--version", action="version", version=f"agentpipe {__version__}")
+    sub = p.add_subparsers(dest="cmd")
+    sc = sub.add_parser("scan", help="scan a repo, github.com/owner/repo or github.com/org")
+    sc.add_argument("path", nargs="?", default=".")
+    sc.add_argument("--json", action="store_true")
+    sc.add_argument("--token", default=None,
+                    help="GitHub token for remote scan (or GITHUB_TOKEN/GH_TOKEN env)")
+    sc.add_argument("--max-repos", type=int, default=50,
+                    help="org scan: cap on repos fetched")
+    sc.add_argument("--fail-on", default="high",
+                    choices=["never", "high", "medium"],
+                    help="exit 1 if findings at this severity exist")
+    pv = sub.add_parser("prove", help="generate a harmless canary kit for each finding")
+    pv.add_argument("path", nargs="?", default=".")
+    pv.add_argument("--token", default=None)
+    pv.add_argument("--json", action="store_true")
+    lc = sub.add_parser("local", help="audit agent configs on this machine (MCP, permissions, hooks)")
+    lc.add_argument("--root", default=None,
+                    help="home dir to audit (default: your $HOME)")
+    lc.add_argument("--cwd", default=".",
+                    help="project dir to audit (default: .)")
+    lc.add_argument("--json", action="store_true")
+    args = p.parse_args(sys.argv[1:] if argv is None else argv)
+    if args.cmd not in ("scan", "prove", "local"):
+        p.print_help()
+        return 2
+
+    if args.cmd == "local":
+        root = Path(args.root).expanduser() if args.root else Path.home()
+        cwd = Path(args.cwd).resolve()
+        errors: list[str] = []
+        findings = local.scan_local(root, cwd, errors=errors)
+        for e in errors:
+            print(f"agentpipe: warning: {e}", file=sys.stderr)
+        if args.json:
+            print(json.dumps([f.to_dict() for f in findings], indent=2))
+        else:
+            print(render(findings))
+        return _fail_code(findings, "high")
+
+    if args.cmd == "prove":
+        r = _resolve(args.path, args.token)
+        if r is None:
+            return 2
+        root, label = r
+        findings, _ = _scan_one(root)
+        if args.json:
+            print(json.dumps([prove.build(f) for f in findings
+                              if f.severity in ("high", "medium")], indent=2))
+        else:
+            print(prove.render_kit(findings, label))
+        return 0
+
+    if remote.is_org_target(args.path) and not remote.is_remote_target(args.path):
+        return _scan_org(args.path, args.token, args.max_repos, args.json)
+
+    r = _resolve(args.path, args.token)
+    if r is None:
+        return 2
+    root, _label = r
+    findings, _ = _scan_one(root)
+    if args.json:
+        print(json.dumps([f.to_dict() for f in findings], indent=2))
+    else:
+        print(render(findings))
+    return _fail_code(findings, args.fail_on)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())