remotivelabs-cli 0.5.0a1__py3-none-any.whl

remotivelabs/cli/cloud/recordings_playback.py

@@ -0,0 +1,274 @@
+from __future__ import annotations
+
+import datetime
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any, List, Union
+
+import grpc
+import typer
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from remotivelabs.cli.broker.lib.broker import Broker, SubscribableSignal
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_error, print_generic_message, print_grpc_error, print_hint, print_unformatted
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+app = typer_utils.create_typer(
+    help="""
+Support for playback of a recording on a cloud broker, make sure to always mount a recording first
+"""
+)
+
+
+@app.command()
+def play(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+    show_progress: bool = typer.Option(False, help="Show progress after started playing"),
+    repeat: bool = typer.Option(False, help="Repeat recording - must keep command running in terminal"),
+) -> None:
+    """
+    Start playing a recording.
+    There is no problem invoking play multiple times since if it is already playing the command will be ignored.
+    Use --repeat to have the recording replayed when it reaches the end.
+    """
+
+    _do_change_playback_mode("play", recording_session, broker, project, progress_on_play=show_progress, repeat=repeat)
+
+
+@app.command()
+def pause(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Pause a recording
+    """
+    _do_change_playback_mode("pause", recording_session, broker, project)
+
+
+@app.command()
+def progress(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Shows progress of the recording playing.
+    Use --repeat to have the recording replayed when it reaches the end.
+    """
+    _do_change_playback_mode("status", recording_session, broker, project)
+
+
+@app.command()
+def seek(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    seconds: int = typer.Option(..., min=0, help="Target offset in seconds"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Seek seconds into a recording
+    """
+    _do_change_playback_mode("seek", recording_session, broker, project, seconds)
+
+
+@app.command()
+def stop(
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Stop playing
+    """
+    _do_change_playback_mode("stop", recording_session, broker, project)
+
+
+# Copied from signals.py
+def read_scripted_code_file(file_path: Path) -> bytes:
+    # typer checks that the Path exists
+    with open(file_path, "rb") as file:
+        return file.read()
+
+
+@app.command()
+def subscribe(  # noqa: PLR0913
+    recording_session: str = typer.Argument(..., help="Recording session id", envvar="REMOTIVE_CLOUD_RECORDING_SESSION"),
+    broker: str = typer.Option(None, help="Broker to use"),
+    signal: List[str] = typer.Option(None, help="Signal names to subscribe to, mandatory when not using script"),
+    script: Path = typer.Option(
+        None,
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        writable=False,
+        readable=True,
+        resolve_path=True,
+        help="Supply a path to Lua script that to use for signal transformation",
+    ),
+    on_change_only: bool = typer.Option(default=False, help="Only get signal if value is changed"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    """
+    Allows you to subscribe to signals based on a mounted recording without knowing the broker URL.
+    This simplifies when playing recordings from the cloud.
+
+    Terminal plotting is not yet supported here so we refer to remotive broker signals subscribe --x-plot for this.
+    """
+    if script is None:
+        if len(signal) == 0:
+            print_generic_error("You must use include at least one signal and one namespace or use script when subscribing")
+            sys.exit(1)
+    if script is not None:
+        if len(signal) > 0:
+            print_generic_error("You must must not specify --signal when using --script")
+            sys.exit(1)
+
+    broker_client = _get_broker_info(project, recording_session, broker, "subscribe")
+
+    try:
+        if script is not None:
+            script_src = read_scripted_code_file(script)
+            broker_client.subscribe_on_script(script_src, lambda sig: print_generic_message(json.dumps(list(sig))), on_change_only)
+        else:
+
+            def to_subscribable_signal(sig: str):
+                arr = sig.split(":")
+                if len(arr) != 2:
+                    print_hint(f"--signal must have format namespace:signal ({sig})")
+                    sys.exit(1)
+                return SubscribableSignal(namespace=arr[0], name=arr[1])
+
+            signals_to_subscribe_to = list(map(to_subscribable_signal, signal))
+            broker_client.long_name_subscribe(
+                signals_to_subscribe_to, lambda sig: print_generic_message(json.dumps(list(sig))), on_change_only
+            )
+            print_generic_message("Subscribing to signals, press Ctrl+C to exit")
+    except grpc.RpcError as rpc_error:
+        print_grpc_error(rpc_error)
+
+    except Exception as e:
+        print_generic_error(str(e))
+        sys.exit(1)
+
+
+def _do_change_playback_mode(  # noqa: C901, PLR0913, PLR0912
+    mode: str,
+    recording_session: str,
+    brokerstr: str,
+    project: str,
+    seconds: int | None = None,
+    progress_on_play: bool = False,
+    repeat: bool = False,
+) -> None:
+    response = Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+    if response is None:
+        return
+    r = json.loads(response.text)
+    enabled_recordings: List[Any] = [r for r in r["recordings"] if r["enabled"]]
+    files = [{"recording": rec["fileName"], "namespace": rec["metadata"]["namespace"]} for rec in enabled_recordings]
+
+    broker_name = brokerstr if brokerstr is not None else "personal"
+    response = Rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
+    if response is None:
+        return
+    if response.status_code == 404:
+        broker_arg = ""
+        if brokerstr is not None:
+            broker_arg = f" --broker {brokerstr} --ensure-broker-started"
+        print_generic_error("You need to mount the recording before you play")
+        print_hint(f"remotive cloud recordings mount {recording_session}{broker_arg} --project {project}")
+        sys.exit(1)
+
+    broker_info = json.loads(response.text)
+    broker = Broker(broker_info["url"], None)
+
+    _verify_recording_on_broker(broker, recording_session, mode, project)
+
+    if mode == "pause":
+        broker.pause_play(files, True)
+    elif mode == "play":
+        broker.play(files, True)
+        if progress_on_play or repeat:
+            _track_progress(broker, repeat, files)
+    elif mode == "seek":
+        if seconds is not None:
+            broker.seek(files, int(seconds * 1000000), True)
+        else:
+            broker.seek(files, 0, True)
+    elif mode == "stop":
+        broker.seek(files, 0, True)
+    elif mode == "status":
+        _track_progress(broker, repeat, files)
+    else:
+        raise ValueError(f"Illegal command {mode}")
+
+
+def _track_progress(broker: Broker, repeat: bool, files: List[Any]) -> None:
+    p = Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), transient=True)
+    t = p.add_task("label", total=1)
+    if repeat:
+        print_unformatted(":point_right: Keep this command running in terminal to keep the recording play with repeat")
+    with p:
+
+        def print_progress(offset: int, total: int, current_mode: str) -> None:
+            p.update(
+                t,
+                description=f"{(datetime.timedelta(seconds=offset))} / {(datetime.timedelta(seconds=total))} ({current_mode})",
+            )
+
+        broker.listen_on_playback(repeat, files, print_progress)
+
+
+def _verify_recording_on_broker(broker: Broker, recording_session: str, mode: str, project: str) -> None:
+    try:
+        # Here we try to verify that we are operating on a recording that is mounted on the
+        # broker so we can verify this before we try playback and can also present some good
+        # error messages
+        tmp = os.path.join(tempfile.gettempdir(), os.urandom(24).hex())
+        broker.download(".cloud.context", tmp, True)
+        with open(tmp, "r", encoding="utf8") as f:
+            json_context = json.loads(f.read())
+            if json_context["recordingSessionId"] != recording_session:
+                print_generic_error(
+                    f"The recording id mounted is '{json_context['recordingSessionId']}' "
+                    f"which not the same as you are trying to {mode}, use cmd below to mount this recording"
+                )
+                print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
+                sys.exit(1)
+    except grpc.RpcError as rpc_error:
+        if rpc_error.code() == grpc.StatusCode.NOT_FOUND:
+            print_generic_error(f"You must use mount to prepare a recording before you can use {mode}")
+            print_hint(f"remotive cloud recordings mount {recording_session} --project {project}")
+        else:
+            print_grpc_error(rpc_error)
+        sys.exit(1)
+
+
+def _get_broker_info(project: str, recording_session: str, broker: Union[str, None], mode: str) -> Broker:
+    # Verify it exists
+    Rest.handle_get(f"/api/project/{project}/files/recording/{recording_session}", return_response=True)
+
+    broker_name = broker if broker is not None else "personal"
+    response = Rest.handle_get(f"/api/project/{project}/brokers/{broker_name}", return_response=True, allow_status_codes=[404])
+    if response is None:
+        print_generic_error(f"No response from: /api/project/{project}/brokers/{broker_name}")
+        sys.exit(1)
+    if response.status_code == 404:
+        broker_arg = ""
+        if broker is not None:
+            broker_arg = f"--broker {broker} --ensure-broker-started"
+        print_generic_error("You need to mount the recording before you play")
+        print_hint(f"remotive cloud recordings mount {recording_session} {broker_arg} --project {project}")
+        sys.exit(1)
+    broker_info = json.loads(response.text)
+    broker_client = Broker(broker_info["url"], None)
+    _verify_recording_on_broker(broker_client, recording_session, mode, project)
+    return broker_client

remotivelabs/cli/cloud/resumable_upload.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Dict
+
+import requests
+from rich.progress import wrap_file
+
+from remotivelabs.cli.utils.console import print_generic_error, print_success
+
+
+def __get_uploaded_bytes(upload_url: str) -> int:
+    headers = {"Content-Range": "bytes */*"}
+    response = requests.put(upload_url, headers=headers, timeout=60)
+    if response.status_code != 308:
+        raise ValueError(f"Failed to retrieve upload status: {response.status_code} {response.text}")
+
+    # Parse the Range header to get the last byte uploaded
+    range_header = response.headers.get("Range")
+    if range_header:
+        last_byte = int(range_header.split("-")[1])
+        return last_byte + 1
+    return 0
+
+
+def with_resumable_upload_signed_url(signed_url: str, source_file_name: str, content_type: str) -> None:
+    """
+    Upload file to file storage with signed url and resumable upload.
+    Resumable upload will only work with the same URL and not if a new signed URL is requested with the
+    same object id.
+    :param content_type:
+    :param signed_url:
+    :param source_file_name:
+    :return:
+    """
+
+    file_size = os.path.getsize(source_file_name)
+    headers = {"x-goog-resumable": "start", "content-type": content_type}
+    response = requests.post(signed_url, headers=headers, timeout=60)
+    if response.status_code not in (200, 201, 308):
+        print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+        sys.exit(1)
+
+    upload_url = response.headers["Location"]
+
+    # Check how many bytes have already been uploaded
+    uploaded_bytes = __get_uploaded_bytes(upload_url)
+
+    # Upload the remaining file in chunks
+    # Not sure what a good chunk size is or if we even should have resumable uploads here, probably not..
+    chunk_size = 256 * 1024 * 10
+    # Upload the file in chunks
+    with open(source_file_name, "rb") as f:
+        with wrap_file(f, os.stat(source_file_name).st_size, description=f"Uploading {source_file_name}...") as file:
+            file.seek(uploaded_bytes)  # Seek to the position of the last uploaded byte
+            for chunk_start in range(uploaded_bytes, file_size, chunk_size):
+                chunk_end = min(chunk_start + chunk_size, file_size) - 1
+                chunk = file.read(chunk_end - chunk_start + 1)
+                headers = {"Content-Range": f"bytes {chunk_start}-{chunk_end}/{file_size}"}
+                response = requests.put(upload_url, headers=headers, data=chunk, timeout=60)
+                if response.status_code not in (200, 201, 308):
+                    print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+                    sys.exit(1)
+
+    print_success(f"File {source_file_name} uploaded successfully.")
+
+
+def upload_signed_url(signed_url: str, source_file_name: Path, headers: Dict[str, str]) -> None:
+    """
+    Upload file to file storage with signed url and resumable upload.
+    Resumable upload will only work with the same URL and not if a new signed URL is requested with the
+    same object id.
+    :param headers:
+    :param signed_url:
+    :param source_file_name:
+    :return:
+    """
+    with open(source_file_name, "rb") as file:
+        with wrap_file(file, os.stat(source_file_name).st_size, description=f"Uploading {source_file_name}...") as f:
+            response = requests.put(signed_url, headers=headers, timeout=60, data=f)
+            if response.status_code not in (200, 201, 308):
+                print_generic_error(f"Failed to upload file: {response.status_code} - {response.text}")
+                sys.exit(1)
+
+    print_success(f"File {source_file_name} uploaded successfully.")

remotivelabs/cli/cloud/sample_recordings.py

@@ -0,0 +1,25 @@
+import json
+
+import typer
+
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+app = typer_utils.create_typer()
+
+
+@app.command(name="import", help="Import sample recording into project")
+def do_import(
+    recording_session: str = typer.Argument(..., help="Recording session id"),
+    project: str = typer.Option(..., help="Project to import sample recording into", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    Rest.handle_post(url=f"/api/samples/files/recording/{recording_session}/copy", body=json.dumps({"projectUid": project}))
+
+
+@app.command("list")
+def list() -> None:
+    """
+    List available sample recordings
+    """
+
+    Rest.handle_get("/api/samples/files/recording")

remotivelabs/cli/cloud/service_account_tokens.py

@@ -0,0 +1,62 @@
+import json
+
+import typer
+
+from remotivelabs.cli.settings import settings
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_generic_message, print_success
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+app = typer_utils.create_typer()
+
+
+# TODO: add add interactive flag to set target directory
+@app.command(name="create", help="Create and download a new service account access token")
+def create(
+    expire_in_days: int = typer.Option(default=365, help="Number of this token is valid"),
+    service_account: str = typer.Option(..., help="Service account name"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    response = Rest.handle_post(
+        url=f"/api/project/{project}/admin/accounts/{service_account}/keys",
+        return_response=True,
+        body=json.dumps({"daysUntilExpiry": expire_in_days}),
+    )
+
+    sat = settings.add_service_account_token(response.text)
+    print_success(f"Service account access token added: {sat.name}")
+    print_generic_message("This file contains secrets and must be kept safe")
+
+
+@app.command(name="list", help="List service account access tokens")
+def list_tokens(
+    service_account: str = typer.Option(..., help="Service account name"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    Rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys")
+
+
+@app.command(name="describe", help="Describe service account access token")
+def describe(
+    name: str = typer.Argument(..., help="Access token name"),
+    service_account: str = typer.Option(..., help="Service account name"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    Rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}")
+
+
+@app.command(name="revoke", help="Revoke service account access token")
+def revoke(
+    name: str = typer.Argument(..., help="Access token name"),
+    delete: bool = typer.Option(True, help="Also deletes the token after revocation"),
+    service_account: str = typer.Option(..., help="Service account name"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    res = Rest.handle_get(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}", return_response=True)
+    if not res.json()["revoked"]:
+        Rest.handle_patch(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}/revoke", quiet=True)
+    if delete:
+        Rest.handle_delete(f"/api/project/{project}/admin/accounts/{service_account}/keys/{name}", quiet=True)
+        token_with_name = [token for token in settings.list_service_account_token_files() if token.name == name]
+        if len(token_with_name) > 0:
+            settings.remove_token_file(name)

remotivelabs/cli/cloud/service_accounts.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+import json
+from typing import List
+
+import typer
+
+from remotivelabs.cli.cloud import service_account_tokens
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+app = typer_utils.create_typer()
+
+
+@app.command(name="list", help="List service-accounts")
+def list_service_accounts(project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT")) -> None:
+    Rest.handle_get(f"/api/project/{project}/admin/accounts")
+
+
+ROLES_DESCRIPTION = """
+    [bold]Supported roles [/bold]
+    project/admin          - Full project support, view, edit, delete and manage users
+    project/user           - View, edit, upload, delete but no admin
+    project/viewer         - View only
+    project/storageCreator - Can upload to storage but not view, overwrite or delete
+    org/topologyRunner     - Can start RemotiveTopology
+"""
+
+
+@app.command(
+    name="create",
+    help=f"""
+    Create a new service account with one or more roles.
+
+    [bold]Must only use lowercase letters, digits, or dashes, and must not contain -- or end with a dash.[/bold]
+
+    remotive cloud service-accounts create --role project/user --role project/storageCreator
+    {ROLES_DESCRIPTION}
+    """,
+)
+def create_service_account(
+    name: str,
+    role: List[str] = typer.Option(..., help="Roles to apply"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    data = {"name": name, "roles": role}
+    Rest.handle_post(url=f"/api/project/{project}/admin/accounts", body=json.dumps(data))
+
+
+@app.command(
+    name="update",
+    help=f"""
+    Update an existing service account with one or more roles.
+
+    remotive cloud service-accounts update --role project/user --role project/storageCreator
+    {ROLES_DESCRIPTION}
+    """,
+)
+def update_service_account(
+    service_account: str = typer.Argument(..., help="Service account name"),
+    role: List[str] = typer.Option(..., help="Roles to apply"),
+    project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT"),
+) -> None:
+    Rest.handle_put(url=f"/api/project/{project}/admin/accounts/{service_account}", body=json.dumps({"roles": role}))
+
+
+@app.command(name="delete", help="Delete service account")
+def delete_service_account(name: str, project: str = typer.Option(..., help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT")) -> None:
+    Rest.handle_delete(url=f"/api/project/{project}/admin/accounts/{name}")
+
+
+app.add_typer(service_account_tokens.app, name="tokens", help="Manage project service account access tokens")

remotivelabs/cli/cloud/storage/__init__.py

@@ -0,0 +1,5 @@
+from remotivelabs.cli.cloud.storage.cmd import app
+from remotivelabs.cli.cloud.storage.uri_or_path import UriOrPath
+from remotivelabs.cli.cloud.uri import URI
+
+__all__ = ["URI", "UriOrPath", "app"]

remotivelabs/cli/cloud/storage/cmd.py

@@ -0,0 +1,76 @@
+import sys
+
+import typer
+from typing_extensions import Annotated
+
+from remotivelabs.cli.cloud.storage.copy import copy
+from remotivelabs.cli.cloud.storage.uri_or_path import UriOrPath
+from remotivelabs.cli.cloud.storage.uri_or_path import uri as uri_parser
+from remotivelabs.cli.cloud.uri import URI, InvalidURIError, JoinURIError
+from remotivelabs.cli.typer import typer_utils
+from remotivelabs.cli.utils.console import print_hint
+from remotivelabs.cli.utils.rest_helper import RestHelper as Rest
+
+HELP = """
+Manage files ([yellow]Beta feature not available for all customers[/yellow])
+
+Copy file from local to remote storage and vice versa, list and delete files.
+"""
+
+app = typer_utils.create_typer(rich_markup_mode="rich", help=HELP)
+
+
+@app.command(name="ls")
+def list_files(
+    project: Annotated[str, typer.Option(help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT", show_default=False)],
+    uri: Annotated[URI, typer.Argument(help="Remote storage path", parser=URI)] = "rcs://",  # type: ignore
+) -> None:
+    """
+    Listing remote files
+
+    This will list files and directories in project top level directory
+    remotive cloud storage ls rcs://
+
+    This will list all files and directories matching the path
+    remotive cloud storage ls rcs://fileOrDirectoryPrefix
+
+    This will list all files and directories in the specified directory
+    remotive cloud storage ls rcs://fileOrDirectory/
+    """
+    Rest.handle_get(f"/api/project/{project}/files/storage{uri.path}")
+
+
+@app.command(name="rm")
+def delete_file(
+    project: Annotated[str, typer.Option(help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT", show_default=False)],
+    uri: Annotated[URI, typer.Argument(help="Remote storage path", parser=URI, show_default=False)],
+) -> None:
+    """
+    [red]Deletes[/red] a file from remote storage, this cannot be undone :fire:
+
+    [white]remotive cloud storage rm rcs://directory/filename[/white]
+    """
+    Rest.handle_delete(f"/api/project/{project}/files/storage{uri.path}")
+
+
+@app.command(name="cp")
+def copy_file(
+    project: Annotated[str, typer.Option(help="Project ID", envvar="REMOTIVE_CLOUD_PROJECT", show_default=False)],
+    source: Annotated[UriOrPath, typer.Argument(help="Remote or local path to source file", parser=uri_parser, show_default=False)],
+    dest: Annotated[UriOrPath, typer.Argument(help="Remote or local path to destination file", parser=uri_parser, show_default=False)],
+    overwrite: Annotated[bool, typer.Option(help="Overwrite existing file on RCS")] = False,
+) -> None:
+    """
+    Copies a file to or from remote storage
+
+    remotive cloud storage cp rcs://dir/filename .
+    remotive cloud storage cp rcs://dir/filename filename
+
+    remotive cloud storage cp filename rcs://dir/
+    remotive cloud storage cp filename rcs://dir/filename
+    """
+    try:
+        return copy(project=project, source=source.value, dest=dest.value, overwrite=overwrite)
+    except (InvalidURIError, JoinURIError, ValueError, FileNotFoundError, FileExistsError) as e:
+        print_hint(str(e))
+        sys.exit(1)