pcode 0.1.0__py3-none-any.whl

pcode/edits.py

@@ -0,0 +1,162 @@
+"""Bounded, sanitized evidence of completed file mutations, not workspace diffs."""
+
+import difflib
+import os
+import re
+
+from pcode.runtime import EditCompleted
+from pcode.tool_display import command_text, plain
+
+MAX_SOURCE = 256 * 1024
+MAX_LINES = 4000
+MAX_PATCH = 64 * 1024
+MAX_PATCH_LINES = 400
+_SENSITIVE = re.compile(
+    r"(?i)(secret|token|password|credential|api.?key|private.?key|\.env|kubeconfig|"
+    r"(?:^|/)\.kube/|(?:^|/)\.aws/|\.tfvars|\.pem$|\.key$|(?:^|/)id_(?:rsa|ed25519)(?:$|\.))"
+)
+_OPEN_SECRET = re.compile(
+    r"(?i)((?:password|passwd|secret|token|api[_-]?key|authorization)[\"']?\s*[:=]\s*)"
+    r"([\"'])(.*?)(?:(?<!\\)\2|\Z)",
+    re.DOTALL,
+)
+
+
+def sensitive_path(path: str) -> bool:
+    return bool(_SENSITIVE.search(path))
+
+
+def edit_text(text: str) -> str:
+    # Redact whole strings before adding diff prefixes or clipping. A credential
+    # can span lines, and a streamed quoted value may not have its closing quote.
+    text = _OPEN_SECRET.sub(r"\1\2[redacted]\2", text)
+    text = re.sub(
+        r"(?i)((?:password|passwd|secret|token|api[_-]?key|authorization)[\"']?\s*[:=]\s*)"
+        r"[^\s\"',;}]+",
+        r"\1[redacted]",
+        text,
+    )
+    text = re.sub(r"-----BEGIN [^-]*PRIVATE KEY-----.*", "[private key redacted]", text, flags=re.S)
+    return command_text(text)
+
+
+_HUNK = re.compile(r"@@ -\d+(?:,(\d+))? \+\d+(?:,(\d+))? @@")
+
+
+def patch_text(patch: str, *, dedent: bool) -> str:
+    """A stored patch as it is displayed: redacted, and dedented if asked."""
+    text = edit_text(patch)
+    return dedent_patch(text) if dedent else text
+
+
+def dedent_patch(patch: str) -> str:
+    """Strip the leading whitespace every line of a hunk shares.
+
+    An edit deep in a nested block otherwise starts its whole diff several
+    levels in. Each hunk is dedented on its own, by the whitespace common to
+    all its context, added and removed lines; whitespace-only lines do not
+    count, and lose only the shared part, so a whitespace change still shows.
+    Hunks are walked by their header's line counts, so a removed `--- x` line
+    is never mistaken for a file header, and everything outside a hunk is left
+    alone; a hunk that does not parse as its header promises is left as it is.
+    `edit_text` has already expanded tabs.
+    """
+    lines = patch.split("\n")
+    index = 0
+    while index < len(lines):
+        match = _HUNK.match(lines[index])
+        index += 1
+        if not match:
+            continue
+        old, new = (int(count) if count is not None else 1 for count in match.groups())
+        body = []
+        malformed = False
+        while index < len(lines) and (old > 0 or new > 0):
+            marker = lines[index][:1]
+            if marker not in (" ", "+", "-", "\\", ""):
+                malformed = True
+                break
+            if marker != "\\":
+                body.append(index)
+                old -= marker != "+"
+                new -= marker != "-"
+            index += 1
+        # A trailing "\ No newline" note belongs to the hunk just read.
+        if index < len(lines) and lines[index].startswith("\\"):
+            index += 1
+        if not malformed:
+            _dedent(lines, body)
+    return "\n".join(lines)
+
+
+def _dedent(lines: list[str], body: list[int]) -> None:
+    contents = [lines[i][1:] for i in body]
+    indents = [c[: len(c) - len(c.lstrip())] for c in contents if c.strip()]
+    if not indents:
+        return
+    shared = os.path.commonprefix(indents)
+    if not shared:
+        return
+    for i, content in zip(body, contents, strict=True):
+        marker = lines[i][:1]
+        kept = content.removeprefix(shared) if content.strip() else content[len(shared) :]
+        lines[i] = marker + kept
+
+
+def source_lines(text: str) -> list[str]:
+    """Lines as git and diff count them, each keeping its newline.
+
+    `str.splitlines` also breaks at form feeds, U+2028 and other separators
+    that are ordinary characters inside a source line, adding lines the file
+    does not have and throwing a hunk's line counts off.
+    """
+    parts = text.split("\n")
+    return [part + "\n" for part in parts[:-1]] + ([parts[-1]] if parts[-1] else [])
+
+
+def change_from_record(record: dict) -> EditCompleted:
+    """Rebuild a saved change, ignoring journal fields the dataclass does not own."""
+    return EditCompleted(
+        **{key: value for key, value in record.items() if key in EditCompleted.__dataclass_fields__}
+    )
+
+
+def completed_change(path, before, after, *, existed=True, call_id="", omitted=""):
+    """Build display evidence while raw snapshots are still local to execution."""
+    operation = "edited" if existed else "created"
+    if sensitive_path(path):
+        return EditCompleted(call_id, "[sensitive path]", operation, omitted="Sensitive file")
+    path = plain(edit_text(path), limit=None)
+    if omitted or before is None:
+        return EditCompleted(
+            call_id, path, operation, omitted=omitted or "Before snapshot unavailable"
+        )
+    if max(len(before), len(after)) > MAX_SOURCE:
+        return EditCompleted(call_id, path, operation, omitted="File exceeds preview size limit")
+    if "\x00" in before or "\x00" in after:
+        return EditCompleted(call_id, path, operation, omitted="Binary content")
+    if max(len(source_lines(before)), len(source_lines(after))) > MAX_LINES:
+        return EditCompleted(call_id, path, operation, omitted="File exceeds preview line limit")
+    if before == after:
+        return EditCompleted(call_id, path, "unchanged" if existed else "created")
+    # Count actual changed source lines, even where redaction hides a change.
+    raw = list(difflib.unified_diff(source_lines(before), source_lines(after), n=3))
+    added = sum(line.startswith("+") for line in raw[2:])
+    removed = sum(line.startswith("-") for line in raw[2:])
+    lines = []
+    for line in difflib.unified_diff(
+        source_lines(edit_text(before)),
+        source_lines(edit_text(after)),
+        fromfile=f"a/{path}" if existed else "/dev/null",
+        tofile=f"b/{path}",
+        n=3,
+    ):
+        lines.append(line.rstrip("\n"))
+        if not line.endswith("\n"):
+            lines.append(r"")
+    patch = "\n".join(lines[:MAX_PATCH_LINES])
+    truncated = len(lines) > MAX_PATCH_LINES or len(patch) > MAX_PATCH
+    patch = patch[:MAX_PATCH]
+    if not patch:
+        omitted = "Changes hidden by redaction or newline normalization"
+    return EditCompleted(call_id, path, operation, patch, added, removed, truncated, omitted)

pcode/email_remote/__init__.py

@@ -0,0 +1,14 @@
+"""`pcode --email-listen`: a Gmail account as a remote control for session hosts.
+
+A new email to the listener's alias starts a session (an ordinary host, under
+`pcode.remote_profile`'s fixed profile, in its own worktree); a reply continues
+it. Only mail the owner sent from their own account is accepted: Gmail labels
+it `SENT`, which nothing delivered from outside can carry. See
+`dev/email-remote.md` for the design and the checks behind it.
+
+- `parsing`: one raw message to headers and the new text in its body
+- `mailbox`: Gmail over IMAP and SMTP, and the keychain credential
+- `state`: what one listener has handled, routed and sent, on disk
+- `outbound`: the messages pcode sends
+- `listener`: acceptance, routing, the sessions, and the loop
+"""

pcode/email_remote/cli.py

@@ -0,0 +1,133 @@
+"""`pcode --email-setup` and `pcode --email-listen`."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import re
+import signal
+import sys
+import time
+from pathlib import Path
+
+from pcode.email_remote.listener import Limits, Listener, head_commit
+from pcode.email_remote.mailbox import GmailMailbox, SetupError, read_password, store_password
+from pcode.email_remote.state import state_dir
+from pcode.preferences import load_preferences, update_preferences
+from pcode.remote_profile import RemoteProfile
+
+_DURATION = re.compile(r"^(\d+(?:\.\d+)?)([smhd]?)$")
+_UNITS = {"s": 1, "m": 60, "h": 3600, "d": 86400, "": 60}
+_ADDRESS = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+APP_PASSWORDS = "https://myaccount.google.com/apppasswords"
+
+
+def parse_duration(text: str) -> float:
+    """`8h`, `30m`, `1d`, `90s`; a bare number is minutes."""
+    match = _DURATION.match(text.strip().lower())
+    if match is None or float(match.group(1)) <= 0:
+        raise ValueError(f"Not a duration: {text!r} (use e.g. 30m, 8h, 1d).")
+    return float(match.group(1)) * _UNITS[match.group(2)]
+
+
+def profile_from_preferences(preferences: dict, base: str | None = None) -> RemoteProfile:
+    """The profile email-started hosts run under: chosen here, never by email."""
+    return RemoteProfile(
+        # The listener's state (routes, the outbox, replies); the keychain is denied anyway.
+        deny_read=(str(state_dir()),),
+        mcp=preferences.get("email_mcp", "off") == "on",
+        turn_minutes=float(preferences.get("email_turn_minutes") or 30),
+        max_requests=int(preferences.get("email_turn_requests") or 100),
+        max_tool_calls=int(preferences.get("email_turn_tool_calls") or 100),
+        base=base,
+        origin="email",
+    )
+
+
+def setup(owner: str | None, ask=input) -> int:
+    """Store the app password in the keychain, check it, and confirm the profile once."""
+    owner = (owner or ask("Gmail address: ")).strip().lower()
+    if not _ADDRESS.match(owner):
+        raise SetupError(f"{owner!r} is not an email address.")
+    print(
+        "pcode reads and sends this account's mail over IMAP with a Gmail app password "
+        f"(2-Step Verification required): create one at {APP_PASSWORDS}.\n"
+        "Paste it at the keychain prompt below; it goes straight into the macOS "
+        "keychain, and only the listener reads it.",
+        file=sys.stderr,
+    )
+    store_password(owner)
+    mailbox = GmailMailbox(owner, read_password(owner))
+    try:
+        mailbox.verify()
+    finally:
+        mailbox.close()
+    print("Signed in to Gmail over IMAP.\n", file=sys.stderr)
+    print("Email-started sessions run unattended, under this profile:", file=sys.stderr)
+    for line in profile_from_preferences(load_preferences()).describe():
+        print(f"  {line}", file=sys.stderr)
+    answer = ask("Let email from this account start sessions under it? [y/N] ")
+    if answer.strip().lower() not in ("y", "yes"):
+        print("Not enabled.", file=sys.stderr)
+        return 1
+    update_preferences({"email_owner": owner})
+    print(f"Enabled for {owner}. Start listening with: pcode --email-listen", file=sys.stderr)
+    return 0
+
+
+def listen(workspace: Path, *, ttl: str, model: str | None) -> int:
+    from pcode.worktree import main_checkout
+
+    preferences = load_preferences()
+    owner = preferences.get("email_owner")
+    if not owner:
+        raise SetupError("No email account is set up; run pcode --email-setup.")
+    model = model or preferences.get("model")
+    if not model:
+        raise SetupError("Email sessions need a model: pass -m or set a default with /model.")
+    workspace = workspace.resolve()
+    if main_checkout(workspace) is None:
+        raise SetupError(f"{workspace} is not in a git repository; email sessions need worktrees.")
+    seconds = parse_duration(ttl)
+    mailbox = GmailMailbox(owner, read_password(owner))
+    mailbox.verify()
+    profile = profile_from_preferences(preferences, base=head_commit(workspace))
+    listener = Listener(
+        owner=owner,
+        mailbox=mailbox,
+        workspace=workspace,
+        profile=profile,
+        ttl=seconds,
+        # One file per run: two listeners (two repositories) never share one.
+        state_path=state_dir() / f"{time.strftime('%Y%m%d-%H%M%S')}-{os.getpid()}.json",
+        limits=Limits.from_preferences(preferences),
+        model=model,
+    )
+    expiry = time.strftime("%Y-%m-%d %H:%M %Z", time.localtime(listener.expires))
+    print(
+        "\n".join(
+            [
+                f"Listening for email from {owner}",
+                f"Workspace: {workspace} (model {model})",
+                "Profile:",
+                *(f"  {line}" for line in profile.describe()),
+                f"Until: {expiry}. Ctrl+C stops listening and every email session.",
+            ]
+        ),
+        file=sys.stderr,
+        flush=True,
+    )
+
+    async def main() -> None:
+        stop = asyncio.Event()
+        loop = asyncio.get_running_loop()
+        for signum in (signal.SIGINT, signal.SIGTERM):
+            loop.add_signal_handler(signum, stop.set)
+        try:
+            await listener.start()
+            await listener.run(stop)
+        finally:
+            mailbox.close()
+
+    asyncio.run(main())
+    return 0