gitpro 0.3.1__py3-none-any.whl

gitpro/hot.py

@@ -0,0 +1,38 @@
+"""Entry point (`gitpro` script and `python -m gitpro`). Nothing but stdlib at module level.
+
+The hot subcommands (git hooks, agent hooks, shell prompt) run on every commit or prompt, so they go
+straight to their own module without importing cli.py, rich or the views. Everything else, and any
+hot subcommand whose package is not built yet, falls through to cli.main.
+"""
+from __future__ import annotations
+
+import importlib
+import os
+import sys
+from typing import List, Optional
+
+HOT = {                      # subcommand -> module with main(argv) -> int (argv includes the subcommand)
+    "guard": "gitpro.guard",          # 06
+    "agent-check": "gitpro.agents",   # 10
+    "prompt": "gitpro.prompt",        # 16
+}
+
+CALLER_UMASK: Optional[int] = None    # the umask gitpro was started with (set before tightening to 077)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    global CALLER_UMASK
+    argv = sys.argv[1:] if argv is None else list(argv)
+    if argv and argv[0] in HOT and os.name == "posix" and os.geteuid() != 0:
+        name = HOT[argv[0]]
+        try:
+            mod = importlib.import_module(name)
+        except ModuleNotFoundError as e:
+            if e.name != name:           # a broken import inside the module is not hidden
+                raise
+            mod = None                   # package not built yet: fall through to cli
+        if mod is not None:
+            CALLER_UMASK = os.umask(0o077)
+            return mod.main(argv)
+    from gitpro.cli import main as cli_main
+    return cli_main(argv)

gitpro/jsonfile.py

@@ -0,0 +1,195 @@
+"""Read and edit JSON / JSONC settings files with a preview, a backup and an undo script (10, 11, 13)."""
+from __future__ import annotations
+
+import copy
+import difflib
+import json
+import os
+import re
+import shlex
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional, Tuple, Union
+
+from . import files, undo
+from .config import ConfigError
+
+
+@dataclass(frozen=True)
+class Result:
+    path: Path
+    changed: bool
+    diff: str
+    backup: Optional[Path]
+    undo: Optional[Path]
+    text: str  # what is (or would be) on disk after the edit
+
+
+def strip_jsonc(text: str) -> Tuple[str, bool]:
+    """(text without // and /* */ comments outside strings and without trailing commas, had comments)."""
+    out, i, n, comments = [], 0, len(text), False
+    while i < n:
+        c = text[i]
+        if c == '"':
+            j = i + 1
+            while j < n and text[j] != '"':
+                j += 2 if text[j] == "\\" else 1
+            out.append(text[i:j + 1])
+            i = j + 1
+        elif text.startswith("//", i):
+            comments = True
+            j = text.find("\n", i)
+            i = n if j < 0 else j
+        elif text.startswith("/*", i):
+            comments = True
+            j = text.find("*/", i + 2)
+            i = n if j < 0 else j + 2
+            out.append(" ")
+        else:
+            out.append(c)
+            i += 1
+    return _drop_trailing_commas("".join(out)), comments
+
+
+def _drop_trailing_commas(text: str) -> str:
+    out, i, n = [], 0, len(text)
+    while i < n:
+        c = text[i]
+        if c == '"':
+            j = i + 1
+            while j < n and text[j] != '"':
+                j += 2 if text[j] == "\\" else 1
+            out.append(text[i:j + 1])
+            i = j + 1
+            continue
+        if c == ",":
+            m = re.compile(r"\s*[}\]]").match(text, i + 1)
+            if m:
+                i += 1
+                continue
+        out.append(c)
+        i += 1
+    return "".join(out)
+
+
+def read(path: Path, *, jsonc: bool = False) -> Tuple[object, str]:
+    """(parsed object, original text, line endings kept). Raises ConfigError("<path>: cannot parse (<error>)")."""
+    with open(path, encoding="utf-8", newline="") as f:
+        text = f.read()
+    return _parse(path, text, jsonc)[0], text
+
+
+def _parse(path: Path, text: str, jsonc: bool) -> Tuple[object, bool]:
+    src, comments = strip_jsonc(text) if jsonc else (text, False)
+    try:
+        return json.loads(src), comments
+    except ValueError as e:
+        raise ConfigError(f"{path}: cannot parse ({e})") from None
+
+
+def detect_indent(text: str) -> Union[int, str]:
+    """The file's own indent when it is 2 or 4 spaces or a tab, else 2."""
+    m = re.search(r"[{\[][ \t]*\r?\n([ \t]+)\S", text)
+    if m:
+        ws = m.group(1)
+        if ws == "\t":
+            return "\t"
+        if ws in ("  ", "    "):
+            return len(ws)
+    return 2
+
+
+def _mode_for(path: Path, old_mode: Optional[int]) -> int:
+    home = Path.home()
+    real = Path(os.path.realpath(path))
+    for private in (home / ".ssh", home / ".config/gh"):
+        if private in real.parents or private in Path(path).parents:
+            return 0o600
+    return old_mode if old_mode is not None else 0o644
+
+
+def _backup(path: Path, text: str) -> Path:
+    """A 0600 copy in <state>/backup-<ts>/ (never next to the file: it may be in a work tree)."""
+    d = undo.state_dir() / f"backup-{undo._stamp()}"
+    d.mkdir(mode=0o700, exist_ok=True)
+    for n in range(1000):
+        bak = d / (path.name + (f".{n}" if n else ""))
+        try:
+            fd = os.open(bak, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
+        except FileExistsError:
+            continue
+        with os.fdopen(fd, "w", encoding="utf-8", newline="") as f:
+            f.write(text)  # the original bytes: CRLF stays CRLF, so the undo restores the file exactly
+        return bak
+    raise OSError(f"no free backup name in {d}")
+
+
+def _current(path: Path) -> Optional[str]:
+    """The file's text with its own line endings (newline=""), None when it does not exist."""
+    try:
+        with open(path, encoding="utf-8", newline="") as f:
+            return f.read()
+    except FileNotFoundError:
+        return None
+
+
+def _discard(*paths: Optional[Path]) -> None:
+    """Remove a backup and undo script whose write failed (and the backup's directory once empty)."""
+    for p in paths:
+        if p is None:
+            continue
+        try:
+            p.unlink()
+            if p.parent.name.startswith("backup-"):
+                p.parent.rmdir()
+        except OSError:
+            pass
+
+
+def edit_json(path: Path, mutate: Callable[[object], object], *, command: str, jsonc: bool = False,
+              create: Optional[object] = None, confirm: Callable[[str], bool], indent: int = 2,
+              mkdir: bool = False, snippet: Optional[str] = None) -> Result:
+    """Apply mutate to the file's JSON; show the diff to confirm; back up, write an undo script, then
+    replace the file atomically. `indent` is used for new files; existing files keep their own indent.
+    `snippet` is what the caller would have the user add by hand when a JSONC file has comments."""
+    path = Path(path)
+    old = _current(path)
+    if old is None:
+        if create is None:
+            raise ConfigError(f"{path}: not found")
+        if not path.parent.is_dir() and not mkdir:
+            raise ConfigError(f"{path.parent}: no such directory")
+        obj, comments, width, old_mode = create, False, indent, None
+    else:
+        obj, comments = _parse(path, old, jsonc)
+        width = detect_indent(old)
+        old_mode = path.stat().st_mode & 0o777
+    new_obj = mutate(copy.deepcopy(obj))
+    text = json.dumps(new_obj, indent=width, ensure_ascii=False) + "\n"
+    diff = "".join(difflib.unified_diff((old or "").replace("\r\n", "\n").splitlines(True), text.splitlines(True),
+                                        f"a{path}", f"b{path}"))
+    if old is not None and "\r\n" in old:
+        text = text.replace("\n", "\r\n")  # keep a CRLF file CRLF (json.dumps escapes newlines in strings)
+    if old is not None and new_obj == obj:
+        return Result(path, False, "", None, None, old)
+    if comments:
+        raise ConfigError(f"{path} has comments; gitpro cannot edit it without losing them"
+                          f" — add this by hand: {snippet or diff}")
+    if not confirm(diff):
+        return Result(path, False, diff, None, None, text)
+    if _current(path) != old:
+        raise ConfigError(f"{path} changed while gitpro was running; nothing written")
+    backup = _backup(path, old) if old is not None else None
+    target = shlex.quote(str(path))
+    # The backup is 0600; the undo restores the file's own mode, not the backup's.
+    lines = [f"cp {shlex.quote(str(backup))} {target}", f"chmod {old_mode:04o} {target}"] if backup \
+        else [f"rm -f {target}"]
+    script = undo.write(command, lines, what=f"edited {undo.tilde(path)}")
+    if old is None and mkdir:
+        path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        files.atomic_write(path, text, _mode_for(path, old_mode))
+    except BaseException:
+        _discard(backup, script)  # nothing changed: leave no backup or undo script behind
+        raise
+    return Result(path, True, diff, backup, script, text)

gitpro/jsonout.py

@@ -0,0 +1,26 @@
+"""The --json envelope every command shares: {"ok": ..., "command": ..., ...}."""
+from __future__ import annotations
+
+import json
+import sys
+
+
+def dumps(obj: dict) -> str:
+    return json.dumps(obj, indent=2, ensure_ascii=False)
+
+
+def emit(command: str, obj: dict, *, ok: bool = True) -> None:
+    """Print {"ok", "command", **obj} on stdout; an "ok" inside obj wins over the argument."""
+    out = {"ok": obj.get("ok", ok), "command": command}
+    out.update((k, v) for k, v in obj.items() if k not in ("ok", "command"))
+    sys.stdout.write(dumps(out) + "\n")
+    sys.stdout.flush()
+
+
+def error(command: str, message: str) -> None:
+    """The error object, on stdout; nothing goes to stderr."""
+    emit(command, {"error": message}, ok=False)
+
+
+def wants_json(args: object) -> bool:
+    return bool(getattr(args, "json", False))

gitpro/keys.py

@@ -0,0 +1,59 @@
+"""SSH keys: which key serves which identity, generating missing ones, printing .pub files."""
+from __future__ import annotations
+
+import socket
+import subprocess
+from dataclasses import dataclass, field
+
+from .config import Default, Identity, signs
+from .render import Expand, pub_path
+
+
+@dataclass
+class Key:
+    path: str
+    email: str
+    uses: list[str] = field(default_factory=list)
+    sign: bool = False
+
+
+def inventory(d: Default, ids: list[Identity]) -> list[Key]:
+    keys: dict[str, Key] = {}
+
+    def use(path: str, email: str, what: str, sign: bool) -> None:
+        k = keys.setdefault(path, Key(path, email))
+        k.uses.append(what)
+        k.sign |= sign
+
+    if d.ssh_key:
+        use(d.ssh_key, d.email or "", f"{', '.join(d.ssh_hosts) or 'any host'} (default)", d.sign)
+    for i in ids:
+        if i.ssh_key:
+            use(i.ssh_key, i.email, f"{i.host}: {', '.join(i.owners) or '*'} [{i.id}]", signs(i, d))
+        elif signs(i, d):
+            use(d.ssh_key, i.email, f"signing for [{i.id}]", True)
+    return list(keys.values())
+
+
+def generate(keys: list[Key], expand: Expand, passphrase: bool = True) -> int:
+    """Create missing keys; existing ones are never touched. Returns how many were created."""
+    created = 0
+    for k in keys:
+        p = expand(k.path)
+        if p.exists():
+            continue
+        p.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        cmd = ["ssh-keygen", "-t", "ed25519", "-a", "100", "-f", str(p),
+               "-C", f"{k.email} {socket.gethostname()}"]
+        subprocess.run(cmd + ([] if passphrase else ["-N", ""]), check=True)
+        created += 1
+    return created
+
+
+def report(keys: list[Key], expand: Expand) -> None:
+    print("SSH keys -- register each public key with the account(s) listed:")
+    for k in keys:
+        role = "auth + signing" if k.sign else "auth"
+        print(f"  {k.path}  ({role})  ->  {'; '.join(k.uses)}")
+        pub = pub_path(expand(k.path))
+        print(f"    {pub.read_text().strip()}" if pub.exists() else "    (missing -- run: gitpro keys --generate)")

gitpro/lint.py

@@ -0,0 +1,50 @@
+"""Advisory checks. Never block a run, never write."""
+from __future__ import annotations
+
+import re
+import subprocess
+
+from . import keys, render
+from .config import Default, Identity
+from .plan import Env
+
+
+def warnings(d: Default, ids: list[Identity], env: Env) -> list[str]:
+    out = []
+    for i in ids:
+        if i.ssh_alias and i.rewrite:
+            out += [f"identity {i.id!r}: owner {o!r} is a glob; insteadOf needs a literal prefix, so "
+                    f"its URLs aren't rewritten to {i.ssh_alias}" for o in i.owners if "*" in o]
+        if i.ssh_key and not i.ssh_alias and i.host in d.ssh_hosts:
+            out.append(f"identity {i.id!r}: ssh tries {i.ssh_key} first, then {d.ssh_key} ([default].ssh_hosts); "
+                       f"if {i.ssh_key} isn't registered you are signed in as the default account. "
+                       "Add an ssh_alias to offer only this identity's key")
+
+    gitconfig = env.home / ".gitconfig"
+    if gitconfig.exists():
+        stray = subprocess.run(["git", "config", "--file", str(gitconfig), "--get-regexp",
+                                r"^(user\.(name|email|signingkey)|core\.sshcommand)$"],
+                               capture_output=True, text=True).stdout.strip()
+        if stray:
+            out.append(f"{gitconfig} also sets these directly; the generated config is included after them "
+                       "and wins, so they only confuse -- consider removing:\n    " + stray.replace("\n", "\n    "))
+
+    ssh_dir = env.home / ".ssh"
+    if ssh_dir.exists() and ssh_dir.stat().st_mode & 0o022:
+        out.append(f"{ssh_dir} is group/world-writable; ssh may refuse it -- chmod 700 {ssh_dir}")
+    ssh_cfg = ssh_dir / "config"
+    if ssh_cfg.exists():
+        text = render.without_block(ssh_cfg.read_text())
+        theirs = {h for line in re.findall(r"^\s*Host\s+(.+)$", text, re.M | re.I) for h in line.split()}
+        ours = set(d.ssh_hosts) | {i.ssh_alias for i in ids if i.ssh_alias}
+        if ours & theirs:
+            out.append(f"{ssh_cfg} also defines Host {' '.join(sorted(ours & theirs))}; "
+                       "the generated block comes first and wins, remove the old one")
+
+    for k in keys.inventory(d, ids):
+        p = env.expand(k.path)
+        if not p.exists():
+            out.append(f"{k.path} missing -- run: gitpro keys --generate")
+        elif p.stat().st_mode & 0o077:
+            out.append(f"{k.path} is accessible by others -- chmod 600 {p}")
+    return out