repro-cli 0.1.0__tar.gz

repro_cli-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: repro-cli
+Version: 0.1.0
+Summary: Disposable Docker environments for any GitHub issue
+Author: Sukhdev Thukral
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

repro_cli-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name="repro-cli"
+version="0.1.0"
+description = "Disposable Docker environments for any GitHub issue"
+readme="README.md"
+requires-python=">=3.9"
+license = "MIT"
+authors = [
+    {name = "Sukhdev Thukral"}
+]
+
+[project.scripts]
+repro = "repro.cli:main"
+
+[tool.setuptools]
+packages = ["repro", "repro.github", "repro.detector", "repro.docker"]

repro_cli-0.1.0/repro/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

repro_cli-0.1.0/repro/cli.py

@@ -0,0 +1,128 @@
+import sys 
+import argparse
+import os
+
+from repro import __version__
+from repro.github.issue import parse_issue
+from repro.detector.detector import detect_runtime, universal
+from repro.docker.runner import (
+    run_sandbox, DockerNotRunningError, DockerNotFoundError,
+    parse_port_spec, InvalidPortError, InvalidRepoError
+    )
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="repro",
+        description="Disposable Docker environments for GitHub issues.",
+        epilog=(
+            "Examples:\n"
+            "  repro https://github.com/org/repo/issues/42\n"
+            "  repro https://github.com/org/repo/issues/42 -p 3000\n"
+            "  repro https://github.com/org/private-repo/issues/7 --token ghp_xxx\n"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("issue_url", nargs="?", help="GitHub issue URL")
+    parser.add_argument(
+        "-p", "--port",
+        action="append",
+        default=[],
+        metavar="PORT",
+        help="Forward a port from the sandbox to your machine. "
+             "Use PORT for same host/container port, or HOST:CONTAINER to map them."
+             "Can be passed multiple times.",
+    )
+    parser.add_argument(
+        "-t", "--token",
+        default=None,
+        metavar="TOKEN",
+        help="GitHub personal access token, for private repos. "
+             "Falls back to the REPRO_GITHUB_TOKEN env var if not passed.",
+    )
+    parser.add_argument(
+        "-v", "--version",
+        action="version",
+        version=f"repro {__version__}",
+    )
+    return parser
+
+def main():
+
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if not args.issue_url:
+        parser.print_help()
+        return
+
+    if "github.com" not in args.issue_url or "/issues/" not in args.issue_url:
+        print(f'ERROR: Expected a GitHub issue URL, got "{args.issue_url}"')
+        print("Usage: python repro.py <issue-url> [-p PORT ...] [--token TOKEN]")
+        sys.exit(1)
+
+
+    try:
+        ports = [parse_port_spec(p) for p in args.port]
+    except InvalidPortError as e:
+        print(f"error: {e}")
+        sys.exit(1)
+
+    token = args.token or os.environ.get("REPRO_GITHUB_TOKEN")
+
+    run(args.issue_url, ports, token)
+
+def run(issue_url: str, ports:list, token: str = None):
+
+    # Parsing the issue
+    print("Fetching issue info...")
+    try:
+        issue = parse_issue(issue_url, token)
+    except ValueError as e:
+        print(f"error: {e}")
+        sys.exit(1)
+
+    print(f"ISSUE #{issue['number']}: {issue['title']}")
+    print(f"REPO: {issue['owner']}/{issue['repo']}\n")
+    if token:
+        print(" Using authenticated access (private repo support enabled)")
+    print()
+
+    # Detecting the runtime
+    print("Detecting runtime...")
+    runtime = detect_runtime(issue["owner"], issue["repo"], token)
+    if runtime is None:
+        print("Could not detect runtime, using universal base image")
+        runtime = universal()
+
+    print(f"Detected: {runtime['name']} (image: {runtime['image']})\n")
+
+    if ports:
+        mapping = ", ".join(f"{h}->{c}" for h, c in ports)
+        print(f"Forwarding ports: {mapping}\n")
+
+    print(" Spinning up sandbox...")
+    try:
+        run_sandbox(issue, runtime, ports, token)
+    except DockerNotFoundError as e:
+        print(f"\n❌ {e}")
+        sys.exit(1)
+    except DockerNotRunningError as e:
+        print(f"\n❌ {e}")
+        sys.exit(1)
+    except InvalidRepoError as e:
+        print(f"\n❌ {e}")
+        sys.exit(1)
+
+# def print_usage():
+#     print("""repro - disposable Docker environments for GitHub issues
+
+# Usage:
+#     python repro.py <issue-url>       Open a sandbox for a GitHub issue
+#     python repro.py --version         Print version
+#     python repro.py --help            Show this help
+
+# Examples:
+#     python repro.py https://github.com/org/repo/issues/42
+#     python repro.py https://github.com/golang/go/issues/1234
+#     """
+# )

repro_cli-0.1.0/repro/detector/detector.py

@@ -0,0 +1,51 @@
+import urllib.request
+import urllib.error
+import json
+
+KNOWN_FILES = [
+    ("package.json",    {"name": "Node.js",          "image": "node:20-alpine",                  "install": "npm install"}),
+    ("yarn.lock",       {"name": "Node.js (yarn)",    "image": "node:20-alpine",                  "install": "yarn install"}),
+    ("pnpm-lock.yaml",  {"name": "Node.js (pnpm)",    "image": "node:20-alpine",                  "install": "npm i -g pnpm && pnpm install"}),
+    ("requirements.txt",{"name": "Python",            "image": "python:3.12-slim",                "install": "pip install -r requirements.txt"}),
+    ("pyproject.toml",  {"name": "Python",            "image": "python:3.12-slim",                "install": "pip install -e ."}),
+    ("Pipfile",         {"name": "Python (pipenv)",   "image": "python:3.12-slim",                "install": "pip install pipenv && pipenv install"}),
+    ("go.mod",          {"name": "Go",                "image": "golang:1.21-alpine",              "install": "go mod download"}),
+    ("Cargo.toml",      {"name": "Rust",              "image": "rust:1.75-slim",                  "install": "cargo fetch"}),
+    ("Gemfile",         {"name": "Ruby",              "image": "ruby:3.3-slim",                   "install": "bundle install"}),
+    ("composer.json",   {"name": "PHP",               "image": "php:8.3-cli",                     "install": "composer install"}),
+    ("pom.xml",         {"name": "Java (Maven)",      "image": "maven:3.9-eclipse-temurin-21",    "install": "mvn dependency:resolve"}),
+    ("build.gradle",    {"name": "Java (Gradle)",     "image": "gradle:8-jdk21",                  "install": "gradle dependencies"}),    
+]
+
+def universal() -> dict:
+    return {"name":"universal", "image": "ubuntu:22.04", "install": ""}
+
+def detect_runtime(owner: str, repo: str, token: str = None) -> dict | None:
+    api_url = f"https://api.github.com/repos/{owner}/{repo}/contents/"
+    headers={"User-Agent": "repro/0.1.0", "Accept": "applications/vnd.github+json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try: 
+        req = urllib.request.Request(
+            api_url,
+            headers=headers
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            contents = json.loads(resp.read())
+    except Exception:
+        return None
+
+    present = {f["name"] for f in contents}
+
+    if ".devcontainer" in present or "devcontainer.json" in present:
+        return {
+            "name" : "devcontainer",
+            "image" : "mcr.microsoft.com/devcontainers/universal:latest",
+            "install": "",
+        }
+
+    for filename, runtime in KNOWN_FILES:
+        if filename in present:
+            return runtime
+
+    return None

repro_cli-0.1.0/repro/docker/runner.py

@@ -0,0 +1,182 @@
+import os 
+import shutil
+import re
+import subprocess
+import tempfile
+
+class DockerNotFoundError(Exception):
+    pass
+
+class DockerNotRunningError(Exception):
+    pass
+
+class InvalidPortError(Exception):
+    pass
+
+class InvalidRepoError(Exception):
+    pass
+
+SAFE_NAME = re.compile(r"^[A-Za-z0-9._-]+$")
+
+def check_docker_available():
+    """Verify Docker CLI exists and the daemon is reachable before trying anythg"""
+    if shutil.which("docker") is None:
+        raise DockerNotFoundError(
+            "Docker is not installed or not on your PATH.\n"
+            "   Install it from: https://docs.docker.com/get-docker/"
+        )
+
+    result = subprocess.run(["docker", "info"], capture_output=True, text=True)
+    if result.returncode != 0:
+        raise DockerNotRunningError(
+            "Docker is installed but the daemon isnt running.\n"
+            "   Start Docker Desktop and wait for the icon to go steady, then try again."
+        )
+
+def validate_repo_identifiers(owner: str, repo:str):
+    """ Guard against shell injection -> owner/repo gets interpolated into a shell command, so anything outside GitHub's allowed charst is rejected 
+    before it even reaches da subprocess"""
+    for label, value in (("owner", owner), ("repo", repo)):
+        if not SAFE_NAME.match(value):
+            raise InvalidRepoError(f'invalid {label} "{value}" - contains disallowed characters')
+        if value in (".", ".."):
+            raise InvalidRepoError(f'invalid {label} "{value}"')
+        if value.startswith("."):
+            raise InvalidRepoError(f'invalid {label} "{value}" - cannot start with a dot')
+
+
+def parse_port_spec(spec: str) -> tuple[int, int]:
+    """ Parse a --port value into (host_port, container_port).
+        Accepts "3000" (same both sides) or "8080:3000" (host:container).
+    """
+    parts = spec.split(":")
+
+    if len(parts) == 1:
+        host, container = parts[0], parts[0]
+    elif len(parts) == 2:
+        host, container = parts
+    else:
+        raise InvalidPortError(f'invalid port spec "{spec}" - use PORT or HOST:CONTAINER')
+
+    for label, value in (("host", host), ("container", container)):
+        if not value.isdigit():
+            raise InvalidPortError(f'invalid {label} port "{value}" in "{spec}" - must be a number')
+        port_num = int(value)
+        if not(1 <= port_num <= 65535):
+            raise InvalidPortError(f'{label} port {port_num} out of range (1-65535)')
+
+    return int(host), int(container)
+
+def run_sandbox(issue: dict, runtime: dict, ports: list =None, token: str = None):
+    check_docker_available()
+    ports = ports or []
+
+    owner = issue["owner"]
+    repo = issue["repo"]
+    number = issue["number"]
+
+    validate_repo_identifiers(owner, repo)
+
+    if not isinstance(number, int):
+        raise InvalidRepoError("issue number must be an integer")
+
+    clone_url_public = f"https://github.com/{owner}/{repo}.git"
+    clone_url_auth = f"https://{token}@github.com/{owner}/{repo}.git" if token else clone_url_public
+
+    work_dir = f"/sandbox/{repo}"
+    container_name = f"repro-{owner}-{repo}-{number}"
+
+    startup_script = build_startup_script(clone_url_auth, clone_url_public, work_dir, runtime["install"], number, ports, has_token=bool(token))
+
+    args = [
+        "docker", "run",
+        "--rm",
+        "-i",
+        "-t",
+        "--name", container_name,
+        "--hostname", f"sandbox-issue-{number}",
+        "-e", f"ISSUE_NUMBER={number}",
+        "-e", f"REPO={owner}/{repo}",
+        "-e", "TERM=xterm-256color",
+    ]
+
+    for host_port, container_port in ports:
+        args += ["-p", f"127.0.0.1:{host_port}:{container_port}"]
+
+    env_file_path = None
+    if token:
+        #writing the toekn to a temp file passed via --env-fle instead of -e/embedded-in-command
+        fd, env_file_path = tempfile.mkstemp(prefix="repro-", suffix=".env")
+        try:
+            os.chmod(env_file_path, 0o600)
+            with os.fdopen(fd, "w") as f:
+                f.write(f"GIT_TOKEN={token}\n")
+        except Exception:
+            if os.path.exists(env_file_path):
+                os.remove(env_file_path)
+            raise
+
+    args += [runtime["image"], "sh", "-c", startup_script]
+
+    print(f"Starting sandbox for {owner}/{repo} issue #{number}")
+    print("     (container will be deleted automatically when you exit)\n")
+
+    env = os.environ.copy()
+    env["DOCKER_CLI_HINTS"] = "false"
+
+    try:
+        result = subprocess.run(args, env=env)
+    except KeyboardInterrupt:
+        print("Interrupted - cleaning up the sandbox...")
+        return
+    
+    if result.returncode not in (0,130):
+        print(f"Sandbox exited with code {result.returncode} - check the output above.")
+        return
+
+    print("\n Sandbox destroyed. Back to reality.")
+
+def build_startup_script(clone_url_auth, clone_url_public, work_dir, install_cmd, issue_number, ports) -> str:
+    install_step = (
+        f'echo "Installing dependencies....." && {install_cmd}'
+        if install_cmd
+        else 'echo "No install step, dropping into shell... "'
+    )
+
+    host_and_path = clone_url_public[len("https://"):]
+    clone_cmd = (
+        f'if [ -n "$GIT_TOEKN" ]; then '
+        f'CLONE_URL="https://${{GIT_TOKEN}}@{host_and_path}";'
+        f'else CLONE_URL="{clone_url_public}"; fi && '
+        f'git clone --depth=1 "$CLONE_URL" {work_dir} 2>&1 | tail -5'
+    )
+
+    lines = [
+        "set -e",
+        "which git > /dev/null 2>&1 || (apk add --no-cache git curl)",
+        'echo ""',
+        'echo "=================================="',
+        f'echo "  DevSandbox - Issue #{issue_number}"',
+        'echo "=================================="',
+        'echo ""',
+        f'echo "Cloning repo..."',
+        clone_cmd,
+        f"git clone --depth=1 {clone_url_auth} {work_dir} 2>&1 | tail -5",
+        f"cd {work_dir} && git remote set-url origin {clone_url_public} && unset GIT_TOKEN",
+        install_step,
+        'echo ""',
+        f'echo "Ready! You are in: {work_dir}"',
+        f'echo "Working on issue #{issue_number}"',
+    ]
+
+    if ports:
+        lines.append('echo ""')
+        for host_port, container_port in ports:
+            lines.append(f'echo "Port {container_port} forwarded -> http://localhost:{host_port}"')
+        lines.append('echo "  Start your app inside this shell (e.g. npm start / node server.js) to use it."')
+
+    lines.append('echo ""')
+    lines.append(f"cd {work_dir} && exec sh")
+
+
+    return " && ".join(lines)

repro_cli-0.1.0/repro/github/issue.py

@@ -0,0 +1,59 @@
+import re 
+import urllib.request
+import urllib.error
+import json
+
+
+ISSUE_PATTERN = re.compile(r"github\.com/([^/]+)/([^/]+)/issues/(\d+)")
+
+def parse_issue(url: str, token: str = None) -> dict:
+    match = ISSUE_PATTERN.search(url)
+    if not match:
+        raise ValueError(f"Invalid Github issue URL: {url}")
+
+    owner, repo, number = match.group(1), match.group(2), int(match.group(3))
+
+    issue = {
+        "owner": owner,
+        "repo": repo,
+        "number": number,
+        "title": "(could not fetch title)",
+        "body" : "",
+    }
+
+    # trying github api, for public repos without auth
+
+    api_url = f"https://api.github.com/repos/{owner}/{repo}/issues/{number}"
+    headers = {"User-Agent": "repro/0.1.0", "Accept": "applications/vnd.github+json"}
+
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    try:
+        req = urllib.request.Request(
+            api_url,
+            headers=headers,
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read())
+            issue["title"] = data.get("title", issue["title"])
+            issue["body"] = data.get("body", "")
+
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            if token:
+                issue["title"] = "(not found - check the URL, or the token lacks access)"
+            else:
+                issue["title"] = "(not found - if this is a private repo, pass --token)"
+        elif e.code == 401:
+            issue["title"] = "(bad or expired token - check --token)"
+        elif e.code == 403:
+            issue["title"] = "(GitHub API rate limit hit - continuing anyway)"
+        else:
+            issue["title"] = f"(GitHub API returned {e.code})"
+    except urllib.error.URLError:
+        issue["title"] = "(no internet connection - continuing anyway)"
+    except Exception:
+        pass
+    
+    return issue

repro_cli-0.1.0/repro_cli.egg-info/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: repro-cli
+Version: 0.1.0
+Summary: Disposable Docker environments for any GitHub issue
+Author: Sukhdev Thukral
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown

repro_cli-0.1.0/repro_cli.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+README.md
+pyproject.toml
+repro/__init__.py
+repro/cli.py
+repro/detector/__init__.py
+repro/detector/detector.py
+repro/docker/__init__.py
+repro/docker/runner.py
+repro/github/__init__.py
+repro/github/issue.py
+repro_cli.egg-info/PKG-INFO
+repro_cli.egg-info/SOURCES.txt
+repro_cli.egg-info/dependency_links.txt
+repro_cli.egg-info/entry_points.txt
+repro_cli.egg-info/top_level.txt
+tests/test_port_parsing.py
+tests/test_repo_validation.py
+tests/test_runtime_detection.py

repro_cli-0.1.0/repro_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

repro_cli-0.1.0/repro_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+repro = repro.cli:main

repro_cli-0.1.0/repro_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+repro

repro_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

repro_cli-0.1.0/tests/test_port_parsing.py

@@ -0,0 +1,34 @@
+import pytest 
+from repro.docker.runner import parse_port_spec, InvalidPortError
+
+def test_single_port_maps_to_itself():
+    assert parse_port_spec("3000") == (3000, 3000)
+
+def test_host_container_mapping():
+    assert parse_port_spec("8080:3000") == (8080, 3000)
+
+def test_rejects_non_numeric_port():
+    with pytest.raises(InvalidPortError):
+        parse_port_spec("abc")
+
+def test_rejects_port_out_of_range_high():
+    with pytest.raises(InvalidPortError):
+        parse_port_spec("99999")
+
+def test_rejects_port_zero():
+    with pytest.raises(InvalidPortError):
+        parse_port_spec("0")
+
+def test_rejects_malformed_spec_too_many_colons():
+    with pytest.raises(InvalidPortError):
+        parse_port_spec("1:2:3")
+
+def test_rejects_empty_string():
+    with pytest.raises(InvalidPortError):
+        parse_port_spec("")
+
+def test_accepts_boundary_port_1():
+    assert parse_port_spec("1") == (1, 1)
+
+def test_accepts_boundary_port_65535():
+    assert parse_port_spec("65535") == (65535, 65535)

repro_cli-0.1.0/tests/test_repo_validation.py

@@ -0,0 +1,46 @@
+import pytest
+from repro.docker.runner import validate_repo_identifiers, InvalidRepoError
+
+
+def test_accepts_normal_owner_repo():
+    validate_repo_identifiers("epressjs", "express")
+
+def test_accpets_hyphens_and_underscores():
+    validate_repo_identifiers("my-org", "my_repo.name")
+
+def test_rejects_shell_injection_semicolon():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner; rm -rf /", "repo")
+
+def test_rejects_shell_injection_backtick():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner`whoami`", "repo")
+
+def test_rejects_shell_injection_dollar():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner$(whoami)", "repo")
+
+
+def test_rejects_path_traversal_dotdot():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner", "..")
+
+
+def test_rejects_single_dot():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner", ".")
+
+
+def test_rejects_leading_dot():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner", ".hidden")
+
+
+def test_rejects_slash_in_repo_name():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner", "repo/../../etc")
+
+
+def test_rejects_space():
+    with pytest.raises(InvalidRepoError):
+        validate_repo_identifiers("owner name", "repo")

repro_cli-0.1.0/tests/test_runtime_detection.py

@@ -0,0 +1,41 @@
+from unittest.mock import patch, MagicMock
+import json
+from repro.detector.detector import detect_runtime, universal
+
+def _mock_response(file_list):
+    body = json.dumps([{"name":name} for name in file_list]).encode()
+    mock_resp = MagicMock()
+    mock_resp.read.return_value = body
+    mock_resp.__enter__.return_value = mock_resp
+    return mock_resp
+
+def test_detects_node_from_package_json():
+    with patch("urllib.request.urlopen", return_value=_mock_response(["package.json", "README.md"])):
+        runtime = detect_runtime("owner", "repo")
+    assert runtime["name"] == "Node.js"
+    assert runtime["image"] == "node:20-alpine"
+
+def test_detecs_python_from_requirements_txt():
+    with patch("urllib.request.urlopen", return_value=_mock_response(["requirements.txt"])):
+        runtime = detect_runtime("owner", "repo")
+    assert runtime["name"] == "Python"
+
+def test_detects_go_from_go_mod():
+    with patch("urllib.request.urlopen", return_value=_mock_response(["go.mod","main.go"])):
+        runtime = detect_runtime("owner", "repo")
+    assert runtime["name"] =="Go"
+
+def test_devcontainer_takes_priority_over_package_json():
+    with patch("urllib.request.urlopen", return_value=_mock_response([".devcontainer", "package.json"])):
+        runtime = detect_runtime("owner", "repo")
+    assert runtime["name"] == "devcontainer"
+
+def test_returns_none_on_network_error():
+    with patch("urllib.request.urlopen", side_effect=Exception("network down")):
+        runtime = detect_runtime("owner", "repo")
+    assert runtime is None
+
+def test_universal_fallback_has_correct_shape():
+    fallback = universal()
+    assert fallback["name"] == "universal"
+    assert fallback["image"] == "ubuntu:22.04"