mirrorneuron-cli 1.0.0__py3-none-any.whl

mn_cli/libs/sys_cmds.py

@@ -0,0 +1,52 @@
+import typer
+import subprocess
+import os
+import time
+from mn_cli.shared import console
+from mn_cli.error_handler import handle_cli_error
+from mn_cli.server_cmds import _start_server, kill_tree, BEAM_PID_FILE, API_PID_FILE, WEB_UI_PID_FILE
+
+def start():
+    """Start MirrorNeuron services"""
+    _start_server()
+
+def stop():
+    """Stop MirrorNeuron services"""
+    console.print("=> Stopping MirrorNeuron Services...")
+    
+    console.print("   Stopping Core Service (Docker: mirror-neuron-core)...")
+    subprocess.run(["docker", "stop", "mirror-neuron-core"], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+    subprocess.run(["docker", "rm", "mirror-neuron-core"], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+
+    for pid_file, name in [
+        (WEB_UI_PID_FILE, "Web UI"),
+        (API_PID_FILE, "REST API"),
+        (BEAM_PID_FILE, "Legacy Core Service"),
+    ]:
+        if pid_file.exists():
+            try:
+                pid = int(pid_file.read_text().strip())
+                try:
+                    os.kill(pid, 0)
+                    console.print(f"   Stopping {name} (PID: {pid})...")
+                    kill_tree(pid)
+                    time.sleep(1)
+                except OSError:
+                    pass
+            except ValueError:
+                pass
+            pid_file.unlink()
+    console.print("=> [green]All services stopped.[/green]")
+
+def join(ip: str):
+    """Join a MirrorNeuron cluster using the IP"""
+    _start_server(ip)
+
+def leave(node_name: str):
+    """Remove a node from the cluster by its node name (e.g. mirror_neuron@192.168.4.173)"""
+    from mn_cli.shared import client, console
+    try:
+        status = client.remove_node(node_name)
+        console.print(f"[green]Successfully requested {node_name} to leave. Status: {status}[/green]")
+    except Exception as e:
+        handle_cli_error(e, console, 'leave')

mn_cli/libs/ui.py

@@ -0,0 +1,162 @@
+from rich.console import Group
+from rich.table import Table
+from rich.panel import Panel
+from rich.text import Text
+from typing import Dict, Any, Optional
+
+def generate_live_layout(job_id: str, data: Dict[str, Any]) -> Group:
+    summary = data.get("summary", {})
+    job = data.get("job", {})
+    agents = data.get("agents", [])
+    
+    status = summary.get("status", "unknown")
+    color = "cyan"
+    if status == "completed":
+        color = "green"
+    elif status in ["failed", "cancelled"]:
+        color = "red"
+        
+    last_event = summary.get("last_event", "N/A")
+    
+    # Top panel: Job info (Executors removed)
+    spinner_str = "[cyan]⠋[/cyan]"
+    try:
+        import time
+        frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+        idx = int(time.time() * 12.5) % len(frames)
+        spinner_str = f"[cyan]{frames[idx]}[/cyan]"
+    except:
+        pass
+
+    info_text = (
+        f"[bold]Job ID:[/bold] {job_id}\n"
+        f"[bold]Name:[/bold] {job.get('job_name', 'N/A')} | [bold]Graph:[/bold] {job.get('graph_id', 'N/A')}\n"
+        f"[bold]Status:[/bold] [{color}]{status}[/{color}] | [bold]Live:[/bold] {summary.get('live?', False)}\n"
+        f"[bold]Nodes:[/bold] {len(summary.get('nodes', []))}\n"
+        f"[bold]Last Event:[/bold] {last_event} {spinner_str if status not in ['completed', 'failed', 'cancelled'] else ''}\n\n"
+        f"[dim]Press 'q' or Ctrl-C to exit[/dim]"
+    )
+    info_panel = Panel(info_text, title="Live Job Monitor", border_style=color)
+    
+    # Agents Table
+    agent_table = Table(title="Agents (Top 20 by Processed Messages)", expand=True)
+    agent_table.add_column("Agent ID")
+    agent_table.add_column("Type")
+    agent_table.add_column("Status")
+    agent_table.add_column("Processed", justify="right")
+    agent_table.add_column("Mailbox", justify="right")
+    
+    sorted_agents = sorted(agents, key=lambda x: x.get("processed_messages", 0), reverse=True)[:20]
+    
+    for ag in sorted_agents:
+        ag_status = ag.get("status", "unknown")
+        st_color = "green" if ag_status in ["running", "completed"] else "yellow" if ag_status in ["ready", "busy", "queued"] else "red"
+        
+        agent_table.add_row(
+            ag.get("agent_id", "N/A"),
+            ag.get("agent_type", "N/A"),
+            f"[{st_color}]{ag_status}[/{st_color}]",
+            str(ag.get("processed_messages", 0)),
+            str(ag.get("mailbox_depth", 0))
+        )
+        
+    return Group(info_panel, agent_table)
+
+def generate_summary_panel(job_id: str, status: str, log_dir) -> Panel:
+    status_text = "Unknown"
+    status_color = "yellow"
+    if status == "completed":
+        status_text = "Success"
+        status_color = "green"
+    elif status == "failed":
+        status_text = "Failed"
+        status_color = "red"
+    elif status == "cancelled":
+        status_text = "Cancelled"
+        status_color = "red"
+        
+    log_file = log_dir / "events.log"
+    
+    panel_text = (
+        f"[bold {status_color}]Job Status: {status_text}[/bold {status_color}]\n\n"
+        f"Job ID: {job_id}\n"
+        f"Outputs:\n"
+        f"  Logs:   {log_file}"
+    )
+    if (log_dir / "result.txt").exists():
+        panel_text += f"\n  Result: {log_dir / 'result.txt'}"
+    if (log_dir / "result_stream.txt").exists():
+        panel_text += f"\n  Stream: {log_dir / 'result_stream.txt'}"
+        
+    return Panel(
+        panel_text,
+        title="Job Execution Summary",
+        border_style=status_color,
+        expand=False
+    )
+
+def generate_run_submitted_panel(
+    *,
+    bundle_name: str,
+    job_id: str,
+    payload_count: int,
+    log_dir,
+    follow_seconds: float,
+    run_mode: str = "Batch",
+    blueprint_run_id: Optional[str] = None,
+    blueprint_revision: Optional[str] = None,
+) -> Panel:
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+    table.add_row("Bundle", bundle_name)
+    table.add_row("Job ID", f"[bold cyan]{job_id}[/bold cyan]")
+    if blueprint_run_id:
+        table.add_row("Blueprint Run ID", f"[bold green]{blueprint_run_id}[/bold green]")
+    if blueprint_revision:
+        table.add_row("Blueprint Revision", blueprint_revision[:12])
+    table.add_row("Type", run_mode)
+    table.add_row("Payloads", str(payload_count))
+    table.add_row("Logs", str(log_dir / "events.log"))
+    table.add_row("Snapshot", str(log_dir / "job_snapshot.json"))
+    table.add_row("Follow", f"{follow_seconds:g}s event tail, then detach")
+
+    return Panel(
+        table,
+        title="Job submitted successfully",
+        border_style="cyan",
+        expand=False,
+    )
+
+def generate_detached_panel(job_id: str, log_dir, status: str, event_count: int) -> Panel:
+    status_color = (
+        "green"
+        if status == "completed"
+        else "red"
+        if status in {"failed", "cancelled"}
+        else "yellow"
+    )
+    status_label = status.replace("_", " ").title() if status else "Unknown"
+
+    table = Table.grid(padding=(0, 1))
+    table.add_column(style="bold")
+    table.add_column()
+    table.add_row("Status", f"[{status_color}]{status_label}[/{status_color}]")
+    table.add_row("Job ID", f"[bold cyan]{job_id}[/bold cyan]")
+    table.add_row("Events Logged", str(event_count))
+    table.add_row("Raw Events", str(log_dir / "events.log"))
+    table.add_row("Run Log", str(log_dir / "run.log"))
+    table.add_row("Monitor", f"mn monitor {job_id}")
+
+    message = Text()
+    if status in {"completed", "failed", "cancelled"}:
+        message.append("Final job state reached.", style=status_color)
+    else:
+        message.append("Detached while job is still scheduled/running.", style="yellow")
+
+    return Panel(
+        Group(message, table),
+        title="Run Detached",
+        border_style=status_color,
+        expand=False,
+    )

mn_cli/logging_config.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import logging
+import os
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+
+def configure_logging(
+    name: str,
+    log_path: Path,
+    *,
+    level: str | None = None,
+) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.setLevel((level or os.getenv("MN_LOG_LEVEL", "INFO")).upper())
+    logger.propagate = False
+
+    if logger.handlers:
+        return logger
+
+    formatter = logging.Formatter(
+        "%(asctime)s %(levelname)s [%(name)s] %(message)s"
+    )
+
+    try:
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+        handler: logging.Handler = RotatingFileHandler(
+            log_path,
+            maxBytes=int(os.getenv("MN_LOG_MAX_BYTES", "1048576")),
+            backupCount=int(os.getenv("MN_LOG_BACKUP_COUNT", "5")),
+        )
+    except OSError:
+        handler = logging.StreamHandler()
+
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    return logger

mn_cli/main.py

@@ -0,0 +1,35 @@
+import typer
+from mn_cli.libs import job_cmds, run_cmds, sys_cmds
+from mn_cli.libs.blueprint_cmds import blueprint_app
+
+app = typer.Typer(help="MirrorNeuron CLI")
+
+# Run commands
+app.command(name="validate")(run_cmds.validate)
+app.command(name="run")(run_cmds.run)
+app.command(name="monitor")(run_cmds.monitor)
+app.command(name="result")(run_cmds.result)
+
+# Job commands
+app.command(name="submit")(job_cmds.submit)
+app.command(name="status")(job_cmds.status)
+app.command(name="list")(job_cmds.list_jobs)
+app.command(name="clear")(job_cmds.clear)
+app.command(name="cancel")(job_cmds.cancel)
+app.command(name="pause")(job_cmds.pause)
+app.command(name="resume")(job_cmds.resume)
+app.command(name="nodes")(job_cmds.nodes)
+app.command(name="metrics")(job_cmds.metrics)
+app.command(name="dead-letters")(job_cmds.dead_letters)
+
+# System commands
+app.command(name="start")(sys_cmds.start)
+app.command(name="stop")(sys_cmds.stop)
+app.command(name="join")(sys_cmds.join)
+app.command(name="leave")(sys_cmds.leave)
+
+# Sub-apps
+app.add_typer(blueprint_app, name="blueprint")
+
+if __name__ == "__main__":
+    app()

mn_cli/server_cmds.py

@@ -0,0 +1,331 @@
+import os
+import signal
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+from urllib.parse import urlparse
+import typer
+from rich.console import Console
+from rich.table import Table
+from mn_cli.config import CliConfig
+from mn_cli.logging_config import configure_logging
+
+console = Console()
+logger = configure_logging("mn-cli", CliConfig.from_env().log_path)
+
+DIR = Path.home() / ".mirror_neuron"
+PID_DIR = DIR / ".pids"
+LOG_DIR = DIR / ".logs"
+BEAM_PID_FILE = PID_DIR / "beam.pid"
+API_PID_FILE = PID_DIR / "api.pid"
+WEB_UI_PID_FILE = PID_DIR / "web-ui.pid"
+BEAM_LOG = LOG_DIR / "beam.log"
+API_LOG = LOG_DIR / "api.log"
+WEB_UI_LOG = LOG_DIR / "web-ui.log"
+VENV_DIR = Path.home() / ".local" / "share" / "mn_venv"
+WEB_UI_DIRS = (
+    DIR / "web-ui-source",
+    Path(f"{DIR}_ui"),
+)
+WEB_UI_PORT = "5173"
+DEFAULT_HOST = "localhost"
+
+def _env_host(name: str, default: str = DEFAULT_HOST) -> str:
+    return os.getenv(name, default).strip() or default
+
+def _core_host() -> str:
+    return _env_host("MN_CORE_HOST")
+
+def _api_host() -> str:
+    return _env_host("MN_API_HOST")
+
+def _redis_host() -> str:
+    return _env_host("MN_REDIS_HOST")
+
+def _epmd_host() -> str:
+    return _env_host("MN_EPMD_HOST")
+
+def _dist_host() -> str:
+    return _env_host("MN_DIST_HOST")
+
+def _web_ui_host() -> str:
+    return _env_host("MN_WEB_UI_HOST")
+
+def _docker_publish_host(host: str) -> str:
+    return "127.0.0.1" if host == "localhost" else host
+
+def check_status(pid_file: Path) -> int:
+    if pid_file.exists():
+        try:
+            pid = int(pid_file.read_text().strip())
+            os.kill(pid, 0)
+            return 0 # Running
+        except (ValueError, OSError):
+            return 1 # Stale
+    return 2 # Not running
+
+def kill_tree(parent_pid: int):
+    try:
+        os.kill(parent_pid, 0)
+    except OSError:
+        logger.debug("Process %s is not running", parent_pid)
+        return
+    
+    try:
+        children = subprocess.check_output(['pgrep', '-P', str(parent_pid)], stderr=subprocess.DEVNULL)
+        for child_pid in children.decode().split():
+            if child_pid.strip():
+                kill_tree(int(child_pid.strip()))
+    except subprocess.CalledProcessError:
+        pass
+    
+    try:
+        logger.info("Stopping process %s", parent_pid)
+        os.kill(parent_pid, signal.SIGTERM)
+    except OSError:
+        logger.exception("Failed to stop process %s", parent_pid)
+        pass
+
+def find_web_ui_dir() -> Optional[Path]:
+    for web_ui_dir in WEB_UI_DIRS:
+        if (web_ui_dir / "package.json").exists() and (web_ui_dir / "node_modules").exists():
+            return web_ui_dir
+    return None
+
+def _host_port_from_target(target: str, default_host: str, default_port: str) -> tuple[str, str]:
+    if "://" in target:
+        parsed = urlparse(target)
+        return parsed.hostname or default_host, str(parsed.port or default_port)
+
+    if target.startswith("[") and "]:" in target:
+        host, port = target.rsplit("]:", 1)
+        return host.lstrip("["), port
+
+    if ":" in target:
+        host, port = target.rsplit(":", 1)
+        return host or default_host, port or default_port
+
+    return target or default_host, default_port
+
+def _redis_host_port(ip: Optional[str]) -> tuple[str, str]:
+    default_host = ip or _redis_host()
+    default_url = f"redis://{default_host}:6379/0"
+    return _host_port_from_target(
+        os.getenv("MN_REDIS_URL", default_url),
+        default_host,
+        "6379",
+    )
+
+def _print_service_endpoints(ip: Optional[str], web_ui_available: bool):
+    core_host = _core_host()
+    grpc_host, grpc_port = _host_port_from_target(
+        os.getenv(
+            "MN_GRPC_TARGET",
+            os.getenv("MN_CORE_GRPC_TARGET", f"{core_host}:50051"),
+        ),
+        core_host,
+        os.getenv("MN_GRPC_PORT", "50051"),
+    )
+    api_host = _api_host()
+    api_port = os.getenv("MN_API_PORT", "4001")
+    redis_host, redis_port = _redis_host_port(ip)
+    epmd_host = _epmd_host()
+    dist_host = _dist_host()
+    dist_port = os.getenv("MN_DIST_PORT", "9000-9010" if os.uname().sysname == "Darwin" else "dynamic")
+    web_ui_host = _web_ui_host()
+
+    table = Table(title="Service endpoints", show_header=True, header_style="bold")
+    table.add_column("Service")
+    table.add_column("Host")
+    table.add_column("Port")
+    table.add_column("URL / target")
+
+    table.add_row("Core gRPC", grpc_host, grpc_port, f"{grpc_host}:{grpc_port}")
+    table.add_row("REST API", api_host, api_port, f"http://{api_host}:{api_port}/api/v1")
+    table.add_row("Redis", redis_host, redis_port, f"redis://{redis_host}:{redis_port}/0")
+    table.add_row("Erlang EPMD", epmd_host, "4369", f"{epmd_host}:4369")
+    table.add_row("Erlang dist", dist_host, dist_port, f"{dist_host}:{dist_port}")
+    if web_ui_available:
+        table.add_row("Web UI", web_ui_host, WEB_UI_PORT, f"http://{web_ui_host}:{WEB_UI_PORT}")
+
+    console.print(table)
+
+def _start_web_ui_if_installed() -> bool:
+    web_ui_dir = find_web_ui_dir()
+    if not web_ui_dir:
+        return False
+
+    status = check_status(WEB_UI_PID_FILE)
+    if status == 0:
+        console.print("[yellow]=> Web UI is already running, skipping.[/yellow]")
+        return True
+    if status == 1:
+        WEB_UI_PID_FILE.unlink(missing_ok=True)
+
+    web_ui_host = _web_ui_host()
+    env = os.environ.copy()
+    env.setdefault("MN_WEB_UI_HOST", web_ui_host)
+    env.setdefault("MN_API_HOST", _api_host())
+    env.setdefault("MN_API_PORT", os.getenv("MN_API_PORT", "4001"))
+    console.print(f"=> Starting mn-web-ui (Vite on {web_ui_host}:5173)...")
+    with open(WEB_UI_LOG, "w") as out:
+        p_web = subprocess.Popen(
+            ["npm", "run", "dev", "--", "--host", web_ui_host],
+            cwd=web_ui_dir,
+            stdout=out,
+            stderr=subprocess.STDOUT,
+            env=env,
+            start_new_session=True
+        )
+    WEB_UI_PID_FILE.write_text(str(p_web.pid))
+    console.print(f"   [green][Started][/green] Web UI (PID: {p_web.pid})")
+    return True
+
+def _start_server(ip: str = None):
+    if check_status(API_PID_FILE) == 0:
+        console.print("[red]Error: MirrorNeuron API is already running.[/red]")
+        console.print("Use 'mn stop' to stop it first.")
+        raise typer.Exit(1)
+        
+    try:
+        docker_status = subprocess.run(["docker", "inspect", "-f", "{{.State.Running}}", "mirror-neuron-core"], capture_output=True, text=True)
+        if docker_status.stdout.strip() == "true":
+            console.print("[red]Error: MirrorNeuron Core (Docker) is already running.[/red]")
+            console.print("Use 'mn stop' to stop it first.")
+            raise typer.Exit(1)
+    except FileNotFoundError:
+        console.print("[red]Error: Docker is not installed or not in PATH.[/red]")
+        raise typer.Exit(1)
+
+    PID_DIR.mkdir(parents=True, exist_ok=True)
+    LOG_DIR.mkdir(parents=True, exist_ok=True)
+
+    console.print("===========================================")
+    if ip:
+        console.print(f"Joining Cluster at {ip} in Detached Mode...")
+    else:
+        console.print("Starting Services in Detached Mode...")
+    console.print("===========================================")
+
+    env = os.environ.copy()
+    env.setdefault("MN_CORE_HOST", _core_host())
+    env.setdefault("MN_API_HOST", _api_host())
+    env.setdefault("MN_REDIS_HOST", _redis_host())
+    env.setdefault("MN_EPMD_HOST", _epmd_host())
+    env.setdefault("MN_DIST_HOST", _dist_host())
+    env.setdefault("MN_WEB_UI_HOST", _web_ui_host())
+    env.setdefault("MN_CORE_GRPC_TARGET", f"{env['MN_CORE_HOST']}:{os.getenv('MN_GRPC_PORT', '50051')}")
+    if ip:
+        env["MN_CLUSTER_NODES"] = ip
+
+    console.print("=> Starting MirrorNeuron Core Service (Docker)...")
+    logger.info("Starting MirrorNeuron Core Docker container")
+    subprocess.run(["docker", "rm", "-f", "mirror-neuron-core"], stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)
+    
+    cmd = ["docker", "run", "-d", "--name", "mirror-neuron-core"]
+    
+    # We want clustering to work, so we need to set the node name.
+    import socket
+    try:
+        local_ip = socket.gethostbyname(socket.gethostname())
+    except socket.gaierror:
+        local_ip = "127.0.0.1"
+    # As a fallback or override, you could prompt the user, but we'll try to guess it.
+    # To be safe for this specific test, we know local is 192.168.4.25 and remote is 192.168.4.173.
+    # Let's see if we can get the actual external IP:
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        # doesn't even have to be reachable
+        s.connect(('10.255.255.255', 1))
+        local_ip = s.getsockname()[0]
+    except Exception:
+        local_ip = '127.0.0.1'
+    finally:
+        s.close()
+        
+    cmd.extend(["-e", f"MN_NODE_NAME=mirror_neuron@{local_ip}"])
+    
+    core_publish_host = _docker_publish_host(env["MN_CORE_HOST"])
+    epmd_publish_host = _docker_publish_host(env["MN_EPMD_HOST"])
+    dist_publish_host = _docker_publish_host(env["MN_DIST_HOST"])
+
+    system_name = os.uname().sysname
+
+    if system_name == "Darwin":
+        cmd.extend(["-p", f"{core_publish_host}:50051:50051", "-p", f"{epmd_publish_host}:4369:4369"])
+        # Publish the distribution ports too
+        for port in range(9000, 9011):
+            cmd.extend(["-p", f"{dist_publish_host}:{port}:{port}"])
+        cmd.extend(["-e", "MN_REDIS_URL=redis://host.docker.internal:6379/0"])
+        cmd.extend(["-e", "MN_EXECUTOR_MAX_CONCURRENCY=50"])
+    else:
+        cmd.extend(["--network", "host"])
+        cmd.extend(["-e", "MN_EXECUTOR_MAX_CONCURRENCY=50"])
+
+    if system_name == "Darwin":
+        cmd.extend(["-e", "MN_CORE_HOST=0.0.0.0"])
+    else:
+        cmd.extend(["-e", f"MN_CORE_HOST={env['MN_CORE_HOST']}"])
+        cmd.extend(["-e", f"MN_REDIS_HOST={env['MN_REDIS_HOST']}"])
+        cmd.extend(["-e", f"ERL_EPMD_ADDRESS={env['MN_EPMD_HOST']}"])
+
+    if ip:
+        cmd.extend(["-e", f"MN_CLUSTER_NODES=mirror_neuron@{ip}"])
+        # A node joining another should also point its redis to the main cluster leader if not specified
+        cmd.extend(["-e", f"MN_REDIS_URL=redis://{ip}:6379/0"])
+
+    for env_name in [
+        "SLACK_BOT_TOKEN",
+        "SLACK_DEFAULT_CHANNEL",
+        "SLACK_API_BASE_URL",
+        "MN_SLACK_BOT_TOKEN",
+        "MN_SLACK_DEFAULT_CHANNEL",
+        "MN_SLACK_API_BASE_URL",
+    ]:
+        if os.getenv(env_name):
+            cmd.extend(["-e", env_name])
+    
+    cmd.append("mirror-neuron-core:latest")
+    
+    try:
+        subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL)
+        console.print("   [green][Started][/green] Core Service (Docker: mirror-neuron-core)")
+    except subprocess.CalledProcessError:
+        console.print("[red]Failed to start Core Service Docker container.[/red]")
+        raise typer.Exit(1)
+
+    console.print("=> Waiting for Elixir to boot...")
+    time.sleep(3)
+
+    api_bin = VENV_DIR / "bin" / "mn-api"
+    if api_bin.exists():
+        console.print("=> Starting mn-api (REST on port 4001)...")
+        with open(API_LOG, "w") as out:
+            p_api = subprocess.Popen(
+                [str(api_bin)],
+                stdout=out,
+                stderr=subprocess.STDOUT,
+                env=env,
+                start_new_session=True
+            )
+        API_PID_FILE.write_text(str(p_api.pid))
+        console.print(f"   [green][Started][/green] REST API (PID: {p_api.pid})")
+    else:
+        console.print("[yellow]=> Warning: mn-api not found, skipping.[/yellow]")
+
+    web_ui_available = _start_web_ui_if_installed()
+
+    console.print("\n===========================================")
+    if ip:
+        console.print(f"MirrorNeuron is running and attempting to join cluster at {ip}!")
+    else:
+        console.print("MirrorNeuron is running in the background!")
+    _print_service_endpoints(ip, web_ui_available)
+    console.print("Logs are available at:")
+    console.print(f"  Core: {BEAM_LOG}")
+    console.print(f"  API:  {API_LOG}")
+    if WEB_UI_LOG.exists():
+        console.print(f"  Web:  {WEB_UI_LOG}")
+    console.print("\nRun 'mn stop' to shut down the services.")
+    console.print("===========================================")

mn_cli/shared.py

@@ -0,0 +1,13 @@
+from mn_sdk import Client
+from rich.console import Console
+from mn_cli.config import CliConfig
+from mn_cli.logging_config import configure_logging
+
+config = CliConfig.from_env()
+logger = configure_logging("mn-cli", config.log_path)
+console = Console(no_color=config.output_mode == "plain")
+client = Client(
+    target=config.grpc_target,
+    timeout=config.grpc_timeout_seconds,
+    auth_token=config.grpc_auth_token,
+)