pennyrouter 0.3.50 → 0.3.52

package/standalone/remote/rc_project.py

@@ -1,167 +0,0 @@
-"""Experimental Penny project launcher with phone Read/Edit approvals and Stop.
-
-Sessions persist after Ctrl+C. Resume is supported only at completed-turn boundaries.
-"""
-
-import argparse
-import asyncio
-import fcntl
-import json
-import os
-from pathlib import Path
-import shlex
-import uuid
-
-import httpx
-
-from rc_echo import EchoWorker, read_login
-from rc_penny import read_profile
-from rc_restart import RestartWorker
-from rc_tools import ToolsWorker
-from rc_local import ensure_inactive, phone_history, read_local
-
-
-class ProjectWorker(RestartWorker, ToolsWorker):
-    def __init__(self, client, oauth, profile, model, directory, project, local=None):
-        super().__init__(client, oauth, profile, model, directory, project)
-        self.title = "Penny: " + Path(self.cwd).name
-        self.phase = "idle"
-        self.history = []
-        if self.resuming:
-            saved = json.loads(self.state_path.read_text())
-            if saved.get("native_config_dir"):
-                self.extra_state = {"native_config_dir": saved["native_config_dir"],
-                                    "history_synced": saved.get("history_synced", False)}
-                ensure_inactive(saved["native_config_dir"], self.local_session)
-                self.claude.persistence_dir = Path(saved["native_config_dir"])
-                self.claude.resume = True
-                if not self.extra_state["history_synced"]:
-                    local = read_local(project, self.local_session, saved["native_config_dir"])
-        if local:
-            self.local_session = local["session_id"]
-            self.claude.session_id = self.local_session
-            self.claude.persistence_dir = Path(local["config_dir"])
-            self.claude.resume = True
-            self.extra_state = {"native_config_dir": local["config_dir"], "history_synced": False}
-            self.history = list(phone_history(local["records"], self.local_session))
-
-    async def start(self):
-        await super().start()
-        if self.extra_state and not self.extra_state["history_synced"]:
-            for offset in range(0, len(self.history), 20):
-                await self.events(*self.history[offset:offset + 20])
-            self.extra_state["history_synced"] = True
-            self.save("idle")
-        print("Local session: " + self.local_session, flush=True)
-        print("Return to terminal: penny claude --resume " + self.local_session, flush=True)
-
-    async def handle(self, envelope):
-        event_id = envelope.get("event_id")
-        is_new_user = (event_id and event_id not in self.seen and event_id not in self.queued_ids
-                       and envelope.get("payload", {}).get("type") == "user")
-        if is_new_user:
-            self.phase = "busy"
-            self.save(self.phase)
-        await ToolsWorker.handle(self, envelope)
-        self.save(self.phase)
-
-    async def process_turns(self):
-        while not self.stopping:
-            envelope = await self.inbox.get()
-            self.active_turn = True
-            try:
-                await EchoWorker.handle(self, envelope)
-                self.queued_ids.discard(envelope["event_id"])
-                self.phase = "busy" if self.queued_ids else "idle"
-                self.save(self.phase)
-                print("Turn saved." if self.phase == "idle" else "Next turn queued.", flush=True)
-            finally:
-                self.active_turn = False
-                self.inbox.task_done()
-
-
-async def run(project, state_dir, effort, local_session=None, continue_local=False):
-    directory = Path(state_dir).resolve()
-    directory.mkdir(mode=0o700, parents=True, exist_ok=True)
-    with (directory / "lock").open("w") as lock:
-        try:
-            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        except BlockingIOError:
-            raise RuntimeError("This remote session is already running.") from None
-        profile, model = read_profile()
-        local = None
-        state_path = directory / "bridge.json"
-        if local_session or continue_local:
-            if state_path.exists():
-                raise RuntimeError("Use a fresh state folder for a local session handoff.")
-            local = read_local(project, local_session)
-            model = local["model"] or model
-        elif state_path.exists():
-            saved = json.loads(state_path.read_text())
-            if saved.get("native_config_dir"):
-                model = saved["model"]
-        async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
-            "User-Agent": "penny-rc-project/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
-            response = await client.get(profile["gateway_base_url"].rstrip("/") + "/health", timeout=5)
-            if response.status_code != 200:
-                raise RuntimeError("Configured Penny gateway is not healthy.")
-            worker = ProjectWorker(client, read_login(), profile, model, directory, project, local)
-            worker.claude.effort = effort
-            tasks = []
-            try:
-                await worker.start()
-                print("PROJECT " + worker.cwd, flush=True)
-                print("Read/Edit ask on your phone. Stop cancels the current turn. Ctrl+C disconnects.", flush=True)
-                print("Resume: penny remote --resume " + shlex.quote(str(directory)), flush=True)
-                tasks = [asyncio.create_task(worker.listen()), asyncio.create_task(worker.heartbeat()),
-                         asyncio.create_task(worker.process_turns())]
-                done, _ = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
-                for task in done:
-                    task.result()
-            finally:
-                for task in tasks:
-                    task.cancel()
-                await asyncio.gather(*tasks, return_exceptions=True)
-                await worker.close()
-
-
-def main():
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("project", nargs="?", default=None, help="Project folder (defaults to current directory)")
-    parser.add_argument("--resume", metavar="STATE_FOLDER", help="Resume a saved Penny remote session")
-    parser.add_argument("--state-dir", help="State folder for a new session")
-    local_group = parser.add_mutually_exclusive_group()
-    local_group.add_argument("--continue", dest="continue_local", action="store_true",
-                             help="Hand off the latest completed local Claude conversation in this project")
-    local_group.add_argument("--local-session", metavar="UUID", help="Hand off a specific local Claude session")
-    parser.add_argument("--effort", choices=["low", "medium", "high"], default="low")
-    args = parser.parse_args()
-    if args.resume and args.state_dir:
-        parser.error("Use --resume or --state-dir, not both.")
-    if args.resume and (args.local_session or args.continue_local):
-        parser.error("Use --resume for a bridge session, or --continue/--local-session for a local handoff.")
-    config_root = Path(os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config")))
-    directory = args.resume or args.state_dir or str(config_root / "pennyrouter/remote" / str(uuid.uuid4()))
-    project = args.project
-    if args.resume:
-        state_path = Path(directory).expanduser() / "bridge.json"
-        if not state_path.is_file():
-            parser.error("No saved remote session found in that folder.")
-        saved = json.loads(state_path.read_text())
-        project = project or saved["cwd"]
-    else:
-        project = project or str(Path.cwd())
-        if (Path(directory).expanduser() / "bridge.json").exists():
-            parser.error("State folder already contains a session; use --resume.")
-    asyncio.run(run(Path(project).expanduser(), Path(directory).expanduser(), args.effort,
-                    args.local_session, args.continue_local))
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except KeyboardInterrupt:
-        print("Disconnected. The session remains available to resume.")
-    except (RuntimeError, TimeoutError, httpx.HTTPError) as error:
-        print(str(error) if isinstance(error, RuntimeError) else "Remote session stopped after a network or timeout failure.")
-        raise SystemExit(1)

package/standalone/remote/rc_restart.py

@@ -1,145 +0,0 @@
-"""Completed-turn restart probe. State survives exit; credentials are never saved.
-
-Run with a fresh --state-dir, send one phone message, then rerun the same command.
-Tools are disabled. An unfinished turn blocks resume rather than being replayed.
-"""
-
-import argparse
-import asyncio
-import fcntl
-import json
-import os
-from pathlib import Path
-
-import httpx
-
-from rc_echo import BASE, read_login
-from rc_penny import PennyWorker, read_profile
-
-
-class RestartWorker(PennyWorker):
-    def __init__(self, client, oauth, profile, model, directory, project=None):
-        self.directory = Path(directory).resolve()
-        self.extra_state = {}
-        self.directory.mkdir(mode=0o700, parents=True, exist_ok=True)
-        self.state_path = self.directory / "bridge.json"
-        cwd = Path(project).resolve() if project else self.directory / "workspace"
-        if project:
-            if not cwd.is_dir():
-                raise RuntimeError("Project folder does not exist.")
-        else:
-            cwd.mkdir(mode=0o700, exist_ok=True)
-        super().__init__(client, oauth, profile, model, str(cwd))
-        self.cwd = str(cwd)
-        self.title = "Penny restart recovery test"
-        self.completed = False
-        self.resuming = self.state_path.exists()
-        if self.resuming:
-            state = json.loads(self.state_path.read_text())
-            if state["phase"] != "idle":
-                raise RuntimeError("An unfinished turn was recorded. Resume is blocked to avoid replaying it.")
-            if state["model"] != model:
-                raise RuntimeError("Resume requires the original model configuration.")
-            if state.get("cwd", str(cwd)) != str(cwd):
-                raise RuntimeError("Resume requires the original project folder.")
-            self.session = state["remote_session"]
-            self.local_session = state["local_session"]
-            self.last_event_id = state["cursor"]
-            self.seen = set(state["seen"])
-            self.replies = state["replies"]
-            self.claude.session_id = self.local_session
-            self.claude.resume = self.replies > 0
-        self.claude.persistence_dir = self.directory / "claude"
-        self.claude.persistence_dir.mkdir(mode=0o700, exist_ok=True)
-
-    def save(self, phase):
-        state = {"version": 1, "phase": phase, "remote_session": self.session,
-                 "local_session": self.local_session, "model": self.model,
-                 "cursor": self.last_event_id, "seen": sorted(self.seen), "replies": self.replies,
-                 "cwd": self.cwd, **self.extra_state}
-        temporary = self.state_path.with_suffix(".tmp")
-        descriptor = os.open(temporary, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
-        with os.fdopen(descriptor, "w") as handle:
-            json.dump(state, handle)
-            handle.flush()
-            os.fsync(handle.fileno())
-        os.replace(temporary, self.state_path)
-
-    async def start(self):
-        if not self.resuming:
-            await super().start()
-        else:
-            bridge = await self.api("POST", self.path + "/bridge", {}, account=True)
-            if bridge["api_base_url"].rstrip("/") != BASE:
-                raise RuntimeError("Unexpected worker host; refusing to forward credentials.")
-            self.worker_token = bridge["worker_jwt"]
-            self.epoch = int(bridge["worker_epoch"])
-            await self.status("idle")
-            print(f"RESUMED https://claude.ai/code/{self.session}", flush=True)
-        self.save("idle")
-
-    async def handle(self, envelope):
-        is_turn = envelope.get("payload", {}).get("type") == "user" and envelope.get("event_id") not in self.seen
-        if is_turn:
-            self.save("busy")
-        await super().handle(envelope)
-        self.save("idle")
-        if is_turn:
-            self.completed = True
-            self.stopping = True
-            print("Completed turn saved. Restart this command to continue on the same phone link.", flush=True)
-
-    async def close(self):
-        self.stopping = True
-        await self.claude.close()
-        # Preserve the remote session instead of the disposable probes' archive policy.
-        if self.worker_token:
-            await self.api("PUT", self.path + "/worker", {
-                "worker_epoch": self.epoch, "connection_status": "disconnected"})
-        self.oauth = self.worker_token = ""
-
-
-async def run(directory, seconds):
-    directory = Path(directory).resolve()
-    directory.mkdir(mode=0o700, parents=True, exist_ok=True)
-    with (directory / "lock").open("w") as lock:
-        try:
-            fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
-        except BlockingIOError:
-            raise RuntimeError("Another restart probe is using this state folder.") from None
-        profile, model = read_profile()
-        async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
-            "User-Agent": "penny-rc-restart-probe/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
-            response = await client.get(profile["gateway_base_url"].rstrip("/") + "/health", timeout=5)
-            if response.status_code != 200:
-                raise RuntimeError("Configured Penny gateway is not healthy.")
-            worker = RestartWorker(client, read_login(), profile, model, directory)
-            tasks = []
-            try:
-                await worker.start()
-                tasks = [asyncio.create_task(worker.listen()), asyncio.create_task(worker.heartbeat())]
-                done, _ = await asyncio.wait(tasks, timeout=seconds, return_when=asyncio.FIRST_COMPLETED)
-                for task in done:
-                    task.result()
-                if worker.completed:
-                    # The stream cursor advances after handle() returns.
-                    worker.save("idle")
-            finally:
-                for task in tasks:
-                    task.cancel()
-                await asyncio.gather(*tasks, return_exceptions=True)
-                await worker.close()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--state-dir", required=True)
-    parser.add_argument("--seconds", type=int, default=900)
-    args = parser.parse_args()
-    try:
-        asyncio.run(run(args.state_dir, max(1, min(args.seconds, 1800))))
-    except KeyboardInterrupt:
-        pass
-    except (RuntimeError, httpx.HTTPError) as error:
-        print(str(error) if isinstance(error, RuntimeError) else "Network request failed.")
-        raise SystemExit(1)

package/standalone/remote/rc_tools.py

@@ -1,171 +0,0 @@
-"""Remote file-tool approval probe confined to a disposable test folder.
-
-Only Read and Edit are available; every call asks the phone. No shell, MCP,
-permission-mode changes, or arbitrary control commands are forwarded.
-"""
-
-import argparse
-import asyncio
-import copy
-from pathlib import Path
-import tempfile
-
-import httpx
-
-from rc_echo import EchoWorker, read_login
-from rc_penny import PennyClaude, PennyWorker, read_profile
-
-
-def confined_input(cwd, request, tool_input):
-    if request.get("tool_name") not in {"Read", "Edit"} or not isinstance(tool_input, dict):
-        return False
-    path = tool_input.get("file_path")
-    if not isinstance(path, str) or not path:
-        return False
-    root = Path(cwd).resolve()
-    target = Path(path)
-    if not target.is_absolute():
-        target = root / target
-    try:
-        return target.resolve().is_relative_to(root) and target.resolve() != root
-    except (OSError, ValueError):
-        return False
-
-
-class ToolsWorker(PennyWorker):
-    def __init__(self, client, oauth, profile, model, cwd):
-        super().__init__(client, oauth, profile, model, cwd)
-        self.title = "Penny file approvals test"
-        self.cwd = cwd
-        self.tools = ["Read", "Edit"]
-        self.claude = PennyClaude(profile, model, self.local_session, cwd, self.permission)
-        self.pending_permissions = {}
-        self.permission_futures = {}
-        self.inbox = asyncio.Queue(maxsize=10)
-        self.queued_ids = set()
-        self.active_turn = False
-        self.disconnect_after_turns = 0
-
-    async def permission(self, event):
-        request = event.get("request", {})
-        denied = {"behavior": "deny", "message": "Only file operations inside this test folder are permitted."}
-        if request.get("subtype") != "can_use_tool" or not confined_input(self.cwd, request, request.get("input")):
-            return denied
-        request_id = event["request_id"]
-        future = asyncio.get_running_loop().create_future()
-        saved = copy.deepcopy(event)
-        self.pending_permissions[request_id] = saved
-        self.permission_futures[request_id] = future
-        print(f"Phone approval needed: {request['tool_name']}", flush=True)
-        try:
-            await self.events({**saved, "session_id": self.local_session, "uuid": self.payload("unused")["uuid"]})
-            async with asyncio.timeout(180):
-                decision = await future
-            if decision.get("behavior") == "allow":
-                tool_input = decision.get("updatedInput", request["input"])
-                if not confined_input(self.cwd, request, tool_input):
-                    return denied
-                # Accept one tool decision, never persistent permission updates.
-                return {"behavior": "allow", "updatedInput": tool_input}
-            return {"behavior": "deny", "message": "The user denied this tool from the phone."}
-        except TimeoutError:
-            return {"behavior": "deny", "message": "Phone approval timed out."}
-        finally:
-            self.pending_permissions.pop(request_id, None)
-            self.permission_futures.pop(request_id, None)
-
-    async def handle(self, envelope):
-        event_id = envelope.get("event_id")
-        if not event_id or event_id in self.seen or event_id in self.queued_ids:
-            return
-        payload = envelope.get("payload", {})
-        kind = payload.get("type")
-        if kind == "user":
-            self.queued_ids.add(event_id)
-            await self.inbox.put(envelope)
-            return
-        if kind == "control_response":
-            await self.delivery(event_id, "received")
-            response = payload.get("response", {})
-            request_id = response.get("request_id")
-            future = self.permission_futures.get(request_id)
-            if future is not None and not future.done():
-                decision = response.get("response", {}) if response.get("subtype") == "success" else {}
-                future.set_result(decision)
-                print(f"Phone decision: {decision.get('behavior', 'deny')}", flush=True)
-            else:
-                print("Ignored unmatched permission response", flush=True)
-            await self.delivery(event_id, "processed")
-            self.seen.add(event_id)
-            return
-        if kind == "control_request" and payload.get("request", {}).get("subtype") == "interrupt":
-            await self.delivery(event_id, "received")
-            for future in self.permission_futures.values():
-                if not future.done():
-                    future.set_result({"behavior": "deny"})
-            if self.active_turn:
-                await self.claude.interrupt(payload["request_id"])
-            else:
-                await self.events(self.payload("control_response", response={
-                    "subtype": "success", "request_id": payload.get("request_id"), "response": {}}))
-            await self.delivery(event_id, "processed")
-            self.seen.add(event_id)
-            return
-        await EchoWorker.handle(self, envelope)
-
-    async def process_turns(self):
-        while not self.stopping:
-            envelope = await self.inbox.get()
-            self.active_turn = True
-            try:
-                await EchoWorker.handle(self, envelope)
-                if self.disconnect_after_turns and self.replies == self.disconnect_after_turns:
-                    self.force_reconnect.set()
-            finally:
-                self.active_turn = False
-                self.queued_ids.discard(envelope["event_id"])
-                self.inbox.task_done()
-
-
-async def run(seconds, effort="low", disconnect_after_turns=0):
-    profile, model = read_profile()
-    async with httpx.AsyncClient(headers={"anthropic-version": "2023-06-01",
-        "User-Agent": "penny-rc-file-probe/0.1"}, timeout=httpx.Timeout(30, read=None), trust_env=False) as client:
-        response = await client.get(profile["gateway_base_url"].rstrip("/") + "/health", timeout=5)
-        if response.status_code != 200:
-            raise RuntimeError("Configured Penny gateway is not healthy.")
-        with tempfile.TemporaryDirectory(prefix="penny-rc-files-") as cwd:
-            (Path(cwd) / "note.txt").write_text("original test content\n")
-            worker = ToolsWorker(client, read_login(), profile, model, cwd)
-            worker.claude.effort = effort
-            worker.disconnect_after_turns = disconnect_after_turns
-            tasks = []
-            try:
-                await worker.start()
-                print("TEST FOLDER " + cwd, flush=True)
-                tasks = [asyncio.create_task(worker.listen()), asyncio.create_task(worker.heartbeat()),
-                         asyncio.create_task(worker.process_turns())]
-                done, _ = await asyncio.wait(tasks, timeout=seconds, return_when=asyncio.FIRST_COMPLETED)
-                for task in done:
-                    task.result()
-            finally:
-                for task in tasks:
-                    task.cancel()
-                await asyncio.gather(*tasks, return_exceptions=True)
-                await worker.close()
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--seconds", type=int, default=900)
-    parser.add_argument("--effort", choices=["low", "medium", "high"], default="low")
-    parser.add_argument("--disconnect-after-turns", type=int, default=0,
-                        help="Simulate one three-second stream drop after this many completed turns")
-    args = parser.parse_args()
-    try:
-        asyncio.run(run(max(1, min(args.seconds, 1800)), args.effort, args.disconnect_after_turns))
-    except KeyboardInterrupt:
-        pass
-    except (RuntimeError, TimeoutError, httpx.HTTPError):
-        print("File approval probe stopped after a protocol, gateway, or timeout failure.")
-        raise SystemExit(1)