remote-cli 0.1.0__py3-none-any.whl

remote_cli/session.py

@@ -0,0 +1,339 @@
+"""Session management, PTY allocation, and I/O multiplexing."""
+
+import asyncio
+import datetime
+import fcntl
+import os
+import pty
+import re
+import struct
+import termios
+import uuid
+
+from .protocol import ExecResult, SessionInfo
+from .screen import RingBuffer, VirtualScreen
+from .utils import generate_session_id, strip_ansi
+
+
+class ExecWatcher:
+    """Tracks command execution via unique sentinels in output stream."""
+
+    def __init__(self, sentinel_id: str, raw_command: str):
+        self.sentinel_id = sentinel_id
+        self.raw_command = raw_command
+        self.start_marker = f"__REMOTE_CLI_START_{sentinel_id}__"
+        self.end_marker_prefix = f"__REMOTE_CLI_END_{sentinel_id}_"
+        self.end_marker_regex = re.compile(rf"{re.escape(self.end_marker_prefix)}(\d+)__")
+        self.future: asyncio.Future[ExecResult] = asyncio.get_event_loop().create_future()
+        self.buffer = ""
+        self.start_seen = False
+        self.start_time = asyncio.get_event_loop().time()
+
+    def feed(self, text: str) -> None:
+        if self.future.done():
+            return
+        self.buffer += text
+
+        # Check for end marker
+        match = self.end_marker_regex.search(self.buffer)
+        if match:
+            exit_code = int(match.group(1))
+            end_pos = match.start()
+
+            # Extract output between the executed start marker and end marker
+            content = self.buffer[:end_pos]
+            if self.start_marker in content:
+                _, _, after_start = content.rpartition(self.start_marker)
+                output = after_start
+            else:
+                output = content
+
+            # Clean output: strip ANSI codes, normalize CRLF to LF, and strip leading/trailing newlines
+            clean_output = strip_ansi(output).replace("\r\n", "\n").replace("\r", "\n").strip("\n")
+            duration = asyncio.get_event_loop().time() - self.start_time
+            result = ExecResult(
+                session_id="",
+                command=self.raw_command,
+                exit_code=exit_code,
+                output=clean_output,
+                duration=round(duration, 3),
+                timed_out=False,
+            )
+            self.future.set_result(result)
+
+
+class Session:
+    """Represents a single interactive PTY session."""
+
+    def __init__(
+        self,
+        session_id: str,
+        name: str,
+        command: list[str],
+        rows: int = 24,
+        cols: int = 80,
+    ):
+        self.session_id = session_id
+        self.name = name or session_id
+        self.command = command
+        self.rows = rows
+        self.cols = cols
+        self.created_at = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        self.status = "active"
+        self.exit_code: int | None = None
+
+        self.master_fd: int | None = None
+        self.process: asyncio.subprocess.Process | None = None
+        self.screen = VirtualScreen(cols=cols, rows=rows)
+        self.buffer = RingBuffer()
+
+        self.attached_writers: set[asyncio.StreamWriter] = set()
+        self.active_watcher: ExecWatcher | None = None
+        self.exec_lock = asyncio.Lock()
+        self.loop = asyncio.get_event_loop()
+
+    def start(self) -> None:
+        """Allocates PTY and spawns subprocess."""
+        master_fd, slave_fd = pty.openpty()
+        self.master_fd = master_fd
+
+        # Set window size on PTY
+        self._set_pty_size(master_fd, self.rows, self.cols)
+
+        # Set non-blocking master
+        flags = fcntl.fcntl(master_fd, fcntl.F_GETFL)
+        fcntl.fcntl(master_fd, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+
+        # Spawn subprocess
+        try:
+            self.process = asyncio.subprocess.Process(
+                transport=None,  # Handled directly via PTY fd
+                protocol=None,
+                loop=self.loop,
+            )
+        except Exception:
+            pass
+
+        # Use os.fork or subprocess with slave_fd
+        import subprocess
+
+        # Set slave fd inheritable
+        os.set_inheritable(slave_fd, True)
+
+        proc = subprocess.Popen(
+            self.command,
+            stdin=slave_fd,
+            stdout=slave_fd,
+            stderr=slave_fd,
+            preexec_fn=os.setsid,
+            close_fds=True,
+        )
+        os.close(slave_fd)
+        self._proc = proc
+
+        # Add reader to event loop
+        self.loop.add_reader(self.master_fd, self._on_pty_readable)
+
+    def _set_pty_size(self, fd: int, rows: int, cols: int) -> None:
+        try:
+            winsize = struct.pack("HHHH", rows, cols, 0, 0)
+            fcntl.ioctl(fd, termios.TIOCSWINSZ, winsize)
+        except Exception:
+            pass
+
+    def resize(self, rows: int, cols: int) -> None:
+        """Resizes the PTY and virtual screen."""
+        self.rows = rows
+        self.cols = cols
+        self.screen.resize(rows, cols)
+        if self.master_fd is not None:
+            self._set_pty_size(self.master_fd, rows, cols)
+
+    def _on_pty_readable(self) -> None:
+        """Callback invoked when PTY master has output to read."""
+        if self.master_fd is None:
+            return
+
+        try:
+            data = os.read(self.master_fd, 4096)
+        except (BlockingIOError, InterruptedError):
+            return
+        except OSError:
+            # PTY slave closed / child exited
+            data = b""
+
+        if not data:
+            self._on_process_exit()
+            return
+
+        # Feed screen and buffer
+        self.screen.feed(data)
+        self.buffer.append(data)
+
+        # Feed active watcher
+        if self.active_watcher:
+            text = data.decode("utf-8", errors="replace")
+            self.active_watcher.feed(text)
+
+        # Broadcast to all attached clients
+        dead_writers = set()
+        for writer in self.attached_writers:
+            try:
+                writer.write(data)
+            except Exception:
+                dead_writers.add(writer)
+
+        for writer in dead_writers:
+            self.attached_writers.discard(writer)
+
+    def _on_process_exit(self) -> None:
+        """Handles PTY close and subprocess termination."""
+        if self.master_fd is not None:
+            try:
+                self.loop.remove_reader(self.master_fd)
+                os.close(self.master_fd)
+            except Exception:
+                pass
+            self.master_fd = None
+
+        self.status = "exited"
+        if hasattr(self, "_proc") and self._proc:
+            try:
+                self._proc.poll()
+                self.exit_code = self._proc.returncode
+            except Exception:
+                pass
+
+        # Notify attached writers
+        for writer in list(self.attached_writers):
+            try:
+                writer.close()
+            except Exception:
+                pass
+        self.attached_writers.clear()
+
+        # Fail any waiting exec
+        if self.active_watcher and not self.active_watcher.future.done():
+            self.active_watcher.future.set_exception(
+                RuntimeError(f"Session {self.session_id} exited with code {self.exit_code}")
+            )
+
+    def write_input(self, data: bytes) -> None:
+        """Writes raw input bytes to the PTY."""
+        if self.master_fd is None or self.status != "active":
+            raise RuntimeError(f"Session {self.session_id} is not active")
+        try:
+            os.write(self.master_fd, data)
+        except Exception as e:
+            raise RuntimeError(f"Failed to write to session {self.session_id}: {e}") from e
+
+    def attach_client(self, writer: asyncio.StreamWriter) -> None:
+        """Registers a client stream for live output broadcast."""
+        self.attached_writers.add(writer)
+
+    def detach_client(self, writer: asyncio.StreamWriter) -> None:
+        """Unregisters a client stream."""
+        self.attached_writers.discard(writer)
+
+    async def execute_command(self, command: str, timeout: float = 30.0) -> ExecResult:
+        """Executes a command and waits for completion sentinel."""
+        async with self.exec_lock:
+            if self.master_fd is None or self.status != "active":
+                raise RuntimeError(f"Session {self.session_id} is not active")
+
+            sentinel_id = uuid.uuid4().hex[:12]
+            watcher = ExecWatcher(sentinel_id, command)
+            self.active_watcher = watcher
+
+            # Format injection with POSIX printf for clean delimiter detection
+            # Command: printf "\n%s\n" "<START>"; <CMD>; printf "\n%s%d__\n" "<END_PREFIX>" "$?"
+            cmd_payload = (
+                f'printf "\\n%s\\n" "{watcher.start_marker}"; '
+                f"{command}; "
+                f'printf "\\n%s%d__\\n" "{watcher.end_marker_prefix}" "$?"\n'
+            )
+
+            self.write_input(cmd_payload.encode("utf-8"))
+
+            try:
+                result = await asyncio.wait_for(watcher.future, timeout=timeout)
+                result.session_id = self.session_id
+                return result
+            except TimeoutError:
+                # Capture partial output
+                partial_output = strip_ansi(watcher.buffer).strip("\r\n")
+                duration = self.loop.time() - watcher.start_time
+                return ExecResult(
+                    session_id=self.session_id,
+                    command=command,
+                    exit_code=None,
+                    output=partial_output,
+                    duration=round(duration, 3),
+                    timed_out=True,
+                )
+            finally:
+                self.active_watcher = None
+
+    def close(self) -> None:
+        """Terminates the session and kills process."""
+        if hasattr(self, "_proc") and self._proc:
+            try:
+                self._proc.terminate()
+            except Exception:
+                pass
+        self._on_process_exit()
+
+    def get_info(self) -> SessionInfo:
+        return SessionInfo(
+            session_id=self.session_id,
+            name=self.name,
+            command=self.command,
+            created_at=self.created_at,
+            status=self.status,
+            exit_code=self.exit_code,
+            attached_clients=len(self.attached_writers),
+            rows=self.rows,
+            cols=self.cols,
+        )
+
+
+class SessionManager:
+    """Manages all active sessions."""
+
+    def __init__(self):
+        self.sessions: dict[str, Session] = {}
+
+    def create_session(
+        self,
+        command: list[str],
+        name: str | None = None,
+        rows: int = 24,
+        cols: int = 80,
+    ) -> Session:
+        session_id = generate_session_id()
+        session_name = name or f"session-{session_id}"
+        session = Session(
+            session_id=session_id,
+            name=session_name,
+            command=command,
+            rows=rows,
+            cols=cols,
+        )
+        session.start()
+        self.sessions[session_id] = session
+        return session
+
+    def get_session(self, session_id: str) -> Session | None:
+        return self.sessions.get(session_id)
+
+    def list_sessions(self) -> list[SessionInfo]:
+        # Cleanup exited sessions older than threshold if needed or return all
+        return [session.get_info() for session in self.sessions.values()]
+
+    def close_session(self, session_id: str) -> bool:
+        session = self.sessions.get(session_id)
+        if session:
+            session.close()
+            del self.sessions[session_id]
+            return True
+        return False

remote_cli/terminal.py

@@ -0,0 +1,137 @@
+"""Terminal raw mode handling, window resize, and interactive attach client."""
+
+import json
+import os
+import select
+import signal
+import socket
+import sys
+import termios
+import tty
+from pathlib import Path
+
+from .client import Client
+from .protocol import ActionType, Request, Response
+from .utils import get_socket_path
+
+ESCAPE_KEY = b"\x1d"  # Ctrl+]
+
+
+def get_terminal_size() -> tuple[int, int]:
+    """Returns (rows, cols) for the current terminal."""
+    try:
+        sz = os.get_terminal_size()
+        return sz.lines, sz.columns
+    except Exception:
+        return 24, 80
+
+
+def attach_session(session_id: str, socket_path: Path | None = None) -> None:
+    """Attaches current terminal in raw mode to a remote-cli session."""
+    sock_path = socket_path or get_socket_path()
+    if not sock_path.exists():
+        print(f"Error: Daemon socket {sock_path} not found.", file=sys.stderr)
+        return
+
+    rows, cols = get_terminal_size()
+
+    # Connect to daemon
+    s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+    try:
+        s.connect(str(sock_path))
+    except Exception as e:
+        print(f"Error connecting to daemon: {e}", file=sys.stderr)
+        return
+
+    # Send ATTACH request
+    req = Request(
+        action=ActionType.ATTACH,
+        session_id=session_id,
+        rows=rows,
+        cols=cols,
+    )
+    s.sendall((req.model_dump_json() + "\n").encode("utf-8"))
+
+    # Read acknowledgment
+    resp_line = b""
+    while b"\n" not in resp_line:
+        chunk = s.recv(1024)
+        if not chunk:
+            break
+        resp_line += chunk
+
+    try:
+        resp = Response.model_validate(json.loads(resp_line.decode("utf-8").strip()))
+        if not resp.success:
+            print(f"Failed to attach: {resp.error or resp.message}", file=sys.stderr)
+            s.close()
+            return
+    except Exception as e:
+        print(f"Invalid attach response from server: {e}", file=sys.stderr)
+        s.close()
+        return
+
+    # Save original terminal attributes
+    stdin_fd = sys.stdin.fileno()
+    is_tty = os.isatty(stdin_fd)
+    old_attrs = None
+    if is_tty:
+        old_attrs = termios.tcgetattr(stdin_fd)
+
+    client_helper = Client(socket_path=sock_path)
+
+    # SIGWINCH handler
+    def handle_sigwinch(signum, frame):
+        try:
+            r, c = get_terminal_size()
+            client_helper.resize(session_id, rows=r, cols=c)
+        except Exception:
+            pass
+
+    old_sigwinch = None
+    try:
+        old_sigwinch = signal.signal(signal.SIGWINCH, handle_sigwinch)
+    except Exception:
+        pass
+
+    try:
+        if is_tty:
+            tty.setraw(stdin_fd)
+
+        # Main select loop
+        running = True
+        sock_fd = s.fileno()
+
+        while running:
+            rlist, _, _ = select.select([stdin_fd, sock_fd], [], [])
+
+            if sock_fd in rlist:
+                data = s.recv(4096)
+                if not data:
+                    # Session exited or socket closed
+                    break
+                os.write(sys.stdout.fileno(), data)
+
+            if stdin_fd in rlist:
+                data = os.read(stdin_fd, 1024)
+                if not data:
+                    break
+                # Check for detach escape key (Ctrl+])
+                if ESCAPE_KEY in data:
+                    # Print detach notice after restoring terminal
+                    break
+                s.sendall(data)
+
+    except (KeyboardInterrupt, BrokenPipeError, ConnectionResetError):
+        pass
+    finally:
+        # Restore terminal settings
+        if is_tty and old_attrs is not None:
+            termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_attrs)
+        if old_sigwinch is not None:
+            try:
+                signal.signal(signal.SIGWINCH, old_sigwinch)
+            except Exception:
+                pass
+        s.close()
+        print("\n[Detached from session]")

remote_cli/utils.py

@@ -0,0 +1,40 @@
+"""Utility functions for remote-cli."""
+
+import os
+import re
+import uuid
+from pathlib import Path
+
+ANSI_ESCAPE_REGEX = re.compile(r"\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])")
+
+
+def get_base_dir() -> Path:
+    """Returns the base directory for remote-cli configuration and sockets."""
+    base = Path(os.environ.get("REMOTE_CLI_DIR", Path.home() / ".remote-cli"))
+    base.mkdir(parents=True, exist_ok=True)
+    return base
+
+
+def get_socket_path() -> Path:
+    """Returns the Unix domain socket path."""
+    return get_base_dir() / "remote-cli.sock"
+
+
+def get_pid_path() -> Path:
+    """Returns the daemon PID file path."""
+    return get_base_dir() / "remote-cli.pid"
+
+
+def get_log_path() -> Path:
+    """Returns the daemon log file path."""
+    return get_base_dir() / "daemon.log"
+
+
+def generate_session_id() -> str:
+    """Generates a short, user-friendly session ID."""
+    return f"s_{uuid.uuid4().hex[:8]}"
+
+
+def strip_ansi(text: str) -> str:
+    """Strips ANSI escape codes from string."""
+    return ANSI_ESCAPE_REGEX.sub("", text)

remote_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,166 @@
+Metadata-Version: 2.5
+Name: remote-cli
+Version: 0.1.0
+Summary: A shared SSH CLI tool for AI Agent and human co-piloting
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: pydantic>=2.10.0
+Requires-Dist: pyte>=0.8.2
+Requires-Dist: rich>=13.9.0
+Requires-Dist: typer>=0.15.0
+Description-Content-Type: text/markdown
+
+# remote-cli
+
+> **Shared SSH & Terminal CLI tool for AI Agent and Human Co-piloting.**
+
+`remote-cli` allows a human user to start an interactive SSH session (handling passwords, 2FA, bastion hosts, and SSH keys themselves) and share that session with an AI Agent via a unique `session-id`.
+
+---
+
+## Key Features
+
+- 🤝 **Real-Time Human & Agent Co-piloting**:
+  - The human sees everything the Agent does in their original terminal window in real-time.
+  - The human can continue typing and operating in the same session at any time.
+- ⚡ **Zero External Binary Dependencies**:
+  - Pure Python + POSIX PTY (`pty.openpty`, `termios`, `tty`).
+  - No need to install `tmux` or `screen` on local or remote servers.
+- 🤖 **First-Class AI Agent Support**:
+  - `exec`: Structured execution of shell commands with stdout capture and return codes.
+  - `snapshot`: In-memory 2D virtual terminal rendering (`pyte`) for clean screen capture (even for ncurses / curses / colored prompts).
+  - `send`: Keystrokes and control signals (`Ctrl+C`, `Ctrl+D`, confirmation answers `y/n`).
+  - `logs`: Fast access to recent scrollback history.
+- 🔌 **Seamless Background Daemon**:
+  - Communicates via Unix Domain Sockets (`~/.remote-cli/remote-cli.sock`).
+  - Transparently auto-starts in the background on demand.
+  - Safely detach (`Ctrl+]`) and re-attach (`remote-cli attach <session-id>`) anytime.
+
+---
+
+## Installation & Setup
+
+Using [`uv`](https://github.com/astral-sh/uv):
+
+```bash
+# Clone the repository
+git clone https://github.com/your-username/remote-cli.git
+cd remote-cli
+
+# Install dependencies and create venv
+uv sync
+
+# Run directly via uv
+uv run remote-cli --help
+```
+
+---
+
+## Quickstart & Workflow
+
+### 1. Human Starts SSH Session
+The user initiates the SSH connection to the remote machine. Once connected and authenticated, a `Session ID` is displayed:
+
+```bash
+uv run remote-cli ssh user@server.example.com
+```
+
+Output:
+```text
+╭────────────────────── remote-cli SSH Session ──────────────────────╮
+│ Session Created: s_7f8a9b2c                                        │
+│ Agent Command: remote-cli exec s_7f8a9b2c "<command>"               │
+│ Press Ctrl+] to detach from session at any time.                  │
+╰────────────────────────────────────────────────────────────────────╯
+user@server.example.com's password: ***
+user@server:~$ _
+```
+
+> **Tip**: You can also create local shell sessions for testing:
+> ```bash
+> uv run remote-cli session create --name my-session -- /bin/bash
+> ```
+
+---
+
+### 2. Share `session-id` with AI Agent
+
+Simply tell your AI Agent:
+> *"I have logged into the server. The session ID is `s_7f8a9b2c`. Please check the disk space and restart Nginx."*
+
+The Agent can now execute commands on the remote server via `remote-cli`:
+
+```bash
+# Agent runs a command and captures return code and stdout
+uv run remote-cli exec s_7f8a9b2c "df -h"
+
+# Agent runs a command with JSON output
+uv run remote-cli exec s_7f8a9b2c "systemctl status nginx" --json
+
+# Agent inspects the current 2D screen state
+uv run remote-cli snapshot s_7f8a9b2c
+
+# Agent sends an interactive response (e.g. confirming a prompt)
+uv run remote-cli send s_7f8a9b2c "y"
+
+# Agent sends Ctrl+C to interrupt a long-running process
+uv run remote-cli send s_7f8a9b2c --ctrl-c
+```
+
+---
+
+### 3. Human Observation & Intervention
+
+While the Agent is executing commands, the human user sees all command text and outputs scrolling in real time in their terminal window. If needed, the human can type commands directly into that same terminal window.
+
+---
+
+## CLI Command Reference
+
+| Command | Description |
+| :--- | :--- |
+| `remote-cli ssh [SSH_ARGS...]` | Start SSH session, print Session ID, and attach immediately |
+| `remote-cli session create [-d] [-- <CMD...>]` | Create a new session (default: `/bin/bash`) |
+| `remote-cli session list` (or `ls`) | List all active and recent sessions |
+| `remote-cli session attach <ID>` (or `attach`) | Attach terminal in raw mode to existing session |
+| `remote-cli session close <ID>` | Close and terminate a session |
+| `remote-cli exec <ID> "<COMMAND>"` | Execute command in session, capture output & exit code |
+| `remote-cli send <ID> [TEXT]` | Send raw keystrokes or control keys (`--ctrl-c`, `--ctrl-d`) |
+| `remote-cli snapshot <ID>` | Capture 2D terminal screen state (ANSI-rendered) |
+| `remote-cli logs <ID> [-n LINES]` | View recent output scrollback logs |
+| `remote-cli daemon start / stop / status` | Manage background daemon lifecycle |
+
+---
+
+## Architecture
+
+```text
+┌─────────────────────────┐          ┌───────────────────────────┐
+│   Human User Terminal   │          │     AI Agent / Script     │
+│       (Raw Mode)        │          │ (remote-cli exec/snapshot)│
+└────────────┬────────────┘          └─────────────┬─────────────┘
+             │                                     │
+             │   Attach (Stdin/Stdout stream)      │ JSON Request/Response
+             ▼                                     ▼
+   ┌─────────────────────────────────────────────────────────────┐
+   │             remote-cli Daemon Process                       │
+   │       (Unix Domain Socket: ~/.remote-cli/remote-cli.sock)   │
+   │                                                             │
+   │  ┌────────────────────────────────────────────────────────┐ │
+   │  │ Session (e.g. s_7f8a9b2c)                              │ │
+   │  │  - Master/Slave PTY (`pty.openpty`)                    │ │
+   │  │  - Pyte Virtual Terminal Screen (`pyte.HistoryScreen`) │ │
+   │  │  - Scrollback Ring Buffer                              │ │
+   │  │  - Exec Sentinel Detection Engine                      │ │
+   │  │  - Process: `ssh user@remote-server` (or local shell)  │ │
+   │  └────────────────────────────────────────────────────────┘ │
+   └─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## Running Tests
+
+```bash
+uv run pytest -v
+```

remote_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+remote_cli/__init__.py,sha256=eF8390oxxMkXcnOMf8r3g6Qf1Vc3CI4pAIeHiZQMOqw,434
+remote_cli/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+remote_cli/cli.py,sha256=YEAJGVdmLGKqo4vNzm0xtR-e6G_XZKBl7f5IpaG87QE,10103
+remote_cli/client.py,sha256=7FwKDDHUbpfmBSC2d_XwtPdd6-sZGFXSy2h9fYuhEF4,5281
+remote_cli/daemon.py,sha256=3YmFhX5BaTfcYteUCWz3M4z6e4dwpZU8A0LPeoxVkZE,10036
+remote_cli/protocol.py,sha256=LnQcgWlkOZZZ6pQoRy-KW9pwfcNdGS-qwCVWYL-tu1I,1507
+remote_cli/screen.py,sha256=Tj9L0XFnMhIMCKkoO3y4qBomcqkeOscevuMj-mRtK2c,2326
+remote_cli/session.py,sha256=XbQq7VI9iUm-lWhOYnWV82eGxnRWM6FU9R8-hfS9GA4,11385
+remote_cli/terminal.py,sha256=LNUaiENiMSOuOBDBVLNGFc9KJ5fXEmbDVOLvFnXzor0,3865
+remote_cli/utils.py,sha256=W_6bLxi8ylVgyvRevLvieR8__Lj0r1xAHqtpcbI4ARs,1037
+remote_cli-0.1.0.dist-info/METADATA,sha256=e4S1atGcBirjXulC3FEn2_8sQitragAAVbU1pOgNwzI,7264
+remote_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+remote_cli-0.1.0.dist-info/entry_points.txt,sha256=7XpsEnHYQZF3EG7dsfxiVeP7ZFcpFZ0Q2ezW7n-ThaQ,50
+remote_cli-0.1.0.dist-info/licenses/LICENSE,sha256=DWcolN0n9Am669uQA1E04dsdunFqNcqXk5YsOR8xS5o,1065
+remote_cli-0.1.0.dist-info/RECORD,,